trackler 2.2.1.137 → 2.2.1.138

data/tracks/java/exercises/grep/build.gradle

@@ -0,0 +1,18 @@
+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"]
+    }
+}

data/tracks/java/exercises/grep/src/test/java/GrepToolTest.java

@@ -0,0 +1,395 @@
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public class GrepToolTest {
+    private GrepTool grepTool;
+
+    @Before
+    public void setUp() throws IOException {
+        List<String> iliadText = Arrays.asList(
+            "Achilles sing, O Goddess! Peleus' son;",
+            "His wrath pernicious, who ten thousand woes",
+            "Caused to Achaia's host, sent many a soul",
+            "Illustrious into Ades premature,",
+            "And Heroes gave (so stood the will of Jove)",
+            "To dogs and to all ravening fowls a prey,",
+            "When fierce dispute had separated once",
+            "The noble Chief Achilles from the son",
+            "Of Atreus, Agamemnon, King of men."
+        );
+        writeToFile("iliad.txt", iliadText);
+
+        List<String> midsummerNightText = Arrays.asList(
+            "I do entreat your grace to pardon me.",
+            "I know not by what power I am made bold,",
+            "Nor how it may concern my modesty,",
+            "In such a presence here to plead my thoughts;",
+            "But I beseech your grace that I may know",
+            "The worst that may befall me in this case,",
+            "If I refuse to wed Demetrius."
+        );
+        writeToFile("midsummer-night.txt", midsummerNightText);
+
+        List<String> paradiseLostText = Arrays.asList(
+            "Of Mans First Disobedience, and the Fruit",
+            "Of that Forbidden Tree, whose mortal tast",
+            "Brought Death into the World, and all our woe,",
+            "With loss of Eden, till one greater Man",
+            "Restore us, and regain the blissful Seat,",
+            "Sing Heav'nly Muse, that on the secret top",
+            "Of Oreb, or of Sinai, didst inspire",
+            "That Shepherd, who first taught the chosen Seed"
+        );
+        writeToFile("paradise-lost.txt", paradiseLostText);
+
+        grepTool = new GrepTool();
+    }
+
+    @After
+    public void tearDown() throws IOException {
+        deleteFile("iliad.txt");
+        deleteFile("midsummer-night.txt");
+        deleteFile("paradise-lost.txt");
+    }
+
+    @Test
+    public void oneFileOneMatchNoFlags() {
+        String expected = "Of Atreus, Agamemnon, King of men.";
+
+        String actual = grepTool.grep(
+            "Agamemnon",
+            Collections.emptyList(),
+            Collections.singletonList("iliad.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void oneFileOneMatchPrintLineNumbersFlag() {
+        String expected = "2:Of that Forbidden Tree, whose mortal tast";
+
+        String actual = grepTool.grep(
+            "Forbidden",
+            Collections.singletonList("-n"),
+            Collections.singletonList("paradise-lost.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void oneFileOneMatchCaseInsensitiveFlag() {
+        String expected = "Of that Forbidden Tree, whose mortal tast";
+
+        String actual = grepTool.grep(
+            "FORBIDDEN",
+            Collections.singletonList("-i"),
+            Collections.singletonList("paradise-lost.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void oneFileOneMatchPrintFileNamesFlag() {
+        String expected = "paradise-lost.txt";
+
+        String actual = grepTool.grep(
+            "Forbidden",
+            Collections.singletonList("-l"),
+            Collections.singletonList("paradise-lost.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void oneFileOneMatchEntireLinesFlag() {
+        String expected = "With loss of Eden, till one greater Man";
+
+        String actual = grepTool.grep(
+            "With loss of Eden, till one greater Man",
+            Collections.singletonList("-x"),
+            Collections.singletonList("paradise-lost.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void oneFileOneMatchMultipleFlags() {
+        String expected = "9:Of Atreus, Agamemnon, King of men.";
+
+        String actual = grepTool.grep(
+            "OF ATREUS, Agamemnon, KIng of MEN.",
+            Arrays.asList("-n", "-i", "-x"),
+            Collections.singletonList("iliad.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void oneFileSeveralMatchesNoFlags() {
+        String expected = "Nor how it may concern my modesty,\n"
+            + "But I beseech your grace that I may know\n"
+            + "The worst that may befall me in this case,";
+
+        String actual = grepTool.grep(
+            "may",
+            Collections.emptyList(),
+            Collections.singletonList("midsummer-night.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void oneFileSeveralMatchesPrintLineNumbersFlag() {
+        String expected = "3:Nor how it may concern my modesty,\n"
+            + "5:But I beseech your grace that I may know\n"
+            + "6:The worst that may befall me in this case,";
+
+        String actual = grepTool.grep(
+            "may",
+            Collections.singletonList("-n"),
+            Collections.singletonList("midsummer-night.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void oneFileSeveralMatchesMatchEntireLineFlag() {
+        String expected = "";
+
+        String actual = grepTool.grep(
+            "may",
+            Collections.singletonList("-x"),
+            Collections.singletonList("midsummer-night.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void oneFileSeveralMatchesCaseInsensitiveFlag() {
+        String expected = "Achilles sing, O Goddess! Peleus' son;\n"
+            + "The noble Chief Achilles from the son";
+
+        String actual = grepTool.grep(
+            "ACHILLES",
+            Collections.singletonList("-i"),
+            Collections.singletonList("iliad.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void oneFileSeveralMatchesInvertedFlag() {
+        String expected = "Brought Death into the World, and all our woe,\n"
+            + "With loss of Eden, till one greater Man\n"
+            + "Restore us, and regain the blissful Seat,\n"
+            + "Sing Heav'nly Muse, that on the secret top\n"
+            + "That Shepherd, who first taught the chosen Seed";
+
+        String actual = grepTool.grep(
+            "Of",
+            Collections.singletonList("-v"),
+            Collections.singletonList("paradise-lost.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void oneFileNoMatchesVariousFlags() {
+        String expected = "";
+
+        String actual = grepTool.grep(
+            "Gandalf",
+            Arrays.asList("-n", "-l", "-x", "-i"),
+            Collections.singletonList("iliad.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void multipleFilesOneMatchNoFlags() {
+        String expected = "iliad.txt:Of Atreus, Agamemnon, King of men.";
+
+        String actual = grepTool.grep(
+            "Agamemnon",
+            Collections.emptyList(),
+            Arrays.asList("iliad.txt", "midsummer-night.txt", "paradise-lost.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void multipleFilesSeveralMatchesNoFlags() {
+        String expected = "midsummer-night.txt:Nor how it may concern my modesty,\n"
+            + "midsummer-night.txt:But I beseech your grace that I may know\n"
+            + "midsummer-night.txt:The worst that may befall me in this case,";
+
+        String actual = grepTool.grep(
+            "may",
+            Collections.emptyList(),
+            Arrays.asList("iliad.txt", "midsummer-night.txt", "paradise-lost.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void multipleFilesSeveralMatchesPrintLineNumbersFlag() {
+        String expected = "midsummer-night.txt:5:But I beseech your grace that I may know\n"
+            + "midsummer-night.txt:6:The worst that may befall me in this case,\n"
+            + "paradise-lost.txt:2:Of that Forbidden Tree, whose mortal tast\n"
+            + "paradise-lost.txt:6:Sing Heav'nly Muse, that on the secret top";
+
+        String actual = grepTool.grep(
+            "that",
+            Collections.singletonList("-n"),
+            Arrays.asList("iliad.txt", "midsummer-night.txt", "paradise-lost.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void multipleFilesOneMatchPrintFileNamesFlag() {
+        String expected = "iliad.txt\n"
+            + "paradise-lost.txt";
+
+        String actual = grepTool.grep(
+            "who",
+            Collections.singletonList("-l"),
+            Arrays.asList("iliad.txt", "midsummer-night.txt", "paradise-lost.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void multipleFilesSeveralMatchesCaseInsensitiveFlag() {
+        String expected = "iliad.txt:Caused to Achaia's host, sent many a soul\n"
+            + "iliad.txt:Illustrious into Ades premature,\n"
+            + "iliad.txt:And Heroes gave (so stood the will of Jove)\n"
+            + "iliad.txt:To dogs and to all ravening fowls a prey,\n"
+            + "midsummer-night.txt:I do entreat your grace to pardon me.\n"
+            + "midsummer-night.txt:In such a presence here to plead my thoughts;\n"
+            + "midsummer-night.txt:If I refuse to wed Demetrius.\n"
+            + "paradise-lost.txt:Brought Death into the World, and all our woe,\n"
+            + "paradise-lost.txt:Restore us, and regain the blissful Seat,\n"
+            + "paradise-lost.txt:Sing Heav'nly Muse, that on the secret top";
+
+        String actual = grepTool.grep(
+            "TO",
+            Collections.singletonList("-i"),
+            Arrays.asList("iliad.txt", "midsummer-night.txt", "paradise-lost.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void multipleFilesSeveralMatchesInvertedFlag() {
+        String expected = "iliad.txt:Achilles sing, O Goddess! Peleus' son;\n"
+            + "iliad.txt:The noble Chief Achilles from the son\n"
+            + "midsummer-night.txt:If I refuse to wed Demetrius.";
+
+        String actual = grepTool.grep(
+            "a",
+            Collections.singletonList("-v"),
+            Arrays.asList("iliad.txt", "midsummer-night.txt", "paradise-lost.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void multipleFilesOneMatchEntireLinesFlag() {
+        String expected = "midsummer-night.txt:But I beseech your grace that I may know";
+
+        String actual = grepTool.grep(
+            "But I beseech your grace that I may know",
+            Collections.singletonList("-x"),
+            Arrays.asList("iliad.txt", "midsummer-night.txt", "paradise-lost.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void multipleFilesOneMatchMultipleFlags() {
+        String expected = "paradise-lost.txt:4:With loss of Eden, till one greater Man";
+
+        String actual = grepTool.grep(
+            "WITH LOSS OF EDEN, TILL ONE GREATER MAN",
+            Arrays.asList("-n", "-i", "-x"),
+            Arrays.asList("iliad.txt", "midsummer-night.txt", "paradise-lost.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void multipleFilesNoMatchesVariousFlags() {
+        String expected = "";
+
+        String actual = grepTool.grep(
+            "Frodo",
+            Arrays.asList("-n", "-l", "-i", "-x"),
+            Arrays.asList("iliad.txt", "midsummer-night.txt", "paradise-lost.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    private void writeToFile(String filename, List<String> contents) throws IOException {
+        Path file = Paths.get(filename);
+        Files.write(file, contents, Charset.forName("UTF-8"));
+    }
+
+    private void deleteFile(String filename) throws IOException {
+        Files.deleteIfExists(Paths.get(filename));
+    }
+}

data/tracks/java/exercises/largest-series-product/src/test/java/LargestSeriesProductCalculatorTest.java

@@ -12,10 +12,10 @@ public class LargestSeriesProductCalculatorTest {
 
     @Test
     public void testCorrectlyCalculatesLargestProductWhenSeriesLengthEqualsStringToSearchLength() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("29");
-        final long expectedProduct = 18;
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("29");
+        long expectedProduct = 18;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(2);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(2);
 
         assertEquals(expectedProduct, actualProduct);
     }
@@ -23,10 +23,10 @@ public class LargestSeriesProductCalculatorTest {
     @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfLengthTwoWithNumbersInOrder() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0123456789");
-        final long expectedProduct = 72;
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0123456789");
+        long expectedProduct = 72;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(2);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(2);
 
         assertEquals(expectedProduct, actualProduct);
     }
@@ -34,10 +34,10 @@ public class LargestSeriesProductCalculatorTest {
     @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfLengthTwoWithNumbersNotInOrder() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("576802143");
-        final long expectedProduct = 48;
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("576802143");
+        long expectedProduct = 48;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(2);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(2);
 
         assertEquals(expectedProduct, actualProduct);
     }
@@ -45,10 +45,10 @@ public class LargestSeriesProductCalculatorTest {
     @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfLengthThreeWithNumbersInOrder() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0123456789");
-        final long expectedProduct = 504;
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0123456789");
+        long expectedProduct = 504;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(3);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(3);
 
         assertEquals(expectedProduct, actualProduct);
     }
@@ -56,10 +56,10 @@ public class LargestSeriesProductCalculatorTest {
     @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfLengthThreeWithNumbersNotInOrder() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("1027839564");
-        final long expectedProduct = 270;
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("1027839564");
+        long expectedProduct = 270;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(3);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(3);
 
         assertEquals(expectedProduct, actualProduct);
     }
@@ -67,10 +67,10 @@ public class LargestSeriesProductCalculatorTest {
     @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfLengthFiveWithNumbersInOrder() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0123456789");
-        final long expectedProduct = 15120;
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0123456789");
+        long expectedProduct = 15120;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(5);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(5);
 
         assertEquals(expectedProduct, actualProduct);
     }
@@ -78,12 +78,12 @@ public class LargestSeriesProductCalculatorTest {
     @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductInLongStringToSearchV1() {
-        final LargestSeriesProductCalculator calculator
+        LargestSeriesProductCalculator calculator
                 = new LargestSeriesProductCalculator("73167176531330624919225119674426574742355349194934");
 
-        final long expectedProduct = 23520;
+        long expectedProduct = 23520;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(6);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(6);
 
         assertEquals(expectedProduct, actualProduct);
     }
@@ -91,10 +91,10 @@ public class LargestSeriesProductCalculatorTest {
     @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfZeroIfAllDigitsAreZeroes() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0000");
-        final long expectedProduct = 0;
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0000");
+        long expectedProduct = 0;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(2);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(2);
 
         assertEquals(expectedProduct, actualProduct);
     }
@@ -102,10 +102,10 @@ public class LargestSeriesProductCalculatorTest {
     @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfZeroIfAllSeriesOfGivenLengthContainZero() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("99099");
-        final long expectedProduct = 0;
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("99099");
+        long expectedProduct = 0;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(3);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(3);
 
         assertEquals(expectedProduct, actualProduct);
     }
@@ -113,7 +113,7 @@ public class LargestSeriesProductCalculatorTest {
     @Ignore("Remove to run test")
     @Test
     public void testSeriesLengthLongerThanLengthOfStringToTestIsRejected() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("123");
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("123");
 
         expectedException.expect(IllegalArgumentException.class);
         expectedException.expectMessage(
@@ -125,10 +125,10 @@ public class LargestSeriesProductCalculatorTest {
     @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfLength0ForEmptyStringToSearch() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("");
-        final long expectedProduct = 1;
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("");
+        long expectedProduct = 1;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(0);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(0);
 
         assertEquals(expectedProduct, actualProduct);
     }
@@ -136,10 +136,10 @@ public class LargestSeriesProductCalculatorTest {
     @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfLength0ForNonEmptyStringToSearch() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("123");
-        final long expectedProduct = 1;
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("123");
+        long expectedProduct = 1;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(0);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(0);
 
         assertEquals(expectedProduct, actualProduct);
     }
@@ -147,7 +147,7 @@ public class LargestSeriesProductCalculatorTest {
     @Ignore("Remove to run test")
     @Test
     public void testEmptyStringToSearchAndSeriesOfNonZeroLengthIsRejected() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("");
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("");
 
         expectedException.expect(IllegalArgumentException.class);
         expectedException.expectMessage(
@@ -168,7 +168,7 @@ public class LargestSeriesProductCalculatorTest {
     @Ignore("Remove to run test")
     @Test
     public void testNegativeSeriesLengthIsRejected() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("12345");
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("12345");
 
         expectedException.expect(IllegalArgumentException.class);
         expectedException.expectMessage("Series length must be non-negative.");