carats 0.3.0

data/test/tc_init.rb

@@ -0,0 +1,29 @@
+
+require 'test/unit'
+require 'carat/init'
+
+
+# fixture
+
+class T
+  attr_reader :x, :y
+  def init
+    @x = 1
+    @y = 2
+  end
+end
+
+# test
+
+class TC_Init < Test::Unit::TestCase
+
+  def setup
+    @a = T.new
+  end
+
+  def test_init
+    assert_equal(1, @a.x)
+    assert_equal(2, @a.y)
+  end
+
+end

data/test/tc_interval.rb

@@ -0,0 +1,153 @@
+
+require 'test/unit'
+require 'carat/interval'
+
+
+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
+
+
+=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
+
+
+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/test/tc_io-reactor.rb

@@ -0,0 +1,5 @@
+
+require 'test/unit'
+require 'carat/io-reactor.rb'
+
+# TODO 

data/test/tc_io-redirect.rb

@@ -0,0 +1,5 @@
+
+require 'test/unit'
+require 'carat/io-redirect.rb'
+
+# TODO 

data/test/tc_lisp-format.rb

@@ -0,0 +1,24 @@
+
+require 'test/unit'
+require 'carat/lisp-format'
+
+
+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/test/tc_lisp.rb

@@ -0,0 +1,32 @@
+
+require 'test/unit'
+require 'carat/lisp'
+
+# 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/test/tc_macro.rb

@@ -0,0 +1,48 @@
+
+require 'test/unit'
+require 'carat/macro'
+
+
+# fixture
+
+module Mixin
+  macro { |options| %{
+    def hello
+      '#{options[:name]}'
+    end
+  } }
+end
+
+class MyClass1
+  include Mixin, :name => 'tml1'
+end
+
+class MyClass2
+  include Mixin, :name => 'tml2'
+end
+
+class MyClass3
+  extend Mixin, :name => 'TML'
+end
+
+
+# test
+
+class TC_Macro < Test::Unit::TestCase
+
+  def setup
+    @m1 = MyClass1.new
+    @m2 = MyClass2.new
+  end
+
+  def test_include
+    assert_equal( 'tml1', @m1.hello )
+    assert_equal( 'tml2', @m2.hello )
+    assert_equal( 'tml1', @m1.hello )
+  end
+
+  def test_extend
+    assert_equal( 'TML', MyClass3.hello )
+  end
+
+end

data/test/tc_multiton.rb

@@ -0,0 +1,188 @@
+
+require 'test/unit'
+require 'carat/multiton'
+
+#
+# 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
+