trackler 2.2.1.105 → 2.2.1.106

data/tracks/java/exercises/atbash-cipher/src/test/java/AtbashTest.java

@@ -1,73 +1,89 @@
+import org.junit.Before;
 import org.junit.Ignore;
 import org.junit.Test;
-import org.junit.experimental.runners.Enclosed;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
-
-import java.util.Arrays;
-import java.util.Collection;
 
 import static org.junit.Assert.assertEquals;
 
-@RunWith(Enclosed.class)
 public class AtbashTest {
 
-    @RunWith(Parameterized.class)
-    public static class EncodeTest {
-        private String plaintext;
-        private String ciphertext;
-
-        @Parameters(name = "{index}: expected plaintext \"{0}\" to encode to ciphertext \"{1}\".")
-        public static Collection<Object[]> data() {
-            return Arrays.asList(new Object[][]{
-                    {"yes", "bvh"},
-                    {"no", "ml"},
-                    {"OMG", "lnt"},
-                    {"O M G", "lnt"},
-                    {"mindblowingly", "nrmwy oldrm tob"},
-                    {"Testing,1 2 3, testing.", "gvhgr mt123 gvhgr mt"},
-                    {"Truth is fiction.", "gifgs rhurx grlm"},
-                    {"The quick brown fox jumps over the lazy dog.", "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt"}
-            });
-        }
-
-        public EncodeTest(String plaintext, String ciphertext) {
-            this.plaintext = plaintext;
-            this.ciphertext = ciphertext;
-        }
-
-
-        @Test
-        public void test() {
-            assertEquals(ciphertext, new Atbash().encode(plaintext));
-        }
+    private Atbash atbash;
+
+    @Before
+    public void setup() {
+        atbash = new Atbash();
+    }
+
+    @Test
+    public void testEncodeYes() {
+        assertEquals("bvh", atbash.encode("yes"));
     }
 
-    @RunWith(Parameterized.class)
-    public static class DecodeTest {
-        private String ciphertext;
-        private String plaintext;
-
-        @Parameters(name = "{index}: expected ciphertext \"{0}\" to decode to plaintext \"{1}\".")
-        public static Collection<Object[]> data() {
-            return Arrays.asList(new Object[][]{
-                    {"vcvix rhn", "exercism"},
-                    {"zmlyh gzxov rhlug vmzhg vkkrm thglm v", "anobstacleisoftenasteppingstone"},
-                    {"gvhgr mt123 gvhgr mt", "testing123testing"},
-                    {"gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt", "thequickbrownfoxjumpsoverthelazydog"}
-            });
-        }
-
-        public DecodeTest(String ciphertext, String plaintext) {
-            this.ciphertext = ciphertext;
-            this.plaintext = plaintext;
-        }
-
-        @Ignore("Remove to run tests")
-        @Test
-        public void test() {
-            assertEquals(plaintext, new Atbash().decode(ciphertext));
-        }
+    @Ignore("Remove to run test")
+    @Test
+    public void testEncodeNo() {
+        assertEquals("ml", atbash.encode("no"));
     }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testEncodeOmgInCapital() {
+        assertEquals("lnt", atbash.encode("OMG"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testEncodeOmgWithSpaces() {
+        assertEquals("lnt", atbash.encode("O M G"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testEncodeMindBlowingly() {
+        assertEquals("nrmwy oldrm tob", atbash.encode("mindblowingly"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testEncodeNumbers() {
+        assertEquals("gvhgr mt123 gvhgr mt", atbash.encode("Testing,1 2 3, testing."));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testEncodeDeepThought() {
+        assertEquals("gifgs rhurx grlm", atbash.encode("Truth is fiction."));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testEncodeAllTheLetters() {
+        assertEquals("gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt",
+                atbash.encode("The quick brown fox jumps over the lazy dog."));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testDecodeExercism() {
+        assertEquals("exercism", atbash.decode("vcvix rhn"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testDecodeASentence() {
+        assertEquals("anobstacleisoftenasteppingstone", atbash.decode("zmlyh gzxov rhlug vmzhg vkkrm thglm v"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testDecodeNumbers() {
+        assertEquals("testing123testing", atbash.decode("gvhgr mt123 gvhgr mt"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testDecodeAllTheLetters() {
+        assertEquals("thequickbrownfoxjumpsoverthelazydog",
+                atbash.decode("gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt"));
+    }
+
 }

data/tracks/java/exercises/binary/.meta/version

@@ -0,0 +1 @@
+1.1.0

data/tracks/java/exercises/binary/src/test/java/BinaryTest.java

@@ -1,49 +1,114 @@
 import org.junit.Test;
 import org.junit.Ignore;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
-
-import java.util.Arrays;
-import java.util.Collection;
 
 import static org.junit.Assert.assertEquals;
 
-@RunWith(Parameterized.class)
 public class BinaryTest {
 
-    private String binaryNumberAsString;
-    private int decimalNumber;
+    private Binary binary;
 
-    @Parameters(name = "{index}: expected {1} when converting \"{0}\" from binary to decimal.")
-    public static Collection<Object[]> data() {
-        return Arrays.asList(new Object[][]{
-                {"1", 1},
-                {"10", 2},
-                {"11", 3},
-                {"100", 4},
-                {"1001", 9},
-                {"11010", 26},
-                {"10001101000", 1128},
-                {"2", 0},
-                {"5", 0},
-                {"9", 0},
-                {"134678", 0},
-                {"abc10z", 0},
-                {"011", 3}
-        });
+    @Test
+    public void testBinary0IsDecimal0() {
+	binary = new Binary("0");
+	assertEquals(0, binary.getDecimal());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testBinary1IsDecimal1() {
+	binary = new Binary("1");
+	assertEquals(1, binary.getDecimal());
     }
 
-    public BinaryTest(String binaryNumberAsString, int decimalNumber) {
-        this.binaryNumberAsString = binaryNumberAsString;
-        this.decimalNumber = decimalNumber;
+    @Ignore("Remove to run test")
+    @Test
+    public void testBinary10IsDecimal2() {
+	binary = new Binary("10");
+	assertEquals(2, binary.getDecimal());
     }
 
+    @Ignore("Remove to run test")
+    @Test
+    public void testBinary11IsDecimal3() {
+	binary = new Binary("11");
+	assertEquals(3, binary.getDecimal());
+    }
 
+    @Ignore("Remove to run test")
     @Test
-    public void test() {
-        Binary binary = new Binary(binaryNumberAsString);
+    public void testBinary100IsDecimal4() {
+	binary = new Binary("100");
+	assertEquals(4, binary.getDecimal());
+    }
 
-        assertEquals(decimalNumber, binary.getDecimal());
+    @Ignore("Remove to run test")
+    @Test
+    public void testBinary1001IsDecimal9() {
+	binary = new Binary("1001");
+	assertEquals(9, binary.getDecimal());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testBinary11010IsDecimal26() {
+	binary = new Binary("11010");
+	assertEquals(26, binary.getDecimal());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testBinary10001101000IsDecimal1128() {
+	binary = new Binary("10001101000");
+	assertEquals(1128, binary.getDecimal());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testBinaryIgnoresLeadingZeros() {
+	binary = new Binary("000011111");
+	assertEquals(31, binary.getDecimal());
     }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void test2NotValidBinaryDigit() {
+	binary = new Binary("2");
+	assertEquals(0, binary.getDecimal());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testNumberContainingNonBinaryDigitInvalid() {
+	binary = new Binary("01201");
+	assertEquals(0, binary.getDecimal());
+   }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testNumberWithTrailingNonBinaryCharactersInvalid() {
+	binary = new Binary("10nope");
+	assertEquals(0, binary.getDecimal());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testNumberWithLeadingNonBinaryCharactersInvalid() {
+	binary = new Binary("nope10");
+	assertEquals(0, binary.getDecimal());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testNumberWithInternalNonBinaryCharactersInvalid() {
+	binary = new Binary("10nope10");
+	assertEquals(0, binary.getDecimal());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testNumberAndWordWhitespaceSeparatedInvalid() {
+	binary = new Binary("001 nope");
+	assertEquals(0, binary.getDecimal());
+    }
+
 }

data/tracks/java/exercises/bracket-push/.meta/version

@@ -1 +1 @@
-1.1.0
+1.2.0

data/tracks/java/exercises/isbn-verifier/.meta/version

@@ -1 +1 @@
-2.0.0
+2.2.0

data/tracks/java/exercises/isbn-verifier/src/test/java/IsbnVerifierTest.java

@@ -91,4 +91,10 @@ public class IsbnVerifierTest {
         assertFalse(isbnVerifier.isValid("3-598-21515-X"));
     }
 
+    @Ignore("Remove to run test")
+    @Test
+    public void emptyIsbn() {
+        assertFalse(isbnVerifier.isValid(""));
+    }
+
 }

data/tracks/java/exercises/matrix/.meta/src/reference/java/Matrix.java

@@ -28,12 +28,4 @@ class Matrix {
         }
         return column;
     }
-
-    int getRowsCount() {
-        return matrix.length;
-    }
-
-    int getColumnsCount() {
-        return matrix[0].length;
-    }
 }

data/tracks/java/exercises/matrix/.meta/version

@@ -0,0 +1,2 @@
+1.0.0
+

data/tracks/java/exercises/matrix/src/test/java/MatrixTest.java

@@ -10,198 +10,100 @@ import java.util.Collection;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 
-@RunWith(Enclosed.class)
 public class MatrixTest {
-
-    @RunWith(Parameterized.class)
-    public static class CountRowsTest {
-        private Matrix matrix;
-        private int numberOfRows;
-
-        @Parameterized.Parameters(name = "{index}: expected matrix constructed with string \n\"{0}\" to have {1} row(s).")
-        public static Collection<Object[]> data() {
-            return Arrays.asList(new Object[][]{
-                    {"0", 1},
-                    {"0 1", 1},
-                    {  "0\n"
-                     + "1", 2},
-                    {  "0 1\n"
-                     + "2 3", 2},
-                    {  "0 1 2\n"
-                     + "3 4 5\n"
-                     + "6 7 8", 3}
-            });
-        }
-
-        public CountRowsTest(String matrixAsString, int numberOfRows) {
-            this.matrix = new Matrix(matrixAsString);
-            this.numberOfRows = numberOfRows;
-        }
-
-        @Test
-        public void countRowsTest() {
-            assertEquals(numberOfRows, matrix.getRowsCount());
-        }
-    }
-
-    @Ignore("Remove to run test")
-    @RunWith(Parameterized.class)
-    public static class CountColumnsTest {
-        private Matrix matrix;
-        private int numberOfColumns;
-
-        @Parameterized.Parameters(name = "{index}: expected matrix constructed with string \n\"{0}\" to have {1} column(s).")
-        public static Collection<Object[]> data() {
-            return Arrays.asList(new Object[][]{
-                    {"0", 1},
-                    {"0 1", 2},
-                    {  "0\n"
-                     + "1", 1},
-                    {  "0 1\n"
-                     + "2 3", 2},
-                    {  "0 1 2\n"
-                     + "3 4 5\n"
-                     + "6 7 8", 3}
-            });
-        }
-
-        public CountColumnsTest(String matrixAsString, int numberOfColumns) {
-            this.matrix = new Matrix(matrixAsString);
-            this.numberOfColumns = numberOfColumns;
-        }
-
-        @Test
-        public void countColumnsTest() {
-            assertEquals(numberOfColumns, matrix.getColumnsCount());
-        }
-    }
-
-    @Ignore("Remove to run test")
-    @RunWith(Parameterized.class)
-    public static class GetFirstRowTest {
-        private Matrix matrix;
-        private int[] firstRow;
-
-        @Parameterized.Parameters(name = "{index}: checking first row of matrix constructed with string \n\"{0}\".")
-        public static Collection<Object[]> data() {
-            return Arrays.asList(new Object[][]{
-                    {"0", new int[] {0}},
-                    {"0 1", new int[] {0, 1}},
-                    {  "0\n"
-                     + "1", new int[] {0}},
-                    {  "0 1\n"
-                     + "2 3", new int[] {0, 1}},
-                    {  "0 1 2\n"
-                     + "3 4 5\n"
-                     + "6 7 8", new int[] {0, 1, 2}}
-            });
-        }
-
-        public GetFirstRowTest(String matrixAsString, int[] firstRow) {
-            this.matrix = new Matrix(matrixAsString);
-            this.firstRow = firstRow;
-        }
-
-        @Test
-        public void getFirstRowTest() {
-            assertArrayEquals(firstRow, matrix.getRow(0));
-        }
-    }
-
-    @Ignore("Remove to run test")
-    @RunWith(Parameterized.class)
-    public static class GetLastRowTest {
-        private Matrix matrix;
-        private int[] lastRow;
-
-        @Parameterized.Parameters(name = "{index}: checking last row of matrix constructed with string \n\"{0}\".")
-        public static Collection<Object[]> data() {
-            return Arrays.asList(new Object[][]{
-                    {"0", new int[] {0}},
-                    {"0 1", new int[] {0, 1}},
-                    {  "0\n"
-                     + "1", new int[] {1}},
-                    {  "0 1\n"
-                     + "2 3", new int[] {2, 3}},
-                    {  "0 1 2\n"
-                     + "3 4 5\n"
-                     + "6 7 8", new int[] {6, 7, 8}}
-            });
-        }
-
-        public GetLastRowTest(String matrixAsString, int[] lastRow) {
-            this.matrix = new Matrix(matrixAsString);
-            this.lastRow = lastRow;
-        }
-
-        @Test
-        public void getLastRowTest() {
-            assertArrayEquals(lastRow, matrix.getRow(matrix.getRowsCount() - 1));
-        }
-    }
-
-    @Ignore("Remove to run test")
-    @RunWith(Parameterized.class)
-    public static class GetFirstColumnTest {
-        private Matrix matrix;
-        private int[] firstColumn;
-
-        @Parameterized.Parameters(name = "{index}: checking first column of matrix constructed with string \n\"{0}\".")
-        public static Collection<Object[]> data() {
-            return Arrays.asList(new Object[][]{
-                    {"0", new int[] {0}},
-                    {"0 1", new int[] {0}},
-                    {  "0\n"
-                     + "1", new int[] {0, 1}},
-                    {  "0 1\n"
-                     + "2 3", new int[] {0, 2}},
-                    {  "0 1 2\n"
-                     + "3 4 5\n"
-                     + "6 7 8", new int[] {0, 3, 6}}
-            });
-        }
-
-        public GetFirstColumnTest(String matrixAsString, int[] firstColumn) {
-            this.matrix = new Matrix(matrixAsString);
-            this.firstColumn = firstColumn;
-        }
-
-        @Test
-        public void getFirstColumnTest() {
-            assertArrayEquals(firstColumn, matrix.getColumn(0));
-        }
-    }
-
-
-    @Ignore("Remove to run test")
-    @RunWith(Parameterized.class)
-    public static class GetLastColumnTest {
-        private Matrix matrix;
-        private int[] lastColumn;
-
-        @Parameterized.Parameters(name = "{index}: checking last column of matrix constructed with string \n\"{0}\".")
-        public static Collection<Object[]> data() {
-            return Arrays.asList(new Object[][]{
-                    {"0", new int[] {0}},
-                    {"0 1", new int[] {1}},
-                    {  "0\n"
-                     + "1", new int[] {0, 1}},
-                    {  "0 1\n"
-                     + "2 3", new int[] {1, 3}},
-                    {  "0 1 2\n"
-                     + "3 4 5\n"
-                     + "6 7 8", new int[] {2, 5, 8}}
-            });
-        }
-
-        public GetLastColumnTest(String matrixAsString, int[] lastColumn) {
-            this.matrix = new Matrix(matrixAsString);
-            this.lastColumn = lastColumn;
-        }
-
-        @Test
-        public void getLastColumnTest() {
-            assertArrayEquals(lastColumn, matrix.getColumn(matrix.getColumnsCount() - 1));
-        }
-    }
+	
+	@Test
+	public void extractRowFromOneNumberMatrixTest() {
+		String matrixAsString = "1";
+		int rowIndex = 0;
+		int[] expectedRow = {1};
+		
+		Matrix matrix = new Matrix(matrixAsString);
+		
+		assertArrayEquals(expectedRow, matrix.getRow(rowIndex));
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void extractRowFromMatrixTest() {
+		String matrixAsString = "1 2\n3 4";
+		int rowIndex = 1;
+		int[] expectedRow = {3, 4};
+		
+		Matrix matrix = new Matrix(matrixAsString);
+		
+		assertArrayEquals(expectedRow, matrix.getRow(rowIndex));
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void extractRowFromDiffWidthsMatrixTest() {
+		String matrixAsString = "1 2\n10 20";
+		int rowIndex = 1;
+		int[] expectedRow = {10, 20};
+		
+		Matrix matrix = new Matrix(matrixAsString);
+		
+		assertArrayEquals(expectedRow, matrix.getRow(rowIndex));
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void extractRowFromNonSquareMatrixTest() {
+		String matrixAsString = "1 2 3\n4 5 6\n7 8 9\n8 7 6";
+		int rowIndex = 2;
+		int[] expectedRow = {7, 8, 9};
+		
+		Matrix matrix = new Matrix(matrixAsString);
+		
+		assertArrayEquals(expectedRow, matrix.getRow(rowIndex));
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void extractColumnFromOneNumberMatrixTest() {
+		String matrixAsString = "1";
+		int columnIndex = 0;
+		int[] expectedColumn = {1};
+		
+		Matrix matrix = new Matrix(matrixAsString);
+		
+		assertArrayEquals(expectedColumn, matrix.getColumn(columnIndex));
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void extractColumnMatrixTest() {
+		String matrixAsString = "1 2 3\n4 5 6\n7 8 9";
+		int columnIndex = 2;
+		int[] expectedColumn = {3, 6, 9};
+		
+		Matrix matrix = new Matrix(matrixAsString);
+		
+		assertArrayEquals(expectedColumn, matrix.getColumn(columnIndex));
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void extractColumnFromNonSquareMatrixTest() {
+		String matrixAsString = "1 2 3\n4 5 6\n7 8 9\n8 7 6";
+		int columnIndex = 2;
+		int[] expectedColumn = {3, 6, 9, 6};
+		
+		Matrix matrix = new Matrix(matrixAsString);
+		
+		assertArrayEquals(expectedColumn, matrix.getColumn(columnIndex));
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void extractColumnFromDiffWidthsMatrixTest() {
+		String matrixAsString = "89 1903 3\n18 3 1\n9 4 800";
+		int columnIndex = 1;
+		int[] expectedColumn = {1903, 3, 4};
+		
+		Matrix matrix = new Matrix(matrixAsString);
+		
+		assertArrayEquals(expectedColumn, matrix.getColumn(columnIndex));
+	}
 }