striuct 0.0.11.1 → 0.1.7

data/test/test_striuct.rb

@@ -10,7 +10,10 @@ class User < Striuct.new
 end
 
 class TestStriuctSubclassEigen < Test::Unit::TestCase
-  User2 = Striuct.new :name, :age
+  User2 = Striuct.define do
+    member :name, AND(String, NOT(''))
+    member :age, Fixnum
+  end
   
   def test_builder
     klass = Striuct.new
@@ -29,24 +32,41 @@ class TestStriuctSubclassEigen < Test::Unit::TestCase
   end
 
   def test_define
-    user = User2.define{|r|r.age = 1; r.name = ''}
+    user = User2.define{|r|r.age = 1; r.name = 'a'}
     assert_same 1, user.age
     
     assert_raises RuntimeError do
       user.age = 1
     end
     
-    user = User2.define(false){|r|r.age = 1; r.name = ''}
+    user = User2.define{|r|r.age = 1; r.name = 'a'}
     assert_same 1, user.age
+    assert_same true, user.lock?
+    assert_same false, user.frozen?
     
     assert_raises RuntimeError do
       User2.define{|r|r.age = 1}
     end
+    
+    user = User2.define(lock: true){|r|r.age = 1; r.name = 'a'}
+    assert_same 1, user.age
+    assert_same true, user.lock?
+    user = User2.define(lock: false){|r|r.age = 1; r.name = 'a'}
+    assert_same false, user.lock?
+    assert_equal true, user.strict?
+    
+    assert_raises Striuct::ConditionError do
+      User2.define{|r|r.age = 1; r.name = 'a'; r.name.clear}
+    end
+    
+    user = User2.define(strict: false){|r|r.age = 1; r.name = 'a'; r.name.clear}
+    assert_equal '', user.name
+    assert_equal false, user.strict?
   end
   
-  def test_sufficent?
-    assert_equal false, User.sufficent?(:age, 19)
-    assert_equal true, User.sufficent?(:age, 20)
+  def test_sufficient?
+    assert_equal false, User.sufficient?(:age, 19)
+    assert_equal true, User.sufficient?(:age, 20)
   end
   
   def test_restrict?
@@ -128,11 +148,11 @@ class TestStriuctSubclassInstance2 < Test::Unit::TestCase
   end
   
   def test_strict?
-    assert_same @user.sufficent?(:last_name), true
+    assert_same @user.sufficient?(:last_name), true
     assert_same @user.strict?, true
-    assert_same @user.sufficent?(:last_name), true
+    assert_same @user.sufficient?(:last_name), true
     @user.last_name.clear
-    assert_same @user.sufficent?(:last_name), false
+    assert_same @user.sufficient?(:last_name), false
     assert_same @user.strict?, false
   end
 end
@@ -173,8 +193,39 @@ class TestStriuctSubclassInstance3 < Test::Unit::TestCase
   def test_each_member
     assert_same @user, @user.each_member{}
     assert_kind_of Enumerator, enum = @user.each_member
-    assert_equal enum.next, :id
-    assert_equal enum.next, :last_name
+    assert_equal :id, enum.next
+    assert_equal :last_name, enum.next
+    assert_equal :family_name, enum.next
+    assert_equal :address, enum.next
+    assert_equal :age, enum.next
+    assert_raises StopIteration do
+      enum.next
+    end
+  end
+  
+  def test_each_index
+    assert_same @user, @user.each_index{}
+    assert_kind_of Enumerator, enum = @user.each_index
+    assert_equal 0, enum.next
+    assert_equal 1, enum.next
+    assert_equal 2, enum.next
+    assert_equal 3, enum.next
+    assert_equal 4, enum.next
+    assert_raises StopIteration do
+      enum.next
+    end
+  end
+  
+  def test_each_with_index
+    assert_same @user, @user.each_with_index{}
+    assert_kind_of Enumerator, enum = @user.each_with_index
+    
+    r = []
+    @user.each_with_index do |value, index|
+      r << [value, index]
+    end
+    
+    assert_equal [@user.each_value.to_a, @user.each_index.to_a].transpose, r
   end
   
   def test_values
@@ -264,14 +315,16 @@ class TestStriuctCloning < Test::Unit::TestCase
     assert_equal false, (@sth.sth == sth2.sth)
   end
   
-  def test_class_clone
+  def test_class_dup
     klass = Sth.dup
     Sth.__send__ :member, :dummy1
-    assert_equal false, klass.member?(:dummy)
-    
+    assert_equal false, klass.member?(:dummy1)
+  end
+  
+  def test_class_clone
     klass = Sth.clone
     Sth.__send__ :member, :dummy2
-    assert_equal false, klass.member?(:dummy)
+    assert_equal false, klass.member?(:dummy2)
   end
 end
 
@@ -304,7 +357,7 @@ end
 
 class TestStriuctDefaultValue < Test::Unit::TestCase
   Sth = Striuct.new do
-    member :lank, Integer
+    member :lank, OR(Bignum, Fixnum)
     default :lank, 1
   end
   
@@ -324,13 +377,46 @@ class TestStriuctDefaultValue < Test::Unit::TestCase
         default :anything, 10
       end
     end
-        
+    
+    klass = Striuct.define do
+      member :lank2, Integer
+      default :lank2, '10'
+    end
+
     assert_raises Striuct::ConditionError do
-      Sth.class_eval do
-        member :lank2, Integer
-        default :lank2, '10'
+      klass.new
+    end
+    
+    scope = self
+    seef = nil
+    klass = Striuct.define do
+      member :lank, Integer
+      scope.assert_raises ArgumentError do
+        default :lank, '10', &->own, name{rand}
+      end
+      
+      scope.assert_raises ArgumentError do
+        default :lank, '10', &->own{rand}
+      end
+      
+      scope.assert_raises ArgumentError do
+        default :lank, '10', &->{rand}
       end
+      
+      default :lank, &->own, name{(seef = own); rand}
+    end
+    
+    assert_raises Striuct::ConditionError do
+      klass.new
+    end
+    
+    klass = Striuct.define do
+      member :lank, Integer      
+      default :lank, &->own, name{(seef = own); 10 - name.length}
     end
+    
+    assert_equal 6, klass.new.lank
+    assert_equal seef, klass.new
   end
 end
 
@@ -394,10 +480,18 @@ class TestStriuctAssign < Test::Unit::TestCase
     assert_equal true, sth.assign?(:foo)
     sth.unassign :foo
     assert_equal false, sth.assign?(:foo)
+    sth.foo = nil
+    assert_equal true, sth.assign?(:foo)
+    sth.clear_at 0
+    assert_equal false, sth.assign?(:foo)
     
     assert_raises NameError do
       sth.unassign :var
     end
+    
+    assert_raises IndexError do
+      sth.unassign 1
+    end
   end
 end
 
@@ -473,18 +567,21 @@ class TestStriuctSafetyNaming < Test::Unit::TestCase
     assert_same false, klass.cname?('__foo__')
     assert_same false, klass.cname?('a b')
     assert_same false, klass.cname?('object_id')
+    assert_same false, klass.cname?('to_ary')
     assert_same true, klass.cname?('foo')
     klass.__send__ :protect_level, :warning
     assert_same false, klass.cname?('m?')
     assert_same false, klass.cname?('__foo__')
     assert_same false, klass.cname?('a b')
     assert_same false, klass.cname?('object_id')
+    assert_same false, klass.cname?('to_ary')
     assert_same true, klass.cname?('foo')
     klass.__send__ :protect_level, :struct
     assert_same true, klass.cname?('m?')
     assert_same true, klass.cname?('__foo__')
     assert_same true, klass.cname?('a b')
     assert_same true, klass.cname?('object_id')
+    assert_same true, klass.cname?('to_ary')
     assert_same true, klass.cname?('foo')
   end
   
@@ -578,3 +675,535 @@ class TestStriuctInference < Test::Unit::TestCase
     assert_equal 2, sth.m
   end
 end
+
+class TestStriuctLoadPairs < Test::Unit::TestCase
+  Sth = Striuct.new :foo, :bar, :hoge
+  
+  def test_load_pairs
+    sth = Sth[hoge: 7, foo: 8]
+   
+    assert_equal [8, nil, 7], sth.values
+  end
+end
+
+class TestStriuctObject < Test::Unit::TestCase
+  Sth = Striuct.new :foo, :bar, :hoge
+
+  def test_hash
+    sth1 = Sth[hoge: 7, foo: 8]
+    sth2 = Sth[hoge: 7, foo: 8]
+    assert_equal true, sth1.eql?(sth2)
+    assert_equal true, sth2.eql?(sth1)
+    assert_equal sth1.hash, sth2.hash
+    assert_equal true, {sth1 => 1}.has_key?(sth2)
+    assert_equal true, {sth2 => 1}.has_key?(sth1)
+    assert_equal 1, {sth1 => 1}[sth2]
+    assert_equal 1, {sth2 => 1}[sth1]
+  end
+end
+
+class TestStriuctHashLike < Test::Unit::TestCase
+  Sth = Striuct.new :foo, :bar, :hoge
+
+  def test_empty?
+    sth = Sth[hoge: 7, foo: 8]
+    assert_equal false, sth.empty?
+    sth.each_member{|name|sth[name] = nil}
+    assert_equal false, sth.empty?
+    sth.each_member{|name|sth.unassign name}
+    assert_equal true, sth.empty?
+  end
+  
+  def test_has_value?
+    sth = Sth[hoge: 7, foo: 8]
+    assert_equal true, sth.value?(7)
+    assert_equal true, sth.value?(8)
+    assert_equal false, sth.value?(9)
+    assert_equal false, sth.value?(nil)
+  end
+  
+  def test_select!
+    sth = Sth[hoge: 7, foo: 8]
+    sth2, sth3 = sth.dup, sth.dup
+  
+    assert_kind_of Enumerator, enum = sth.select!
+    assert_equal [:foo, 8], enum.next
+    assert_equal [:bar, nil], enum.next
+    assert_equal [:hoge, 7], enum.next
+    assert_raises StopIteration do
+      enum.next
+    end
+
+    assert_equal nil, sth2.select!{|k, v|true}
+    assert_equal sth3, sth3.select!{|k, v|k == :hoge && v == 7}
+    assert_equal nil, sth3.foo
+    assert_equal true, sth3.assign?(:hoge)
+    assert_equal false, sth3.assign?(:foo)
+    assert_equal 7, sth3.hoge    
+  end
+
+  def test_keep_if
+    sth = Sth[hoge: 7, foo: 8]
+    sth2, sth3 = sth.dup, sth.dup
+    
+    assert_kind_of Enumerator, enum = sth.keep_if
+    assert_equal [:foo, 8], enum.next
+    assert_equal [:bar, nil], enum.next
+    assert_equal [:hoge, 7], enum.next
+    assert_raises StopIteration do
+      enum.next
+    end
+    
+    assert_equal sth2, sth2.keep_if{|k, v|true}
+    assert_equal sth3, sth3.keep_if{|k, v|k == :hoge && v == 7}
+    assert_equal nil, sth3.foo
+    assert_equal true, sth3.assign?(:hoge)
+    assert_equal false, sth3.assign?(:foo)
+    assert_equal 7, sth3.hoge
+  end
+  
+  def test_reject!
+    sth = Sth[hoge: 7, foo: 8]
+    sth2, sth3 = sth.dup, sth.dup
+    
+    assert_kind_of Enumerator, enum = sth.reject!
+    assert_equal [:foo, 8], enum.next
+    assert_equal [:bar, nil], enum.next
+    assert_equal [:hoge, 7], enum.next
+    assert_raises StopIteration do
+      enum.next
+    end
+    
+    enum.rewind
+    assert_equal [:foo, 8], enum.next
+
+    assert_equal nil, sth2.reject!{|k, v|false}
+    assert_equal sth3, sth3.reject!{|k, v|k == :hoge && v == 7}
+    assert_equal nil, sth3.hoge
+    assert_equal false, sth3.assign?(:hoge)
+    assert_equal true, sth3.assign?(:foo)
+    assert_equal 8, sth3.foo
+  end
+
+  def test_delete_if
+    sth = Sth[hoge: 7, foo: 8]
+    sth2, sth3 = sth.dup, sth.dup
+    
+    assert_kind_of Enumerator, enum = sth.delete_if
+
+    assert_equal [:foo, 8], enum.next
+    assert_equal [:bar, nil], enum.next
+    assert_equal [:hoge, 7], enum.next
+    assert_raises StopIteration do
+      enum.next
+    end
+
+    assert_equal sth2, sth2.delete_if{|k, v|false}
+    assert_equal sth3, sth3.delete_if{|k, v|k == :hoge && v == 7}
+    assert_equal nil, sth3.hoge
+    assert_equal false, sth3.assign?(:hoge)
+    assert_equal true, sth3.assign?(:foo)
+    assert_equal 8, sth3.foo
+  end
+  
+  def test_assoc
+    sth = Sth[hoge: 7, foo: 8]
+
+    assert_equal [:foo, 8], sth.assoc(:foo)
+    assert_equal [:bar, nil], sth.assoc(:bar)
+    assert_equal [:hoge, 7], sth.assoc(:hoge)
+    
+    assert_raises NameError do
+      sth.assoc(:dummy)
+    end
+  end
+
+  def test_rassoc
+    sth = Sth[hoge: 7, foo: 7]
+
+    assert_equal [:foo, 7], sth.rassoc(7)
+    assert_equal [:bar, nil], sth.rassoc(nil)
+    assert_equal nil, sth.rassoc(9)
+  end
+
+  def test_flatten
+    sth = Sth[hoge: 7, foo: 8, bar: [1, 2]]
+    assert_equal [:foo, 8, :bar, [1, 2], :hoge, 7], sth.flatten
+    assert_equal [:foo, 8, :bar, [1, 2], :hoge, 7], sth.flatten(1)
+    assert_equal [:foo, 8, :bar, 1, 2, :hoge, 7], sth.flatten(2)
+    assert_equal [:foo, 8, :bar, 1, 2, :hoge, 7], sth.flatten(3)
+    assert_equal [:foo, 8, :bar, 1, 2, :hoge, 7], sth.flatten(-1)
+  end
+  
+  def test_select
+    sth = Sth[hoge: 7, foo: 8]
+
+    assert_kind_of Enumerator, enum = sth.select
+    
+    assert_equal Sth[hoge: 7], sth.select{|k, v|k == :hoge}
+  end
+
+  def test_reject
+    sth = Sth[hoge: 7, foo: 8]
+
+    assert_kind_of Enumerator, enum = sth.reject
+    
+    assert_equal Sth[foo: 8], sth.reject{|k, v|k == :hoge}
+  end
+end
+
+
+class TestStriuctAliasMember < Test::Unit::TestCase
+  class Sth < Striuct.new
+    member :foo, String
+    
+    member :bar, Integer do |v|
+      v
+    end
+    
+    member :hoge, Symbol
+    default :hoge, :'Z'
+    alias_member :abc, :bar
+    default :abc, 8
+  end
+
+  def test_alias_member
+    sth = Sth.new 'A'
+    assert_equal [:foo, :bar, :hoge], sth.members
+
+    assert_equal 8, sth[:abc]
+    flavor = Sth.__send__(:flavor_for, :abc)
+    assert_kind_of Proc, flavor
+    assert_same flavor, Sth.__send__(:flavor_for, :bar)
+    assert_equal 8, sth.abc
+    sth.abc = 5
+    assert_equal 5, sth.bar
+    sth[:abc] = 6
+    assert_equal 6, sth.bar
+    
+    assert_raises Striuct::ConditionError do
+      sth[:abc] = 'a'
+    end
+    
+    assert_raises Striuct::ConditionError do
+      sth.abc = 'a'
+    end
+    
+    assert_raises Striuct::ConditionError do
+      sth.bar = 'a'
+    end
+    
+    assert_raises ArgumentError do
+      Sth.class_eval do
+        member :abc
+      end
+    end
+  end
+end
+
+class TestStriuctSpecificConditions < Test::Unit::TestCase
+  Sth = Striuct.define do
+    member :list_only_int, generics(Integer)
+    member :true_or_false, boolean
+    member :like_str, stringable
+    member :has_x, CAN(:x)
+    member :has_x_and_y, CAN(:x, :y)
+    member :one_of_member, member_of([1, 3])
+    member :has_ignore, AND(1..5, 3..10)
+    member :all_pass, OR(1..5, 3..10)
+    member :catch_name_error, CATCH(NameError){|v|v.no_name!}
+    member :no_exception, STILL(->v{v.class})
+    member :not_integer, NOT(Integer)
+  end
+
+  def test_not
+    sth = Sth.new
+    
+    obj = Object.new
+    
+    sth.not_integer = obj
+    assert_same obj, sth.not_integer
+
+    assert_raises Striuct::ConditionError do
+      sth.not_integer = 1
+    end
+  end
+
+
+  def test_still
+    sth = Sth.new
+    
+    obj = Object.new
+    
+    sth.no_exception = obj
+    assert_same obj, sth.no_exception
+    sth.no_exception = false
+
+    obj.singleton_class.class_eval do
+      undef_method :class
+    end
+
+    assert_raises Striuct::ConditionError do
+      sth.no_exception = obj
+    end
+  end
+
+  def test_catch
+    sth = Sth.new
+    
+    obj = Object.new
+    
+    sth.catch_name_error = obj
+    assert_same obj, sth.catch_name_error
+    sth.catch_name_error = false
+
+    obj.singleton_class.class_eval do
+      def no_name!
+      end
+    end
+
+    assert_raises Striuct::ConditionError do
+      sth.catch_name_error = obj
+    end
+  end
+
+  def test_or
+    sth = Sth.new
+
+    assert_raises Striuct::ConditionError do
+      sth.all_pass = 11
+    end
+    
+    sth.all_pass = 1
+    assert_equal 1, sth.all_pass
+    sth.all_pass = 4
+    assert_equal 4, sth.all_pass
+    assert_equal true, sth.valid?(:all_pass)
+  end
+
+  def test_and
+    sth = Sth.new
+
+    assert_raises Striuct::ConditionError do
+      sth.has_ignore = 1
+    end
+
+    assert_raises Striuct::ConditionError do
+      sth.has_ignore = 2
+    end
+  
+    sth.has_ignore = 3
+    assert_equal 3, sth.has_ignore
+    assert_equal true, sth.valid?(:has_ignore)
+    
+    assert_raises Striuct::ConditionError do
+      sth.has_ignore = []
+    end
+  end
+  
+  def test_member_of
+    sth = Sth.new
+    
+    assert_raises Striuct::ConditionError do
+      sth.one_of_member = 4
+    end
+  
+    sth.one_of_member = 3
+    assert_equal 3, sth.one_of_member
+    assert_equal true, sth.valid?(:one_of_member)
+  end
+  
+  def test_generics
+    sth = Sth.new
+    
+    assert_raises Striuct::ConditionError do
+      sth.list_only_int = [1, '2']
+    end
+  
+    sth.list_only_int = [1, 2]
+    assert_equal [1, 2], sth.list_only_int
+    assert_equal true, sth.valid?(:list_only_int)
+    sth.list_only_int = []
+    assert_equal [], sth.list_only_int
+    assert_equal true, sth.valid?(:list_only_int)
+    sth.list_only_int << '2'
+    assert_equal false, sth.valid?(:list_only_int)
+  end
+  
+  def test_boolean
+    sth = Sth.new
+    
+    assert_raises Striuct::ConditionError do
+      sth.true_or_false = nil
+    end
+    
+    assert_equal false, sth.valid?(:true_or_false)
+  
+    sth.true_or_false = true
+    assert_equal true, sth.true_or_false
+    assert_equal true, sth.valid?(:true_or_false)
+    sth.true_or_false = false
+    assert_equal false, sth.true_or_false
+    assert_equal true, sth.valid?(:true_or_false)
+  end
+  
+  def test_stringable
+    sth = Sth.new
+    obj = Object.new
+    
+    assert_raises Striuct::ConditionError do
+      sth.like_str = obj
+    end
+  
+    sth.like_str = 'str'
+    assert_equal true, sth.valid?(:like_str)
+    sth.like_str = :sym
+    assert_equal true, sth.valid?(:like_str)
+    
+    obj.singleton_class.class_eval do
+      def to_str
+      end
+    end
+    
+    sth.like_str = obj
+    assert_equal true, sth.valid?(:like_str)
+  end
+
+  def test_responsible_arg1
+    sth = Sth.new
+    obj = Object.new
+    
+    assert_raises Striuct::ConditionError do
+      sth.has_x = obj
+    end
+    
+    obj.singleton_class.class_eval do
+      def x
+      end
+    end
+    
+    sth.has_x = obj
+    assert_equal obj, sth.has_x
+    assert_equal true, sth.valid?(:has_x)
+  end
+
+  def test_responsible_arg2
+    sth = Sth.new
+    obj = Object.new
+    
+    assert_raises Striuct::ConditionError do
+      sth.has_x_and_y = obj
+    end
+    
+    obj.singleton_class.class_eval do
+      def x
+      end
+    end
+    
+    assert_raises Striuct::ConditionError do
+      sth.has_x_and_y = obj
+    end
+    
+    obj.singleton_class.class_eval do
+      def y
+      end
+    end
+    
+    sth.has_x_and_y = obj
+    assert_equal obj, sth.has_x_and_y
+    assert_equal true, sth.valid?(:has_x_and_y)
+  end
+end
+
+
+class TestStriuctLock < Test::Unit::TestCase
+  Sth = Striuct.new :foo, :bar
+  Sth.__send__ :close
+  
+  def test_lock
+    sth = Sth.new
+    assert_equal false, sth.lock?(:foo)
+    assert_equal false, sth.lock?(:bar)
+    assert_equal false, sth.secure?
+    sth.lock :bar
+    assert_equal true, sth.lock?(:bar)
+    assert_equal false, sth.secure?
+  
+    assert_raises RuntimeError do
+     sth.bar = 1
+    end
+   
+    sth.__send__ :unlock, :bar
+    
+    assert_equal false, sth.lock?(:bar)
+    
+    sth.bar = 1
+    assert_equal 1, sth.bar
+    
+    sth.lock
+    assert_equal true, sth.lock?(:foo)
+    assert_equal true, sth.lock?(:bar)
+    assert_equal true, sth.lock?
+    
+    assert_raises RuntimeError do
+      sth.foo = 1
+    end
+    
+    assert_equal true, sth.secure?
+  end
+end
+
+class TestStriuctInherit < Test::Unit::TestCase
+  Sth = Striuct.define do
+    member :foo, String
+    member :bar, OR(nil, Fixnum)
+  end
+  
+  class SubSth < Sth
+    member :hoge, OR(nil, 1..3)
+  end
+  
+  class SubSubSth < SubSth
+    member :rest, AND(/\d/, Symbol)
+  end
+  
+  def test_inherit
+    assert_equal [*Sth.members, :hoge], SubSth.members
+    sth = Sth.new
+    substh = SubSth.new
+
+    assert_raises Striuct::ConditionError do
+      substh.bar = 'str'
+    end
+    
+    assert_raises Striuct::ConditionError do
+      substh.hoge = 4
+    end
+    
+    assert_raises NoMethodError do
+      sth.hoge = 3
+    end
+    
+    assert_raises NoMethodError do
+      substh.rest = :a4
+    end
+    
+    subsubsth = SubSubSth.new
+    
+    assert_raises Striuct::ConditionError do
+      subsubsth.rest = 4
+    end
+    
+    subsubsth.rest = :a4
+    
+    assert_equal :a4, subsubsth[:rest]
+    
+    assert_equal true, Sth.__send__(:closed?)
+    assert_equal false, SubSth.__send__(:closed?)
+    SubSth.__send__(:close)
+    assert_equal true, SubSth.__send__(:closed?)
+    assert_equal false, SubSubSth.__send__(:closed?)
+    SubSubSth.__send__(:close)
+    assert_equal true, SubSubSth.__send__(:closed?)
+  end
+end