facets 3.0.0 → 3.2.0

data/test/core/time/test_shift.rb

@@ -1,135 +0,0 @@
-covers 'facets/time/shift'
-
-test_case Time do
-
-  method :shift do
-
-    setup "January 1st 2010 at Noon" do
-      @t = Time.utc(2010,01,01, 12,00,00)
-    end
-
-    test 'years' do
-      @t.shift(1, :year).year.assert = 2011
-      @t.shift(2, :years).year.assert = 2012
-    end
-
-    test 'weeks' do
-      @t.shift(1, :week).day.assert == 8
-      @t.shift(2, :weeks).day.assert == 15
-    end
-
-    test 'days' do
-      @t.shift(1, :day).day.assert == 2
-      @t.shift(2, :days).day.assert == 3
-    end
-
-    test 'hours' do
-      @t.shift(1, :hour).hour.assert == 13
-      @t.shift(2, :hours).hour.assert == 14
-      @t.shift(12, :hours).hour.assert == 0
-    end
-
-    test 'minutes' do
-      @t.shift(1, :minute).min.assert == 1
-      @t.shift(2, :minutes).min.assert == 2
-      @t.shift(60, :minutes).min.assert == 0
-    end
-
-    test 'seconds' do
-      @t.shift(1, :second).sec.assert == 1
-      @t.shift(2, :seconds).sec.assert == 2
-      @t.shift(60, :seconds).sec.assert == 0
-    end
-
-  end
-
-  method :shift do
-
-    test "change years" do
-      e = Time.utc(2008,11, 1, 18,30,57)
-      r = Time.utc(2007,11, 1, 18,30,57).shift(1, :years)
-      r.assert == e                 
-    end
-
-    test "change weeks" do
-      e = Time.utc(2008,12, 1, 18,30,57)
-      r = Time.utc(2008,11,24, 18,30,57).shift(1, :weeks)
-      r.assert == e
-    end
-
-    test "change days" do
-      e = Time.utc(2008,12, 1, 18,30,57)
-      r = Time.utc(2008,11,30, 18,30,57).shift(1, :days)
-      r.assert == e
-    end
-
-    test "change hours" do
-      e = Time.utc(2008,12, 1,  0,30,57)
-      r = Time.utc(2008,11,30, 23,30,57).shift(1, :hours)
-      r.assert == e
-    end
-
-    test "change minutes" do
-      e = Time.utc(2008,12, 1,  0, 0,57)
-      r = Time.utc(2008,11,30, 23,58,57).shift(2, :minutes)
-      r.assert == e
-    end
-
-    test "change seconds" do
-      e = Time.utc(2008,12, 1,  0, 0, 1)
-      r = Time.utc(2008,11,30, 23,59,57).shift(4, :seconds)
-      r.assert == e
-    end
-
-  end
-
-  # months are more difficult, so they get their own section
-
-  method :shift do
-
-    test "change month no year wrap" do
-      e = Time.utc(2008,12, 1)
-      r = Time.utc(2008,11, 1).shift(1, :months)
-      r.assert == e
-    end
-
-    test "change month with year wrap due to month" do
-      e = Time.utc(2008, 1, 1)
-      r = Time.utc(2007,12, 1).shift(1, :months)
-      r.assert == e
-    end
-
-    test "change month with 12 or more converts extra months into a year adjustment" do
-      e = Time.utc(2008, 1, 1)
-      r = Time.utc(2007, 1, 1).shift(12, :months)
-      r.assert == e
-
-      e = Time.utc(2008,12, 1)
-      r = Time.utc(2006,11, 1).shift(25, :months)
-      r.assert == e
-    end
-
-    test "change month with 12 or more AND year wrap due to month" do
-      e = Time.utc(2008, 1, 1)
-      r = Time.utc(2006,12, 1).shift(13, :months)
-      r.assert == e
-    end
-
-    test "smaller units should remain unchanged" do
-      e = Time.utc(2006, 1,20, 15,37,59)
-      r = Time.utc(2005, 8,20, 15,37,59).shift(5, :months)
-      r.assert == e
-    end
-
-    test "passing a negative number to #shift should be same as a positive number to #ago" do
-      e = Time.utc(2005, 8,20)
-      r = Time.utc(2006, 1,20).shift(-5, :months)
-      r.assert == e
-
-      r = Time.utc(2006, 1,20).ago(5, :months)
-      r.assert == e
-    end
-
-  end
-
-end

data/test/core/time/test_stamp.rb

@@ -1,42 +0,0 @@
-covers 'facets/time/stamp'
-
-test_case Time do
-
-  method :stamp do
-
-    test "default" do
-      t = Time.utc(2005,4,20,15,37)
-      t.stamp.assert == "2005-04-20 15:37:00 +0000"
-    end
-
-    test "ruby18" do
-      t = Time.utc(2005,4,20,15,37)
-      t.stamp(:ruby18).assert == "Wed Apr 20 15:37:00 +0000 2005"
-    end
-
-    test "long format" do
-      t = Time.utc(2005,4,20,15,37)
-      t.stamp(:long).assert == "April 20, 2005 15:37"
-    end
-
-    test "short format" do
-      t = Time.utc(2005,4,20,15,37)
-      t.stamp(:short).assert == "20 Apr 15:37"
-    end
-
-  end
-
-  class_method :stamp do
-
-    test "long format" do
-      Time.stamp(:long)
-    end
-
-    test "short format" do
-      Time.stamp(:short)
-    end
-
-  end
-
-end
-

data/test/core/time/test_to_time.rb

@@ -1,15 +0,0 @@
-covers 'facets/time/to_time'
-
-test_case Time do
-
-  method :to_time do
-
-    test do
-      t = Time.now
-      t.to_time.assert.is_a?(Time)
-    end
-
-  end
-
-end
-

data/test/core/time/test_trunc.rb

@@ -1,34 +0,0 @@
-covers 'facets/time/trunc'
-
-test_case Time do
-
-  method :trunc do
-
-    setup do
-      @t = Time.local(2000,03,03,3,37,23)
-    end
-
-    test "hour" do
-      @t.trunc(60 * 60).assert == Time.local(2000,03,03,3, 0)
-    end
-
-    #test "month" do
-    #  @t.trunc(1.month).assert == Time.local(2000,03,01,0, 0)
-    #end
-
-    test "15 minutes" do
-      @t.trunc(15 * 60).assert == Time.local(2000,03,03,3,30)
-    end
-    
-    test "10 minutes" do
-      @t.trunc(10 * 60).assert == Time.local(2000,03,03,3,30)
-    end
-
-    test "05 minutes" do
-      @t.trunc(5 * 60).assert == Time.local(2000,03,03,3,35)
-    end
-
-  end
-
-end
-

data/test/core/to_hash_tc.rb

@@ -1,210 +0,0 @@
-covers 'facets/to_hash'
-
-test_case Array do
-
-  method :to_h do
-    test do
-      a = [ [:a,1], [:b,2] ]
-      a.to_h.assert == { :a=>1, :b=>2 }
-    end
-
-    test do
-      a = [ [:a,1,2], [:b,2], [:c], [:d] ]
-      a.to_h.assert == { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
-    end
-
-    test do
-      a = [ [:a,1,2], 2, :b, [:c,3], 9 ]
-      a.to_h.assert == { [:a,1,2]=>2, :b=>[:c,3], 9=>nil } 
-    end
-  end
-
-  method :to_h_auto do
-    test do
-      a = [ [:a,1], [:b,2] ]
-      a.to_h_auto.assert == { :a=>1, :b=>2 }
-    end
-
-    test do
-      a = [ [:a,1,2], [:b,2], [:c], [:d] ]
-      a.to_h_auto.assert == { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
-    end
-
-    test do
-      a = [ [:a,1,2], 2, :b, [:c,3], 9 ]
-      a.to_h_auto == { [:a,1,2]=>2, :b=>[:c,3], 9=>nil } 
-    end
-  end
-
-  method :to_h_splat do
-    test do
-      a = [:a,1,:b,2,:c]
-      a.to_h_splat.assert == { :a=>1, :b=>2, :c=>nil }
-    end
-  end
-
-  method :to_h_flat do
-    test do
-      a = [:a,1,[:b,2,:c]]
-      a.to_h_flat.assert == { :a=>1, :b=>2, :c=>nil }
-    end
-  end
-
-  method :to_h_assoc do
-    test do
-      a = [ [:a,1,2], [:b,2], [:c], [:d] ]
-      a.to_h_assoc.assert == { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
-    end
-  end
-
-  method :to_h_assoc do
-    test do
-      a = [ :x, [:x], [:x,1,2], [:x,3], [:x,4] ]
-      a.to_h_assoc.assert == { :x=>[4] }
-    end
-  end
-
-  method :to_h_multi do
-    test  "#to_h can default to #to_h_multi" do
-      a = [ [:a,1,2], [:b,2], [:c], [:d] ]
-      a.to_h.assert == { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
-    end
-  
-    test do
-      a = [ [:a,1,2], [:a,3], [:a,4], [:a], :a ]
-      a.to_h_multi.assert == { :a=>[1,2,3,4] }
-    end
-  end
-
-  #method :to_hash do
-  #end
-
-end
-
-test_case Hash do
-
-  method :to_h do
-    test do
-      {"a"=>1,"b"=>2}.to_h.assert == {"b"=>2,"a"=>1}
-    end
-  end
-
-  method :to_hash do
-    test do
-      h = {:a=>1, :b=>2}
-      h.to_hash.assert == h
-    end
-  end
-
-end
-
-test_case Enumerable do
-
-  method :to_h do
-    test do
-      (1..4).to_h.assert == { 1=>2, 3=>4 }
-    end
-  end
-
-  method :to_h_auto do
-    test do
-      (1..4).to_h_auto.assert == { 1=>2, 3=>4 }
-    end
-  end
-
-  method :to_h_splat do
-    test do
-      (1..4).to_h_splat.assert == { 1=>2, 3=>4 }
-    end
-  end
-
-  method :to_h_flat do
-    test do
-      (1..4).to_h_flat.assert == { 1=>2, 3=>4 }
-    end
-  end
-
-  method :to_h_assoc do
-    test do
-      (1..4).to_h_assoc.assert == { 1=>[], 2=>[], 3=>[], 4=>[] }
-    end
-  end
-
-  method :to_h_multi do
-    test do
-      (1..4).to_h_multi.assert == { 1=>[], 2=>[], 3=>[], 4=>[] }
-    end
-  end
-
-  #method :to_hash do
-  #  test do
-  #    (1..4).to_hash.assert == { 1=>2, 3=>4 }
-  #  end
-  #end
-end
-
-test_case Enumerator do
-
-  method :to_h do
-    test do
-      (1..4).to_enum.to_h.assert == { 1=>2, 3=>4 }
-    end
-  end
-
-  method :to_h_auto do
-    test do
-      (1..4).to_enum.to_h_auto.assert == { 1=>2, 3=>4 }
-    end
-  end
-
-  method :to_h_splat do
-    test do
-      (1..4).to_enum.to_h_splat.assert == { 1=>2, 3=>4 }
-    end
-  end
-
-  method :to_h_flat do
-    test do
-      (1..4).to_enum.to_h_flat.assert == { 1=>2, 3=>4 }
-    end
-  end
-
-  method :to_h_assoc do
-    test do
-      (1..4).to_enum.to_h_assoc.assert == { 1=>[], 2=>[], 3=>[], 4=>[] }
-    end
-  end
-
-  method :to_h_multi do
-    test do
-      (1..4).to_enum.to_h_multi.assert == { 1=>[], 2=>[], 3=>[], 4=>[] }
-    end
-  end
-
-  #method :to_hash do
-  #  test do
-  #    (1..4).to_hash.assert == { 1=>2, 3=>4 }
-  #  end
-  #end
-end
-
-test_case Struct do
-
-  method :to_h do
-    test do
-      s = Struct.new(:a,:b).new(1,2)
-      s.to_h.assert == {:a=>1, :b=>2}
-    end
-  end
-
-end
-
-test_case NilClass do
-
-  method :to_h do
-    test do
-      nil.to_h.assert == {}
-    end
-  end
-
-end

data/test/core/unboundmethod/test_arguments.rb

@@ -1,25 +0,0 @@
-covers 'facets/unboundmethod/arguments'
-
-test_case UnboundMethod do
-
-  method :arguments do
-
-    test do
-      x = Class.new do
-        def foo(a, b); end
-        def bar(a, b=1); end
-      end
-
-      foomethod = x.instance_method(:foo)
-      arguments  = foomethod.arguments
-      arguments.assert == "a0, a1"
-
-      barmethod = x.instance_method(:bar)
-      arguments = barmethod.arguments
-      arguments.assert == "a0, *args"
-    end
-
-  end
-
-end
-

data/test/core/unboundmethod/test_name.rb

@@ -1,19 +0,0 @@
-covers 'facets/unboundmethod/name'
-
-test_case UnboundMethod do
-
-  method :name do
-
-    test do
-      x = Class.new do
-        def foo; "bar"; end
-      end
-
-      meth = x.instance_method(:foo)
-      meth.name.to_sym.assert == :foo
-    end
-
-  end
-
-end
-

data/test/standard/binding/test_block_exec.rb

@@ -1,21 +0,0 @@
-covers "facets/binding/block_exec"
-
-testcase Binding do
-
-  # TODO: How do we test this?
-
-  method :block_exec do
-
-    #setup do
-    #  c = Class.new
-    #  $block_exec_binding = binding
-    #end
-
-    #test do
-    #  q = $block_exec_binding.block_exec { x }
-    #  q.assert == 5
-    #end
-
-  end
-
-end

data/test/standard/math/test_abs.rb

@@ -1,13 +0,0 @@
-require 'facets/math/abs'
-
-test_case Math do
-
-  class_method :abs do
-    test do
-      Math.abs(-3.1).assert == 3.1
-      Math.abs( 0.0).assert == 0.0
-      Math.abs( 3.1).assert == 3.1
-    end
-  end
-
-end

data/test/standard/math/test_acot.rb

@@ -1,23 +0,0 @@
-require 'facets/math/acot'
-require 'facets/numeric/range'  # used to test within a precision
-
-test_case Math do
-
-  class_method :acot do
-    test do
-      Math.acot(-1.0).range(1.0e-6).assert === 0.5 * Math::PI - Math.atan(-1.0)
-      Math.acot( 1.0).range(1.0e-6).assert === 0.5 * Math::PI - Math.atan( 1.0)
-    end
-  end
-
-    # TODO: Check complementarity of acot and cot
-    #assert_equal_float(1.0, Math.acot(Math.cot(1.0)), 1.0e-6)
-    #assert_equal_float(1.0, Math.cot(Math.acot(1.0)), 1.0e-6)
-    #assert_equal_float(2.0, Math.acot(Math.cot(2.0)), 1.0e-6)
-    #assert_equal_float(2.0, Math.cot(Math.acot(2.0)), 1.0e-6)
-
-    # TODO: Check consistency of atan2 and acot
-    #assert_equal_float(Math.atan2(1.0, 1.0), Math.acot(1.0), 1.0e-6)
-    #assert_equal_float(Math.atan2(1.0, 2.0), Math.acot(2.0), 1.0e-6)
-
-end

data/test/standard/math/test_acoth.rb

@@ -1,22 +0,0 @@
-require 'facets/math/acoth'
-require 'facets/math/coth'
-require 'facets/numeric/range'  # used to test within a precision
-
-test_case Math do
-
-  class_method :acoth do
-    test do
-      Math.acoth(1.5).range(1.0e-6).assert === 0.5 * Math.log(5.0)
-      Math.acoth(5.0).range(1.0e-6).assert === 0.5 * Math.log(1.5)
-    end
-
-    # 1.0e-6
-    test "check complementarity of acoth and coth" do
-      Math.acoth(Math.coth( 1.5)).range(1.0e-6).assert === 1.5
-      Math.coth(Math.acoth( 1.5)).range(1.0e-6).assert === 1.5
-      Math.acoth(Math.coth(-1.5)).range(1.0e-6).assert === -1.5
-      Math.coth(Math.acoth(-1.5)).range(1.0e-6).assert === -1.5
-    end
-  end
-
-end

data/test/standard/math/test_beta.rb

@@ -1,19 +0,0 @@
-require 'facets/math/beta'
-
-test_case Math do
-
-  class_method :beta do
-    test do
-      Math.beta(1.0, 1.0).range(1.0e-6).assert === 1.0
-      Math.beta(1.0, 2.0).range(1.0e-6).assert === 0.5
-      Math.beta(1.0, 3.0).range(1.0e-6).assert === 1.0 /  3.0
-      Math.beta(2.0, 1.0).range(1.0e-6).assert === 0.5
-      Math.beta(2.0, 2.0).range(1.0e-6).assert === 1.0 /  6.0
-      Math.beta(2.0, 3.0).range(1.0e-6).assert === 1.0 / 12.0
-      Math.beta(3.0, 1.0).range(1.0e-6).assert === 1.0 /  3.0
-      Math.beta(3.0, 2.0).range(1.0e-6).assert === 1.0 / 12.0
-      Math.beta(3.0, 3.0).range(1.0e-6).assert === 1.0 / 30.0
-    end
-  end
-
-end

data/test/standard/math/test_ceil.rb

@@ -1,22 +0,0 @@
-require 'facets/math/ceil'
-
-test_case Math do
-
-  class_method :ceil do
-    test do
-      Math.ceil( 1.99999).assert == 2
-      Math.ceil( 1.5    ).assert == 2
-      Math.ceil( 1.00001).assert == 2
-      Math.ceil( 0.99999).assert == 1
-      Math.ceil( 0.5    ).assert == 1
-      Math.ceil( 0.00001).assert == 1
-      Math.ceil(-0.00001).assert == 0
-      Math.ceil(-0.5    ).assert == 0
-      Math.ceil(-0.99999).assert == 0
-      Math.ceil(-1.00001).assert == -1
-      Math.ceil(-1.5    ).assert == -1
-      Math.ceil(-1.99999).assert == -1
-    end
-  end
-
-end

data/test/standard/math/test_cosec.rb

@@ -1,19 +0,0 @@
-require 'facets/math/cosec'
-
-test_case Math do
-
-  class_method :cosec do
-    test do
-      Math.cosec(-1.0).assert == 1.0 / Math.sin(-1.0)
-      Math.cosec( 1.0).assert == 1.0 / Math.sin( 1.0)
-    end
-  end
-
-  # TODO: Check complementarity of cosec and sin
-  #assert_equal_float(1.0, Math.cosec(-2.0) * Math.sin(-2.0), 1.0e-6)
-  #assert_equal_float(1.0, Math.cosec(-1.0) * Math.sin(-1.0), 1.0e-6)
-  #assert_equal_float(1.0, Math.cosec( 1.0) * Math.sin( 1.0), 1.0e-6)
-  #assert_equal_float(1.0, Math.cosec( 2.0) * Math.sin( 2.0), 1.0e-6)
-
-end
-

data/test/standard/math/test_cosech.rb

@@ -1,19 +0,0 @@
-require 'facets/math/cosech'
-
-test_case Math do
-
-  class_method :cosech do
-    test do
-      Math.cosech(-1.0).assert == 1.0 / Math.sinh(-1.0)
-      Math.cosech( 1.0).assert == 1.0 / Math.sinh( 1.0)
-    end
-
-    test "check complementarity of cosech and sinh" do
-      (Math.cosech(-2.0) * Math.sinh(-2.0)).assert == 1.0
-      (Math.cosech(-1.0) * Math.sinh(-1.0)).assert == 1.0
-      (Math.cosech( 1.0) * Math.sinh( 1.0)).assert == 1.0
-      (Math.cosech( 2.0) * Math.sinh( 2.0)).assert == 1
-    end
-  end
-
-end

data/test/standard/math/test_cot.rb

@@ -1,13 +0,0 @@
-require 'facets/math/cot'
-require 'facets/numeric/range'  # used to test within a precision
-
-test_case Math do
-
-  class_method :cot do
-    test do
-      Math.cot(1.0).range(1.0e-6).assert === 1.0 / Math.tan(1.0)
-      Math.cot(2.0).range(1.0e-6).assert === 1.0 / Math.tan(2.0) 
-    end
-  end
-
-end

data/test/standard/math/test_coth.rb

@@ -1,13 +0,0 @@
-require 'facets/math/coth'
-require 'facets/numeric/range'  # used to test within a precision
-
-test_case Math do
-
-  class_method :coth do
-    test do
-      Math.coth(1.0).range(1.0e-6).assert === 1.0 / Math.tanh(1.0)
-      Math.coth(2.0).range(1.0e-6).assert === 1.0 / Math.tanh(2.0)
-    end
-  end
-
-end

data/test/standard/math/test_distance.rb

@@ -1,16 +0,0 @@
-require 'facets/math/distance'
-
-test_case Math do
-
-  class_method :distance do
-    test do
-      Math.distance(1, 2).assert == 1.0
-      Math.distance([1,2], [3,4]).assert >= 2.828427
-      Math.distance([1,2], [3,4]).assert <= 2.8284271247461903
-      Math.distance([1,2,3], [4,5,6]).assert >= 5.196152
-      Math.distance([1,2,3], [4,5,6]).assert <= 5.196152422706632
-      Math.distance([1,2,3,4], [5,6,7,8]).assert == 8.0
-    end
-  end
-
-end