- fix on OrderBy: no longer creating a unnecessary IterableStream

- unit tests now with 100% code coverage

Author: brunovinicius

src/main/java/br/com/zbra/androidlinq/AbstractStream.java

@@ -7,8 +7,6 @@
 import java.math.BigDecimal;
 import java.util.*;
 
-import static br.com.zbra.androidlinq.Linq.stream;
-
 abstract class AbstractStream<T> implements Stream<T> {
 
     protected Iterator<T> reverseIterator() {
@@ -54,7 +52,7 @@ public <R extends Comparable<R>> Stream<T> orderBy(Selector<T, R> keySelector) {
 
     @Override
     public <R> Stream<T> orderByDescending(Selector<T, R> keySelector, Comparator<R> comparator) {
-        return stream(new OrderByDescendingStream<>(this, keySelector, comparator));
+        return new OrderByDescendingStream<>(this, keySelector, comparator);
     }
 
     @Override

src/main/java/br/com/zbra/androidlinq/IterableStream.java

@@ -1,8 +1,6 @@
 package br.com.zbra.androidlinq;
 
-import java.util.ArrayList;
 import java.util.Iterator;
-import java.util.List;
 
 class IterableStream<T> extends AbstractStream<T> {
 

src/main/java/br/com/zbra/androidlinq/Linq.java

@@ -8,7 +8,9 @@
  */
 public final class Linq {
 
-    private Linq() { }
+    private Linq() {
+        throw new UnsupportedOperationException();
+    }
 
     /**
      * Decorates the passed {@code iterable} with a Stream.

src/main/java/br/com/zbra/androidlinq/ListStream.java

@@ -2,7 +2,6 @@
 
 import java.util.Iterator;
 import java.util.List;
-import java.util.ListIterator;
 
 
 class ListStream<T> extends AbstractStream<T> {

src/main/java/br/com/zbra/androidlinq/MapStream.java

@@ -1,9 +1,7 @@
 package br.com.zbra.androidlinq;
 
 import java.util.Iterator;
-import java.util.LinkedList;
 import java.util.Map;
-import java.util.SortedSet;
 
 public class MapStream<K, V> extends AbstractStream<Map.Entry<K, V>> {
 

src/test/groovy/br/com/zbra/androidlinq/LinqTest.groovy

@@ -1,8 +1,19 @@
 package br.com.zbra.androidlinq
 
+import java.lang.reflect.Constructor
+
 import static br.com.zbra.androidlinq.Linq.stream
 
 class LinqTest extends GroovyTestCase {
+
+    void testConstructor() {
+        Constructor<Linq> constructor = Linq.class.getDeclaredConstructor();
+        constructor.setAccessible(true);
+        shouldFailWithCause(UnsupportedOperationException.class, {
+            constructor.newInstance();
+        });
+    }
+
     void testArrayStream() {
         def array = 0..9 as int[]
         def arrayStream = stream(array)
@@ -50,5 +61,9 @@ class LinqTest extends GroovyTestCase {
 
         assert stream(new HashMap<String, Integer>()).toList() == []
         assert stream(new HashMap<String, Integer>()).reverse().toList() == []
+
+        assert stream(map).count() == map.size()
+        assert stream(new HashMap<String, Integer>()).count() == 0
+
     }
 }

src/test/groovy/br/com/zbra/androidlinq/StreamTest.groovy

@@ -20,6 +20,8 @@ class StreamTest extends GroovyTestCase {
 
         assert integers.collect { it * 2 } == stream.toList()
         assert integers.reverse().collect { it * 2 } == stream.reverse().toList()
+
+        assert integers.size() == stream.count()
     }
 
     void testSelectMany() {
@@ -71,9 +73,10 @@ class StreamTest extends GroovyTestCase {
         assert result.get(1).elements.toList() == [1, 3, 5, 7, 9]
 
         // groupBy with key and element selectors
-        result = stream(integers)
+        def groupByStream = stream(integers)
                 .groupBy(keySelector, elementSelector)
-                .toList()
+
+        result = groupByStream.toList()
 
         assert result.size() == 2
 
@@ -82,6 +85,14 @@ class StreamTest extends GroovyTestCase {
 
         assert result.get(1).key == "Odd"
         assert result.get(1).elements.toList() == [10, 30, 50, 70, 90]
+
+        // test reverse
+        def reverseResult = groupByStream.reverse().toList()
+        assert reverseResult.get(0).key == "Odd"
+        assert reverseResult.get(0).elements.toList() == [10, 30, 50, 70, 90]
+
+        assert reverseResult.get(1).key == "Even"
+        assert reverseResult.get(1).elements.toList() == [00, 20, 40, 60, 80]
     }
 
     void testOrderBy() {
@@ -104,6 +115,13 @@ class StreamTest extends GroovyTestCase {
                         .orderBy({ n -> n }, { n1, n2 -> n1 - n2 })
                         .toList()
 
+
+        // orderBy count()
+        assert shuffledItems.size() ==
+                stream(shuffledItems)
+                        .orderBy({ n -> n }, { n1, n2 -> n1 - n2 })
+                        .count()
+
         // orderBy descending
         assert integersDescending ==
                 stream(shuffledItems)
@@ -150,6 +168,10 @@ class StreamTest extends GroovyTestCase {
         assert stream(integers).take(10).toList().size() == 10
         // takes 100 items (get all items)
         assert stream(integers).take(100).toList().size() == 10
+        // takes 5 and count
+        assert stream(integers).take(5).count() == 5
+        // takes 5 and reverses
+        assert stream(integers).take(5).reverse().toList() == [4, 3, 2, 1, 0]
     }
 
     void testSkip() {
@@ -170,6 +192,10 @@ class StreamTest extends GroovyTestCase {
         assert stream(integers).skip(10).toList().size() == 0
         // skips 100 items (more than present in the collection)
         assert stream(integers).skip(100).toList().size() == 0
+        // skips 5 and count
+        assert stream(integers).skip(5).count() == 5
+        // skips 5 and reverses
+        assert stream(integers).skip(5).reverse().toList() == [9, 8, 7, 6, 5]
     }
 
     void testDistinct() {
@@ -379,4 +405,12 @@ class StreamTest extends GroovyTestCase {
         assert stream([]).toMap(keySelector).isEmpty()
         assert stream([]).toMap(keySelector, elementSelector).isEmpty()
     }
+
+    void testReverse() {
+        def integers = 0..9
+
+        assert integers ==
+                stream(integers).reverse().reverse().toList()
+    }
 }
+