Stream.generate unit tests

lib/fromarray.rb

@@ -73,7 +73,7 @@ def map(&function)
     # Skip the first n elements of the stream.
     # +count+:: Number of elements to skip from the beginning of the stream.
     def skip(count)
-      raise ArgumentError, 'count has to be positive' unless count.positive?
+      raise ArgumentError, 'count has to be positive integer' unless count.positive? and count.is_a? Integer
 
       skipped = []
       @array.each_with_index do |val, index|

lib/stream.rb

@@ -40,20 +40,11 @@ def self.from_array(array)
   # Generate a Stream based on a seed function.
   # Since this would be an infinite Stream, a limit has to be applied.
   # If no limit is specified, the default is 100 elements.
-  def self.generate(&seed)
-    Stream.generate(100, &seed)
-  end
-
-  # Generate a Stream based on a seed function.
-  # Since this would be an infinite Stream, a limit has to be applied.
-  # If no limit is specified, the default is 100 elements.
-  def self.generate(limit, &seed)
-    raise ArgumentError, 'limit has to be positive' unless count.positive?
+  def self.generate(limit = 100, &seed)
+    raise ArgumentError, 'limit has to be a positive integer' unless limit.positive? and limit.is_a? Integer
 
     elements = []
-    limit.times do
-      elements.push(seed.call)
-    end
+    limit.times { elements.push(seed.call) }
     FromArray.new(elements)
   end
 end

test/fromarray_test.rb

@@ -66,14 +66,30 @@ def test_skip_argument_error_count_negative
       stream = FromArray.new([1, 2, 3])
       begin
         stream.skip(-1)
+        assert(false, 'Exception was expected!')
       rescue ArgumentError => e
         assert(
-          e.message == 'count has to be positive',
+          e.message == 'count has to be positive integer',
           'Unexpected ArgumentError message!'
         )
       end
     end
 
+    # FromArray raises ArgumentError if the given count to skip
+    # is positive but not an integer.
+    def test_skip_argument_error_count_not_integer
+      stream = FromArray.new([1, 2, 3])
+      begin
+        stream.skip(2.23)
+        assert(false, 'Exception was expected!')
+      rescue ArgumentError => e
+        assert(
+            e.message == 'count has to be positive integer',
+            'Unexpected ArgumentError message!'
+        )
+      end
+    end
+
     # FromArray returns self after skipping some elements.
     def test_skip_returns_self
       stream = FromArray.new([1, 2, 3])

test/stream_test.rb

@@ -30,5 +30,49 @@ class StreamTest < Minitest::Test
     def test_that_from_array_works
       refute_nil Stream.from_array([1, 2, 3])
     end
+
+    # A Stream can be generated with the default limit of 100.
+    def test_generates_hundred_elements
+      assert(
+        Stream.generate { 1 }.count == 100,
+        'Default size of a generated Stream should be 100'
+      )
+    end
+
+    # A Stream can be generated with a specified limit.
+    def test_generates_with_limit
+      assert(
+        Stream.generate(15) { 1 }.count == 15,
+        'Default size of a generated Stream should be 100'
+      )
+    end
+
+    # Stream.generate should throw an exception if the given limit is
+    # not a positive integer.
+    def test_generates_with_negative_limit
+      begin
+        Stream.generate(-1) { 1 }
+        assert(false, 'Exception was expected!')
+      rescue ArgumentError => e
+        assert(
+          e.message == 'limit has to be a positive integer',
+          'Unexpected ArgumentError message!'
+        )
+      end
+    end
+
+    # Stream.generate should throw an exception if the given limit is not
+    # a positive integer.
+    def test_generates_with_rational_limit
+      begin
+        Stream.generate(2.23) { 1 }
+        assert(false, 'Exception was expected!')
+      rescue ArgumentError => e
+        assert(
+          e.message == 'limit has to be a positive integer',
+          'Unexpected ArgumentError message!'
+        )
+      end
+    end
   end
 end