striuct 0.4.4 → 0.7.0

data/test/test_subc-i-accessor.rb

@@ -1,138 +0,0 @@
-require_relative 'helper'
-
-class Test_Striuct_Subclass_Instance_Setter < Test::Unit::TestCase
-
-  class User < Striuct.new
-    member :id, Integer
-    member :last_name, /\A\w+\z/
-    member :family_name, /\A\w+\z/
-    member :address, /\A((\w+) ?)+\z/
-    member :age, ->age{(20..140).include? age}
-  end
-
-  def test_setter
-    user = User.new
-    user[:last_name] = 'foo'
-    assert_equal user.last_name, 'foo'
-    user.last_name = 'bar'
-    assert_equal user[:last_name], 'bar'
-    
-    assert_raises Validation::InvalidWritingError do
-      user[:last_name] = 'foo s'
-    end
-  
-    assert_raises Validation::InvalidWritingError do
-      User.new 'asda'
-    end
-    
-    assert_raises Validation::InvalidWritingError do
-      user.age = 19
-    end
-  end
-
-end
-
-class Test_Striuct_Subclass_Instance_Accessor_With_Validation < Test::Unit::TestCase
-
-  class User < Striuct.new
-    member :id, Integer
-    member :last_name, /\A\w+\z/
-    member :family_name, /\A\w+\z/
-    member :address, /\A((\w+) ?)+\z/
-    member :age, ->age{(20..140).include? age}
-  end
-  
-  def setup
-    @user = User.new 9999, 'taro', 'yamada', 'Tokyo Japan', 30
-  end
-
-  def test_reader
-    assert_equal @user[1], 'taro'
-    assert_equal @user[:last_name], 'taro'
-    assert_equal @user.last_name, 'taro'
-  end
-
-  def test_setter_pass
-    assert_equal((@user.id = 2139203509295), 2139203509295)
-    assert_equal @user.id, 2139203509295
-    assert_equal((@user.last_name = 'jiro'), 'jiro')
-    assert_equal @user.last_name, 'jiro'
-    assert_equal((@user.age = 40), 40)
-    assert_equal @user.age, 40
-  end
-  
-  def test_setter_fail
-    assert_raises Validation::InvalidWritingError do
-      @user.id = 2139203509295.0
-    end
-
-    assert_raises Validation::InvalidWritingError do
-      @user.last_name = 'ignore name'
-    end
-    
-    assert_raises Validation::InvalidWritingError do
-      @user.age = 19
-    end
-  end
-  
-  def test_strict?
-    assert_same @user.sufficient?(:last_name), true
-    assert_same @user.strict?, true
-    assert_same @user.sufficient?(:last_name), true
-    @user.last_name.clear
-    assert_same @user.sufficient?(:last_name), false
-    assert_same @user.strict?, false
-  end
-
-end
-
-
-class Test_Striuct_Subclass_Instance_Accsessor < Test::Unit::TestCase
-
-  class Sth < Striuct.new
-    member :bool, OR(true, false)
-    member :sth
-    conflict_management :struct do
-      member :lambda, OR(->v{v % 3 == 2}, ->v{v.kind_of? Float})
-    end
-  end
-  
-  def setup
-    @sth = Sth.new
-  end
-
-  def test_accessor
-    @sth.bool = true
-    assert_same true, @sth.bool
-    @sth.bool = false
-    assert_same false, @sth.bool
-    
-    assert_raises Validation::InvalidWritingError do
-      @sth.bool = nil
-    end
-    
-    @sth.sth = 1
-    assert_same 1, @sth.sth
-
-    @sth.sth = 'String'
-    assert_equal 'String', @sth.sth
-    
-    @sth.sth = Class.class
-    assert_same Class.class, @sth.sth
-    
-    assert_raises Validation::InvalidWritingError do
-      @sth.lambda = 9
-    end
-    
-    assert_raises Validation::InvalidWritingError do
-      @sth.lambda = 7
-    end
-    
-    @sth.lambda = 8
-    assert_same 8, @sth.lambda
-
-    @sth.lambda = 9.0
-    assert_equal 9.0, @sth.lambda
-  end
-
-end

data/test/test_subc-i-adjuster.rb

@@ -1,95 +0,0 @@
-require_relative 'helper'
-
-
-class Test_Striuct_Subclass_Instance_Adjuster < Test::Unit::TestCase
-
-  class MyClass
-    def self.parse(v)
-      raise unless /\A[a-z]+\z/ =~ v
-      new
-    end
-  end
-  
-  Sth = Striuct.define do
-    member :chomped, AND(Symbol, /[^\n]\z/), &WHEN(String, ->v{v.chomp.to_sym})
-    member :no_reduced, Symbol, &->v{v.to_sym}
-    member :reduced, Symbol, &INJECT(->v{v.to_s}, ->v{v.to_sym})
-    member :integer, Integer, &PARSE(Integer)
-    member :myobj, ->v{v.instance_of? MyClass}, &PARSE(MyClass)
-  end
-  
-  def test_WHEN
-    sth = Sth.new
-    
-    assert_raises Validation::InvalidWritingError do
-      sth.chomped = :"a\n"
-    end
-    
-    sth.chomped = "a\n"
-    
-    assert_equal :a, sth.chomped
-    
-    sth.chomped = :b
-    assert_equal :b, sth.chomped
-  end
-
-  def test_INJECT
-    sth = Sth.new
-    
-    assert_raises Validation::UnmanagebleError do
-      sth.no_reduced = 1
-    end
-    
-    sth.reduced = 1
-    
-    assert_equal :'1', sth.reduced
-  end
-  
-  def test_PARSE
-    sth = Sth.new
-    
-    assert_raises Validation::UnmanagebleError do
-      sth.integer = '1.0'
-    end
-    
-    sth.integer = '1'
-    
-    assert_equal 1, sth.integer
-    
-    assert_raises Validation::UnmanagebleError do
-      sth.myobj = '1'
-    end
-    
-    sth.myobj = 'a'
-    
-    assert_kind_of MyClass, sth.myobj
-  end
-
-end
-
-class Test_Striuct_Subclass_Instance_AdjusterOld < Test::Unit::TestCase
-
-  Sth = Striuct.new do
-    member :age, Numeric, &->arg{Integer arg}
-  end
-  
-  def setup
-    @sth = Sth.new
-    assert_same nil, @sth.age
-  end
-  
-  def test_procedure
-    @sth.age = 10
-    assert_same 10, @sth.age
-    @sth.age = 10.0
-    assert_same 10, @sth.age
-
-    assert_raises Validation::UnmanagebleError do
-      @sth.age = '10.0'
-    end
-    
-    @sth.age = '10'
-    assert_same 10, @sth.age
-  end
-
-end

data/test/test_subc-i-assign.rb

@@ -1,53 +0,0 @@
-require_relative 'helper'
-
-class Test_Striuct_Subclass_Instance_Assign < Test::Unit::TestCase
-
-  Sth = Striuct.new do
-    member :foo
-  end  
-
-  [:unassign, :delete_at].each do |callee|
-    define_method :"test_#{callee}" do
-      sth = Sth.new
-      assert_equal false, sth.assign?(:foo)
-      assert_equal false, sth.assigned?(:foo)
-      sth.foo = nil
-      assert_equal true, sth.assign?(:foo)
-      assert_equal true, sth.assigned?(:foo)
-      sth.public_send callee, :foo
-      assert_equal false, sth.assign?(:foo)
-      assert_equal false, sth.assigned?(:foo)
-      sth.foo = nil
-      assert_equal true, sth.assign?(:foo)
-      assert_equal true, sth.assigned?(:foo)
-      sth.public_send callee, 0
-      assert_equal false, sth.assign?(:foo)
-      
-      assert_raises KeyError do
-        sth.public_send callee, :var
-      end
-      
-      assert_raises KeyError do
-        sth.public_send callee, 1
-      end
-    end
-  end
-  
-  def test_empty?
-    cls = Striuct.new :foo, :bar
-    sth = cls.new
-    
-    assert_same true, sth.empty?
-    
-    sth.foo = nil
-    assert_same false, sth.empty?
-    sth.bar = true
-    assert_same false, sth.empty?
-    sth.unassign :foo
-    assert_same false, sth.empty?
-    sth.unassign :bar
-
-    assert_same true, sth.empty?
-  end
-
-end

data/test/test_subc-i-basic.rb

@@ -1,32 +0,0 @@
-require_relative 'helper'
-
-class Test_Striuct_Subclass_Instance_Basic < Test::Unit::TestCase
-
-  class User < Striuct.new
-    member :id, Integer
-    member :last_name, /\A\w+\z/
-    member :family_name, /\A\w+\z/
-    member :address, /\A((\w+) ?)+\z/
-    member :age, ->age{(20..140).include? age}
-  end
-
-  def setup
-    @user = User.new 9999, 'taro', 'yamada', 'Tokyo Japan', 30
-    @user2 = User.new 9999, 'taro', 'yamada', 'Tokyo Japan', 30
-  end
-  
-  def test_delegate_class_method
-    assert_equal @user.members, User.members
-    assert_equal @user.size, User.size
-    assert_equal @user.member?(:age), User.member?(:age)
-  end
-
-  def test_values
-    assert_equal @user.values, [9999, 'taro', 'yamada', 'Tokyo Japan', 30]
-  end
-  
-  def test_values_at
-    assert_equal(@user.values_at(4, 0, (2..4)), [30, 9999, 'yamada', 'Tokyo Japan', 30])
-  end
-
-end

data/test/test_subc-i-cast.rb

@@ -1,27 +0,0 @@
-require_relative 'helper'
-
-class Test_Striuct_Subclass_Instance_Cast < Test::Unit::TestCase
-
-  Sth = Striuct.new :foo, :bar, :hoge
-  
-  def test_to_h
-    sth = Sth.new
-    assert_equal({foo: nil, bar: nil, hoge: nil}, sth.to_h)
-    assert_equal({foo: nil, bar: nil, hoge: nil}, sth.to_h(true))
-    assert_equal({}, sth.to_h(false))
-
-    sth.bar = :BAR
-    assert_equal({foo: nil, bar: :BAR, hoge: nil}, sth.to_h)
-    assert_equal({foo: nil, bar: :BAR, hoge: nil}, sth.to_h(true))
-    assert_equal({bar: :BAR}, sth.to_h(false))
-  end
-
-  def test_to_a
-    sth = Sth.new
-    assert_equal([nil, nil, nil], sth.to_a)
-
-    sth.bar = :BAR
-    assert_equal([nil, :BAR, nil], sth.to_a)
-  end
-
-end

data/test/test_subc-i-compare.rb

@@ -1,52 +0,0 @@
-require_relative 'helper'
-
-
-class Test_Striuct_Subclass_Instance_Compare < Test::Unit::TestCase
-  
-  class User < Striuct.new
-    member :id, Integer
-    member :last_name, /\A\w+\z/
-    member :family_name, /\A\w+\z/
-    member :address, /\A((\w+) ?)+\z/
-    member :age, ->age{(20..140).include? age}
-  end
-
-  def setup
-    @user = User.new 9999, 'taro', 'yamada', 'Tokyo Japan', 30
-    @user2 = User.new 9999, 'taro', 'yamada', 'Tokyo Japan', 30
-  end
-  
-  def test_hash
-    assert_kind_of Integer, @user.hash
-    assert_equal @user.hash, @user2.hash
-  end
-  
-  def test_eql?
-    assert_equal true, @user.eql?(@user2)
-    assert_equal true, @user2.eql?(@user)
-    assert_equal false, @user.eql?(User.new 9999, 'taro', 'yamada', 'Tokyo Japan', 31)
-  end
-  
-  def test_equal
-    user1 = User.new 11218, 'taro'
-    user2 = User.new 11218, 'taro'
-    assert_equal true, (user1 == user2)
-    user2.last_name = 'ichiro'
-    assert_equal false, (user1 == user2)
-  end
-  
-  Sth = Striuct.new :foo, :bar, :hoge
-
-  def test_hashkeyable
-    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

data/test/test_subc-i-copy.rb

@@ -1,23 +0,0 @@
-require_relative 'helper'
-
-class Test_Striuct_Subclass_Instance_Copy < Test::Unit::TestCase
-
-  class Sth < Striuct.new
-    member :sth
-  end
-  
-  def test_dup
-    sth = Sth.new
-    sth2 = sth.dup
-    sth.sth = 1
-    assert_equal false, (sth.sth == sth2.sth)
-  end
-  
-  def test_clone
-    sth = Sth.new
-    sth2 = sth.clone
-    sth.sth = 2
-    assert_equal false, (sth.sth == sth2.sth)
-  end
-
-end

data/test/test_subc-i-default_value.rb

@@ -1,129 +0,0 @@
-require_relative 'helper'
-
-class Test_Striuct_Subclass_Instance_Default_Value < Test::Unit::TestCase
-
-  Sth = Striuct.new do
-    member :lank, OR(Bignum, Fixnum)
-    default :lank, 1
-  end
-  
-  def test_default
-    sth = Sth.new 2
-    assert_equal 2, sth.lank
-    sth = Sth.new
-    assert_equal 1, sth.lank
-    assert_equal true, sth.default?(:lank)
-    sth.lank = 2
-    assert_equal false, sth.default?(:lank)
-  end
-  
-  def test_define_default
-    assert_raises NameError do
-      Sth.class_eval do
-        default :anything, 10
-      end
-    end
-    
-    klass = Striuct.define do
-      member :lank2, Integer
-      default :lank2, '10'
-    end
-
-    assert_raises Validation::InvalidWritingError do
-      klass.new
-    end
-    
-    scope = self
-    seef = nil
-    klass = Striuct.define do
-      member :lank, Integer
-
-      scope.assert_raises ArgumentError do
-        default :lank, &->own, name, exess{rand}
-      end
-
-      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 Validation::InvalidWritingError 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
-
-class Test_Striuct_Subclass_Instance_DefaultValue_Under_MemberMacro < Test::Unit::TestCase
-
-  Sth = Striuct.new do
-    member :lank, OR(Bignum, Fixnum), default: 1
-  end
-  
-  def test_default
-    sth = Sth.new 2
-    assert_equal 2, sth.lank
-    sth = Sth.new
-    assert_equal 1, sth.lank
-    assert_equal true, sth.default?(:lank)
-    sth.lank = 2
-    assert_equal false, sth.default?(:lank)
-  end
-  
-  def test_define_default
-    assert_raises NameError do
-      Sth.class_eval do
-        default :anything, 10
-      end
-    end
-    
-    klass = Striuct.define do
-      member :lank2, Integer, default: '10'
-    end
-
-    assert_raises Validation::InvalidWritingError do
-      klass.new
-    end
-    
-    scope = self
-    seef = nil
-    klass = Striuct.define do
-      
-      scope.assert_raises OptionalArgument::KeyConflictError do
-        member :lank, Integer, default: '10', default_proc: ->own,name{rand}
-      end
-      
-      member :lank, Integer, default_proc: ->own,name{(seef = own); rand}
-    end
-    
-    assert_raises Validation::InvalidWritingError do
-      klass.new
-    end
-    
-    klass = Striuct.define do
-      member :lank, Integer, default_proc: ->own,name{(seef = own); 10 - name.length}
-    end
-    
-    assert_equal 6, klass.new.lank
-    assert_equal seef, klass.new
-  end
-
-end