carats 0.3.0

data/test/tc_nack.rb

@@ -0,0 +1,31 @@
+
+require 'test/unit'
+require 'carat/nack'
+
+
+class TC_Nack < Test::Unit::TestCase
+
+  def scalar( x )
+    if x.kind_of?(Enumerable)
+      return nack(ArgumentError, "Value cannot not be enumerable")
+    end
+    x
+  end
+
+  def test000
+    assert_equal( 1, scalar(1) )
+  end
+
+  def test001
+    assert_equal( nack, scalar([1,2]) )
+  end
+
+  def test002
+    assert_equal( 1, nail(scalar(1)) )
+  end
+
+  def test003
+    assert_raises(ArgumentError) { nail(scalar([1,2])) }
+  end
+  
+end

data/test/tc_nil-as-emptiness.rb

@@ -0,0 +1,19 @@
+
+require 'test/unit'
+require 'carat/nil-as-emptiness'
+
+
+class TC_NilAsEmptiness < Test::Unit::TestCase
+  
+  def test_emptiness
+    assert( nil.empty? )
+    assert_equal( 0.0, nil.to_f )
+    #assert_equal( false, nil.to_b )
+    assert_equal( nil, nil[:any] )
+    assert_equal( 0, nil.length )
+    assert_equal( 0, nil.size )
+    assert_equal( nil, nil.include?(:any) )   
+    assert_equal( {}, nil.to_h )
+  end
+ 
+end 

data/test/tc_nil-comparable.rb

@@ -0,0 +1,29 @@
+
+require 'test/unit'
+require 'carat/nil-comparable'
+
+class Mock < String
+  include NilComparable
+end
+
+
+class TC_NilClass_Comparable < Test::Unit::TestCase
+
+  def test001
+    assert_equal( 0, nil <=> nil )
+    assert_equal( -1, nil <=> 4 )
+    assert_equal( -1, nil <=> "a" )
+    assert_equal( -1, nil <=> Object.new )
+    assert_equal( 0, nil.cmp(nil) )
+    assert( nil < 4 )
+  end
+
+  def test002
+    m = Mock.new("A")
+    assert_equal( 1, m <=> nil )
+    assert_equal( -1, m <=> "B" )
+    #assert_equal( 1, m.cmp(nil) )
+    assert( m > nil )
+  end
+ 
+end

data/test/tc_notcopyable.rb

@@ -0,0 +1,64 @@
+
+
+require 'test/unit'
+require 'carat/notcopyable'
+
+
+# fixture
+
+class Foo
+  include NotCopyable
+end
+
+class Bar < Foo
+end
+
+class Foo2
+end
+
+
+# test
+
+class TC_NotCopyable < Test::Unit::TestCase
+
+  def test_dup
+    f = Foo.new
+    assert_raises(TypeError) do
+      g = f.dup
+    end
+  end
+
+  def test_dup_derived
+    f = Bar.new
+    assert_raises(TypeError) do
+      g = f.dup
+    end
+  end
+
+  def test_dup_okay
+    f = Foo2.new
+    g = f.dup
+  end
+
+  def test_clone
+    f = Foo.new
+    assert_raises(TypeError) do
+      g = f.clone
+    end
+  end
+
+  def test_clone_derived
+    f = Bar.new
+    assert_raises(TypeError) do
+      g = f.clone
+    end
+  end
+
+  def test_clone_okay
+    f = Foo2.new
+    g = f.clone
+  end
+
+end
+
+

data/test/tc_orderedhash.rb

@@ -0,0 +1,36 @@
+
+require 'test/unit'
+require 'carat/orderedhash'
+
+
+class TC_OrderedHash < Test::Unit::TestCase
+
+  def test01
+   hsh = OrderedHash.new
+   hsh['z'] = 1
+   hsh['a'] = 2
+   hsh['c'] = 3
+   assert_equal( ['z','a','c'], hsh.keys )
+  end
+  
+  def test02
+    hsh = OrderedHash['z', 1, 'a', 2, 'c', 3] 
+    assert_equal( ['z','a','c'], hsh.keys )
+  end
+
+  def test03
+    hsh = OrderedHash['a', 1, 'c', 2, 'z', 3]
+    assert( hsh.push('end', 15) )
+    assert_equal( 15, hsh['end'] )
+    assert( ! hsh.push('end', 30) )
+    assert( hsh.unshift('begin', 50) )
+    assert_equal( 50, hsh['begin'] )
+    assert( ! hsh.unshift('begin', 60) )
+    assert_equal( ["begin", "a", "c", "z", "end"], hsh.keys )
+    assert_equal( ["end", 15], hsh.pop )
+    assert_equal( ["begin", "a", "c", "z"], hsh.keys )
+    assert_equal( ["begin", 50], hsh.shift )
+  end
+
+end
+

data/test/tc_ostructable.rb

@@ -0,0 +1,31 @@
+
+
+require 'test/unit'
+require 'carat/ostructable'
+
+
+# fixture
+
+class Record
+  include OpenStructable
+end
+
+
+# test
+
+class TC_OpenStructable < Test::Unit::TestCase
+
+  def test_record
+    record = nil
+    assert_nothing_raised {
+      record = Record.new
+      record.name    = "John Smith"
+      record.age     = 70
+      record.pension = 300
+    }
+    assert_equal( "John Smith", record.name )
+    assert_equal( 70, record.age )
+    assert_equal( nil, record.address )
+  end
+ 
+end

data/test/tc_semaphore.rb

@@ -0,0 +1,5 @@
+
+require 'test/unit'
+require 'carat/semaphore'
+
+# TODO 

data/test/tc_snapshot.rb

@@ -0,0 +1,20 @@
+
+require 'test/unit'
+require 'carat/snapshot'
+
+
+class TC_Snapshot < Test::Unit::TestCase
+
+  def setup
+    customer = Struct.new("Customer", :name, :address, :zip)
+    joe = customer.new( "Joe Pitare", "1115 Lila Ln.", 47634 )
+    @joe_snap = joe.take_snapshot
+  end
+ 
+  def test_storage
+    assert_equal( "Joe Pitare", @joe_snap[:name]  )
+    assert_equal( "1115 Lila Ln.", @joe_snap[:address] )
+    assert_equal( 47634, @joe_snap[:zip] )
+  end
+  
+end

data/test/tc_soundex.rb

@@ -0,0 +1,19 @@
+
+require 'test/unit'
+require 'carat/soundex'
+
+
+class TC_Soundex < Test::Unit::TestCase
+
+  TESTVEC = "Euler Ellery Gauss Ghosh Hilbert Heilbronn Knuth Kant Lloyd Ladd Lukasiewicz Lissajous".split(" ")
+  RESVEC  = "E460 E460 G200 G200 H416 H416 K530 K530 L300 L300 L222 L222".split(" ")
+  
+  def test_soundex
+    TESTVEC.each_with_index {|str,i| 
+      res = Text::Soundex.soundex(str)
+      #print "#{str.ljust(11)} => #{res} ... "
+      assert_equal( RESVEC[i], res )
+    }
+  end
+
+end

data/test/tc_sstruct.rb

@@ -0,0 +1,313 @@
+
+require "test/unit"
+require "carat/sstruct"
+
+
+class TC_SuperStruct < Test::Unit::TestCase
+
+  def test001
+    # Must pass in String or Symbol
+    assert_raises(ArgumentError) { SuperStruct.new(0) }
+  end
+  
+  def test002
+    # Must pass in valid name(s)
+    assert_raises(ArgumentError) { SuperStruct.new("###") }
+  end
+  
+  def test003
+    # Can't assign to nonexistent fields
+    myStruct = SuperStruct.new
+    assert_raises(ArgumentError) { myStruct.new(345) }
+  end
+  
+  def test004
+    # Need not assign to existing fields (default to nil)
+    myStruct = SuperStruct.new(:alpha)
+    assert_nothing_raised(ArgumentError) { myStruct.new }
+  end
+  
+  def test005
+    # A value assigned at construction may be retrieved
+    myStruct = SuperStruct.new(:alpha)
+    x = myStruct.new(234)
+    assert(x.alpha == 234)
+  end
+  
+  def test006
+    # Unassigned fields are nil
+    myStruct = SuperStruct.new(:alpha,:beta)
+    x = myStruct.new(234)
+    assert(x.beta == nil)
+  end
+  
+  def test007
+    # An open structure still may not construct with nonexistent fields
+    myStruct = SuperStruct.open
+    assert_raises(ArgumentError) { x = myStruct.new(234) }
+  end
+  
+  def test008
+    # An open structure may assign fields not previously existing
+    myStruct = SuperStruct.open
+    x = myStruct.new
+    assert_nothing_raised { x.foobar = 123 }
+  end
+  
+  def test009
+    # A field assigned to an open struct after its construction may be retrieved
+    myStruct = SuperStruct.open
+    x = myStruct.new
+    x.foobar = 123
+    assert(x.foobar == 123)
+  end
+  
+  def test010
+    # The act of retrieving a nonexistent field from an open struct will
+    # create that field
+    myStruct = SuperStruct.open
+    x = myStruct.new
+    assert_nothing_raised { y = x.foobar }
+  end
+  
+  def test011
+    # A field (in an open struct) that is unassigned will be nil
+    myStruct = SuperStruct.open
+    x = myStruct.new
+    y = x.foobar
+    assert(y == nil)
+  end
+  
+  def test012
+    # A struct created with new rather than open cannot reference nonexistent
+    # fields
+    myStruct = SuperStruct.new
+    x = myStruct.new
+    assert_raises(NoMethodError) { y = x.foobar }
+  end
+  
+  def test013
+    # Adding a field to a struct will create a writer and reader for that field
+    myStruct = SuperStruct.new(:alpha)
+    x = myStruct.new
+    x.send(:alpha=,1)
+    assert(x.alpha == 1)
+  end
+  
+  def test014
+    # Only a single value may be passed to a writer (for code coverage)
+    myStruct = SuperStruct.new(:alpha)
+    x = myStruct.new
+    assert_raises(ArgumentError) { x.send(:alpha=,1,2) }
+  end
+  
+  def test015
+    # An open struct will also create a writer and a reader together
+    myStruct = SuperStruct.open
+    x = myStruct.new
+    x.send(:alpha=,1)
+    assert(x.alpha == 1)
+  end
+  
+  def test016
+    # Only a single value may be passed to a writer (for code coverage)
+    myStruct = SuperStruct.open
+    x = myStruct.new
+    assert_raises(ArgumentError) { x.send(:alpha=,1,2) }
+  end
+  
+  def test017
+    # A field has a real writer and reader corresponding to it
+    myStruct = SuperStruct.new(:alpha)
+    x = myStruct.new
+    assert(myStruct.instance_methods.include?("alpha"))
+    assert(myStruct.instance_methods.include?("alpha="))
+  end
+  
+  def test018
+    # Creating a field by retrieval in an open struct will NOT create a writer 
+    # (This behavior has changed!)
+    myStruct = SuperStruct.open
+    x = myStruct.new
+    y = x.alpha
+    assert(myStruct.instance_methods.include?("alpha"))
+    assert(!myStruct.instance_methods.include?("alpha="))
+  end
+  
+  def test019
+    # Creating a field by writing in an open struct will NOT create a reader
+    # (This behavior has changed!)
+    myStruct = SuperStruct.open
+    x = myStruct.new
+    x.alpha = 5
+    assert(myStruct.instance_methods.include?("alpha="))
+    assert(!myStruct.instance_methods.include?("alpha"))
+  end
+  
+  def test020
+    # A string will work as well as a symbol
+    myStruct = SuperStruct.new("alpha")
+    x = myStruct.new
+    assert(myStruct.instance_methods.include?("alpha"))
+    assert(myStruct.instance_methods.include?("alpha="))
+  end
+  
+  def test021
+    # to_a will return an array of values
+    myStruct = SuperStruct.new("alpha","beta","gamma")
+    x = myStruct.new(7,8,9)
+    assert(x.to_a == [7,8,9])
+  end
+  
+  def test022
+    # Instance method 'members' will return a list of members (as strings)
+    myStruct = SuperStruct.new(:alpha,"beta")
+    x = myStruct.new
+    assert_equal(["alpha","beta"],x.members)
+  end
+  
+  def test023
+    # Class method 'members' will return a list of members (as strings)
+    myStruct = SuperStruct.new(:alpha,"beta")
+    assert_equal(["alpha","beta"],myStruct.members)
+  end
+  
+  def test024
+    # to_ary will allow a struct to be treated like an array in
+    # multiple assignment
+    myStruct = SuperStruct.new("alpha","beta","gamma")
+    x = myStruct.new(7,8,9)
+    a,b,c = x
+    assert(b == 8)
+  end
+  
+     def aux025(*arr)  # Just used in test 25
+       arr[1]
+     end
+  
+  def test025
+    # to_ary will allow a struct to be treated like an array in
+    # passed parameters
+    myStruct = SuperStruct.new("alpha","beta","gamma")
+    x = myStruct.new(7,8,9)
+    b = aux025(*x)
+    assert(b == 8)
+  end
+  
+  def test026
+    # to_hash will return a hash with fields as keys
+    myStruct = SuperStruct.new("alpha","beta","gamma")
+    x = myStruct.new(7,8,9)
+    h = x.to_hash
+    assert_equal({"alpha"=>7,"beta"=>8,"gamma"=>9},h)
+  end
+  
+  def test027
+    # A field name (String) may be used in a hash-like notation
+    myStruct = SuperStruct.new("alpha","beta","gamma")
+    x = myStruct.new(7,8,9)
+    y = x["beta"]
+    assert(8,y)
+  end
+  
+  def test028
+    # A field name (Symbol) may be used in a hash-like notation
+    myStruct = SuperStruct.new("alpha","beta","gamma")
+    x = myStruct.new(7,8,9)
+    y = x[:beta]
+    assert(8,y)
+  end
+  
+  def test029
+    # [offset,length] may be used as for arrays
+    myStruct = SuperStruct.new("alpha","beta","gamma")
+    x = myStruct.new(7,8,9)
+    y = x[0,2]
+    assert([7,8],y)
+  end
+  
+  def test030
+    # Ranges may be used as for arrays
+    myStruct = SuperStruct.new("alpha","beta","gamma")
+    x = myStruct.new(7,8,9)
+    y = x[1..2]
+    assert([8,9],y)
+  end
+  
+  def test031
+    # Adding a field to an open struct adds it to the instance
+    myStruct = SuperStruct.open(:alpha)
+    x = myStruct.new
+    x.beta = 5
+    assert_equal(["alpha","beta"],x.members)
+  end
+  
+  def test032
+    # Adding a field to an open struct adds it to the class also
+    myStruct = SuperStruct.open(:alpha)
+    x = myStruct.new
+    x.beta = 5
+    assert_equal(["alpha","beta"],myStruct.members)
+  end
+  
+  def test033
+    # An array passed to SuperStruct.new need not be starred
+    myStruct = SuperStruct.new(%w[alpha beta gamma])
+    x = myStruct.new
+    assert_equal(%w[alpha beta gamma],x.members)
+  end
+  
+  def xtest034
+    # A hash passed to SuperStruct.new will initialize the values
+    # (but order will not be predictable!)
+    assert false, "Not implemented yet."
+  end
+  
+  def test035
+    # A hash passed to #set will set multiple values at once
+    myStruct = SuperStruct.new(%w[alpha beta gamma])
+    x = myStruct.new
+    hash = {"alpha"=>234,"beta"=>345,"gamma"=>456}
+    x.set(hash)
+    assert_equal([234,345,456], x.to_a)
+  end
+  
+  def test036
+    # Make sure ||= works properly
+    x = SuperStruct.open.new
+    x.foo ||= 333
+    x.bar = x.bar || 444
+    assert_equal(333,x.foo)
+    assert_equal(444,x.bar)
+  end
+
+  def test037
+    # A simple array index works ok
+    myStruct = SuperStruct.new("alpha","beta","gamma")
+    x = myStruct.new(7,8,9)
+    assert_equal(7,x[0])
+    assert_equal(8,x[1])
+    assert_equal(9,x[2])
+  end
+
+  def test038
+    # attr_tester will create a ?-method
+    klass = SuperStruct.new(:alpha,:beta,:gamma)
+    klass.attr_tester :alpha, :gamma
+    x = klass.new(22,33,nil)
+    assert(x.alpha?)
+    assert_raises(NoMethodError) { x.beta? }
+    assert(! x.gamma?)
+  end
+
+  def test039
+    # attr_tester works with open() (?-methods not created)
+    klass = SuperStruct.open(:alpha,:beta,:gamma)
+    klass.attr_tester :alpha, :gamma
+    x = klass.new(22,33,nil)
+    assert(x.alpha?)
+    assert_raises(NoMethodError) { x.beta? }  # ?-methods are not automatic
+    assert(! x.gamma?)
+  end
+  
+end