made empty

Crypto/Crypto.iml

+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" name="Arquillian JUnit:Release" level="project" />
+    <orderEntry type="module-library">
+      <library name="JUnit4">
+        <CLASSES>
+          <root url="jar://$APPLICATION_HOME_DIR$/lib/junit-4.12.jar!/" />
+          <root url="jar://$APPLICATION_HOME_DIR$/lib/hamcrest-core-1.3.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+  </component>
+</module>

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/ROT13Test.java

+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class ROT13Test {
+
+
+    @Test
+    public void rotateStringTest0() {
+        // Given
+        String s1 = "ABCDEF";
+        String s2 = "ABCDEF";
+
+        // When
+        ROT13 cipher = new ROT13();
+        String actual = cipher.rotate(s1, 'A');
+
+        // Then
+        assertTrue(actual.equals(s2));
+    }
+
+    @Test
+    public void rotateStringTest1() {
+        // Given
+        String s1 = "ABCDEF";
+        String s2 = "DEFABC";
+
+        // When
+        ROT13 cipher = new ROT13();
+        String actual = cipher.rotate(s1, 'D');
+
+        // Then
+        assertTrue(actual.equals(s2));
+    }
+
+    @Test
+    public void rotateStringTest2() {
+        // Given
+        String s1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        String s2 = "NOPQRSTUVWXYZABCDEFGHIJKLM";
+
+        // When
+        ROT13 cipher = new ROT13();
+        String actual = cipher.rotate(s1, 'N');
+        System.out.println(s1);
+        System.out.println(actual);
+        // Then
+        assertTrue(actual.equals(s2));
+    }
+
+    @Test
+    public void cryptTest1() {
+        // Given
+        ROT13 cipher = new ROT13('a', 'n');
+
+        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
+        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
+        ROT13 cipher = new ROT13('a', 'n');
+
+        String Q1 = "Why did the chicken cross the road?";
+        System.out.println(Q1);
+
+        // When
+        String actual = cipher.crypt(cipher.crypt(Q1));
+        System.out.println(actual);
+        // Then
+        assertTrue(actual.equals(Q1));
+    }
+
+}

README.md

 Applying ROT13 to a piece of text merely requires examining its alphabetic characters and replacing each one by the letter 13 places further along in the alphabet, wrapping back to the beginning if necessary.[3] A becomes N, B becomes O, and so on up to M, which becomes Z, then the sequence continues at the beginning of the alphabet: N becomes A, O becomes B, and so on to Z, which becomes M. Only those letters which occur in the English alphabet are affected; numbers, symbols, whitespace, and all other characters are left unchanged.
 
 ```Java
-String s = "we hold these truths to be self evident"
+String s = "we hold these truths to be self evident";
+
+//WHEN you create a ROT13 with 'a' and 'n' THEN 
 
 if (crypt(crypt(s)) == s) {
   return true;
 }
+
+//if anything else, you must use the encrypt/decrypt pair.
 ```
 In other words, two successive applications of ROT13 restore the original text (in mathematics, this is sometimes called an involution; in cryptography, a reciprocal cipher).
 
 The transformation can be done using a lookup table, such as the following:
 
 ```
-// for ROT13('a', 'm')
+// for ROT13('a', 'n')
 Input	ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz
 Output	NOPQRSTUVWXYZABCDEFGHIJKLM nopqrstuvwxyzabcdefghijklm
 
 // for ROT13('a', 'd')
 Input	ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz
-Output	EFGHIJKLMNOPQRSTUVWXYZABCD efghijklmnopqrstuvwxyzabcd
+Output	DEFGHIJKLMNOPQRSTUVWXYZABC defghijklmnopqrstuvwxyzabc
 ```
 For example, in the following joke, the punchline has been obscured by ROT13: