cairo 1.8.5-x86-mingw32 → 1.10.0-x86-mingw32

data/test-unit/test/collector/test_load.rb

@@ -1,333 +0,0 @@
-require 'tmpdir'
-require 'pathname'
-
-require 'test/unit'
-require 'test/unit/collector/load'
-
-class TestUnitCollectorLoad < Test::Unit::TestCase
-  def setup
-    @previous_descendants = Test::Unit::TestCase::DESCENDANTS.dup
-    Test::Unit::TestCase::DESCENDANTS.clear
-
-    @temporary_test_cases_module_name = "TempTestCases"
-    ::Object.const_set(@temporary_test_cases_module_name, Module.new)
-
-    @test_dir = Pathname(Dir.tmpdir) + "test-unit"
-    @test_dir.rmtree if @test_dir.exist?
-    @test_dir.mkpath
-  end
-
-  setup
-  def setup_top_level_test_cases
-    @test_case1 = @test_dir + "test_case1.rb"
-    @test_case2 = @test_dir + "test_case2.rb"
-    @no_load_test_case3 = @test_dir + "case3.rb"
-
-    @test_case1.open("w") do |test_case|
-      test_case.puts(<<-EOT)
-module #{@temporary_test_cases_module_name}
-  class TestCase1 < Test::Unit::TestCase
-    def test1_1
-    end
-
-    def test1_2
-    end
-  end
-end
-EOT
-    end
-
-    @test_case2.open("w") do |test_case|
-      test_case.puts(<<-EOT)
-module #{@temporary_test_cases_module_name}
-  class TestCase2 < Test::Unit::TestCase
-    def test2
-    end
-  end
-end
-EOT
-    end
-
-    @no_load_test_case3.open("w") do |test_case|
-      test_case.puts(<<-EOT)
-module #{@temporary_test_cases_module_name}
-  class NoLoadTestCase3 < Test::Unit::TestCase
-    def test3
-    end
-  end
-end
-EOT
-    end
-  end
-
-  setup
-  def setup_sub_level_test_cases
-    @sub_test_dir = @test_dir + "sub"
-    @sub_test_dir.mkpath
-
-    @sub_test_case4 = @sub_test_dir + "test_case4.rb"
-    @no_load_sub_test_case5 = @sub_test_dir + "case5.rb"
-    @sub_test_case6 = @sub_test_dir + "test_case6.rb"
-
-    @sub_test_case4.open("w") do |test_case|
-      test_case.puts(<<-EOT)
-module #{@temporary_test_cases_module_name}
-  class SubTestCase4 < Test::Unit::TestCase
-    def test4_1
-    end
-
-    def test4_2
-    end
-  end
-end
-EOT
-    end
-
-    @no_load_sub_test_case5.open("w") do |test_case|
-      test_case.puts(<<-EOT)
-module #{@temporary_test_cases_module_name}
-  class NoLoadSubTestCase5 < Test::Unit::TestCase
-    def test5_1
-    end
-
-    def test5_2
-    end
-  end
-end
-EOT
-    end
-
-    @sub_test_case6.open("w") do |test_case|
-      test_case.puts(<<-EOT)
-module #{@temporary_test_cases_module_name}
-  class SubTestCase6 < Test::Unit::TestCase
-    def test6
-    end
-  end
-end
-EOT
-    end
-  end
-
-  setup
-  def setup_sub_level_test_cases2
-    @sub2_test_dir = @test_dir + "sub2"
-    @sub2_test_dir.mkpath
-
-    @no_load_sub2_test_case7 = @sub2_test_dir + "case7.rb"
-    @sub2_test_case8 = @sub2_test_dir + "test_case8.rb"
-    @sub2_test_case9 = @sub2_test_dir + "test_case9.rb"
-
-    @no_load_sub2_test_case7.open("w") do |test_case|
-      test_case.puts(<<-EOT)
-module #{@temporary_test_cases_module_name}
-  class NoLoadSub2TestCase7 < Test::Unit::TestCase
-    def test7_1
-    end
-
-    def test7_2
-    end
-  end
-end
-EOT
-    end
-
-    @sub2_test_case8.open("w") do |test_case|
-      test_case.puts(<<-EOT)
-module #{@temporary_test_cases_module_name}
-  class Sub2TestCase8 < Test::Unit::TestCase
-    def test8_1
-    end
-
-    def test8_2
-    end
-  end
-end
-EOT
-    end
-
-    @sub2_test_case9.open("w") do |test_case|
-      test_case.puts(<<-EOT)
-module #{@temporary_test_cases_module_name}
-  class Sub2TestCase9 < Test::Unit::TestCase
-    def test9
-    end
-  end
-end
-EOT
-    end
-  end
-
-  setup
-  def setup_svn_test_cases
-    @svn_test_dir = @test_dir + ".svn"
-    @svn_test_dir.mkpath
-
-    @svn_test_case10 = @svn_test_dir + "test_case10.rb"
-
-    @svn_test_case10.open("w") do |test_case|
-      test_case.puts(<<-EOT)
-module #{@temporary_test_cases_module_name}
-  class SvnTestCase10 < Test::Unit::TestCase
-    def test7
-    end
-  end
-end
-EOT
-    end
-  end
-
-  setup
-  def setup_sub_cvs_test_cases
-    @sub_cvs_test_dir = @sub_test_dir + "CVS"
-    @sub_cvs_test_dir.mkpath
-
-    @sub_cvs_test_case11 = @sub_cvs_test_dir + "test_case11.rb"
-
-    @sub_cvs_test_case11.open("w") do |test_case|
-      test_case.puts(<<-EOT)
-module #{@temporary_test_cases_module_name}
-  class SubCVSTestCase11 < Test::Unit::TestCase
-    def test11
-    end
-  end
-end
-EOT
-    end
-  end
-
-  def teardown
-    @test_dir.rmtree if @test_dir.exist?
-    ::Object.send(:remove_const, @temporary_test_cases_module_name)
-    Test::Unit::TestCase::DESCENDANTS.replace(@previous_descendants)
-  end
-
-  def test_simple_collect
-    assert_collect([:suite, {:name => @sub_test_dir.basename.to_s},
-                    [:suite, {:name => _test_case_name("SubTestCase4")},
-                     [:test, {:name => "test4_1"}],
-                     [:test, {:name => "test4_2"}]],
-                    [:suite, {:name => _test_case_name("SubTestCase6")},
-                     [:test, {:name => "test6"}]]],
-                   @sub_test_dir.to_s)
-  end
-
-  def test_multilevel_collect
-    assert_collect([:suite, {:name => "."},
-                    [:suite, {:name => _test_case_name("TestCase1")},
-                     [:test, {:name => "test1_1"}],
-                     [:test, {:name => "test1_2"}]],
-                    [:suite, {:name => _test_case_name("TestCase2")},
-                     [:test, {:name => "test2"}]],
-                    [:suite, {:name => @sub_test_dir.basename.to_s},
-                     [:suite, {:name => _test_case_name("SubTestCase4")},
-                      [:test, {:name => "test4_1"}],
-                      [:test, {:name => "test4_2"}]],
-                     [:suite, {:name => _test_case_name("SubTestCase6")},
-                      [:test, {:name => "test6"}]]],
-                   [:suite, {:name => @sub2_test_dir.basename.to_s},
-                     [:suite, {:name => _test_case_name("Sub2TestCase8")},
-                      [:test, {:name => "test8_1"}],
-                      [:test, {:name => "test8_2"}]],
-                     [:suite, {:name => _test_case_name("Sub2TestCase9")},
-                      [:test, {:name => "test9"}]]]])
-  end
-
-  def test_collect_file
-    assert_collect([:suite, {:name => @test_case1.basename.to_s},
-                    [:suite, {:name => _test_case_name("TestCase1")},
-                     [:test, {:name => "test1_1"}],
-                     [:test, {:name => "test1_2"}]]],
-                   @test_case1.to_s)
-
-    assert_collect([:suite, {:name => @no_load_sub_test_case5.basename.to_s},
-                    [:suite, {:name => _test_case_name("NoLoadSubTestCase5")},
-                     [:test, {:name => "test5_1"}],
-                     [:test, {:name => "test5_2"}]]],
-                   @no_load_sub_test_case5.to_s)
-  end
-
-  def test_nil_pattern
-    assert_collect([:suite, {:name => @sub_test_dir.basename.to_s},
-                    [:suite, {:name => _test_case_name("NoLoadSubTestCase5")},
-                     [:test, {:name => "test5_1"}],
-                     [:test, {:name => "test5_2"}]],
-                    [:suite, {:name => _test_case_name("SubTestCase4")},
-                     [:test, {:name => "test4_1"}],
-                     [:test, {:name => "test4_2"}]],
-                    [:suite, {:name => _test_case_name("SubTestCase6")},
-                     [:test, {:name => "test6"}]]],
-                   @sub_test_dir.to_s) do |collector|
-      collector.patterns.clear
-    end
-  end
-
-  def test_filtering
-    assert_collect([:suite, {:name => "."},
-                    [:suite, {:name => _test_case_name("TestCase1")},
-                     [:test, {:name => "test1_1"}],
-                     [:test, {:name => "test1_2"}]]]) do |collector|
-      collector.filter = Proc.new do |test|
-        not /\Atest1/.match(test.method_name).nil?
-      end
-    end
-  end
-
-  def test_collect_multi
-    test_dirs = [@sub_test_dir.to_s, @sub2_test_dir.to_s]
-    assert_collect([:suite, {:name => "[#{test_dirs.join(', ')}]"},
-                    [:suite, {:name => @sub_test_dir.basename.to_s},
-                     [:suite, {:name => _test_case_name("SubTestCase4")},
-                      [:test, {:name => "test4_1"}],
-                      [:test, {:name => "test4_2"}]],
-                     [:suite, {:name => _test_case_name("SubTestCase6")},
-                      [:test, {:name => "test6"}]]],
-                   [:suite, {:name => @sub2_test_dir.basename.to_s},
-                     [:suite, {:name => _test_case_name("Sub2TestCase8")},
-                      [:test, {:name => "test8_1"}],
-                      [:test, {:name => "test8_2"}]],
-                     [:suite, {:name => _test_case_name("Sub2TestCase9")},
-                      [:test, {:name => "test9"}]]]],
-                   *test_dirs)
-  end
-
-  private
-  def assert_collect(expected, *collect_args)
-    keep_required_files do
-      Dir.chdir(@test_dir.to_s) do
-        collector = Test::Unit::Collector::Load.new
-        yield(collector) if block_given?
-        actual = inspect_test_object(collector.send(:collect, *collect_args))
-        assert_equal(expected, actual)
-      end
-    end
-  end
-
-  def keep_required_files
-    required_files = $".dup
-    yield
-  ensure
-    $".replace(required_files)
-  end
-
-  def _test_case_name(test_case_class_name)
-    "#{@temporary_test_cases_module_name}::#{test_case_class_name}"
-  end
-
-  def inspect_test_object(test_object)
-    return nil if test_object.nil?
-    case test_object
-    when Test::Unit::TestSuite
-      sub_tests = test_object.tests.collect do |test|
-        inspect_test_object(test)
-      end.sort_by do |type, attributes, *children|
-        attributes[:name]
-      end
-      [:suite, {:name => test_object.name}, *sub_tests]
-    when Test::Unit::TestCase
-      [:test, {:name => test_object.method_name}]
-    else
-      raise "unexpected test object: #{test_object.inspect}"
-    end
-  end
-end

data/test-unit/test/collector/test_objectspace.rb

@@ -1,98 +0,0 @@
-# Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
-# License:: Ruby license.
-
-require 'test/unit'
-require 'test/unit/collector/objectspace'
-
-module Test
-  module Unit
-    module Collector
-      class TC_ObjectSpace < TestCase
-        def setup
-          @tc1 = Class.new(TestCase) do
-            def self.name
-              "tc_1"
-            end
-            def test_1
-            end
-            def test_2
-            end
-          end
-
-          @tc2 = Class.new(TestCase) do
-            def self.name
-              "tc_2"
-            end
-            def test_0
-            end
-          end
-
-          @no_tc = Class.new do
-            def test_4
-            end
-          end
- 
-          @object_space = {Class => [@tc1, @tc2, @no_tc], String => ['']}
-          def @object_space.each_object(type)
-            self[type].each{|item| yield(item) }
-          end
-
-          @c = ObjectSpace.new(@object_space)
-        end
-
-        def full_suite(name=ObjectSpace::NAME)
-          expected = TestSuite.new(name)
-          expected << (TestSuite.new(@tc1.name) << @tc1.new('test_1') << @tc1.new('test_2'))
-          expected << (TestSuite.new(@tc2.name) << @tc2.new('test_0'))
-        end
-
-        def empty_suite
-          TestSuite.new(ObjectSpace::NAME)
-        end
-        
-        def test_basic_collection
-          assert_equal(full_suite("name"), @c.collect("name"))
-
-          @c.filter = []
-          assert_equal(full_suite("name"), @c.collect("name"))
-        end
-        
-        def test_filtered_collection
-          @c.filter = proc{false}
-          assert_equal(empty_suite, @c.collect)
-
-          @c.filter = proc{true}
-          assert_equal(full_suite, @c.collect)
-
-          @c.filter = proc{nil}
-          assert_equal(full_suite, @c.collect)
-
-          @c.filter = [proc{false}, proc{true}]
-          assert_equal(empty_suite, @c.collect)
-
-          @c.filter = [proc{true}, proc{false}]
-          assert_equal(full_suite, @c.collect)
-
-          @c.filter = [proc{nil}, proc{false}]
-          assert_equal(empty_suite, @c.collect)
-          
-          @c.filter = [proc{nil}, proc{true}]
-          assert_equal(full_suite, @c.collect)
-          
-          expected = TestSuite.new(ObjectSpace::NAME)
-          expected << (TestSuite.new(@tc1.name) << @tc1.new('test_1'))
-          expected << (TestSuite.new(@tc2.name) << @tc2.new('test_0'))
-          @c.filter = proc{|test| ['test_1', 'test_0'].include?(test.method_name)}
-          assert_equal(expected, @c.collect)
-
-          expected = TestSuite.new(ObjectSpace::NAME)
-          expected << (TestSuite.new(@tc1.name) << @tc1.new('test_1'))
-          expected << (TestSuite.new(@tc2.name) << @tc2.new('test_0'))
-          @c.filter = [proc{|t| t.method_name == 'test_1' ? true : nil}, proc{|t| t.method_name == 'test_0' ? true : nil}, proc{false}]
-          assert_equal(expected, @c.collect)
-        end
-      end
-    end
-  end
-end

data/test-unit/test/run-test.rb

@@ -1,13 +0,0 @@
-#!/usr/bin/env ruby
-
-$VERBOSE = true
-
-base_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
-lib_dir = File.join(base_dir, "lib")
-test_dir = File.join(base_dir, "test")
-
-$LOAD_PATH.unshift(lib_dir)
-
-require 'test/unit'
-
-exit Test::Unit::AutoRunner.run(true, test_dir)

data/test-unit/test/test_assertions.rb

@@ -1,693 +0,0 @@
-# Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
-# License:: Ruby license.
-
-require 'test/unit'
-
-module Test
-  module Unit
-    class TC_Assertions < TestCase
-      def check(value, message="")
-        add_assertion
-        raise AssertionFailedError.new(message) unless value
-      end
-
-      def check_assertions(expect_fail, expected_message="",
-                           return_value_expected=false)
-        @actual_assertion_count = 0
-        failed = true
-        actual_message = nil
-        @catch_assertions = true
-        return_value = nil
-        begin
-          return_value = yield
-          failed = false
-        rescue AssertionFailedError => error
-          actual_message = error.message
-        end
-        @catch_assertions = false
-
-        if expect_fail
-          message = "Should have failed, but didn't"
-        else
-          message = "Should not have failed, but did with message\n" +
-            "<#{actual_message}>"
-        end
-        check(expect_fail == failed, message)
-
-        message = "Should have made one assertion but made\n" +
-          "<#{@actual_assertion_count}>"
-        check(1 == @actual_assertion_count, message)
-
-        if expect_fail
-          case expected_message
-          when String
-            check(actual_message == expected_message,
-                  "Should have the correct message.\n" +
-                  "<#{expected_message.inspect}> expected but was\n" +
-                  "<#{actual_message.inspect}>")
-          when Regexp
-            check(actual_message =~ expected_message,
-                  "The message should match correctly.\n" +
-                  "</#{expected_message.source}/> expected to match\n" +
-                  "<#{actual_message.inspect}>")
-          else
-            check(false,
-                  "Incorrect expected message type in assert_nothing_failed")
-          end
-        else
-          if return_value_expected
-            check(!return_value.nil?, "Should return a value")
-          else
-            check(return_value.nil?,
-                  "Should not return a value but returned <#{return_value}>")
-          end
-        end
-
-        return_value
-      end
-
-      def check_nothing_fails(return_value_expected=false, &proc)
-        check_assertions(false, "", return_value_expected, &proc)
-      end
-
-      def check_fails(expected_message="", &proc)
-        check_assertions(true, expected_message, &proc)
-      end
-
-      def inspect_tag(tag)
-        begin
-          throw tag
-        rescue NameError
-          tag.to_s.inspect
-        rescue ArgumentError
-          tag.inspect
-        end
-      end
-
-      def test_assert_block
-        check_nothing_fails {
-          assert_block {true}
-        }
-        check_nothing_fails {
-          assert_block("successful assert_block") {true}
-        }
-        check_nothing_fails {
-          assert_block("successful assert_block") {true}
-        }
-        check_fails("assert_block failed.") {
-          assert_block {false}
-        }
-        check_fails("failed assert_block") {
-          assert_block("failed assert_block") {false}
-        }
-      end
-      
-      def test_assert
-        check_nothing_fails{assert("a")}
-        check_nothing_fails{assert(true)}
-        check_nothing_fails{assert(true, "successful assert")}
-        check_fails("<nil> is not true."){assert(nil)}
-        check_fails("<false> is not true."){assert(false)}
-        check_fails("failed assert.\n<false> is not true."){assert(false, "failed assert")}
-      end
-      
-      def test_assert_equal
-        check_nothing_fails {
-          assert_equal("string1", "string1")
-        }
-        check_nothing_fails {
-          assert_equal( "string1", "string1", "successful assert_equal")
-        }
-        check_nothing_fails {
-          assert_equal("string1", "string1", "successful assert_equal")
-        }
-
-        message = <<-EOM.chomp
-<"string1"> expected but was
-<"string2">.
-
-diff:
-- string1
-?       ^
-+ string2
-?       ^
-EOM
-        check_fails(message) {
-          assert_equal("string1", "string2")
-        }
-
-        message = <<-EOM.chomp
-failed assert_equal.
-<"string1"> expected but was
-<"string2">.
-
-diff:
-- string1
-?       ^
-+ string2
-?       ^
-EOM
-        check_fails(message) {
-          assert_equal("string1", "string2", "failed assert_equal")
-        }
-
-        message = <<-EOM.chomp
-<"111111"> expected but was
-<111111>.
-
-diff:
-- "111111"
-? -      -
-+ 111111
-EOM
-        check_fails(message) do
-          assert_equal("111111", 111111)
-        end
-      end
-
-      def test_assert_equal_for_too_small_difference
-        message = <<-EOM.chomp
-<1> expected but was
-<2>.
-EOM
-        check_fails(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
-<#{now.inspect}> expected but was
-<#{now.inspect}>.
-EOM
-        check_fails(message) do
-          assert_equal(now, now_without_usec)
-        end
-      end
-
-      def test_assert_equal_with_multi_lines_result
-        message = <<-EOM.chomp
-<#{"a\nb".inspect}> expected but was
-<#{"x".inspect}>.
-
-diff:
-+ x
-- a
-- b
-EOM
-        check_fails(message) do
-          assert_equal("a\nb", "x")
-        end
-      end
-
-      def test_assert_raise
-        return_value = nil
-        check_nothing_fails(true) {
-          return_value = assert_raise(RuntimeError) {
-            raise "Error"
-          }
-        }
-        check(return_value.kind_of?(Exception), "Should have returned the exception from a successful assert_raise")
-        check(return_value.message == "Error", "Should have returned the correct exception from a successful assert_raise")
-        check_nothing_fails(true) {
-          assert_raise(ArgumentError, "successful assert_raise") {
-            raise ArgumentError.new("Error")
-          }
-        }
-        check_nothing_fails(true) {
-          assert_raise(RuntimeError) {
-            raise "Error"
-          }
-        }
-        check_nothing_fails(true) {
-          assert_raise(RuntimeError, "successful assert_raise") {
-            raise "Error"
-          }
-        }
-        check_fails("<RuntimeError> exception expected but none was thrown.") {
-          assert_raise(RuntimeError) {
-            1 + 1
-          }
-        }
-        check_fails(%r{\Afailed assert_raise.\n<ArgumentError> exception expected but was\nClass: <RuntimeError>\nMessage: <"Error">\n---Backtrace---\n.+\n---------------\Z}m) {
-          assert_raise(ArgumentError, "failed assert_raise") {
-            raise "Error"
-          }
-        }
-        check_fails("Should expect a class of exception, Object.\n<false> is not true.") {
-          assert_nothing_raised(Object) {
-            1 + 1
-          }
-        }
-
-        exceptions = [ArgumentError, TypeError]
-        modules = [Math, Comparable]
-        rescues = exceptions + modules
-        exceptions.each do |exc|
-          check_nothing_fails(true) {
-            return_value = assert_raise(*rescues) {
-              raise exc, "Error"
-            }
-          }
-          check(return_value.instance_of?(exc), "Should have returned #{exc} but was #{return_value.class}")
-          check(return_value.message == "Error", "Should have returned the correct exception from a successful assert_raise")
-        end
-        modules.each do |mod|
-          check_nothing_fails(true) {
-            return_value = assert_raise(*rescues) {
-              raise Exception.new("Error").extend(mod)
-            }
-          }
-          check(mod === return_value, "Should have returned #{mod}")
-          check(return_value.message == "Error", "Should have returned the correct exception from a successful assert_raise")
-        end
-        check_fails("<[ArgumentError, TypeError, Math, Comparable]> exception expected but none was thrown.") {
-          assert_raise(*rescues) {
-            1 + 1
-          }
-        }
-        check_fails(%r{\Afailed assert_raise.
-<\[ArgumentError, TypeError\]> exception expected but was
-Class: <RuntimeError>
-Message: <"Error">
----Backtrace---
-.+
----------------\Z}m) {
-          assert_raise(ArgumentError, TypeError, "failed assert_raise") {
-            raise "Error"
-          }
-        }
-      end
-      
-      def test_assert_instance_of
-        check_nothing_fails {
-          assert_instance_of(String, "string")
-        }
-        check_nothing_fails {
-          assert_instance_of(String, "string", "successful assert_instance_of")
-        }
-        check_nothing_fails {
-          assert_instance_of(String, "string", "successful assert_instance_of")
-        }
-        check_fails(%Q{<"string"> expected to be an instance of\n<Hash> but was\n<String>.}) {
-          assert_instance_of(Hash, "string")
-        }
-        check_fails(%Q{failed assert_instance_of.\n<"string"> expected to be an instance of\n<Hash> but was\n<String>.}) {
-          assert_instance_of(Hash, "string", "failed assert_instance_of")
-        }
-      end
-      
-      def test_assert_nil
-        check_nothing_fails {
-          assert_nil(nil)
-        }
-        check_nothing_fails {
-          assert_nil(nil, "successful assert_nil")
-        }
-        check_nothing_fails {
-          assert_nil(nil, "successful assert_nil")
-        }
-        check_fails(%Q{<"string"> expected to be nil.}) {
-          assert_nil("string")
-        }
-        check_fails(%Q{failed assert_nil.\n<"string"> expected to be nil.}) {
-          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_fails("<nil> expected to not be nil."){assert_not_nil(nil)}
-        check_fails("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)
-        }
-        check_nothing_fails {
-          assert_kind_of(Object, "string", "successful assert_kind_of")
-        }
-        check_nothing_fails {
-          assert_kind_of(Object, "string", "successful assert_kind_of")
-        }
-        check_nothing_fails {
-          assert_kind_of(Comparable, 1)
-        }
-        check_fails(%Q{<"string">\nexpected to be kind_of?\n<Class> but was\n<String>.}) {
-          assert_kind_of(Class, "string")
-        }
-        check_fails(%Q{failed assert_kind_of.\n<"string">\nexpected to be kind_of?\n<Class> but was\n<String>.}) {
-          assert_kind_of(Class, "string", "failed assert_kind_of")
-        }
-      end
-      
-      def test_assert_match
-        check_nothing_fails {
-          assert_match(/strin./, "string")
-        }
-        check_nothing_fails {
-          assert_match("strin", "string")
-        }
-        check_nothing_fails {
-          assert_match(/strin./, "string", "successful assert_match")
-        }
-        check_nothing_fails {
-          assert_match(/strin./, "string", "successful assert_match")
-        }
-        check_fails(%Q{<"string"> expected to be =~\n</slin./>.}) {
-          assert_match(/slin./, "string")
-        }
-        check_fails(%Q{<"string"> expected to be =~\n</strin\\./>.}) {
-          assert_match("strin.", "string")
-        }
-        check_fails(%Q{failed assert_match.\n<"string"> expected to be =~\n</slin./>.}) {
-          assert_match(/slin./, "string", "failed assert_match")
-        }
-      end
-      
-      def test_assert_same
-        thing = "thing"
-        check_nothing_fails {
-          assert_same(thing, thing)
-        }
-        check_nothing_fails {
-          assert_same(thing, thing, "successful assert_same")
-        }
-        check_nothing_fails {
-          assert_same(thing, thing, "successful assert_same")
-        }
-        thing2 = "thing"
-        check_fails(%Q{<"thing">\nwith id <#{thing.__id__}> expected to be equal? to\n<"thing">\nwith id <#{thing2.__id__}>.}) {
-          assert_same(thing, thing2)
-        }
-        check_fails(%Q{failed assert_same.\n<"thing">\nwith id <#{thing.__id__}> expected to be equal? to\n<"thing">\nwith id <#{thing2.__id__}>.}) {
-          assert_same(thing, thing2, "failed assert_same")
-        }
-      end
-      
-      def test_assert_nothing_raised
-        check_nothing_fails {
-          assert_nothing_raised {
-            1 + 1
-          }
-        }
-        check_nothing_fails {
-          assert_nothing_raised("successful assert_nothing_raised") {
-            1 + 1
-          }
-        }
-        check_nothing_fails {
-          assert_nothing_raised("successful assert_nothing_raised") {
-            1 + 1
-          }
-        }
-        check_nothing_fails {
-          begin
-            assert_nothing_raised(RuntimeError, StandardError, Comparable, "successful assert_nothing_raised") {
-              raise ZeroDivisionError.new("ArgumentError")
-            }
-          rescue ZeroDivisionError
-          end
-        }
-        check_fails("Should expect a class of exception, Object.\n<false> is not true.") {
-          assert_nothing_raised(Object) {
-            1 + 1
-          }
-        }
-        check_fails(%r{\AException raised:\nClass: <RuntimeError>\nMessage: <"Error">\n---Backtrace---\n.+\n---------------\Z}m) {
-          assert_nothing_raised {
-            raise "Error"
-          }
-        }
-        check_fails(%r{\Afailed assert_nothing_raised\.\nException raised:\nClass: <RuntimeError>\nMessage: <"Error">\n---Backtrace---\n.+\n---------------\Z}m) {
-          assert_nothing_raised("failed assert_nothing_raised") {
-            raise "Error"
-          }
-        }
-        check_fails(%r{\AException raised:\nClass: <RuntimeError>\nMessage: <"Error">\n---Backtrace---\n.+\n---------------\Z}m) {
-          assert_nothing_raised(StandardError, RuntimeError) {
-            raise "Error"
-          }
-        }
-        check_fails("Failure.") do
-          assert_nothing_raised do
-            flunk("Failure")
-          end
-        end
-      end
-      
-      def test_flunk
-        check_fails("Flunked.") {
-          flunk
-        }
-        check_fails("flunk message.") {
-          flunk("flunk message")
-        }
-      end
-      
-      def test_assert_not_same
-        thing = "thing"
-        thing2 = "thing"
-        check_nothing_fails {
-          assert_not_same(thing, thing2)
-        }
-        check_nothing_fails {
-          assert_not_same(thing, thing2, "message")
-        }
-        check_fails(%Q{<"thing">\nwith id <#{thing.__id__}> expected to not be equal? to\n<"thing">\nwith id <#{thing.__id__}>.}) {
-          assert_not_same(thing, thing)
-        }
-        check_fails(%Q{message.\n<"thing">\nwith id <#{thing.__id__}> expected to not be equal? to\n<"thing">\nwith id <#{thing.__id__}>.}) {
-          assert_not_same(thing, thing, "message")
-        }
-      end
-      
-      def test_assert_not_equal
-        check_nothing_fails {
-          assert_not_equal("string1", "string2")
-        }
-        check_nothing_fails {
-          assert_not_equal("string1", "string2", "message")
-        }
-        check_fails(%Q{<"string"> expected to be != to\n<"string">.}) {
-          assert_not_equal("string", "string")
-        }
-        check_fails(%Q{message.\n<"string"> expected to be != to\n<"string">.}) {
-          assert_not_equal("string", "string", "message")
-        }
-      end
-      
-      def test_assert_no_match
-        check_nothing_fails{assert_no_match(/sling/, "string")}
-        check_nothing_fails{assert_no_match(/sling/, "string", "message")}
-        check_fails(%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
-          assert_no_match("asdf", "asdf")
-        end
-        check_fails(%Q{</string/> expected to not match\n<"string">.}) do
-          assert_no_match(/string/, "string")
-        end
-        check_fails(%Q{message.\n</string/> expected to not match\n<"string">.}) do
-          assert_no_match(/string/, "string", "message")
-        end
-      end
-      
-      def test_assert_throws
-        check_nothing_fails do
-          assert_throws(:thing, "message") do
-            throw :thing
-          end
-        end
-
-        tag = :thing2
-        check_fails("message.\n" +
-                    "<:thing> expected to be thrown but\n" +
-                    "<#{inspect_tag(tag)}> was thrown.") do
-          assert_throws(:thing, "message") do
-            throw :thing2
-          end
-        end
-        check_fails("message.\n" +
-                    "<:thing> should have been thrown.") do
-          assert_throws(:thing, "message") do
-            1 + 1
-          end
-        end
-      end
-      
-      def test_assert_nothing_thrown
-        check_nothing_fails do
-          assert_nothing_thrown("message") do
-            1 + 1
-          end
-        end
-
-        tag = :thing
-        inspected = inspect_tag(tag)
-        check_fails("message.\n" +
-                    "<#{inspected}> was thrown when nothing was expected.") do
-          assert_nothing_thrown("message") do
-            throw tag
-          end
-        end
-      end
-      
-      def test_assert_operator
-        check_nothing_fails {
-          assert_operator("thing", :==, "thing", "message")
-        }
-        check_fails(%Q{<0.15>\ngiven as the operator for #assert_operator must be a Symbol or #respond_to?(:to_str).}) do
-          assert_operator("thing", 0.15, "thing")
-        end
-        check_fails(%Q{message.\n<"thing1"> expected to be\n==\n<"thing2">.}) {
-          assert_operator("thing1", :==, "thing2", "message")
-        }
-      end
-      
-      def test_assert_respond_to
-        check_nothing_fails {
-          assert_respond_to("thing", :to_s, "message")
-        }
-        check_nothing_fails {
-          assert_respond_to("thing", "to_s", "message")
-        }
-        check_fails("<0.15>\ngiven as the method name argument to #assert_respond_to must be a Symbol or #respond_to?(:to_str).") {
-          assert_respond_to("thing", 0.15)
-        }
-        check_fails("message.\n<:symbol>\nof type <Symbol>\nexpected to respond_to?<:non_existent>.") {
-          assert_respond_to(:symbol, :non_existent, "message")
-        }
-      end
-      
-      def test_assert_in_delta
-        check_nothing_fails {
-          assert_in_delta(1.4, 1.4, 0)
-        }
-        check_nothing_fails {
-          assert_in_delta(0.5, 0.4, 0.1, "message")
-        }
-        check_nothing_fails {
-          float_thing = Object.new
-          def float_thing.to_f
-            0.2
-          end
-          assert_in_delta(0.1, float_thing, 0.1)
-        }
-        check_fails("message.\n<0.5> and\n<0.4> expected to be within\n<0.05> of each other.") {
-          assert_in_delta(0.5, 0.4, 0.05, "message")
-        }
-        check_fails(%r{The arguments must respond to to_f; the first float did not\.\n<.+>\nof type <Object>\nexpected to respond_to\?<:to_f>.}) {
-          assert_in_delta(Object.new, 0.4, 0.1)
-        }
-        check_fails("The delta should not be negative.\n<-0.1> expected to be\n>=\n<0.0>.") {
-          assert_in_delta(0.5, 0.4, -0.1, "message")
-        }
-      end
-      
-      def test_assert_send
-        object = Object.new
-        class << object
-          private
-          def return_argument(argument, bogus)
-            return argument
-          end
-        end
-        check_nothing_fails {
-          assert_send([object, :return_argument, true, "bogus"], "message")
-        }
-        check_fails(%r{\Amessage\.\n<.+> expected to respond to\n<return_argument\(\[false, "bogus"\]\)> with a true value.\Z}) {
-          assert_send([object, :return_argument, false, "bogus"], "message")
-        }
-      end
-      
-      def test_condition_invariant
-        object = Object.new
-        def object.inspect
-          @changed = true
-        end
-        def object.==(other)
-          @changed ||= false
-          return (!@changed)
-        end
-        check_nothing_fails do
-          assert_equal(object, object, "message")
-        end
-      end
-
-      def test_assert_boolean
-        check_nothing_fails do
-          assert_boolean(true)
-        end
-        check_nothing_fails do
-          assert_boolean(false)
-        end
-
-        check_fails("<true> or <false> expected but was\n<1>") do
-          assert_boolean(1)
-        end
-
-        check_fails("<true> or <false> expected but was\n<nil>") do
-          assert_boolean(nil)
-        end
-
-        check_fails("message.\n<true> or <false> expected but was\n<\"XXX\">") do
-          assert_boolean("XXX", "message")
-        end
-      end
-
-      def test_assert_true
-        check_nothing_fails do
-          assert_true(true)
-        end
-
-        check_fails("<true> expected but was\n<false>") do
-          assert_true(false)
-        end
-
-        check_fails("<true> expected but was\n<1>") do
-          assert_true(1)
-        end
-
-        check_fails("message.\n<true> expected but was\n<nil>") do
-          assert_true(nil, "message")
-        end
-      end
-
-      def test_assert_false
-        check_nothing_fails do
-          assert_false(false)
-        end
-
-        check_fails("<false> expected but was\n<true>") do
-          assert_false(true)
-        end
-
-        check_fails("<false> expected but was\n<nil>") do
-          assert_false(nil)
-        end
-
-        check_fails("message.\n<false> expected but was\n<:false>") do
-          assert_false(:false, "message")
-        end
-      end
-
-      def add_failure(message, location=caller)
-        unless @catch_assertions
-          super
-        end
-      end
-
-      def add_assertion
-        if @catch_assertions
-          @actual_assertion_count += 1
-        else
-          super
-        end
-      end
-    end
-  end
-end