test-unit 2.5.5 → 3.0.0

data/lib/test/unit/attribute.rb

@@ -92,7 +92,8 @@ module Test
 
         def attributes(method_name)
           attributes = attributes_table[method_name]
-          ancestors[1..-1].each do |ancestor|
+          ancestors.each do |ancestor|
+            next if ancestor == self
             if ancestor.is_a?(Class) and ancestor < Test::Unit::Attribute
               parent_attributes = ancestor.attributes(method_name)
               if attributes

data/lib/test/unit/autorunner.rb

@@ -240,11 +240,8 @@ module Test
                "Runs tests in TestCases matching TESTCASE.",
                "(patterns may be used).") do |n|
             n = (%r{\A/(.*)/\Z} =~ n ? Regexp.new($1) : n)
-            case n
-            when Regexp
-              @filters << proc{|t| n =~ t.class.name ? true : false}
-            else
-              @filters << proc{|t| n == t.class.name}
+            @filters << lambda do |test|
+              match_test_case_name(test, n)
             end
           end
 
@@ -252,11 +249,8 @@ module Test
                "Ignores tests in TestCases matching TESTCASE.",
                "(patterns may be used).") do |n|
             n = (%r{\A/(.*)/\Z} =~ n ? Regexp.new($1) : n)
-            case n
-            when Regexp
-              @filters << proc {|t| n =~ t.class.name ? false : true}
-            else
-              @filters << proc {|t| n != t.class.name}
+            @filters << lambda do |test|
+              not match_test_case_name(test, n)
             end
           end
 
@@ -465,6 +459,14 @@ module Test
           yield
         end
       end
+
+      def match_test_case_name(test, pattern)
+        test.class.ancestors.each do |test_class|
+          break if test_class == TestCase
+          return true if pattern === test_class.name
+        end
+        false
+      end
     end
   end
 end

data/lib/test/unit/collector/dir.rb

@@ -55,7 +55,7 @@ module Test
           sub_suites = []
           path = realdir(name)
           if @file.directory?(path)
-	    dir_name = name unless name == '.'
+            dir_name = name unless name == '.'
             @dir.entries(path).each do |e|
               next if(e == '.' || e == '..')
               e_name = dir_name ? @file.join(dir_name, e) : e
@@ -95,13 +95,13 @@ module Test
           $:.delete_at($:.rindex(dir)) if(dir)
         end
 
-	def realdir(path)
-	  if @base
-	    @file.join(@base, path)
-	  else
-	    path
-	  end
-	end
+        def realdir(path)
+          if @base
+            @file.join(@base, path)
+          else
+            path
+          end
+        end
       end
     end
   end

data/lib/test/unit/collector/load.rb

@@ -119,10 +119,16 @@ module Test
         end
 
         def add_load_path(path)
-          $LOAD_PATH.unshift(path.to_s) if path
-          yield
-        ensure
-          $LOAD_PATH.delete_at($LOAD_PATH.index(path.to_s)) if path
+          return yield if path.nil?
+
+          path = path.to_s
+          begin
+            $LOAD_PATH.unshift(path)
+            yield
+          ensure
+            index = $LOAD_PATH.index(path)
+            $LOAD_PATH.delete_at(index) if index
+          end
         end
 
         def excluded_directory?(base)

data/lib/test/unit/collector/objectspace.rb

@@ -9,14 +9,14 @@ module Test
     module Collector
       class ObjectSpace
         include Collector
-        
+
         NAME = 'collected from the ObjectSpace'
-        
+
         def initialize(source=::ObjectSpace)
           super()
           @source = source
         end
-        
+
         def collect(name=NAME)
           suite = TestSuite.new(name)
           sub_suites = []

data/lib/test/unit/{exceptionhandler.rb → exception-handler.rb}

@@ -5,7 +5,7 @@ module Test
       class << self
         def exception_handlers
           @@exception_handlers
-	end
+        end
 
         def included(base)
           base.extend(ClassMethods)

data/lib/test/unit/{testsuitecreator.rb → test-suite-creator.rb}

@@ -41,9 +41,10 @@ module Test
       end
 
       def collect_test_names
-        method_names = @test_case.public_instance_methods(true).collect do |name|
-          name.to_s
-        end
+        methods = @test_case.public_instance_methods(true)
+        super_test_case = @test_case.superclass
+        methods -= super_test_case.public_instance_methods(true)
+        method_names = methods.collect(&:to_s)
         test_names = method_names.find_all do |method_name|
           method_name =~ /^test./ or @test_case.attributes(method_name)[:test]
         end

data/lib/test/unit/testcase.rb

@@ -8,7 +8,7 @@
 
 require 'test/unit/attribute'
 require 'test/unit/fixture'
-require 'test/unit/exceptionhandler'
+require 'test/unit/exception-handler'
 require 'test/unit/assertions'
 require 'test/unit/failure'
 require 'test/unit/error'
@@ -18,8 +18,8 @@ require 'test/unit/notification'
 require 'test/unit/priority'
 require 'test/unit/data'
 require 'test/unit/testsuite'
-require 'test/unit/testsuitecreator'
-require 'test/unit/assertionfailederror'
+require 'test/unit/test-suite-creator'
+require 'test/unit/assertion-failed-error'
 require 'test/unit/util/backtracefilter'
 require 'test/unit/util/output'
 require 'test/unit/util/method-owner-finder'
@@ -117,8 +117,14 @@ module Test
           if _added_methods.include?(stringified_name)
             attribute(:redefined, {:backtrace => caller}, {}, stringified_name)
           end
-          path, line, = caller[0].split(/:(\d+)/,2)
-          line = line.to_i if line
+          _attributes = attributes_table[stringified_name] || {}
+          source_location = _attributes[:source_location]
+          if source_location
+            path, line = source_location
+          else
+            path, line, = caller[0].split(/:(\d+)/,2)
+            line = line.to_i if line
+          end
           method_locations << {
             :method_name => stringified_name,
             :path => path,
@@ -267,12 +273,12 @@ module Test
               raise ArgumentError, message
             end
             method_name = "test: #{test_description}"
-            define_method(method_name, &block)
             description(test_description, method_name)
             attribute(:test, true, {}, method_name)
             if block.respond_to?(:source_location)
               attribute(:source_location, block.source_location, {}, method_name)
             end
+            define_method(method_name, &block)
           else
             targets = test_description_or_targets
             attribute(:test, true, {}, *targets)
@@ -330,10 +336,11 @@ module Test
         #   case class context.
         # @return [Test::Unit::TestCase] Created sub test case class.
         def sub_test_case(name, &block)
+          parent_test_case = self
           sub_test_case = Class.new(self) do
             singleton_class = class << self; self; end
             singleton_class.send(:define_method, :name) do
-              name
+              [parent_test_case.name, name].compact.join("::")
             end
           end
           sub_test_case.class_eval(&block)

data/lib/test/unit/util/backtracefilter.rb

@@ -27,13 +27,17 @@ module Test
             entry.start_with?("org/jruby/")
           end
 
+          rubinius_internal_p = lambda do |entry|
+            entry.start_with?("kernel/")
+          end
+
           found_prefix = false
           new_backtrace = backtrace.reverse.reject do |entry|
             if test_unit_internal_p.call(entry)
               found_prefix = true
               true
             elsif found_prefix
-              jruby_internal_p.call(entry)
+              jruby_internal_p.call(entry) or rubinius_internal_p.call(entry)
             else
               true
             end
@@ -41,7 +45,9 @@ module Test
 
           if new_backtrace.empty?
             new_backtrace = backtrace.reject do |entry|
-              test_unit_internal_p.call(entry) or jruby_internal_p.call(entry)
+              test_unit_internal_p.call(entry) or
+                jruby_internal_p.call(entry) or
+                rubinius_internal_p.call(entry)
             end
             new_backtrace = backtrace if new_backtrace.empty?
           end

data/lib/test/unit/version.rb

@@ -1,5 +1,5 @@
 module Test
   module Unit
-    VERSION = '2.5.5'
+    VERSION = '3.0.0'
   end
 end

data/test/test-assertions.rb

@@ -2,10 +2,11 @@
 #
 # Author:: Nathaniel Talbott.
 # Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
-#             Copyright (c) 2009-2013 Kouhei Sutou. All rights reserved.
+#             Copyright (c) 2009-2014 Kouhei Sutou. All rights reserved.
 # License:: Ruby license.
 
 require 'test/unit'
+require "testunit-test-util"
 
 module Test
   module Unit
@@ -102,17 +103,7 @@ module Test
       end
 
       def inspect_tag(tag)
-        if jruby?
-          "`#{tag}'".inspect
-        else
-          begin
-            throw tag
-          rescue NameError
-            tag.to_s.inspect
-          rescue ArgumentError
-            tag.inspect
-          end
-        end
+        tag.inspect
       end
 
       def add_failure(message, location=caller, options=nil)
@@ -151,15 +142,24 @@ module Test
         }
       end
 
-      def test_assert_equal
-        check_nothing_fails {
-          assert_equal("string1", "string1")
-        }
-        check_nothing_fails {
-          assert_equal("string1", "string1", "successful assert_equal")
-        }
+      class TestAssertEqual < self
+        class TestSuccess < self
+          def test_without_message
+            check_nothing_fails {
+              assert_equal("string1", "string1")
+            }
+          end
 
-        message = <<-EOM.chomp
+          def test_with_message
+            check_nothing_fails {
+              assert_equal("string1", "string1", "successful assert_equal")
+            }
+          end
+        end
+
+        class TestFailure < self
+          def test_without_message
+            message = <<-EOM.chomp
 <"string1"> expected but was
 <"string2">.
 
@@ -169,11 +169,13 @@ diff:
 + string2
 ?       ^
 EOM
-        check_fail(message) {
-          assert_equal("string1", "string2")
-        }
+            check_fail(message) {
+              assert_equal("string1", "string2")
+            }
+          end
 
-        message = <<-EOM.chomp
+          def test_with_message
+            message = <<-EOM.chomp
 failed assert_equal.
 <"string1"> expected but was
 <"string2">.
@@ -184,11 +186,15 @@ diff:
 + string2
 ?       ^
 EOM
-        check_fail(message) {
-          assert_equal("string1", "string2", "failed assert_equal")
-        }
+           check_fail(message) {
+             assert_equal("string1", "string2", "failed assert_equal")
+            }
+          end
+        end
 
-        message = <<-EOM.chomp
+        class TestSystemMessage < self
+          def test_different_type
+            message = <<-EOM.chomp
 <"111111"> expected but was
 <111111>.
 
@@ -197,31 +203,31 @@ diff:
 ? -      -
 + 111111
 EOM
-        check_fail(message) do
-          assert_equal("111111", 111111)
-        end
-      end
-
-      def test_assert_equal_with_long_line
-        expected = ["0123456789",
-                    "1123456789",
-                    "2123456789",
-                    "3123456789",
-                    "4123456789",
-                    "5123456789",
-                    "6123456789",
-                    "7123456789",
-                    "8123456789"].join
-        actual =   ["0000000000",
-                    "1123456789",
-                    "2123456789",
-                    "3123456789",
-                    "4123456789",
-                    "5123456789",
-                    "6123456789",
-                    "7123456789",
-                    "8123456789"].join
-        message = <<-EOM.chomp
+            check_fail(message) do
+              assert_equal("111111", 111111)
+            end
+          end
+
+          def test_long_line
+            expected = ["0123456789",
+                        "1123456789",
+                        "2123456789",
+                        "3123456789",
+                        "4123456789",
+                        "5123456789",
+                        "6123456789",
+                        "7123456789",
+                        "8123456789"].join
+            actual =   ["0000000000",
+                        "1123456789",
+                        "2123456789",
+                        "3123456789",
+                        "4123456789",
+                        "5123456789",
+                        "6123456789",
+                        "7123456789",
+                        "8123456789"].join
+            message = <<-EOM.chomp
 <"#{expected}"> expected but was
 <"#{actual}">.
 
@@ -238,35 +244,35 @@ folded diff:
 ?  ^^^^^^^^^
   898123456789
 EOM
-        check_fail(message) do
-          assert_equal(expected, actual)
-        end
-      end
+            check_fail(message) do
+              assert_equal(expected, actual)
+            end
+          end
 
-      def test_assert_equal_for_too_small_difference
-        message = <<-EOM.chomp
+          def test_too_small_difference
+            message = <<-EOM.chomp
 <1> expected but was
 <2>.
 EOM
-        check_fail(message) do
-          assert_equal(1, 2)
-        end
-      end
+            check_fail(message) do
+              assert_equal(1, 2)
+            end
+          end
 
-      def test_assert_equal_for_same_inspected_objects
-        now = Time.now
-        now_without_usec = Time.at(now.to_i)
-        message = <<-EOM.chomp
+          def test_same_inspected_objects
+            now = Time.now
+            now_without_usec = Time.at(now.to_i)
+            message = <<-EOM.chomp
 <#{now.inspect}> expected but was
 <#{now.inspect}>.
 EOM
-        check_fail(message) do
-          assert_equal(now, now_without_usec)
-        end
-      end
+            check_fail(message) do
+              assert_equal(now, now_without_usec)
+            end
+          end
 
-      def test_assert_equal_with_multi_lines_result
-        message = <<-EOM.chomp
+          def test_multi_lines_result
+            message = <<-EOM.chomp
 <#{"a\nb".inspect}> expected but was
 <#{"x".inspect}>.
 
@@ -275,13 +281,13 @@ diff:
 - a
 - b
 EOM
-        check_fail(message) do
-          assert_equal("a\nb", "x")
-        end
-      end
+            check_fail(message) do
+              assert_equal("a\nb", "x")
+            end
+          end
 
-      def test_assert_equal_with_large_string
-        message = <<-EOM.chomp
+          def test_large_string
+            message = <<-EOM.chomp
 <#{("a\n" + "x" * 997).inspect}> expected but was
 <#{"x".inspect}>.
 
@@ -296,25 +302,25 @@ folded diff:
 #{(["- " + ("x" * 78)] * 12).join("\n")}
 - #{"x" * 61}
 EOM
-        check_fail(message) do
-          assert_equal("a\n" + "x" * 997, "x")
-        end
+            check_fail(message) do
+              assert_equal("a\n" + "x" * 997, "x")
+            end
 
-        message = <<-EOM.chomp
+            message = <<-EOM.chomp
 <#{("a\n" + "x" * 998).inspect}> expected but was
 <#{"x".inspect}>.
 EOM
-        check_fail(message) do
-          assert_equal("a\n" + "x" * 998, "x")
-        end
-      end
+            check_fail(message) do
+              assert_equal("a\n" + "x" * 998, "x")
+            end
+          end
 
-      def test_assert_equal_with_max_diff_target_string_size
-        key = "TEST_UNIT_MAX_DIFF_TARGET_STRING_SIZE"
-        before_value = ENV[key]
-        ENV[key] = "100"
-        begin
-          message = <<-EOM.chomp
+          def test_max_diff_target_string_size
+            key = "TEST_UNIT_MAX_DIFF_TARGET_STRING_SIZE"
+            before_value = ENV[key]
+            ENV[key] = "100"
+            begin
+              message = <<-EOM.chomp
 <#{("a\n" + "x" * 97).inspect}> expected but was
 <#{"x".inspect}>.
 
@@ -329,61 +335,61 @@ folded diff:
 #{(["- " + ("x" * 78)]).join("\n")}
 - #{"x" * 19}
 EOM
-          check_fail(message) do
-            assert_equal("a\n" + "x" * 97, "x")
-          end
+              check_fail(message) do
+                assert_equal("a\n" + "x" * 97, "x")
+              end
 
-          message = <<-EOM.chomp
+              message = <<-EOM.chomp
 <#{("a\n" + "x" * 98).inspect}> expected but was
 <#{"x".inspect}>.
 EOM
-          check_fail(message) do
-            assert_equal("a\n" + "x" * 98, "x")
+              check_fail(message) do
+                assert_equal("a\n" + "x" * 98, "x")
+              end
+            ensure
+              ENV[key] = before_value
+            end
           end
-        ensure
-          ENV[key] = before_value
-        end
-      end
 
-      def test_assert_equal_with_different_encoding
-        utf8_string = "こんにちは"
-        unless utf8_string.respond_to?(:force_encoding)
-          omit("encoding test is for Ruby >= 1.9")
-        end
-        ascii_8bit_string = utf8_string.dup.force_encoding("ascii-8bit")
-        message = <<-EOM.chomp
+          def test_different_encoding
+            utf8_string = "こんにちは"
+            unless utf8_string.respond_to?(:force_encoding)
+              omit("encoding test is for Ruby >= 1.9")
+            end
+            ascii_8bit_string = utf8_string.dup.force_encoding("ascii-8bit")
+            message = <<-EOM.chomp
 <#{utf8_string.inspect}>("UTF-8") expected but was
 <#{ascii_8bit_string.inspect}>("ASCII-8BIT").
 EOM
-        check_fail(message) do
-          assert_equal(utf8_string, ascii_8bit_string)
-        end
-      end
+            check_fail(message) do
+              assert_equal(utf8_string, ascii_8bit_string)
+            end
+          end
 
-      def test_assert_equal_with_different_hash
-        designers = {
-          "Ruby" => "Matz",
-          "Lisp" => "John McCarthy",
-        }
-        categories = {
-          "LL" => ["Ruby", "Python"],
-          "Heavy" => ["C", "C++"],
-        }
-        message = <<-EOM.chomp
+          def test_different_hash
+            designers = {
+              "Ruby" => "Matz",
+              "Lisp" => "John McCarthy",
+            }
+            categories = {
+              "LL" => ["Ruby", "Python"],
+              "Heavy" => ["C", "C++"],
+            }
+            message = <<-EOM.chomp
 <{"Lisp"=>"John McCarthy", "Ruby"=>"Matz"}> expected but was
 <{"Heavy"=>["C", "C++"], "LL"=>["Ruby", "Python"]}>.
 EOM
-        check_fail(message) do
-          assert_equal(designers, categories)
-        end
-      end
+            check_fail(message) do
+              assert_equal(designers, categories)
+            end
+          end
 
-      def test_assert_equal_with_recursive_hash
-        alice = {"name" => "Alice"}
-        bob = {"name" => "Bob"}
-        alice["followers"] = [bob]
-        bob["followers"] = [alice]
-        message = <<-EOM.chomp
+          def test_recursive_hash
+            alice = {"name" => "Alice"}
+            bob = {"name" => "Bob"}
+            alice["followers"] = [bob]
+            bob["followers"] = [alice]
+            message = <<-EOM.chomp
 <{"followers"=>[{"followers"=>[{...}], "name"=>"Bob"}], "name"=>"Alice"}> expected but was
 <{"followers"=>[{"followers"=>[{...}], "name"=>"Alice"}], "name"=>"Bob"}>.
 
@@ -393,8 +399,31 @@ diff:
 + {"followers"=>[{"followers"=>[{...}], "name"=>"Alice"}], "name"=>"Bob"}
 ?                                                       +++++++++++++++++
 EOM
-        check_fail(message) do
-          assert_equal(alice, bob)
+            check_fail(message) do
+              assert_equal(alice, bob)
+            end
+          end
+
+          def test_numeric
+            numeric_family_class = Class.new(Numeric) do
+              def inspect
+                "inspect is called"
+              end
+
+              def to_s
+                "to_s is called"
+              end
+            end
+            numeric = numeric_family_class.new
+
+            message = <<-MESSAGE.chomp
+<to_s is called> expected but was
+<"must be failed">.
+            MESSAGE
+            check_fail(message) do
+              assert_equal(numeric, "must be failed")
+            end
+          end
         end
       end
 
@@ -592,24 +621,49 @@ EOM
         check_nothing_fails {
           assert_instance_of(String, "string", "successful assert_instance_of")
         }
-        check_fail(%Q{<"string"> expected to be an instance of\n<Hash> but was\n<String>.}) {
+        check_fail(%Q{<"string"> expected to be instance_of?\n<Hash> but was\n<String>.}) {
           assert_instance_of(Hash, "string")
         }
-        check_fail(%Q{failed assert_instance_of.\n<"string"> expected to be an instance of\n<Hash> but was\n<String>.}) {
+        check_fail(%Q{failed assert_instance_of.\n<"string"> expected to be instance_of?\n<Hash> but was\n<String>.}) {
           assert_instance_of(Hash, "string", "failed assert_instance_of")
         }
 
         check_nothing_fails do
           assert_instance_of([Fixnum, NilClass], 100)
         end
-        check_fail(%Q{<"string"> expected to be an instance of\n[<Fixnum>, <NilClass>] but was\n<String>.}) do
+        check_fail(%Q{<"string"> expected to be instance_of?\n[<Fixnum>, <NilClass>] but was\n<String>.}) do
           assert_instance_of([Fixnum, NilClass], "string")
         end
-        check_fail(%Q{<100> expected to be an instance of\n[<Numeric>, <NilClass>] but was\n<Fixnum>.}) do
+        check_fail(%Q{<100> expected to be instance_of?\n[<Numeric>, <NilClass>] but was\n<Fixnum>.}) do
           assert_instance_of([Numeric, NilClass], 100)
         end
       end
 
+      def test_assert_not_instance_of
+        check_nothing_fails {
+          assert_not_instance_of(NilClass, "string")
+        }
+        check_nothing_fails {
+          assert_not_instance_of(NilClass, "string", "successful assert_instance_of")
+        }
+        check_fail(%Q{<"string"> expected to not be instance_of?\n<String> but was.}) {
+          assert_not_instance_of(String, "string")
+        }
+        check_fail(%Q{failed assert.\n<"string"> expected to not be instance_of?\n<String> but was.}) {
+          assert_not_instance_of(String, "string", "failed assert")
+        }
+
+        check_nothing_fails do
+          assert_not_instance_of([Numeric, NilClass], 100)
+        end
+        check_fail(%Q{<100> expected to not be instance_of?\n[<Fixnum>, <NilClass>] but was.}) do
+          assert_not_instance_of([Fixnum, NilClass], 100)
+        end
+        check_fail(%Q{<"str"> expected to not be instance_of?\n[<Numeric>, <String>] but was.}) do
+          assert_not_instance_of([Numeric, String], 'str')
+        end
+      end
+
       def test_assert_nil
         check_nothing_fails {
           assert_nil(nil)
@@ -627,14 +681,14 @@ EOM
           assert_nil("string", "failed assert_nil")
         }
       end
-      
+
       def test_assert_not_nil
         check_nothing_fails{assert_not_nil(false)}
         check_nothing_fails{assert_not_nil(false, "message")}
         check_fail("<nil> expected to not be nil."){assert_not_nil(nil)}
         check_fail("message.\n<nil> expected to not be nil.") {assert_not_nil(nil, "message")}
       end
-        
+
       def test_assert_kind_of
         check_nothing_fails {
           assert_kind_of(Module, Array)
@@ -643,7 +697,7 @@ EOM
           assert_kind_of(Object, "string", "successful assert_kind_of")
         }
         check_nothing_fails {
-          assert_kind_of(Object, "string", "successful assert_kind_of")
+          assert_kind_of(String, "string", "successful assert_kind_of")
         }
         check_nothing_fails {
           assert_kind_of(Comparable, 1)
@@ -663,6 +717,31 @@ EOM
         end
       end
 
+      def test_assert_not_kind_of
+        check_nothing_fails {
+          assert_not_kind_of(Class, 42)
+        }
+        check_nothing_fails {
+          assert_not_kind_of(Symbol, "string", "successful assert_not_kind_of")
+        }
+        check_nothing_fails {
+          assert_not_kind_of(Integer, 1.1)
+        }
+        check_fail(%Q{<1> expected to not be kind_of?\n<Integer> but was.}) {
+          assert_not_kind_of(Integer, 1)
+        }
+        check_fail(%Q{failed assert_not_kind_of.\n<"string"> expected to not be kind_of?\n<String> but was.}) {
+          assert_not_kind_of(String, "string", "failed assert_not_kind_of")
+        }
+
+        check_nothing_fails do
+          assert_not_kind_of([String, NilClass], 100)
+        end
+        check_fail(%Q{<100> expected to not be kind_of?\n[<Fixnum>, <NilClass>] but was.}) do
+          assert_not_kind_of([Fixnum, NilClass], 100)
+        end
+      end
+
       def test_assert_match
         check_nothing_fails {
           assert_match(/strin./, "string")
@@ -686,7 +765,7 @@ EOM
           assert_match(/slin./, "string", "failed assert_match")
         }
       end
-      
+
       def test_assert_same
         thing = "thing"
         check_nothing_fails {
@@ -706,7 +785,7 @@ EOM
           assert_same(thing, thing2, "failed assert_same")
         }
       end
-      
+
       def test_assert_nothing_raised
         check_nothing_fails {
           assert_nothing_raised {
@@ -796,7 +875,7 @@ EOM
           assert_not_same(thing, thing, "message")
         }
       end
-      
+
       def test_assert_not_equal
         check_nothing_fails {
           assert_not_equal("string1", "string2")
@@ -827,7 +906,7 @@ EOM
       def test_assert_not_match_fail_not_regexp
         check_fail("<REGEXP> in assert_not_match(<REGEXP>, ...) " +
                     "should be a Regexp.\n" +
-                    "<\"asdf\"> expected to be an instance of\n" +
+                    "<\"asdf\"> expected to be instance_of?\n" +
                     "<Regexp> but was\n" +
                     "<String>.") do
           assert_not_match("asdf", "asdf")
@@ -852,7 +931,7 @@ EOM
       def test_assert_no_match
         check_nothing_fails{assert_no_match(/sling/, "string")}
         check_nothing_fails{assert_no_match(/sling/, "string", "message")}
-        check_fail(%Q{The first argument to assert_no_match should be a Regexp.\n<"asdf"> expected to be an instance of\n<Regexp> but was\n<String>.}) do
+        check_fail(%Q{The first argument to assert_no_match should be a Regexp.\n<"asdf"> expected to be instance_of?\n<Regexp> but was\n<String>.}) do
           assert_no_match("asdf", "asdf")
         end
         check_fail(%Q{</string/> expected to not match\n<"string">.}) do
@@ -885,7 +964,7 @@ EOM
           end
         end
       end
-      
+
       def test_assert_nothing_thrown
         check_nothing_fails do
           assert_nothing_thrown("message") do
@@ -902,7 +981,7 @@ EOM
           end
         end
       end
-      
+
       def test_assert_operator
         check_nothing_fails {
           assert_operator("thing", :==, "thing", "message")
@@ -915,6 +994,18 @@ EOM
         }
       end
 
+      def test_assert_not_operator
+        check_nothing_fails {
+          assert_not_operator("thing", :==, "Thing", "message")
+        }
+        check_fail(%Q{<42>\ngiven as the operator for #assert_not_operator must be a Symbol or #respond_to?(:to_str).}) do
+          assert_not_operator("thing", 42, "message")
+        end
+        check_fail(%Q{message.\n<0> expected to not be\n==\n<0.0>.}) {
+          assert_not_operator(0, :==, 0.0, "message")
+        }
+      end
+
       def test_assert_respond_to
         check_nothing_fails {
           assert_respond_to("thing", :to_s, "message")
@@ -1316,6 +1407,14 @@ EOM
         end
       end
 
+      def test_pass_block
+        check_nothing_fails do
+          assert do
+            true
+          end
+        end
+      end
+
       def test_fail_nil
         check_fail("<nil> is not true.") do
           assert(nil)
@@ -1344,6 +1443,14 @@ EOM
         end
       end
 
+      def test_fail_block
+        check_fail(//) do
+          assert do
+            0.odd?
+          end
+        end
+      end
+
       def test_error_invalid_message_true
         check_fail("assertion message must be String, Proc or " +
                     "Test::Unit::Assertions::AssertionMessage: " +
@@ -1355,6 +1462,33 @@ EOM
           end
         end
       end
+
+      def test_error_wrong_number_of_arguments
+        check_fail("wrong number of arguments (0 for 1..2)") do
+          begin
+            assert
+          rescue ArgumentError
+            raise AssertionFailedError, $!.message
+          end
+        end
+      end
+
+      class TestBlock < self
+        def test_with_message
+          if defined?(PowerAssert)
+            system_message = <<-MESSAGE
+              1 == 2
+MESSAGE
+          else
+            system_message = "<false> is not true."
+          end
+          check_fail("user message.\n#{system_message}") do
+            assert("user message") do
+              1 == 2
+            end
+          end
+        end
+      end
     end
 
     class TestRefute < TestCase