finished ROT13. Need to fix my own cipher

Crypto/src/NewCipher.java

@@ -0,0 +1,71 @@
+public class NewCipher {
+    String text;
+    String encryptedText;
+    String alphabets;
+    int key;
+
+    public NewCipher(String text, int key) {
+        this.text = text;
+        this.key = key;
+        alphabets = "abcdefghijklmnopqrstuvwxyz";
+    }
+
+    public String encrypt(){
+
+        String encrypted = "";
+//        for (int i = 0; i < text.length(); i++) {
+//            char ch = text.charAt(i);
+//            if (Character.isLetter(ch)) {
+//                if(ch+key >='a' && ch+key <= 'z') {
+//                    ch = (char)(ch + key);
+//                }
+//                else
+//                {
+//                   int index = alphabets.indexOf(ch);
+//                   for()
+//
+//                }
+//            }
+//
+//            encrypted += ch;
+//        }
+
+        for(int i = 0; i<text.length(); i++){
+            char ch = text.charAt(i);
+            if(Character.isLetter(ch)){
+                if(ch+key >='a' && ch+key <= 'z') {
+                    ch = (char)(ch + key);
+                }
+                else {
+                    int pos = alphabets.indexOf(ch);
+                    int times = 0;
+                    int j;
+                    for(j = pos; times <key; j++) {
+                        if(j==alphabets.length()){
+                            j= 0;
+                        }
+                        times++;
+                    }
+                    ch = alphabets.charAt(j);
+                }
+            }
+            encrypted += ch;
+        }
+        System.out.println("encrypted text is " + encrypted);
+        return encrypted;
+    }
+
+    public String decrypt(){
+        String decrypted = "";
+        for (int i = 0; i < text.length(); i++) {
+            char ch = text.charAt(i);
+            if (Character.isLetter(ch)) {
+                ch = (char)(((ch - 'a') - key) % 26 + 'a');
+            }
+
+            decrypted += ch;
+        }
+        System.out.println("decrypted text is " + decrypted);
+        return decrypted;
+    }
+}

Crypto/src/NewCipherTest.java

@@ -0,0 +1,27 @@
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class NewCipherTest {
+    NewCipher cipher;
+
+    @Before
+    public void setup(){
+        cipher = new NewCipher("abc jkl wxyz", 2);
+    }
+
+    @Test
+    public void testEncrypt(){
+        String expected = "cde lmn yzab";
+        String actual = cipher.encrypt();
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testDecrypt(){
+        String expected = cipher.text;
+        cipher.encrypt();
+        String actual = cipher.decrypt();
+        Assert.assertEquals(expected, actual);
+    }
+}

Crypto/src/ROT13.java

@@ -1,32 +1,157 @@
+import java.io.*;
+
 import static java.lang.Character.isLowerCase;
 import static java.lang.Character.isUpperCase;
 import static java.lang.Character.toLowerCase;
 
 public class ROT13  {
 
+    int shift;
     ROT13(Character cs, Character cf) {
+        shift = cf - cs;
     }
 
     ROT13() {
     }
 
-
     public String crypt(String text) throws UnsupportedOperationException {
-
-        return "";
+        StringBuilder sb = new StringBuilder();
+        for(int i=0;i<text.length();i++){
+            if((text.charAt(i) >= 'a' && text.charAt(i) <= 'm') || (text.charAt(i) >= 'A' && text.charAt(i) <= 'M')){
+                sb.append((char)(text.charAt(i) + 13));
+            }
+            else if((text.charAt(i) >= 'n' && text.charAt(i) <= 'z') || (text.charAt(i) >= 'N' && text.charAt(i) <= 'Z')){
+                sb.append((char)(text.charAt(i) - 13));
+            }
+            else
+                sb.append(text.charAt(i));
+        }
+        return sb.toString();
     }
 
     public String encrypt(String text) {
-        return text;
+        String encrypted = "";
+        //Individual characters of a String are numbered from 0 until n-1 where n is the
+        //length of the string
+        //So what we want to repeat is "get the i character of the String, encrypt it, and build
+        //it onto the String named encrypted" We want to do that for each value of i
+        //To actually encrypt, we need to worry about "wraparound" issues around z
+        for (int i = 0; i < text.length(); i++) {
+            //Check if it is a letter. If it isn't, then we don't have to do anything anyway
+            if( (text.charAt(i) >= 'A' && text.charAt(i) <= 'Z') ||
+                    (text.charAt(i) >= 'a' && text.charAt(i) <= 'z'))
+            {
+                //Check if there was "wraparound" For example z + 3 should give us c
+                //In this case, the way to get this result is by subtracting 23 instead of adding 3
+                if (((char)(text.charAt(i) + shift)  > 'Z' &&
+                        text.charAt(i) <= 'Z')
+                        || ((char)(text.charAt(i) + shift)  > 'z'
+                        && text.charAt(i) <= 'z'))
+
+                {
+                    //add the next character which is encrypted to the String
+                    encrypted = encrypted + (char)(text.charAt(i) + shift - 26);
+                }
+                else
+                {
+                    //add the next character which is encrypted to the String
+                    encrypted = encrypted + (char)(text.charAt(i) + shift);
+                }
+            }
+            else
+            {
+                //add the original character to the Stringx
+                encrypted = encrypted + text.charAt(i);
+            }
+        }
+
+        //return the resulting String
+        return encrypted;
     }
 
     public String decrypt(String text) {
-        return text;
+        String decrypted = "";
+        for (int i = 0; i < text.length(); i++) {
+            if( (text.charAt(i) >= 'A' && text.charAt(i) <= 'Z') ||
+                    (text.charAt(i) >= 'a' && text.charAt(i) <= 'z'))
+            {
+                if (((char)(text.charAt(i) - shift)  < 'A' &&
+                        text.charAt(i) >= 'A')
+                        || ((char)(text.charAt(i) - shift)  < 'a'
+                        && text.charAt(i) >= 'a'))
+
+                {
+                    decrypted = decrypted + (char)(text.charAt(i) - shift + 26);
+                }
+                else {
+                    decrypted = decrypted + (char)(text.charAt(i) - shift);
+                }
+            }
+            else
+            {
+                decrypted = decrypted + text.charAt(i);
+            }
+        }
+        return decrypted;
     }
 
     public static String rotate(String s, Character c) {
+       int shift = c - s.charAt(0);
+       return s.substring(shift) + s.substring(0,shift);
+    }
+
+    public String readFile(String fileName){
 
-        return "";
+        StringBuilder sb = new StringBuilder();
+        // This will reference one line at a time
+        String line = null;
+
+        try {
+            // FileReader reads text files in the default encoding.
+            FileReader fileReader =
+                    new FileReader(fileName);
+
+            // Always wrap FileReader in BufferedReader.
+            BufferedReader bufferedReader =
+                    new BufferedReader(fileReader);
+
+            while((line = bufferedReader.readLine()) != null) {
+                sb.append(line + "\n");
+            }
+
+            // Always close files.
+            bufferedReader.close();
+        }
+        catch(FileNotFoundException ex) {
+            System.out.println(
+                    "Unable to open file '" +
+                            fileName + "'");
+        }
+        catch(IOException ex) {
+            System.out.println(
+                    "Error reading file '"
+                            + fileName + "'");
+            // Or we could just do this:
+            // ex.printStackTrace();
+        }
+        return sb.toString();
     }
 
+    public void encryptFile(String fileName, String newFileName){
+        String text = readFile(fileName);
+        String encryptedText = encrypt(text);
+        writeToFile(newFileName, encryptedText);
+    }
+
+    private void writeToFile(String newFileName, String encryptedText) {
+        try {
+            FileWriter fileWriter = new FileWriter(newFileName);
+            BufferedWriter br = new BufferedWriter(fileWriter);
+            br.write(encryptedText);
+            br.flush();
+            br.close();
+        }catch (IOException ie){
+            ie.printStackTrace();
+        }
+    }
 }

Crypto/src/ROT13Test.java

@@ -1,6 +1,9 @@
+
+import org.junit.Assert;
 import org.junit.Test;
 
-import static org.junit.Assert.*;
+import java.io.*;
+
 
 public class ROT13Test {
 
@@ -16,7 +19,7 @@ public class ROT13Test {
         String actual = cipher.rotate(s1, 'A');
 
         // Then
-        assertTrue(actual.equals(s2));
+        Assert.assertTrue(actual.equals(s2));
     }
 
     @Test
@@ -30,7 +33,7 @@ public class ROT13Test {
         String actual = cipher.rotate(s1, 'D');
 
         // Then
-        assertTrue(actual.equals(s2));
+        Assert.assertTrue(actual.equals(s2));
     }
 
     @Test
@@ -45,7 +48,7 @@ public class ROT13Test {
         System.out.println(s1);
         System.out.println(actual);
         // Then
-        assertTrue(actual.equals(s2));
+        Assert.assertTrue(actual.equals(s2));
     }
 
     @Test
@@ -64,14 +67,14 @@ public class ROT13Test {
         System.out.println(Q1);
         System.out.println(A1);
         // Then
-        assertTrue(actual.equals(A1));
+        Assert.assertTrue(actual.equals(A1));
 
         // When
         String actual2 = cipher.decrypt(Q2);
         System.out.println(Q2);
         System.out.println(A2);
         // Then
-        assertTrue(actual2.equals(A2));
+        Assert.assertTrue(actual2.equals(A2));
     }
     @Test
     public void cryptTest2() {
@@ -85,7 +88,27 @@ public class ROT13Test {
         String actual = cipher.crypt(cipher.crypt(Q1));
         System.out.println(actual);
         // Then
-        assertTrue(actual.equals(Q1));
+        Assert.assertTrue(actual.equals(Q1));
+    }
+
+    @Test
+    public void testFileEncryption() throws IOException {
+        ROT13 cipher = new ROT13('a', 'n');
+        String fileName = "sonnet18.txt";
+        String encryptedFile = "encryptedFile.txt";
+        String line;
+        String newFileText ="";
+
+        cipher.encryptFile(fileName, encryptedFile);
+        String encryptedText = cipher.encrypt(cipher.readFile(fileName));
+
+        FileReader fr = new FileReader(encryptedFile);
+        BufferedReader br = new BufferedReader(fr);
+        while((line = br.readLine())!= null){
+            newFileText += line + "\n";
+        }
+
+        Assert.assertEquals(encryptedText, newFileText);
     }
 
 }

SimpleCrypt.iml

@@ -0,0 +1,15 @@
+<?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_8">
+    <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" isTestSource="false" />
+      <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>

encryptedFile.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.

pom.xml

@@ -8,5 +8,31 @@
     <artifactId>SimpleCrypt</artifactId>
     <version>1.0-SNAPSHOT</version>
 
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>8</source>
+                    <target>8</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+        </dependency>
+
+    </dependencies>
 
 </project>