facets 2.6.0 → 2.7.0

data/test/more/test_bbcode.rb

@@ -1,21 +0,0 @@
-# Test for facets/bbcode.rb
-
-require 'facets/bbcode.rb'
-require 'test/unit'
-
-class TC_BBCode < Test::Unit::TestCase
-
-  def test_to_ansi
-    str = "this is [COLOR=red]red[/COLOR], this is [B]bold[/B]"
-    out = "this is \e[0;31mred\e[0m, this is \e[1mbold\e[0m\n"
-    assert_equal( out, BBCode.bbcode_to_ansi(str) )
-  end
-
-  def test_to_html
-    str = "this is [COLOR=red]red[/COLOR], this is [B]bold[/B]"
-    out = "this is <font color=\"red\">red</font>, this is <strong>bold</strong><br />\n"
-    assert_equal( out, BBCode.bbcode_to_html(str) )
-  end
-
-end
-

data/test/more/test_binreadable.rb

@@ -1,50 +0,0 @@
-# Test for facets/binreadable.rb
-
-require 'facets/binreadable.rb'
-require 'test/unit'
-
-class TC_ByteOrder < Test::Unit::TestCase
-
-  include BinaryReader
-
-  def test_equal
-    assert_equal ByteOrder.little?, ByteOrder.little_endian?
-    assert_equal ByteOrder.big?, ByteOrder.big_endian?
-    assert_equal ByteOrder.network?, ByteOrder.big_endian?
-    assert_equal ByteOrder.byte_order, ByteOrder.byteorder
-
-    assert_equal ByteOrder::Big, ByteOrder::BigEndian
-    assert_equal ByteOrder::Network, ByteOrder::BigEndian
-    assert_equal ByteOrder::Little, ByteOrder::LittleEndian
-
-    assert_equal ByteOrder.byte_order, ByteOrder::LittleEndian if ByteOrder.little?
-    assert_equal ByteOrder.byte_order, ByteOrder::BigEndian if ByteOrder.big?
-  end
-
-  def test_uname_byteorder
-    assert_equal(ByteOrder.little?, true) if `uname -m` =~ /i386/
-  end
-
-  def test_byteorder
-    if ByteOrder.little?
-      assert_equal "\x12\x34\x56\x78".unpack("L").first, 0x78563412
-      assert_equal "\x78\x56\x34\x12".unpack("L").first, 0x12345678
-      assert_equal [0x12345678].pack("L"), "\x78\x56\x34\x12"
-      assert_equal [0x78563412].pack("L"), "\x12\x34\x56\x78"
-    else
-      assert_equal "\x12\x34\x56\x78".unpack("L").first, 0x12345678
-      assert_equal "\x78\x56\x34\x12".unpack("L").first, 0x78563412
-      assert_equal [0x12345678].pack("L"), "\x12\x34\x56\x78"
-      assert_equal [0x78563412].pack("L"), "\x78\x56\x34\x12"
-    end
-  end
-
-end
-
-class TC_BinaryReader < Test::Unit::TestCase
-
-  def test_todo
-    assert(true)  # to do
-  end
-
-end

data/test/more/test_buildable.rb

@@ -1,73 +0,0 @@
-# Test facets/buildable.rb
-
-require 'facets/buildable.rb'
-require 'test/unit'
-
-class TestBuildable < Test::Unit::TestCase
-
-  module M
-    include Buildable
-
-    extend self
-
-    def m(n,*m) ; "#{n}{#{m}}"; end
-    def t(n) ; "#{n}"; end
-
-    alias :build :m
-  end
-
-  def test_01
-    str = M.build do
-      html do
-        head do
-          title "Test"
-        end
-        body do
-          i "Hello"
-          build! :not
-          t "Test"
-          t "Hey"
-        end
-      end
-    end
-
-    r = "html{head{title{Test}}body{i{Hello}not{}TestHey}}"
-
-    assert_equal( r, M.builder.to_s )
-  end
-
-end
-
-#
-
-class TestBuildingBlock < Test::Unit::TestCase
-
-  module M
-    extend self
-    def m(n,*m) ; "#{n}{#{m}}"; end
-    def t(n) ; "#{n}"; end
-  end
-
-  def test_01
-    build = BuildingBlock.new(M, :m)
-
-    build.html do
-      head do
-        title "Test"
-      end
-
-      body do
-        i "Hello"
-        build! :not
-        t "Test"
-        t "Hey"
-      end
-    end
-
-    r = "html{head{title{Test}}body{i{Hello}not{}TestHey}}"
-
-    assert_equal( r, build.to_s )
-  end
-
-end
-

data/test/more/test_classmethods.rb

@@ -1,56 +0,0 @@
-# Test facets/classmethods.rb.
-
-require 'facets/classmethods.rb'
-require 'test/unit'
-
-class TC_ClassMethods < Test::Unit::TestCase
-
-  # fixture
-
-  module N
-    class_methods do
-      def n ; 43 ; end
-      def s ; self ; end
-    end
-  end
-
-  class X
-    include N
-    def n ; 11 ; end
-  end
-
-  module K
-    include N
-    class_methods do
-      def n ; super + 1 ; end
-    end
-  end
-
-  class Z
-    include K
-  end
-
-  # tests
-
-  def test_knows_self
-    assert_equal( 43, N.n )
-    assert_equal(  N,  N.s )
-  end
-  def test_included
-    assert_equal( 43, X.n )
-    assert_equal(  X, X.s )
-  end
-  def test_instance_level
-    assert_equal( 11, X.new.n )
-  end
-  def test_included_and_redefined
-    assert_equal( 44, K.n )
-    assert_equal(  K, K.s )
-  end
-  def test_included_again
-    assert_equal( 44, Z.n )
-    assert_equal(  Z, Z.s )
-  end
-
-end
-

data/test/more/test_crypt.rb

@@ -1,32 +0,0 @@
-# Test facets/crypt.rb
-
-require "facets/crypt.rb"
-require "test/unit"
-
-class CryptTest < Test::Unit::TestCase
-
-  def array_test(arr, algo)
-    arr.each do |password, hash|
-      assert(Crypt.check(password, hash, algo))
-    end
-  end
-
-  def test_md5
-    a = [ [' ', '$1$yiiZbNIH$YiCsHZjcTkYd31wkgW8JF.'],
-      ['pass', '$1$YeNsbWdH$wvOF8JdqsoiLix754LTW90'],
-      ['____fifteen____', '$1$s9lUWACI$Kk1jtIVVdmT01p0z3b/hw1'],
-      ['____sixteen_____', '$1$dL3xbVZI$kkgqhCanLdxODGq14g/tW1'],
-      ['____seventeen____', '$1$NaH5na7J$j7y8Iss0hcRbu3kzoJs5V.'],
-      ['__________thirty-three___________', '$1$HO7Q6vzJ$yGwp2wbL5D7eOVzOmxpsy.'],
-      ['apache', '$apr1$J.w5a/..$IW9y6DR0oO/ADuhlMF5/X1']
-    ]
-    array_test(a, :md5)
-  end
-
-  def test_bad_algo
-    assert_raise(ArgumentError) do
-      Crypt.crypt("qsdf", :qsdf)
-    end
-  end
-
-end

data/test/more/test_dependency.rb

@@ -1,69 +0,0 @@
-# Test facets/dependency.rb
-
-require 'facets/dependency.rb'
-require 'test/unit'
-
-class DependableTest1 < Test::Unit::TestCase
-
-  class C
-    #extend MethodDependency
-
-    attr :s
-    def initialize
-      @s = ''
-    end
-
-    def x ; @s << 'x'; end
-    def y ; @s << 'y'; end
-    def z ; @s << 'z'; end
-
-    depend :x => :y
-    depend :z => [:x, :y]
-  end
-
-  module M
-    #extend MethodDependency
-
-    attr :s
-    def initialize
-      @s = ''
-    end
-
-    def x ; @s << 'x'; end
-    def y ; @s << 'y'; end
-    def z ; @s << 'z'; end
-
-    depend :x => :y
-    depend :z => [:x, :y]
-  end
-
-  class D
-    include M
-  end
-
-  def test_01
-    c = C.new
-    c.x
-    assert_equal( 'yx', c.s )
-  end
-
-  def test_02
-    c = C.new
-    c.z
-    assert_equal( 'yxz', c.s )
-  end
-
-  def test_03
-    c = D.new
-    c.x
-    assert_equal( 'yx', c.s )
-  end
-
-  def test_04
-    c = D.new
-    c.z
-    assert_equal( 'yxz', c.s )
-  end
-
-end
-

data/test/more/test_elementwise.rb

@@ -1,25 +0,0 @@
-# Test lib/more/ext/enumerable/elementwise.rb'
-
-require 'facets/elementwise.rb'
-require 'test/unit'
-
-class TestElementWise < Test::Unit::TestCase
-
-  def test_elementwise
-    a = [1,2,3]
-    b = [4,5]
-    assert_equal( [4,5,6], a.elementwise + 3 )
-    assert_equal( [5,7], a.elementwise + b )
-    assert_equal( [[5,7],[3,4,5]], a.elementwise.+(b,2) )
-    assert_equal( [[5,7],[4,5,6]], a.elementwise.+(b,3) )
-  end
-
-  def test_ewise
-    a = [1,2,3]
-    assert_equal( [4,5,6], a.ewise + 3 )
-    assert_equal( [5,7], a.ewise + [4,5] )
-    assert_equal( [[5,7],[3,4,5]], a.ewise.+([4,5],2) )
-    assert_equal( [[5,7],[4,5,6]], a.ewise.+([4,5],3) )
-  end
-
-end

data/test/more/test_infinity.rb

@@ -1,40 +0,0 @@
-# Test 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/more/test_interval.rb

@@ -1,151 +0,0 @@
-# Test facets/interval.rb
-
-require 'facets/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_003B ; assert_equal( true,  @b.include?(70007)     ) ; end
-  def test_004B ; assert_equal( true,  @b.include?(5000005)   ) ; end
-  #def test_005B ; assert_equal( false, @b.include?(INFINITY)  ) ; end
-
-end
-
-class TC_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
-
-
-=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