facets 2.0.2 → 2.0.3

data/test/unit/test_infinity.rb

@@ -1,52 +1,46 @@
-  #  _____         _
-  # |_   _|__  ___| |_
-  #   | |/ _ \/ __| __|
-  #   | |  __/\__ \ |
-  #   |_|\___||___/\__|
-  #
-  # for lib/facets/infinity.rb
-  #
-  # Extracted Mon Sep 03 16:23:07 -0700 2007
-  # w/ Test Extraction Ratchet
-  #
-
- require 'facets/infinity.rb'
-
-
-
-  require 'test/unit'
-
-  class GeneralTest < Test::Unit::TestCase
-
-    def test_pos
-      assert_equal((1.0/0), INFINITY.to_f)
-      assert_equal(1, INFINITY<=>5)
-      assert_equal(1, INFINITY<=>"a")
-      assert_equal("PosInf", INFINITY.to_s)
-    end
-
-    def test_neg
-      assert_equal((-1.0/0), -INFINITY.to_f)
-      assert_equal(-1, -INFINITY<=>5)
-      assert_equal(-1, -INFINITY<=>"a")
-      assert_equal("NegInf", (-INFINITY).to_s)
-    end
-
-    def test_ord
-      assert_equal((-1.0/0), -INFINITY.to_f)
-      assert_equal(-1, 5<=>INFINITY)
-      assert_equal(1, 5<=>-INFINITY)
-    end
-
-    def test_eq
-      assert_equal(Inf, Inf)
-      assert_equal(-Inf, -Inf)
-      assert_equal(PosInf, PosInf)
-      assert_equal(NegInf, NegInf)
-      assert_not_equal(NaN, NaN)
-    end
+#      _____         _
+#    |_   _|__  ___| |_
+#     | |/ _ \/ __| __|
+#    | |  __/\__ \ |
+#   |_|\___||___/\__|
+#
+# for facets/infinity.rb
 
+require 'facets/infinity.rb'
+
+require 'test/unit'
+
+class GeneralTest < Test::Unit::TestCase
+
+  def test_pos
+    assert_equal((1.0/0), INFINITY.to_f)
+    assert_equal(1, INFINITY<=>5)
+    assert_equal(1, INFINITY<=>"a")
+    assert_equal("PosInf", INFINITY.to_s)
+  end
+
+  def test_neg
+    assert_equal((-1.0/0), -INFINITY.to_f)
+    assert_equal(-1, -INFINITY<=>5)
+    assert_equal(-1, -INFINITY<=>"a")
+    assert_equal("NegInf", (-INFINITY).to_s)
   end
 
+  def test_ord
+    assert_equal((-1.0/0), -INFINITY.to_f)
+    assert_equal(-1, 5<=>INFINITY)
+    assert_equal(1, 5<=>-INFINITY)
+  end
+
+  def test_eq
+    assert_equal(Inf, Inf)
+    assert_equal(-Inf, -Inf)
+    assert_equal(PosInf, PosInf)
+    assert_equal(NegInf, NegInf)
+    assert_not_equal(NaN, NaN)
+  end
+
+end
+
 
 

data/test/unit/test_inheritor.rb

@@ -1,157 +1,148 @@
-  #  _____         _
-  # |_   _|__  ___| |_
-  #   | |/ _ \/ __| __|
-  #   | |  __/\__ \ |
-  #   |_|\___||___/\__|
-  #
-  # for lib/facets/inheritor.rb
-  #
-  # Extracted Mon Sep 03 16:23:07 -0700 2007
-  # w/ Test Extraction Ratchet
-  #
-
- require 'facets/inheritor.rb'
-
-
-
-  require 'test/unit'
-
-  #class TC01 < Test::Unit::TestCase
-  #  def setup
-  #    @a = [1]
-  #    @i = Inheritor.new( @a, [2], :+ )
-  #  end
-  #  def test_01_001
-  #    assert_equal([2],@i)
-  #  end
-  #  def test_01_002
-  #    assert_equal([1,2],@i.inheritance)
-  #  end
-  #end
-
-  class TC02 < Test::Unit::TestCase
-    class C
-      inheritor :koko, [1], :+
-    end
-    class D < C
-      inheritor :koko, [2], :+
-    end
-
-    def test_02_001
-      assert_equal( [1], C.koko! )
-    end
-    def test_02_002
-      assert_equal( [1], C.koko )
-    end
-    def test_02_003
-      assert_equal( [2], D.koko! )
-    end
-    def test_02_004
-      assert_equal( [1,2], D.koko )
-    end
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |
+#   |_|\___||___/\__|
+#
+# for facets/inheritor.rb
+
+require 'facets/inheritor.rb'
+
+require 'test/unit'
+
+#class TC_Inheritor_01 < Test::Unit::TestCase
+#  def setup
+#    @a = [1]
+#    @i = Inheritor.new( @a, [2], :+ )
+#  end
+#  def test_01_001
+#    assert_equal([2],@i)
+#  end
+#  def test_01_002
+#    assert_equal([1,2],@i.inheritance)
+#  end
+#end
+
+class TC_Inheritor_02 < Test::Unit::TestCase
+  class C
+    inheritor :koko, [1], :+
+  end
+  class D < C
+    inheritor :koko, [2], :+
   end
 
-  class TC03 < Test::Unit::TestCase
-    class C
-      inheritor :koko, [1], :+
-    end
-    class D < C
-    end
-
-    def test_03_001
-      assert_equal( [1], C.koko! )
-    end
-    def test_03_002
-      assert_equal( [1], C.koko )
-    end
-    def test_03_003
-      assert_equal( [], D.koko! )
-    end
-    def test_03_004
-      assert_equal( [1], D.koko )
-    end
+  def test_02_001
+    assert_equal( [1], C.koko! )
   end
+  def test_02_002
+    assert_equal( [1], C.koko )
+  end
+  def test_02_003
+    assert_equal( [2], D.koko! )
+  end
+  def test_02_004
+    assert_equal( [1,2], D.koko )
+  end
+end
 
-  class TC04 < Test::Unit::TestCase
-    class X
-      inheritor :x, {:a=>1}, :merge
-    end
-    module M
-      inheritor :x, {:b=>2}, :merge
-    end
-    class Y < X
-      include M
-      inheritor :x, {:c=>3}, :merge
-    end
+class TC_Inheritor_03 < Test::Unit::TestCase
+  class C
+    inheritor :koko, [1], :+
+  end
+  class D < C
+  end
 
-    def test_04_001
-      assert_equal( {:a=>1}, X.x )
-    end
-    def test_04_002
-      assert_equal( 2, M.x[:b] )
-    end
-    def test_04_003
-      assert_equal( {:a=>1,:b=>2,:c=>3}, Y.x )
-    end
-    def test_04_004
-      assert_equal( 1, X.x[:a] )
-      assert_equal( nil, X.x[:b] )
-      assert_equal( nil, X.x[:c] )
-    end
-    def test_04_005 ; assert_equal( 1, Y.x[:a] ) ; end
-    def test_04_006 ; assert_equal( 2, Y.x[:b] ) ; end
-    def test_04_007 ; assert_equal( 3, Y.x[:c] ) ; end
-    def test_04_008
-      Y.x![:d] = 4
-      assert_equal( 4, Y.x[:d] )
-    end
+  def test_03_001
+    assert_equal( [1], C.koko! )
+  end
+  def test_03_002
+    assert_equal( [1], C.koko )
+  end
+  def test_03_003
+    assert_equal( [], D.koko! )
+  end
+  def test_03_004
+    assert_equal( [1], D.koko )
   end
+end
 
-  class TC05 < Test::Unit::TestCase
-    class C
-      inheritor :relations, [], :concat
-    end
-    class D < C
-      #inheritor :relations, [], :concat
-    end
+class TC_Inheritor_04 < Test::Unit::TestCase
+  class X
+    inheritor :x, {:a=>1}, :merge
+  end
+  module M
+    inheritor :x, {:b=>2}, :merge
+  end
+  class Y < X
+    include M
+    inheritor :x, {:c=>3}, :merge
+  end
 
-    C.relations! << 1
-    C.relations! << 2
-    D.relations! << 3
+  def test_04_001
+    assert_equal( {:a=>1}, X.x )
+  end
+  def test_04_002
+    assert_equal( 2, M.x[:b] )
+  end
+  def test_04_003
+    assert_equal( {:a=>1,:b=>2,:c=>3}, Y.x )
+  end
+  def test_04_004
+    assert_equal( 1, X.x[:a] )
+    assert_equal( nil, X.x[:b] )
+    assert_equal( nil, X.x[:c] )
+  end
+  def test_04_005 ; assert_equal( 1, Y.x[:a] ) ; end
+  def test_04_006 ; assert_equal( 2, Y.x[:b] ) ; end
+  def test_04_007 ; assert_equal( 3, Y.x[:c] ) ; end
+  def test_04_008
+    Y.x![:d] = 4
+    assert_equal( 4, Y.x[:d] )
+  end
+end
 
-    def test_05_001
-      assert_equal( [1,2], C.relations )
-      assert_equal( [1,2,3], D.relations )
-    end
+class TC_Inheritor_05 < Test::Unit::TestCase
+  class C
+    inheritor :relations, [], :concat
+  end
+  class D < C
+    #inheritor :relations, [], :concat
   end
 
-  class TC06 < Test::Unit::TestCase
-    module MM
-      inheritor :koko, [], :+
-      koko! << 1
-    end
-    class CC1
-      include MM
-      #inheritor :koko, [], :+
-      koko! << 2
-      koko! << 3
-    end
-    class CC2
-      include MM
-      #inheritor :koko, [], :+
-      koko! << 4
-    end
+  C.relations! << 1
+  C.relations! << 2
+  D.relations! << 3
 
-    def test_06_001
-      assert_equal( [1], MM.koko )
-    end
-    def test_06_002
-      assert_equal( [1,2,3], CC1.koko )
-    end
-    def test_06_003
-      assert_equal( [1,4], CC2.koko )
-    end
+  def test_05_001
+    assert_equal( [1,2], C.relations )
+    assert_equal( [1,2,3], D.relations )
   end
+end
 
+class TC_Inheritor_06 < Test::Unit::TestCase
+  module MM
+    inheritor :koko, [], :+
+    koko! << 1
+  end
+  class CC1
+    include MM
+    #inheritor :koko, [], :+
+    koko! << 2
+    koko! << 3
+  end
+  class CC2
+    include MM
+    #inheritor :koko, [], :+
+    koko! << 4
+  end
 
-
+  def test_06_001
+    assert_equal( [1], MM.koko )
+  end
+  def test_06_002
+    assert_equal( [1,2,3], CC1.koko )
+  end
+  def test_06_003
+    assert_equal( [1,4], CC2.koko )
+  end
+end

data/test/unit/test_interval.rb

@@ -1,121 +1,157 @@
-  #  _____         _
-  # |_   _|__  ___| |_
-  #   | |/ _ \/ __| __|
-  #   | |  __/\__ \ |
-  #   |_|\___||___/\__|
-  #
-  # for lib/facets/interval.rb
-  #
-  # Extracted Mon Sep 03 16:23:07 -0700 2007
-  # w/ Test Extraction Ratchet
-  #
+#      _____         _
+#    |_   _|__  ___| |_
+#     | |/ _ \/ __| __|
+#    | |  __/\__ \ |
+#   |_|\___||___/\__|
+#
+# for facets/interval.rb
 
- require 'facets/interval.rb'
+require 'facets/interval.rb'
 
+require 'test/unit'
 
+class InclusiveTest < Test::Unit::TestCase
 
-  require 'test/unit'
-
-  class InclusiveTest < Test::Unit::TestCase
-
-    def setup
-      @a = Interval.new( 1, 10 )
-      @b = Interval.new( 1, 10, true, false )
-      @c = Interval.new( 1, 10, false, true )
-      @d = Interval.new( 1, 10, true, true )
-    end
-
-    def test_001A ; assert_equal( false, @a.include?(0)  ) ; end
-    def test_002A ; assert_equal( true,  @a.include?(1)  ) ; end
-    def test_003A ; assert_equal( true,  @a.include?(2)  ) ; end
-    def test_004A ; assert_equal( true,  @a.include?(9)  ) ; end
-    def test_005A ; assert_equal( true,  @a.include?(10) ) ; end
-    def test_006A ; assert_equal( false, @a.include?(11) ) ; end
-
-    def test_001B ; assert_equal( false, @b.include?(0)  ) ; end
-    def test_002B ; assert_equal( false, @b.include?(1)  ) ; end
-    def test_003B ; assert_equal( true,  @b.include?(2)  ) ; end
-    def test_004B ; assert_equal( true,  @b.include?(9)  ) ; end
-    def test_005B ; assert_equal( true,  @b.include?(10) ) ; end
-    def test_006B ; assert_equal( false, @b.include?(11) ) ; end
-
-    def test_001C ; assert_equal( false, @c.include?(0)  ) ; end
-    def test_002C ; assert_equal( true,  @c.include?(1)  ) ; end
-    def test_003C ; assert_equal( true,  @c.include?(2)  ) ; end
-    def test_004C ; assert_equal( true,  @c.include?(9)  ) ; end
-    def test_005C ; assert_equal( false, @c.include?(10) ) ; end
-    def test_006C ; assert_equal( false, @c.include?(11) ) ; end
-
-    def test_001D ; assert_equal( false, @d.include?(0)  ) ; end
-    def test_002D ; assert_equal( false, @d.include?(1)  ) ; end
-    def test_003D ; assert_equal( true,  @d.include?(2)  ) ; end
-    def test_004D ; assert_equal( true,  @d.include?(9)  ) ; end
-    def test_005D ; assert_equal( false, @d.include?(10) ) ; end
-    def test_006D ; assert_equal( false, @d.include?(11) ) ; end
+  def setup
+    @a = Interval.new( 1, 10 )
+    @b = Interval.new( 1, 10, true, false )
+    @c = Interval.new( 1, 10, false, true )
+    @d = Interval.new( 1, 10, true, true )
+  end
 
+  def test_001A ; assert_equal( false, @a.include?(0)  ) ; end
+  def test_002A ; assert_equal( true,  @a.include?(1)  ) ; end
+  def test_003A ; assert_equal( true,  @a.include?(2)  ) ; end
+  def test_004A ; assert_equal( true,  @a.include?(9)  ) ; end
+  def test_005A ; assert_equal( true,  @a.include?(10) ) ; end
+  def test_006A ; assert_equal( false, @a.include?(11) ) ; end
+
+  def test_001B ; assert_equal( false, @b.include?(0)  ) ; end
+  def test_002B ; assert_equal( false, @b.include?(1)  ) ; end
+  def test_003B ; assert_equal( true,  @b.include?(2)  ) ; end
+  def test_004B ; assert_equal( true,  @b.include?(9)  ) ; end
+  def test_005B ; assert_equal( true,  @b.include?(10) ) ; end
+  def test_006B ; assert_equal( false, @b.include?(11) ) ; end
+
+  def test_001C ; assert_equal( false, @c.include?(0)  ) ; end
+  def test_002C ; assert_equal( true,  @c.include?(1)  ) ; end
+  def test_003C ; assert_equal( true,  @c.include?(2)  ) ; end
+  def test_004C ; assert_equal( true,  @c.include?(9)  ) ; end
+  def test_005C ; assert_equal( false, @c.include?(10) ) ; end
+  def test_006C ; assert_equal( false, @c.include?(11) ) ; end
+
+  def test_001D ; assert_equal( false, @d.include?(0)  ) ; end
+  def test_002D ; assert_equal( false, @d.include?(1)  ) ; end
+  def test_003D ; assert_equal( true,  @d.include?(2)  ) ; end
+  def test_004D ; assert_equal( true,  @d.include?(9)  ) ; end
+  def test_005D ; assert_equal( false, @d.include?(10) ) ; end
+  def test_006D ; assert_equal( false, @d.include?(11) ) ; end
+
+end
+
+class LrgNumericTest < Test::Unit::TestCase
+
+  def setup
+    @a = Interval.new(0,100000000)
+    @b = Interval.new(0,100000000)
   end
 
-  class LrgNumericTest < Test::Unit::TestCase
+  def test_001A ; assert_equal( true,  @a.include?(0)         ) ; end
+  def test_002A ; assert_equal( true,  @a.include?(1000)      ) ; end
+  def test_003A ; assert_equal( true,  @a.include?(1000000)   ) ; end
+  def test_004A ; assert_equal( true,  @a.include?(100000000) ) ; end
+  #def test_005A ; assert_equal( false, @a.include?(INFINITY)  ) ; end
 
-    def setup
-      @a = Interval.new(0,100000000)
-      @b = Interval.new(0,100000000)
-    end
+  def test_001B ; assert_equal( true,  @b.include?(0)         ) ; end
+  def test_002B ; assert_equal( true,  @b.include?(5)         ) ; end
+  def test_002B ; assert_equal( true,  @b.include?(70007)     ) ; end
+  def test_002B ; assert_equal( true,  @b.include?(5000005)   ) ; end
+  #def test_002B ; assert_equal( false, @b.include?(INFINITY)  ) ; end
 
-    def test_001A ; assert_equal( true,  @a.include?(0)         ) ; end
-    def test_002A ; assert_equal( true,  @a.include?(1000)      ) ; end
-    def test_003A ; assert_equal( true,  @a.include?(1000000)   ) ; end
-    def test_004A ; assert_equal( true,  @a.include?(100000000) ) ; end
-    #def test_005A ; assert_equal( false, @a.include?(INFINITY)  ) ; end
+end
 
-    def test_001B ; assert_equal( true,  @b.include?(0)         ) ; end
-    def test_002B ; assert_equal( true,  @b.include?(5)         ) ; end
-    def test_002B ; assert_equal( true,  @b.include?(70007)     ) ; end
-    def test_002B ; assert_equal( true,  @b.include?(5000005)   ) ; end
-    #def test_002B ; assert_equal( false, @b.include?(INFINITY)  ) ; end
+class SelectTest < Test::Unit::TestCase
 
+  def setup
+    @a = Interval.new( 0,10 )
   end
 
-  class SelectTest < Test::Unit::TestCase
+  def test_001
+    b = @a.collect( 2 ){ |n| n }
+    assert_equal( [0,2,4,6,8,10], b )
+  end
 
-    def setup
-      @a = Interval.new( 0,10 )
-    end
+  def test_002
+    b = @a.select{ |n| n % 2 == 0 }
+    assert_equal( [0,2,4,6,8,10], b )
+  end
 
-    def test_001
-      b = @a.collect( 2 ){ |n| n }
-      assert_equal( [0,2,4,6,8,10], b )
-    end
+  def test_003
+    b = @a.collect( 1,2 ){ |n| n }
+    assert_equal( [0,5,10], b )
+  end
 
-    def test_002
-      b = @a.select{ |n| n % 2 == 0 }
-      assert_equal( [0,2,4,6,8,10], b )
-    end
+  def test_004
+    b = @a.select( 1,2 ){ |n| n % 2 == 0 }
+    assert_equal( [0,10], b )
+  end
 
-    def test_003
-      b = @a.collect( 1,2 ){ |n| n }
-      assert_equal( [0,5,10], b )
-    end
+end
 
-    def test_004
-      b = @a.select( 1,2 ){ |n| n % 2 == 0 }
-      assert_equal( [0,10], b )
-    end
+class ArrayTest < Test::Unit::TestCase
 
+  def setup
+    @a = Interval.new( 0,10 )
+    @b = Interval.new( 0,1 )
   end
 
-  class ArrayTest < Test::Unit::TestCase
+  def test_001A ; assert_equal( [0,5,10], @a.to_a(1,2) ) ; end
 
-    def setup
-      @a = Interval.new( 0,10 )
-      @b = Interval.new( 0,1 )
-    end
+  def test_001B ; assert_equal( [0, 0.25, 0.5, 0.75, 1.0], @b.to_a(1,4) ) ; end
 
-    def test_001A ; assert_equal( [0,5,10], @a.to_a(1,2) ) ; end
+end
 
-    def test_001B ; assert_equal( [0, 0.25, 0.5, 0.75, 1.0], @b.to_a(1,4) ) ; end
 
-  end
+=begin
+  class InfTest < Test::Unit::TestCase
 
+    def setup
+      @a = Interval.new( -INFINITY, -3 )
+      @b = Interval.new( -INFINITY, -3, true, false )
+      @c = Interval.new( -3, INFINITY )
+      @d = Interval.new( -INFINITY, INFINITY )
+      @e = Interval.new( -3, -2 )
+    end
 
+    def test_001A ; assert_equal( true,  @a.include?(-INFINITY) ) ; end
+    def test_002A ; assert_equal( true,  @a.include?(-4)        ) ; end
+    def test_003A ; assert_equal( true,  @a.include?(-3)        ) ; end
+    def test_004A ; assert_equal( false, @a.include?(-2)        ) ; end
+    def test_005A ; assert_equal( false, @a.include?(INFINITY)  ) ; end
+
+    def test_001B ; assert_equal( true,  @b.include?(-INFINITY) ) ; end
+    def test_002B ; assert_equal( true,  @b.include?(-4)        ) ; end
+    def test_003B ; assert_equal( false, @b.include?(-3)        ) ; end
+    def test_004B ; assert_equal( false, @b.include?(-2)        ) ; end
+    def test_005B ; assert_equal( false, @b.include?(INFINITY)  ) ; end
+
+    def test_001C ; assert_equal( false, @c.include?(-INFINITY) ) ; end
+    def test_002C ; assert_equal( false, @c.include?(-4)        ) ; end
+    def test_003C ; assert_equal( true,  @c.include?(-3)        ) ; end
+    def test_004C ; assert_equal( true,  @c.include?(-2)        ) ; end
+    def test_005C ; assert_equal( true,  @c.include?(INFINITY)  ) ; end
+
+    def test_001D ; assert_equal( true,  @d.include?(-INFINITY) ) ; end
+    def test_002D ; assert_equal( true,  @d.include?(-4)        ) ; end
+    def test_003D ; assert_equal( true,  @d.include?(-3)        ) ; end
+    def test_004D ; assert_equal( true,  @d.include?(-2)        ) ; end
+    def test_005D ; assert_equal( true,  @d.include?(INFINITY)  ) ; end
+
+    def test_001E ; assert_equal( false, @e.include?(-INFINITY) ) ; end
+    def test_002E ; assert_equal( false, @e.include?(-4)        ) ; end
+    def test_003E ; assert_equal( true,  @e.include?(-3)        ) ; end
+    def test_004E ; assert_equal( true,  @e.include?(-2)        ) ; end
+    def test_005E ; assert_equal( false, @e.include?(INFINITY)  ) ; end
 
+  end
+=end