striuct 0.6.1 → 0.7.0

data/test/test_subc-c-copy.rb

@@ -1,71 +0,0 @@
-require_relative 'helper'
-
-class Test_Striuct_Subclass_Class_Copy < Test::Unit::TestCase
-
-  def test_dup
-    org_cls = Striuct.define do
-      member :sth
-    end.freeze
-
-    assert_same true, org_cls.frozen?
-    assert_same true, org_cls.closed?
-    cls2 = org_cls.dup
-    assert_same true, org_cls.frozen?
-    assert_same true, org_cls.closed?
-    assert_same false, cls2.frozen?
-    assert_same false, cls2.closed?
-    cls2.__send__ :member, :dummy1
-    assert_same false, org_cls.member?(:dummy1)
-  end
-  
-  def test_clone
-    org_cls = Striuct.define do
-      member :sth
-    end.freeze
-
-    assert_same true, org_cls.frozen?    
-    assert_same true, org_cls.closed?
-    cls2 = org_cls.clone
-    assert_same true, org_cls.frozen?
-    assert_same true, org_cls.closed?
-    assert_same true, cls2.frozen?
-    assert_same true, cls2.closed?
-  end
-
-  def test_dup_deep
-    org_cls =  Striuct.define do
-      member :foo, Numeric
-    end
-
-    foo = org_cls.new
-    cls2 = org_cls.dup
-    foo2 = cls2.new
-    foo2.foo = 0.1
-    assert_raises Validation::InvalidWritingError do
-      foo2.foo = '1'
-    end
-
-    foo.foo = 1
-
-    assert_same 1, foo.foo
-  end
-
-  def test_clone_deep
-    org_cls =  Striuct.define do
-      member :foo, Numeric
-    end
-
-    foo = org_cls.new
-    cls2 = org_cls.clone
-    foo2 = cls2.new
-    foo2.foo = 0.1
-    assert_raises Validation::InvalidWritingError do
-      foo2.foo = '1'
-    end
-
-    foo.foo = 1
-
-    assert_same 1, foo.foo
-  end
-
-end

data/test/test_subc-c-freeze.rb

@@ -1,36 +0,0 @@
-require_relative 'helper'
-
-class Test_Striuct_Subclass_Class_Freeze < Test::Unit::TestCase
-
-  Sth = Striuct.new do
-    member :foo
-  end
-
-  def test_class_freeze
-    sth = Sth.new
-
-    assert_same true, sth.member?(:foo)
-
-    Sth.class_eval do
-      member :bar
-    end
-
-    assert_same true, sth.member?(:bar)
-    assert_equal [:foo, :bar], sth.members
-    
-    assert_same false, Sth.frozen?
-    
-    Sth.freeze
-    
-    assert_same true, Sth.frozen?
-   
-    assert_raises RuntimeError do
-      Sth.class_eval do
-        member :var2
-      end
-    end
-   
-    assert_same false, sth.member?(:var2)
-  end
-
-end

data/test/test_subc-c-inheritable.rb

@@ -1,58 +0,0 @@
-require_relative 'helper'
-
-class Test_Striuct_Subclass_Class_Inheritable < Test::Unit::TestCase
-
-  Sth = Striuct.define do
-    member :foo, String
-    member :bar, OR(nil, Integer)
-  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 Validation::InvalidWritingError do
-      substh.bar = 'str'
-    end
-    
-    assert_raises Validation::InvalidWritingError 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 Validation::InvalidWritingError 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

data/test/test_subc-c-safety_naming.rb

@@ -1,73 +0,0 @@
-require_relative 'helper'
-
-class Test_Striuct_Subclass_Class_SafetyNaming < Test::Unit::TestCase
-
-  def test_cname?
-    klass = Striuct.new
-    assert_same false, klass.cname?(BasicObject)
-    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__ :set_conflict_management_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__ :set_conflict_management_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
-  
-  def test_protect
-    klass = Striuct.new
-    assert_raises NameError do
-      klass.class_eval do
-        member ''
-      end
-    end
-    
-    assert_raises NameError do
-      klass.class_eval do
-        member :'a b'
-      end
-    end
-
-    assert_raises NameError do
-      klass.class_eval do
-        member :'__send__'
-      end
-    end
-
-    assert_raises NameError do
-      klass.class_eval do
-        member :'__foo__'
-      end
-    end
-    
-    assert_raises NameError do
-      klass.class_eval do
-        member :'m?'
-      end
-    end
-  
-    assert_same false, klass.member?('m?')
-    
-    klass.class_eval do
-      conflict_management :struct do
-        member :'m?'
-      end
-    end
-    
-    assert_same true, klass.member?('m?')
-  end
-
-end

data/test/test_subc-f-alias_member.rb

@@ -1,54 +0,0 @@
-require_relative 'helper'
-
-class Test_Striuct_Subclass_AliasMember < 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 [:foo, :bar, :hoge], sth.autonyms
-    assert_equal({abc: :bar}, sth.aliases)
-    assert_equal [:foo, :bar, :hoge, :abc], sth.all_members
-
-    assert_equal 8, sth[:abc]
-    adjuster = Sth.__send__(:adjuster_for, :abc)
-    assert_kind_of Proc, adjuster
-    assert_same adjuster, Sth.__send__(:adjuster_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 Validation::InvalidWritingError do
-      sth[:abc] = 'a'
-    end
-    
-    assert_raises Validation::InvalidWritingError do
-      sth.abc = 'a'
-    end
-    
-    assert_raises Validation::InvalidWritingError do
-      sth.bar = 'a'
-    end
-    
-    assert_raises ArgumentError do
-      Sth.class_eval do
-        member :abc
-      end
-    end
-  end
-
-end

data/test/test_subc-f-enum.rb

@@ -1,159 +0,0 @@
-require_relative 'helper'
-
-class Test_Striuct_Subclass_Enum < Test::Unit::TestCase
-  
-  class Subclass < Striuct
-    member :foo
-    member :bar
-
-    close_member
-  end.freeze
-
-  FOO = 'Fooo! :)'.freeze
-  BAR = 'bar :('.freeze
-  INSTANCE = Subclass.new(FOO, BAR).freeze
-  
-  TYPE_PAIRS = {
-    class: Subclass,
-    instance: INSTANCE
-  }.freeze
-
-  [:each_autonym, :each_member].each do |callee|
-    TYPE_PAIRS.each_pair do |type, reciever|
-      define_method :"test_#{type}_#{callee}" do
-        assert_same(reciever, reciever.public_send(callee) {})
-        
-        enum = reciever.public_send(callee)
-        assert_instance_of Enumerator, enum
-        assert_equal 2, enum.size
-        assert_same :foo, enum.next
-        assert_same :bar, enum.next
-        assert_raises StopIteration do
-          enum.next
-        end
-      end
-    end
-  end
-  
-  [:each_index].each do |callee|
-    TYPE_PAIRS.each_pair do |type, reciever|
-      define_method :"test_#{type}_#{callee}" do
-        assert_same(reciever, reciever.public_send(callee) {})
-        
-        enum = reciever.public_send(callee)
-        assert_instance_of Enumerator, enum
-        assert_equal 2, enum.size
-        assert_same 0, enum.next
-        assert_same 1, enum.next
-        assert_raises StopIteration do
-          enum.next
-        end
-      end
-    end
-  end
-
-  [:each_autonym_with_index, :each_member_with_index].each do |callee|
-    TYPE_PAIRS.each_pair do |type, reciever|
-      define_method :"test_#{type}_#{callee}" do
-        assert_same(reciever, reciever.public_send(callee) {})
-        
-        enum = reciever.public_send(callee)
-        assert_instance_of Enumerator, enum
-        assert_equal 2, enum.size
-        assert_equal [:foo, 0], enum.next
-        assert_equal [:bar, 1], enum.next
-        assert_raises StopIteration do
-          enum.next
-        end
-      end
-    end
-  end
-  
-  [:each_value, :each].each do |callee|
-    {instance: INSTANCE}.each_pair do |type, reciever|
-      define_method :"test_#{type}_#{callee}" do
-        assert_same(reciever, reciever.public_send(callee) {})
-        
-        enum = reciever.public_send(callee)
-        assert_instance_of Enumerator, enum
-        assert_equal 2, enum.size
-        assert_same FOO, enum.next
-        assert_same BAR, enum.next
-        assert_raises StopIteration do
-          enum.next
-        end
-      end
-    end
-  end
-
-  [:each_value_with_index, :each_with_index].each do |callee|
-    {instance: INSTANCE}.each_pair do |type, reciever|
-      define_method :"test_#{type}_#{callee}" do
-        assert_same(reciever, reciever.public_send(callee) {})
-        
-        enum = reciever.public_send(callee)
-        assert_instance_of Enumerator, enum
-        assert_equal 2, enum.size
-        assert_equal [FOO, 0], ret = enum.next
-        assert_same FOO, ret.first
-        assert_equal [BAR, 1], ret = enum.next
-        assert_same BAR, ret.first
-        assert_raises StopIteration do
-          enum.next
-        end
-      end
-    end
-  end
-
-  [:each_pair].each do |callee|
-    {instance: INSTANCE}.each_pair do |type, reciever|
-      define_method :"test_#{type}_#{callee}" do
-        assert_same(reciever, reciever.public_send(callee) {})
-        
-        enum = reciever.public_send(callee)
-        assert_instance_of Enumerator, enum
-        assert_equal 2, enum.size
-        assert_equal [:foo, FOO], ret = enum.next
-        assert_same FOO, ret.last
-        assert_equal [:bar, BAR], ret = enum.next
-        assert_same BAR, ret.last
-        assert_raises StopIteration do
-          enum.next
-        end
-      end
-    end
-  end
-
-  [:each_pair_with_index].each do |callee|
-    {instance: INSTANCE}.each_pair do |type, reciever|
-      define_method :"test_#{type}_#{callee}" do
-        assert_same(reciever, reciever.public_send(callee) {})
-        
-        enum = reciever.public_send(callee)
-        assert_instance_of Enumerator, enum
-        assert_equal 2, enum.size
-        assert_equal [:foo, FOO, 0], ret = enum.next
-        assert_same FOO, ret[1]
-        assert_equal [:bar, BAR, 1], ret = enum.next
-        assert_same BAR, ret[1]
-        assert_raises StopIteration do
-          enum.next
-        end
-      end
-    end
-    
-    def test_modified_members_enum_size
-      klass = Striuct.new do
-        member :foo
-      end
-      cenum = klass.each_autonym
-      ienum = klass.new.each_autonym
-      assert_equal 1, cenum.size
-      assert_equal 1, ienum.size
-      klass.send :member, :bar
-      assert_equal 2, cenum.size
-      assert_equal 2, ienum.size
-    end
-  end
-
-end