oktest 1.3.1 → 1.5.0

data/test/assertion_test.rb

@@ -1,24 +1,25 @@
 # -*- coding: utf-8 -*-
+# frozen_string_literal: true
 
 ###
-### $Release: 1.3.1 $
+### $Release: 1.5.0 $
 ### $Copyright: copyright(c) 2011-2024 kuwata-lab.com all rights reserved $
 ### $License: MIT License $
 ###
 
-require_relative './initialize'
+require_relative './init'
 
 
-class AssertionObject_TC < TC
-  #include Test::Unit::Assertions
-  include Oktest::SpecHelper
+class AssertionObject__Test
+  extend NanoTest
+  extend Oktest::SpecHelper
 
-  def FAIL!(errmsg, &b)
+  def self.FAIL!(errmsg, &b)
     failmsg = "expected to be failed, but succeeded unexpectedly."
     return ERROR!(Oktest::FAIL_EXCEPTION, errmsg, failmsg, &b)
   end
 
-  def ERROR!(errcls, errmsg=nil, _failmsg=nil, &b)
+  def self.ERROR!(errcls, errmsg=nil, _failmsg=nil, &b)
     exc = nil
     begin
       yield
@@ -28,92 +29,92 @@ class AssertionObject_TC < TC
         raise
     else
       _failmsg ||= "#{errcls} expected to be raised, but nothing raised."
-      assert false, _failmsg
+      test_ok? false, _failmsg
     end
     #
     if errmsg
-      assert errmsg === exc.message,
-        ("unexpected error message:\n"\
-         "  expected: #{errmsg}\n"\
-         "  actual:   #{exc.message}")
+      test_ok? errmsg === exc.message,
+              msg: ("unexpected error message:\n"\
+                    "  expected: #{errmsg}\n"\
+                    "  actual:   #{exc.message}")
     end
     #
     return exc
   end
 
-  def PASS!()
+  def self.PASS!(&b)
     yield
   end
 
-  def should_return_self
+  def self.should_return_self(&b)
     obj = yield
-    assert obj.class == Oktest::AssertionObject
+    test_ok? obj.class == Oktest::AssertionObject
   end
 
 
-  describe '.report_not_yet()' do
-    it "[!3nksf] reports if 'ok{}' called but assertion not performed." do
-      assert Oktest::AssertionObject::NOT_YET.empty?, "should be empty"
-      sout, serr = capture do
+  test_target 'Oktest::AssertionObject.report_not_yet()' do
+    test_subject "[!3nksf] reports if 'ok{}' called but assertion not performed." do
+      test_ok? Oktest::AssertionObject::NOT_YET.empty?, msg: "should be empty"
+      sout, serr = capture_output! do
         Oktest::AssertionObject.report_not_yet()
       end
-      assert_eq sout, ""
-      assert_eq serr, ""
+      test_eq? sout, ""
+      test_eq? serr, ""
       #
       lineno = __LINE__ + 1
       ok {1+1}
-      assert ! Oktest::AssertionObject::NOT_YET.empty?, "should not be empty"
-      sout, serr = capture { Oktest::AssertionObject.report_not_yet() }
+      test_ok? ! Oktest::AssertionObject::NOT_YET.empty?, msg: "should not be empty"
+      sout, serr = capture_output! { Oktest::AssertionObject.report_not_yet() }
       expected = "** warning: ok() is called but not tested yet (at #{__FILE__}:#{lineno}:in"
-      assert_eq sout, ""
-      assert serr.start_with?(expected), "not matched"
+      test_eq? sout, ""
+      test_ok? serr.start_with?(expected), msg: "not matched"
     end
-    it "[!f92q4] clears remained objects." do
+    test_subject "[!f92q4] clears remained objects." do
       ok {1+1}
-      assert ! Oktest::AssertionObject::NOT_YET.empty?, "should not be empty"
-      sout, serr = capture { Oktest::AssertionObject.report_not_yet() }
-      assert Oktest::AssertionObject::NOT_YET.empty?, "should be empty"
+      test_ok? ! Oktest::AssertionObject::NOT_YET.empty?, msg: "should not be empty"
+      sout, serr = capture_output! { Oktest::AssertionObject.report_not_yet() }
+      test_ok? Oktest::AssertionObject::NOT_YET.empty?, msg: "should be empty"
     end
   end
 
-  describe '.NOT()' do
-    it "[!g775v] returns self." do
+  test_target 'Oktest::AssertionObject.NOT()' do
+    test_subject "[!g775v] returns self." do
       begin
         should_return_self { ok {1+1}.NOT }
       ensure
         Oktest::AssertionObject::NOT_YET.clear()
       end
     end
-    it "[!63dde] toggles internal boolean." do
+    test_subject "[!63dde] toggles internal boolean." do
       begin
         x = ok {1+1}
-        assert_eq x.bool, true
+        test_eq? x.bool, true
         x.NOT
-        assert_eq x.bool, false
+        test_eq? x.bool, false
       ensure
         Oktest::AssertionObject::NOT_YET.clear()
       end
     end
   end
 
-  describe '#==' do
-    it "[!c6p0e] returns self when passed." do
+  test_target 'Oktest::AssertionObject#==' do
+    test_subject "[!c6p0e] returns self when passed." do
       should_return_self { ok {1+1} == 2 }
     end
-    it "[!1iun4] raises assertion error when failed." do
+    test_subject "[!1iun4] raises assertion error when failed." do
       errmsg = "$<actual> == $<expected>: failed.\n"\
                "    $<actual>:   2\n"\
                "    $<expected>: 3"
       FAIL!(errmsg) { ok {1+1} == 3 }
     end
-    it "[!eyslp] is avaialbe with NOT." do
+    test_subject "[!eyslp] is avaialbe with NOT." do
       PASS! { ok {1+1}.NOT == 3 }
       errmsg = "$<actual> != $<expected>: failed.\n"\
                "    $<actual>:   2\n"\
                "    $<expected>: 2"
       FAIL!(errmsg) { ok {1+1}.NOT == 2 }
     end
-    it "[!3xnqv] shows context diff when both actual and expected are text." do
+    test_subject "[!3xnqv] shows context diff when both actual and expected are text." do
       expected = "Haruhi\nMikuru\nYuki\n"
       actual   = "Haruhi\nMichiru\nYuki\n"
       errmsg = <<'END'
@@ -132,18 +133,18 @@ END
     end
   end
 
-  describe '#!=' do
-    it "[!iakbb] returns self when passed." do
+  test_target 'Oktest::AssertionObject#!=' do
+    test_subject "[!iakbb] returns self when passed." do
       should_return_self { ok {1+1} != 3 }
     end
-    it "[!90tfb] raises assertion error when failed." do
+    test_subject "[!90tfb] raises assertion error when failed." do
       #errmsg = "<2> expected to be != to\n<2>."
       errmsg = "$<actual> != $<expected>: failed.\n"\
                "    $<actual>:   2\n"\
                "    $<expected>: 2"
       FAIL!(errmsg) { ok {1+1} != 2 }
     end
-    it "[!l6afg] is avaialbe with NOT." do
+    test_subject "[!l6afg] is avaialbe with NOT." do
       PASS! { ok {1+1}.NOT != 2 }
       #errmsg = "<3> expected but was\n<2>."
       errmsg = "$<actual> == $<expected>: failed.\n"\
@@ -153,39 +154,41 @@ END
     end
   end #if RUBY_VERSION >= "1.9"
 
-  describe '#===' do
-    it "[!uh8bm] returns self when passed." do
+  test_target 'Oktest::AssertionObject#===' do
+    test_subject "[!uh8bm] returns self when passed." do
       should_return_self { ok {String} === 'str' }
     end
-    it "[!42f6a] raises assertion error when failed." do
+    test_subject "[!42f6a] raises assertion error when failed." do
       errmsg = "$<actual> === $<expected>: failed.\n"\
                "    $<actual>:   Integer\n"\
                "    $<expected>: \"str\""
       FAIL!(errmsg) { ok {Integer} === 'str' }
     end
-    it "[!vhvyu] is avaialbe with NOT." do
+    test_subject "[!vhvyu] is avaialbe with NOT." do
       PASS! { ok {Integer}.NOT === 'str' }
       errmsg = "!($<actual> === $<expected>): failed.\n"\
                "    $<actual>:   String\n"\
                "    $<expected>: \"str\""
       FAIL!(errmsg) { ok {String}.NOT === 'str' }
     end
-    it "[!mjh4d] raises error when combination of 'not_ok()' and matcher object." do
+    test_subject "[!mjh4d] raises error when combination of 'not_ok()' and matcher object." do
       errmsg = "negative `===` is not available with matcher object."
-      assert_exc(Oktest::OktestError, errmsg) do
+      exc = test_exception? Oktest::OktestError do
         not_ok {Oktest::JsonMatcher.new({})} === {}
       end
-      assert_exc(Oktest::OktestError, errmsg) do
+      test_eq? errmsg, exc.message
+      exc = test_exception? Oktest::OktestError do
         ok {Oktest::JsonMatcher.new({})}.NOT === {}
       end
+      test_eq? errmsg, exc.message
     end
   end
 
-  describe '>' do
-    it "[!3j7ty] returns self when passed." do
+  test_target 'Oktest::AssertionObject>' do
+    test_subject "[!3j7ty] returns self when passed." do
       should_return_self { ok {2} > 1 }
     end
-    it "[!vjjuq] raises assertion error when failed." do
+    test_subject "[!vjjuq] raises assertion error when failed." do
       #errmsg = "Expected 2 to be > 2."
       errmsg = "2 > 2: failed."
       FAIL!(errmsg) { ok {2} > 2 }
@@ -195,7 +198,7 @@ END
       errmsg = "\"aaa\" > \"bbb\": failed."
       FAIL!(errmsg) { ok {'aaa'} > 'bbb' }
     end
-    it "[!73a0t] is avaialbe with NOT." do
+    test_subject "[!73a0t] is avaialbe with NOT." do
       PASS! { ok {2}.NOT > 2 }
       #errmsg = "Expected 2 to be <= 1."
       errmsg = "2 <= 1: failed."
@@ -203,12 +206,12 @@ END
     end
   end
 
-  describe '>=' do
-    it "[!75iqw] returns self when passed." do
+  test_target 'Oktest::AssertionObject>=' do
+    test_subject "[!75iqw] returns self when passed." do
       should_return_self { ok {2} >= 2 }
       should_return_self { ok {2} >= 1 }
     end
-    it "[!isdfc] raises assertion error when failed." do
+    test_subject "[!isdfc] raises assertion error when failed." do
       #errmsg = "Expected 1 to be >= 2."
       errmsg = "1 >= 2: failed."
       FAIL!(errmsg) { ok {1} >= 2 }
@@ -216,7 +219,7 @@ END
       errmsg = "\"aaa\" >= \"bbb\": failed."
       FAIL!(errmsg) { ok {'aaa'} >= 'bbb' }
     end
-    it "[!3dgmh] is avaialbe with NOT." do
+    test_subject "[!3dgmh] is avaialbe with NOT." do
       PASS! { ok {1}.NOT >= 2 }
       #errmsg = "Expected 2 to be < 2."
       errmsg = "2 < 2: failed."
@@ -224,11 +227,11 @@ END
     end
   end
 
-  describe '<' do
-    it "[!vkwcc] returns self when passed." do
+  test_target 'Oktest::AssertionObject<' do
+    test_subject "[!vkwcc] returns self when passed." do
       should_return_self { ok {1} < 2 }
     end
-    it "[!ukqa0] raises assertion error when failed." do
+    test_subject "[!ukqa0] raises assertion error when failed." do
       #errmsg = "Expected 2 to be < 2."
       errmsg = "2 < 2: failed."
       FAIL!(errmsg) { ok {2} < 2 }
@@ -238,7 +241,7 @@ END
       errmsg = "\"bbb\" < \"aaa\": failed."
       FAIL!(errmsg) { ok {'bbb'} < 'aaa' }
     end
-    it "[!gwvdl] is avaialbe with NOT." do
+    test_subject "[!gwvdl] is avaialbe with NOT." do
       PASS! { ok {2}.NOT < 2 }
       #errmsg = "Expected 1 to be >= 2."
       errmsg = "1 >= 2: failed."
@@ -246,12 +249,12 @@ END
     end
   end
 
-  describe '<=' do
-    it "[!yk7t2] returns self when passed." do
+  test_target 'Oktest::AssertionObject<=' do
+    test_subject "[!yk7t2] returns self when passed." do
       should_return_self { ok {1} <= 2 }
       should_return_self { ok {1} <= 1 }
     end
-    it "[!ordwe] raises assertion error when failed." do
+    test_subject "[!ordwe] raises assertion error when failed." do
       #errmsg = "Expected 2 to be <= 1."
       errmsg = "2 <= 1: failed."
       FAIL!(errmsg) { ok {2} <= 1 }
@@ -259,7 +262,7 @@ END
       errmsg = "\"bbb\" <= \"aaa\": failed."
       FAIL!(errmsg) { ok {'bbb'} <= 'aaa' }
     end
-    it "[!mcb9w] is avaialbe with NOT." do
+    test_subject "[!mcb9w] is avaialbe with NOT." do
       PASS! { ok {2}.NOT <= 1 }
       #errmsg = "Expected 1 to be > 2."
       errmsg = "1 > 2: failed."
@@ -267,11 +270,11 @@ END
     end
   end
 
-  describe '=~' do
-    it "[!acypf] returns self when passed." do
+  test_target 'Oktest::AssertionObject=~' do
+    test_subject "[!acypf] returns self when passed." do
       should_return_self { ok {'SOS'} =~ /^[A-Z]+$/ }
     end
-    it "[!xkldu] raises assertion error when failed." do
+    test_subject "[!xkldu] raises assertion error when failed." do
       #errmsg = 'Expected /^\\d+$/ to match "SOS".'
       errmsg = "$<actual> =~ $<expected>: failed.\n"\
                "    $<expected>: /^\\d+$/\n"\
@@ -280,7 +283,7 @@ END
                "END\n"
       FAIL!(errmsg) { ok {"SOS\n"} =~ /^\d+$/ }
     end
-    it "[!2aa6f] is avaialbe with NOT." do
+    test_subject "[!2aa6f] is avaialbe with NOT." do
       PASS! { ok {'SOS'}.NOT =~ /^\d+$/ }
       #errmsg = "</\\w+/> expected to not match\n<\"SOS\">."
       errmsg = "$<actual> !~ $<expected>: failed.\n"\
@@ -290,18 +293,18 @@ END
     end if false
   end
 
-  describe '!~' do
-    it "[!xywdr] returns self when passed." do
+  test_target 'Oktest::AssertionObject!~' do
+    test_subject "[!xywdr] returns self when passed." do
       should_return_self { ok {'SOS'} !~ /^\d+$/ }
     end
-    it "[!58udu] raises assertion error when failed." do
+    test_subject "[!58udu] raises assertion error when failed." do
       #errmsg = "</^\\w+$/> expected to not match\n<\"SOS\">."
       errmsg = "$<actual> !~ $<expected>: failed.\n"\
                "    $<expected>: /^\\w+$/\n"\
                "    $<actual>:   \"SOS\"\n"
       FAIL!(errmsg) { ok {'SOS'} !~ /^\w+$/ }
     end
-    it "[!iuf5j] is avaialbe with NOT." do
+    test_subject "[!iuf5j] is avaialbe with NOT." do
       PASS! { ok {'SOS'}.NOT !~ /^\w+$/ }
       #errmsg = "Expected /\\d+/ to match \"SOS\"."
       errmsg = "$<actual> =~ $<expected>: failed.\n"\
@@ -311,18 +314,18 @@ END
     end
   end #if RUBY_VERSION >= "1.9"
 
-  describe '#in_delta?' do
-    it "[!m0791] returns self when passed." do
+  test_target 'Oktest::AssertionObject#in_delta?' do
+    test_subject "[!m0791] returns self when passed." do
       should_return_self { ok {3.14159}.in_delta?(3.141, 0.001) }
     end
-    it "[!f3zui] raises assertion error when failed." do
+    test_subject "[!f3zui] raises assertion error when failed." do
       errmsg = "($<actual> - $<expected>).abs < #{0.1}: failed.\n"\
                "    $<actual>:   1.375\n"\
                "    $<expected>: 1.5\n"\
                "    ($<actual> - $<expected>).abs: #{0.125}"
       FAIL!(errmsg) { ok {1.375}.in_delta?(1.5, 0.1) }
     end
-    it "[!t7liw] is avaialbe with NOT." do
+    test_subject "[!t7liw] is avaialbe with NOT." do
       PASS! { ok {1.375}.NOT.in_delta?(1.5, 0.1) }
       errmsg = "($<actual> - $<expected>).abs < #{0.2} == false: failed.\n"\
                "    $<actual>:   1.375\n"\
@@ -332,18 +335,18 @@ END
     end
   end
 
-  describe '#same?' do
-    it "[!yk7zo] returns self when passed." do
+  test_target 'Oktest::AssertionObject#same?' do
+    test_subject "[!yk7zo] returns self when passed." do
       should_return_self { ok {:SOS}.same?(:SOS) }
     end
-    it "[!ozbf4] raises assertion error when failed." do
+    test_subject "[!ozbf4] raises assertion error when failed." do
       errmsg = "$<actual>.equal?($<expected>): failed.\n"\
                "    $<actual>:   \"SOS\"\n"\
                "    $<expected>: \"SOS\"\n"
-      FAIL!(errmsg) { ok {'SOS'}.same?('SOS') }
+      FAIL!(errmsg) { ok {'SOS'.dup}.same?('SOS') }
     end
-    it "[!dwtig] is avaialbe with NOT." do
-      PASS! { ok {'SOS'}.NOT.same? 'SOS' }
+    test_subject "[!dwtig] is avaialbe with NOT." do
+      PASS! { ok {'SOS'.dup}.NOT.same? 'SOS' }
       errmsg = "$<actual>.equal?($<expected>) == false: failed.\n"\
                "    $<actual>:   :SOS\n"\
                "    $<expected>: :SOS\n"
@@ -351,21 +354,21 @@ END
     end
   end
 
-  describe '#method_missing()' do
-    it "[!7bbrv] returns self when passed." do
+  test_target 'Oktest::AssertionObject#method_missing()' do
+    test_subject "[!7bbrv] returns self when passed." do
       should_return_self { ok {"file.png"}.end_with?(".png") }
     end
-    it "[!yjnxb] enables to handle boolean methods." do
+    test_subject "[!yjnxb] enables to handle boolean methods." do
       PASS! { ok {""}.empty?  }
       PASS! { ok {nil}.nil?  }
       PASS! { ok {1}.is_a?(Integer)  }
     end
-    it "[!ttow6] raises NoMethodError when not a boolean method." do
+    test_subject "[!ttow6] raises NoMethodError when not a boolean method." do
       ERROR!(NoMethodError) do
         ok {"a"}.start_with
       end
     end
-    it "[!gd3vg] supports keyword arguments on Ruby >= 2.7." do
+    test_subject "[!gd3vg] supports keyword arguments on Ruby >= 2.7." do
       #if RUBY_VERSION >= "2.7"
       if true
         eval <<-END
@@ -386,14 +389,14 @@ END
         end
       end
     end
-    it "[!f0ekh] skip top of backtrace when NoMethodError raised." do
+    test_subject "[!f0ekh] skip top of backtrace when NoMethodError raised." do
       exc = ERROR!(NoMethodError) do
         ok {[1]}.start_with?(1)
       end
-      assert exc.backtrace[0] !~ /\/oktest\.rbc?:/, "backtrace not skipped"
-      assert exc.backtrace[0].start_with?(__FILE__), "backtrace not skipped"
+      test_ok? exc.backtrace[0] !~ /\/oktest\.rbc?:/, msg: "backtrace not skipped"
+      test_ok? exc.backtrace[0].start_with?(__FILE__), msg: "backtrace not skipped"
     end
-    it "[!cun59] fails when boolean method failed returned false." do
+    test_subject "[!cun59] fails when boolean method failed returned false." do
       errmsg = "$<actual>.empty?: failed.\n    $<actual>:   \"SOS\""
       FAIL!(errmsg) { ok {"SOS"}.empty? }
       errmsg = "$<actual>.nil?: failed.\n    $<actual>:   \"\""
@@ -401,7 +404,7 @@ END
       errmsg = "$<actual>.is_a?(Integer): failed.\n    $<actual>:   3.14"
       FAIL!(errmsg) { ok {3.14}.is_a?(Integer) }
     end
-    it "[!4objh] is available with NOT." do
+    test_subject "[!4objh] is available with NOT." do
       ok {"SOS"}.NOT.empty?
       ok {"SOS"}.NOT.nil?
       ok {"SOS"}.NOT.is_a?(Integer)
@@ -412,15 +415,15 @@ END
       errmsg = "$<actual>.is_a?(Integer) == false: failed.\n    $<actual>:   1"
       FAIL!(errmsg) { ok {1}.NOT.is_a?(Integer) }
     end
-    it "[!sljta] raises TypeError when boolean method returned non-boolean value." do
+    test_subject "[!sljta] raises TypeError when boolean method returned non-boolean value." do
       errmsg = "ok(): String#sos?() expected to return true or false, but got 1."
       ERROR!(TypeError, errmsg) do
-        s = "SOS"
+        s = "SOS".dup
         def s.sos?; return 1; end
         ok {s}.sos?
       end
     end
-    it "[!5y9iu] reports args and kwargs in error message." do
+    test_subject "[!5y9iu] reports args and kwargs in error message." do
       if RUBY_VERSION >= "2.7"
         str = '123, "abc", x: "45", y: true'
       else
@@ -429,7 +432,7 @@ END
       errmsg = "$<actual>.bla?(#{str}): failed.\n"\
                "    $<actual>:   \"Blabla\""
       FAIL!(errmsg) do
-        s = "Blabla"
+        s = "Blabla".dup
         def s.bla?(*a, **k); return false; end
         ok {s}.bla?(123, "abc", x: "45", y: true)
       end
@@ -439,12 +442,12 @@ END
       actual = obj.instance_eval {
         __inspect_args_and_kwargs([123, "abc"], c: "45", d: true)
       }
-      assert_eq actual, expected
+      test_eq? actual, expected
     end
   end
 
-  describe '#raise?' do
-    it "[!y1b28] returns exception object." do
+  test_target 'Oktest::AssertionObject#raise?' do
+    test_subject "[!y1b28] returns exception object." do
       pr = proc { "SOS".sos }
       if RUBY_VERSION >= "3.3"
         expected = "undefined method `sos' for an instance of String"
@@ -457,10 +460,10 @@ END
         expected = "undefined method `sos' for \"SOS\":String"
       end
       ret = ok {pr}.raise?(NoMethodError, expected)
-      assert_eq ret.class, NoMethodError
-      assert_eq ret.message, expected
+      test_eq? ret.class, NoMethodError
+      test_eq? ret.message, expected
     end
-    it "[!2rnni] 1st argument can be error message string or rexp." do
+    test_subject "[!2rnni] 1st argument can be error message string or rexp." do
       pr = proc { raise "something wrong" }
       PASS! { ok {pr}.raise?("something wrong") }
       PASS! { ok {pr}.raise?(/something wrong/) }
@@ -468,31 +471,31 @@ END
       pr = proc { raise StandardError, "something wrong" }
       ERROR!(StandardError, "something wrong") { ok {pr}.raise?("something wrong") }
     end
-    describe '[!dpv5g] when `ok{}` called...' do
-      it "[!yps62] assertion passes when expected exception raised." do
+    test_target 'Oktest::AssertionObject[!dpv5g] when `ok{}` called...' do
+      test_subject "[!yps62] assertion passes when expected exception raised." do
         pr = proc { "SOS".sub() }
         PASS! { ok {pr}.raise?(ArgumentError) }
         pr = proc { 1/0 }
         PASS! { ok {pr}.raise?(ZeroDivisionError) }
       end
-      it "[!wbwdo] raises assertion error when nothing raised." do
+      test_subject "[!wbwdo] raises assertion error when nothing raised." do
         pr = proc { nil }
         errmsg = "Expected ArgumentError to be raised but nothing raised."
         FAIL!(errmsg) { ok {pr}.raise?(ArgumentError) }
       end
-      it "[!lq6jv] compares error class with '==' operator, not '.is_a?'." do
+      test_subject "[!lq6jv] compares error class with '==' operator, not '.is_a?'." do
         pr = proc { "SOS".foobar }
         PASS! { ok {pr}.raise?(NoMethodError) }
-        assert NoMethodError < NameError, "NoMethodError extends NameError"
+        test_ok? NoMethodError < NameError, msg: "NoMethodError extends NameError"
         ERROR!(NoMethodError, /foobar/) { ok {pr}.raise?(NameError) }
       end
-      it "[!hwg0z] compares error class with '.is_a?' if '_subclass: true' specified." do
+      test_subject "[!hwg0z] compares error class with '.is_a?' if '_subclass: true' specified." do
         pr = proc { "SOS".foobar }
         PASS! { ok {pr}.raise?(NoMethodError, nil) }
-        assert NoMethodError < NameError, "NoMethodError extends NameError"
+        test_ok? NoMethodError < NameError, msg: "NoMethodError extends NameError"
         PASS! { ok {pr}.raise?(NameError, nil, _subclass: true) }
       end
-      it "[!4n3ed] reraises if exception is not matched to specified error class." do
+      test_subject "[!4n3ed] reraises if exception is not matched to specified error class." do
         pr = proc { "SOS".sos }
         if RUBY_VERSION >= "3.3"
           errmsg = "undefined method `sos' for an instance of String"
@@ -506,7 +509,7 @@ END
         end
         ERROR!(NoMethodError, errmsg) { ok {pr}.raise?(ArgumentError) }
       end
-      it "[!tpxlv] accepts string or regexp as error message." do
+      test_subject "[!tpxlv] accepts string or regexp as error message." do
         if RUBY_VERSION >= "3.1"
           expected = "undefined method `sos' for \"SOS\":String\n"\
                      "\n"\
@@ -525,7 +528,7 @@ END
         end
         PASS! { ok {pr}.raise?(NoMethodError, expected) }
       end
-      it "[!4c6x3] not check exception class when nil specified as errcls." do
+      test_subject "[!4c6x3] not check exception class when nil specified as errcls." do
         pr = proc { foobar() }
         PASS! { ok {pr}.raise?(nil, /undefined method `foobar'/) }
         pr = proc { 1/0 }
@@ -533,31 +536,31 @@ END
         pr = proc { 1/0 }
         PASS! { ok {pr}.raise?(nil) }
       end
-      it "[!dq97o] if block given, call it with exception object." do
+      test_subject "[!dq97o] if block given, call test_subject with exception object." do
         pr = proc { "SOS".foobar }
         exc1 = nil
         ok {pr}.raise?(NoMethodError) do |exc2|
           exc1 = exc2
         end
-        assert exc1 != nil
-        assert exc1.equal?(pr.exc)
+        test_ok? exc1 != nil
+        test_ok? exc1.equal?(pr.exc)
       end
     end
-    describe '[!qkr3h] when `ok{}.NOT` called...' do
-      it "[!cownv] not support error message." do
+    test_target 'Oktest::AssertionObject[!qkr3h] when `ok{}.NOT` called...' do
+      test_subject "[!cownv] not support error message." do
         pr = proc { raise "some error" }
         errmsg = "\"some error\": NOT.raise?() can't take errmsg."
         ERROR!(ArgumentError, errmsg) { ok {pr}.NOT.raise?(Exception, "some error") }
       end
-      it "[!spzy2] is available with NOT." do
+      test_subject "[!spzy2] is available with NOT." do
         pr = proc { "SOS".length }
         PASS! { ok {pr}.NOT.raise? }
       end
-      it "[!a1a40] assertion passes when nothing raised." do
+      test_subject "[!a1a40] assertion passes when nothing raised." do
         pr = proc { nil }
         PASS! { ok {pr}.NOT.raise? }
       end
-      it "[!61vtv] assertion fails when specified exception raised." do
+      test_subject "[!61vtv] assertion fails when specified exception raised." do
         pr = proc { "SOS".foobar }
         if RUBY_VERSION >= "3.3"
           errmsg = "NoMethodError should not be raised but got #<NoMethodError: undefined method `foobar' for an instance of String>."
@@ -571,36 +574,36 @@ END
         end
         FAIL!(errmsg) { ok {pr}.NOT.raise?(NoMethodError) }
       end
-      it "[!smprc] compares error class with '==' operator, not '.is_a?'." do
+      test_subject "[!smprc] compares error class with '==' operator, not '.is_a?'." do
         pr = proc { "SOS".foobar }
         FAIL!(/foobar/) { ok {pr}.NOT.raise?(NoMethodError) }
-        assert NoMethodError < NameError, "NoMethodError extends NameError"
+        test_ok? NoMethodError < NameError, msg: "NoMethodError extends NameError"
         ERROR!(NoMethodError) { ok {pr}.NOT.raise?(NameError) }
       end
-      it "[!34nd8] compares error class with '.is_a?' if '_subclass: true' specified." do
+      test_subject "[!34nd8] compares error class with '.is_a?' if '_subclass: true' specified." do
         pr = proc { "SOS".foobar }
         FAIL!(/foobar/) { ok {pr}.NOT.raise?(NoMethodError, nil) }
-        assert NoMethodError < NameError, "NoMethodError extends NameError"
+        test_ok? NoMethodError < NameError, msg: "NoMethodError extends NameError"
         FAIL!(/foobar/) { ok {pr}.NOT.raise?(NameError, nil, _subclass: true) }
       end
-      it "[!shxne] reraises exception if different from specified error class." do
+      test_subject "[!shxne] reraises exception if different from specified error class." do
         pr = proc { 1/0 }
         errmsg = "divided by 0"
         ERROR!(ZeroDivisionError, errmsg) { ok {pr}.NOT.raise?(NoMethodError) }
       end
-      it "[!36032] re-raises exception when errcls is nil." do
+      test_subject "[!36032] re-raises exception when errcls is nil." do
         pr = proc { foobar() }
         ERROR!(NoMethodError) { ok {pr}.NOT.raise?(nil) }
         pr = proc { 1/0 }
         ERROR!(ZeroDivisionError) { ok {pr}.NOT.raise?(nil) }
       end
     end
-    it "[!vnc6b] sets exception object into '#exc' attribute." do
+    test_subject "[!vnc6b] sets exception object into '#exc' attribute." do
       pr = proc { "SOS".foobar }
-      assert !pr.respond_to?(:exc)
+      test_ok? !pr.respond_to?(:exc)
       PASS! { ok {pr}.raise?(NoMethodError) }
-      assert pr.respond_to?(:exc)
-      assert pr.exc.is_a?(NoMethodError)
+      test_ok? pr.respond_to?(:exc)
+      test_ok? pr.exc.is_a?(NoMethodError)
       if RUBY_VERSION >= "3.3"
         errmsg = "undefined method `foobar' for an instance of String"
       elsif RUBY_VERSION =~ /^3\.1\./
@@ -611,18 +614,18 @@ END
       else
         errmsg = "undefined method `foobar' for \"SOS\":String"
       end
-      assert_eq pr.exc.message, errmsg
+      test_eq? pr.exc.message, errmsg
       #
       pr = proc { nil }
-      assert !pr.respond_to?(:exc)
+      test_ok? !pr.respond_to?(:exc)
       PASS! { ok {pr}.NOT.raise?(NoMethodError) }
-      assert pr.respond_to?(:exc)
-      assert_eq pr.exc, nil
+      test_ok? pr.respond_to?(:exc)
+      test_eq? pr.exc, nil
     end
   end
 
-  describe '#raise!' do
-    it "[!8k6ee] compares error class by '.is_a?' instead of '=='." do
+  test_target 'Oktest::AssertionObject#raise!' do
+    test_subject "[!8k6ee] compares error class by '.is_a?' instead of '=='." do
       pr = proc { "SOS".foobar }
       PASS! { ok {pr}.raise!(NoMethodError) }
       PASS! { ok {pr}.raise!(NameError) }
@@ -630,47 +633,59 @@ END
     end
   end
 
-  describe '#thrown?' do
-    it "[!w7935] raises ArgumentError when arg of 'thrown?()' is nil." do
+  test_target 'Oktest::AssertionObject#raise_nothing?' do
+    test_subject "[!leqey] do nothing without calling proc object." do
+      pr = proc { 1/0 }
+      ERROR!(ZeroDivisionError) { ok {pr}.raise_nothing? }
+    end
+    test_subject "[!a61b7] not available with `.NOT`." do
+      pr = proc { nil }
+      errmsg = "`raise_nothing?()` is not available with `.NOT`."
+      ERROR!(Oktest::OktestError, errmsg) { ok {pr}.NOT.raise_nothing? }
+    end
+  end
+
+  test_target 'Oktest::AssertionObject#thrown?' do
+    test_subject "[!w7935] raises ArgumentError when arg of 'thrown?()' is nil." do
       ERROR!(ArgumentError, "throw?(nil): expected tag required.") do
         pr = proc { throw :sym1 }
         ok {pr}.throw?(nil)
       end
     end
-    it "[!lglzr] assertion passes when expected symbol thrown." do
+    test_subject "[!lglzr] assertion passes when expected symbol thrown." do
       pr = proc { throw :sym2 }
       ok {pr}.throw?(:sym2)
-      assert true, "ok"
+      test_ok? true, msg: "ok"
     end
-    it "[!gf9nx] assertion fails when thrown tag is equal to but not same as expected." do
+    test_subject "[!gf9nx] assertion fails when thrown tag is equal to but not same as expected." do
       pr = proc { throw "sym" }
       expected = ("Thrown tag \"sym\" is equal to but not same as expected.\n"\
                   "    (`\"sym\".equal?(\"sym\")` should be true but not.)")
-      FAIL!(expected) { ok {pr}.throw?("sym") }
+      FAIL!(expected) { ok {pr}.throw?("sym".dup) }
     end
-    it "[!flgwy] assertion fails when thrown tag is different from expectd." do
+    test_subject "[!flgwy] assertion fails when thrown tag is different from expectd." do
       FAIL!(":sym4 should be thrown but actually :sym9 thrown.") do
         pr = proc { throw :sym9 }
         ok {pr}.throw?(:sym4)
       end
     end
-    it "[!9ik3x] assertion fails when nothing thrown." do
+    test_subject "[!9ik3x] assertion fails when nothing thrown." do
       pr = proc { nil }
       expected = ":sym5 should be thrown but nothing thrown."
       FAIL!(expected) { ok {pr}.throw?(:sym5) }
     end
-    it "[!m03vq] raises ArgumentError when non-nil arg passed to 'NOT.thrown?()'." do
+    test_subject "[!m03vq] raises ArgumentError when non-nil arg passed to 'NOT.thrown?()'." do
       ERROR!(ArgumentError, "NOT.throw?(:sym6): argument should be nil.") do
         pr = proc { nil }
         ok {pr}.NOT.throw?(:sym6)
       end
     end
-    it "[!kxizg] assertion fails when something thrown in 'NOT.throw?()'." do
+    test_subject "[!kxizg] assertion fails when something thrown in 'NOT.throw?()'." do
       pr = proc { throw :sym7 }
       expected = "Nothing should be thrown but :sym7 thrown."
       FAIL!(expected) { ok {pr}.NOT.throw?(nil) }
     end
-    it "[!zq9h6] returns self when passed." do
+    test_subject "[!zq9h6] returns self when passed." do
       pr = proc { throw :sym8 }
       should_return_self { ok {pr}.throw?(:sym8) }
       #
@@ -679,17 +694,17 @@ END
     end
   end
 
-  describe '#in?' do
-    it "[!jzoxg] returns self when passed." do
+  test_target 'Oktest::AssertionObject#in?' do
+    test_subject "[!jzoxg] returns self when passed." do
       should_return_self { ok {3}.in?(1..5) }
     end
-    it "[!9rm8g] raises assertion error when failed." do
+    test_subject "[!9rm8g] raises assertion error when failed." do
       errmsg = "$<expected>.include?($<actual>): failed.\n"\
                "    $<actual>:   3\n"\
                "    $<expected>: 1..2"
       FAIL!(errmsg) { ok {3}.in?(1..2) }
     end
-    it "[!singl] is available with NOT." do
+    test_subject "[!singl] is available with NOT." do
       PASS! { ok {3}.NOT.in?(1..2) }
       errmsg = "$<expected>.include?($<actual>) == false: failed.\n"\
                "    $<actual>:   3\n"\
@@ -698,17 +713,17 @@ END
     end
   end
 
-  describe '#attr()' do
-    it "[!lz3lb] returns self when passed." do
+  test_target 'Oktest::AssertionObject#attr()' do
+    test_subject "[!lz3lb] returns self when passed." do
       should_return_self { ok {"SOS"}.attr(:length, 3) }
     end
-    it "[!79tgn] raises assertion error when failed." do
+    test_subject "[!79tgn] raises assertion error when failed." do
       errmsg = "$<actual>.size == $<expected>: failed.\n"\
                "    $<actual>.size: 3\n"\
                "    $<expected>: 2"
       FAIL!(errmsg) { ok {"SOS"}.attr(:size, 2) }
     end
-    it "[!cqnu3] is available with NOT." do
+    test_subject "[!cqnu3] is available with NOT." do
       PASS! { ok {"SOS"}.NOT.attr(:length, 2) }
       errmsg = "$<actual>.size != $<expected>: failed.\n"\
                "    $<actual>.size: 3\n"\
@@ -717,17 +732,17 @@ END
     end
   end
 
-  describe '#attrs()' do
-    it "[!rtq9f] returns self when passed." do
+  test_target 'Oktest::AssertionObject#attrs()' do
+    test_subject "[!rtq9f] returns self when passed." do
       should_return_self { ok {"SOS"}.attrs(:length=>3, :size=>3) }
     end
-    it "[!7ta0s] raises assertion error when failed." do
+    test_subject "[!7ta0s] raises assertion error when failed." do
       errmsg = "$<actual>.size == $<expected>: failed.\n"\
                "    $<actual>.size: 3\n"\
                "    $<expected>: 2"
       FAIL!(errmsg) { ok {"SOS"}.attrs(:size=>2) }
     end
-    it "[!s0pnk] is available with NOT." do
+    test_subject "[!s0pnk] is available with NOT." do
       PASS! { ok {"SOS"}.NOT.attrs(:length=>2) }
       errmsg = "$<actual>.size != $<expected>: failed.\n"\
                "    $<actual>.size: 3\n"\
@@ -736,19 +751,19 @@ END
     end
   end
 
-  describe '#keyval()' do
-    it "[!byebv] returns self when passed." do
+  test_target 'Oktest::AssertionObject#keyval()' do
+    test_subject "[!byebv] returns self when passed." do
       d = {'a'=>1}
       should_return_self { ok {d}.keyval('a', 1) }
     end
-    it "[!vtrlz] raises assertion error when failed." do
+    test_subject "[!vtrlz] raises assertion error when failed." do
       d = {'a'=>1}
       errmsg = "$<actual>[\"a\"] == $<expected>: failed.\n"\
                "    $<actual>[\"a\"]: 1\n"\
                "    $<expected>: \"1\""
       FAIL!(errmsg) { ok {d}.keyval('a', '1') }
     end
-    it "[!mmpwz] is available with NOT." do
+    test_subject "[!mmpwz] is available with NOT." do
       d = {'a'=>1}
       PASS! { ok {d}.NOT.keyval('a', '1') }
       errmsg = "$<actual>[\"a\"] != $<expected>: failed.\n"\
@@ -758,19 +773,19 @@ END
     end
   end
 
-  describe '#keyvals()' do
-    it "[!vtw22] returns self when passed." do
+  test_target 'Oktest::AssertionObject#keyvals()' do
+    test_subject "[!vtw22] returns self when passed." do
       d = {'a'=>1, 'b'=>2}
       should_return_self { ok {d}.keyvals('a'=>1, 'b'=>2) }
     end
-    it "[!fyvmn] raises assertion error when failed." do
+    test_subject "[!fyvmn] raises assertion error when failed." do
       d = {'a'=>1, 'b'=>2}
       errmsg = "$<actual>[\"a\"] == $<expected>: failed.\n"\
                "    $<actual>[\"a\"]: 1\n"\
                "    $<expected>: \"1\""
       FAIL!(errmsg) { ok {d}.keyvals('a'=>'1', 'b'=>2) }
     end
-    it "[!js2j2] is available with NOT." do
+    test_subject "[!js2j2] is available with NOT." do
       d = {'a'=>1, 'b'=>2}
       PASS! { ok {d}.NOT.keyvals('a'=>'1') }
       errmsg = "$<actual>[\"a\"] != $<expected>: failed.\n"\
@@ -780,17 +795,17 @@ END
     end
   end
 
-  describe '#length' do
-    it "[!l9vnv] returns self when passed." do
+  test_target 'Oktest::AssertionObject#length' do
+    test_subject "[!l9vnv] returns self when passed." do
       should_return_self { ok {"SOS"}.length(3) }
     end
-    it "[!1y787] raises assertion error when failed." do
+    test_subject "[!1y787] raises assertion error when failed." do
       errmsg = "$<actual>.length == 5: failed.\n"\
                "    $<actual>.length: 3\n"\
                "    $<actual>:   \"SOS\""
       FAIL!(errmsg) { ok {"SOS"}.length(5) }
     end
-    it "[!kryx2] is available with NOT." do
+    test_subject "[!kryx2] is available with NOT." do
       PASS! { ok {"SOS"}.NOT.length(5) }
       errmsg = "$<actual>.length != 3: failed.\n"\
                "    $<actual>.length: 3\n"\
@@ -799,16 +814,16 @@ END
     end
   end
 
-  describe '#truthy?' do
-    it "[!nhmuk] returns self when passed." do
+  test_target 'Oktest::AssertionObject#truthy?' do
+    test_subject "[!nhmuk] returns self when passed." do
       should_return_self { ok {""}.truthy? }
     end
-    it "[!3d94h] raises assertion error when failed." do
+    test_subject "[!3d94h] raises assertion error when failed." do
       errmsg = "!!$<actual> == true: failed.\n"\
                "    $<actual>:   nil"
       FAIL!(errmsg) { ok {nil}.truthy? }
     end
-    it "[!8rmgp] is available with NOT." do
+    test_subject "[!8rmgp] is available with NOT." do
       PASS! { ok {nil}.NOT.truthy? }
       errmsg = "!!$<actual> != true: failed.\n"\
                "    $<actual>:   0"
@@ -816,16 +831,16 @@ END
     end
   end
 
-  describe '#falsy?' do
-    it "[!w1vm6] returns self when passed." do
+  test_target 'Oktest::AssertionObject#falsy?' do
+    test_subject "[!w1vm6] returns self when passed." do
       should_return_self { ok {nil}.falsy? }
     end
-    it "[!7o48g] raises assertion error when failed." do
+    test_subject "[!7o48g] raises assertion error when failed." do
       errmsg = "!!$<actual> == false: failed.\n"\
                "    $<actual>:   0"
       FAIL!(errmsg) { ok {0}.falsy? }
     end
-    it "[!i44q6] is available with NOT." do
+    test_subject "[!i44q6] is available with NOT." do
       PASS! { ok {0}.NOT.falsy? }
       errmsg = "!!$<actual> != false: failed.\n"\
                "    $<actual>:   nil"
@@ -833,16 +848,16 @@ END
     end
   end
 
-  describe '#file_exist?' do
-    it "[!6bcpp] returns self when passed." do
+  test_target 'Oktest::AssertionObject#file_exist?' do
+    test_subject "[!6bcpp] returns self when passed." do
       should_return_self { ok {__FILE__}.file_exist? }
     end
-    it "[!69bs0] raises assertion error when failed." do
+    test_subject "[!69bs0] raises assertion error when failed." do
       errmsg = "File.file?($<actual>): failed.\n"\
                "    $<actual>:   \".\""
       FAIL!(errmsg) { ok {'.'}.file_exist? }
     end
-    it "[!r1mze] is available with NOT." do
+    test_subject "[!r1mze] is available with NOT." do
       PASS! { ok {'.'}.NOT.file_exist? }
       errmsg = "File.file?($<actual>) == false: failed.\n"\
                "    $<actual>:   \"#{__FILE__}\""
@@ -850,16 +865,16 @@ END
     end
   end
 
-  describe '#dir_exist?' do
-    it "[!8qe7u] returns self when passed." do
+  test_target 'Oktest::AssertionObject#dir_exist?' do
+    test_subject "[!8qe7u] returns self when passed." do
       should_return_self { ok {'.'}.dir_exist? }
     end
-    it "[!vfh7a] raises assertion error when failed." do
+    test_subject "[!vfh7a] raises assertion error when failed." do
       errmsg = "File.directory?($<actual>): failed.\n"\
                "    $<actual>:   \"#{__FILE__}\""
       FAIL!(errmsg) { ok {__FILE__}.dir_exist? }
     end
-    it "[!qtllp] is available with NOT." do
+    test_subject "[!qtllp] is available with NOT." do
       PASS! { ok {__FILE__}.NOT.dir_exist? }
       errmsg = "File.directory?($<actual>) == false: failed.\n"\
                "    $<actual>:   \".\""
@@ -867,20 +882,20 @@ END
     end
   end
 
-  describe '#symlink_exist?' do
-    def with_symlink
+  test_target 'Oktest::AssertionObject#symlink_exist?' do
+    def self.with_symlink(&b)
       linkname = "_sym_#{rand().to_s[2...7]}"
       File.symlink(__FILE__, linkname)
-      yield linkname
+      b.call linkname
     ensure
       File.unlink(linkname)
     end
-    it "[!ugfi3] returns self when passed." do
+    test_subject "[!ugfi3] returns self when passed." do
       with_symlink do |linkname|
         should_return_self { ok {linkname}.symlink_exist? }
       end
     end
-    it "[!qwngl] raises assertion error when failed." do
+    test_subject "[!qwngl] raises assertion error when failed." do
       with_symlink do |linkname|
         errmsg = "File.symlink?($<actual>): failed.\n"\
                  "    $<actual>:   \"_not_exist\""
@@ -890,7 +905,7 @@ END
         FAIL!(errmsg) { ok {'.'}.symlink_exist? }
       end
     end
-    it "[!cgpbt] is available with NOT." do
+    test_subject "[!cgpbt] is available with NOT." do
       with_symlink do |linkname|
         PASS! { ok {'_not_exist'}.NOT.symlink_exist? }
         PASS! { ok {'.'}.NOT.symlink_exist? }
@@ -901,16 +916,16 @@ END
     end
   end
 
-  describe '#not_exist?' do
-    it "[!1ujag] returns self when passed." do
+  test_target 'Oktest::AssertionObject#not_exist?' do
+    test_subject "[!1ujag] returns self when passed." do
       should_return_self { ok {'_not_exist'}.not_exist? }
     end
-    it "[!ja84s] raises assertion error when failed." do
+    test_subject "[!ja84s] raises assertion error when failed." do
       errmsg = "File.exist?($<actual>) == false: failed.\n"\
                "    $<actual>:   \".\""
       FAIL!(errmsg) { ok {'.'}.not_exist? }
     end
-    it "[!to5z3] is available with NOT." do
+    test_subject "[!to5z3] is available with NOT." do
       PASS! { ok {'.'}.NOT.not_exist? }
       errmsg = "File.exist?($<actual>): failed.\n"\
                "    $<actual>:   \"_not_exist\""
@@ -918,59 +933,59 @@ END
     end
   end
 
-  describe '#JSON()' do
-    it "[!n0k03] creates JsonMatcher object." do
+  test_target 'Oktest::AssertionObject#JSON()' do
+    test_subject "[!n0k03] creates JsonMatcher object." do
       o = JSON({})
-      assert_eq o.class, Oktest::JsonMatcher
+      test_eq? o.class, Oktest::JsonMatcher
     end
   end
 
-  describe '#Enum()' do
-    it "[!fbfr0] creates Enum object which is a subclass of Set." do
+  test_target 'Oktest::AssertionObject#Enum()' do
+    test_subject "[!fbfr0] creates Enum object which is a subclass of Set." do
       o = Enum("a", "b", "c")
-      assert_eq o.class, Oktest::JsonMatcher::Enum
-      assert    o.class < Set
-      assert_eq (o === "a"), true
-      assert_eq (o === "b"), true
-      assert_eq (o === "c"), true
-      assert_eq (o === "d"), false
+      test_eq? o.class, Oktest::JsonMatcher::Enum
+      test_ok?  o.class < Set
+      test_eq? (o === "a"), true
+      test_eq? (o === "b"), true
+      test_eq? (o === "c"), true
+      test_eq? (o === "d"), false
     end
   end
 
-  describe '#Bool()' do
-    it "[!vub5j] creates a set of true and false." do
-      assert_eq Bool().class, Oktest::JsonMatcher::Enum
-      assert Bool() === true
-      assert Bool() === false
-      assert_eq (Bool() === 1), false
-      assert_eq (Bool() === 0), false
+  test_target 'Oktest::AssertionObject#Bool()' do
+    test_subject "[!vub5j] creates a set of true and false." do
+      test_eq? Bool().class, Oktest::JsonMatcher::Enum
+      test_ok? Bool() === true
+      test_ok? Bool() === false
+      test_eq? (Bool() === 1), false
+      test_eq? (Bool() === 0), false
     end
   end
 
-  describe '#OR()' do
-    it "[!9e8im] creates `OR` object." do
+  test_target 'Oktest::AssertionObject#OR()' do
+    test_subject "[!9e8im] creates `OR` object." do
       o = OR(1, 2, 3)
-      assert_eq o.class, Oktest::JsonMatcher::OR
+      test_eq? o.class, Oktest::JsonMatcher::OR
     end
   end
 
-  describe '#AND()' do
-    it "[!38jln] creates `AND` object." do
+  test_target 'Oktest::AssertionObject#AND()' do
+    test_subject "[!38jln] creates `AND` object." do
       o = AND(4, 5, 6)
-      assert_eq o.class, Oktest::JsonMatcher::AND
+      test_eq? o.class, Oktest::JsonMatcher::AND
     end
   end
 
-  describe '#Length()' do
-    it "[!qqas3] creates Length object." do
+  test_target 'Oktest::AssertionObject#Length()' do
+    test_subject "[!qqas3] creates Length object." do
       o = Length(3)
-      assert_eq o.class, Oktest::JsonMatcher::Length
+      test_eq? o.class, Oktest::JsonMatcher::Length
     end
   end
 
-  describe '#Any()' do
-    it "[!dlo1o] creates an 'Any' object." do
-      assert_eq Any().class, Oktest::JsonMatcher::Any
+  test_target 'Oktest::AssertionObject#Any()' do
+    test_subject "[!dlo1o] creates an 'Any' object." do
+      test_eq? Any().class, Oktest::JsonMatcher::Any
     end
   end