facets 1.0.2 → 1.0.3

data/packages/more/test/lib/facet/test_interval.rb

@@ -0,0 +1,119 @@
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+# for lib/facet/interval.rb
+#
+# Extracted Wed Jan 25 10:52:51 EST 2006
+# Unit Tools Reap Test Extractor
+#
+
+require 'facet/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
+
+

data/packages/more/test/lib/facet/test_lisp-format.rb

@@ -0,0 +1,37 @@
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+# for lib/facet/lisp-format.rb
+#
+# Extracted Wed Jan 25 10:52:51 EST 2006
+# Unit Tools Reap Test Extractor
+#
+
+require 'facet/lisp-format.rb'
+
+
+  require 'test/unit'
+
+  class FormatTest < Test::Unit::TestCase
+
+    def test_decimal
+      assert( Lisp.format("~D", 1) == "1" )
+    end
+
+    def test_decimal_params
+      assert( Lisp.format("~5,'-D~6D", 1, 2) == "----1     2" )
+    end
+
+    def test_decimal_modifiers
+      assert( Lisp.format("~5,'-,'.:@D~@D", 1013, 2) == "+1.013+2" )
+      assert( Lisp.format("~7,,,2:@D~@D", 1013, 2) == " +10,13+2" )
+    end
+
+    # Tests for ~v, ~V, ~#
+
+  end
+
+

data/packages/more/test/lib/facet/test_lisp.rb

@@ -0,0 +1,47 @@
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+# for lib/facet/lisp.rb
+#
+# Extracted Wed Jan 25 10:52:51 EST 2006
+# Unit Tools Reap Test Extractor
+#
+
+require 'facet/lisp.rb'
+
+
+  require 'test/unit'
+
+  # fixture
+
+  class T
+
+    include Lisp
+
+    (def accumulate (fun, x, list)
+      (if (null? list)
+        x
+      else
+        (accumulate fun, (fun.call x, (car list)), (cdr list))
+      end)
+    end)
+
+  end
+
+  # test
+
+  class TC_Lisp < Test::Unit::TestCase
+
+    include Lisp
+
+    def test_accumulate
+      t = T.new
+      t.accumulate( proc{ |x,y| x+y }, 0, [1,2,3] )
+    end
+
+  end
+
+

data/packages/more/test/lib/facet/test_lrucache.rb

@@ -0,0 +1,25 @@
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+# for lib/facet/lrucache.rb
+#
+# Extracted Wed Jan 25 10:52:51 EST 2006
+# Unit Tools Reap Test Extractor
+#
+
+require 'facet/lrucache.rb'
+
+
+  require 'test/unit'
+
+  class TC_LRUCache < Test::Unit::TestCase
+
+    def test_01
+    end
+
+  end
+
+

data/packages/more/test/lib/facet/test_mathconstants.rb

@@ -0,0 +1,18 @@
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+# for lib/facet/mathconstants.rb
+#
+# Extracted Wed Jan 25 10:52:51 EST 2006
+# Unit Tools Reap Test Extractor
+#
+
+require 'facet/mathconstants.rb'
+
+
+  # If it loads, it works.
+
+

data/packages/more/test/lib/facet/test_methodprobe.rb

@@ -0,0 +1,53 @@
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+# for lib/facet/methodprobe.rb
+#
+# Extracted Wed Jan 25 10:52:51 EST 2006
+# Unit Tools Reap Test Extractor
+#
+
+require 'facet/methodprobe.rb'
+
+
+  require 'test/unit'
+
+  # " I am a Duck Hunter ! "
+
+  class TC_MethodProbe < Test::Unit::TestCase
+
+    # fixture
+    def amethod(x)
+      x + 1
+    end
+
+    def test_signiture_default
+      assert_nothing_raised {
+        method(:amethod).signature
+      }
+    end
+
+    def test_signiture_with_class
+      assert_nothing_raised {
+        method(:amethod).signature(:class)
+      }
+    end
+
+    def test_signiture_pp
+      assert_nothing_raised {
+        method(:amethod).signature(:pp)
+      }
+    end
+
+    def test_signiture_all
+      assert_nothing_raised {
+        method(:amethod).signature(:complete)
+      }
+    end
+
+  end
+
+

data/packages/more/test/lib/facet/test_multipliers.rb

@@ -0,0 +1,114 @@
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+# for lib/facet/multipliers.rb
+#
+# Extracted Wed Jan 25 10:52:51 EST 2006
+# Unit Tools Reap Test Extractor
+#
+
+require 'facet/multipliers.rb'
+
+
+  require 'test/unit'
+
+  class TC_Multipliers < Test::Unit::TestCase
+
+    def test_deka
+      assert_equal( 10, 1.deka )
+    end
+
+    def test_hecto
+      assert_equal( 100, 1.hecto )
+    end
+
+    def test_kilo
+      assert_equal( 1000, 1.kilo )
+    end
+
+    def test_mega
+      assert_equal( 1000000, 1.mega )
+    end
+
+    def test_giga
+      assert_equal( 1000000000, 1.giga )
+    end
+
+    def test_tera
+      assert_equal( 1000000000000, 1.tera )
+    end
+
+    def test_peta
+      assert_equal( 1000000000000000, 1.peta )
+    end
+
+    def test_exa
+      assert_equal( 1000000000000000000, 1.exa )
+    end
+
+    # Fractional
+
+    def test_deci
+      assert_equal( 0.1, 1.deci )
+    end
+
+    def test_centi
+      assert_equal( 0.01, 1.centi )
+    end
+
+    def test_milli
+      assert_equal( 0.001, 1.milli )
+    end
+
+    def test_milli
+      assert_equal( 0.000001, 1.micro )
+    end
+
+    def test_nano
+      assert_equal( 0.000000001, 1.nano )
+    end
+
+    def test_pico
+      assert_equal( 0.000000000001, 1.pico )
+    end
+
+    def test_femto
+      assert_equal( 0.000000000000001, 1.femto )
+    end
+
+    def test_atto
+      assert_equal( 0.000000000000000001, 1.atto )
+    end
+
+    # SI Binary
+
+    def test_kibi
+      assert_equal( 1024, 1.kibi )
+    end
+
+    def test_mebi
+      assert_equal( 1024**2, 1.mebi )
+    end
+
+    def test_gibi
+      assert_equal( 1024**3, 1.gibi )
+    end
+
+    def test_tebi
+      assert_equal( 1024**4, 1.tebi )
+    end
+
+    def test_pebi
+      assert_equal( 1024**5, 1.pebi )
+    end
+
+    def test_exbi
+      assert_equal( 1024**6, 1.exbi )
+    end
+
+  end
+
+

data/packages/more/test/lib/facet/test_multiton.rb

@@ -0,0 +1,200 @@
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+# for lib/facet/multiton.rb
+#
+# Extracted Wed Jan 25 10:52:51 EST 2006
+# Unit Tools Reap Test Extractor
+#
+
+require 'facet/multiton.rb'
+
+
+  require 'test/unit'
+
+  #
+  # EXAMPLE A - STANDARD USAGE
+  #
+  class TC_Multiton_A < Test::Unit::TestCase
+
+    class SomeMultitonClass
+      include Multiton
+      attr :arg
+      def initialize(arg)
+        @arg = arg
+      end
+    end
+
+    def test_standard
+
+      a = SomeMultitonClass.instance(4)
+      b = SomeMultitonClass.instance(4)     # a and b are same object
+      c = SomeMultitonClass.instance(2)     # c is a different object
+
+      assert_equal( a, b )
+      assert_equal( 42, [a.arg,b.arg].max * 10 + c.arg )
+
+    end
+
+  end
+
+
+  #
+  # EXAMPLE B - MODIFY AN EXISTING CLASS, SHARED FILEHANDLES
+  #
+  class TC_Multiton_B < Test::Unit::TestCase
+
+    class ::File
+      include Multiton
+    end
+
+    def test_modify_existing
+
+      lineno = __LINE__
+      # HERE1
+      # HERE2
+
+      a = File.instance(__FILE__)
+      b = File.instance(__FILE__)
+
+      assert_equal( a, b )
+
+      lineno.times{ a.gets }
+
+      assert_equal( "# HERE1", a.gets.strip )
+      assert_equal( "# HERE2", b.gets.strip )
+
+    end
+
+  end
+
+  #
+  # EXAMPLE C - INHERITENCE
+  #
+  class TC_Multiton_C < Test::Unit::TestCase
+
+    class A < String
+      include Multiton
+    end
+
+    # B is also a multiton - with it's OWN object cache
+    class B < A; end
+
+    def test_inheritence
+
+      # w is the same object as x, y is the same object as z
+      w,x,y,z = A.instance('A'), A.instance('A'), B.instance('B'), B.instance('B')
+
+      assert_equal( w.object_id, x.object_id ) # -> true
+      assert_equal( y.object_id, z.object_id ) # -> true
+
+      a = B.instance('A')
+      b = B.instance('A')
+
+      assert_not_equal( a.object_id, w.object_id ) # -> false (each class has it's own pool)
+      assert_equal( a.object_id, b.object_id )     # -> true
+
+    end
+
+  end
+
+
+  #
+  # EXAMPLE D - MULTIPLE MODULE INCLUSION (does nothing)
+  #
+  class TC_Multiton_D < Test::Unit::TestCase
+
+    class A < String
+      include Multiton
+    end
+
+    # B is also a multiton - with it's OWN object cache
+    class B < A; end
+
+    def test_multiple
+
+      # w is the same object as x, y is the same object as z
+      w,x,y,z = A.instance('A'), A.instance('A'), B.instance('B'), B.instance('B')
+
+      yz_id = y.object_id || z.object_id
+
+      B.class_eval {
+        include Multiton
+      }
+
+      # y is not only the same object as z, but they are both the same object(s)
+      # as from EXAMPLE C
+
+      y,z = B.instance('B'), B.instance('B')
+
+      assert_equal( y.object_id, yz_id )   # -> true
+      assert_equal( z.object_id, yz_id ) # -> true
+
+    end
+
+  end
+
+  #
+  # EXAMPLE E - SO YOU WANNA USE NEW INSTEAD OF INSTANCE...
+  #
+  class TC_Multiton_E < Test::Unit::TestCase
+
+    module K
+      # use an inner class which is itself a multiton
+      class K < String; include Multiton; end
+
+      # define a new which returns a mutltion using #instance... 
+      class << self
+        def new(*args, &block)
+          K.instance *args, &block
+        end
+      end
+    end
+
+    def test_new
+
+      the = K.new '4'
+      answer = K.new '2'
+
+      assert_equal( "42", sprintf( "%s%s", the, answer ) )  #-> 42
+      assert_equal( K::K, the.class )  #-> K::K
+
+    end
+
+  end
+
+  #
+  # EXAMPLE F - using Klass.multiton_id 
+  #
+  class TC_Multiton_F < Test::Unit::TestCase
+
+    class Klass
+      include Multiton
+
+      def initialize( important, not_important )
+        @important, @not_important = important, not_important
+      end
+
+      def Klass.multiton_id(*args, &block)
+        # we consider only the first arg
+        important, not_important = *args
+        important
+      end
+    end
+
+    def test_using_id
+      a = Klass.instance( :a, :b )
+      b = Klass.instance( :a, :c )
+      c = Klass.instance( :b, :b )
+
+      assert_equal( a, b )
+      assert_not_equal( a, c )
+      assert_not_equal( b, c )
+    end
+
+  end
+
+