carray 1.5.1 → 1.5.6

data/spec/Classes/CAWindow_spec.rb

@@ -0,0 +1,54 @@
+
+require 'carray'
+require "rspec-power_assert"
+
+describe "TestCArrayCAWindow " do
+
+  example "virtual_array" do
+    a = CArray.int(3,3).seq!
+    b = a.window(-1..1, -1..1)
+    r = b.parent
+    is_asserted_by { b.class == CAWindow }
+    is_asserted_by { true == b.virtual? }
+    is_asserted_by { a == r }
+  end
+
+
+  example "basic_features" do
+    # ---
+    a = CArray.int(3,3).seq!
+    b = a.window(-1..1, -1..1)
+    is_asserted_by { CA_INT([[0,0,0],
+                         [0,0,1],
+                         [0,3,4]]) ==  b }
+
+    # ---
+    a = CArray.int(3,3).seq!
+    b = a.window(-1..1, -1..1) { UNDEF}
+    _ = UNDEF
+    is_asserted_by { CA_INT([[_,_,_],
+                         [_,0,1],
+                         [_,3,4]]) == b }
+  end
+
+  example "invalid_args" do
+    # ---
+    a = CArray.int(3,3).seq
+    expect { a.window(1) }.to raise_error(ArgumentError)
+    expect { a.window([nil]) }.to raise_error(ArgumentError)
+    expect { a.window(nil, [nil,2]) }.to raise_error(ArgumentError)
+    expect { a.window(1..-1, nil) }.to raise_error(ArgumentError)
+  end
+
+  example "out_of_index" do
+    # ---
+    a = CArray.int(3,3).seq
+    i1 = CA_INT([1,2,3])
+    i2 = CA_INT([-4,-3,-2])
+    expect { a[i1,nil] }.to raise_error(IndexError)
+    expect { a[nil,i1] }.to raise_error(IndexError)
+    expect { a[i2,nil] }.to raise_error(IndexError)
+    expect { a[nil,i2] }.to raise_error(IndexError)
+  end
+
+end

data/spec/Classes/CAWrap_spec.rb

@@ -0,0 +1,8 @@
+
+require 'carray'
+require "rspec-power_assert"
+
+describe "TestCArrayCAWrap " do
+  example "default" do
+  end
+end

data/{test/test_CArray.rb → spec/Classes/CArray_spec.rb}

@@ -1,61 +1,60 @@
-$:.unshift("../lib", "..")
 
-require 'test/unit'
 require 'carray'
+require "rspec-power_assert"
 
-class TestCArray < Test::Unit::TestCase
+describe "TestCArray " do
 
   def assert_carray (ca, type, dim, ary)
-    assert_equal(ca, CArray.new(type, dim){ary})
+    is_asserted_by { ca == CArray.new(type, dim) { ary } }
   end
 
-  def test_s_new
+  example "s_new" do
     a = CArray.new(CA_INT32, [3, 2, 1]) { 1 }
-    assert_instance_of(CArray, a)
+    is_asserted_by { a.class == CArray }
   end
 
-  def test_s_type
+  example "s_type" do
     a = CArray.int32(3, 3) { 1 }
     assert_carray(a, CA_INT32, [3,3], 1)
   end
 
-  def test_equal
+  example "equal" do
     a = CArray.int32(3, 3)  { 0 }
     b = CArray.int32(3, 3)  { 0 }
     c = CArray.uint32(3, 3) { 0 }
     d = CArray.uint32(2, 3) { 0 }
     e = CArray.int32(3, 3)  { 1 }
-    assert_equal(a == b, true)
-    assert_equal(a != b, false)
-    assert_equal(a == c, false)
-    assert_equal(a != c, true)
-    assert_equal(a == d, false)
-    assert_equal(a != d, true)
-    assert_equal(a == e, false)
-    assert_equal(a != e, true)
+    is_asserted_by { (a == b) == true }
+    is_asserted_by { (a != b) == false }
+    is_asserted_by { (a == c) == false }
+    is_asserted_by { (a != c) == true }
+    is_asserted_by { (a == d) == false }
+    is_asserted_by { (a != d) == true }
+    is_asserted_by { (a == e) == false }
+    is_asserted_by { (a != e) == true }
   end
 
-  def test_clone
+  example "clone" do
     a = CArray.int32(3, 3)
-    assert_equal(a.clone, a)
+    is_asserted_by { a.clone == a }
   end
 
-  def test_to_s
+  example "to_s" do
     a = CArray.int8(3, 3) { 1 }
-    assert_equal(a.to_s, "\001"*9)
+    is_asserted_by { a.to_s == ("\u0001" * 9) }
 
     a = CArray.int32(3, 3) { 1 }
-    assert_equal(a.to_s, [1].pack("l")*9)
+    is_asserted_by { a.to_s == ([1].pack("l") * 9) }
   end
 
-  def test_to_ca
+  example "to_ca" do
     a = CArray.int32(3, 3).seq
-    assert_equal(a.to_ca, a)
+    is_asserted_by { a.to_ca == a }
 
     c = CArray.int32(4, 4)
     c[0..2, 0..2] = a
     b = c[0..2, 0..2]
-    assert_equal(b.to_ca, b)
+    is_asserted_by { b.to_ca == b }
 
     a = CArray.int32(3, 3).seq
     assert_carray(a[nil, 0].to_ca, CA_INT32, [3], [0,3,6])
@@ -68,25 +67,14 @@ class TestCArray < Test::Unit::TestCase
 #    assert_carray(a[2, nil].to_ca, CA_INT32, [3], [6,7,8])
   end
 
-  def test_store_array
+  example "store_array" do
     a = CArray.int32(3, 3){1}
     b = CArray.int32(3, 3)
     b[] = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
-    assert_equal(a, b)
+    is_asserted_by { a == b }
   end
 
-  def test_seq
-    a = CArray.int32(3, 3)
-    a.seq!
-    assert_carray(a, CA_INT32, [3,3], [
-        [0, 1, 2],
-        [3, 4, 5],
-        [6, 7, 8]
-      ])
-    assert_equal(a.seq, a)
-  end
-
-  def test_set_value
+  example "set_value" do
     a = CArray.int32(3, 3)
     b = CArray.int32(3, 3)
 
@@ -136,93 +124,61 @@ class TestCArray < Test::Unit::TestCase
       ])
   end
 
-  def test_set_point
+  example "set_point" do
     a = CArray.int32(3, 3) { 0 }
 
     a[1, 1] = 1
-    assert_equal(a[1,1], 1)
+    is_asserted_by { a[1, 1] == 1 }
 
   end
 
-  def test_set_addr
+  example "set_addr" do
     a = CArray.int32(3, 3) { 0 }
 
     a[4] = 1
-    assert_equal(a[1,1], 1)
+    is_asserted_by { a[1, 1] == 1 }
 
     a[3..5] = -1
-    assert_equal(a[1,1], -1)
+    is_asserted_by { a[1, 1] == (-1) }
 
     a[3..5] = [1,2,3]
-    assert_equal(a[1,1], 2)
-  end
-
-  def test_dump_io ()
-    a = CArray.int32(3, 3).seq!
-    b = CArray.int32(3, 3)
-    open("bintest", "w") { |io| a.dump_binary(io) }
-    open("bintest")      { |io| b.load_binary(io) }
-    assert_equal(a, b)
-
-    a = CArray.int32(3, 3).seq!
-    b = CArray.int32(3, 3).seq!
-    open("bintest", "w") { |io| a[0..1, 0..1].dump_binary(io) }
-    open("bintest")      { |io| b[0..1, 0..1].load_binary(io) }
-    assert_equal(a, b)
-  ensure
-    File.unlink("bintest")
-  end
-
-  def test_dump_str ()
-    a = CArray.int32(3, 3).seq!
-    b = CArray.int32(3, 3)
-    s = ""
-    a.dump_binary(s)
-    b.load_binary(s)
-    assert_equal(a, b)
-
-    a = CArray.int32(3, 3).seq!
-    b = CArray.int32(3, 3).seq!
-    s = ""
-    a[0..1, 0..1].dump_binary(s)
-    b[0..1, 0..1].load_binary(s)
-    assert_equal(a, b)
+    is_asserted_by { a[1, 1] == 2 }
   end
 
-  def test_reverse
+  example "reverse" do
     a = CArray.uint8(100).seq!
     b = a[-1..0].to_ca
-    assert_equal(a.reverse!, b)
+    is_asserted_by { a.reverse! == b }
   end
 
-  def test_stat
+  example "stat" do
     a = CArray.float32(3,3).seq!(1,2)
     stddev = Math.sqrt(((a - a.mean)**2).sum/(a.elements-1))
 
-    assert_equal(a.max, 17)
-    assert_equal(a.min, 1)
-    assert_equal(a.sum, 81)
-    assert_equal(a.mean, 9)
-    assert_equal(a.stddev, stddev)
+    is_asserted_by { a.max == 17 }
+    is_asserted_by { a.min == 1 }
+    is_asserted_by { a.sum == 81 }
+    is_asserted_by { a.mean == 9 }
+    is_asserted_by { a.stddev == stddev }
 
     c = CArray.int32(4,4)
     c[0..2, 0..2] = a
     a = c[0..2, 0..2]
-    assert_equal(a.max, 17)
-    assert_equal(a.min, 1)
-    assert_equal(a.sum, 81)
-    assert_equal(a.mean, 9)
-    assert_equal(a.stddev, stddev)
+    is_asserted_by { a.max == 17 }
+    is_asserted_by { a.min == 1 }
+    is_asserted_by { a.sum == 81 }
+    is_asserted_by { a.mean == 9 }
+    is_asserted_by { a.stddev == stddev }
   end
 
-  def test_ancestors
+  example "ancestors" do
     # ---
     a = CArray.int(3,3).seq!
     b = a.reshape(9)
     c = b.reshape(3,3)
     d = c[0..1,0..1]
-    assert_equal(a, d.root_array)
-    assert_equal([a,b,c,d], d.ancestors)
+    is_asserted_by { a == d.root_array }
+    is_asserted_by { [a, b, c, d] == d.ancestors }
   end
 
 end

data/spec/Classes/CScalar_spec.rb

@@ -0,0 +1,55 @@
+require 'carray'
+require "rspec-power_assert"
+
+describe "CScalar#[]" do
+  
+  example "basic" do  
+    a = CA_DOUBLE(3.0)
+    
+    is_asserted_by { a[0] == 3.0 }
+    is_asserted_by { a[1] == 3.0 }
+
+    # a[] returns self
+    is_asserted_by { a[].class == CScalar }
+    is_asserted_by { a[] == a }
+
+    # a[nil] returns self
+    is_asserted_by { a[nil].class == CScalar }
+    is_asserted_by { a[nil] == a }
+
+    # a[block] returns self
+    is_asserted_by { a[0..5].class == CScalar }
+    is_asserted_by { a[0..5] == a }
+
+    a[0] = 5.0
+    is_asserted_by { a[0] == 5.0 }
+    expect { a[1] = 5.0 }.to raise_error(IndexError)
+  end
+
+  example "select" do  
+    a = CA_DOUBLE(3.0)
+    idx = CA_BOOLEAN([true,false,true,false,true])
+    expect { a[idx] }.to raise_error(RuntimeError)
+  end
+
+  example "mapping" do  
+    a = CA_DOUBLE(3.0)
+    idx = CA_INT([0,0,0,0,0])
+    is_asserted_by { a[idx] == CA_DOUBLE([3,3,3,3,3]) }
+
+    idx = CA_INT([0,1,2,3,4])
+    expect { a[idx] }.to raise_error(IndexError)
+  end
+
+  example "method" do  
+    a = CA_DOUBLE(3.0)
+    a[:gt,1] = 10
+    is_asserted_by { a[0] == 10 }
+
+    a = CA_DOUBLE(3.0)
+    a[:lt,1] = 10
+    is_asserted_by { a[0] == 3.0 }
+  end
+    
+end
+

data/spec/Features/feature_130_spec.rb

@@ -0,0 +1,19 @@
+
+require 'carray'
+require "rspec-power_assert"
+
+describe "Test130 " do
+
+  example "float_arithmetic" do
+    is_asserted_by { (CA_FLOAT([100]) + 1)[0] == 101.0 }
+  end
+  
+  example "int64" do
+    expect { CA_INT64([0xffffffffffffffff]) }.to raise_error(RangeError)
+    is_asserted_by { CA_INT64([0x7fffffffffffffff])[0] == 0x7fffffffffffffff }
+    is_asserted_by { CA_INT64([0x7fffffffffffffff])+1  == CA_INT64([-0x8000000000000000]) }
+    is_asserted_by { CA_INT64([0x7fffffffffffffff, 0x7fffffffffffffff]).sum == (2*0x7fffffffffffffff).to_f }
+  end
+
+
+end

data/spec/Features/feature_attributes_spec.rb

@@ -0,0 +1,280 @@
+
+require 'carray'
+require "rspec-power_assert"
+
+describe "TestCArrayAttribute " do
+
+  example "attribute_basic_features" do
+    a = CArray.new(CA_INT32, [4, 3, 2, 1])
+    is_asserted_by {  a.class == CArray }
+    is_asserted_by {  CA_OBJ_ARRAY == a.obj_type }
+    is_asserted_by {  CA_INT32 == a.data_type }
+    is_asserted_by {  4 == a.rank }
+    is_asserted_by {  CArray.sizeof(CA_INT32) == a.bytes }
+    is_asserted_by {  24 == a.elements }
+    is_asserted_by {  [4, 3, 2, 1] == a.dim }
+    is_asserted_by {  4 == a.dim0 }
+    is_asserted_by {  3 == a.dim1 }
+    is_asserted_by {  2 == a.dim2 }
+    is_asserted_by {  1 == a.dim3 }
+  end
+
+  example "fixlen?" do
+    is_asserted_by {  CArray.new(CA_FIXLEN, [1], bytes: 1).fixlen? == true }
+    is_asserted_by {  CArray.boolean(1).fixlen? == false }
+    is_asserted_by {  CArray.int8(1).fixlen? == false }
+    is_asserted_by {  CArray.uint8(1).fixlen? == false }
+    is_asserted_by {  CArray.int16(1).fixlen? == false }
+    is_asserted_by {  CArray.uint16(1).fixlen? == false }
+    is_asserted_by {  CArray.int32(1).fixlen? == false }
+    is_asserted_by {  CArray.uint32(1).fixlen? == false }
+    is_asserted_by {  CArray.int64(1).fixlen? == false }
+    is_asserted_by {  CArray.uint64(1).fixlen? == false }
+    is_asserted_by {  CArray.float32(1).fixlen? == false }
+    is_asserted_by {  CArray.float64(1).fixlen? == false }
+    if CArray.data_type?(:float128)
+      is_asserted_by {  CArray.float128(1).fixlen? == false }
+    end
+    if CArray::HAVE_COMPLEX
+      is_asserted_by {  CArray.cmplx64(1).fixlen? == false }
+      is_asserted_by {  CArray.cmplx128(1).fixlen? == false }
+      if CArray.data_type?(:cmplx256)
+        is_asserted_by {  CArray.cmplx256(1).fixlen? == false }
+      end
+    end
+    is_asserted_by {  CArray.object(1).fixlen? == false }
+  end
+
+  example "boolean?" do
+    is_asserted_by {  CArray.new(CA_FIXLEN, [1], bytes: 1).boolean? == false }
+    is_asserted_by {  CArray.boolean(1).boolean? == true }
+    is_asserted_by {  CArray.int8(1).boolean? == false }
+    is_asserted_by {  CArray.uint8(1).boolean? == false }
+    is_asserted_by {  CArray.int16(1).boolean? == false }
+    is_asserted_by {  CArray.uint16(1).boolean? == false }
+    is_asserted_by {  CArray.int32(1).boolean? == false }
+    is_asserted_by {  CArray.uint32(1).boolean? == false }
+    is_asserted_by {  CArray.int64(1).boolean? == false }
+    is_asserted_by {  CArray.uint64(1).boolean? == false }
+    is_asserted_by {  CArray.float32(1).boolean? == false }
+    is_asserted_by {  CArray.float64(1).boolean? == false }
+    if CArray.data_type?(:float128)
+      is_asserted_by {  CArray.float128(1).boolean? == false }
+    end
+    if CArray::HAVE_COMPLEX
+      is_asserted_by {  CArray.cmplx64(1).boolean? == false }
+      is_asserted_by {  CArray.cmplx128(1).boolean? == false }
+      if CArray.data_type?(:cmplx256)
+        is_asserted_by {  CArray.cmplx256(1).boolean? == false }
+      end
+    end
+    is_asserted_by {  CArray.object(1).boolean? == false }
+  end
+
+  example "numeric?" do
+    is_asserted_by {  CArray.new(CA_FIXLEN, [1], bytes: 1).integer? == false }
+    is_asserted_by {  CArray.boolean(1).integer? == false }
+    is_asserted_by {  CArray.int8(1).integer? == true }
+    is_asserted_by {  CArray.uint8(1).integer? == true }
+    is_asserted_by {  CArray.int16(1).integer? == true }
+    is_asserted_by {  CArray.uint16(1).integer? == true }
+    is_asserted_by {  CArray.int32(1).integer? == true }
+    is_asserted_by {  CArray.uint32(1).integer? == true }
+    is_asserted_by {  CArray.int64(1).integer? == true }
+    is_asserted_by {  CArray.uint64(1).integer? == true }
+    is_asserted_by {  CArray.float32(1).integer? == false }
+    is_asserted_by {  CArray.float64(1).integer? == false }
+    if CArray.data_type?(:float128)
+      is_asserted_by {  CArray.float128(1).integer? == false }
+    end
+    if CArray::HAVE_COMPLEX
+      is_asserted_by {  CArray.cmplx64(1).integer? == false }
+      is_asserted_by {  CArray.cmplx128(1).integer? == false }
+      if CArray.data_type?(:cmplx256)
+        is_asserted_by {  CArray.cmplx256(1).integer? == false }
+      end
+    end
+    is_asserted_by {  CArray.object(1).integer? == false }
+  end
+
+  example "integer?" do
+    is_asserted_by {  CArray.new(CA_FIXLEN, [1], bytes: 1).integer? == false }
+    is_asserted_by {  CArray.boolean(1).integer? == false }
+    is_asserted_by {  CArray.int8(1).integer? == true }
+    is_asserted_by {  CArray.uint8(1).integer? == true }
+    is_asserted_by {  CArray.int16(1).integer? == true }
+    is_asserted_by {  CArray.uint16(1).integer? == true }
+    is_asserted_by {  CArray.int32(1).integer? == true }
+    is_asserted_by {  CArray.uint32(1).integer? == true }
+    is_asserted_by {  CArray.int64(1).integer? == true }
+    is_asserted_by {  CArray.uint64(1).integer? == true }
+    is_asserted_by {  CArray.float32(1).integer? == false }
+    is_asserted_by {  CArray.float64(1).integer? == false }
+    if CArray.data_type?(:float128)
+      is_asserted_by {  CArray.float128(1).integer? == false }
+    end
+    if CArray::HAVE_COMPLEX
+      is_asserted_by {  CArray.cmplx64(1).integer? == false }
+      is_asserted_by {  CArray.cmplx128(1).integer? == false }
+      if CArray.data_type?(:cmplx256)
+        is_asserted_by {  CArray.cmplx256(1).integer? == false }
+      end
+    end
+    is_asserted_by {  CArray.object(1).integer? == false }
+  end
+
+  example "unsigned?" do
+    is_asserted_by {  CArray.new(CA_FIXLEN, [1], bytes: 1).unsigned? == false }
+    is_asserted_by {  CArray.boolean(1).unsigned? == false }
+    is_asserted_by {  CArray.int8(1).unsigned? == false }
+    is_asserted_by {  CArray.uint8(1).unsigned? == true }
+    is_asserted_by {  CArray.int16(1).unsigned? == false }
+    is_asserted_by {  CArray.uint16(1).unsigned? == true }
+    is_asserted_by {  CArray.int32(1).unsigned? == false }
+    is_asserted_by {  CArray.uint32(1).unsigned? == true }
+    is_asserted_by {  CArray.int64(1).unsigned? == false }
+    is_asserted_by {  CArray.uint64(1).unsigned? == true }
+    is_asserted_by {  CArray.float32(1).unsigned? == false }
+    is_asserted_by {  CArray.float64(1).unsigned? == false }
+    if CArray.data_type?(:float128)
+      is_asserted_by {  CArray.float128(1).unsigned? == false }
+    end
+    if CArray::HAVE_COMPLEX
+      is_asserted_by {  CArray.cmplx64(1).unsigned? == false }
+      is_asserted_by {  CArray.cmplx128(1).unsigned? == false }
+      if CArray.data_type?(:cmplx256)
+        is_asserted_by {  CArray.cmplx256(1).unsigned? == false }
+      end
+    end
+    is_asserted_by {  CArray.object(1).unsigned? == false }
+  end
+
+  example "float?" do
+    is_asserted_by {  CArray.new(CA_FIXLEN, [1], bytes: 1).float? == false }
+    is_asserted_by {  CArray.boolean(1).float? == false }
+    is_asserted_by {  CArray.int8(1).float? == false }
+    is_asserted_by {  CArray.uint8(1).float? == false }
+    is_asserted_by {  CArray.int16(1).float? == false }
+    is_asserted_by {  CArray.uint16(1).float? == false }
+    is_asserted_by {  CArray.int32(1).float? == false }
+    is_asserted_by {  CArray.uint32(1).float? == false }
+    is_asserted_by {  CArray.int64(1).float? == false }
+    is_asserted_by {  CArray.uint64(1).float? == false }
+    is_asserted_by {  CArray.float32(1).float? == true }
+    is_asserted_by {  CArray.float64(1).float? == true }
+    if CArray.data_type?(:float128)
+      is_asserted_by {  CArray.float128(1).float? == true }
+    end
+    if CArray::HAVE_COMPLEX
+      is_asserted_by {  CArray.cmplx64(1).float? == false }
+      is_asserted_by {  CArray.cmplx128(1).float? == false }
+      if CArray.data_type?(:cmplx256)
+        is_asserted_by {  CArray.cmplx256(1).float? == false }
+      end
+    end
+    is_asserted_by {  CArray.object(1).float? == false }
+  end
+
+  example "complex?" do
+    is_asserted_by {  CArray.new(CA_FIXLEN, [1], bytes: 1).complex? == false }
+    is_asserted_by {  CArray.boolean(1).complex? == false }
+    is_asserted_by {  CArray.int8(1).complex? == false }
+    is_asserted_by {  CArray.uint8(1).complex? == false }
+    is_asserted_by {  CArray.int16(1).complex? == false }
+    is_asserted_by {  CArray.uint16(1).complex? == false }
+    is_asserted_by {  CArray.int32(1).complex? == false }
+    is_asserted_by {  CArray.uint32(1).complex? == false }
+    is_asserted_by {  CArray.int64(1).complex? == false }
+    is_asserted_by {  CArray.uint64(1).complex? == false }
+    is_asserted_by {  CArray.float32(1).complex? == false }
+    is_asserted_by {  CArray.float64(1).complex? == false }
+    if CArray.data_type?(:float128)
+      is_asserted_by {  CArray.float128(1).complex? == false }
+    end
+    if CArray::HAVE_COMPLEX
+      is_asserted_by {  CArray.cmplx64(1).complex? == true }
+      is_asserted_by {  CArray.cmplx128(1).complex? == true }
+      if CArray.data_type?(:cmplx256)
+        is_asserted_by {  CArray.cmplx256(1).complex? == true }
+      end
+    end
+    is_asserted_by {  CArray.object(1).complex? == false }
+  end
+
+  example "object?" do
+    is_asserted_by {  CArray.new(CA_FIXLEN, [1], bytes: 1).object? == false }
+    is_asserted_by {  CArray.boolean(1).object? == false }
+    is_asserted_by {  CArray.int8(1).object? == false }
+    is_asserted_by {  CArray.uint8(1).object? == false }
+    is_asserted_by {  CArray.int16(1).object? == false }
+    is_asserted_by {  CArray.uint16(1).object? == false }
+    is_asserted_by {  CArray.int32(1).object? == false }
+    is_asserted_by {  CArray.uint32(1).object? == false }
+    is_asserted_by {  CArray.int64(1).object? == false }
+    is_asserted_by {  CArray.uint64(1).object? == false }
+    is_asserted_by {  CArray.float32(1).object? == false }
+    is_asserted_by {  CArray.float64(1).object? == false }
+    if CArray.data_type?(:float128)
+      is_asserted_by {  CArray.float128(1).object? == false }
+    end
+    if CArray::HAVE_COMPLEX
+      is_asserted_by {  CArray.cmplx64(1).object? == false }
+      is_asserted_by {  CArray.cmplx128(1).object? == false }
+      if CArray.data_type?(:cmplx256)
+        is_asserted_by {  CArray.cmplx256(1).object? == false }
+      end
+    end
+    is_asserted_by {  CArray.object(1).object? == true }
+  end
+
+  example "entity?" do
+    a = CArray.int32(3)
+    is_asserted_by {  a.entity? == true }
+    is_asserted_by {  a[].entity? == false }
+    is_asserted_by {  a[0..1].entity? == false }
+    is_asserted_by {  a[a > 0].entity? == false }
+
+    b = CScalar.int32()
+    is_asserted_by {  b.entity? == true }
+    is_asserted_by {  b[].entity? == true }
+  end
+
+  example "virtual?" do
+    a = CArray.int32(3)
+    is_asserted_by {  a.virtual? == false }
+    is_asserted_by {  a[].virtual? == true }
+    is_asserted_by {  a[0..1].virtual? == true }
+    is_asserted_by {  a[a > 0].virtual? == true }
+
+    b = CScalar.int32()
+    is_asserted_by {  b.virtual? == false }
+    is_asserted_by {  b[].virtual? == false }
+  end
+
+  example "valid_index?" do
+    a = CArray.int32(3,3)
+    is_asserted_by {  true == a.valid_index?(2, 2) }
+    is_asserted_by {  true == a.valid_index?(1, 1) }
+#    is_asserted_by {  true == a.valid_index?((-1), (-1)) }
+#    is_asserted_by {  true == a.valid_index?((-3), (-3)) }
+
+    is_asserted_by {  true == a.valid_addr?(8) }
+    is_asserted_by {  true == a.valid_addr?(4) }
+#    is_asserted_by {  true == a.valid_addr?((-4)) }
+#    is_asserted_by {  true == a.valid_addr?((-8)) }
+      
+    is_asserted_by {  false == a.valid_index?(1, 3) }
+#    is_asserted_by {  false == a.valid_index?((-4), 1) }
+
+    is_asserted_by {  false == a.valid_addr?(9) }
+#    is_asserted_by {  false == a.valid_addr?((-10)) }
+  end
+
+  example "same_shape?" do
+    a = CArray.int32(4,3,2,1)
+    b = CArray.int8(1,2,3,4)
+    is_asserted_by {  false == a.same_shape?(b) }
+    is_asserted_by {  true == a.transposed.same_shape?(b) }
+  end
+
+end