Updated Example Code for Vavr Collections

vavr/src/test/java/com/baeldung/vavr/collections/CollectionAPIUnitTest.java

@@ -30,16 +30,67 @@
 
 public class CollectionAPIUnitTest {
 
+
+    @Test
+    public void givenParams_whenListAPI_thenCorrect() {
+
+        List<String> list
+          = List.of("Java", "PHP", "Jquery", "JavaScript", "JShell", "JAVA");
+
+        List list1 = list.drop(2);
+        assertFalse(list1.contains("Java") && list1.contains("PHP"));
+
+        List list2 = list.dropRight(2);
+        assertFalse(list2.contains("JAVA") && list2.contains("JShell"));
+
+        List list3 = list.dropUntil(s -> s.contains("Shell"));
+        assertEquals(list3.size(), 2);
+
+        List list4 = list.dropWhile(s -> s.length() > 0);
+        assertTrue(list4.isEmpty());
+
+        List list5 = list.take(1);
+        assertEquals(list5.single(), "Java");
+
+        List list6 = list.takeRight(1);
+        assertEquals(list6.single(), "JAVA");
+
+        List list7 = list.takeUntil(s -> s.length() > 6);
+        assertEquals(list7.size(), 3);
+
+        List list8
+          = list.distinctBy( (s1, s2) -> s1.startsWith(s2.charAt(0)+"") ? 0 : 1);
+        assertEquals(list8.size(), 2);
+
+        Iterator<List<String>> iterator = list.grouped(2);
+        assertEquals(iterator.head().size(), 2);
+
+        Map<Boolean, List<String>> map = list.groupBy(e -> e.startsWith("J"));
+        assertEquals(map.size(), 2);
+        assertEquals(map.get(false).get().size(), 1);
+        assertEquals(map.get(true).get().size(), 5);
+
+        String words = List.of("Boys", "Girls")
+                         .intersperse("and")
+                         .reduce((s1, s2) -> s1.concat( " " + s2 ))
+                         .trim();
+
+        assertEquals(words, "Boys and Girls");
+
+    }
+
     @Test
-    public void givenEmptyList_whenStacked_thenCorrect() {
+    public void givenEmptyList_whenStackAPI_thenCorrect() {
+
         List<Integer> intList = List.empty();
 
-        List<Integer> anotherList = intList.push(4)
-          .push(0);
-        Iterator<Integer> iterator = anotherList.iterator();
+        List<Integer> intList1 = intList.pushAll(List.rangeClosed(5,10));
+
+        assertEquals(intList1.peek(), Integer.valueOf(10));
+
+        List intList2 = intList1.pop();
+        assertEquals(intList2.size(), (intList1.size() - 1) );
 
-        assertEquals(new Integer(0), iterator.next());
-        assertEquals(new Integer(4), iterator.next());
     }
 
     @Test
@@ -61,27 +112,33 @@ public void givenList_whenPrependTail_thenCorrect() {
 
     @Test
     public void givenQueue_whenEnqueued_thenCorrect() {
+
         Queue<Integer> queue = Queue.of(1, 2, 3);
-        Queue<Integer> secondQueue = queue.enqueue(4)
-          .enqueue(5);
+        Queue<Integer> secondQueue = queue.enqueueAll(List.of(4,5));
 
         assertEquals(3, queue.size());
         assertEquals(5, secondQueue.size());
 
         Tuple2<Integer, Queue<Integer>> result = secondQueue.dequeue();
-        Integer headValue = result.apply((head, tail) -> head);
-        assertEquals(new Integer(1), headValue);
-
-        Iterator<Integer> iterator = result.apply((head, tail) -> tail.iterator());
+        assertEquals(Integer.valueOf(1), result._1);
 
-        assertEquals(new Integer(2), iterator.next());
-        assertEquals(new Integer(3), iterator.next());
-        assertEquals(new Integer(4), iterator.next());
-        assertEquals(new Integer(5), iterator.next());
+        Queue<Integer> tailQueue = result._2;
+        assertFalse(tailQueue.contains(secondQueue.get(0)));
     }
 
     @Test
     public void givenStream_whenProcessed_thenCorrect() {
+
+        Stream<Integer> s1 = Stream.tabulate(5, (i)-> i + 1);
+        assertEquals(s1.get(2).intValue(), 3);
+
+        Stream<Integer> s = Stream.of(2,1,3,4);
+
+        Stream<Tuple2<Integer, Integer>> s2 = s.zip(List.of(7,8,9));
+        Tuple2<Integer, Integer> t1 = s2.get(0);
+        assertEquals(t1._1().intValue(), 2);
+        assertEquals(t1._2().intValue(), 7);
+
         Stream<Integer> intStream = Stream.iterate(0, i -> i + 1)
           .take(10);
 
@@ -92,7 +149,6 @@ public void givenStream_whenProcessed_thenCorrect() {
           .longValue();
 
         assertEquals(20, evenSum);
-        assertEquals(new Integer(5), intStream.get(5));
     }
 
     @Test
@@ -102,11 +158,12 @@ public void givenArray_whenQueried_thenCorrect() {
 
         assertEquals(3, intArray.size());
         assertEquals(2, newArray.size());
+        assertEquals(3, newArray.get(1).intValue());
+
+        Array<Integer> array2 = intArray.replace(1, 5);
+        assertEquals(array2.get(0).intValue(), 5);
+
 
-        assertEquals(new Integer(1), intArray.get(0));
-        assertEquals(new Integer(2), intArray.get(1));
-        assertEquals(new Integer(3), intArray.get(2));
-        assertEquals(new Integer(3), newArray.get(1));
     }
 
     @Test
@@ -117,10 +174,8 @@ public void givenVector_whenQueried_thenCorrect() {
         assertEquals(4, intVector.size());
         assertEquals(4, newVector.size());
 
-        assertEquals(new Integer(1), intVector.get(0));
-        assertEquals(new Integer(2), intVector.get(1));
-        assertEquals(new Integer(3), intVector.get(2));
-        assertEquals(new Integer(6), newVector.get(1));
+        assertEquals(2, intVector.get(1).intValue());
+        assertEquals(6, newVector.get(1).intValue());
     }
 
     @Test
@@ -143,57 +198,46 @@ public void givenHashSet_whenModified_thenCorrect() {
 
         assertEquals(3, set.size());
         assertEquals(4, newSet.size());
-        assertFalse(set.contains("Yellow"));
         assertTrue(newSet.contains("Yellow"));
     }
 
     @Test
     public void givenSortedSet_whenIterated_thenCorrect() {
         SortedSet<String> set = TreeSet.of("Red", "Green", "Blue");
+        assertEquals("Blue", set.head());
 
-        Iterator<String> iterator = set.iterator();
-        assertEquals("Blue", iterator.next());
-        assertEquals("Green", iterator.next());
-        assertEquals("Red", iterator.next());
+        SortedSet<Integer> intSet = TreeSet.of(1,2,3);
+        assertEquals(2, intSet.average().get().intValue());
+
     }
 
     @Test
     public void givenSortedSet_whenReversed_thenCorrect() {
-        SortedSet<String> set = TreeSet.of(Comparator.reverseOrder(), "Green", "Red", "Blue");
+        SortedSet<String> reversedSet
+          = TreeSet.of(Comparator.reverseOrder(), "Green", "Red", "Blue");
+        assertEquals("Red", reversedSet.head());
 
-        Iterator<String> iterator = set.iterator();
-        assertEquals("Red", iterator.next());
-        assertEquals("Green", iterator.next());
-        assertEquals("Blue", iterator.next());
+        String str = reversedSet.mkString(" and ");
+        assertEquals("Red and Green and Blue", str);
     }
 
     @Test
     public void givenMap_whenIterated_thenCorrect() {
         Map<Integer, List<Integer>> map = List.rangeClosed(0, 10)
           .groupBy(i -> i % 2);
-
+        
         assertEquals(2, map.size());
-
-        Iterator<Tuple2<Integer, List<Integer>>> iterator = map.iterator();
-        assertEquals(6, iterator.next()
-          ._2()
-          .size());
-        assertEquals(5, iterator.next()
-          ._2()
-          .size());
+        assertEquals(6, map.get(0).get().size());
+        assertEquals(5, map.get(1).get().size());
     }
 
     @Test
     public void givenTreeMap_whenIterated_thenCorrect() {
-        SortedMap<Integer, String> map = TreeMap.of(3, "Three", 2, "Two", 4, "Four", 1, "One");
-
-        Iterator<Tuple2<Integer, String>> iterator = map.iterator();
-        assertEquals(new Integer(1), iterator.next()
-          ._1());
-        assertEquals(new Integer(2), iterator.next()
-          ._1());
-        assertEquals(new Integer(3), iterator.next()
-          ._1());
+        SortedMap<Integer, String> map
+          = TreeMap.of(3, "Three", 2, "Two", 4, "Four", 1, "One");
+
+        assertEquals(1, map.keySet().toJavaArray()[0]);
+        assertEquals("Four", map.get(4).get());
     }
 
     @Test
@@ -202,14 +246,13 @@ public void givenJavaList_whenConverted_thenCorrect() {
         List<Integer> vavrList = List.ofAll(javaList);
 
         assertEquals(4, vavrList.size());
-        assertEquals(new Integer(1), vavrList.head());
+        assertEquals(1, vavrList.head().intValue());
 
         java.util.stream.Stream<Integer> javaStream = javaList.stream();
         Set<Integer> vavrSet = HashSet.ofAll(javaStream);
 
         assertEquals(4, vavrSet.size());
-        assertEquals(new Integer(2), vavrSet.tail()
-          .head());
+        assertEquals(2, vavrSet.tail().head().intValue());
     }
 
     @Test
@@ -220,7 +263,7 @@ public void givenJavaStream_whenCollected_thenCorrect() {
           .collect(List.collector());
 
         assertEquals(4, vavrList.size());
-        assertEquals(new Integer(2), vavrList.head());
+        assertEquals(2, vavrList.head().intValue());
     }
 
     @Test
@@ -231,7 +274,7 @@ public void givenVavrList_whenConverted_thenCorrect() {
 
         java.util.Map<String, Integer> map = List.of("1", "2", "3")
           .toJavaMap(i -> Tuple.of(i, Integer.valueOf(i)));
-        assertEquals(new Integer(2), map.get("2"));
+        assertEquals(2, map.get("2").intValue());
     }
 
     @Test
@@ -240,8 +283,7 @@ public void givenVavrList_whenCollected_thenCorrect() {
           .collect(Collectors.toSet());
 
         assertEquals(3, javaSet.size());
-        assertEquals(new Integer(1), javaSet.iterator()
-          .next());
+        assertEquals(1, javaSet.toArray()[0]);
     }
 
     @Test
@@ -250,15 +292,15 @@ public void givenVavrList_whenConvertedView_thenCorrect() {
           .asJavaMutable();
         javaList.add(4);
 
-        assertEquals(new Integer(4), javaList.get(3));
+        assertEquals(4, javaList.get(3).intValue());
     }
 
     @Test(expected = UnsupportedOperationException.class)
     public void givenVavrList_whenConvertedView_thenException() {
         java.util.List<Integer> javaList = List.of(1, 2, 3)
           .asJava();
 
-        assertEquals(new Integer(3), javaList.get(2));
+        assertEquals(3, javaList.get(2).intValue());
         javaList.add(4);
     }