Crypto/src/Main/Caesar.java

+public class Caesar extends ROT13 {
+    public Caesar(Character cs, Character cf) {
+        super(cs, cf);
+    }
+
+    public Caesar() {
+        
+    }
+}

Crypto/src/Main/FileCrypter.java

+import java.io.File;
+import java.lang.*;
+import java.util.*;
+
+public class FileCrypter extends ROT13 {
+
+    private Formatter formatter;
+    private Scanner scanner;
+    private String fileToString;
+    private String fileIn;
+    private String fileOut;
+    private String encryptedString;
+
+    FileCrypter(){
+        fileIn = "Sonnet18.txt";
+        fileOut = "Sonnet18.enc";
+    }
+
+    public String getFileIn() {
+        return fileIn;
+    }
+
+    public void setFileIn(String fileIn) {
+        this.fileIn = fileIn;
+    }
+
+    public String getFileOut() {
+        return fileOut;
+    }
+
+    public void setFileOut(String fileOut) {
+        this.fileOut = fileOut;
+    }
+
+    /**
+     * Methods to read in from an existing file
+     */
+    public void connectToFile(){
+        try {
+            scanner = new Scanner(new File(fileIn));
+        }
+        catch (Exception e){
+            System.out.println("File not found.");
+        }
+    }
+
+    public String readFile(){
+        StringBuilder builder = new StringBuilder();
+        while (scanner.hasNextLine()){
+            builder.append(scanner.nextLine() + "\n");
+        }
+        fileToString = builder.toString();
+        return builder.toString();
+    }
+
+    /**
+     * Methods to print out to a new file
+     */
+    public void openFile(){
+        try {
+            formatter = new Formatter(fileOut);
+        }
+        catch (Exception e){
+            System.out.println("Error writing to file.");
+        }
+    }
+
+    public String addRecords(String encryptedStr){
+        formatter.format("%s", encryptedStr);
+        return encryptedStr;
+    }
+
+    public void closeFile(){
+        formatter.close();
+        scanner.close();
+    }
+
+    public void encryptFile(){
+        ROT13 rot13 = new ROT13('a', 'n');
+        connectToFile();
+        encryptedString = rot13.encrypt(readFile());
+
+        /**
+         * Create/ overwrite and output to file
+         */
+        openFile();
+        addRecords(encryptedString);
+        closeFile();
+    }
+
+
+
+    public static void main(String[] args) {
+        FileCrypter fileCrypter = new FileCrypter();
+        ROT13 rot13 = new ROT13('a', 'n');
+
+        fileCrypter.connectToFile();
+        fileCrypter.encryptedString = rot13.encrypt(fileCrypter.readFile());
+
+        /**
+         * Create/ overwrite and output to file
+         */
+        fileCrypter.openFile();
+        fileCrypter.addRecords(fileCrypter.encryptedString);
+        fileCrypter.closeFile();
+
+
+    }
+
+}

Crypto/src/Main/ROT13.java

+import java.util.Arrays;
+import java.util.List;
+
+public class ROT13  {
+    private int rotate;
+    private int encryptShift = 26;
+    private boolean encrypt;
+
+    public boolean isEncrypt() {
+        return encrypt;
+    }
+
+    public void setEncrypt(boolean encrypt) {
+        this.encrypt = encrypt;
+    }
+
+    ROT13(Character cs, Character cf) {
+        rotate = (int)(cs) - (int)(cf);
+    }
+
+    ROT13() {
+    }
+
+    public int getRotate() {
+        return rotate;
+    }
+
+    public String crypt(String text){
+        return encrypt(text);
+    }
+
+    public String crypt(String text, int rotate) throws UnsupportedOperationException {
+        List<String> textList = Arrays.asList(text.split(" "));
+        StringBuilder builder = new StringBuilder();
+
+        for (String s: textList) {
+            char[] charArr = s.toCharArray();
+            for (char c: charArr) {
+                String strToAppend = isEncrypt() ? shiftCharEncrypt(c, rotate) : shiftCharDecrypt(c, rotate);
+                builder.append(strToAppend);
+            }
+            builder.append(" ");
+        }
+        return builder.toString().trim();
+    }
+
+    public String encrypt(String text) {
+        setEncrypt(true);
+        return crypt(text, getRotate());
+    }
+
+    public String decrypt(String text) {
+        setEncrypt(false);
+        return crypt(text, getRotate() * -1);
+    }
+
+    public String shiftCharEncrypt(char c, int rotate){
+        if (c > 64 && c != 8217){
+            return  ( (c > 96 && (c + rotate) > 96) || (c <= 96 && (c + rotate) > 64) ) ?
+                    ( Character.toString( (char)(c + rotate) ) ) :
+                    ( Character.toString( (char)(c + rotate + encryptShift) ) );
+        } else {
+            return Character.toString(c);
+        }
+    }
+
+    public String shiftCharDecrypt(char c, int rotate){
+        if (c > 64){
+            return  ( (c + rotate > 122) || (c <= 90  && c + rotate > 90 ) ) ?
+                    ( Character.toString( (char)(c + rotate + encryptShift * -1) ) ) :
+                    ( Character.toString( (char)(c + rotate) ) );
+        } else {
+            return Character.toString(c);
+        }
+    }
+
+    public static String rotate(String s, Character c) {
+        int rotateBy = (int)(c) - (int)(s.charAt(0));
+        char[] charArr = s.toCharArray();
+        char[] returnChar = new char[charArr.length];
+
+        int x = 0;
+        for (int i = rotateBy; i < returnChar.length; i++) {
+            returnChar[x] = (char)( (int)(charArr[i]));
+            x++;
+        }
+
+        for (int i = 0; i < rotateBy; i++) {
+            returnChar[x] = (char)( (int)(charArr[i]));
+            x++;
+        }
+        return String.copyValueOf(returnChar);
+    }
+
+}

Crypto/src/ROT13.java

-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/Test/CaesarTest.java

+import org.junit.Test;
+import static org.junit.Assert.*;
+import static org.junit.Assert.assertTrue;
+
+public class CaesarTest {
+
+    @Test
+    public void rotateStringTest0() {
+        // Given
+        String s1 = "ABCDEF";
+        String s2 = "BCDEFA";
+
+        // When
+        Caesar cipher = new Caesar();
+        String actual = cipher.rotate(s1, 'B');
+        System.out.println(actual);
+        // Then
+        assertTrue(actual.equals(s2));
+    }
+
+    @Test
+    public void rotateStringTest1() {
+        // Given
+        String s1 = "ABCDEF";
+        String s2 = "DEFABC";
+
+        // When
+        Caesar cipher = new Caesar();
+        String actual = cipher.rotate(s1, 'D');
+
+        // Then
+        assertTrue(actual.equals(s2));
+    }
+
+    @Test
+    public void rotateStringTest2() {
+        // Given
+        String s1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        String s2 = "NOPQRSTUVWXYZABCDEFGHIJKLM";
+
+        // When
+        Caesar cipher = new Caesar();
+        String actual = cipher.rotate(s1, 'N');
+        System.out.println(s1);
+        System.out.println(actual);
+        // Then
+        assertTrue(actual.equals(s2));
+    }
+
+    @Test
+    public void cryptTest1() {
+        // Given
+        Caesar cipher = new Caesar('a', 'b');
+
+        String Q1 = "Caesar Salad!";  //"Why did the chicken cross the road?";
+        String A1 = "Bzdrzq Rzkzc!"; //"Jul qvq gur puvpxra pebff gur ebnq?";
+
+        String Q2 = "With Chicken"; //"Gb trg gb gur bgure fvqr!";
+        String A2 = "Xjui Dijdlfo"; //"To get to the other side!";
+
+        // When
+        String actual = cipher.encrypt(Q1);
+        System.out.println(Q1);
+        System.out.println(A1);
+        // Then
+        assertTrue(actual.equals(A1));
+
+        // When
+        String actual2 = cipher.decrypt(Q2);
+        System.out.println(Q2);
+        System.out.println(A2);
+        // Then
+        assertTrue(actual2.equals(A2));
+    }
+    @Test
+    public void cryptTest2() {
+        // Given
+        Caesar cipher = new Caesar('b', 'o');
+
+        String Q1 = "Eat more Chicken?";
+        System.out.println(Q1);
+
+        // When
+        String actual = cipher.crypt(cipher.crypt(Q1));
+        System.out.println(actual);
+        // Then
+        assertTrue(actual.equals(Q1));
+    }
+
+}
+

Crypto/src/ROT13Test.java → Crypto/src/Test/ROT13Test.java

         // When
         ROT13 cipher = new ROT13();
         String actual = cipher.rotate(s1, 'A');
-
+        System.out.println(actual);
         // Then
         assertTrue(actual.equals(s2));
     }

Crypto/src/Test/fileCrypterTest.java

+import org.junit.Test;
+
+import static org.junit.Assert.assertTrue;
+
+public class fileCrypterTest {
+
+    @Test
+    public void cryptTest1() {
+        // Given
+        FileCrypter fileCrypter = new FileCrypter();
+        fileCrypter.setFileIn("Sonnet18.txt");
+
+        fileCrypter.connectToFile();
+        String expected = fileCrypter.readFile();
+
+        // When
+        fileCrypter.encryptFile();
+        fileCrypter.setFileIn("Sonnet18.enc");
+        fileCrypter.encryptFile();
+        fileCrypter.connectToFile();
+        String actual = fileCrypter.readFile();
+
+        // Then
+        assertTrue(actual.equals(expected));
+
+    }
+}

SimpleCrypt.iml

+<?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" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/Crypto/src/Test" isTestSource="true" />
+      <excludeFolder url="file://$MODULE_DIR$/target" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" scope="TEST" name="Maven: junit:junit:4.12" level="project" />
+    <orderEntry type="library" scope="TEST" name="Maven: org.hamcrest:hamcrest-core:1.3" level="project" />
+  </component>
+</module>

pom.xml

     <groupId>com.zipcodewilmington</groupId>
     <artifactId>SimpleCrypt</artifactId>
     <version>1.0-SNAPSHOT</version>
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>RELEASE</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
 
 
 </project>

sonnet18.txt

 Nor shall death brag thou wander’st in his shade,
 When in eternal lines to time thou grow’st:
    So long as men can breathe or eyes can see,
-   So long lives this, and this gives life to thee.
+   So long lives this, and this gives life to thee.