multiarray 0.2.4 → 0.4.0

data/test/tc_multiarray.rb

@@ -1,30 +1,112 @@
 require 'test/unit'
+begin
+  require 'rubygems'
+rescue LoadError
+end
 Kernel::require 'multiarray'
 
 class TC_MultiArray < Test::Unit::TestCase
 
+  O = Hornetseye::OBJECT
+  M = Hornetseye::MultiArray
+
+  def lazy( &action )
+    Hornetseye::lazy &action
+  end
+
+  def eager( &action )
+    Hornetseye::eager &action
+  end
+
   def setup
-    @@types = [ Hornetseye::UBYTE,
-                Hornetseye::BYTE,
-                Hornetseye::USINT,
-                Hornetseye::SINT,
-                Hornetseye::UINT,
-                Hornetseye::INT,
-                Hornetseye::ULONG,
-                Hornetseye::LONG ]
   end
 
   def teardown
-    @@types = nil
   end
 
-  def test_multiarray_new
-    for t in @@types
-      m = Hornetseye::MultiArray.new t, 3, 2
-      m.set
-      assert_equal [ [ 0, 0, 0 ], [ 0, 0, 0 ] ], m.to_a
+  def M( *args )
+    Hornetseye::MultiArray *args
+  end
+
+  def test_default
+    assert_equal [ [ nil ] * 3 ] * 2, M( O, 3, 2 ).new.to_a
+  end
+
+  def test_multiarray_inspect
+    assert_equal 'MultiArray.object(3,2)', M( O, 3, 2 ).inspect
+  end
+
+  def test_multiarray_to_s
+    assert_equal 'MultiArray.object(3,2)', M( O, 3, 2 ).to_s
+  end
+
+  def test_multiarray_assign
+    assert_equal [ [ :a, :b, :c ], [ :d, :e, :f ] ],
+                 M[ [ :a, :b, :c ], [ :d, :e, :f ] ].to_a
+    assert_equal [ [ :a, nil ], [ :b, :c ] ],
+                 M[ [ :a ], [ :b, :c ] ].to_a
+    assert_equal [ [ :a, :b ], [ :c, :c ] ],
+                 M[ [ :a, :b ], :c ].to_a
+  end
+
+  def test_inspect
+    assert_equal "MultiArray.object(3,2):\n" + 
+                 "[ [ :a, :b, :c ],\n  [ :d, :e, :f ] ]",
+                 M[ [ :a, :b, :c ], [ :d, :e, :f ] ].inspect
+  end
+
+  def test_to_s
+    # !!!
+  end
+
+  def test_at_assign
+    m = M.new O, 3, 2
+    for j in 0 ... 2
+      for i in 0 ... 3
+        assert_equal i + j * 3 + 1, m[ j ][ i ] = i + j * 3 + 1
+      end
+    end
+    for j in 0 ... 2
+      for i in 0 ... 3
+        assert_equal i + j * 3 + 1, m[ j ][ i ]
+      end
     end
+    assert_equal [ 4, 5, 6 ], m[ 1 ].to_a
+    assert_equal 7, m[ 1 ] = 7
+    assert_equal [ [ 1, 2, 3 ], [ 7, 7, 7 ] ], m.to_a
   end
 
-end
+  def test_equal
+    # !!!
+  end
+
+  def test_negate
+    m = M[ [ 1, 2, 3 ], [ 4, 5, 6 ] ]
+    assert_equal [ [ -1, -2, -3 ], [ -4, -5, -6 ] ], ( -m ).to_a
+  end
 
+  def test_lazy
+    m = M[ [ 1, 2, 3 ], [ 4, 5, 6 ] ]
+    u = lazy { -m }
+    assert_equal 'MultiArray.object(3,2):<delayed>', u.inspect
+    assert_equal [ [ -1, -2, -3 ], [ -4, -5, -6 ] ], u.force.to_a
+    u = lazy { --m }
+    assert_equal 'MultiArray.object(3,2):<delayed>', u.inspect
+    assert_equal [ [ 1, 2, 3 ], [ 4, 5, 6 ] ], u.force.to_a
+    u = -lazy { -m }
+    assert_equal "MultiArray.object(3,2):\n[ [ 1, 2, 3 ],\n  [ 4, 5, 6 ] ]",
+                 u.inspect
+    assert_equal [ [ 1, 2, 3 ], [ 4, 5, 6 ] ], u.to_a
+    u = lazy { -lazy { -m } }
+    assert_equal 'MultiArray.object(3,2):<delayed>', u.inspect
+    assert_equal [ [ 1, 2, 3 ], [ 4, 5, 6 ] ], u.force.to_a
+    u = eager { lazy { -m } }
+    assert_equal 'MultiArray.object(3,2):<delayed>', u.inspect
+    assert_equal [ [ -1, -2, -3 ], [ -4, -5, -6 ] ], u.force.to_a
+    u = lazy { eager { -lazy { -m } } }
+    assert_equal "MultiArray.object(3,2):\n[ [ 1, 2, 3 ],\n  [ 4, 5, 6 ] ]",
+      u.inspect
+    assert_equal [ [ 1, 2, 3 ], [ 4, 5, 6 ] ], u.to_a
+  end
+
+end

data/test/tc_object.rb

@@ -1,79 +1,86 @@
 require 'test/unit'
+begin
+  require 'rubygems'
+rescue LoadError
+end
 Kernel::require 'multiarray'
 
 class TC_Object < Test::Unit::TestCase
 
-  def setup
-    @@t = Hornetseye::OBJECT
-  end
+  O = Hornetseye::OBJECT
 
-  def teardown
-    @@t = nil
+  def lazy( &action )
+    Hornetseye::lazy &action
   end
 
-  def test_object_default
-    assert_nil @@t.default
+  def eager( &action )
+    Hornetseye::eager &action
   end
 
-  def test_int_to_s
-    assert_equal 'OBJECT', @@t.to_s
+  def setup
   end
 
-  def test_int_inspect
-    assert_equal @@t.to_s, @@t.inspect
+  def teardown
   end
 
-  def test_bytesize
-    assert_equal 1, @@t.bytesize
+  def test_object_default
+    assert_nil O.new[]
   end
 
-  def test_typecode
-    assert_equal @@t, @@t.typecode
+  def test_object_inspect
+    assert_equal 'OBJECT', O.inspect
   end
 
-  def test_shape
-    assert_equal [], @@t.shape
+  def test_object_to_s
+    assert_equal 'OBJECT', O.to_s
   end
 
-  def test_size
-    assert_equal 1, @@t.size
+  def test_inspect
+    assert_equal 'OBJECT(42)', O.new( 42 ).inspect
   end
 
   def test_to_s
-    assert_equal '42', @@t.new( 42 ).to_s
+    assert_equal '42', O.new( 42 ).to_s
   end
 
-  def test_inspect
-    assert_equal "OBJECT(42)", @@t.new( 42 ).inspect
+  def test_marshal
+    assert_equal O.new( 42 ), Marshal.load( Marshal.dump( O.new( 42 ) ) )
   end
 
-  def test_get_set
-    i = @@t.new nil
-    assert_nil i.get
-    assert_equal 42, i.set( 42 )
-    assert_equal 42, i.get
-    assert_nil i.set
-    assert_nil i.get
+  def test_at_assign
+    o = O.new 3
+    assert_equal 3, o[]
+    assert_equal 42, o[] = 42
+    assert_equal 42, o[]
   end
 
-  def test_at_assign
-    i = @@t.new nil
-    assert_nil i.at
-    assert_equal 42, i.assign( 42 )
-    assert_equal 42, i.at
-    assert_raise( ArgumentError ) { i.at 0 }
-    assert_raise( ArgumentError ) { i.assign 0, nil }
-    i = @@t.new nil
-    assert_nil i[]
-    assert_equal 42, i[] = 42 
-    assert_equal 42, i[]
-    assert_raise( ArgumentError ) { i[ 0 ] }
-    assert_raise( ArgumentError ) { i[ 0 ] = nil }
+  def test_equal
+    assert_not_equal O.new( 3 ), O.new( 4 )
+    assert_equal O.new( 3 ), O.new( 3 )
+  end
+
+  def test_negate
+    o = O.new 5
+    assert_equal O.new( -5 ), -o
   end
 
-  def test_op
-    i = @@t.new 1
-    assert_equal 3, i.op( 2 ) { |x| set get + x }.get
+  def test_lazy
+    o = lazy { -O.new( 3 ) }
+    assert_not_equal O.new( -3 ), o
+    assert_equal 'OBJECT(<delayed>)', o.inspect
+    assert_equal O.new( -3 ), o.force
+    o = lazy { --O.new( 3 ) }
+    assert_equal 'OBJECT(<delayed>)', o.inspect
+    assert_equal O.new( 3 ), o.force
+    o = -lazy { -O.new( 3 ) }
+    assert_equal O.new( 3 ), o
+    o = lazy { -lazy { -O.new( 3 ) } }
+    assert_equal 'OBJECT(<delayed>)', o.inspect
+    assert_equal O.new( 3 ), o.force
+    o = eager { lazy { -O.new( 3 ) } }
+    assert_equal 'OBJECT(<delayed>)', o.inspect
+    o = lazy { eager { -lazy { -O.new( 3 ) } } }
+    assert_equal O.new( 3 ), o
   end
 
 end

data/test/tc_sequence.rb

@@ -1,144 +1,127 @@
 require 'test/unit'
+begin
+  require 'rubygems'
+rescue LoadError
+end
 Kernel::require 'multiarray'
 
 class TC_Sequence < Test::Unit::TestCase
 
-  def setup
-    @@types = [ Hornetseye::OBJECT,
-                Hornetseye::UBYTE,
-                Hornetseye::BYTE,
-                Hornetseye::USINT,
-                Hornetseye::SINT,
-                Hornetseye::UINT,
-                Hornetseye::INT,
-                Hornetseye::ULONG,
-                Hornetseye::LONG ]
+  O   = Hornetseye::OBJECT
+  U8  = Hornetseye::UBYTE
+  S8  = Hornetseye::BYTE
+  U16 = Hornetseye::USINT
+  S16 = Hornetseye::SINT
+  U32 = Hornetseye::UINT
+  S32 = Hornetseye::INT
+  U64 = Hornetseye::ULONG
+  S64 = Hornetseye::LONG
+  S   = Hornetseye::Sequence
+
+  T = [ O, U8, S8, U16, S16, U32, S32 ]
+  INSPECT = {
+    O => 'OBJECT',
+    U8 => 'UBYTE', S8 => 'BYTE',
+    U16 => 'USINT', S16 => 'SINT',
+    U32 => 'UINT', S32 => 'INT'
+  }
+  SIGNED = {
+    O => true,
+    U8 => false, S8 => true,
+    U16 => false, S16 => true,
+    U32 => false, S32 => true
+  }
+
+  def lazy( &action )
+    Hornetseye::lazy &action
+  end
+
+  def eager( &action )
+    Hornetseye::eager &action
   end
 
-  def teardown
-    @@types = nil
+  def setup
   end
 
-  def test_default
-    for t in @@types
-      assert_equal [ t.default ] * 3, Hornetseye::Sequence( t, 3 ).default.to_a
-    end
+  def teardown
   end
 
-  def test_sequence_new
-    for t in @@types
-      s = Hornetseye::Sequence.new t, 3
-      s.set
-      assert_equal [ t.default ] * 3, s.to_a
-    end
+  def S( *args )
+    Hornetseye::Sequence *args
   end
 
-  def test_sequence_to_s
-    for t in @@types
-      assert_equal "Sequence.#{t.to_s.downcase}(3)",
-                   Hornetseye::Sequence( t, 3 ).to_s
+  def test_default
+    T.each do |t|
+      s = S( t, 3 ).new
+      s[] = t.new[]
+      assert_equal [ t.new[] ] * 3, s.to_a
     end
   end
 
   def test_sequence_inspect
-    for t in @@types
-      assert_equal "Sequence.#{t.inspect.downcase}(3)",
-                   Hornetseye::Sequence( t, 3 ).inspect
-    end
-  end
-
-  def test_bytesize
-    for t in @@types
-      assert_equal t.bytesize * 3, Hornetseye::Sequence( t, 3 ).bytesize
-    end
-  end
-
-  def test_typecode
-    for t in @@types
-      assert_equal t, Hornetseye::Sequence( t, 3 ).typecode
+    T.each do |t|
+      assert_equal "Sequence.#{t.inspect.downcase}(3)", S( t, 3 ).inspect
     end
   end
 
-  def test_empty
-    for t in @@types
-      assert Hornetseye::Sequence( t, 0 ).new.empty?
-      assert !Hornetseye::Sequence( t, 3 ).new.empty?
-    end
-  end
-
-  def test_shape
-    for t in @@types
-      assert_equal [ 3 ], Hornetseye::Sequence( t, 3 ).shape
+  def test_sequence_to_s
+    T.each do |t|
+      assert_equal "Sequence.#{t.to_s.downcase}(3)", S( t, 3 ).to_s
     end
   end
 
-  def test_size
-    for t in @@types
-      assert_equal 3, Hornetseye::Sequence( t, 3 ).size
-    end
+  def test_sequence_assign
+    assert_equal [ :a, :b, :c ], S[ :a, :b, :c ].to_a
   end
 
   def test_inspect
-    for t in @@types
-      s = Hornetseye::Sequence( t, 3 ).new
-      s[] = [ 1, 2, 3 ]
-      assert_equal "Sequence.#{t.inspect.downcase}(3):\n[ 1, 2, 3 ]", s.inspect
-    end
+    assert_equal "Sequence.object(3):\n[ :a, :b, :c ]", S[ :a, :b, :c ].inspect
   end
 
   def test_to_s
-    for t in @@types
-      s = Hornetseye::Sequence( t, 3 ).new
-      s[] = [ 1, 2, 3 ]
-      assert_equal '123', s.to_s
-    end
+    # !!!
   end
 
-  def test_to_a
-    for t in @@types
-      s = Hornetseye::Sequence( t, 3 ).new
-      s[] = [ 1, 2, 3 ]
-      assert_equal [ 1, 2, 3 ], s.to_a
+  def test_at_assign
+    s = S.new O, 3
+    for i in 0 ... 3
+      assert_equal i + 1, s[ i ] = i + 1
     end
-  end
-
-  def test_get_set
-    for t in @@types
-      s1 = Hornetseye::Sequence( t, 3 ).new
-      s1[] = 2
-      assert_equal t.default, s1.set
-      assert_equal [ t.default ] * 3, s1.get.to_a
-      assert_equal [ t.default ] * 3, s1.to_a
-      assert_equal 1, s1.set( 1 )
-      assert_equal [ 1, 1, 1 ], s1.to_a
-      assert_equal [ 2, 3 ], s1.set( [ 2, 3 ] )
-      assert_equal [ 2, 3, t.default ], s1.to_a
-      s2 = Hornetseye::Sequence( t, 3 ).new
-      s2[] = [ 1, 2, 3 ]
-      s1[] = s2
-      assert_equal [ 1, 2, 3 ], s2.to_a
+    assert_equal [ 1, 2, 3 ], s[].to_a
+    for i in 0 ... 3
+      assert_equal i + 1, s[ i ]
     end
   end
 
-  def test_at_assign
-    for t in @@types
-      s = Hornetseye::Sequence( t, 3 ).new
-      s[] = 0
-      assert_equal [ 0, 0, 0 ], [ s.at( 0 ), s.at( 1 ), s.at( 2 ) ]
-      assert_equal [ 1, 2, 3 ], [ s.assign( 0, 1 ),
-                                  s.assign( 1, 2 ),
-                                  s.assign( 2, 3 ) ]
-      assert_equal [ 1, 2, 3 ], [ s.at( 0 ), s.at( 1 ), s.at( 2 ) ]
-      assert_raise( ArgumentError ) { s.at 0, 0 }
-      assert_nothing_raised { s.at }
-      s = Hornetseye::Sequence( t, 3 ).new
-      s[] = 0
-      assert_equal [ 0, 0, 0 ], [ s[ 0 ], s[ 1 ], s[ 2 ] ]
-      assert_equal [ 1, 2, 3 ], [ s[ 0 ] = 1, s[ 1 ] = 2, s[ 2 ] = 3 ]
-      assert_equal [ 1, 2, 3 ], [ s[ 0 ], s[ 1 ], s[ 2 ] ]
-      assert_raise( ArgumentError ) { s[ 0, 0 ] }
-      assert_nothing_raised { s[] }
-    end
+  def test_equal
+    # !!!
+  end
+
+  def test_negate
+    s = S[ 1, 2, 3 ]
+    assert_equal [ -1, -2, -3 ], ( -s ).to_a
+  end
+
+  def test_lazy
+    s = S[ 1, 2, 3 ]
+    u = lazy { -s }
+    assert_equal 'Sequence.object(3):<delayed>', u.inspect
+    assert_equal [ -1, -2, -3 ], u.force.to_a
+    u = lazy { --s }
+    assert_equal 'Sequence.object(3):<delayed>', u.inspect
+    assert_equal [ 1, 2, 3 ], u.force.to_a
+    u = -lazy { -s }
+    assert_equal "Sequence.object(3):\n[ 1, 2, 3 ]", u.inspect
+    assert_equal [ 1, 2, 3 ], u.to_a
+    u = lazy { -lazy { -s } }
+    assert_equal 'Sequence.object(3):<delayed>', u.inspect
+    assert_equal [ 1, 2, 3 ], u.force.to_a
+    u = eager { lazy { -s } }
+    assert_equal 'Sequence.object(3):<delayed>', u.inspect
+    assert_equal [ -1, -2, -3 ], u.force.to_a
+    u = lazy { eager { -lazy { -s } } }
+    assert_equal "Sequence.object(3):\n[ 1, 2, 3 ]", u.inspect
+    assert_equal [ 1, 2, 3 ], u.to_a
   end
 
 end