Add bin and edit workflow

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