Caesar Cipher

src/main/java/CaeserCipher.java

@@ -0,0 +1,46 @@
+public class CaeserCipher extends ROT13 {
+    // takes in a shift and then returns an encoded string of the letter shift
+
+    public CaeserCipher(int shift) {
+        super.setShift(shift);
+    }
+
+
+    public String encrypt(String s) {
+        StringBuilder sb = new StringBuilder();
+
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+
+            if (c >= 'a' && c <= 'z') {
+                sb.append((char) ((c - 'a' + getShift()) % 26 + 'a'));
+
+            } else if (c >= 'A'  && c <= 'Z') {
+                sb.append((char)((c - 'A' + getShift()) % 26 + 'A'));
+
+            } else {
+                sb.append(c);
+            }
+        }
+        return sb.toString();
+    }
+
+    public String decrypt(String s) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+
+            if (c >= 'a' && c <= 'z') {
+                sb.append((char) ((c + 'a' - getShift()) % 26 + 'a'));
+
+            } else if (c >= 'A'  && c <= 'Z') {
+                sb.append((char)((c + 'A' - getShift()) % 26 + 'A'));
+
+            } else {
+                sb.append(c);
+            }
+        }
+        return sb.toString();
+
+    }
+}

src/main/java/ROT13.java

@@ -3,45 +3,49 @@ import static java.lang.Character.isUpperCase;
 import static java.lang.Character.toLowerCase;
 
 public class ROT13  {
-
-    private int rotation;
+    private int shift;
 
     ROT13(Character cs, Character cf) {
-        rotation = cf - cs;
+        shift = cf - cs;
         // With this constructor, we are finding how much to rotate by
         // UP TO CF, not including
     }
 
     ROT13() {
+        shift = 13;
+    }
+
+    public int getShift() {
+        return shift;
     }
 
-    public int getRotation() {
-        return rotation;
+    public void setShift(int shift) {
+        this.shift = shift;
     }
 
     public String crypt(String text) throws UnsupportedOperationException {
-        String s = "";
-        // only 26 letters in the alphabet, with the 13 rotation, the crpt and encrypt are equal
+        StringBuilder sb = new StringBuilder();
+        // only 26 letters in the alphabet, with the 13 shift, the crpt and encrypt are equal
         for (int i = 0; i < text.length(); i++) {
             char c = text.charAt(i);
             if (c >= 'a' && c <= 'm') {
-                c += rotation;
-                s += c;
+                c += shift;
+                sb.append(c);
             } else if (c >= 'A' && c <= 'M') {
-                c += rotation;
-                s += c;
+                c += shift;
+                sb.append(c);
             } else if (c >= 'n' && c <= 'z') {
-                c -= rotation;
-                s += c;
+                c -= shift;
+                sb.append(c);
             } else if (c >= 'N' && c <= 'Z') {
-                c -= rotation;
-                s += c;
+                c -= shift;
+                sb.append(c);
             } else {
-                s += c;
+                sb.append(c);
             }
         }
         // we are rotating each letter, not shifting
-        return s;
+        return sb.toString();
     }
 
     public String encrypt(String text) {
@@ -63,9 +67,9 @@ public class ROT13  {
             }
         }
 
-        int shift = index % s.length();
+        int rotation = index % s.length();
 
-        return s.substring(shift) + s.substring(0, index);
+        return s.substring(rotation) + s.substring(0, index);
     }
 
 }

src/test/java/CaeserCipherTest.java

@@ -0,0 +1,36 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class CaeserCipherTest {
+
+    @Test
+    public void testCaesar() {
+        CaeserCipher cc = new CaeserCipher(23);
+
+
+        String text = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        String expected = "XYZABCDEFGHIJKLMNOPQRSTUVW";
+
+        String actual = cc.encrypt(text);
+        System.out.println(actual);
+        Assert.assertEquals(expected, actual);
+
+    }
+
+    @Test
+    public void testDecrypt() {
+        CaeserCipher cc = new CaeserCipher(23);
+
+        String text = "XYZABCDEFGHIJKLMNOPQRSTUVW";
+        String exp = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+        String actual = cc.decrypt(text);
+
+        Assert.assertEquals(exp, actual);
+
+
+
+    }
+}

src/test/java/ROT13Test.java

@@ -1,3 +1,4 @@
+import org.junit.Assert;
 import org.junit.Test;
 
 import static org.junit.Assert.*;
@@ -92,6 +93,7 @@ public class ROT13Test {
     @Test
     public void testRotation() {
         ROT13 cipher = new ROT13('a', 'n');
-        System.out.println(cipher.getRotation());
+        System.out.println(cipher.getShift());
     }
+
 }