Added all tests

Author: alemazzo

stream/iterators.py

@@ -21,8 +21,8 @@ def generate(generator):
 
     @staticmethod
     def concat(*iterables):
-        for iterator in iterables:
-            for elem in iterator:
+        for iterable in iterables:
+            for elem in iterable.iterator():
                 yield elem
 
     """

stream/stream.py

@@ -94,7 +94,7 @@ def concat(*streams):
         :param *Stream streams: the streams to concat
         :return: the concatenation of the input streams
         '''
-        return Stream(IteratorUtils.concat(streams))
+        return Stream(IteratorUtils.concat(*streams))
 
     """
     Normal Methods
@@ -196,7 +196,7 @@ def peek(self, consumer):
         :param Consumer consumer: action to perform on the elements as they are consumed from the stream
         :return: the new stream
         '''
-        return Stream(IteratorUtils.peek(self.__iterable, function))
+        return Stream(IteratorUtils.peek(self.__iterable, consumer))
 
     def forEach(self, function):
         '''
@@ -301,7 +301,11 @@ def count(self):
 
         :return: the count of elements in this stream
         '''
-        return len(self.__iterable)
+        count = 0
+        for elem in self.__iterable:
+            count += 1
+
+        return count
 
     def toList(self):
         '''
@@ -326,3 +330,6 @@ def iterator(self):
         :return: the iterator over the elements in this stream
         '''
         return self.__iterable
+
+    def __eq__(self, value):
+        return self.__iterable == value.__iterable

test.py

@@ -9,14 +9,134 @@ def test_empty(self):
         self.assertEqual(s.count(), 0)
 
     def test_of(self):
+
         s = Stream.of(1, 2, 3)
+
         self.assertEqual(s.count(), 3)
         self.assertTrue(s.findAny().isPresent())
         self.assertEqual(s.findAny().get(), 1)
 
-    def test_sum(self):
-        self.assertTrue(Stream.of(1, 2, 3, 4).sum().isPresent())
-        self.assertEqual(Stream.of(1, 2, 3, 4).sum().get(), 10)
+        self.assertEqual(Stream.ofNullable(None), Stream.empty())
+
+        self.assertEqual(Stream.of(), Stream.empty())
+
+    def test_iterate(self):
+        index = 0
+        s = Stream.iterate(index, lambda i: i + 1).iterator()
+
+        for elem in s:
+            self.assertEqual(elem, index)
+            index += 1
+            if index == 10:
+                break
+
+    def test_generate(self):
+        index = 0
+        s = Stream.generate(lambda: 1).iterator()
+
+        for elem in s:
+            self.assertEqual(elem, 1)
+            index += 1
+            if index == 10:
+                break
+
+    def test_concat(self):
+        s = Stream.concat(Stream.of(1, 2, 3), Stream.of(
+            4, 5, 6)).toList()
+        self.assertEqual(s, [1, 2, 3, 4, 5, 6])
+
+    def test_filter(self):
+        s = Stream.of(1, 2, 3, 4).filter(lambda x: x % 2 == 0).toList()
+        self.assertEqual(s, [2, 4])
+
+    def test_map(self):
+        s = Stream.of(1, 2, 3).map(lambda x: x**2).toList()
+        self.assertEqual(s, [1, 4, 9])
+
+    def test_flatMap(self):
+        s = Stream.of(1, 2, 3).flatMap(lambda x: Stream.of(x, x)).toList()
+        self.assertEqual(s, [1, 1, 2, 2, 3, 3])
+
+    def test_distinct(self):
+        s = Stream.of(1, 1, 2, 2, 3, 4)
+        self.assertEqual(s.distinct().toList(), [1, 2, 3, 4])
+
+    def test_limit(self):
+        s = Stream.iterate(0, lambda i: i + 1).limit(5).toList()
+        self.assertEqual(s, [0, 1, 2, 3, 4])
+
+    def test_skip(self):
+        s = Stream.of(1, 2, 3, 4, 5, 6).skip(3).toList()
+        self.assertEqual(s, [4, 5, 6])
+
+    def test_takeWhile(self):
+        s = Stream.of(1, 2, 3, 4, 5, 6).takeWhile(lambda x: x != 4).toList()
+        self.assertEqual(s, [1, 2, 3])
+
+    def test_dropWhile(self):
+        s = Stream.of(1, 2, 3, 4, 5, 6).dropWhile(lambda x: x != 4).toList()
+        self.assertEqual(s, [4, 5, 6])
+
+    def test_sorted(self):
+        s = Stream.of(1, 2, 5, 4, 3).sorted().toList()
+        s2 = Stream.of(1, 2, 3, 4, 5).sorted(lambda x, y: y-x).toList()
+
+        self.assertEqual(s, [1, 2, 3, 4, 5])
+        self.assertEqual(
+            s2, [5, 4, 3, 2, 1])
+
+    def test_peek(self):
+        self.count = 0
+
+        def inc(*args):
+            self.count += 1
+
+        s = Stream.of(1, 2, 3).peek(inc)
+        self.assertEqual(self.count, 0)
+
+        s = s.toList()
+        self.assertEqual(self.count, 3)
+
+    def test_forEach(self):
+        self.count = 0
+
+        def inc(*args):
+            self.count += 1
+
+        s = Stream.of(1, 2, 3).forEach(inc)
+        self.assertEqual(self.count, 3)
+
+    def test_anyMatch(self):
+        self.assertTrue(Stream.of(1, 2, 3).anyMatch(lambda x: x % 2 == 0))
+        self.assertFalse(
+            Stream.of(1, 3, 5, 7).anyMatch(lambda x: x % 2 == 0))
+
+    def test_allMatch(self):
+        self.assertTrue(Stream.of(2, 4, 6, 8).allMatch(lambda x: x % 2 == 0))
+        self.assertFalse(Stream.of(1, 2, 3, 4, 5).allMatch(lambda x: x < 5))
+
+    def test_noneMatch(self):
+        self.assertTrue(Stream.of(1, 2, 3, 4).noneMatch(lambda x: x > 4))
+        self.assertFalse(Stream.of(1, 2, 3, 4, 5).noneMatch(lambda x: x > 4))
+
+    def test_findFirst(self):
+        elem = Stream.of(1, 2, 3, 4, 5).findFirst()
+        self.assertTrue(elem.isPresent())
+        self.assertEqual(elem.get(), 1)
+
+    def test_findAny(self):
+        elem = Stream.of(1, 2, 3, 4, 5).findAny()
+        self.assertTrue(elem.isPresent())
+        self.assertIn(elem.get(), [1, 2, 3, 4, 5])
+
+    def test_reduce(self):
+        elem = Stream.of(1, 2, 3).reduce(lambda x, y: x - y)
+        self.assertTrue(elem.isPresent())
+        self.assertEqual(elem.get(), -4)
+
+        elem = Stream.of(1, 2, 3).reduce(lambda x, y: x - y, 0)
+        self.assertTrue(elem.isPresent())
+        self.assertEqual(elem.get(), -6)
 
     def test_min(self):
         s = Stream.of(1, 2, 5, 4, 3)
@@ -28,15 +148,14 @@ def test_max(self):
         self.assertTrue(s.max().isPresent())
         self.assertEqual(s.max().get(), 5)
 
-    def test_sorted(self):
-        s = Stream.of(1, 2, 5, 4, 3)
-        self.assertEqual(s.sorted().toList(), [1, 2, 3, 4, 5])
-        self.assertEqual(
-            s.sorted(lambda x, y: y - x).toList(), [5, 4, 3, 2, 1])
+    def test_sum(self):
+        self.assertTrue(Stream.of(1, 2, 3, 4).sum().isPresent())
+        self.assertEqual(Stream.of(1, 2, 3, 4).sum().get(), 10)
 
-    def test_distinct(self):
-        s = Stream.of(1, 1, 2, 2, 3, 4)
-        self.assertEqual(s.distinct().toList(), [1, 2, 3, 4])
+    def test_count(self):
+        self.assertEqual(Stream.of(1, 2, 3, 4).count(), 4)
+        self.assertEqual(Stream.empty().count(), 0)
+        self.assertEqual(Stream.generate(lambda: 1).limit(10).count(), 10)
 
 
 if __name__ == '__main__':

version

@@ -1 +1 @@
-10
+11