minitest-ok 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0954d6aa6e1f266702561e5d1bc754e240939d62
+  data.tar.gz: 6356034dae10336b4b53a39b70e9fb2d35a42029
+SHA512:
+  metadata.gz: c5b547b6b93ec8261f4eb38a4e00aed087bcc721f594312b685eef0a7780a7eb0fda544c891ed6a2c297d7f58890aed7ecd7284dd4c3acf9948c2eb0888e9e28
+  data.tar.gz: 95dcfac0362e4040c9512c24878b36a83038d2201080297950c05982715163605655b2b3b526abb05a57a9451bd836f1d48fa3f22975c75f387b977174df4b24

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+$Copyright: copyright(c) 2015 kuwata-lab.com all rights reserved $
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,143 @@
+# Minitest::Ok
+
+Minitest::Ok is a pretty good helper library for Minitest.
+For example:
+
+```ruby
+ok {1+1} == 2               # same as assert_equal 2, 1+1
+ok {1+1} >  1               # same as assert_operator 1+1, :>, 1
+ok {'123'} =~ /\d+/         # same as assert_match /\d+/, '123'
+ok {[]}.kind_of?(Array)     # same as assert_kind_of Array, []
+ok {1..9}.include?(1)       # same as assert_includes 1, 1..9
+ok {1}.in?(1..9)            # same as assert_includes 1, 1..9
+ok {0}.NOT.in?(1..9)        # same as refute_includes 0, 1..9
+ok {""}.truthy?             # same as assert true, !!""
+ok {128}.even?              # same as assert_predicate 128, :even?
+ok {obj}.attrs(x: 1, y: 2)  # same as assert obj.x == 1; assert obj.y == 2
+ok {obj}.items(x: 1, y: 2)  # same as assert obj[:x] == 1; assert obj[:y] == 2
+```
+
+
+## Example
+
+```ruby
+# -*- coding: utf-8 -*-
+
+require 'minitest/spec'
+require 'minitest/autorun'
+
+require 'minitest/ok'
+
+
+describe 'Minitest::Ok' do
+
+  it "helps to write assertions" do
+
+    ## operators
+    ok {1+1} == 2            # same as assert_equal 2, 1+1
+    ok {1+1} != 1            # same as refute_equal 2, 1+1
+    ok {1+1} >  1            # same as assert_operator 1+1, :>,  1
+    ok {1+1} >= 2            # same as assert_operator 1+1, :>=, 2
+    ok {1+1} <  3            # same as assert_operator 1+1, :<,  3
+    ok {1+1} <= 2            # same as assert_operator 1+1, :<=, 2
+    ok {Array} === [1, 2]    # same as assert_operator Array, :===, [1, 2]
+    ok {/\d+/} === '123'     # same as assert_operator /\d+/, :===, '123'
+
+    ## pattern matching
+    ok {'123'} =~ /\d+/      # same as assert_match /\d+/, '123'
+    ok {'abc'} !~ /\d+/      # same as refute_match /\d+/, 'abc'
+
+    ## type
+    arr = [1, 2, 3]
+    ok {arr}.kind_of?(Array)       # same as assert_kind_of Array, [1,2,3]
+    ok {arr}.is_a?(Array)          # 'is_a?' is an alias of 'kind_of?'
+    ok {arr}.NOT.kind_of?(Hash)    # same as refute_kind_of Hash, [1,2,3]
+
+    ok {1}.instance_of?(Fixnum)      # same as assert_instance_of Fixnum, 1
+    ok {1}.NOT.instance_of?(Integer) # same as refute_instance_of Integer, 1
+
+    ## identity
+    arr = []
+    ok {arr}.same?(arr)            # same as assert_same arr, arr
+    ok {arr}.NOT.same?([])         # same as refute_same arr, []
+
+    ## numeric difference
+    ok {3.14159}.in_delta?(3.14, 0.01)       # same as assert_in_delta 3.14, 3.14159, 0.001
+    ok {3.14159}.NOT.in_delta?(3.14, 0.001)  # same as refute_in_delta 3.14, 3.14159, 0.0001
+
+    ok {3.14159}.in_epsilon?(3.14, 0.001)       # same as assert_in_epsilon 3.14, 3.14159, 0.001
+    ok {3.14159}.NOT.in_epsilon?(3.14, 0.0001)  # same as refute_in_epsilon 3.14, 3.14159, 0.0001
+
+    ## exception
+    ex = ok {proc { 1/0 }}.raise?(ZeroDivisionError)  # same as assert_raise(...)
+    ex = ok {proc { 1/0 }}.raise?(ZeroDivisionError, "divided by zero")
+    ex = ok {proc { 1/0 }}.raise?(ZeroDivisionError, /^divided by zero$/)
+    p ex     #=> #<ZeroDivisionError: divided by 0>
+    ok {proc { 1/1 }}.NOT.raise?(Exception)
+
+    ok {proc {throw :exit}}.throw?(:exit)  # same as assert_throws(:exit) {...}
+
+    ## stdout and stderr
+    ok {proc {puts 'X'}}.output?("X\n")  # same as assert_output {...}
+    ok {proc {nil}}.silent?              # same as assert_silent {...}
+
+    ## boolean
+    ok {123}.truthy?               # similar to assert 123
+    ok {0}.truthy?                 # similar to assert 0
+    ok {""}.truthy?                # similar to assert ""
+    ok {false}.falthy?             # similar to refute false
+    ok {nil}.falthy?               # similar to refute nil
+
+    ## predicates
+    ok {""}.empty?                 # same as assert_empty? ""
+    ok {[]}.empty?                 # same as assert_empty? []
+    ok {[1,2,3]}.NOT.empty?        # same as refute_empty? [1,2,3]
+    ok {1..9}.respond_to?(:each)   # same as assert_respond_to "foo", :each
+    ok {1..9}.include?(1)          # same as assert_includes 1..9, 1
+    ok {1..9}.NOT.include?(0)      # same as refute_includes 1..9, 0
+    ok {1}.in?(1..9)               # same as assert_includes 1..9, 1
+    ok {0}.NOT.in?(1..9)           # same as refute_includes 1..9, 0
+
+    ok {'foo'.freeze}.frozen?      # same as assert 'foo'.freeze.frozen?
+    ok {'foo'.taint}.tainted?      # same as assert 'foo'.taint.tainted?
+    obj = Object.new
+    obj.instance_variable_set('@x', 10)
+    ok {obj}.instance_variable_defined?('@x')
+
+    ok {'logo.png'}.end_with?('.png')   # same as assert 'logon.png'.start_with?('.png')
+    ok {[1,2,3]}.any? {|x| x % 2 == 0}  # same as assert [1,2,3].any? {...}
+    ok {[1,2,3]}.NOT.all? {|x| x < 0 }  # same as refute [1,2,3].all? {...}
+
+    ## attribute
+    time = Time.new(2015, 2, 14)
+    ok {time}.attr(:year, 2015).attr(:month, 2).attr(:day, 14)
+    ok {time}.attrs(year: 2015, month: 2, day: 14)
+
+    ## key and value
+    dict = {:name=>"Haruhi", :age=>16}
+    ok {dict}.item(:name, "Haruhi").item(:age, 16)
+    ok {dict}.items(name: "Haruhi", age: 16)
+
+    ## file and directory
+    ok {__FILE__}.file_exist?      # whether file exists or not
+    ok {Dir.pwd }.dir_exist?       # whether directory exists or not
+    ok {'/XXXX' }.not_exist?       # whether nothing exits or not
+
+  end
+
+end
+```
+
+
+## Copyright and License
+
+$Copyright: copyright(c) 2015 kuwata-lab.com all rights reserved $
+
+$License: MIT License $
+
+
+## History
+
+### 2015-11-22: Release 0.1.0
+
+* First release

data/Rakefile

@@ -0,0 +1,57 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test
+
+
+desc "show how to release"
+task :help do
+  puts <<END
+How to release:
+
+    $ git checkout dev
+    $ git diff
+    $ which ruby
+    $ rake test                 # for confirmation
+    $ git checkout -b rel-1.0   # or git checkout rel-1.0
+    $ rake edit rel=1.0.0
+    $ git diff
+    $ git commit -a -m "release preparation for 1.0.0"
+    $ rake build                # for confirmation
+    $ rake install              # for confirmation
+    $ #rake release
+    $ gem push pkg/minitest-ok-1.0.0.gem
+    $ git tag v1.0.0
+    $ git push -u origin rel-1.0
+    $ git push --tags
+END
+
+end
+
+
+desc "edit files (for release preparation)"
+task :edit do
+  rel = ENV['rel']  or
+    raise "ERROR: 'rel' environment variable expected."
+  filenames = Dir[*%w[lib/**/*.rb test/**/*_test.rb test/test_helper.rb *.gemspec]]
+  filenames.each do |fname|
+    File.open(fname, 'r+', encoding: 'utf-8') do |f|
+      content = f.read()
+      x = content.gsub!(/\$Release:.*?\$/, "$Release: #{rel} $")
+      if x.nil?
+        puts "[_] #{fname}"
+      else
+        puts "[C] #{fname}"
+        f.rewind()
+        f.truncate(0)
+        f.write(content)
+      end
+    end
+  end
+end

data/lib/minitest/ok.rb

@@ -0,0 +1,676 @@
+# -*- coding: utf-8 -*-
+
+###
+### $Release: 0.1.0 $
+### $Copyright: copyright(c) 2015 kuwata-lab.com all rights reserved $
+### $License: MIT License $
+###
+
+require 'minitest/unit'
+
+
+## for Ruby 1.9
+if ! defined?(Minitest) && defined?(MiniTest)
+  Minitest = MiniTest
+end
+
+
+module Minitest
+
+
+  module Assertions
+
+    ##
+    ## Helper method to call assertion methods.
+    ## See AssertionObject class for details.
+    ##
+    ##   ok {1+1} == 2               # same as assert_equal 2, 1+1
+    ##   ok {1+1} != 1               # same as refute_equal 1, 1+1
+    ##   ok {1+1} >  1               # same as assert_operator 1+1, :>, 1
+    ##   ok {1+1} <= 2               # same as assert_operator 1+1, :<=, 2
+    ##   ok {'123'} =~ /\d+/         # same as assert_match /\d+/, '123'
+    ##   ok {[]}.kind_of?(Array)     # same as assert_kind_of Array, []
+    ##   ok {[]}.NOT.kind_of?(Hash)  # same as refute_kind_of Hash, []
+    ##   ok {1..9}.include?(5)       # same as assert_includes 5, 1..9
+    ##   ok {1..9}.NOT.include?(0)   # same as refute_includes 0, 1..9
+    ##   ok {""}.truthy?             # same as assert true, !!""
+    ##   ok {nil}.falthy?            # same as assert false, !!""
+    ##
+    ##   ex = ok { proc { 1 / 0 } }.raise?(ZeroDivisionError, "divided by 0")
+    ##   p ex      #=> #<ZeroDivisionError: divided by 0>
+    ##
+    def ok
+      actual = yield
+      Ok::AssertionObject.new(actual, self, caller(1, 1).first)
+    end
+
+    ## for Ruby 1.9
+    begin
+      caller(1, 1)
+    rescue ArgumentError
+      def ok
+        actual = yield
+        Ok::AssertionObject.new(actual, self, caller(1).first)
+      end
+    end
+
+  end
+
+
+  module Ok
+
+    VERSION = '$Release: 0.1.0 $'.split()[1]
+
+
+    class AssertionObject
+
+      ## Don't create this object directly. Use <tt>ok {value}</tt> instead.
+      def initialize(actual, context, location)
+        @actual  = actual
+        @context = context
+        @not     = false
+        @tested  = tested = [false]
+        ObjectSpace.define_finalizer(self, proc {
+          unless tested[0]
+            loc = location.to_s.split(/:in /).first
+            $stderr.puts "** WARNING: ok() called but no assertion invoked (#{loc})"
+          end
+        })
+      end
+
+      def _mark_as_tested   # :nodoc:
+        @tested[0] = true
+        self
+      end
+
+      ##
+      ## Make logical condition reversed.
+      ##
+      ##   ok {[1,2,3]}.empty?       # Fail
+      ##   ok {[1,2,3]}.NOT.empty?   # Pass
+      ##
+      def NOT()
+        @not = ! @not
+        self
+      end
+
+      ##
+      ## Same as <tt>assert_equal()</tt>.
+      ##
+      ##   ok {1+1} == 2             # Pass
+      ##   ok {1+1} == 1             # Fail
+      ##
+      def ==(expected)
+        _mark_as_tested()
+        @context.assert_equal expected, @actual  unless @not
+        @context.refute_equal expected, @actual  if     @not
+        self
+      end
+
+      ##
+      ## Same as <tt>refute_equal()</tt>.
+      ##
+      ##   ok {1+1} != 1             # Pass
+      ##   ok {1+1} != 2             # Fail
+      ##
+      def !=(expected)
+        _mark_as_tested()
+        @context.refute_equal expected, @actual  unless @not
+        @context.assert_equal expected, @actual  if     @not
+        self
+      end
+
+      ##
+      ## Tests <tt>actual > expected</tt>.
+      ##
+      ##   ok {1+1} > 1             # Pass
+      ##   ok {1+1} > 2             # Fail
+      ##   ok {1+1} > 3             # Fail
+      ##
+      def >(expected)
+        _mark_as_tested()
+        @context.assert_operator @actual, :'>', expected  unless @not
+        @context.refute_operator @actual, :'>', expected  if     @not
+        self
+      end
+
+      ##
+      ## Tests <tt>actual >= expected</tt>.
+      ##
+      ##   ok {1+1} >= 1             # Pass
+      ##   ok {1+1} >= 2             # Pass
+      ##   ok {1+1} >= 3             # Fail
+      ##
+      def >=(expected)
+        _mark_as_tested()
+        @context.assert_operator @actual, :'>=', expected  unless @not
+        @context.refute_operator @actual, :'>=', expected  if     @not
+        self
+      end
+
+      ##
+      ## Tests <tt>actual < expected</tt>.
+      ##
+      ##   ok {1+1} < 3             # Pass
+      ##   ok {1+1} < 2             # Fail
+      ##   ok {1+1} < 1             # Fail
+      ##
+      def <(expected)
+        _mark_as_tested()
+        @context.assert_operator @actual, :'<', expected  unless @not
+        @context.refute_operator @actual, :'<', expected  if     @not
+        self
+      end
+
+      ##
+      ## Tests <tt>actual <= expected</tt>.
+      ##
+      ##   ok {1+1} <= 3             # Pass
+      ##   ok {1+1} <= 2             # Pass
+      ##   ok {1+1} <= 1             # Fail
+      ##
+      def <=(expected)
+        _mark_as_tested()
+        @context.assert_operator @actual, :'<=', expected  unless @not
+        @context.refute_operator @actual, :'<=', expected  if     @not
+        self
+      end
+
+      ##
+      ## Tests <tt>actual === expected</tt>.
+      ##
+      ##   ok {String} === 'foo'     # Pass
+      ##   ok {/\d+/}  === '123'     # Pass
+      ##
+      def ===(expected)
+        _mark_as_tested()
+        @context.assert_operator @actual, :'===', expected  unless @not
+        @context.refute_operator @actual, :'===', expected  if     @not
+        self
+      end
+
+      ##
+      ## Same as <tt>assert_match()</tt>.
+      ##
+      ##   ok {"abc"} =~ /\w+/        # Pass
+      ##   ok {"abc"} =~ /\d+/        # Fail
+      ##
+      def =~(expected)
+        _mark_as_tested()
+        @context.assert_match expected, @actual  unless @not
+        @context.refute_match expected, @actual  if     @not
+        self
+      end
+
+      ##
+      ## Same as <tt>refute_match()</tt>.
+      ##
+      ##   ok {"abc"} !~ /\d+/        # Pass
+      ##   ok {"abc"} !~ /\w+/        # Fail
+      ##
+      def !~(expected)
+        _mark_as_tested()
+        @context.refute_match expected, @actual  unless @not
+        @context.assert_match expected, @actual  if     @not
+        self
+      end
+
+      ##
+      ## Same as <tt>assert_kind_of()</tt>.
+      ##
+      ##   ok {123}.kind_of?(Fixnum)     # Pass
+      ##   ok {123}.kind_af?(Integer)    # Pass
+      ##   ok {123}.kind_of?(Float)      # Fail
+      ##
+      def kind_of?(expected)
+        _mark_as_tested()
+        @context.assert_kind_of expected, @actual  unless @not
+        @context.refute_kind_of expected, @actual  if     @not
+        self
+      end
+
+      ##
+      ## Same as <tt>assert_kind_of()</tt>.
+      ##
+      ##   ok {123}.is_a?(Fixnum)     # Pass
+      ##   ok {123}.is_a?(Integer)    # Pass
+      ##   ok {123}.is_a?(Float)      # Fail
+      ##
+      alias is_a? kind_of?
+
+      ##
+      ## Same as <tt>assert_instance_of()</tt>.
+      ##
+      ##   ok {123}.instance_of?(Fixnum)     # Pass
+      ##   ok {123}.instance_of?(Integer)    # Fail
+      ##
+      def instance_of?(expected)
+        _mark_as_tested()
+        @context.assert_instance_of expected, @actual  unless @not
+        @context.refute_instance_of expected, @actual  if     @not
+        self
+      end
+
+      ##
+      ## Same as <tt>assert_same()</tt>.
+      ##
+      ##   arr = [1]
+      ##   ok {arr}.same?(arr)               # Pass
+      ##   ok {arr}.same?([1])               # Fail
+      ##   ok {arr}.NOT.same?([1])           # Pass
+      ##
+      def same?(expected)
+        _mark_as_tested()
+        @context.assert_same expected, @actual  unless @not
+        @context.refute_same expected, @actual  if     @not
+        self
+      end
+
+      ##
+      ## Same as <tt>assert_empty()</tt>.
+      ##
+      ##   ok {""}.empty?                    # Pass
+      ##   ok {[]}.empty?                    # Pass
+      ##   ok {"X"}.empty?                   # Fail
+      ##   ok {"X"}.NOT.empty?               # Pass
+      ##
+      def empty?
+        _mark_as_tested()
+        @context.assert_empty @actual  unless @not
+        @context.refute_empty @actual  if     @not
+        self
+      end
+
+      ##
+      ## Same as <tt>assert_in_delta()</tt>.
+      ##
+      ##   ok {3.14159}.in_delta?(3.14, 0.01)       # Pass
+      ##   ok {3.14159}.in_delta?(3.14, 0.001)      # Fail
+      ##
+      def in_delta?(expected, delta)
+        _mark_as_tested()
+        @context.assert_in_delta(expected, @actual, delta)  unless @not
+        @context.refute_in_delta(expected, @actual, delta)  if     @not
+        self
+      end
+
+      ##
+      ## Same as <tt>assert_in_epsilon()</tt>.
+      ##
+      ##   ok {3.14159}.in_epsilon?(3.14, 0.001)    # Pass
+      ##   ok {3.14159}.in_epsilon?(3.14, 0.0001)   # Fail
+      ##
+      def in_epsilon?(expected, epsilon)
+        _mark_as_tested()
+        @context.assert_in_epsilon(expected, @actual, epsilon)  unless @not
+        @context.refute_in_epsilon(expected, @actual, epsilon)  if     @not
+        self
+      end
+
+      ##
+      ## Same as <tt>assert_raises()</tt>.
+      ##
+      ##   ex = ok { proc { 1/0 } }.raise?(ZeroDivisionError)  # Pass
+      ##   p ex.class        #=> ZeroDivisionError
+      ##   ex = ok { proc { 1/0 } }.raise?(ZeroDivisionError, "divided by zero")
+      ##   ex = ok { proc { 1/0 } }.raise?(ZeroDivisionError, /^divided by zero$/)
+      ##
+      ##   ok { proc { 1 / 1 } }.NOT.raise?(Exception)         # Pass
+      ##
+      def raise?(exception_class, message=nil)
+        _mark_as_tested()
+        ex = nil
+        unless @not
+          ex = @context.assert_raises(exception_class) { @actual.call }
+        else
+          begin
+            @actual.call
+          rescue exception_class => ex
+            @context.assert false, "Exception #{ex.class} raised unexpectedly."
+          else
+            @context.assert true
+          end
+        end
+        return ex   # not self!
+      end
+
+      ##
+      ## Same as <tt>assert_throws()</tt>.
+      ##
+      ##   ok {proc {throw :exit}}.throw?(:exit)   # Pass
+      ##   ok {proc {nil}}.NOT.throw?(:exit)       # NOT AVAILABLE
+      ##
+      def throw?(sym)
+        _mark_as_tested()
+        ! @not  or
+          raise "NOT.throw? is unsupported because refute_throws() is not defined in Minitest."
+        @context.assert_throws(sym) { @actual.call }
+        self
+      end
+
+      ##
+      ## Same as <tt>assert_respond_to()</tt>.
+      ##
+      ##   ok {"X"}.respond_to?(:each)     # Pass
+      ##   ok {123}.respond_to?(:each)     # Fail
+      ##
+      def respond_to?(expected)
+        _mark_as_tested()
+        @context.assert_respond_to @actual, expected  unless @not
+        @context.refute_respond_to @actual, expected  if     @not
+        self
+      end
+
+      ##
+      ## Same as <tt>assert_includes()</tt>.
+      ##
+      ##   ok {[1, 2, 3]}.include?(2)         # Pass
+      ##   ok {[1, 2, 3]}.include?(0)         # Fail
+      ##   ok {[1, 2, 3]}.NOT.include?(0)     # Pass
+      ##
+      def include?(expected)
+        _mark_as_tested()
+        @context.assert_includes @actual, expected  unless @not
+        @context.refute_includes @actual, expected  if     @not
+        self
+      end
+
+      ##
+      ## Same as <tt>assert_includes()</tt>.
+      ##
+      ##   ok {1}.in?(1..9)         # Pass
+      ##   ok {0}.in?(1..9)         # Fail
+      ##   ok {0}.NOT.in?(1..9)     # Pass
+      ##
+      def in?(expected)
+        _mark_as_tested()
+        @context.assert_includes expected, @actual  unless @not
+        @context.refute_includes expected, @actual  if     @not
+        self
+      end
+
+      ##
+      ## Same as <tt>assert_output()</tt>.
+      ##
+      ##   ok {proc { puts 'X' }}.output?("X\n")  # Pass
+      ##   ok {proc { x = 123  }}.NOT.output?     # NOT AVAILABLE
+      ##
+      def output?(stdout=nil, stderr=nil)
+        _mark_as_tested()
+        ! @not  or
+          raise "use ok().silent? instead of ok().NOT.output?."
+        @context.assert_output(stdout, stderr, &@actual)
+        self
+      end
+
+      ##
+      ## Same as <tt>assert_silent()</tt>.
+      ##
+      ##   ok {proc { x = 1234 }}.silent?       # Pass
+      ##   ok {proc { puts 'X' }}.NOT.silent?   # NOT AVAILABLE
+      ##
+      def silent?
+        _mark_as_tested()
+        ! @not  or
+          raise "use ok().output? instead of ok().NOT.silent?."
+        @context.assert_silent(&@actual)
+        self
+      end
+
+      ## for predicates
+
+      ##
+      ## Tests whether object is frozen or not.
+      ##
+      ##   ok {"foo".freeze}.frozen?     # Pass
+      ##   ok {"foo"}.NOT.frozen?        # Pass
+      ##
+      def frozen?
+        _mark_as_tested()
+        @context.assert_predicate @actual, :frozen?  unless @not
+        @context.refute_predicate @actual, :frozen?  if     @not
+        self
+      end
+
+      ##
+      ## Tests whether object is tainted or not.
+      ##
+      ##   ok {"foo".tainted}.tainted?   # Pass
+      ##   ok {"foo"}.NOT.tainted?       # Pass
+      ##
+      def tainted?
+        _mark_as_tested()
+        @context.assert_predicate @actual, :tainted?  unless @not
+        @context.refute_predicate @actual, :tainted?  if     @not
+        self
+      end
+
+      ##
+      ## Tests whether object has instance variable or not.
+      ##
+      ##   class User
+      ##     def initialize(name); @name = name; end
+      ##   end
+      ##   ok {User.new('Haruhi')}.instance_variable_defined?('@name')  # Pass
+      ##
+      def instance_variable_defined?(varname)
+        _mark_as_tested()
+        result = @actual.instance_variable_defined?(varname)
+        unless @not
+          @context.assert result, "Expected #{@actual.inspect} to have instance variable #{varname}, but not."
+        else
+          @context.refute result, "Expected #{@actual.inspect} not to have instance variable #{varname}, but has it."
+        end
+        self
+      end
+
+      ##
+      ## When <tt>ok {actual}.xxx?</tt> called, tries <tt>assert_xxx(actual)</tt> at first.
+      ## If it is not defined, tries <tt>assert actual.xxx?</tt>.
+      ##
+      ##   ok {'logo.jpg'}.end_with?('.jpg')   # Pass
+      ##   ok {[1, 2, 3]}.all? {|x| x <= 3 }   # Pass
+      ##
+      def method_missing(symbol, *args, &block)
+        unless symbol.to_s =~ /\?\z/
+          return super
+        end
+        _mark_as_tested()
+        unless @not
+          ## Try assert_xxxx() at first.
+          ## If not defined, try assert @actual.xxxx?.
+          begin
+            @context.__send__("assert_#{symbol.to_s[0..-2]}", @actual, *args, &block)
+          rescue NoMethodError
+            result = @actual.__send__(symbol, *args, &block)
+            msg = result ? nil : "Expected #{@actual.inspect}.#{symbol}(#{args.inspect[1..-2]}) but failed."
+            @context.assert result, msg
+          end
+        else
+          ## Try refute_xxxx() at first.
+          ## If not defined, try refute @actual.xxxx?.
+          begin
+            @context.__send__("refute_#{symbol.to_s[0..-2]}", @actual, *args, &block)
+          rescue NoMethodError
+            result = @actual.__send__(symbol, *args, &block)
+            msg = ! result ? nil : "Expected #{@actual.inspect}.#{symbol}(#{args.inspect[1..-2]}) to fail but succeeded."
+            @context.refute result, msg
+          end
+        end
+        self
+      end
+
+      ## other helpers
+
+      ##
+      ## Tests whether actual is regarded as true-like value.
+      ##
+      ##   ok {true}.truthy?                 # Pass
+      ##   ok {0}.truthy?                    # Pass
+      ##   ok {""}.truthy?                   # Pass
+      ##   ok {[]}.truthy?                   # Pass
+      ##   ok {nil}.truthy?                  # Fail
+      ##   ok {false}.truthy?                # Fail
+      ##
+      def truthy?
+        _mark_as_tested()
+        unless @not
+          msg = @actual ? nil : "Expected (!! #{@actual.inspect}) == true, but not."
+          @context.assert @actual, msg
+        else
+          msg = ! @actual ? nil : "Expected (!! #{@actual.inspect}) == false, but not."
+          @context.refute @actual, msg
+        end
+        self
+      end
+
+      ##
+      ## Tests whether actual is false or nil.
+      ##
+      ##   ok {nil}.falthy?                  # Pass
+      ##   ok {false}.falthy?                # Pass
+      ##   ok {true}.falthy?                 # Fail
+      ##   ok {0}.falthy?                    # Fail
+      ##   ok {""}.falthy?                   # Fail
+      ##   ok {[]}.falthy?                   # Fail
+      ##
+      def falthy?
+        _mark_as_tested()
+        unless @not
+          msg = ! @actual ? nil : "Expected (!! #{@actual.inspect}) == false, but not."
+          @context.refute @actual, msg
+        else
+          msg = @actual ? nil : "Expected (!! #{@actual.inspect}) == true, but not."
+          @context.assert @actual, msg
+        end
+        self
+      end
+
+      ##
+      ## Tests attribute value.
+      ##
+      ##   User = Struct.new(:user, :age)   # define User class quickly
+      ##   user = User.new('Haruhi', 16)
+      ##   ok {user}.attr(:name, 'Haruhi').attr(:age, 16)   # Pass
+      ##
+      def attr(name, expected)
+        _mark_as_tested()
+        object = @actual
+        actual = object.__send__(name)
+        pr = proc {|op|
+          "Expected <object>.#{name} #{op} <exected>, but failed.\n" +
+          " (object: #{object.inspect})"
+        }
+        result = expected == actual
+        @context.assert_equal expected, actual, (result ? nil : pr.call('=='))  unless @not
+        @context.refute_equal expected, actual, (result ? pr.call('!=') : nil)  if     @not
+        self
+      end
+
+      ##
+      ## Tests attribute values.
+      ##
+      ##   User = Struct.new(:user, :age)   # define User class quickly
+      ##   user = User.new('Haruhi', 16)
+      ##   ok {user}.attrs(name: 'Haruhi', age: 16)   # Pass
+      ##
+      def attrs(expecteds={})
+        _mark_as_tested()
+        expecteds.each do |name, expected|
+          attr(name, expected)
+        end
+        self
+      end
+
+      ##
+      ## Tests key and value.
+      ##
+      ##   user = {:name=>'Haruhi', :age=>16}
+      ##   ok {user}.item(:name, 'Haruhi').item(:age, 16)   # Pass
+      ##
+      def item(key, expected)
+        _mark_as_tested()
+        object = @actual
+        actual = object[key]
+        pr = proc {|op|
+          "Expected <object>[#{key.inspect}] #{op} <exected>, but failed.\n" +
+          " (object: #{object.inspect})"
+        }
+        result = expected == actual
+        @context.assert_equal expected, actual, (result ? nil : pr.call('=='))  unless @not
+        @context.refute_equal expected, actual, (result ? pr.call('!=') : nil)  if     @not
+        self
+      end
+
+      ##
+      ## Tests keys and values.
+      ##
+      ##   user = {:name=>'Haruhi', :age=>16}
+      ##   ok {user}.items(name: 'Haruhi', age: 16)   # Pass
+      ##
+      def items(expecteds={})
+        _mark_as_tested()
+        expecteds.each do |key, expected|
+          item(key, expected)
+        end
+        self
+      end
+
+      ##
+      ## Tests whether file exists or not.
+      ##
+      ##   ok {__FILE__}.file_exist?         # Pass
+      ##   ok {'/some/where'}.file_exist?    # Fail
+      ##   ok {Dir.pwd}.file_exist?          # Fail
+      ##
+      def file_exist?
+        _mark_as_tested()
+        fpath = @actual
+        unless @not
+          @context.assert File.exist?(fpath), "File '#{fpath}' doesn't exist."
+          @context.assert File.file?(fpath),  "'#{fpath}' is not a file."
+        else
+          @context.refute File.exist?(fpath), "File '#{fpath}' exists unexpectedly."
+        end
+      end
+
+      ##
+      ## Tests whether directory exists or not.
+      ##
+      ##   ok {Dir.pwd}.dir_exist?           # Pass
+      ##   ok {'/some/where'}.dir_exist?     # Fail
+      ##   ok {__FILE__}.dir_exist?          # Fail
+      ##
+      def dir_exist?
+        _mark_as_tested()
+        fpath = @actual
+        unless @not
+          @context.assert File.exist?(fpath),     "Directory '#{fpath}' doesn't exist."
+          @context.assert File.directory?(fpath), "'#{fpath}' is not a directory."
+        else
+          @context.refute File.exist?(fpath),     "Directory '#{fpath}' exists unexpectedly."
+        end
+      end
+
+      ##
+      ## Tests whether file or directory not exist.
+      ##
+      ##   ok {'/some/where'}.not_exist?     # Pass
+      ##   ok {__FILE__}.not_exist?          # Fail
+      ##   ok {Dir.pwd}.not_exist?           # Fail
+      ##
+      def not_exist?
+        _mark_as_tested()
+        fpath = @actual
+        @context.assert ! File.exist?(fpath), "'#{fpath}' exists unexpectedly." unless @not
+        @context.refute ! File.exist?(fpath), "'#{fpath}' doesn't exist."       if     @not
+        self
+      end
+
+    end
+
+
+  end
+
+
+end