Fixed merge conflicts

config.json

@@ -54,7 +54,8 @@
     "custom-set",
     "wordy",
     "palindrome-products",
-	"twelve-days"
+	"twelve-days",
+    "sublist"
   ],
   "exercises": [
     {
@@ -311,7 +312,12 @@
 	  "slug": "twelve-days",
 	  "difficulty": 1,
 	  "topics": []
-	}
+	},
+    {
+      "slug": "sublist",
+      "difficulty": 1,
+      "topics": []
+    }
   ],
   "deprecated": [
     "binary",

exercises/etl/src/test/java/EtlTest.java

@@ -24,7 +24,7 @@ public class EtlTest {
         };
         expected = Collections.unmodifiableMap(expected);
 
-        assertEquals(etl.transform(old), expected);
+        assertEquals(expected, etl.transform(old));
     }
 
     @Test
@@ -47,7 +47,7 @@ public class EtlTest {
         };
         expected = Collections.unmodifiableMap(expected);
 
-        assertEquals(etl.transform(old), expected);
+        assertEquals(expected, etl.transform(old));
     }
 
     @Test
@@ -70,7 +70,7 @@ public class EtlTest {
         };
         expected = Collections.unmodifiableMap(expected);
 
-        assertEquals(etl.transform(old), expected);
+        assertEquals(expected, etl.transform(old));
     }
 
     @Test
@@ -120,6 +120,6 @@ public class EtlTest {
         };
         expected = Collections.unmodifiableMap(expected);
 
-        assertEquals(etl.transform(old), expected);
+        assertEquals(expected, etl.transform(old));
     }
 }

exercises/settings.gradle

@@ -44,6 +44,7 @@ include 'series'
 include 'sieve'
 include 'simple-cipher'
 include 'simple-linked-list'
+include 'sublist'
 include 'sum-of-multiples'
 include 'space-age'
 include 'strain'

exercises/simple-cipher/HINT.md

@@ -0,0 +1,6 @@
+This exercise has three test classes: SimpleCipherStepOneTest.java, SimpleCipherStepTwoTest.java and SimpleCipherStepThreeTest.java.
+
+To run only one test class (e.g. in this example SimpleCipherStepOneTest.java):
+```
+$ gradle test --tests *StepOne*
+```

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

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

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

@@ -1,62 +0,0 @@
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.Ignore;
-
-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]+"));
-    }
-
-    @Ignore
-    @Test
-    public void defaultCipherKeyIs100Characters() {
-        assertEquals(100, cipher.getKey().length());
-    }
-
-    @Ignore
-    @Test
-    public void cipherKeysAreRandomlyGenerated() {
-        assertTrue(!(new Cipher().getKey().equals(cipher.getKey())));
-    }
-
-    /**
-     * 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.
-     */
-    @Ignore
-    @Test
-    public void cipherCanEncode() {
-        String expectedOutput = cipher.getKey().substring(0, 10);
-
-        assertEquals(expectedOutput, cipher.encode("aaaaaaaaaa"));
-    }
-
-    @Ignore
-    @Test
-    public void cipherCanDecode() {
-        String expectedOutput = "aaaaaaaaaa";
-
-        assertEquals(expectedOutput, cipher.decode(cipher.getKey().substring(0, 10)));
-    }
-
-    @Ignore
-    @Test
-    public void cipherIsReversible() {
-        String plainText = "abcdefghij";
-
-        assertEquals(plainText, cipher.decode(cipher.encode(plainText)));
-    }
-}

exercises/simple-cipher/src/test/java/SimpleCipherStepOneTest.java

@@ -0,0 +1,41 @@
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Step 1: Make a simple shift cipher
+ */
+public class SimpleCipherStepOneTest {
+    private Cipher cipherWithDefaultKey;
+
+    @Before
+    public void setup() {
+        cipherWithDefaultKey = new Cipher();
+    }
+
+    /**
+     * 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 cipherText = cipherWithDefaultKey.getKey().substring(0, 10);
+        assertEquals(cipherText, cipherWithDefaultKey.encode("aaaaaaaaaa"));
+    }
+
+    @Ignore
+    @Test
+    public void cipherCanDecode() {
+        String cipherText = "aaaaaaaaaa";
+        assertEquals(cipherText, cipherWithDefaultKey.decode(cipherWithDefaultKey.getKey().substring(0, 10)));
+    }
+
+    @Ignore
+    @Test
+    public void cipherIsReversible() {
+        String plainText = "abcdefghij";
+        assertEquals(plainText, cipherWithDefaultKey.decode(cipherWithDefaultKey.encode(plainText)));
+    }
+}

exercises/simple-cipher/src/test/java/SimpleCipherStepThreeTest.java

@@ -0,0 +1,63 @@
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import static org.junit.Assert.*;
+
+/**
+ * Step 3: Generate random key if key isn't specified. Check key is right format
+ */
+public class SimpleCipherStepThreeTest {
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
+
+    @Ignore
+    @Test
+    public void cipherKeyIsMadeOfLetters() {
+        assertTrue(new Cipher().getKey().matches("[a-z]+"));
+    }
+
+    @Ignore
+    @Test
+    public void defaultCipherKeyIs100Characters() {
+        assertEquals(100, new Cipher().getKey().length());
+    }
+
+    @Ignore
+    @Test
+    public void cipherKeysAreRandomlyGenerated() {
+        String newKey = new Cipher().getKey();
+        assertFalse("Cipher constructor without argument should generate a random key. No two calls to the" +
+                " constructor should generate the same key. Two calls to the constructor " +
+                "both returned key: " + newKey, newKey.equals(new Cipher().getKey()));
+    }
+
+    @Ignore
+    @Test
+    public void cipherThrowsWithAllCapsKey() {
+        expectedException.expect(IllegalArgumentException.class);
+        new Cipher("ABCDEF");
+    }
+
+    @Ignore
+    @Test
+    public void cipherThrowsWithAnyCapsKey() {
+        expectedException.expect(IllegalArgumentException.class);
+        new Cipher("abcdEFg");
+    }
+
+    @Ignore
+    @Test
+    public void cipherThrowsWithNumericKey() {
+        expectedException.expect(IllegalArgumentException.class);
+        new Cipher("12345");
+    }
+
+    @Ignore
+    @Test
+    public void cipherThrowsWithAnyNumericKey() {
+        expectedException.expect(IllegalArgumentException.class);
+        new Cipher("abcd345ef");
+    }
+}

exercises/simple-cipher/src/test/java/SimpleCipherStepTwoTest.java

@@ -0,0 +1,86 @@
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Step 2: Specify key and use that for shift distance : substitution cipher
+ */
+public class SimpleCipherStepTwoTest {
+    private Cipher cipherWithSetKey;
+    private static final String key = "abcdefghij";
+
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
+
+    @Before
+    public void setup() {
+        cipherWithSetKey = new Cipher(key);
+    }
+
+    @Ignore
+    @Test
+    public void cipherKeepsTheSubmittedKey() {
+        assertEquals(key, cipherWithSetKey.getKey());
+    }
+
+    @Ignore
+    @Test
+    public void cipherThrowsWithEmptyKey() {
+        expectedException.expect(IllegalArgumentException.class);
+        new Cipher("");
+    }
+
+    @Ignore
+    @Test
+    public void cipherCanEncodeWithGivenKey() {
+        String cipherText = "abcdefghij";
+        assertEquals(cipherText, cipherWithSetKey.encode("aaaaaaaaaa"));
+    }
+
+    @Ignore
+    @Test
+    public void cipherCanDecodeWithGivenKey() {
+        String cipherText = "aaaaaaaaaa";
+        assertEquals(cipherText, cipherWithSetKey.decode("abcdefghij"));
+    }
+
+    @Ignore
+    @Test
+    public void cipherIsReversibleGivenKey() {
+        String plainText = "abcdefghij";
+        assertEquals(plainText, cipherWithSetKey.decode(cipherWithSetKey.encode("abcdefghij")));
+    }
+
+    @Ignore
+    @Test
+    public void cipherCanWrapEncode() {
+        String cipherText = "zabcdefghi";
+        assertEquals(cipherText, cipherWithSetKey.encode("zzzzzzzzzz"));
+    }
+
+    @Ignore
+    @Test
+    public void cipherCanEncodeMessageThatIsShorterThanTheKey() {
+        String cipherText = "abcde";
+        assertEquals(cipherText, cipherWithSetKey.encode("aaaaa"));
+    }
+
+    @Ignore
+    @Test
+    public void cipherCanDecodeMessageThatIsShorterThanTheKey() {
+        String cipherText = "aaaaa";
+        assertEquals(cipherText, cipherWithSetKey.decode("abcde"));
+    }
+
+    @Ignore
+    @Test
+    public void cipherCanDoubleShiftEncode() {
+        String plainText = "iamapandabear";
+        String cipherText = "qayaeaagaciai";
+        assertEquals(cipherText, new Cipher(plainText).encode(plainText));
+    }
+}

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

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

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

@@ -1,79 +0,0 @@
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.Ignore;
-
-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());
-    }
-
-    @Ignore
-    @Test
-    public void cipherCanEncodeWithGivenKey() {
-        String expectedOutput = "abcdefghij";
-
-        assertEquals(expectedOutput, cipher.encode("aaaaaaaaaa"));
-    }
-
-    @Ignore
-    @Test
-    public void cipherCanDecodeWithGivenKey() {
-        String expectedOutput = "aaaaaaaaaa";
-
-        assertEquals(expectedOutput, cipher.decode("abcdefghij"));
-    }
-
-    @Ignore
-    @Test
-    public void cipherIsReversibleGivenKey() {
-        String plainText = "abcdefghij";
-
-        assertEquals(plainText, cipher.decode(cipher.encode("abcdefghij")));
-    }
-
-    @Ignore
-    @Test
-    public void cipherCanDoubleShiftEncode() {
-        String plainText = "iamapandabear";
-        String expectedOutput = "qayaeaagaciai";
-
-        assertEquals(expectedOutput, new Cipher(plainText).encode(plainText));
-    }
-
-    @Ignore
-    @Test
-    public void cipherCanWrapEncode() {
-        String expectedOutput = "zabcdefghi";
-
-        assertEquals(expectedOutput, cipher.encode("zzzzzzzzzz"));
-    }
-
-    @Ignore
-    @Test
-    public void cipherCanEncodeMessageThatIsShorterThanTheKey() {
-        String expectedOutput = "abcde";
-
-        assertEquals(expectedOutput, cipher.encode("aaaaa"));
-    }
-
-    @Ignore
-    @Test
-    public void cipherCanDecodeMessageThatIsShorterThanTheKey() {
-        String expectedOutput = "aaaaa";
-
-        assertEquals(expectedOutput, cipher.decode("abcde"));
-    }
-}

exercises/sublist/build.gradle

@@ -0,0 +1,17 @@
+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  testCompile "junit:junit:4.12"
+}
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

exercises/sublist/src/example/java/Relationship.java

@@ -0,0 +1 @@
+../../main/java/Relationship.java

exercises/sublist/src/example/java/RelationshipComputer.java

@@ -0,0 +1,29 @@
+import java.util.List;
+
+final class RelationshipComputer<T extends Comparable> {
+
+    Relationship computeRelationship(final List<T> firstList, final List<T> secondList) {
+        if (firstList.equals(secondList))          return Relationship.EQUAL;
+        if (checkIfSublist(firstList, secondList)) return Relationship.SUBLIST;
+        if (checkIfSublist(secondList, firstList)) return Relationship.SUPERLIST;
+        return Relationship.UNEQUAL;
+    }
+
+    private boolean checkIfSublist(final List<T> firstList, final List<T> secondList) {
+        final int firstListSize = firstList.size();
+        final int secondListSize = secondList.size();
+
+        if (firstListSize > secondListSize) return false;
+
+        final int numberOfSublistCandidates = secondListSize - firstListSize + 1;
+
+        for (int startIndex = 0; startIndex < numberOfSublistCandidates; startIndex++) {
+            if (secondList.subList(startIndex, startIndex + firstListSize).equals(firstList)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+}

exercises/sublist/src/main/java/Relationship.java

@@ -0,0 +1,5 @@
+enum Relationship {
+
+    EQUAL, SUBLIST, SUPERLIST, UNEQUAL
+
+}

exercises/sublist/src/main/java/RelationshipComputer.java

@@ -0,0 +1,5 @@
+final class RelationshipComputer<T extends Comparable> {
+
+
+
+}

exercises/sublist/src/test/java/RelationshipComputerTest.java

@@ -0,0 +1,183 @@
+import org.junit.Ignore;
+import org.junit.Test;
+
+import java.util.List;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptyList;
+import static org.junit.Assert.assertEquals;
+
+public class RelationshipComputerTest {
+
+    @Test
+    public void testThatTwoEmptyListsAreConsideredEqual() {
+        Relationship computedRelationship = new RelationshipComputer<>().computeRelationship(
+                emptyList(),
+                emptyList());
+
+        assertEquals(Relationship.EQUAL, computedRelationship);
+    }
+
+    @Ignore
+    @Test
+    public void testEmptyListIsSublistOfNonEmptyList() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                emptyList(),
+                asList(1, 2, 3));
+
+        assertEquals(Relationship.SUBLIST, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testNonEmptyListIsSuperlistOfEmptyList() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList('1', '2', '3'),
+                emptyList());
+
+        assertEquals(Relationship.SUPERLIST, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testListIsEqualToItself() {
+        List<String> anyList = asList("1", "2", "3");
+
+        Relationship relationship = new RelationshipComputer<String>().computeRelationship(
+                anyList,
+                anyList);
+
+        assertEquals(Relationship.EQUAL, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testDifferentListsOfTheSameLengthAreUnequal() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList(1, 2, 3),
+                asList(2, 3, 4));
+
+        assertEquals(Relationship.UNEQUAL, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testSublistCheckDoesNotAbortAfterFalseStart() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList('1', '2', '5'),
+                asList('0', '1', '2', '3', '1', '2', '5', '6'));
+
+        assertEquals(Relationship.SUBLIST, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testSublistCheckHandlesExtraneousRepeatsOfFirstEntry() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList("1", "1", "2"),
+                asList("0", "1", "1", "1", "2", "1", "2"));
+
+        assertEquals(Relationship.SUBLIST, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testSublistAtStart() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList(0, 1, 2),
+                asList(0, 1, 2, 3, 4, 5));
+
+        assertEquals(Relationship.SUBLIST, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testSublistInMiddle() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList('2', '3', '4'),
+                asList('0', '1', '2', '3', '4', '5'));
+
+        assertEquals(Relationship.SUBLIST, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testSublistAtEnd() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList("3", "4", "5"),
+                asList("0", "1", "2", "3", "4", "5"));
+
+        assertEquals(Relationship.SUBLIST, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testAtStartOfSuperlist() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList(0, 1, 2, 3, 4, 5),
+                asList(0, 1, 2));
+
+        assertEquals(Relationship.SUPERLIST, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testInMiddleOfSuperlist() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList('0', '1', '2', '3', '4', '5'),
+                asList('2', '3'));
+
+        assertEquals(Relationship.SUPERLIST, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testAtEndOfSuperlist() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList("0", "1", "2", "3", "4", "5"),
+                asList("3", "4", "5"));
+
+        assertEquals(Relationship.SUPERLIST, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testFirstListMissingElementFromSecondList() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList(1, 3),
+                asList(1, 2, 3));
+
+        assertEquals(Relationship.UNEQUAL, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testSecondListMissingElementFromFirstList() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList('1', '2', '3'),
+                asList('1', '3'));
+
+        assertEquals(Relationship.UNEQUAL, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testThatListOrderingIsAccountedFor() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList("1", "2", "3"),
+                asList("3", "2", "1"));
+
+        assertEquals(Relationship.UNEQUAL, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testThatListsWithSameDigitsButDifferentNumbersAreUnequal() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList(1, 0, 1),
+                asList(10, 1));
+
+        assertEquals(Relationship.UNEQUAL, relationship);
+    }
+
+}