trackler 2.0.7.0 → 2.0.8.1

data/tracks/java/exercises/anagram/src/test/java/AnagramTest.java

@@ -18,13 +18,21 @@ public class AnagramTest {
 
     @Ignore
     @Test
-    public void testSimpleAnagram() {
+    public void testDetectSimpleAnagram() {
         Anagram detector = new Anagram("ant");
         List<String> anagram = detector.match(Arrays.asList("tan", "stand", "at"));
         assertThat(anagram, hasItem("tan"));
         assertThat(anagram.size(), is(1));
     }
 
+    @Ignore
+    @Test
+    public void testDetectLongerAnagram() {
+        Anagram detector = new Anagram("listen");
+        List<String> anagrams = detector.match(Arrays.asList("enlists", "google", "inlets", "banana"));
+        assertThat(anagrams, hasItem("inlets"));
+    }
+
     @Ignore
     @Test
     public void testDetectMultipleAnagrams() {
@@ -33,12 +41,19 @@ public class AnagramTest {
         assertThat(anagrams, allOf(hasItem("maters"), hasItem("stream")));
     }
 
+    @Ignore
+    @Test
+    public void testDetectMultipleAnagramsForLongerWord() {
+        Anagram detector = new Anagram("allergy");
+        List<String> anagrams = detector.match(Arrays.asList("gallery", "ballerina", "regally", "clergy", "largely", "leading"));
+        assertThat(anagrams, allOf(hasItem("gallery"), hasItem("largely"), hasItem("regally")));
+    }
+
     @Ignore
     @Test
     public void testDoesNotConfuseDifferentDuplicates() {
         Anagram detector = new Anagram("galea");
-        List<String> anagrams = detector.match(Arrays.asList("eagle"));
-        assertTrue(anagrams.isEmpty());
+        assertTrue(detector.match(Arrays.asList("eagle")).isEmpty());
     }
 
     @Ignore
@@ -50,6 +65,20 @@ public class AnagramTest {
         assertThat(anagrams.size(), is(1));
     }
 
+    @Ignore
+    @Test
+    public void testIdenticalWordRepeatedIsNotAnagram() {
+        Anagram detector = new Anagram("go");
+        assertTrue(detector.match(Arrays.asList("go Go GO")).isEmpty());
+    }
+
+    @Ignore
+    @Test
+    public void testCapitalWordIsNotOwnAnagram() {
+        Anagram detector = new Anagram("BANANA");
+        assertTrue(detector.match(Arrays.asList("Banana")).isEmpty());
+    }
+
     @Ignore
     @Test
     public void testEliminateAnagramsWithSameChecksum() {
@@ -66,26 +95,25 @@ public class AnagramTest {
 
     @Ignore
     @Test
-    public void testDetectAnagrams() {
-        Anagram detector = new Anagram("listen");
-        List<String> anagrams = detector.match(Arrays.asList("enlists", "google", "inlets", "banana"));
-        assertThat(anagrams, hasItem("inlets"));
+    public void testCaseInsensitiveWhenSubjectStartsWithUpperCaseLetter() {
+        Anagram detector = new Anagram("Orchestra");
+        List<String> anagrams = detector.match(Arrays.asList("cashregister", "carthorse", "radishes"));
+        assertThat(anagrams, hasItem("carthorse"));
     }
 
     @Ignore
     @Test
-    public void testMultipleAnagrams() {
-        Anagram detector = new Anagram("allergy");
-        List<String> anagrams = detector.match(Arrays.asList("gallery", "ballerina", "regally", "clergy", "largely", "leading"));
-        assertThat(anagrams, allOf(hasItem("gallery"), hasItem("largely"), hasItem("regally")));
+    public void testCaseInsensitiveWhenAnagramStartsWithUpperCaseLetter() {
+        Anagram detector = new Anagram("orchestra");
+        List<String> anagrams = detector.match(Arrays.asList("cashregister", "Carthorse", "radishes"));
+        assertThat(anagrams, hasItem("Carthorse"));
     }
 
     @Ignore
     @Test
-    public void testAnagramsAreCaseInsensitive() {
+    public void testCaseInsensitiveWhenBothAnagramAndSubjectStartWithUpperCaseLetter() {
         Anagram detector = new Anagram("Orchestra");
         List<String> anagrams = detector.match(Arrays.asList("cashregister", "Carthorse", "radishes"));
         assertThat(anagrams, hasItem("Carthorse"));
     }
-
 }

data/tracks/java/exercises/list-ops/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/list-ops/src/example/java/ListOps.java

@@ -0,0 +1,51 @@
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.BiFunction;
+import java.util.function.BinaryOperator;
+import java.util.function.Predicate;
+import java.util.function.UnaryOperator;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class ListOps {
+
+    private ListOps() {
+    }
+
+    public static <T> int length(final List<T> list) {
+        return list.size();
+    }
+
+    public static <T> List<T> reverse(final List<T> list) {
+        List<T> result = new ArrayList(list);
+        Collections.reverse(result);
+        return result;
+    }
+
+    public static <T> List<T> map(final List<T> list,
+            UnaryOperator<T> mapper) {
+        return list.stream().map(mapper).collect(Collectors.toList());
+    }
+
+    public static <T> List<T> filter(final List<T> list,
+            Predicate<T> predicate) {
+        return list.stream().filter(predicate).collect(Collectors.toList());
+    }
+
+    public static <U, T> U reduce(final List<T> list,
+            U identity,
+            BiFunction<U, T, U> accumulator,
+            BinaryOperator<U> combiner) {
+        return list.stream().reduce(identity, accumulator, combiner);
+    }
+
+    public static <T> List<T> concat(final List<T>... lists) {
+        return Stream.of(lists)
+                .flatMap(Collection::stream)
+                .collect(Collectors.toList());
+    }
+
+}

data/tracks/java/exercises/list-ops/src/test/java/ListOpsTest.java

@@ -0,0 +1,316 @@
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.BiFunction;
+import java.util.function.BinaryOperator;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import static junit.framework.TestCase.assertEquals;
+import static junit.framework.TestCase.assertFalse;
+import static junit.framework.TestCase.assertNotNull;
+import static junit.framework.TestCase.assertTrue;
+import org.junit.Ignore;
+import org.junit.Test;
+
+public class ListOpsTest {
+
+    private static final List<Integer> EMPTY_LIST
+            = Collections.emptyList();
+
+    @Test
+    public void lengthOfAnEmptyListShouldBeZero() {
+        final int expected = 0;
+        final int actual = ListOps.length(EMPTY_LIST);
+
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void shouldReturnTheCorrectLengthOfAnNonEmptyList() {
+        final List<Integer> list = Collections.unmodifiableList(
+                Arrays.asList(0, 1, 2, 3, 4)
+        );
+        final int actual = ListOps.length(list);
+        final int expected = list.size();
+
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void shouldReverseAnEmptyList() {
+        final List<Integer> actual = ListOps.reverse(EMPTY_LIST);
+
+        assertNotNull(actual);
+        assertTrue(actual.isEmpty());
+    }
+
+    @Test
+    @Ignore
+    public void shouldReverseANonEmptyList() {
+        final List<Integer> list = Collections.unmodifiableList(
+                Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8)
+        );
+        final List<Integer> actual
+                = ListOps.reverse(list);
+        final List<Integer> expected
+                = Arrays.asList(8, 7, 6, 5, 4, 3, 2, 1, 0);
+
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void shouldMapAnEmptyListAndReturnAnEmptyList() {
+        final List<Integer> actual = ListOps.map(EMPTY_LIST, x -> x + 1);
+
+        assertNotNull(actual);
+        assertTrue(actual.isEmpty());
+    }
+
+    @Test
+    @Ignore
+    public void shouldMapNonEmptyList() {
+        final List<Integer> list
+                = Collections.unmodifiableList(Arrays.asList(1, 3, 5, 7));
+        final List<Integer> actual = ListOps.map(list, x -> x + 1);
+
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(Arrays.asList(2, 4, 6, 8), actual);
+    }
+
+    @Test
+    @Ignore
+    public void shouldFilterAnEmptyListanddReturnAnEmptyList() {
+        final List<Integer> actual = ListOps.filter(EMPTY_LIST, x -> x > 0);
+
+        assertNotNull(actual);
+        assertTrue(actual.isEmpty());
+    }
+
+    @Test
+    @Ignore
+    public void shouldFilterNonEmptyList() {
+        Predicate<Integer> predicate = x -> x % 2 > 0;
+        final List<Integer> list = Collections.unmodifiableList(
+                IntStream.range(0, 100).boxed().collect(Collectors.toList())
+        );
+        final List<Integer> actual = ListOps.filter(list, predicate);
+        final List<Integer> expected = list.stream()
+                .filter(predicate)
+                .collect(Collectors.toList());
+
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void shouldConcatenateZeroLists() {
+        List<Integer> actual = ListOps.concat();
+
+        assertNotNull(actual);
+        assertTrue(actual.isEmpty());
+    }
+
+    @Test
+    @Ignore
+    public void shouldConcatenateOneNonEmptyList() {
+        final List<Integer> list
+                = Collections.unmodifiableList(
+                        Arrays.asList(0, 1, 2, 3, 4)
+                );
+        final List<Integer> actual = ListOps.concat(list);
+        final List<Integer> expected = Arrays.asList(0, 1, 2, 3, 4);
+
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void shouldConcatenateOneEmptyList() {
+        final List<Integer> actual = ListOps.concat(EMPTY_LIST);
+
+        assertNotNull(actual);
+        assertTrue(actual.isEmpty());
+    }
+
+    @Test
+    @Ignore
+    public void shouldConcatenateTwoEmptyLists() {
+        final List<Integer> actual = ListOps.concat(EMPTY_LIST, EMPTY_LIST);
+
+        assertNotNull(actual);
+        assertTrue(actual.isEmpty());
+    }
+
+    @Test
+    @Ignore
+    public void shouldConcatenateOneEmptyAndOneNonEmptyLists() {
+        final List<Integer> list
+                = Collections.unmodifiableList(
+                        Arrays.asList(0, 1, 2, 3, 4)
+                );
+        final List<Integer> actual = ListOps.concat(list, EMPTY_LIST);
+        final List<Integer> expected
+                = Arrays.asList(0, 1, 2, 3, 4);
+
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void shouldConcatenateOneNonEmptyAndOneEmptyLists() {
+        final List<Integer> list
+                = Collections.unmodifiableList(
+                        Arrays.asList(0, 1, 2, 3, 4)
+                );
+        final List<Integer> actual = ListOps.concat(EMPTY_LIST, list);
+        final List<Integer> expected
+                = Arrays.asList(0, 1, 2, 3, 4);
+
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void shouldConcatenateTwoListsWithSameElements() {
+        final List<Integer> list1 = Collections.unmodifiableList(
+                Arrays.asList(0, 1, 2, 3, 4)
+        );
+        final List<Integer> list2 = Collections.unmodifiableList(
+                Arrays.asList(1, 2, 3, 4, 5, 6)
+        );
+        final List<Integer> expected
+                = Arrays.asList(0, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6);
+        final List<Integer> actual = ListOps.concat(list1, list2);
+
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void shouldConcatenateSeveralLists() {
+        final List<Integer> list1 = Collections.unmodifiableList(
+                Arrays.asList(0, 1, 2, 3)
+        );
+        final List<Integer> list2 = Collections.unmodifiableList(
+                Arrays.asList(4, 5, 6, 7)
+        );
+        final List<Integer> list3 = Collections.unmodifiableList(
+                Arrays.asList(8, 9, 10, 11)
+        );
+        final List<Integer> list4 = Collections.unmodifiableList(
+                Arrays.asList(12, 13, 14, 15)
+        );
+        final List<Integer> expected
+                = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
+                        14, 15);
+
+        final List<Integer> actual
+                = ListOps.concat(list1, list2, EMPTY_LIST, list3, list4);
+
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void shouldReturnIdentityWhenAnEmptyListIsReduced() {
+        final int expected = 0;
+        final int actual
+                = ListOps.reduce(EMPTY_LIST, 0, (x, y) -> x + y, Integer::sum);
+
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void shouldCalculateTheSumOfANonEmptyIntegerList() {
+        final List<Integer> list = Collections.unmodifiableList(
+                Arrays.asList(0, 1, 2, 3, 4)
+        );
+        final int actual = ListOps.reduce(list, 0,
+                (x, y) -> x + y,
+                Integer::sum);
+
+        assertEquals(10, actual);
+    }
+
+    /*
+    https://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html
+    https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html#reduce-U-java.util.function.BiFunction-java.util.function.BinaryOperator-
+     */
+    private BiFunction<List<Integer>, Integer, List<Integer>> accumulator
+            = (List<Integer> partial, Integer elem) -> {
+                List<Integer> result = new ArrayList<>(partial);
+                result.add(elem);
+                return result;
+            };
+
+    private BinaryOperator<List<Integer>> combiner
+            = (list1, list2) -> {
+                List<Integer> result = new ArrayList<>(list1);
+                result.addAll(list2);
+                return result;
+            };
+
+    @Test
+    @Ignore
+    public void shouldReduceAnEmptyListAndANonEmptyListAndReturnConcatenation() {
+        final List<Integer> list = Collections.unmodifiableList(
+                Arrays.asList(0, 1, 2, 3, 4, 5)
+        );
+        final List<Integer> actual
+                = ListOps.reduce(list,
+                        new ArrayList<Integer>(),
+                        accumulator,
+                        combiner);
+        final List<Integer> expected
+                = Arrays.asList(0, 1, 2, 3, 4, 5);
+
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void shouldReduceTwoNonEmptyListsAndReturnConcatenation() {
+        final List<Integer> listOne = Collections.unmodifiableList(
+                Arrays.asList(0, 1, 2, 3, 4)
+        );
+        final List<Integer> listTwo = Collections.unmodifiableList(
+                Arrays.asList(5, 6, 7, 8, 9)
+        );
+        final List<Integer> actual
+                = ListOps.reduce(listTwo,
+                        listOne,
+                        accumulator,
+                        combiner);
+        final List<Integer> expected
+                = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(expected, actual);
+    }
+
+}