Merge branch 'simple-cipher'

config.json

@@ -30,6 +30,7 @@
     "trinary",
     "rna-transcription",
     "sieve",
+    "simple-cipher",
     "pascals-triangle"	
   ],
   "deprecated": [

simple-cipher/build.gradle

@@ -0,0 +1,11 @@
+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  testCompile "junit:junit:4.10"
+}

simple-cipher/example.java

@@ -0,0 +1,73 @@
+import java.util.Random;
+import java.util.stream.IntStream;
+
+public class Cipher {
+
+    private static final String ALPHABET = "abcdefghijklmnopqrstuvwxyz";
+    private static final Random random = new Random();
+
+    public String key;
+
+    public Cipher() {
+        this.key = IntStream.range(0, 100)
+                .map(x -> ALPHABET.toCharArray()[random.nextInt(ALPHABET.length())])
+                .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
+                .toString();
+    }
+
+    public Cipher(String key) {
+        if (!isValidKey(key)) {
+            throw new IllegalArgumentException("Invalid key");
+        }
+
+        this.key = key;
+    }
+
+    private static boolean isValidKey(String key) {
+        return key.matches("^[a-z]+$");
+    }
+
+    public String getKey() {
+        return key;
+    }
+
+    public String encode(String plainText) {
+        StringBuilder ciphertext = new StringBuilder(plainText.length());
+
+        for (int index = 0; index < Math.min(plainText.length(), key.length()); index++) {
+            ciphertext.append(encodeCharacter(plainText, index));
+        }
+
+        return ciphertext.toString();
+    }
+
+    private char encodeCharacter(String plainText, int index) {
+        int alphabetIdx = ALPHABET.indexOf(plainText.toCharArray()[index]) + ALPHABET.indexOf(key.toCharArray()[index]);
+
+        if (alphabetIdx >= ALPHABET.length()) {
+            alphabetIdx -= ALPHABET.length();
+        }
+
+        return ALPHABET.toCharArray()[alphabetIdx];
+    }
+
+    public String decode(String cipherText) {
+        StringBuilder plainText = new StringBuilder(cipherText.length());
+
+        for (int i = 0; i < cipherText.length(); i++) {
+            plainText.append(decodeCharacter(cipherText, i));
+        }
+
+        return plainText.toString();
+    }
+
+    private char decodeCharacter(String cipherText, int index) {
+        int alphabetIdx = ALPHABET.indexOf(cipherText.toCharArray()[index]) - ALPHABET.indexOf(key.toCharArray()[index]);
+
+        if (alphabetIdx < 0) {
+            alphabetIdx += ALPHABET.length();
+        }
+
+        return ALPHABET.toCharArray()[alphabetIdx];
+    }
+}

simple-cipher/src/main/java/Cipher.java

@@ -0,0 +1,2 @@
+public class Cipher {
+}

simple-cipher/src/test/java/IncorrectKeyCipherTest.java

@@ -0,0 +1,29 @@
+import org.junit.Test;
+
+public class IncorrectKeyCipherTest {
+
+    @Test(expected = IllegalArgumentException.class)
+    public void cipherThrowsWithAllCapsKey() {
+        new Cipher("ABCDEF");
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void cipherThrowsWithAnyCapsKey() {
+        new Cipher("abcdEFg");
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void cipherThrowsWithNumericKey() {
+        new Cipher("12345");
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void cipherThrowsWithAnyNumericKey() {
+        new Cipher("abcd345ef");
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void cipherThrowsWithEmptyKey() {
+        new Cipher("");
+    }
+}

simple-cipher/src/test/java/RandomKeyCipherTest.java

@@ -0,0 +1,55 @@
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class RandomKeyCipherTest {
+
+    private Cipher cipher;
+
+    @Before
+    public void setup() {
+        this.cipher = new Cipher();
+    }
+
+    @Test
+    public void cipherKeyIsMadeOfLetters() {
+        assertTrue(cipher.getKey().matches("[a-z]+"));
+    }
+
+    @Test
+    public void defaultCipherKeyIs100Characters() {
+        assertEquals(100, cipher.getKey().length());
+    }
+
+    @Test
+    public void cipherKeysAreRandomlyGenerated() {
+        assertTrue(!(new Cipher().getKey().equals(cipher.getKey().length())));
+    }
+
+    /**
+     * Here we take advantage of the fact that plaintext of "aaa..." doesn't output the key. This is a critical problem
+     * with shift ciphers, some characters will always output the key verbatim.
+     */
+    @Test
+    public void cipherCanEncode() {
+        String expectedOutput = cipher.getKey().substring(0, 10);
+
+        assertEquals(expectedOutput, cipher.encode("aaaaaaaaaa"));
+    }
+
+    @Test
+    public void cipherCanDecode() {
+        String expectedOutput = "aaaaaaaaaa";
+
+        assertEquals(expectedOutput, cipher.decode(cipher.getKey().substring(0, 10)));
+    }
+
+    @Test
+    public void cipherIsReversible() {
+        String plainText = "abcdefghij";
+
+        assertEquals(plainText, cipher.decode(cipher.encode(plainText)));
+    }
+}

simple-cipher/src/test/java/SimpleCipherTest.java

@@ -0,0 +1,11 @@
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+        RandomKeyCipherTest.class,
+        IncorrectKeyCipherTest.class,
+        SubstitutionCipherTest.class
+})
+public class SimpleCipherTest {
+}

simple-cipher/src/test/java/SubstitutionCipherTest.java

@@ -0,0 +1,70 @@
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class SubstitutionCipherTest {
+
+    private static final String KEY = "abcdefghij";
+    private Cipher cipher;
+
+    @Before
+    public void setup() {
+        this.cipher = new Cipher(KEY);
+    }
+
+    @Test
+    public void cipherKeepsTheSubmittedKey() {
+        assertEquals(KEY, cipher.getKey());
+    }
+
+    @Test
+    public void cipherCanEncodeWithGivenKey() {
+        String expectedOutput = "abcdefghij";
+
+        assertEquals(expectedOutput, cipher.encode("aaaaaaaaaa"));
+    }
+
+    @Test
+    public void cipherCanDecodeWithGivenKey() {
+        String expectedOutput = "aaaaaaaaaa";
+
+        assertEquals(expectedOutput, cipher.decode("abcdefghij"));
+    }
+
+    @Test
+    public void cipherIsReversibleGivenKey() {
+        String plainText = "abcdefghij";
+
+        assertEquals(plainText, cipher.decode(cipher.encode("abcdefghij")));
+    }
+
+    @Test
+    public void cipherCanDoubleShiftEncode() {
+        String plainText = "iamapandabear";
+        String expectedOutput = "qayaeaagaciai";
+
+        assertEquals(expectedOutput, new Cipher(plainText).encode(plainText));
+    }
+
+    @Test
+    public void cipherCanWrapEncode() {
+        String expectedOutput = "zabcdefghi";
+
+        assertEquals(expectedOutput, cipher.encode("zzzzzzzzzz"));
+    }
+
+    @Test
+    public void cipherCanEncodeMessageThatIsShorterThanTheKey() {
+        String expectedOutput = "abcde";
+
+        assertEquals(expectedOutput, cipher.encode("aaaaa"));
+    }
+
+    @Test
+    public void cipherCanDecodeMessageThatIsShorterThanTheKey() {
+        String expectedOutput = "aaaaa";
+
+        assertEquals(expectedOutput, cipher.decode("abcde"));
+    }
+}