Crypto/src/ROT13.java

@@ -1,32 +0,0 @@
-import static java.lang.Character.isLowerCase;
-import static java.lang.Character.isUpperCase;
-import static java.lang.Character.toLowerCase;
-
-public class ROT13  {
-
-    ROT13(Character cs, Character cf) {
-    }
-
-    ROT13() {
-    }
-
-
-    public String crypt(String text) throws UnsupportedOperationException {
-
-        return "";
-    }
-
-    public String encrypt(String text) {
-        return text;
-    }
-
-    public String decrypt(String text) {
-        return text;
-    }
-
-    public static String rotate(String s, Character c) {
-
-        return "";
-    }
-
-}

Crypto/src/main/java/Caesar.java

@@ -0,0 +1,20 @@
+public class Caesar extends ROT13 {
+
+
+    public Caesar() {
+
+    }
+
+    public Caesar(int shift) {
+        this.shift = shift;
+        this.shiftedUpper = rotateByNumber(alphaUpper, shift);
+        this.shiftedLower = rotateByNumber(alphaLower, shift);
+
+    }
+
+    public static String rotateByNumber (String input, int number) {
+
+        return input.substring(number) + input.substring(0, number);
+    }
+
+}

Crypto/src/main/java/LaurensCipher.java

@@ -0,0 +1,79 @@
+import java.util.ArrayList;
+
+public class LaurensCipher {
+
+    String alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    Integer[] code = new Integer[26];
+    int magicNumber = 2;
+
+    public LaurensCipher(int numb) {
+        this.magicNumber = numb;
+        this.code = createCipher(this.magicNumber);
+    }
+
+    public Integer[] getCode() {
+        return code;
+    }
+
+    public int getMagicNumber() {
+        return magicNumber;
+    }
+
+    public Integer[] createCipher(int magicNumber) {
+
+        Integer[] cipher = new Integer[26];
+
+        for (int i = 0; i < 26; i++) {
+          cipher[i] = ((alpha.charAt(i) + magicNumber) * magicNumber);
+
+        }
+
+        return cipher;
+    }
+
+    public Character getLetter(int codeNumber) {
+
+        int letterNumber = codeNumber / magicNumber - magicNumber;
+
+        int index = letterNumber - 65;
+
+        return alpha.charAt(index);
+
+    }
+
+    public String encrypt(String text) {
+        String result = "";
+        text = text.toUpperCase().replace(" ", "");
+        for (Character c: text.toCharArray()) {
+            if(Character.isLetter(c)) {
+                for (int i = 0; i < alpha.length(); i++) {
+                    if(c.equals(alpha.charAt(i))) {
+                        result += code[i] + " ";
+                    }
+                }
+            } else {
+                result += c + " ";
+            }
+
+        }
+
+        return (result.charAt(0) + result.substring(1).toLowerCase()).trim();
+
+    }
+
+    public String decrypt(String text) {
+        String result = "";
+        String[] str = text.split(" ");
+        ArrayList<Integer> numbers = new ArrayList<Integer>();
+        for(String s: str) {
+
+                numbers.add(Integer.parseInt(s));
+
+        }
+        for(Integer i: numbers) {
+            result += getLetter(i);
+        }
+        return result;
+    }
+
+}

Crypto/src/main/java/ROT13.java

@@ -0,0 +1,143 @@
+import java.io.*;
+import java.util.*;
+import java.util.stream.Stream;
+
+import static java.lang.Character.isLowerCase;
+import static java.lang.Character.isUpperCase;
+import static java.lang.Character.toLowerCase;
+
+public class ROT13  {
+
+    Character original;
+    Character adjusted;
+    int shift = 13;
+    String alphaUpper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    String shiftedUpper = "NOPQRSTUVWXYZABCDEFGHIJKLM";
+    String alphaLower = "abcdefghijklmnopqrstuvwxyz";
+    String shiftedLower = "nopqrstuvwxyzabcdefghijklm";
+
+    ROT13(Character cs, Character cf) {
+        this.original = cs;
+        this.adjusted = cf;
+        this.shift = cf - cs;
+        this.shiftedUpper = rotate(alphaUpper, Character.toUpperCase(cf));
+        this.shiftedLower = rotate(alphaLower, Character.toLowerCase(cf));
+
+    }
+
+    ROT13() {
+
+    }
+
+    public String getShiftedUpper() {
+        return shiftedUpper;
+    }
+
+    public String getShiftedLower() {
+        return shiftedLower;
+    }
+
+    public String crypt(String text) throws UnsupportedOperationException {
+
+        return text;
+    }
+
+    public String encrypt(String text) {
+        String result = "";
+        for (Character c: text.toCharArray()) {
+            if(Character.isLetter(c)) {
+                String alphabet = alphaLower;
+                String shifted = this.shiftedLower;
+                if(Character.isUpperCase(c)) {
+                    alphabet = alphaUpper;
+                    shifted = this.shiftedUpper;
+                }
+                for (int i = 0; i < alphabet.length(); i++) {
+                    if(c.equals(alphabet.charAt(i))) {
+                        result += shifted.charAt(i);
+                    }
+                }
+
+            } else {
+                result += c;
+            }
+
+        }
+
+        return result;
+    }
+
+    public String decrypt(String text) {
+        String result = "";
+
+        for (Character c: text.toCharArray()) {
+            if(Character.isLetter(c)) {
+                String alphabet = alphaLower;
+                String shifted = this.shiftedLower;
+                if(Character.isUpperCase(c)) {
+                    alphabet = alphaUpper;
+                    shifted = this.shiftedUpper;
+                }
+                for (int i = 0; i < alphabet.length(); i++) {
+                    if(c.equals(alphabet.charAt(i))) {
+                        result += shifted.charAt(i);
+                    }
+                }
+
+            } else {
+                result += c;
+            }
+
+        }
+
+        return result;
+    }
+
+    public static String rotate(String s, Character c) {
+
+        int index = 0;
+        for (int i = 0; i < s.length(); i++) {
+            if(s.charAt(i) == c){
+                index = i;
+            }
+        }
+        return s.substring(index) + s.substring(0, index);
+    }
+
+    public void fileEncrypter(String fileName, String newFileName) throws FileNotFoundException {
+
+        String fileString = fileToString(fileName);
+        String newFileString = encrypt(fileString);
+        System.out.println(newFileString);
+
+        try {
+            File file = new File(newFileName);
+            FileWriter fileWriter = new FileWriter(file);
+            fileWriter.write(newFileString);
+            fileWriter.flush();
+            fileWriter.close();
+        } catch (IOException e) {
+            System.out.println("Error writing file");
+        }
+
+    }
+
+    public String fileToString(String fileName) throws FileNotFoundException {
+        File file = new File(fileName);
+        BufferedReader reader = new BufferedReader(new FileReader(file));
+        StringBuilder stringBuilder = new StringBuilder();
+        String line = null;
+
+        try {
+            while((line = reader.readLine()) != null) {
+                stringBuilder.append(line + "\n");
+            }
+
+        } catch (Exception e) {
+            System.out.println("Error Reading File");
+        }
+
+        return stringBuilder.toString();
+    }
+
+}

Crypto/src/test/java/CaesarTest.java

@@ -0,0 +1,102 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class CaesarTest {
+
+    @Test
+    public void rotateStringTest0() {
+        // Given
+        String s1 = "ABCDEF";
+        String s2 = "ABCDEF";
+
+        // When
+        Caesar cipher = new Caesar();
+        String actual = cipher.rotateByNumber(s1, 0);
+
+        // Then
+        assertTrue(actual.equals(s2));
+    }
+
+    @Test
+    public void rotateStringTest1() {
+        // Given
+        String s1 = "ABCDEF";
+        String s2 = "DEFABC";
+
+        // When
+        Caesar cipher = new Caesar();
+        String actual = cipher.rotateByNumber(s1, 3);
+
+        // Then
+        assertTrue(actual.equals(s2));
+    }
+
+    @Test
+    public void rotateStringTest2() {
+        // Given
+        String s1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        String s2 = "NOPQRSTUVWXYZABCDEFGHIJKLM";
+
+        // When
+        Caesar cipher = new Caesar();
+        String actual = cipher.rotateByNumber(s1, 13);
+        System.out.println(s1);
+        System.out.println(actual);
+        // Then
+        assertTrue(actual.equals(s2));
+    }
+
+    @Test
+    public void cryptTest1() {
+        // Given
+        Caesar cipher = new Caesar(13);
+
+        String Q1 = "Why did the chicken cross the road?";
+        String A1 = "Jul qvq gur puvpxra pebff gur ebnq?";
+
+        String Q2 = "Gb trg gb gur bgure fvqr!";
+        String A2 = "To get to the other side!";
+
+        // When
+        String actual = cipher.encrypt(Q1);
+        System.out.println(Q1);
+        System.out.println(A1);
+        // Then
+        Assert.assertEquals(A1, actual);
+
+        // When
+        String actual2 = cipher.decrypt(Q2);
+        System.out.println(Q2);
+        System.out.println(A2);
+        // Then
+        Assert.assertEquals(A2, actual2);
+    }
+
+    @Test
+    public void cryptTest2() {
+        // Given
+        Caesar cipher = new Caesar(4);
+
+        String Q1 = "This is a test of Caesar.";
+        String A1 = "Xlmw mw e xiwx sj geiwev.";
+
+        String Q2 = "Ynulpo wna bqj!";
+        String A2 = "Crypts are fun!";
+
+        // When
+        String actual = cipher.encrypt(Q1);
+        System.out.println(Q1);
+        System.out.println(A1);
+        // Then
+        Assert.assertEquals(A1, actual);
+
+        // When
+        String actual2 = cipher.decrypt(Q2);
+        System.out.println(Q2);
+        System.out.println(A2);
+        // Then
+        Assert.assertEquals(A2, actual2);
+    }
+}

Crypto/src/test/java/LaurensCipherTest.java

@@ -0,0 +1,83 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+import static org.junit.Assert.assertTrue;
+
+public class LaurensCipherTest {
+
+    @Test
+    public void createCodeTest() {
+        // Given
+        LaurensCipher cipher = new LaurensCipher(4);
+        Integer[] expected = new Integer[26];
+        for (int i = 0; i < 26; i++) {
+            expected[i] = (('A' + i - 0) + 4) * 4;
+        }
+
+        // When
+        Integer[] actual = cipher.getCode();
+
+        // Then
+        Assert.assertArrayEquals(expected, actual);
+    }
+
+    @Test
+    public void getLetterTest() {
+        // Given
+        LaurensCipher cipher = new LaurensCipher(4);
+        Character expected = 'D';
+
+        // When
+        Character actual = cipher.getLetter(288);
+
+        // Then
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void encryptTest() {
+        // Given
+        LaurensCipher cipher = new LaurensCipher(6);
+        System.out.println(cipher.getCode());
+        String text = "This is my secret code";
+        String expected = "540 468 474 534 474 534 498 570 534 450 438 528 450 540 438 510 444 450";
+
+        // When
+        String actual = cipher.encrypt(text);
+
+        // Then
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void encryptTest2() {
+        // Given
+        LaurensCipher cipher = new LaurensCipher(10);
+        String text = "The top secret code";
+        String expected = "940 820 790 940 890 900 930 790 770 920 790 940 770 890 780 790";
+
+        // When
+        String actual = cipher.encrypt(text);
+
+        // Then
+        Assert.assertEquals(expected, actual);
+    }
+
+
+    @Test
+    public void decryptTest2() {
+        // Given
+        LaurensCipher cipher = new LaurensCipher(10);
+        String text = "Mischief Managed";
+        String code = cipher.encrypt(text);
+        String expected = "MISCHIEFMANAGED";
+
+        // When
+        String actual = cipher.decrypt(code);
+
+        // Then
+        Assert.assertEquals(expected, actual);
+
+    }
+
+}

Crypto/src/ROT13Test.java → Crypto/src/test/java/ROT13Test.java

@@ -1,10 +1,15 @@
+import org.junit.Assert;
 import org.junit.Test;
 
+import java.io.BufferedReader;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+
 import static org.junit.Assert.*;
 
 public class ROT13Test {
 
-
     @Test
     public void rotateStringTest0() {
         // Given
@@ -64,14 +69,14 @@ public class ROT13Test {
         System.out.println(Q1);
         System.out.println(A1);
         // Then
-        assertTrue(actual.equals(A1));
+        Assert.assertEquals(A1, actual);
 
         // When
         String actual2 = cipher.decrypt(Q2);
         System.out.println(Q2);
         System.out.println(A2);
         // Then
-        assertTrue(actual2.equals(A2));
+        Assert.assertEquals(A2, actual2);
     }
     @Test
     public void cryptTest2() {
@@ -88,4 +93,28 @@ public class ROT13Test {
         assertTrue(actual.equals(Q1));
     }
 
+    @Test
+    public void fileReaderTest() throws IOException {
+        // Given
+        ROT13 cipher = new ROT13('a', 'n');
+        String filePath = "sonnet18.txt";
+        String newFilePath = "sonnet18Encrypt.txt";
+
+        // When
+        cipher.fileEncrypter(filePath, newFilePath);
+        BufferedReader bROriginal = new BufferedReader(new FileReader(filePath));
+        BufferedReader bRnewFile = new BufferedReader(new FileReader(newFilePath));
+
+        String lineOriginal;
+        String lineNew;
+
+        // Then
+        while ((lineOriginal = bROriginal.readLine()) != null) {
+            lineNew = cipher.decrypt(bRnewFile.readLine());
+            Assert.assertEquals(lineOriginal, lineNew);
+        }
+
+    }
+
+
 }

SimpleCrypt.iml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module org.jetbrains.idea.maven.project.MavenProjectsManager.isMavenModule="true" type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" LANGUAGE_LEVEL="JDK_1_5">
+    <output url="file://$MODULE_DIR$/target/classes" />
+    <output-test url="file://$MODULE_DIR$/target/test-classes" />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/Crypto/src/main/java" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/Crypto/src/test/java" isTestSource="true" />
+      <excludeFolder url="file://$MODULE_DIR$/target" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" name="Maven: junit:junit:4.12" level="project" />
+    <orderEntry type="library" name="Maven: org.hamcrest:hamcrest-core:1.3" level="project" />
+  </component>
+</module>

pom.xml

@@ -8,5 +8,13 @@
     <artifactId>SimpleCrypt</artifactId>
     <version>1.0-SNAPSHOT</version>
 
+    <dependencies>
 
+
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>RELEASE</version>
+        </dependency>
+    </dependencies>
 </project>

sonnet18Encrypt.txt

@@ -0,0 +1,14 @@
+Funyy V pbzcner gurr gb n fhzzre’f qnl?
+Gubh neg zber ybiryl naq zber grzcrengr:
+Ebhtu jvaqf qb funxr gur qneyvat ohqf bs Znl,
+Naq fhzzre’f yrnfr ungu nyy gbb fubeg n qngr;
+Fbzrgvzr gbb ubg gur rlr bs urnira fuvarf,
+Naq bsgra vf uvf tbyq pbzcyrkvba qvzz'q;
+Naq rirel snve sebz snve fbzrgvzr qrpyvarf,
+Ol punapr be angher’f punatvat pbhefr hagevzz'q;
+Ohg gul rgreany fhzzre funyy abg snqr,
+Abe ybfr cbffrffvba bs gung snve gubh bj’fg;
+Abe funyy qrngu oent gubh jnaqre’fg va uvf funqr,
+Jura va rgreany yvarf gb gvzr gubh tebj’fg:
+   Fb ybat nf zra pna oerngur be rlrf pna frr,
+   Fb ybat yvirf guvf, naq guvf tvirf yvsr gb gurr.