facets 3.0.0 → 3.2.0

data/test/core/array/test_only.rb

@@ -1,17 +0,0 @@
-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
-

data/test/core/array/test_pad.rb

@@ -1,40 +0,0 @@
-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
-

data/test/core/array/test_peek.rb

@@ -1,28 +0,0 @@
-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
-

data/test/core/array/test_permutation.rb

@@ -1,20 +0,0 @@
-covers 'facets/array/permutation'
-
-test_case Array do
-
-  method :permutation do
-
-    test do
-      r = []
-      %w[a b c].permutation{ |x| r << x.join('') }
-
-      x = ['abc','acb','bac','bca','cab','cba']
-      x.each do |e|
-        r.assert.include?(e)
-      end
-    end
-
-  end
-
-end
-

data/test/core/array/test_poke.rb

@@ -1,21 +0,0 @@
-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

data/test/core/array/test_probability.rb

@@ -1,18 +0,0 @@
-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
-

data/test/core/array/test_product.rb

@@ -1,64 +0,0 @@
-covers 'facets/array/product'
-
-test_case Array do
-
-  method :product do
-
-    test "single argument" do
-      r = [1,2,3].product([4,5,6])
-      x = [[1, 4],[1, 5],[1, 6],[2, 4],[2, 5],[2, 6],[3, 4],[3, 5],[3, 6]]
-      r.assert == x
-    end
-
-    test "multiple arguments" do
-      a = %w|a b|
-      b = %w|a x|
-      c = %w|x y|
-      r = a.product(b, c)
-      x = [ ["a", "a", "x"],
-            ["a", "a", "y"],
-            ["a", "x", "x"],
-            ["a", "x", "y"],
-            ["b", "a", "x"],
-            ["b", "a", "y"],
-            ["b", "x", "x"],
-            ["b", "x", "y"] ]
-      r.assert == x
-    end
-
-  end
-
-  #def test_product_01
-  #  i = [[1,2], [4], ["apple", "banana"]]
-  #  o = [[1, 4, "apple"], [1, 4, "banana"], [2, 4, "apple"], [2, 4, "banana"]]
-  #  assert_equal( o, Enumerable.product(*i) )
-  #end
-
-  #     def test_op_mod
-  #       a = [:A,:B,:C]
-  #       assert_equal( a[1], a/1 )
-  #       assert_equal( :B, a/1 )
-  #     end
-  #
-  #     def test_op_div
-  #       a = [:A,:B,:C]
-  #       assert_equal( a[1], a/1 )
-  #       assert_equal( :B, a/1 )
-  #     end
-
-
-  #def test_op_mod
-  #  a = [:A,:B,:C]
-  #  assert_equal( a[1], a/1 )
-  #  assert_equal( :B, a/1 )
-  #end
-  #
-  #def test_op_div
-  #  a = [:A,:B,:C]
-  #  assert_equal( a[1], a/1 )
-  #  assert_equal( :B, a/1 )
-  #end
-
-end
-
-

data/test/core/array/test_pull.rb

@@ -1,15 +0,0 @@
-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

data/test/core/array/test_recurse.rb

@@ -1,40 +0,0 @@
-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

data/test/core/array/test_recursively.rb

@@ -1,33 +0,0 @@
-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

data/test/core/array/test_reject_values.rb

@@ -1,17 +0,0 @@
-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_rotate.rb

@@ -1,38 +0,0 @@
-covers 'facets/array/rotate'
-
-test_case Array do
-
-  method :rotate do
-
-    test "clockwise" do
-      a = [1,2,3]
-      r = a.rotate
-      r.assert == [2,3,1]
-    end
-
-    test "counter-clockwise" do
-      a = [1,2,3]
-      r = a.rotate(-1)
-      r.assert == [3,1,2]
-    end
-
-  end
-
-  method :rotate! do
-
-    test "clockwise" do
-      a = [1,2,3]
-      a.rotate!
-      a.assert == [2,3,1]
-    end
-
-    test "counter-clockwise" do
-      a = [1,2,3]
-      a.rotate!(-1)
-      a.assert == [3,1,2]
-    end
-
-  end
-
-end
-

data/test/core/array/test_select.rb

@@ -1,16 +0,0 @@
-covers 'facets/array/select'
-
-test_case Array do
-
-  method :select! do
-
-    test do
-      a = [1,2,3,4,5,6,7,8,9,10]
-      a.select!{ |e| e % 2 == 0 }
-      a.assert == [2,4,6,8,10]
-    end
-
-  end
-
-end
-

data/test/core/array/test_splice.rb

@@ -1,21 +0,0 @@
-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

data/test/core/array/test_split.rb

@@ -1,22 +0,0 @@
-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
-

data/test/core/array/test_squeeze.rb

@@ -1,22 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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_store.rb

@@ -1,22 +0,0 @@
-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
-

data/test/core/array/test_traverse.rb

@@ -1,26 +0,0 @@
-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
-

data/test/core/array/test_uniq_by.rb

@@ -1,17 +0,0 @@
-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
-
-  end
-
-end
-

data/test/core/array/test_unique_permutation.rb

@@ -1,23 +0,0 @@
-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/binding/test_caller.rb

@@ -1,69 +0,0 @@
-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
-

data/test/core/binding/test_defined.rb

@@ -1,18 +0,0 @@
-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
-

data/test/core/binding/test_eval.rb

@@ -1,15 +0,0 @@
-covers 'facets/binding/eval'
-
-test_case Binding do
-
-  x = "hello"
-  bind = binding
-
-  method :eval do
-    test do
-      bind.eval("x").assert == "hello"
-    end
-  end
-
-end
-