carats 0.3.0

data/test/fixtures/filelist/testfile.txt

@@ -0,0 +1 @@
+ 

data/test/fixtures/filelist/testfile2.txt

@@ -0,0 +1 @@
+ 

data/test/tc_1st.rb

@@ -0,0 +1,16 @@
+
+require 'test/unit'
+require 'carat/1st'
+
+
+class TC_First < Test::Unit::TestCase
+
+  def ameth
+    "x"
+  end
+
+  def test_methods
+    assert_equal( method(:ameth), method(:ameth) )
+  end
+
+end

data/test/tc_ansicolor.rb

@@ -0,0 +1,23 @@
+
+require 'test/unit'
+require 'carat/ansicolor'
+
+
+class TC_ANSIColor < Test::Unit::TestCase
+
+  include Term::ANSIColor
+
+  def test_methods
+    str = red + "Hello" + blue + "World"
+    out = "\e[31mHello\e[34mWorld"
+    assert_equal( out, str )
+  end
+
+  def test_blocks
+    str = red { "Hello" } + blue { "World" }
+    out = "\e[31mHello\e[0m\e[34mWorld\e[0m"
+    assert_equal( out, str )
+  end
+
+  
+end

data/test/tc_attr.rb

@@ -0,0 +1,46 @@
+
+require 'test/unit'
+require 'carat/attr'
+
+
+# fixture
+
+class C
+  attr :a, :a=
+  attr :b?, :b=
+  attr :c, true
+  attr :d, :e, true
+end
+
+# test
+
+class TC_Attr < Test::Unit::TestCase
+
+  def setup
+    @c = C.new
+  end
+
+  def test_1
+    assert_nothing_raised{ @c.a = 10 }
+    assert_equal( 10, @c.a )
+  end
+  
+  def test_2
+    assert_nothing_raised{ @c.b = "1" }
+    assert( @c.b? )
+  end
+  
+  def test_3
+    assert_nothing_raised{ @c.c = 20 }
+    assert_equal( 20, @c.c )  
+  end
+  
+  def test_4
+    assert_nothing_raised{ @c.d = 30 }
+    assert_equal( 30, @c.d )  
+    assert_nothing_raised{ @c.e = 40 }
+    assert_equal( 40, @c.e )    
+  end
+
+end
+

data/test/tc_bbcode.rb

@@ -0,0 +1,20 @@
+
+require 'test/unit'
+require 'carat/bbcode'
+
+
+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/tc_binaryreader.rb

@@ -0,0 +1,14 @@
+
+# TODO
+
+require 'test/unit'
+require 'carat/binaryreader'
+
+
+class TC_BinaryReader < Test::Unit::TestCase
+
+  def test_todo
+    assert(true)  # to do
+  end
+
+end

data/test/tc_binding_of_caller.rb

@@ -0,0 +1,2 @@
+
+# TODO

data/test/tc_byteorder.rb

@@ -0,0 +1,41 @@
+# By Michael Neumann
+
+require 'test/unit'
+require 'carat/byteorder'
+
+class TC_ByteOrder < Test::Unit::TestCase
+
+  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
+ 

data/test/tc_constant.rb

@@ -0,0 +1,12 @@
+
+require 'test/unit'
+
+class TC_Constant < Test::Unit::TestCase
+
+  def test_loads
+    assert_nothing_raised { 
+      require 'carat/constant'
+    }
+  end
+
+end

data/test/tc_coroutine.rb

@@ -0,0 +1,50 @@
+
+require 'test/unit'
+require 'carat/coroutine'
+
+
+class TC_Coroutine < Test::Unit::TestCase
+
+  def test_run
+    assert_nothing_raised {
+
+      count = (ARGV.shift || 1000).to_i
+
+      input = (1..count).map { (rand * 10000).round.to_f / 100}
+
+      @producer = Coroutine.new do |me|
+        loop do
+          1.upto(6) do
+            me[:last_input] = input.shift
+            me.resume(@printer)
+          end
+          input.shift  # discard every seventh input number
+        end
+      end
+
+      @printer = Coroutine.new do |me|
+        loop do
+          1.upto(8) do
+            me.resume(@producer)
+            if @producer[:last_input]
+              #print @producer[:last_input], "\t"
+              @producer[:last_input] = nil
+            end
+            me.resume(@controller)
+          end
+          #puts
+        end
+      end
+
+      @controller = Coroutine.new do |me|
+        until input.empty? do
+          me.resume(@printer)
+        end
+      end
+      @controller.run
+      puts
+
+    }
+  end
+    
+end

data/test/tc_crosscase.rb

@@ -0,0 +1,33 @@
+
+require 'test/unit'
+require 'carat/crosscase'
+
+
+class TC_CrossCase < Test::Unit::TestCase
+
+  # Test to be sure the module loaded
+  def test_00_module
+    assert_instance_of Module, CrossCase, "CrossCase module didn't load"
+  end
+
+  # Test pre-include
+  def test_10_preinclude
+    rval = obj = testClass = nil
+                
+    assert_nothing_raised {
+      testClass = Class::new( Object ) {
+        include CrossCase
+        def underbarred_method; "under_barred"; end
+        def camelCasedMethod; "camelCased"; end
+      }
+    }
+
+    obj = testClass::new
+    assert_respond_to obj, :underbarredMethod, "alias for underbarred_method"
+    assert_respond_to obj, :camel_cased_method, "alias for camelCasedMethod"
+  end
+
+end
+
+
+

data/test/tc_duckhunter.rb

@@ -0,0 +1,37 @@
+
+require 'test/unit'
+require 'carat/duckhunter'
+
+
+class TC_DuckHunter < 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/test/tc_dynamic-mixin.rb

@@ -0,0 +1,66 @@
+
+require 'test/unit'
+require 'carat/dynamic-mixin'
+
+# fixture
+
+module Mixin
+  extend DynamicMixin
+  def self.default_options
+    { :name => "D" }
+  end
+  def hello
+    "#{dynamic_options[:name]}"
+  end
+end
+
+module Mixin2
+  extend DynamicMixin
+  include Mixin[ :name => "Q" ]
+end
+
+class T
+  include Mixin[ :name => "T" ]
+end
+
+class S
+  include Mixin[ :name => "S" ]
+end
+
+class R
+  include Mixin2[ :name => "R" ]
+end
+
+class Q
+  include Mixin2
+end
+
+# test
+
+class TC_DynamicMixin < Test::Unit::TestCase
+
+  def setup
+    @t = T.new
+    @s = S.new
+    @r = R.new
+    @q = Q.new
+  end
+
+  def test_T
+    assert_equal( 'T', @t.hello )
+  end
+
+  def test_S
+    assert_equal( 'S', @s.hello )
+  end
+
+  def test_R
+    assert_equal( 'R', @r.hello )
+  end
+
+  def test_Q
+    assert_equal( 'Q', @q.hello )
+  end
+
+end
+

data/test/tc_enumerable-args.rb

@@ -0,0 +1,66 @@
+
+require 'test/unit'
+require 'carat/enumerable-args'
+
+# fixture
+
+class PlusArray
+  include EnumerableWithArgs
+  def initialize(arr)
+    @arr = arr
+  end
+  def each(n=0)
+    @arr.each{ |e| yield(e+n) }
+  end
+end
+
+
+class TC_Enumerable < Test::Unit::TestCase
+
+  def test_collect
+    t = PlusArray.new([1,2,3])
+    assert_equal( [5,6,7], t.collect(4){ |e| e } )
+  end
+
+  def test_each_slice
+    t = PlusArray.new([1,2,3,4])
+    a = []
+    t.each_slice(4){ |e,f| a << [e,f] }
+    assert_equal( [[5,6],[7,8]], a )
+  end
+
+  def test_grep
+    # TODO
+  end
+
+  def test_to_a
+    t = PlusArray.new([1,2,3])
+    assert_equal( [5,6,7], t.to_a(4) )  
+  end
+
+  def test_min
+    t = PlusArray.new([1,2,3])
+    assert_equal( 5, t.min(4) )
+  end
+  
+  def test_max
+    t = PlusArray.new([1,2,3])
+    assert_equal( 7, t.max(4) )
+  end
+    
+  def test_include?
+    t = PlusArray.new([1,2,3])
+    assert( t.include?(7,4) )
+  end
+  
+  def test_select
+    t = PlusArray.new([1,2,3])
+    assert_equal( [6], t.select(4){ |x| x == 6 } )
+  end
+
+  def test_reject
+    t = PlusArray.new([1,2,3])
+    assert_equal( [5,7], t.reject(4){ |x| x == 6 } )
+  end
+  
+end