facets 1.8.49 → 1.8.51

data/test/lib/facets/more/test_htmlfilter.rb

@@ -1,86 +0,0 @@
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-# for lib/facets/more/htmlfilter.rb
-#
-# Extracted Fri Feb 16 02:00:36 EST 2007
-# Project.rb Test Extraction
-#
-
-require 'facets/more/htmlfilter.rb'
-
-
-  require 'test/unit'
-
-  class TestHtmlFilter < Test::Unit::TestCase
-
-    # core tests
-
-    def test_multiton_without_options
-      h1 = HtmlFilter.new
-      h2 = HtmlFilter.new
-      h3 = HtmlFilter.new( :strip_comments => false )
-      assert_equal( h1.object_id, h2.object_id )
-      assert_not_equal( h1.object_id, h3.object_id )
-    end
-
-    def test_multiton_with_options
-      h1 = HtmlFilter.new( :strip_comments => false )
-      h2 = HtmlFilter.new( :strip_comments => false )
-      h3 = HtmlFilter.new
-      assert_equal( h1.object_id, h2.object_id )
-      assert_not_equal( h1.object_id, h3.object_id )
-    end
-
-    def test_strip_single
-      hf = HtmlFilter.new
-      assert_equal( '"', hf.send(:strip_single,'\"') )
-      assert_equal( "\000", hf.send(:strip_single,'\0') )
-    end
-
-    # functional tests
-
-    def assert_filter(filtered, original)
-      assert_equal(filtered, original.html_filter)
-    end
-
-    def test_fix_quotes
-      assert_filter '<img src="foo.jpg" />', "<img src=\"foo.jpg />"
-    end
-
-    def test_basics
-      assert_filter '', ''
-      assert_filter 'hello', 'hello'
-    end
-
-    def test_balancing_tags
-      assert_filter "<b>hello</b>", "<<b>hello</b>"
-      assert_filter "<b>hello</b>", "<b>>hello</b>"
-      assert_filter "<b>hello</b>", "<b>hello<</b>"
-      assert_filter "<b>hello</b>", "<b>hello</b>>" 
-      assert_filter "", "<>"
-    end
-
-    def test_tag_completion
-      assert_filter "hello", "hello<b>"
-      assert_filter "<b>hello</b>", "<b>hello"
-      assert_filter "hello<b>world</b>", "hello<b>world"
-      assert_filter "hello", "hello</b>"
-      assert_filter "hello", "hello<b/>"
-      assert_filter "hello<b>world</b>", "hello<b/>world"
-      assert_filter "<b><b><b>hello</b></b></b>", "<b><b><b>hello"
-      assert_filter "", "</b><b>"
-    end
-
-    def test_end_slashes
-      assert_filter '<img />', '<img>'
-      assert_filter '<img />', '<img/>'
-      assert_filter '', '<b/></b>'
-    end
-
-  end
-
-

data/test/lib/facets/more/test_infinity.rb

@@ -1,50 +0,0 @@
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-# for lib/facets/more/infinity.rb
-#
-# Extracted Fri Feb 16 02:00:36 EST 2007
-# Project.rb Test Extraction
-#
-
-require 'facets/more/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/lib/facets/more/test_inheritor.rb

@@ -1,155 +0,0 @@
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-# for lib/facets/more/inheritor.rb
-#
-# Extracted Fri Feb 16 02:00:36 EST 2007
-# Project.rb Test Extraction
-#
-
-require 'facets/more/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
-  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
-  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
-
-    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
-
-  class TC05 < Test::Unit::TestCase
-    class C
-      inheritor :relations, [], :concat
-    end
-    class D < C
-      #inheritor :relations, [], :concat
-    end
-
-    C.relations! << 1
-    C.relations! << 2
-    D.relations! << 3
-
-    def test_05_001
-      assert_equal( [1,2], C.relations )
-      assert_equal( [1,2,3], D.relations )
-    end
-  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
-
-    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/lib/facets/more/test_instance_intercept.rb

@@ -1,50 +0,0 @@
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-# for lib/facets/more/instance_intercept.rb
-#
-# Extracted Fri Feb 16 02:00:36 EST 2007
-# Project.rb Test Extraction
-#
-
-require 'facets/more/instance_intercept.rb'
-
-
-  require 'test/unit'
-
-  class TestModule < Test::Unit::TestCase
-
-    module A
-
-      def f ; "F" ; end
-      def g ; "G" ; end
-
-      instance_interception do
-        def f( target, *args, &blk )
-          '{' + target.super + '}'
-        end
-        def g( target, *args, &blk )
-          '{' + target.super + '}'
-        end
-      end
-
-    end
-
-    class X
-      def f ; super ; end
-      include A
-      def g ; super ; end
-    end
-
-    def test_1_01
-      x = X.new
-      assert_equal( "{F}", x.f )
-      assert_equal( "{G}", x.g )
-    end
-
-  end
-
-

data/test/lib/facets/more/test_interval.rb

@@ -1,119 +0,0 @@
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-# for lib/facets/more/interval.rb
-#
-# Extracted Fri Feb 16 02:00:36 EST 2007
-# Project.rb Test Extraction
-#
-
-require 'facets/more/interval.rb'
-
-
-  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
-
-  end
-
-  class LrgNumericTest < Test::Unit::TestCase
-
-    def setup
-      @a = Interval.new(0,100000000)
-      @b = Interval.new(0,100000000)
-    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
-
-    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
-
-  end
-
-  class SelectTest < Test::Unit::TestCase
-
-    def setup
-      @a = Interval.new( 0,10 )
-    end
-
-    def test_001
-      b = @a.collect( 2 ){ |n| n }
-      assert_equal( [0,2,4,6,8,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_003
-      b = @a.collect( 1,2 ){ |n| n }
-      assert_equal( [0,5,10], b )
-    end
-
-    def test_004
-      b = @a.select( 1,2 ){ |n| n % 2 == 0 }
-      assert_equal( [0,10], b )
-    end
-
-  end
-
-  class ArrayTest < Test::Unit::TestCase
-
-    def setup
-      @a = Interval.new( 0,10 ) 
-      @b = Interval.new( 0,1 ) 
-    end
-
-    def test_001A ; assert_equal( [0,5,10], @a.to_a(1,2) ) ; end
-
-    def test_001B ; assert_equal( [0, 0.25, 0.5, 0.75, 1.0], @b.to_a(1,4) ) ; end
-
-  end
-
-