neuroncheck 0.1.0 → 0.1.1

data/lib/neuroncheck/version.rb

@@ -1,3 +1,3 @@
 module Neuroncheck
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/test/test_advanced_syntactical.rb

@@ -4,122 +4,122 @@ require 'neuroncheck'
 
 # スクリプトエラーのチェック
 class ScriptErrorTest < Test::Unit::TestCase
-	# 二重に定義することはできない
-	test 'double declaration' do
-		assert_raise(NeuronCheckSystem::DeclarationError) do
-			module Foo2
-				extend NeuronCheck
-
-				ndecl {
-				}
-
-				ndecl {
-				}
-			end
-		end
-	end
+  # 二重に定義することはできない
+  test 'double declaration' do
+    assert_raise(NeuronCheckSystem::DeclarationError) do
+      module Foo2
+        extend NeuronCheck
+
+        ndecl {
+        }
+
+        ndecl {
+        }
+      end
+    end
+  end
 end
 
 # ndeclを複数回定義してもエラーにならないことと、1回しか呼ばれないことをチェック
 class MultipleDeclareTest <  Test::Unit::TestCase
-	def self.counter; @counter; end
-	def self.counter=(v); @counter = v; end
-	test "" do
-		cls = Class.new
-		MultipleDeclareTest.counter = 0
-
-		assert_nothing_raised(NeuronCheckSystem::DeclarationError){
-			cls.class_eval do
-				extend NeuronCheck
-
-				3.times do
-					ndecl {
-						args String
-					}
-
-					def foo_method(arg)
-						MultipleDeclareTest.counter += 1
-					end
-				end
-			end
-		}
-
-		cls.new.foo_method('')
-		assert_equal(1, MultipleDeclareTest.counter)
-
-		assert_raise(NeuronCheckError){
-			cls.new.foo_method(1)
-		}
-	end
+  def self.counter; @counter; end
+  def self.counter=(v); @counter = v; end
+  test "" do
+    cls = Class.new
+    MultipleDeclareTest.counter = 0
+
+    assert_nothing_raised(NeuronCheckSystem::DeclarationError){
+      cls.class_eval do
+        extend NeuronCheck
+
+        3.times do
+          ndecl {
+            args String
+          }
+
+          def foo_method(arg)
+            MultipleDeclareTest.counter += 1
+          end
+        end
+      end
+    }
+
+    cls.new.foo_method('')
+    assert_equal(1, MultipleDeclareTest.counter)
+
+    assert_raise(NeuronCheckError){
+      cls.new.foo_method(1)
+    }
+  end
 end
 
 # もともとmethod_addedが定義されていたときに両方とも呼ばれるかどうかのチェック
 class MethodAddedPreservedTest < Test::Unit::TestCase
-	test 'define method_added -> extend NeuronCheck' do
-		class Foo3
-			def self.original_method_added_called; @original_method_added_called; end
-			def self.method_added(name)
-				super
-				@original_method_added_called = true
-			end
-			extend NeuronCheck
-
-			ndecl {
-				args String
-			}
-			def foo3_method(arg1)
-			end
-		end
-
-		assert(Foo3.original_method_added_called)
-
-		assert_raise(NeuronCheckError) do
-			Foo3.new.foo3_method(nil)
-		end
-	end
+  test 'define method_added -> extend NeuronCheck' do
+    class Foo3
+      def self.original_method_added_called; @original_method_added_called; end
+      def self.method_added(name)
+        super
+        @original_method_added_called = true
+      end
+      extend NeuronCheck
+
+      ndecl {
+        args String
+      }
+      def foo3_method(arg1)
+      end
+    end
+
+    assert(Foo3.original_method_added_called)
+
+    assert_raise(NeuronCheckError) do
+      Foo3.new.foo3_method(nil)
+    end
+  end
 end
 
 
 # もともとsingleton_method_addedが定義されていたときに呼ばれるかどうかのチェック
 class SingletonMethodAddedPreservedTest < Test::Unit::TestCase
-	test 'define method_added -> extend NeuronCheck' do
-		class Foo1
-			def self.original_singleton_method_added_called; @original_singleton_method_added_called; end
-			def self.original_singleton_method_added_called=(v); @original_singleton_method_added_called = v; end
-
-			def self.singleton_method_added(name)
-				@original_singleton_method_added_called = true
-			end
-
-			extend NeuronCheck
-
-			ndecl {
-				args String
-			}
-			def foo1_method(arg1)
-			end
-		end
-
-		Foo1.original_singleton_method_added_called = false
-		def Foo1.test1
-			p 1
-		end
-		assert{ Foo1.original_singleton_method_added_called }
-
-		assert_raise(NeuronCheckError) do
-			Foo1.new.foo1_method(nil)
-		end
-	end
+  test 'define method_added -> extend NeuronCheck' do
+    class Foo1
+      def self.original_singleton_method_added_called; @original_singleton_method_added_called; end
+      def self.original_singleton_method_added_called=(v); @original_singleton_method_added_called = v; end
+
+      def self.singleton_method_added(name)
+        @original_singleton_method_added_called = true
+      end
+
+      extend NeuronCheck
+
+      ndecl {
+        args String
+      }
+      def foo1_method(arg1)
+      end
+    end
+
+    Foo1.original_singleton_method_added_called = false
+    def Foo1.test1
+      p 1
+    end
+    assert{ Foo1.original_singleton_method_added_called }
+
+    assert_raise(NeuronCheckError) do
+      Foo1.new.foo1_method(nil)
+    end
+  end
 end
 
 # 複数回extendしても例外は発生しないか？
 class MultipleExtendTest < Test::Unit::TestCase
-	test 'define method_added -> extend NeuronCheck' do
-		 assert_nothing_raised do
-			module Foo3
-				extend NeuronCheck
-				extend NeuronCheck
-			end
-		end
-	end
+  test 'define method_added -> extend NeuronCheck' do
+     assert_nothing_raised do
+      module Foo3
+        extend NeuronCheck
+        extend NeuronCheck
+      end
+    end
+  end
 end

data/test/test_inheritance.rb

@@ -4,150 +4,150 @@ require 'neuroncheck'
 
 # 継承時のチェック
 class InheritanceTest < Test::Unit::TestCase
-	def setup
-		parent_cls = Class.new do
-			extend NeuronCheck
-
-			ndecl {
-				args /a/
-				returns /A/
-			}
-			def test1(name, ret)
-				ret
-			end
-
-			ndecl {
-				args /c/
-				returns /C/
-			}
-			def test2_only_parent(name, ret)
-				ret
-			end
-
-
-			ndecl {
-				precond do
-					assert{arg1 =~ /a/}
-				end
-
-				postcond do |ret|
-					assert{ret =~ /A/}
-				end
-			}
-			def cond_test1(arg1, ret1)
-				ret1
-			end
-
-			ndecl {
-				val String
-			}
-			attr_accessor :attr1
-		end
-
-		child_cls = Class.new(parent_cls) do
-			extend NeuronCheck
-
-			ndecl {
-				args /b/
-				returns /B/
-			}
-			def test1(name, ret = 'ABC')
-				super
-
-				ret
-			end
-
-			ndecl {
-				precond do
-					assert{ arg1 =~ /b/ }
-				end
-
-				postcond do |ret|
-					assert{ ret =~ /B/ }
-				end
-			}
-			def cond_test1(arg1, ret1 = 'ABC')
-				super
-
-				ret1
-			end
-		end
-
-		@parent_inst = parent_cls.new
-		@inst = child_cls.new
-	end
-
-	# 親の引数チェックを引き継ぐ
-	test 'arguments check inherited by superclass' do
-		assert_raise(NeuronCheckError){ @inst.test1(nil) }
-		assert_raise(NeuronCheckError){ @inst.test1('') }
-		assert_raise(NeuronCheckError){ @inst.test1('a123') }
-		assert_raise(NeuronCheckError){ @inst.test1('b123') }
-		assert_nothing_raised{ @inst.test1('a123b') }
-	end
-
-	# 親の引数チェックを引き継ぐ (子で再定義されていない場合)
-	test 'arguments check inherited by superclass (without child overridding)' do
-		assert_raise(NeuronCheckError){ @inst.test2_only_parent('c', 10) }
-		assert_raise(NeuronCheckError){ @inst.test2_only_parent('a', 'C') }
-		assert_nothing_raised{ @inst.test2_only_parent('c', 'C') }
-	end
-
-	# 親の戻り値チェックを引き継ぐ
-	test 'results check inherited by superclass' do
-		assert_raise(NeuronCheckError){ @inst.test1('ab', 'AC') }
-		assert_raise(NeuronCheckError){ @inst.test1('ab', 'BC') }
-		assert_nothing_raised{ @inst.test1('ab', 'aaABC') }
-	end
-	# 親の事前条件チェックを引き継ぐ
-	test 'precond check inherited by superclass' do
-		assert_raise(NeuronCheckError){ @inst.cond_test1(nil) }
-		assert_raise(NeuronCheckError){ @inst.cond_test1('') }
-		assert_raise(NeuronCheckError){ @inst.cond_test1('a123') }
-		assert_raise(NeuronCheckError){ @inst.cond_test1('b123') }
-		assert_nothing_raised{ @inst.cond_test1('a123b') }
-	end
-
-	# 親の事後条件チェックを引き継ぐ
-	test 'postcond check inherited by superclass' do
-		assert_raise(NeuronCheckError){ @inst.cond_test1('ab', 'AC') }
-		assert_raise(NeuronCheckError){ @inst.cond_test1('ab', 'BC') }
-		assert_nothing_raised{ @inst.cond_test1('ab', 'aaABC') }
-	end
-
-	# 親の属性チェックを引き継ぐ
-	test 'attribute check inherited by superclass' do
-		assert_raise(NeuronCheckError){ @inst.attr1 = 30 }
-		assert_nothing_raised{ @inst.attr1 = '1s' }
-	end
+  def setup
+    parent_cls = Class.new do
+      extend NeuronCheck
+
+      ndecl {
+        args /a/
+        returns /A/
+      }
+      def test1(name, ret)
+        ret
+      end
+
+      ndecl {
+        args /c/
+        returns /C/
+      }
+      def test2_only_parent(name, ret)
+        ret
+      end
+
+
+      ndecl {
+        precond do
+          assert{arg1 =~ /a/}
+        end
+
+        postcond do |ret|
+          assert{ret =~ /A/}
+        end
+      }
+      def cond_test1(arg1, ret1)
+        ret1
+      end
+
+      ndecl {
+        val String
+      }
+      attr_accessor :attr1
+    end
+
+    child_cls = Class.new(parent_cls) do
+      extend NeuronCheck
+
+      ndecl {
+        args /b/
+        returns /B/
+      }
+      def test1(name, ret = 'ABC')
+        super
+
+        ret
+      end
+
+      ndecl {
+        precond do
+          assert{ arg1 =~ /b/ }
+        end
+
+        postcond do |ret|
+          assert{ ret =~ /B/ }
+        end
+      }
+      def cond_test1(arg1, ret1 = 'ABC')
+        super
+
+        ret1
+      end
+    end
+
+    @parent_inst = parent_cls.new
+    @inst = child_cls.new
+  end
+
+  # 親の引数チェックを引き継ぐ
+  test 'arguments check inherited by superclass' do
+    assert_raise(NeuronCheckError){ @inst.test1(nil) }
+    assert_raise(NeuronCheckError){ @inst.test1('') }
+    assert_raise(NeuronCheckError){ @inst.test1('a123') }
+    assert_raise(NeuronCheckError){ @inst.test1('b123') }
+    assert_nothing_raised{ @inst.test1('a123b') }
+  end
+
+  # 親の引数チェックを引き継ぐ (子で再定義されていない場合)
+  test 'arguments check inherited by superclass (without child overridding)' do
+    assert_raise(NeuronCheckError){ @inst.test2_only_parent('c', 10) }
+    assert_raise(NeuronCheckError){ @inst.test2_only_parent('a', 'C') }
+    assert_nothing_raised{ @inst.test2_only_parent('c', 'C') }
+  end
+
+  # 親の戻り値チェックを引き継ぐ
+  test 'results check inherited by superclass' do
+    assert_raise(NeuronCheckError){ @inst.test1('ab', 'AC') }
+    assert_raise(NeuronCheckError){ @inst.test1('ab', 'BC') }
+    assert_nothing_raised{ @inst.test1('ab', 'aaABC') }
+  end
+  # 親の事前条件チェックを引き継ぐ
+  test 'precond check inherited by superclass' do
+    assert_raise(NeuronCheckError){ @inst.cond_test1(nil) }
+    assert_raise(NeuronCheckError){ @inst.cond_test1('') }
+    assert_raise(NeuronCheckError){ @inst.cond_test1('a123') }
+    assert_raise(NeuronCheckError){ @inst.cond_test1('b123') }
+    assert_nothing_raised{ @inst.cond_test1('a123b') }
+  end
+
+  # 親の事後条件チェックを引き継ぐ
+  test 'postcond check inherited by superclass' do
+    assert_raise(NeuronCheckError){ @inst.cond_test1('ab', 'AC') }
+    assert_raise(NeuronCheckError){ @inst.cond_test1('ab', 'BC') }
+    assert_nothing_raised{ @inst.cond_test1('ab', 'aaABC') }
+  end
+
+  # 親の属性チェックを引き継ぐ
+  test 'attribute check inherited by superclass' do
+    assert_raise(NeuronCheckError){ @inst.attr1 = 30 }
+    assert_nothing_raised{ @inst.attr1 = '1s' }
+  end
 end
 
 # 親と子でそれぞれ別々にextendした場合
 class InheritanceOtherExtendTest < Test::Unit::TestCase
 
-	# 親のみextend
-	test 'extend only Parent' do
-		par_cls = Class.new do
-			extend NeuronCheck
-
-			ndecl {
-				args String
-			}
-			def foo_method(str1)
-			end
-		end
-
-		chd_cls = Class.new(par_cls) do
-			ndecl {
-				args String
-			}
-			def bar_method(str2)
-			end
-		end
-
-		chd = chd_cls.new
-		assert_raise(NeuronCheckError){ chd.foo_method(1) }
-		assert_raise(NeuronCheckError){ chd.bar_method(2) }
-	end
+  # 親のみextend
+  test 'extend only Parent' do
+    par_cls = Class.new do
+      extend NeuronCheck
+
+      ndecl {
+        args String
+      }
+      def foo_method(str1)
+      end
+    end
+
+    chd_cls = Class.new(par_cls) do
+      ndecl {
+        args String
+      }
+      def bar_method(str2)
+      end
+    end
+
+    chd = chd_cls.new
+    assert_raise(NeuronCheckError){ chd.foo_method(1) }
+    assert_raise(NeuronCheckError){ chd.bar_method(2) }
+  end
 
 end