Add bin and edit workflow

bin/gems/facets-3.1.0/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

bin/gems/facets-3.1.0/test/core/array/test_average.rb

@@ -0,0 +1,16 @@
+require 'facets/array/average'
+
+test_case Array do
+  method :average do
+    test 'Empty array returns nil' do
+      [].average.assert == nil
+    end
+
+    test 'Calculate average of array of numerical values' do
+      [1, 2, 3].average.assert == 2
+      [96, 35, 72, 30, 75, 33, 68, 13, 49, 71].average.assert == 54.2
+      [36, -67, -17, 85, -46, -64, -23, -13, 89, -47].average.assert == -6.7
+      [60.7829, 31.2622, 20.626, 78.8907, 61.5328].average.assert == 50.61892
+    end
+  end
+end

bin/gems/facets-3.1.0/test/core/array/test_before.rb

@@ -0,0 +1,48 @@
+covers 'facets/array/before'
+
+test_case Array do
+
+  method :before do
+
+    setup do
+      @sequence = ['a', 'b', 'c']
+    end
+
+    test "returns the previous element" do
+      @sequence.before('b').assert == 'a'
+      @sequence.before('c').assert == 'b'
+    end
+
+    test "loops around from back to front" do
+      @sequence.before('a').assert == 'c'
+    end
+
+    test "non-member elements return nil" do
+      @sequence.before('d').assert == nil
+    end
+
+  end
+
+  method :after do
+
+    setup do
+      @sequence = ['a', 'b', 'c']
+    end
+
+    test "returns the following element" do
+      @sequence.after('a').assert == 'b'
+      @sequence.after('b').assert == 'c'
+    end
+
+    test "loops around from back to front" do
+      @sequence.after('c').assert == 'a'
+    end
+
+    test "non-member elements return nil" do
+      @sequence.after('d').assert == nil
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/array/test_collapse.rb

@@ -0,0 +1,23 @@
+covers 'facets/array/collapse'
+
+test_case Array do
+
+  method :collapse do
+
+    test do
+      [1, nil, [1, 2], nil, [[3]]].collapse.assert == [1, 1, 2, 3]
+    end
+
+  end
+
+  method :collapse! do
+
+    test do
+      a = [1, nil, [1, 2], nil, [[3]]]
+      a.collapse!
+      a.assert == [1, 1, 2, 3]
+
+    end
+  end
+end
+

bin/gems/facets-3.1.0/test/core/array/test_commonality.rb

@@ -0,0 +1,35 @@
+covers 'facets/array/commonality'
+
+test_case Array do
+
+  method :commonality do
+
+    test do
+      a = [1,2,2,3,3,3]
+      e = { 2 => [2,2], 3 => [3,3,3] }
+      r = a.commonality
+      r.assert == e
+    end
+
+    test "with block" do
+      a = [1,2,2,3,3,3]
+      e = {false=>[1, 2, 2], true=>[3, 3, 3]}
+      r = a.commonality{ |x| x > 2 }
+      r.assert == e
+    end
+
+  end
+
+  method :collisions do
+
+    test "alias for commonality" do
+      a = [1,2,2,3,3,3]
+      e = { 2 => [2,2], 3 => [3,3,3] }
+      r = a.collisions
+      r.assert == e
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/array/test_conjoin.rb

@@ -0,0 +1,50 @@
+covers 'facets/array/conjoin'
+
+test_case Array do
+
+  method :conjoin do
+
+    setup "any array" do
+      @a = [1,2,3,4]
+    end
+
+    test "like join but spaced" do
+      @a.conjoin.assert == "1 2 3 4"
+    end
+
+    test "comma+space and 'and' on tail" do
+      @a.conjoin(', ', ' and ').assert = "1, 2, 3 and 4"
+    end
+
+    test "comma+space and 'or' on tail using :last option" do
+      @a.conjoin(', ', :last => ' or ').assert == "1, 2, 3 or 4"
+    end
+
+    test "semicolon+space and ampersand on tail using index" do
+      @a.conjoin('; ', -1 => ' & ').assert == "1; 2; 3 & 4"
+    end
+
+    test "with block to determine separator" do
+      r = @a.conjoin{ |i, a, b| i % 2 == 0 ? '.' : '-' }
+      r.assert == "1.2-3.4"
+    end
+
+    test "very esoteric transformation" do
+      r = @a.conjoin{ |i, x, y| "<#{i} #{x} #{y}>" }
+      r.assert == "1<0 1 2>2<1 2 3>3<2 3 4>4"
+    end
+
+    test "with :space option" do
+      r = @a.conjoin(',', '&', :space=>2)
+      r.assert == "1  ,  2  ,  3  &  4"
+    end
+
+    test ":spacer option can set an alternate spacing string" do
+      r = @a.conjoin('|', '>', :space=>2, :spacer=>'-')
+      r.assert == "1--|--2--|--3-->--4"
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/array/test_contains.rb

@@ -0,0 +1,14 @@
+covers 'facets/array/contains'
+
+test_case Array do
+
+  method :contains? do
+
+    test do
+      [1,2,3,4].assert.contains?(2)
+      [1,2,3,4].refute.contains?(9)
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/array/test_delete.rb

@@ -0,0 +1,42 @@
+covers 'facets/array/delete'
+
+test_case Array do
+
+  method :delete_unless do
+
+    test do
+      a = [1,2,3]
+      a.delete_unless{ |e| e == 2 }
+      a.assert == [2]
+    end
+
+  end
+
+  method :delete_values do
+
+    test do
+      a = [1,2,3,4]
+      a.delete_values(1,2).assert == [1,2]
+      a.assert == [3,4]
+    end
+
+  end
+
+  method :delete_values_at do
+
+    test do
+      a = [1,2,3,4]
+      a.delete_values_at(1,2).assert == [2,3]
+      a.assert == [1,4]
+    end
+
+    test do
+      a = [1,2,3,4]
+      a.delete_values_at(0..2).assert == [1,2,3]
+      a.assert == [4]
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/array/test_delete_unless.rb

@@ -0,0 +1,17 @@
+covers 'facets/array/delete_unless'
+
+test_case Array do
+
+  method :delete_unless do
+
+    test 'with an explicit block' do
+      [1,2,3].delete_unless{ |x| x < 2 }.assert == [1]
+    end
+
+    test 'with an implicit block' do
+      [1,2,3].delete_unless(&:even?).assert == [2]
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/array/test_delete_values.rb

@@ -0,0 +1,31 @@
+covers 'facets/array/delete_values'
+
+test_case Array do
+
+  method :delete_values do
+
+    test do
+      a = [1,2,3,4]
+      a.delete_values(1,2).assert == [1,2]
+      a.assert                    == [3,4]
+    end
+
+  end
+
+  method :delete_values_at do
+
+    test do
+      a = [1,2,3,4]
+      a.delete_values_at(1,2).assert == [2,3]
+      a.assert                       == [1,4]
+    end
+
+    test do
+      a = [1,2,3,4]
+      a.delete_values_at(0..2).assert == [1,2,3]
+      a.assert                        == [4]
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/array/test_divide.rb

@@ -0,0 +1,24 @@
+covers 'facets/array/divide'
+
+test_case Array do
+
+  method :divide do
+
+    test do
+      r = ['a1','b1','a2','b2'].divide(/^a/)
+      r.assert == [['a1','b1'],['a2','b2']]
+    end
+
+    test do
+      r = ['a1','b1','a2','b2'].divide(/^b/)
+      r.assert == [['a1'],['b1', 'a2'],['b2']]
+    end
+
+    test do
+      r = ['a1','b1','a2','b2'].divide(/c/)
+      r.assert = [['a1','b1','a2','b2']]
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/array/test_duplicates.rb

@@ -0,0 +1,29 @@
+covers 'facets/array/duplicates'
+
+test_case Array do
+
+  method :duplicates do
+
+    test do
+      a = [1,1,2,2,3,4,5]
+      a.duplicates.sort.assert == [1,2]
+    end
+
+    test "with minimum" do
+      a = [0,1,2,3,4,5,
+           0,1,2,3,4,
+           0,1,2,3,
+           0,1,2,
+           0,1,
+           0]
+      (1..6).each do |m|
+        d = a.duplicates(m).sort
+        e = [*0..6-m]
+        d.assert == e
+      end
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/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
+

bin/gems/facets-3.1.0/test/core/array/test_each_pair.rb

@@ -0,0 +1,16 @@
+covers 'facets/array/each_pair'
+
+test_case Array do
+
+  method :each_pair do
+
+    test do
+      result = {}
+      a = [:a,:b,:c,:d]
+      a.each_pair{|i,e| result[e] = i + 1}
+      result.assert == {a: 1, b: 2, c: 3, d: 4}
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/array/test_each_value.rb

@@ -0,0 +1,16 @@
+covers 'facets/array/each_value'
+
+test_case Array do
+
+  method :each_value do
+
+    test do
+      a = [ "a", "b", "c" ]
+      out = ''
+      a.each_value {|x| out +=  "#{x} -- " }
+      out.assert == 'a -- b -- c -- '
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/array/test_entropy.rb

@@ -0,0 +1,23 @@
+covers 'facets/array/entropy'
+
+test_case Array do
+
+  method :entropy do
+
+    test do
+      %w{ a b }.entropy.assert == 1.0
+    end
+
+  end
+
+  method :ideal_entropy do
+
+    test do
+      %w{ a b }.ideal_entropy.assert == 1.0
+      %w{ a a b b }.ideal_entropy.assert == 2.0
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/array/test_extract_options.rb

@@ -0,0 +1,28 @@
+covers 'facets/array/extract_options'
+
+test_case Array do
+
+  method :extract_options! do
+
+    test do
+      h = { :x=>1, :y=>1 }
+      a = [:a, :b, h]
+      a.extract_options!.assert == h
+    end
+
+  end
+
+end
+
+test_case Hash do
+
+  method :extractable_options? do
+
+    test do
+      h = { :x=>1, :y=>1 }
+      h.assert.extractable_options?
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/array/test_first.rb

@@ -0,0 +1,17 @@
+covers 'facets/array/indexable'
+
+test_case Array do
+
+  method :first! do 
+
+    test "alias of shift" do
+      a = [1,2,3]
+      r = a.first!
+      r.assert == 1
+      a.assert == [2,3]
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/array/test_from.rb

@@ -0,0 +1,42 @@
+covers 'facets/array/from'
+
+test_case Array do
+
+  method :from do
+
+    test do
+      %w{W o r l d}.from(3).assert == ['l', 'd']
+      %w{W o r l d}.from(8).assert == []
+    end
+  end
+
+  method :thru do
+
+    test do
+
+      [1, 2, 3, 4, 5].thru(2).assert == [1, 2, 3]
+      [1, 2, 3, 4, 5].thru(7).assert == [1, 2, 3, 4, 5]
+
+    end
+
+    test do
+
+      [1, 2, 3, 4, 5].thru(0, 2).assert == [1, 2, 3]
+      [1, 2, 3, 4, 5].thru(2, 4).assert == [3, 4, 5]
+
+    end
+
+    test do
+
+      [1, 2, 3, 4, 5].thru(3, 7).assert == [4, 5]
+
+    end
+
+    test do
+
+      [1, 2, 3, 4, 5].thru(6, 7).assert = []
+
+    end
+
+  end
+end

bin/gems/facets-3.1.0/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

bin/gems/facets-3.1.0/test/core/array/test_last.rb

@@ -0,0 +1,17 @@
+covers 'facets/array/indexable'
+
+test_case Array do
+
+  method :last! do
+
+    test "alias of pop" do
+      a = [1,2,3]
+      r = a.last!
+      r.assert == 3
+      a.assert == [1,2]
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/array/test_median.rb

@@ -0,0 +1,27 @@
+covers 'facets/array/median'
+
+test_case Array do
+
+  method :median do
+    test "odd sized" do
+      r = %w{e a b c d}.median
+      r.assert == "c"
+    end
+
+    test "even sized" do
+      r = %w{f e a b c d}.median
+      r.assert == "d"
+    end
+
+    test "with positive offset" do
+      r = %w{e a b c d}.median(1)
+      r.assert == "d"
+    end
+
+    test "with negative offset" do
+      r = %w{e a b c d}.median(-1)
+      r.assert == "b"
+    end
+  end
+
+end

bin/gems/facets-3.1.0/test/core/array/test_merge.rb

@@ -0,0 +1,27 @@
+covers 'facets/array/merge'
+
+test_case Array do
+
+  method :merge do
+
+    test do
+      a = [1,2,3]
+      b = [3,4,5]
+      a.merge(b).assert == [1,2,3,4,5]
+    end
+
+  end
+
+  method :merge! do
+
+    test do
+      a = [1,2,3]
+      b = [3,4,5]
+      a.merge!(b)
+      a.assert == [1,2,3,4,5]
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/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
+

bin/gems/facets-3.1.0/test/core/array/test_mode.rb

@@ -0,0 +1,17 @@
+covers 'facets/array/mode'
+
+test_case Array do
+
+  method :mode do
+
+    test do
+      [1, 1, 2, 3].mode.assert == [1]
+    end
+
+    test do
+      [1, 1, 2, 2, 3].mode.sort.assert == [1,2]
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/array/test_nonuniq.rb

@@ -0,0 +1,25 @@
+covers 'facets/array/nonuniq'
+
+test_case Array do
+
+  method :nonuniq do
+
+    test do
+      a = [1,1,2,2,3,4,5]
+      a.nonuniq.sort.assert == [1,2]
+    end
+
+  end
+
+  method :nonuniq! do
+
+    test do
+      a = [1,1,2,2,3,4,5]
+      a.nonuniq!
+      a.sort.assert == [1,2]
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/array/test_not_empty.rb

@@ -0,0 +1,17 @@
+covers 'facets/array/not_empty'
+
+test_case Array do
+
+  method :not_empty? do
+
+    test do
+      [].refute.not_empty?
+    end
+
+    test do
+      [1,2].assert.not_empty?
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/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

bin/gems/facets-3.1.0/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
+

bin/gems/facets-3.1.0/test/core/array/test_only.rb

@@ -0,0 +1,17 @@
+covers 'facets/array/only.rb'
+
+test_case Array do
+
+  method :only do
+
+    test do
+      [5].only.assert == 5
+      [nil].only.assert == nil
+      expect(IndexError){ [].only }
+      expect(IndexError){ [1,2,3].only }
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/array/test_op_pow.rb

@@ -0,0 +1,13 @@
+covers 'facets/array/op_pow'
+
+test_case Array do
+
+  method :** do
+
+    test do
+      ([1,2] ** [3,4]).assert == [[1, 3], [1, 4], [2, 3], [2, 4]]
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/array/test_pad.rb

@@ -0,0 +1,40 @@
+covers 'facets/array/pad'
+
+test_case Array do
+
+  method :pad do
+
+    test do
+      r = [0,1,2,3].pad(7,"x")
+      x = [0,1,2,3,"x","x","x"]
+      r.assert == x
+    end
+
+    test "negative index" do
+      r = [0,1,2,3].pad(-7,"n")
+      x = ["n","n","n",0,1,2,3]
+      r.assert == x
+    end
+
+  end
+
+  method :pad! do
+
+    test do
+      a = [0,1,2,3]
+      r = a.pad!(6,"y")
+      x = [0,1,2,3,"y","y"]
+      r.assert == x
+    end
+
+    test "negative index" do
+      a = [0,1,2,3]
+      r = a.pad!(-6,"q")
+      x = ["q","q",0,1,2,3]
+      r.assert == x
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/array/test_peek.rb

@@ -0,0 +1,28 @@
+covers 'facets/array/pull'
+
+test_case Array do
+
+  method :peek do
+
+    test do
+      a = [1,2,3]
+      a.peek.assert == 3
+      a.assert == [1,2,3]
+    end
+
+    test do
+      a = [1,2,3]
+      a.peek(1).assert == 2
+      a.assert == [1,2,3]
+    end
+
+    test do
+      a = [1,2,3]
+      a.peek(-1).assert == 1
+      a.assert == [1,2,3]
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/array/test_poke.rb

@@ -0,0 +1,21 @@
+covers 'facets/array/pull'
+
+test_case Array do
+
+  method :poke do
+
+    test do
+      a = [1,2,3]
+      a.poke(9)
+      a.assert == [9,1,2,3]
+    end
+
+    test do
+      a = [2,3]
+      a.poke(1).assert == [1,2,3]
+      a.poke(4).assert == [4,1,2,3]
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/array/test_probability.rb

@@ -0,0 +1,18 @@
+covers 'facets/array/probability'
+
+test_case Array do
+
+  method :probability do
+
+    test do
+      %w{a b}.probability.assert == {'a'=>0.5, 'b'=>0.5}
+    end
+
+    test do
+      %w{a a a b}.probability.assert == {'a'=>0.75, 'b'=>0.25}
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/array/test_pull.rb

@@ -0,0 +1,15 @@
+covers 'facets/array/pull'
+
+test_case Array do
+
+  method :pull do
+
+    test do
+      a = [1,2,3]
+      a.pull.assert == 1
+      a.assert == [2,3]
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/array/test_recurse.rb

@@ -0,0 +1,40 @@
+covers 'facets/array/recurse'
+
+test_case Array do
+
+  method :recurse do
+
+    test do
+      a = ["a", ["b", "c", nil], nil]
+      r = a.recurse{|a| a.compact! }
+      r.assert ["a", ["b", "c"]]
+    end
+
+    test "with Hashes" do
+      require 'facets/hash/recurse'
+      objects = []
+      struct = [1, 2, {:a => 3, :b => [4, 5, {:c=>6}]}, [7, 8]]
+      struct.recurse(Array, Hash){|o| objects << o; o } 
+
+      objects.assert.include?( [7, 8]                           )
+      objects.assert.include?( {:c=>6}                          )
+      objects.assert.include?( [4, 5, {:c=>6}]                  )
+      objects.assert.include?( {:a => 3, :b => [4, 5, {:c=>6}]} )
+      objects.assert.include?( struct                           )
+
+      objects.length.assert == 5
+    end
+
+  end
+
+  method :recurse! do
+
+    test do
+      a = ["a", ["b", "c", nil], nil]
+      a.recurse!{|a| a.compact! }
+      a.assert ["a", ["b", "c"]]
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/array/test_recursively.rb

@@ -0,0 +1,33 @@
+covers 'facets/array/recursively'
+
+test_case Array do
+
+  method :recursively do
+
+    test "each" do
+      r = []
+      [1,2,['a','b']].recursively{ |v| v }.each{ |v| r << v }
+      r.assert == [1,2,'a','b']
+    end
+
+    test "map" do
+      a = [1,2,['a','b']]
+      r = a.recursively{ |v| v.reverse }.map{ |v| v.succ }
+      r.assert == [2,3,['c','b']]
+    end
+
+    test "map!" do
+      a = [1,2,['a','b']]
+      a.recursively{ |v| v }.map!{ |v| v.succ }
+      a.assert == [2,3,['b','c']]
+    end
+
+    test "with block" do
+      a = [1,2,['a','b', nil], nil]
+      r = a.recursively{ |v| v.compact }.map{ |v| v }.compact
+      r.assert == [1,2,['a','b']]
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/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
+

bin/gems/facets-3.1.0/test/core/array/test_splice.rb

@@ -0,0 +1,21 @@
+covers 'facets/array/splice'
+
+test_case Array do
+
+  method :splice do
+
+    test do
+      a = [1,2,3]
+      a.splice(1).assert == 2
+      a.assert == [1,3]
+    end
+
+    test do
+      a = [1,2,3]
+      a.splice(1,4).assert == 4
+      a.assert == [1,4,3]
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/array/test_split.rb

@@ -0,0 +1,22 @@
+covers 'facets/array/split'
+
+test_case Array do
+
+  method :split do
+
+    test do
+      ['a','b','c'].split('b').assert == [['a'], ['c']]
+    end
+
+    test "empty" do
+      [].split('a').assert == []
+    end
+
+    test "same" do
+      ['a'].split('a').assert == []
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/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
+

bin/gems/facets-3.1.0/test/core/array/test_standard_deviation.rb

@@ -0,0 +1,18 @@
+require 'facets/array/standard_deviation'
+
+test_case Array do
+  method :standard_deviation do
+    test 'Empty array returns nil' do
+      [].standard_deviation.assert == nil
+    end
+
+    test 'Calculate standard_deviation of array of numerical values' do
+      [1, 2, 3].standard_deviation.assert == 0.816496580927726
+      [96, 35, 72, 30, 75, 33, 68, 13, 49, 71].standard_deviation.assert == 24.69331893448104
+      [36, -67, -17, 85, -46, -64, -23, -13, 89, -47].standard_deviation.assert == 54.67183918618432
+      [60.7829, 31.2622, 20.626, 78.8907, 61.5328].standard_deviation.assert == 21.428815505053002
+    end
+  end
+end
+
+

bin/gems/facets-3.1.0/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
+
+

bin/gems/facets-3.1.0/test/core/array/test_store.rb

@@ -0,0 +1,22 @@
+covers 'facets/array/store'
+
+test_case Array do
+
+  method :store do
+
+    test do
+      a = [1,2,3,4,5]
+      a.store(0, :A)
+      a.assert == [:A,2,3,4,5]
+    end
+
+    test do
+      a = [1,2,3,4,5]
+      a.store(-1, :Z)
+      a.assert == [1,2,3,4,:Z]
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/array/test_to_h.rb

@@ -0,0 +1,14 @@
+covers 'facets/array/to_h'
+
+test_case Array do
+
+  method :to_h do
+
+    test do
+      arr = [[:a, 1], [:b, 2]]
+      arr.to_h.assert == {:a => 1, :b => 2}
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/array/test_traverse.rb

@@ -0,0 +1,26 @@
+covers 'facets/array/traverse'
+
+test_case Array do
+
+  method :traverse do
+
+    test do
+      a = ["A", "B", ["X", "Y"]]
+      g = a.traverse{ |e| e.downcase }
+      g.assert == ["a", "b", ["x", "y"]]
+    end
+
+  end
+
+  method :traverse! do
+
+    test do
+      a = ["A", "B", ["X", "Y"]]
+      a.traverse!{ |e| e.downcase }
+      a.assert == ["a", "b", ["x", "y"]]
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/array/test_uniq_by.rb

@@ -0,0 +1,24 @@
+covers 'facets/array/uniq_by'
+
+test_case Array do
+
+  method :uniq_by! do
+
+    test do
+      e = [-5, -4, -3, -2, -1, 0]
+      r = (-5..5).to_a
+      r.uniq_by!{ |i| i*i }
+      r.assert == e
+    end
+
+    test do
+      e = [5, 4, 3, 2, 1, 0]
+      r = (-5..5).to_a.reverse
+      r.uniq_by!{ |i| i*i }
+      r.assert == e
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/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

bin/gems/facets-3.1.0/test/core/array/test_variance.rb

@@ -0,0 +1,17 @@
+require 'facets/array/variance'
+
+test_case Array do
+  method :variance do
+    test 'Empty array returns nil' do
+      [].variance.assert == nil
+    end
+
+    test 'Calculate variance of array of numerical values' do
+      [1, 2, 3].variance.assert == 0.6666666666666666
+      [96, 35, 72, 30, 75, 33, 68, 13, 49, 71].variance.assert == 609.76
+      [36, -67, -17, 85, -46, -64, -23, -13, 89, -47].variance.assert == 2989.0099999999993
+      [60.7829, 31.2622, 20.626, 78.8907, 61.5328].variance.assert == 459.1941339495999
+    end
+  end
+end
+

bin/gems/facets-3.1.0/test/core/array/test_zip.rb

@@ -0,0 +1,13 @@
+covers 'facets/array/zip'
+
+test_case Array do
+
+  method :zip do
+
+    test 'example' do
+      Array.zip([1,2], [3,4]).assert == [[1,3],[2,4]]
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/binding/test_caller.rb

@@ -0,0 +1,69 @@
+covers 'facets/binding/caller'
+
+test_case Binding do
+
+  a = 1
+  b = 2
+  x = "hello"
+  
+  bind = binding
+  line = __LINE__  # the line number must be updated if it moves
+  file = __FILE__  # why does it equal basename only?
+
+  method :__LINE__ do
+    test do
+      bind.__LINE__.assert == line - 1
+    end
+  end
+
+  method :__FILE__ do
+    test do
+      bind.__FILE__.assert == file
+    end
+  end
+
+  method :__DIR__ do
+    test do
+      bind.__DIR__.assert == File.dirname(file)
+    end
+  end
+
+  method :callstack do
+    test do
+      bind.callstack.assert.is_a?(Array)
+    end
+  end
+
+  method :call_stack do
+    test do
+      bind.call_stack.assert.is_a?(Array)
+    end
+  end
+
+  method :caller do
+    test do
+      Exception.refute.raised? do
+        bind.caller
+      end
+    end
+  end
+
+  method :__callee__ do
+    test do
+      alternate.__callee__.assert == :alternate
+    end
+  end
+
+  method :__method__ do
+    test do
+      alternate.__method__.assert == :alternate
+    end
+  end
+
+  # helper method
+  def alternate
+    binding
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/binding/test_defined.rb

@@ -0,0 +1,18 @@
+covers 'facets/binding/defined'
+
+test_case Binding do
+
+  a = 1
+  b = 2
+  x = "hello"
+
+  bind = binding
+
+  method :defined? do
+    test do
+      bind.assert.defined?("x")
+    end
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/binding/test_op.rb

@@ -0,0 +1,24 @@
+covers 'facets/binding/op'
+
+test_case Binding do
+
+  a = 1
+  b = 2
+  x = "hello"
+
+  bind = binding
+
+  method :[] do
+    test do
+      bind["x"].assert == "hello"
+    end
+  end
+
+  method :[]= do
+    test do
+      bind["x"] = "goodbye"
+      bind["x"].assert == "goodbye"
+    end
+  end
+
+end

bin/gems/facets-3.1.0/test/core/binding/test_self.rb

@@ -0,0 +1,16 @@
+covers 'facets/binding/self'
+
+test_case Binding do
+
+  bind = binding
+  this = self
+
+  method :self do
+
+    test do
+      bind.self == this
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/class/test_descendents.rb

@@ -0,0 +1,19 @@
+covers 'facets/class/descendants'
+
+test_case Class do
+
+  method :descendants do
+
+    a = Class.new
+    b = Class.new(a)
+    c = Class.new(b)
+
+    test do
+      a.descendants.assert.include?(b)
+      a.descendants.assert.include?(c)
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/class/test_preallocate.rb

@@ -0,0 +1,32 @@
+covers 'facets/class/preallocate'
+
+test_case Class do
+
+  method :preallocate do
+
+    setup do
+      @c = Class.new do
+        def f
+          "f"
+        end
+      end
+
+      @m = Module.new do
+        def f
+          '{' + super + '}'
+        end
+      end
+    end
+
+    test do
+      m = @m
+      @c.class_eval do
+        preallocate m
+      end
+      x = @c.new
+      x.f.assert == "{f}"
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/class/test_subclasses.rb

@@ -0,0 +1,20 @@
+covers 'facets/class/subclasses'
+
+test_case Class do
+
+  method :subclasses do
+
+    # class with a number of subclasses
+    c = Class.new
+    x = Class.new(c)
+    y = Class.new(c)
+    z = Class.new(c)
+
+    test do
+      c.subclasses == [x, y, z]
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/class/test_to_proc.rb

@@ -0,0 +1,16 @@
+covers 'facets/class/to_proc'
+
+test_case Class do
+
+  method :to_proc do
+
+    test do
+      person = Struct.new(:name)
+      people = ["joe"].map(&person)
+      people[0].name.assert == "joe"
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/comparable/test_bound.rb

@@ -0,0 +1,32 @@
+covers 'facets/comparable/bound'
+
+test_case Comparable do
+
+  method :bound do
+
+    test 'single argument' do
+      3.bound(4).assert == 4
+      4.bound(4).assert == 4
+      5.bound(4).assert == 5
+    end
+
+    test 'two arguments' do
+      4.bound(3,5).assert == 4
+      3.bound(3,5).assert == 3
+      5.bound(3,5).assert == 5
+      2.bound(3,5).assert == 3
+      6.bound(3,5).assert == 5
+    end
+
+    test 'on strings' do
+      'd'.bound('c','e').assert == 'd'
+      'c'.bound('c','e').assert == 'c'
+      'e'.bound('c','e').assert == 'e'
+      'b'.bound('c','e').assert == 'c'
+      'f'.bound('c','e').assert == 'e'
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/comparable/test_cap.rb

@@ -0,0 +1,36 @@
+covers 'facets/comparable/cap'
+
+test_case Comparable do
+
+  method :cap do
+
+    test do
+      3.cap(4).assert == 3
+      4.cap(4).assert == 4
+      5.cap(4).assert == 4
+    end
+
+  end
+
+  method :at_most do
+
+    test do
+      3.at_most(4).assert == 3
+      4.at_most(4).assert == 4
+      5.at_most(4).assert == 4
+    end
+
+  end
+
+  method :at_least do
+
+    test do
+      3.at_least(4).assert == 4
+      4.at_least(4).assert == 4
+      5.at_least(4).assert == 5
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/comparable/test_clip.rb

@@ -0,0 +1,31 @@
+covers 'facets/comparable/clip'
+
+test_case Comparable do
+
+  method :clip do
+
+    test 'single argument' do
+      3.clip(4).assert == 4
+      4.clip(4).assert == 4
+      5.clip(4).assert == 5
+    end
+
+    test 'two arguments' do
+      4.clip(3,5).assert == 4
+      3.clip(3,5).assert == 3
+      5.clip(3,5).assert == 5
+      2.clip(3,5).assert == 3
+      6.clip(3,5).assert == 5
+    end
+
+    test 'on strings' do
+      'd'.clip('c','e').assert == 'd'
+      'c'.clip('c','e').assert == 'c'
+      'e'.clip('c','e').assert == 'e'
+      'b'.clip('c','e').assert == 'c'
+      'f'.clip('c','e').assert == 'e'
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/comparable/test_cmp.rb

@@ -0,0 +1,16 @@
+covers 'facets/comparable/cmp'
+
+test_case Comparable do
+
+  method :cmp do
+
+    test 'on integers' do
+      3.cmp(4).assert == -1
+      3.cmp(3).assert ==  0
+      3.cmp(2).assert ==  1
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/comparable/test_op_get.rb

@@ -0,0 +1,61 @@
+covers 'facets/comparable/op_get'
+
+test_case Comparable do
+
+  class_method :[] do
+
+    test do
+      c = Class.new do
+        include Comparable[:a,:b]
+
+        attr_accessor :a, :b
+
+        def initialize(a,b)
+          @a=a; @b=b
+        end
+      end
+
+      a = [c.new(10,20),c.new(10,30)]
+      a.sort.assert == a
+
+      a = [c.new(10,30),c.new(10,20)]
+      a.sort.assert == a.reverse
+
+      a = [c.new(10,10),c.new(20,10)]
+      a.sort.assert == a
+
+      a = [c.new(20,10),c.new(10,10)]
+      a.sort.assert == a.reverse
+
+      a = [c.new(10,30),c.new(20,10)]
+      a.sort.assert == a
+    end
+
+=begin
+  class_method :sort_on do
+    test do
+      c = Class.new
+      c.class_eval {
+        def initialize(a,b)
+          @a=a; @b=b
+        end
+        sort_on :a,:b
+      }
+      a = [c.new(10,20),c.new(10,30)]
+      assert_equal( a, a.sort )
+      a = [c.new(10,30),c.new(10,20)]
+      assert_equal( a.reverse, a.sort )
+      a = [c.new(10,10),c.new(20,10)]
+      assert_equal( a, a.sort )
+      a = [c.new(20,10),c.new(10,10)]
+      assert_equal( a.reverse, a.sort )
+      a = [c.new(10,30),c.new(20,10)]
+      assert_equal( a, a.sort )
+    end
+  end
+=end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/denumerable_tc.rb

@@ -0,0 +1,194 @@
+covers 'facets/denumerable'
+covers 'facets/enumerable/defer'
+#require 'facets/enumerable/take'
+
+test_case Denumerable do
+
+  c = Class.new do
+    include Denumerable
+    def initialize(*a)
+      @a = a
+    end
+    def each(&blk)
+      @a.each(&blk)
+    end
+    def size; @a.size; end
+  end
+
+  method :map do
+    test do
+      o = c.new(1,2,3,4)
+      o.map.assert.is_a?(Denumerator)
+      o.map{ |x| x + 1 }.assert.is_a?(Denumerator)
+      o.map{ |x| x + 1 }.to_a.assert == [2,3,4,5]
+    end
+  end
+
+  method :collect do
+    test do
+      o = c.new(1,2,3,4)
+      o.collect.assert.is_a?(Denumerator)
+      o.collect{ |x| x + 1 }.assert.is_a?(Denumerator)
+      o.collect{ |x| x + 1 }.to_a.assert == [2,3,4,5]
+    end
+  end
+
+  method :select do
+    test do
+      o = c.new(1,2,3,4)
+      o.select.assert.is_a?(Denumerator)
+      o.select{ |x| x > 1 }.assert.is_a?(Denumerator)
+      o.select{ |x| x > 1 }.to_a.assert == [2,3,4]
+    end
+  end
+
+  method :find_all do
+    test do
+      o = c.new(1,2,3,4)
+      o.find_all.assert.is_a?(Denumerator)
+      o.find_all{ |x| x > 1 }.assert.is_a?(Denumerator)
+      o.find_all{ |x| x > 1 }.to_a.assert == [2,3,4]
+    end
+  end
+
+  method :reject do
+    test do
+      o = c.new(1,2,3,4)
+      o.reject.assert.is_a?(Denumerator)
+      o.reject{ |x| x > 1 }.assert.is_a?(Denumerator)
+      o.reject{ |x| x > 1 }.to_a.assert == [1]
+    end
+  end
+
+  method :skip do
+    test do
+      o = c.new(1,2,3,4)
+      o.skip(2).assert.is_a?(Denumerator)
+      o.skip(2).to_a.assert == [3,4]
+    end
+  end
+
+  method :take do
+    test do
+      o = c.new(1,2,3,4)
+      o.take(2).assert.is_a?(Denumerator)
+      o.take(2).to_a.assert == [1,2]
+    end
+  end
+
+end
+
+test_case Denumerator do
+
+  source = (1..1/0.0)   # infinite Enumerable object
+
+  method :each do
+    test do
+      res = []
+      (1..5).defer.each { |i| res << i }
+      res.assert == [1,2,3,4,5]
+    end
+  end
+
+  method :take do
+    test do
+      d = source.defer
+      d.take(5).to_a.assert == [1,2,3,4,5]
+    end
+  end
+
+  method :inject do
+    test do
+      d = (1..5).defer
+      d = d.inject({}) { |h,v| h[v] = v*2; h }
+      d.assert == {1=>2,2=>4,3=>6,4=>8,5=>10}
+    end
+
+    # TODO: problem with break in proc
+    #test do
+    #  d = (1..5).defer
+    #  d = d.inject({}){ |h,v| h[v] = v*2; break h if v>=3; h }
+    #  d.assert == {1=>2,2=>4,3=>6}
+    #end
+  end
+
+  method :max do
+    test do
+      d = source.defer
+      d.take(5).max.assert == 5
+    end
+  end
+
+  method :min do
+    test do
+      d = source.defer
+      d.take(5).min.assert == 1
+    end
+  end
+
+  method :sort_by do
+    test do
+      d = source.defer
+      d.take(5).sort_by{ |x| -x }.assert == [5,4,3,2,1]
+    end
+  end
+
+  method :map do
+    test do
+      d = source.defer
+      d.map{ |i| i*2 }.take(5).min.assert == 2
+    end
+  end
+
+  method :defer do
+    test do
+      d = source.defer.defer{ |out,i| out << i*2 }
+      d.take(5).to_a.assert == [2,4,6,8,10]
+    end
+
+    test "chain" do
+      d = source.defer { |out,i| out.yield(i) if i % 2 == 0 }.
+                 defer { |out,i| out.yield(i + 100) }
+      d.take(5).to_a.assert == [102,104,106,108,110]
+    end
+  end
+
+  method :select do
+    test do
+      d = source.defer
+      d = d.select{ |i| i % 2 == 0 }
+      d.take(5).to_a.assert == [2,4,6,8,10]
+    end
+  end
+
+  method :find_all do
+    test do
+      d = source.defer
+      d = d.find_all{ |i| i % 2 == 0 }
+      d.take(5).to_a.assert == [2,4,6,8,10]
+    end
+  end
+
+  method :reject do
+    test do
+      d = source.defer
+      d = d.reject { |i| i % 3 == 0 }
+      d.take(5).to_a.assert == [1,2,4,5,7]
+    end
+  end
+
+  method :skip do
+    test do
+      d = source.defer
+      d = d.skip(20)
+      d.take(5).to_a.assert == [21,22,23,24,25]
+    end
+  end
+
+  #method :each_cons
+  #  test do
+  #    a = source.defer
+  #    assert_equal [[1,2,3],[2,3,4],[3,4,5],[4,5,6]], a.each_cons(3).take(4)
+  #  end
+  #end
+end

bin/gems/facets-3.1.0/test/core/dir/test_ascend.rb

@@ -0,0 +1,40 @@
+covers 'facets/dir/ascend'
+
+test_case Dir do
+
+   test_directory = 'test/core/dir'
+
+   class_method :ascend do
+
+     test do
+       c = []
+       Dir.ascend(test_directory) do |path|
+         c << path
+       end
+       rdir = test_directory
+       c.each do |d|
+         d.assert == rdir
+         rdir = File.dirname(rdir)
+       end
+     end
+
+   end
+
+   class_method :ascend do
+
+     test "exclude current" do
+       c = []
+       Dir.ascend(test_directory, false) do |path|
+         c << path
+       end
+       rdir = File.dirname(test_directory)
+       c.each do |d|
+         d.assert == rdir
+         rdir = File.dirname(rdir)
+       end
+     end
+
+   end
+
+end
+

bin/gems/facets-3.1.0/test/core/dir/test_descend.rb

@@ -0,0 +1,24 @@
+covers 'facets/dir/ascend'
+
+test_case Dir do
+
+   test_directory = 'test/core/dir'
+
+   class_method :descend do
+
+     test do
+       c = []
+       Dir.descend(test_directory) do |path|
+         c << path
+       end
+       rdir = test_directory
+       c.reverse_each do |d|
+         d.assert == rdir
+         rdir = File.dirname(rdir)
+       end
+     end
+
+   end
+
+end
+

bin/gems/facets-3.1.0/test/core/dir/test_each_child.rb

@@ -0,0 +1,22 @@
+covers 'facets/dir/each_child'
+
+test_case Dir do
+
+  test_directory = 'test'
+
+  method :each_child do
+
+    test do
+      c = []
+      d = Dir.new(test_directory)
+      d.each_child do |path|
+        c << path
+      end
+      d.close
+      (['core', 'standard'] - c).assert.empty?
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/dir/test_multiglob.rb

@@ -0,0 +1,25 @@
+covers 'facets/dir/multiglob'
+
+test_case Dir do
+
+  class_method :multiglob do
+
+    test do
+      r = Dir.multiglob('test/c*').sort
+      r.assert.include?('test/core')
+    end
+
+  end
+
+  class_method :multiglob_r do
+
+    test do
+      r = Dir.multiglob_r('test').sort
+      r.assert.include?('test/core/dir')
+      r.assert.include?('test/core/dir/test_multiglob.rb')
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/dir/test_parent.rb

@@ -0,0 +1,14 @@
+covers 'facets/dir/parent'
+
+test_case Dir do
+
+  class_method :parent? do
+
+    test do
+      Dir.assert.parent?("a/b/c", "a/b/c/d")
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/dir/test_recurse.rb

@@ -0,0 +1,26 @@
+covers 'facets/dir/recurse'
+
+test_case Dir do
+
+  class_method :recurse do
+
+    test do
+      r = Dir.recurse('test')
+      r.assert.include?('test/core/dir')
+      r.assert.include?('test/core/dir/test_recurse.rb')
+    end
+
+  end
+
+  class_method :ls_r do
+
+    test do
+      r = Dir.ls_r('test')
+      r.assert.include?('test/core/dir')
+      r.assert.include?('test/core/dir/test_recurse.rb')
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/enumerable/test_accumulate.rb

@@ -0,0 +1,44 @@
+covers 'facets/enumerable/accumulate'
+
+test_case Enumerable do
+
+  method :accumulate do
+
+    test do
+      a = [1,2,3]
+      a.accumulate.succ.assert == [2,3,4]
+    end
+
+    test do
+      a = [{:ab=>1},{22=>:c}]
+      a.accumulate.values_at(:ab,22).assert == [1,nil,:c]
+    end
+
+    test "chained twice" do
+      a = [1,2,3]
+      a.accumulate(2).succ.to_s.assert == ['2','3','4']
+    end
+
+    test "chained three times" do
+      a = [{:ab=>1},{22=>:c}]
+      a.accumulate(3).keys.to_s.split(//).assert == ['a', 'b', '2']
+    end
+
+    test "empty receiver" do
+      a = []
+      a.accumulate.succ.assert == []
+    end
+
+  end
+
+  method :accumulate_all do
+
+    test "not uniq entries" do
+      a = [{:ab=>1},{22=>:c}]
+      a.accumulate_all(3).keys.to_s.split(//).assert == ['a', 'b', '2', '2']
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/enumerable/test_cluster.rb

@@ -0,0 +1,36 @@
+covers 'facets/enumerable/cluster'
+
+test_case Enumerable do
+
+  method :cluster do
+
+    test "on an array" do
+      a = [0, 2, 3, 5, 6, 6, 7, 13]
+      e = [[0, 2], [3, 5], [6, 6], [7, 13]]
+      r = a.cluster{ |x| x % 2 }
+      r.assert == e
+    end
+
+    test "on an array of strings" do
+      a = ["dog", "duck", "cat", "dude"]
+      e = [["dog", "duck"], ["cat"], ["dude"]]
+      r = a.cluster{ |x| x[0] }
+      r.assert == e
+    end
+
+    test "on a hash" do
+      h = {0=>0, 1=>2, 2=>4, 3=>6, 4=>8, 5=>1, 6=>3, 7=>5, 8=>7, 9=>9}
+      e = [[[0, 0], [1, 2], [2, 4], [3, 6], [4, 8]], [[5, 1], [6, 3], [7, 5], [8, 7], [9, 9]]]
+      r = h.cluster{ |k, v| v % 2 }.each{|a| a.sort!}
+      r.assert == e
+    end
+
+    test "on an empty array" do
+      r = [].cluster{ |a| a }
+      r.assert == []
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/enumerable/test_compact_map.rb

@@ -0,0 +1,32 @@
+covers 'facets/enumerable/compact_map'
+
+test_case Enumerable do
+
+  method :compact_map do
+
+    test do
+      r = [1,2,nil,4].compact_map { |e| e }
+      r.assert == [1,2,4]
+    end
+
+  end
+
+  method :compact_collect do
+
+    test do
+      r = [1,2,nil,4].compact_collect { |e| e }
+      r.assert == [1,2,4]
+    end
+
+  end
+
+  #method :filter_collect do
+  #  e = [3,4]
+  #  a = [1,2,3,4].filter_collect { |n|
+  #    throw(:skip) if n < 3
+  #    n
+  #  }
+  #  assert_equal( e, a )
+  #end
+
+end

bin/gems/facets-3.1.0/test/core/enumerable/test_defer.rb

@@ -0,0 +1,27 @@
+covers 'facets/enumerable/defer'
+
+test_case Enumerable do
+
+  method :defer do
+
+    source = (1...1/0.0)
+
+    test do
+      Denumerator.assert === [1,2,3,4].defer
+    end
+
+    test "without block" do
+      a = source.defer
+      a.class.assert == Denumerator
+      a.take(5).to_a.assert == [1,2,3,4,5]
+    end
+
+    test "with block" do
+      a = source.defer { |out,i| out << i*2 }
+      a.class.assert == Denumerator
+      a.take(5).to_a.assert == [2,4,6,8,10]
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/enumerable/test_each_by.rb

@@ -0,0 +1,49 @@
+covers 'facets/enumerable/each_by'
+
+test_case Enumerable do
+
+  method :each_by do
+
+    test "infer groups of two" do
+      e = [[1,2], [3,4], [5,6]]
+      a = [1,2,3,4,5,6]
+      r = []
+      a.each_by{ |a,b| r << [a,b] }
+      r.assert == e
+    end
+
+    test "infer groups of three" do
+      e = [[1,2,3],[4,5,nil]]
+      a = [1,2,3,4,5]
+      r = []
+      a.each_by{ |a,b,c| r << [a,b,c] }
+      r.assert == e
+    end
+
+    test "specify groups of two" do
+      e = [[1,2],[3,4]]
+      a = [1,2,3,4]
+      r = []
+      a.each_by(2){ |a,b| r << [a,b] }
+      r.assert == e
+    end
+
+    test "specify groups of three with splat argument" do
+      e = [ [[1,2,3]], [[4,5,6]] ]
+      a = [1,2,3,4,5,6]
+      r = []
+      a.each_by(3){ |*a| r << a }
+      r.assert == e
+    end
+
+    test "specify groups of four with splat argument" do
+      e = [ [[1,2,3,4]], [[5,6,7,8]] ]
+      a = [1,2,3,4,5,6,7,8]
+      r = []
+      a.each_by(4){ |*a| r << a }
+      r.assert == e
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/enumerable/test_every.rb

@@ -0,0 +1,33 @@
+covers 'facets/enumerable/every'
+
+test_case Enumerable do
+
+  method :every do
+
+    test do
+      a = [1,2,3]
+      (a.every + 3 ).assert == [4,5,6]
+      (a.every - 1).assert == [0,1,2]
+      (a.every.to_s).assert == ['1','2','3']
+    end
+
+    test "on Enumerator" do
+      e = [1,2,3].to_enum(:map)
+      r = e.every + 3
+      r.assert == [4,5,6]
+    end
+
+  end
+
+  method :every! do
+
+    test do
+      a = [1,2,3]
+      a.every! + 3
+      a.assert == [4,5,6]
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/enumerable/test_ewise.rb

@@ -0,0 +1,30 @@
+covers 'facets/enumerable/ewise'
+
+test_case Enumerable do
+
+  method :ewise do
+
+    test do
+      a = [1,2,3]
+      (a.ewise + 3).assert == [4,5,6]
+      (a.ewise + [4,5]).assert == [5,7]
+      (a.ewise.+([4,5],2)).assert == [[5,7],[3,4,5]]
+      (a.ewise.+([4,5],3)).assert == [[5,7],[4,5,6]]
+    end
+
+  end
+
+  method :elementwise do
+
+    test do
+      a = [1,2,3]
+      (a.elementwise + 3).assert == [4,5,6]
+      (a.elementwise + [4,5]).assert == [5,7]
+      (a.elementwise.+([4,5],2)).assert == [[5,7],[3,4,5]]
+      (a.elementwise.+([4,5],3)).assert == [[5,7],[4,5,6]]
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/enumerable/test_exclude.rb

@@ -0,0 +1,15 @@
+covers 'facets/enumerable/exclude'
+
+test_case Enumerable do
+
+  method :exclude? do
+
+    test do
+      a = [1,2,2,3]
+      a.refute.exclude?(2)
+      a.assert.exclude?(4)
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/enumerable/test_expand.rb

@@ -0,0 +1,15 @@
+covers 'facets/enumerable/expand'
+
+test_case Enumerable do
+
+  method :expand do
+
+    test do
+      a = [1,2,2,[1,2]]
+      r = a.expand
+      r == [1,2,2,1,2]
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/enumerable/test_filter.rb

@@ -0,0 +1,19 @@
+covers 'facets/enumerable/filter'
+
+test_case Enumerable do
+
+  method :filter do
+
+    test do
+      x = (1..10000)
+      x = x.filter{ |out,i| out << i if i % 2 == 0 }   # like select
+      x = x.filter{ |out,i| out << i + 100 }           # like map
+      x = x.take(3)
+
+      x.assert == [102, 104, 106]
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/enumerable/test_find_yield.rb

@@ -0,0 +1,96 @@
+covers 'facets/enumerable/find_yield'
+
+test_case Enumerable do
+  
+  method :find_yield do
+
+    test "a value" do
+      r = [true].find_yield { |value| value }
+      r.assert == true
+    end
+
+    test "detects correct value" do
+      r = [1].find_yield { |value| value }
+      r.assert == 1
+    end
+
+    test "returns value of block" do
+      r = [1].find_yield { |v| v + 3 }
+      r.assert == 4
+    end
+
+    test "detects first truthy value" do
+      r = [false, false, 1].find_yield { |value| value }
+      r.assert == 1
+    end
+
+    test "returns value when block is true" do
+      r = [false].find_yield { |value| true }
+      r.assert == true
+    end
+
+    test "returns early when block is true" do
+      v1 = lambda { :something }
+      v2 = lambda { raise "This shouldn't be called" }
+      r = [v1, v2].find_yield { |obj| obj.call }
+      r.assert == :something
+    end
+
+    test "returns nil when block returns false for all elements" do
+      r = [1,2,3,4].find_yield { |value| false }
+      r.assert == nil
+    end
+
+    test "returns nil when no elements in collection" do
+      r = [].find_yield { |v| }
+      r.assert == nil
+    end
+
+    test "can have return value specified when block isnt true" do
+      r = [1,2,3].find_yield(:a_value){ |value| false }
+      r.assert == :a_value
+    end
+
+    test "documentation correct" do
+      obj1, obj2 = Object.new, Object.new
+
+      class << obj1
+        def foo?
+          false
+        end
+
+        def foo
+          raise
+        end
+      end
+
+      class << obj2
+        def foo?
+          true
+        end
+
+        def foo
+          "a value"
+        end
+      end
+
+      obj1.foo?.assert == false
+      obj2.foo?.assert == true
+      obj2.foo.assert == "a value"
+
+      result = [obj1, obj2].find_yield { |obj| obj.foo if obj.foo? }
+      result.assert == "a value"
+    end
+
+  end
+
+  method :map_detect do
+
+    test "old alias for #find_yield" do
+      r = [true].map_detect{ |value| value }
+      r.assert == true
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/enumerable/test_frequency.rb

@@ -0,0 +1,15 @@
+covers 'facets/enumerable/frequency'
+
+test_case Enumerable do
+
+  method :frequency do
+
+    test do
+      %w{a b}.frequency.assert == {'a'=>1,'b'=>1}
+      %w{a a b}.frequency.assert == {'a'=>2,'b'=>1}
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/enumerable/test_graph.rb

@@ -0,0 +1,42 @@
+covers 'facets/enumerable/graph'
+
+test_case Enumerable do
+
+  method :graph do
+
+    test "returns hash" do
+      a = { :a => 1, :b => 2, :c => 3 }
+      e = { :a => 2, :b => 3, :c => 4 }
+      r = a.graph{ |k,v| {k => v+1} }
+      r.assert == e
+    end
+
+    test "hash of array" do
+      a = { :a => [1,2], :b => [2,3], :c => [3,4] }
+      e = { :a => 2, :b => 6, :c => 12 }
+      r = a.graph{ |k,v| [k, v[0]*v[1] ] }
+      r.assert == e
+    end
+
+    test "array of array" do
+      a = [ [1,2], [2,3], [3,4] ]
+      e = { [1,2] => 2, [2,3] => 6, [3,4] => 12 }
+      r = a.graph{ |a| [a, a[0]*a[1] ] }
+      r.assert == e
+    end
+
+    test "squares" do
+      numbers  = (1..3)
+      squares  = numbers.graph{ |n| [n, n*n] }
+      squares.assert == {1=>1, 2=>4, 3=>9}
+    end
+
+    test "roots" do
+      numbers  = (1..3)
+      sq_roots = numbers.graph{ |n| [n*n, n] }
+      sq_roots.assert == {1=>1, 4=>2, 9=>3}
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/enumerable/test_hashify.rb

@@ -0,0 +1,113 @@
+covers 'facets/enumerable/hashify'
+
+test_case Enumerable do
+  method :hashify do
+    test do
+      a = [ [:a,1], [:b,2] ]
+      a.hashify.class.assert == Enumerable::Hashifier
+    end
+  end
+end
+
+test_case Enumerable::Hashifier do
+  method :splat do
+    test do
+      a = [1,2,3,4]
+      h = Enumerable::Hashifier.new(a)
+      h.splat.assert == {1 => 2, 3 => 4}
+    end
+
+    test do
+      a = [1,2,3,4,5]
+      h = Enumerable::Hashifier.new(a)
+      h.splat.assert == {1 => 2, 3 => 4, 5=> nil}
+    end
+
+    test do
+      a = 1..5
+      h = Enumerable::Hashifier.new(a)
+      h.splat.assert == {1 => 2, 3 => 4, 5=> nil}
+    end
+  end
+
+  method :flat do
+    test do
+      a = [:a,1,[:b,2,:c],4]
+      h = Enumerable::Hashifier.new(a)
+      h.flat.assert == {a: 1, b: 2, c: 4}
+    end
+
+    test do
+      a = [:a,1,[:b,2,:c]]
+      h = Enumerable::Hashifier.new(a)
+      h.flat.assert == {a: 1, b: 2, c: nil}
+    end
+
+    test do
+      require 'set'
+      a = Set.new([:a, 1, [:b, 2, :c]])
+      h = Enumerable::Hashifier.new(a)
+      h.flat.assert == {a: 1, b: 2, c: nil}
+    end
+  end
+
+  method :associate do
+    test do
+      a = [ [:a,1,2], [:b,2], [:c], [:d] ]
+      a.hashify.associate.assert == { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
+    end
+
+    test do
+      a = [ :x, [:x], [:x,1,2], [:x,3], [:x,4] ]
+      a.hashify.associate.assert == { :x=>[4] }
+    end
+  end
+
+  method :merge do
+    test do
+      a = [ [:a,1,2], [:b,2], [:c], [:d] ]
+      a.hashify.merge.assert == { :a=>1, :b=>2, :c=>nil, :d=>nil }
+    end
+
+    test do
+      a = [ :x, [:x], [:x,1,2], [:x,3], [:x,4] ]
+      a.hashify.merge.assert == { :x=>4 }
+    end
+  end
+
+  method :concat do
+    test do
+      a = [ [:a,1,2], [:b,2], [:c], [:d] ]
+      a.hashify.concat.assert == { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
+    end
+
+    test do
+      a = [ [:a,1,2], [:a,3], [:a,4], [:a], :a ]
+      a.hashify.concat.assert == { :a=>[1,2,3,4] }
+    end
+  end
+
+  method :by_index do
+    test do
+      [:a,:b,:c].hashify.by_index.assert == {0=>:a, 1=>:b, 2=>:c}
+    end
+  end
+
+  method :auto do
+    test do
+      a = [ [:a,1], [:b,2] ]
+      a.hashify.auto.assert == { :a=>1, :b=>2 }
+    end
+
+    test do
+      a = [ [:a,1,2], [:b,2], [:c], [:d] ]
+      a.hashify.auto.assert == { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
+    end
+
+    test do
+      a = [ [:a,1,2], 2, :b, [:c,3], 9 ]
+      a.hashify.auto.assert =={ [:a,1,2]=>2, :b=>[:c,3], 9=>nil }
+    end
+
+  end
+end

bin/gems/facets-3.1.0/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

bin/gems/facets-3.1.0/test/core/enumerable/test_map_by.rb

@@ -0,0 +1,27 @@
+covers 'facets/enumerable/map_by'
+
+test_case Enumerable do
+
+  method :map_by do
+
+    test do
+      a = [1,2,3,4,5]
+      r = a.map_by{ |e| [e % 2, e + 1] }
+      r.assert == { 0=>[3,5], 1=>[2,4,6] }
+    end
+
+    test "works well with a hash" do
+      h = {"A"=>1, "B"=>1, "C"=>1, "D"=>2, "E"=>2}
+      r = h.map_by{ |k,v| [v, k.downcase] }
+      r.assert == {1=>["a", "b", "c"], 2=>["d", "e"]}
+    end
+
+    test "if only a scalar is returned, #map_by acts like #group_by" do
+      h = {"A"=>1, "B"=>1, "C"=>1, "D"=>2, "E"=>2}
+      r = h.map_by{ |k,v| v }
+      r.assert == {1=>[["A",1], ["B",1], ["C",1]], 2=>[["D",2], ["E",2]]}
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/enumerable/test_map_send.rb

@@ -0,0 +1,26 @@
+covers 'facets/enumerable/map_send'
+
+test_case Enumerable do
+
+  method :map_send do
+
+    test do
+      [1,2,3].map_send(:+, 3).assert == [4,5,6]
+    end
+
+  end
+
+  #method :map_send do
+  #  test do
+  #    r = [1,2,3].map_send(:+, 1)
+  #    assert_equal(r, [2,3,4])
+  #  end
+  #
+  #  test "with_block" do
+  #    r = [1,2,3].map_send(:+,1){ |x| x + 1 }
+  #    assert_equal(r, [3,4,5])
+  #  end
+  #end
+
+end
+

bin/gems/facets-3.1.0/test/core/enumerable/test_map_with_index.rb

@@ -0,0 +1,23 @@
+covers 'facets/enumerable/map_with_index'
+
+test_case Enumerable do
+
+  method :map_with_index do
+
+    test do
+      a = [1,2,3].map_with_index{ |e,i| e*i }
+      a.assert == [0,2,6]
+    end
+
+  end
+
+  method :collect_with_index do
+
+    test do
+      a = [1,2,3].collect_with_index{ |e,i| e*i }
+      a.assert == [0,2,6]
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/enumerable/test_mash.rb

@@ -0,0 +1,17 @@
+covers 'facets/enumerable/mash'
+
+test_case Enumerable do
+
+  method :mash do
+
+    test "is an alias for #graph" do
+      a = { :a => 1, :b => 2, :c => 3 }
+      e = { :a => 2, :b => 3, :c => 4 }
+      r = a.mash{ |k,v| {k => v+1} }
+      r.assert == e
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/enumerable/test_modulate.rb

@@ -0,0 +1,17 @@
+covers 'facets/enumerable/modulate'
+
+test_case Enumerable do
+
+  method :modulate do
+
+    test do
+      a = [2,4,6,8]
+      r = a.modulate(2)
+      x = [[2,6],[4,8]]
+      r.assert == x
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/enumerable/test_occur.rb

@@ -0,0 +1,40 @@
+covers 'facets/enumerable/occur'
+
+test_case Enumerable do
+
+  method :occur 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 do
+      e = eC.new(:a,:b,:a)
+      e.occur(1).assert == [:b]
+    end
+
+    test do
+      e = eC.new(:a,:b,:a)
+      e.occur(2).assert == [:a]
+    end
+
+    test do
+      e = eC.new(:a,:b,:a)
+      e.occur(1..1).assert == [:b]
+    end
+
+    test do
+      e = eC.new(:a,:b,:a)
+      e.occur{ |n| n % 2 == 0 }.assert == [:a]
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/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

bin/gems/facets-3.1.0/test/core/enumerable/test_per.rb

@@ -0,0 +1,19 @@
+covers 'facets/enumerable/per'
+
+test_case Enumerable do
+
+  method :per do
+
+    test "map" do
+      e = [1,2,3].per.map
+
+      (e + 3).assert == [4,5,6]
+      (e - 1).assert == [0,1,2]
+
+      e.to_s.assert == ['1','2','3']
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/enumerable/test_purge.rb

@@ -0,0 +1,22 @@
+covers 'facets/enumerable/purge'
+
+test_case Enumerable do
+
+  method :purge do
+
+    test do
+      [1, nil, 2].purge.assert == [1,2]
+    end
+
+    test "with trash arguments" do
+      (1..6).purge(3,4).assert == [1,2,5,6]
+    end
+
+    test "with block" do
+      (1..6).purge(0){ |n| n % 2 }.assert == [1,3,5]
+      (1..6).purge(1){ |n| n % 2 }.assert == [2,4,6]
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/enumerable/test_recursively.rb

@@ -0,0 +1,33 @@
+covers 'facets/enumerable/recursively'
+
+test_case Enumerable do
+
+  method :recursively do
+
+    c = Class.new do
+      include Enumerable
+      def initialize(ary)
+        @ary = ary
+      end
+      def each(&b)
+        @ary.each(&b)
+      end
+    end
+
+    test "each" do
+      e = c.new [1,2,['a','b']]
+      a = []
+      e.recursively(Enumerable).each{ |v| a << v }
+      a.assert == [1,2,'a','b']
+    end
+
+    test "map" do
+      e = c.new [1,2,['a','b']]
+      a = e.recursively(Enumerable).map{ |v| v.succ }
+      a.assert == [2,3,['b','c']]
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/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

bin/gems/facets-3.1.0/test/core/enumerable/test_sum.rb

@@ -0,0 +1,40 @@
+covers 'facets/enumerable/sum'
+
+test_case Enumerable do
+
+  method :sum do
+
+    test do
+      [1,2,3].sum.assert == 6
+    end
+
+    test 'with block' do
+      a = [1.0, 2.1, 3.2].sum(&:to_i)
+      a.assert == 6
+    end
+
+    test 'with identity' do
+      a = [].sum(9)
+      a.assert == 9
+
+      a = [1].sum(9)
+      a.assert == 10
+    end
+
+    test 'with identity and block' do
+      # 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 == 10.1
+    end
+
+    test 'with non-numeral addition' do
+      a = [[1],[2],[3]].sum([])
+      a.assert == [1,2,3]
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/enumerable/test_uniq_by.rb

@@ -0,0 +1,25 @@
+covers 'facets/enumerable/uniq_by'
+
+test_case Enumerable do
+
+  method :uniq_by do
+
+    test do
+      e = [-5, -4, -3, -2, -1, 0]
+      r = (-5..5).to_a.uniq_by{ |i| i*i }
+      r.assert == e
+    end
+
+  end
+
+  #method :uniq_by! do
+  #  test do
+  #    e = [-5, -4, -3, -2, -1, 0]
+  #    r = (-5..5).to_a
+  #    r.uniq_by!{ |i| i*i }
+  #    r.assert == e 
+  #  end
+  #end
+
+end
+

bin/gems/facets-3.1.0/test/core/enumerable/test_visit.rb

@@ -0,0 +1,14 @@
+covers 'facets/enumerable/visit'
+
+test_case Enumerable do
+
+  method :visit do
+
+    test do
+      r = [1, 2, 8..9].visit{ |x| x.succ }
+      r.assert == [2, 3, [9, 10]]
+    end  
+
+  end
+
+end