facets 3.1.0 → 3.2.0

data/test/standard/math/test_median.rb

@@ -1,17 +0,0 @@
-covers 'facets/math/median'
-
-test_case Math do
-
-  class_method :median do
-    test "fractional" do
-      r = Math.median [1, 2, 3, 3, 6, 11, 20, 20]
-      r.assert == 4.5
-    end
-
-    test "whole value" do
-      r = Math.median [1, 2, 4, 6, 8]
-      r.assert == 4
-    end
-  end
-
-end

data/test/standard/math/test_percentile.rb

@@ -1,13 +0,0 @@
-covers 'facets/math/percentile'
-
-test_case Math do
-
-  class_method :percentile do
-    test do
-      a = [1,1,2,2,3,3,3,4]
-      r = Math.percentile(a,75)
-      r.assert == 3.0
-    end
-  end
-
-end

data/test/standard/math/test_pow.rb

@@ -1,30 +0,0 @@
-require 'facets/math/pow'
-require 'facets/numeric/range'
-
-test_case Math do
-
-  class_method :pow do
-    test do
-      Math.pow(  4.0,   3.0).range(1.0e-6).assert === 64.0  
-      Math.pow(  0.9,   3.0).range(1.0e-6).assert === 0.729
-      Math.pow(  0.25, -0.5).range(1.0e-6).assert === 2.0   
-      Math.pow( 64.0,  -1.0/3).range(1.0e-6).assert === 0.25
-    end
-  end
-
-  class_method :pwr do
-    test do
-      Math.pwr(  4.0,   3.0).range(1.0e-6).assert === 64.0  
-      Math.pwr(  0.9,   3.0).range(1.0e-6).assert === 0.729
-      Math.pwr(  0.25, -0.5).range(1.0e-6).assert === 2.0   
-      Math.pwr( 64.0,  -1.0/3).range(1.0e-6).assert === 0.25
-    end
-  end
-
-  # TODO: Check complementarity of pwr and root
-  #  assert_equal_float(           4.0, Math.root(Math.pwr(2.0, 6.0), 3.0), 1.0e-6)
-  #  assert_equal_float(           2.0, Math.root(Math.pwr(4.0, 4.0), 8.0), 1.0e-6)
-  #  assert_equal_float(Math.sqrt(2.0), Math.pwr(Math.root(2.0, 6.0), 3.0), 1.0e-6)
-  #  assert_equal_float(          16.0, Math.pwr(Math.root(4.0, 4.0), 8.0), 1.0e-6)
-
-end

data/test/standard/math/test_root.rb

@@ -1,15 +0,0 @@
-require 'facets/math/root'
-require 'facets/numeric/range'
-
-test_case Math do
-
-  class_method :root do
-    test do
-      Math.root( 64.0,    3.0).range(1.0e-6).assert === 4.0
-      Math.root(  0.729,  3.0).range(1.0e-6).assert === 0.9
-      Math.root(  2.0,   -0.5).range(1.0e-6).assert === 0.25
-      Math.root(  0.25,  -1.0/3).range(1.0e-6).assert === 64.0
-    end
-  end
-
-end

data/test/standard/math/test_sec.rb

@@ -1,19 +0,0 @@
-require 'facets/math/sec'
-require 'facets/numeric/range'  # used to test within a precision
-
-test_case Math do
-
-  class_method :sec do
-    test do
-      Math.sec(1.0).range(1.0e-6).assert === 1.0 / Math.cos(1.0)
-      Math.sec(2.0).range(1.0e-6).assert === 1.0 / Math.cos(2.0)
-    end
-  end
-
-    # TODO: Check complementarity of cos and sec
-    #assert_equal_float(1.0, Math.sec(-2.0) * Math.cos(-2.0), 1.0e-6)
-    #assert_equal_float(1.0, Math.sec(-1.0) * Math.cos(-1.0), 1.0e-6)
-    #assert_equal_float(1.0, Math.sec( 1.0) * Math.cos( 1.0), 1.0e-6)
-    #assert_equal_float(1.0, Math.sec( 2.0) * Math.cos( 2.0), 1.0e-6)
-
-end

data/test/standard/math/test_sech.rb

@@ -1,19 +0,0 @@
-require 'facets/math/sech'
-require 'facets/numeric/range'  # used to test within a precision
-
-test_case Math do
-
-  class_method :sech do
-    test do
-      Math.sech(1.0).range(1.0e-6).assert === 1.0 / Math.cosh(1.0)
-      Math.sech(2.0).range(1.0e-6).assert === 1.0 / Math.cosh(2.0)
-    end
-  end
-
-    # TODO: Check complementarity of cosh and sech
-    #assert_equal_float(1.0, Math.sech(-2.0) * Math.cosh(-2.0), 1.0e-6)
-    #assert_equal_float(1.0, Math.sech(-1.0) * Math.cosh(-1.0), 1.0e-6)
-    #assert_equal_float(1.0, Math.sech( 1.0) * Math.cosh( 1.0), 1.0e-6)
-    #assert_equal_float(1.0, Math.sech( 2.0) * Math.cosh( 2.0), 1.0e-6)
-
-end

data/test/standard/math/test_sign.rb

@@ -1,20 +0,0 @@
-require 'facets/math/sign'
-
-test_case Math do
-
-  class_method :sign do
-    test do
-      Math.sign(-3.1).assert == -1.0
-      Math.sign( 0.0).assert ==  0.0
-      Math.sign( 3.1).assert ==  1.0
-    end
-
-    # Check complementarity of abs and sign
-    #assert_equal_float(-2.0, Math.abs(-2.0) * Math.sign(-2.0), 1e-6)
-    #assert_equal_float( 0.0, Math.abs( 0.0) * Math.sign( 0.0), 1e-6)
-    #assert_equal_float( 3.0, Math.abs( 3.0) * Math.sign( 3.0), 1e-6)
-
-  end
-
-end
-

data/test/standard/math/test_sinc.rb

@@ -1,15 +0,0 @@
-require 'facets/math/sinc'
-
-test_case Math do
-
-  class_method :sinc do
-    test do
-      Math.sinc( 0.0).assert == 1.0
-      Math.sinc( 1.0).assert == Math.sin(1.0)
-      Math.sinc(-1.0).assert == Math.sin(1.0)
-      Math.sinc( 2.0).assert == 0.5 * Math.sin(2.0)
-      Math.sinc(-2.0).assert == 0.5 * Math.sin(2.0)
-    end
-  end
-
-end

data/test/standard/math/test_srq.rb

@@ -1,20 +0,0 @@
-require 'facets/math/sqr'
-require 'facets/numeric/range'
-
-test_case Math do
-
-  class_method :sqr do
-    test do
-      Math.sqr(-0.9).range(1.0e-6).assert === 0.81
-      Math.sqr(-0.7).range(1.0e-6).assert === 0.49
-      Math.sqr(-0.7).range(1.0e-6).assert === 0.49
-      Math.sqr( 0.9).range(1.0e-6).assert === 0.81
-    end
-  end
-
-  # TODO: Check complementarity of sqrt and sqr
-  #  assert_equal_float(0.3, Math.sqrt(Math.sqr( 0.3)), 1.0e-6)
-  #  assert_equal_float(0.3, Math.sqrt(Math.sqr(-0.3)), 1.0e-6)
-  #  assert_equal_float(0.3, Math.sqr(Math.sqrt( 0.3)), 1.0e-6)
-
-end

data/test/standard/pathname/test_chdir.rb

@@ -1,16 +0,0 @@
-covers 'facets/pathname/chdir'
-
-test_case Pathname do
-
-  method :chdir do
-
-    test do
-      Pathname.pwd.basename.to_s.assert != 'tmp'
-      Pathname.new('tmp').chdir do
-        Pathname.pwd.basename.to_s.assert == 'tmp'
-      end
-    end
-
-  end
-end
-

data/test/standard/pathname/test_readline.rb

@@ -1,23 +0,0 @@
-require 'pathname'
-
-covers 'facets/pathname/readline'
-
-test_case Pathname do
-
-  method :readline do
-
-    setup do
-      @test_file = Pathname.new('tmp/test_file')
-      File.open(@test_file, "w") { |f| f << "line1\nline2" }
-    end
-
-    test do
-      @test_file.readline.assert == "line1\n"
-    end
-
-  end
-end
-
-
-
-

data/test/standard/test_argvector.rb

@@ -1,64 +0,0 @@
-covers 'facets/argvector'
-
-test_case Argvector do
-
-  method :parameters do
-
-    test do
-      line = "-x baz --foo=8 bar"
-      cargs = Argvector.new(line)
-      args, keys = cargs.parameters
-      args.assert == ['baz','bar']
-      keys.assert == {'foo'=>'8','x'=>true}
-    end
-
-    test "with arity" do
-      line = "-g a -x b -x c"
-      cargs = Argvector.new(line, :g=>1, :x=>1)
-      args, keys = cargs.parameters
-      keys.assert == {'g'=>'a','x'=>['b','c']}
-      args.assert == []
-    end
-
-    test "repeated option" do
-      line = "-x baz --foo=1 --foo=2 bar"
-      cargs = Argvector.new(line)
-      args, keys = cargs.parameters
-      args.assert == ['baz','bar']
-      keys.assert == {'x'=>true,'foo'=>['1','2']}
-    end
-
-    test do
-      line = "-q baz --aq 5 bar"
-      cargs = Argvector.new(line,'aq'=>1)
-      words, flags = cargs.parameters
-      words.assert == ['baz','bar']
-      flags.assert == {'q'=>true,'aq'=>'5'}
-    end
-
-  end
-
-  method :preoptions do
-
-    test do
-      line = "-x --foo=7 baz -y bar"
-      cargs = Argvector.new(line)
-      flags = cargs.preoptions
-      flags.assert == {'x'=>true,'foo'=>'7'}
-    end
-
-  end
-
-  method :flags do
-
-    test do
-      line = "-x baz --foo=8 bar"
-      cargs = Argvector.new(line)
-      flags = cargs.flags
-      flags.assert == ['x']
-    end
-
-  end
-
-end
-

data/test/standard/test_cloneable.rb

@@ -1,60 +0,0 @@
-require 'facets/cloneable'
-
-test_case Cloneable do
-
-  foo = Class.new do
-    include Cloneable
-    def initialize
-      @bar=[]
-    end
-    def bar_id
-      @bar.object_id
-    end
-  end
-
-  method :dup do
-    test do
-      a = foo.new
-      b = a.dup
-      a.bar_id.refute == b.bar_id
-    end
-
-    test "tainted" do
-      a = foo.new
-      a.taint
-      b = a.dup
-      b.assert.tainted?
-    end
-
-    test "frozen" do
-      a = foo.new
-      a.freeze
-      b = a.dup
-      b.refute.frozen?
-    end
-  end
-
-  method :clone do
-    test do
-      a = foo.new
-      b = a.clone
-      assert(a.bar_id != b.bar_id, "should not be equal")
-    end
-
-    test "tainted" do
-      a = foo.new
-      a.taint
-      b = a.clone
-      assert b.tainted?, "b should be tainted"
-    end
-
-    test "frozen" do
-      a = foo.new
-      a.freeze
-      b = a.clone
-      assert b.frozen?, "b should be frozen"
-    end
-
-  end
-
-end

data/test/standard/test_date.rb

@@ -1,82 +0,0 @@
-covers 'facets/date'
-
-test_case Date do
-
-  setup "Date 2005-05-20" do
-    @d = Date.civil(2005, 04, 20)
-  end
-
-  method :to_date do
-    test do
-      @d.to_date.assert.instance_of?(::Date)
-    end
-  end
-
-  method :to_time do
-    test do
-      @d.to_time.assert.instance_of?(::Time)
-    end
-  end
-
-  method :to_s do
-    test do
-      @d.to_s.assert == "2005-04-20"
-    end
-  end
-
-  method :stamp do
-    test do
-      @d.stamp.assert == "2005-04-20"
-    end
-  end
-
-  method :stamp do
-    test do
-      @d.stamp(:short).assert == "20 Apr"
-    end
-  end
-
-  method :stamp do
-    test do
-      @d.stamp(:long).assert == "April 20, 2005"
-    end
-  end
-
-  method :days_in_month do
-    test do
-      @d.days_in_month.assert == 30
-    end
-  end
-
-  method :days_of_month do
-    test do
-      @d.days_of_month.assert == (1..(@d.days_in_month)).to_a
-    end
-  end
-
-end
-
-test_case String do
-
-  method :to_date do
-    test do
-      s = "2005-10-31"
-      d = s.to_date
-      d.day.assert == 31
-      d.month.assert == 10
-      d.year.assert == 2005
-    end
-  end
-
-end
-
-test_case Time do
-
-  method :to_date do
-    test do
-      t = Time.now #parse('4/20/2005 15:37')
-      t.to_date.assert.instance_of?(::Date)
-    end
-  end
-
-end

data/test/standard/test_enumargs.rb

@@ -1,105 +0,0 @@
-covers 'facets/enumargs'
-
-test_case Enumerable::Arguments do
-
-  setup do
-    @PlusArray = Class.new do
-      include Enumerable::Argumentable
-      def initialize(arr)
-        @arr = arr
-      end
-      def each(n=0)
-        @arr.each{ |e| yield(e+n) }
-      end
-    end
-  end
-
-  method :collect do
-    test do
-      t = @PlusArray.new([1,2,3])
-      r = t.collect(4){ |e| e }
-      r.assert == [5,6,7]
-    end
-  end
-
-  #method :each_slice do
-  #  test do
-  #    t = PlusArray.new([1,2,3,4])
-  #    a = []
-  #    t.each_slice(2,4){ |e,f| a << [e,f] }
-  #    a.assert == [[5,6],[7,8]]
-  #  end
-  #end
-
-  #method :find do
-  #  test do
-  #    t = PlusArray.new([1,2,3,4])
-  #    f = t.find(2, :ifnone=>lambda{:NOPE}) { |a| a == 10 }
-  #    f.assert == :NOPE
-  #  end
-  #end
-
-  method :grep do
-  end
-
-  method :to_a do
-    test do
-      t = @PlusArray.new([1,2,3])
-      t.to_a(4).assert == [5,6,7]
-    end
-  end
-
-  # TODO: These two methods have issues! Any way to fix?
-  skip do
-		method :min do
-		  test do
-		    t = @PlusArray.new([1,2,3])
-
-		    # test is failing.  min has a variable number
-		    #  of arguments which makes it's .arity = -1.
-		    #  given the way this works for arity -1
-		    #  the method always passes the single argument to
-		    #  the min method, and passes nothing to the each
-		    #  resulting it taking the X smallest values of the
-		    #  given and unchanged array
-		    t.min(4).assert = 5 # returning [1,2,3]
-		  end
-		end
-
-    method :max do
-      # test is failing.  max has a variable number of arguments which makes it
-      #  .arity = -1.  given the way this works for arity -1 the method
-      #  always passes the single argument to the max method, and passes nothing
-      #  to the each resulting it taking the X largest values of the given and
-      #  unchanged array
-      test do
-        t = @PlusArray.new([1,2,3])
-        t.max(4).assert == 7
-      end
-    end
-  end
-
-  method :include? do
-    test do
-      t = @PlusArray.new([1,2,3])
-      t.assert.include?(7,4)
-    end
-  end
-
-  method :select do
-    test do
-      t = @PlusArray.new([1,2,3])
-      r = t.select(4){ |x| x == 6 }
-      r.assert == [6]
-    end
-  end
-
-  method :reject do
-    test do
-      t = @PlusArray.new([1,2,3])
-      r = t.reject(4){ |x| x == 6 }
-      r.assert == [5,7]
-    end
-  end
-
-end

data/test/standard/test_equitable.rb

@@ -1,46 +0,0 @@
-require 'facets/equitable'
-
-test_case Equitable do
-
-  c = Class.new
-  c.class_eval { 
-    include Equitable(:a,:b)
-    attr_accessor :a, :b
-  }
-
-  method :== do
-    test "equatable with arguments" do
-      c1,c2 = c.new,c.new
-      c1.a = 10; c1.b = 20
-      c2.a = 10; c2.b = 20
-      assert(c1 == c2)
-
-      c1.a = 10; c1.b = 10
-      c2.a = 10; c2.b = 20
-      refute(c1 == c2)
-
-      c1.a = 10; c1.b = 20
-      c2.a = 20; c2.b = 20
-      refute(c1 == c2)
-    end
-  end
-
-=begin
-  def test_equate_on_old
-    c = Class.new
-    c.class_eval { attr_accessor :a, :b ; equate_on :a,:b }
-    c1,c2 = c.new,c.new
-    c1.a = 10; c1.b = 20
-    c2.a = 10; c2.b = 20
-    assert_equal( c1, c2 )
-    c1.a = 10; c1.b = 10
-    c2.a = 10; c2.b = 20
-    assert_not_equal( c1, c2 )
-    c1.a = 10; c1.b = 20
-    c2.a = 20; c2.b = 20
-    assert_not_equal( c1, c2 )
-  end
-=end
-
-end
-

data/test/standard/test_instantiable.rb

@@ -1,40 +0,0 @@
-require 'facets/instantiable'
-
-test_case Instantiable do
-
-  setup do
-    @m = Module.new do
-      extend Instantiable
-
-      attr :a
-
-      def initialize( a )
-        @a = a
-      end
-    end
-
-    @n = Module.new do
-      include Instantiable
-
-      attr :a
-
-      def initialize( a )
-        @a = a
-      end
-    end
-  end
-
-  method :new do
-    test do
-      m = @m.new(1)
-      1.assert == m.a
-    end
-
-    test do
-      m = @n.new(1)
-      1.assert == m.a
-    end
-  end
-
-end
-

data/test/standard/test_math.rb

@@ -1,3 +0,0 @@
-# test the math require
-require 'facets/math'
-

data/test/standard/test_memoizable.rb

@@ -1,42 +0,0 @@
-covers 'facets/memoizable'
-
-test_case Memoizable do
-
-  method :memoize do
-
-    test "returns expected values" do
-      c = Class.new do
-        include Memoizable
-        def initialize(a)
-          @a = a
-        end
-        attr_accessor :a
-        memoize :a
-      end
-
-      o = c.new("A")
-      o.a.assert == "A"
-      o.a = "B"
-      o.a.assert == "A"
-    end
-
-    test "returns identical objects" do
-      c = Class.new do
-        include Memoizable
-        def initialize(a)
-          @a = a
-        end
-        attr_accessor :a
-        memoize :a
-      end
-
-      o = c.new("A")
-      o.a.__id__.assert == o.a.__id__
-      o.a = "B"
-      o.a.__id__.assert == o.a.__id__
-    end
-
-  end
-
-end
-