list-ops: update test and version file (exercism#1730)

lemoncurry · FridaTveit · commit d59537b60e1a · 2019-09-09T12:10:47.000+01:00
* list-ops: update test and version file closes exercism#1677 * ListOpsTest fix * update ListOpsTest.java
diff --git a/exercises/list-ops/.meta/version b/exercises/list-ops/.meta/version
@@ -1 +1 @@
-2.3.0
+2.4.0
diff --git a/exercises/list-ops/src/test/java/ListOpsTest.java b/exercises/list-ops/src/test/java/ListOpsTest.java
@@ -13,31 +13,35 @@ public class ListOpsTest {
     public void testAppendingEmptyLists() {
         assertEquals(
                 Collections.emptyList(),
-                ListOps.append(Collections.emptyList(), Collections.emptyList()));
+                ListOps.append(Collections.emptyList(), Collections.emptyList())
+        );
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testAppendingNonEmptyListOnEmptyList() {
         assertEquals(
                 Arrays.asList('1', '2', '3', '4'),
-                ListOps.append(Collections.emptyList(), Arrays.asList('1', '2', '3', '4')));
+                ListOps.append(Collections.emptyList(), Arrays.asList('1', '2', '3', '4'))
+        );
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testAppendingNonEmptyListOnNonEmptyList() {
         assertEquals(
                 Arrays.asList("1", "2", "2", "3", "4", "5"),
-                ListOps.append(Arrays.asList("1", "2"), Arrays.asList("2", "3", "4", "5")));
+                ListOps.append(Arrays.asList("1", "2"), Arrays.asList("2", "3", "4", "5"))
+        );
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testConcatOnEmptyListOfLists() {
         assertEquals(
                 Collections.emptyList(),
-                ListOps.concat(Collections.emptyList()));
+                ListOps.concat(Collections.emptyList())
+        );
     }
 
     @Ignore("Remove to run test")
@@ -47,11 +51,13 @@ public void testConcatOnNonEmptyListOfLists() {
                 Arrays.asList('1', '2'),
                 Collections.singletonList('3'),
                 Collections.emptyList(),
-                Arrays.asList('4', '5', '6'));
+                Arrays.asList('4', '5', '6')
+        );
 
         assertEquals(
                 Arrays.asList('1', '2', '3', '4', '5', '6'),
-                ListOps.concat(listOfLists));
+                ListOps.concat(listOfLists)
+        );
     }
 
     @Ignore("Remove to run test")
@@ -90,15 +96,17 @@ public void testConcatOnNonEmptyListOfNestedLists() {
     public void testFilteringEmptyList() {
         assertEquals(
                 Collections.emptyList(),
-                ListOps.filter(Collections.<Integer>emptyList(), integer -> integer % 2 == 1));
+                ListOps.filter(Collections.<Integer>emptyList(), integer -> integer % 2 == 1)
+        );
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testFilteringNonEmptyList() {
         assertEquals(
                 Arrays.asList(1, 3, 5),
-                ListOps.filter(Arrays.asList(1, 2, 3, 5), integer -> integer % 2 == 1));
+                ListOps.filter(Arrays.asList(1, 2, 3, 5), integer -> integer % 2 == 1)
+        );
     }
 
     @Ignore("Remove to run test")
@@ -118,15 +126,17 @@ public void testSizeOfNonEmptyList() {
     public void testTransformingEmptyList() {
         assertEquals(
                 Collections.emptyList(),
-                ListOps.map(Collections.<Integer>emptyList(), integer -> integer + 1));
+                ListOps.map(Collections.<Integer>emptyList(), integer -> integer + 1)
+        );
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testTransformingNonEmptyList() {
         assertEquals(
                 Arrays.asList(2, 4, 6, 8),
-                ListOps.map(Arrays.asList(1, 3, 5, 7), integer -> integer + 1));
+                ListOps.map(Arrays.asList(1, 3, 5, 7), integer -> integer + 1)
+        );
     }
 
     @Ignore("Remove to run test")
@@ -137,7 +147,9 @@ public void testFoldLeftOnEmptyList() {
                 ListOps.foldLeft(
                     Collections.<Double>emptyList(),
                     2.0,
-                    (x, y) -> x * y));
+                    (x, y) -> x * y
+                )
+        );
     }
 
     @Ignore("Remove to run test")
@@ -148,7 +160,9 @@ public void testFoldLeftWithDirectionIndependentOperationOnNonEmptyList() {
                 ListOps.foldLeft(
                     Arrays.asList(1, 2, 3, 4),
                     5,
-                    (x, y) -> x + y));
+                    (x, y) -> x + y
+                )
+        );
     }
 
     @Ignore("Remove to run test")
@@ -159,7 +173,9 @@ public void testFoldLeftWithDirectionDependentOperationOnNonEmptyList() {
                 ListOps.foldLeft(
                     Arrays.asList(2, 5),
                     5,
-                    (x, y) -> x / y));
+                    (x, y) -> x / y
+                )
+        );
     }
 
     @Ignore("Remove to run test")
@@ -170,7 +186,9 @@ public void testFoldRightOnEmptyList() {
                 ListOps.foldRight(
                     Collections.<Double>emptyList(),
                     2.0,
-                    (x, y) -> x * y));
+                    (x, y) -> x * y
+                )
+        );
     }
 
     @Ignore("Remove to run test")
@@ -181,7 +199,9 @@ public void testFoldRightWithDirectionIndependentOperationOnNonEmptyList() {
                 ListOps.foldRight(
                     Arrays.asList(1, 2, 3, 4),
                     5,
-                    (x, y) -> x + y));
+                    (x, y) -> x + y
+                )
+        );
     }
 
     @Ignore("Remove to run test")
@@ -192,23 +212,48 @@ public void testFoldRightWithDirectionDependentOperationOnNonEmptyList() {
                 ListOps.foldRight(
                     Arrays.asList(2, 5),
                     5,
-                    (x, y) -> x / y));
+                    (x, y) -> x / y
+                )
+        );
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testReversingEmptyList() {
         assertEquals(
                 Collections.emptyList(),
-                ListOps.reverse(Collections.emptyList()));
+                ListOps.reverse(Collections.emptyList())
+        );
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testReversingNonEmptyList() {
         assertEquals(
                 Arrays.asList('7', '5', '3', '1'),
-                ListOps.reverse(Arrays.asList('1', '3', '5', '7')));
+                ListOps.reverse(Arrays.asList('1', '3', '5', '7'))
+        );
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testListOfListIsNotFlattened() {
+        List<List<Character>> listOfLists = Arrays.asList(
+                Arrays.asList('1', '2'),
+                Collections.singletonList('3'),
+                Collections.emptyList(),
+                Arrays.asList('4', '5', '6')
+        );
+
+        assertEquals(
+                Arrays.asList(
+                        Arrays.asList('4', '5', '6'),
+                        Collections.emptyList(),
+                        Collections.singletonList('3'),
+                        Arrays.asList('1', '2')
+                ),
+                ListOps.reverse(listOfLists)
+        );
     }
 
 }
