facets 2.9.3 → 3.0.0

data/test/core/array/test_arrange.rb

@@ -0,0 +1,37 @@
+require 'facets/array/arrange'
+
+test_case Array do
+
+	method :rangify do
+		test 'Array of consecutive integers should return an array made up of a single range.' do
+			[1,2,3,4,5].rangify.assert == [1..5]
+		end
+		
+		test 'Array of non-consecutive integers should return the original array.' do
+			[1,3,5,7].rangify.assert == [1,3,5,7]
+		end
+
+		test 'Array of ranges should return the correct ranges.' do
+			arr = [40..45, 1..3, 4..10, 20..30, 24..28, 42..50, 1..6, 1..3, 1..1]
+			arr.rangify.assert == [1..10, 20..30, 40..50]
+		end
+		
+		test 'Array of ranges and integers should return the correct ranges.' do
+			arr = [99, 100, 1..3, 101, 4..5, 103, 10..19, 99, 20..20, 31, 32..33, 98, 97]
+			arr.rangify.assert == [1..5, 10..20, 31..33, 97..101, 103]
+		end	
+
+		test 'Array of non-consecutive integers should return the correct ranges.' do
+			[1,2,3,6,7,8,10,15].rangify.assert == [1..3, 6..8, 10, 15] 
+		end
+	
+		test 'Element order should not affect the result.' do
+			[8, 1, 15, 2, 6, 3, 7, 10].rangify.assert == [1..3, 6..8, 10, 15] 
+		end
+		
+		test 'Duplicate elements should not affect the result.' do
+			[8, 1, 15, 2, 6, 3, 7, 10, 8, 15, 2, 3, 1, 2].rangify.assert == [1..3, 6..8, 10, 15] 
+		end
+	end
+
+end

data/test/core/array/test_each_overlap.rb

@@ -0,0 +1,31 @@
+covers 'facets/array/each_overlap'
+
+test_case Array do
+
+  method :each_overlap do
+
+    test do
+      a = [1,2,3,4,5]
+      r = []
+      a.each_overlap(2,1) { |x| r << x } 
+      r.assert == [[1,2],[2,3],[3,4],[4,5]]
+    end
+
+    test do
+      a = [1,2,3,4,5,6,7]
+      r = []
+      a.each_overlap(3,1) { |x| r << x } 
+      r.assert == [[1,2,3],[3,4,5],[5,6,7]]
+    end
+
+    test do
+      a = [1,2,3,4,5]
+      r = []
+      a.each_overlap(3,2) { |x| r << x } 
+      r.assert == [[1,2,3],[2,3,4],[3,4,5]]
+    end
+
+  end
+
+end
+

data/test/core/array/test_intersection.rb

@@ -0,0 +1,19 @@
+require 'facets/array/intersection'
+
+test_case Array do
+
+	method :intersection do
+		test { [1, 2].intersection.assert == nil }
+		test { [1..10, 11..20].intersection.assert == nil }
+		test { [1..10, 5..15, 11..20].intersection.assert == nil }
+		test { [8..8, 1..10, 10 ].intersection.assert == nil }
+		test { [10, 1..10].intersection.assert == 10 }
+		test { [1..10, 1].intersection.assert == 1 }
+		test { [1, 1].intersection.assert == 1 }
+		test { [1..10, 5, 5..8, 5..10 ].intersection.assert == 5 }
+		test { [1..10, 5..8, 5..10 ].intersection.assert == (5..8) }
+		test { [5..10, 1..10, 4..8 ].intersection.assert == (5..8) }
+		test { [5..10, 1..10, 4..20, 8].intersection.assert == 8 }
+	end
+
+end

data/test/core/array/test_missing.rb

@@ -0,0 +1,12 @@
+require 'facets/array/missing'
+
+test_case Array do
+
+	method :missing do
+		test { [1,3..3].missing.assert == [2] }
+		test { [1..5,10..12].missing.assert == [6..9] }
+		test { [100, 9..11, 14, 1..5, 16, 10..12, 17..17].missing.assert == [6..8, 13, 15, 18..99] }
+	end
+
+end
+

data/test/core/array/test_occur.rb

@@ -0,0 +1,52 @@
+covers 'facets/array/occur'
+
+test_case Array do
+
+  method :occur do
+
+    test "set limit" do
+      a = [1,2,3,4,5,
+             2,3,4,5,
+               3,4,5,
+                 4,5,
+                   5]  
+      (1..5).each do |m|
+        d = a.occur(m)
+        d.assert == [m]
+      end
+    end
+
+    test "range" do
+      a = %w{a b c d e
+               b c d e
+                 c d e
+                   d e
+                     e}
+      a.occur(1..2).sort.assert == ['a','b']
+      a.occur(1..3).sort.assert == ['a','b','c']
+      a.occur(2..3).sort.assert == ['b','c']
+    end
+
+    test do
+      a = [:a,:b,:a]
+      a.occur(1).assert == [:b]
+    end
+
+    test do
+      a = [:a,:b,:a]
+      a.occur(2).assert == [:a]
+    end
+
+    test do
+      a = [:a,:b,:a]
+      a.occur(1..1).assert == [:b]
+    end
+
+    test do
+      a = [:a,:b,:a]
+      a.occur{ |n| n % 2 == 0 }.assert == [:a]
+    end
+
+  end
+
+end

data/test/core/array/test_occurrence.rb

@@ -0,0 +1,20 @@
+covers 'facets/array/occurrence'
+
+test_case Array do
+
+  method :occurrence do
+
+    test "no arguments" do
+      r = [:a,:a,:b,:c,:c,:c].occurrence
+      r.assert == { :a => 2, :b => 1, :c => 3 } 
+    end
+  
+    test "with block" do
+      r = [2,2,3,4,4,4].occurrence{|i| i % 2} 
+      r.assert == { 0 => 5, 1 => 1 }
+    end
+
+  end
+
+end
+

data/test/core/array/test_reject_values.rb

@@ -0,0 +1,17 @@
+covers 'facets/array/reject_values'
+
+testcase Array do
+
+  method :reject_values do
+
+    test do
+      a = [1,2,3,4,5]
+      r = a.reject_values(2,4)
+      r.assert == [1,3,5]
+      a.assert = [1,2,3,4,5]  # hasn't changed
+    end
+
+  end
+
+end
+

data/test/core/array/test_squeeze.rb

@@ -0,0 +1,22 @@
+covers 'facets/array/squeeze'
+
+test_case Array do
+
+  method :squeeze! do
+
+    test 'default' do
+      a = [1,2,2,3,3,2,1]
+      a.squeeze!
+      a.assert == [1,2,3,2,1]
+    end
+
+    test 'with argument' do
+      a = [1,2,2,3,3,2,1]
+      a.squeeze!(*[3])
+      a.assert == [1,2,2,3,2,1]
+    end
+
+  end
+
+end
+

data/test/core/array/test_step.rb

@@ -0,0 +1,28 @@
+covers 'facets/array/step.rb'
+
+test_case Array do
+
+  method :step do
+
+    test "iteration" do
+      a = [:a, :b, :c, :d]
+      r = []
+
+      a.step(2){ |e| r << e }
+
+      r.assert == [:b, :d]
+    end
+
+    test "conversion to array" do
+      a = [:a, :b, :c, :d]
+      a.step(1).to_a.assert == [:a, :b, :c, :d]
+      a.step(2).to_a.assert == [:b, :d]
+      a.step(3).to_a.assert == [:c]
+      a.step(5).to_a.assert == []
+    end
+
+  end
+
+end
+
+

data/test/core/array/test_unique_permutation.rb

@@ -0,0 +1,23 @@
+covers 'facets/array/unique_permutation'
+
+test_case Array do
+
+  method :unique_permutation do
+
+    test 'example' do
+      [1,1,2,2,3].unique_permutation(2).to_a.assert == [
+        [1, 1], [1, 2], [1, 3], [2, 1], [2, 2], [2, 3], [3, 1], [3, 2]
+	  ]
+    end
+
+    test 'not eq permutation.to_a' do
+      [1,1,2,3].unique_permutation.to_a.assert != [1,1,2,3].permutation.to_a
+    end
+
+    test 'eq permutation.to_a.uniq' do
+      [1,1,2,3].unique_permutation.to_a.assert == [1,1,2,3].permutation.to_a.uniq
+    end
+
+  end
+
+end

data/test/core/enumerable/test_key_by.rb

@@ -0,0 +1,22 @@
+covers 'facets/enumerable/key_by'
+
+test_case Enumerable do
+
+  method :key_by do
+
+    test do
+      a = [:a,:b,:c]
+      r = a.key_by{ |v| v.to_s }
+      r.assert == {'a'=>:a, 'b'=>:b, 'c'=>:c}
+    end
+
+    # Is this how it should behave?
+    test "works with a hash" do
+      h = {"A"=>1, "B"=>1, "C"=>1, "D"=>2, "E"=>2}
+      r = h.key_by{ |k,v| k }
+      r.assert == {"A"=>["A",1], "B"=>["B",1], "C"=>["C",1], "D"=>["D",2], "E"=>["E",2]}
+    end
+
+  end
+
+end

data/test/core/enumerable/test_occur.rb

@@ -4,22 +4,35 @@ test_case Enumerable do
 
   method :occur do
 
-    arr = [:a,:b,:a]
+    # make an Enumerable class to test
+    eC = Class.new do
+      include Enumerable
+      def initialize(*a)
+        @a = a
+      end
+      def each(&b)
+        @a.each(&b)
+      end
+    end
 
     test do
-      arr.occur(1).assert == [:b]
+      e = eC.new(:a,:b,:a)
+      e.occur(1).assert == [:b]
     end
 
     test do
-      arr.occur(2).assert == [:a]
+      e = eC.new(:a,:b,:a)
+      e.occur(2).assert == [:a]
     end
 
     test do
-      arr.occur(1..1).assert == [:b]
+      e = eC.new(:a,:b,:a)
+      e.occur(1..1).assert == [:b]
     end
 
     test do
-      arr.occur{ |n| n % 2 == 0 }.assert == [:a]
+      e = eC.new(:a,:b,:a)
+      e.occur{ |n| n % 2 == 0 }.assert == [:a]
     end
 
   end

data/test/core/enumerable/test_only.rb

@@ -0,0 +1,40 @@
+covers 'facets/enumerable/only'
+
+test_case Enumerable do
+
+  # make an Enumerable class to test
+  eC = Class.new do
+    include Enumerable
+    def initialize(*a)
+      @a = a
+    end
+    def each(&b)
+      @a.each(&b)
+    end
+  end
+
+  method :only? do
+
+    test do
+      e = eC.new(false)
+      assert e.only?
+    end
+
+    test do
+      e = eC.new(1)
+      assert e.only?
+    end
+
+    test do
+      e = eC.new(false, false)
+      refute e.only?
+    end
+
+    test do
+      e = eC.new()
+      refute e.only?
+    end  
+
+  end
+
+end

data/test/core/enumerable/test_squeeze.rb

@@ -0,0 +1,35 @@
+covers 'facets/enumerable/squeeze'
+
+test_case Enumerable do
+
+  method :squeeze do
+
+    # make an Enumerable class to test
+    eC = Class.new do
+      include Enumerable
+      def initialize(*a)
+        @a = a
+      end
+      def each(&b)
+        @a.each(&b)
+      end
+    end
+
+    test 'example (default)' do
+      e = eC.new(1,2,2,3,3,2,1)
+      e.squeeze.assert == [1,2,3,2,1]
+    end
+
+    test 'sort.squeeze eq uniq (default)' do
+      e = eC.new(1,2,2,3,3,2,1)
+      e.sort.squeeze.assert == [1,2,3]
+    end
+
+    test 'example (with argument)' do
+      e = eC.new(1,2,2,3,3,2,1)
+      e.squeeze(*[3]).assert == [1,2,2,3,2,1]
+    end
+
+  end
+
+end

data/test/core/enumerable/test_sum.rb

@@ -18,16 +18,21 @@ test_case Enumerable do
       a.assert == 9
 
       a = [1].sum(9)
-      a.assert == 1
+      a.assert == 10
     end
 
     test 'with identity and block' do
-      # notice identity is not effected by block (correct?)
+      # notice identity is not effected by the block
       a = [].sum(9.1, &:to_i)
       a.assert == 9.1
 
       a = [1.1].sum(9.1, &:to_i)
-      a.assert == 1
+      a.assert == 10.1
+    end
+
+    test 'with non-numeral addition' do
+      a = [[1],[2],[3]].sum([])
+      a.assert == [1,2,3]
     end
 
   end

data/test/core/enumerator/lazy/test_squeeze.rb

@@ -0,0 +1,33 @@
+if defined?(Enumerator::Lazy)
+  covers 'facets/enumerator/lazy/squeeze'
+
+  test_case Enumerator::Lazy do
+
+    method :squeeze do
+
+      # make an Enumerable class to test
+      eC = Class.new do
+        include Enumerable
+        def initialize(*a)
+          @a = a
+        end
+        def each(&b)
+          @a.each(&b)
+        end
+      end
+
+      test 'example (default)' do
+        e = eC.new(1,2,2,3,3,2,1)
+        e.lazy.squeeze.to_a.assert == [1,2,3,2,1]
+      end
+
+      test 'example (with argument)' do
+        e = eC.new(1,2,2,3,3,2,1)
+        e.lazy.squeeze(*[3]).to_a.assert == [1,2,2,3,2,1]
+      end
+
+    end
+
+  end
+
+end