win32-api 1.4.8 → 1.9.1

data/vendor/bundle/ruby/2.5.0/gems/test-unit-3.3.5/test/fixtures/header-label.csv

@@ -0,0 +1,3 @@
+label,expected,label
+upper case,HELLO,HELLO
+lower case,Hello,hello

data/vendor/bundle/ruby/2.5.0/gems/test-unit-3.3.5/test/fixtures/header-label.tsv

@@ -0,0 +1,3 @@
+label	expected	label
+upper case	HELLO	HELLO
+lower case	Hello	hello

data/vendor/bundle/ruby/2.5.0/gems/test-unit-3.3.5/test/fixtures/header.csv

@@ -0,0 +1,3 @@
+label,expected,target
+empty string,true,""
+plain string,false,hello

data/vendor/bundle/ruby/2.5.0/gems/test-unit-3.3.5/test/fixtures/header.tsv

@@ -0,0 +1,3 @@
+label	expected	target
+empty string	true	""
+plain string	false	hello

data/vendor/bundle/ruby/2.5.0/gems/test-unit-3.3.5/test/fixtures/no-header.csv

@@ -0,0 +1,2 @@
+empty string,true,""
+plain string,false,hello

data/vendor/bundle/ruby/2.5.0/gems/test-unit-3.3.5/test/fixtures/no-header.tsv

@@ -0,0 +1,2 @@
+empty string	true	""
+plain string	false	hello

data/vendor/bundle/ruby/2.5.0/gems/test-unit-3.3.5/test/fixtures/plus.csv

@@ -0,0 +1,3 @@
+label,expected,augend,addend
+positive positive,4,3,1
+positive negative,-1,1,-2

data/vendor/bundle/ruby/2.5.0/gems/test-unit-3.3.5/test/run-test.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+$VERBOSE = true
+
+$KCODE = "utf8" unless "".respond_to?(:encoding)
+
+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'
+
+test_unit_notify_base_dir = File.join(base_dir, "..", "test-unit-notify")
+test_unit_notify_base_dir = File.expand_path(test_unit_notify_base_dir)
+if File.exist?(test_unit_notify_base_dir)
+  $LOAD_PATH.unshift(File.join(test_unit_notify_base_dir, "lib"))
+  require 'test/unit/notify'
+end
+
+exit Test::Unit::AutoRunner.run(true, test_dir)

data/vendor/bundle/ruby/2.5.0/gems/test-unit-3.3.5/test/test-assertions.rb

@@ -0,0 +1,2187 @@
+# -*- coding: utf-8 -*-
+#
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. 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
+    module AssertionCheckable
+      include TestUnitTestUtil
+
+      private
+      def check(value, message="")
+        add_assertion
+        raise AssertionFailedError.new(message) unless value
+      end
+
+      def check_assertions(expect_fail, options={})
+        expected_message = options[:expected_message]
+        actual_message_normalizer = options[:actual_message_normalizer]
+        return_value_expected = options[:return_value_expected]
+        @actual_assertion_count = 0
+        failed = true
+        actual_message = nil
+        @catch_assertions = true
+        return_value = nil
+        begin
+          return_value = yield
+          failed = false
+        rescue AssertionFailedError => error
+          return_value = 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
+          if actual_message_normalizer
+            actual_message = actual_message_normalizer.call(actual_message)
+          end
+          case expected_message
+          when String
+            check(expected_message == actual_message,
+                  "Should have the correct message.\n" +
+                  "<#{expected_message.inspect}> expected but was\n" +
+                  "<#{actual_message.inspect}>")
+          when Regexp
+            check(expected_message =~ actual_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
+          case return_value_expected
+          when :dont_care
+            # do nothing
+          when true
+            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,
+                         {:expected_message => nil,
+                          :return_value_expected => return_value_expected},
+                         &proc)
+      end
+
+      def check_fail(expected_message, options={}, &proc)
+        check_assertions(true,
+                         options.merge(:expected_message => expected_message),
+                         &proc)
+      end
+
+      def check_fail_exception(expected_message, options={}, &proc)
+        normalizer = lambda do |actual_message|
+          actual_message.gsub(/(^[^:\n]+:\d+:.+\n?)+\z/, "")
+        end
+        check_assertions(true,
+                         options.merge(:expected_message => expected_message,
+                                       :actual_message_normalizer => normalizer),
+                         &proc)
+      end
+
+      def inspect_tag(tag)
+        tag.inspect
+      end
+
+      def add_failure(message, location=caller, options=nil)
+        unless @catch_assertions
+          super
+        end
+      end
+
+      def add_assertion
+        if @catch_assertions
+          @actual_assertion_count += 1
+        else
+          super
+        end
+      end
+    end
+
+    class TestAssertions < TestCase
+      include AssertionCheckable
+
+      class TestAssertBlock < self
+        def test_pass_without_message
+          check_nothing_fails {
+            assert_block {true}
+          }
+        end
+
+        def test_pass_with_message
+          check_nothing_fails {
+            assert_block("successful assert_block") {true}
+          }
+        end
+
+        def test_failure_without_message
+          check_fail("assert_block failed.") {
+            assert_block {false}
+          }
+        end
+
+        def test_failure_with_message
+          check_fail("failed assert_block") {
+            assert_block("failed assert_block") {false}
+          }
+        end
+      end
+
+      class TestAssertEqual < self
+        class TestSuccess < self
+          def test_without_message
+            check_nothing_fails {
+              assert_equal("string1", "string1")
+            }
+          end
+
+          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">.
+
+diff:
+- string1
+?       ^
++ string2
+?       ^
+EOM
+            check_fail(message) {
+              assert_equal("string1", "string2")
+            }
+          end
+
+          def test_with_message
+            message = <<-EOM.chomp
+failed assert_equal.
+<"string1"> expected but was
+<"string2">.
+
+diff:
+- string1
+?       ^
++ string2
+?       ^
+EOM
+           check_fail(message) {
+             assert_equal("string1", "string2", "failed assert_equal")
+            }
+          end
+
+          def test_with_message_proc
+            message = <<-EOM.chomp
+failed assert_equal.
+<"string1"> expected but was
+<"string2">.
+
+diff:
+- string1
+?       ^
++ string2
+?       ^
+EOM
+           check_fail(message) do
+              assert_equal("string1", "string2", lambda {"failed assert_equal"})
+            end
+          end
+        end
+
+        class TestSystemMessage < self
+          def test_different_type
+            message = <<-EOM.chomp
+<"111111"> expected but was
+<111111>.
+
+diff:
+- "111111"
+? -      -
++ 111111
+EOM
+            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}">.
+
+diff:
+- #{expected}
+?  ^^^^^^^^^
++ #{actual}
+?  ^^^^^^^^^
+
+folded diff:
+- 012345678911234567892123456789312345678941234567895123456789612345678971234567
+?  ^^^^^^^^^
++ 000000000011234567892123456789312345678941234567895123456789612345678971234567
+?  ^^^^^^^^^
+  898123456789
+EOM
+            check_fail(message) do
+              assert_equal(expected, actual)
+            end
+          end
+
+          def test_too_small_difference
+            message = <<-EOM.chomp
+<1> expected but was
+<2>.
+EOM
+            check_fail(message) do
+              assert_equal(1, 2)
+            end
+          end
+
+          def test_same_inspected_objects
+            same_inspected_class = Class.new do
+              def inspect
+                "inspected"
+              end
+            end
+            object1 = same_inspected_class.new
+            object2 = same_inspected_class.new
+            message = <<-EOM.chomp
+<inspected> expected but was
+<inspected>.
+EOM
+            check_fail(message) do
+              assert_equal(object1, object2)
+            end
+          end
+
+          def test_multi_lines_result
+            message = <<-EOM.chomp
+<#{AssertionMessage.convert("a\nb")}> expected but was
+<#{AssertionMessage.convert("x")}>.
+
+diff:
++ x
+- a
+- b
+EOM
+            check_fail(message) do
+              assert_equal("a\nb", "x")
+            end
+          end
+
+          def test_large_string
+            message = <<-EOM.chomp
+<#{AssertionMessage.convert("a\n" + "x" * 997)}> expected but was
+<#{AssertionMessage.convert("x")}>.
+
+diff:
++ x
+- a
+- #{"x" * 997}
+
+folded diff:
++ x
+- a
+#{(["- " + ("x" * 78)] * 12).join("\n")}
+- #{"x" * 61}
+EOM
+            check_fail(message) do
+              assert_equal("a\n" + "x" * 997, "x")
+            end
+
+            message = <<-EOM.chomp
+<#{AssertionMessage.convert("a\n" + "x" * 998)}> expected but was
+<#{AssertionMessage.convert("x")}>.
+EOM
+            check_fail(message) do
+              assert_equal("a\n" + "x" * 998, "x")
+            end
+          end
+
+          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
+<#{AssertionMessage.convert("a\n" + "x" * 97)}> expected but was
+<#{AssertionMessage.convert("x")}>.
+
+diff:
++ x
+- a
+- #{"x" * 97}
+
+folded diff:
++ x
+- a
+#{(["- " + ("x" * 78)]).join("\n")}
+- #{"x" * 19}
+EOM
+              check_fail(message) do
+                assert_equal("a\n" + "x" * 97, "x")
+              end
+
+              message = <<-EOM.chomp
+<#{AssertionMessage.convert("a\n" + "x" * 98)}> expected but was
+<#{AssertionMessage.convert("x")}>.
+EOM
+              check_fail(message) do
+                assert_equal("a\n" + "x" * 98, "x")
+              end
+            ensure
+              ENV[key] = before_value
+            end
+          end
+
+          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
+
+          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
+
+          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"}>.
+
+diff:
+- {"followers"=>[{"followers"=>[{...}], "name"=>"Bob"}], "name"=>"Alice"}
+?                                       -----------------
++ {"followers"=>[{"followers"=>[{...}], "name"=>"Alice"}], "name"=>"Bob"}
+?                                                       +++++++++++++++++
+EOM
+            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
+
+      def test_assert_raise_success
+        return_value = nil
+        check_nothing_fails(true) do
+          return_value = assert_raise(RuntimeError) do
+            raise "Error"
+          end
+        end
+        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) do
+          assert_raise(ArgumentError, "successful assert_raise") do
+            raise ArgumentError.new("Error")
+          end
+        end
+
+        check_nothing_fails(true) do
+          assert_raise(RuntimeError) do
+            raise "Error"
+          end
+        end
+
+        check_nothing_fails(true) do
+          assert_raise(RuntimeError, "successful assert_raise") do
+            raise "Error"
+          end
+        end
+
+        check_nothing_fails(true) do
+          assert_raise do
+            raise Exception, "Any exception"
+          end
+        end
+      end
+
+      def test_assert_raise_fail
+        check_fail("<RuntimeError> exception was expected but none was thrown.") do
+          assert_raise(RuntimeError) do
+            1 + 1
+          end
+        end
+
+        message = <<-EOM.chomp
+failed assert_raise.
+<ArgumentError> exception expected but was
+<RuntimeError(<Error>)>.
+EOM
+        check_fail_exception(message) do
+          assert_raise(ArgumentError, "failed assert_raise") do
+            raise "Error"
+          end
+        end
+
+        message = <<-EOM
+<Object> must be a subclass of Exception, an object of Exception subclasses or a Module.
+EOM
+        check_fail(message.chomp) do
+          assert_nothing_raised(Object) do
+            1 + 1
+          end
+        end
+      end
+
+      def test_assert_raise_module
+        exceptions = [ArgumentError, TypeError]
+        modules = [Math, Comparable]
+        rescues = exceptions + modules
+
+        exceptions.each do |exc|
+          return_value = nil
+          check_nothing_fails(true) do
+            return_value = assert_raise(*rescues) do
+              raise exc, "Error"
+            end
+          end
+          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|
+          return_value = nil
+          check_nothing_fails(true) do
+            return_value = assert_raise(*rescues) do
+              raise Exception.new("Error").extend(mod)
+            end
+          end
+          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_fail("<[ArgumentError, TypeError, Math, Comparable]> exception " +
+                    "was expected but none was thrown.") do
+          assert_raise(*rescues) do
+            1 + 1
+          end
+        end
+
+        message = <<-EOM.chomp
+failed assert_raise.
+<[ArgumentError, TypeError]> exception expected but was
+<RuntimeError(<Error>)>.
+EOM
+        check_fail_exception(message) do
+          assert_raise(ArgumentError, TypeError, "failed assert_raise") do
+            raise "Error"
+          end
+        end
+      end
+
+      def test_assert_raise_instance
+        return_value = nil
+        check_nothing_fails(true) do
+          return_value = assert_raise(RuntimeError.new("Error")) do
+            raise "Error"
+          end
+        end
+        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")
+
+        message = <<-EOM.chomp
+<RuntimeError(<XXX>)> exception expected but was
+<RuntimeError(<Error>)>.
+
+diff:
+- RuntimeError(<XXX>)
+?               ^^^
++ RuntimeError(<Error>)
+?               ^^^^^
+EOM
+        check_fail_exception(message) do
+          return_value = assert_raise(RuntimeError.new("XXX")) do
+            raise "Error"
+          end
+        end
+
+        different_error_class = Class.new(StandardError)
+        message = <<-EOM.chomp
+<#{different_error_class.inspect}(<Error>)> exception expected but was
+<RuntimeError(<Error>)>.
+EOM
+        check_fail_exception(message) do
+          assert_raise(different_error_class.new("Error")) do
+            raise "Error"
+          end
+        end
+
+        different_error = different_error_class.new("Error")
+        def different_error.inspect
+          "DifferentError: \"Error\""
+        end
+        message = <<-EOM.chomp
+<DifferentError: "Error"> exception expected but was
+<RuntimeError(<Error>)>.
+EOM
+        check_fail_exception(message) do
+          assert_raise(different_error) do
+            raise "Error"
+          end
+        end
+
+        check_nothing_fails(true) do
+          assert_raise(different_error_class.new("Error"),
+                       RuntimeError.new("Error"),
+                       RuntimeError.new("XXX")) do
+            raise "Error"
+          end
+        end
+      end
+
+      def test_assert_raise_jruby
+        omit("For JRuby") unless Object.const_defined?(:Java)
+
+        exception = Java::JavaLang::StringIndexOutOfBoundsException
+
+        return_value = nil
+        check_nothing_fails(true) do
+          return_value = assert_raise(exception) do
+            Java::JavaLang::String.new("abc").char_at(4)
+          end
+        end
+        check(return_value.instance_of?(exception),
+              "Should have returned #{exception} but was #{return_value.class}")
+      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_fail(%Q{<"string"> was 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"> was 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([Class, NilClass], Array)
+        end
+        check_fail(%Q{<"string"> was expected to be instance_of?\n[<Class>, <NilClass>] but was\n<String>.}) do
+          assert_instance_of([Class, NilClass], "string")
+        end
+        check_fail(%Q{<Array> was expected to be instance_of?\n[<Module>, <NilClass>] but was\n<Class>.}) do
+          assert_instance_of([Module, NilClass], Array)
+        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"> was expected to not be instance_of?\n<String> but was.}) {
+          assert_not_instance_of(String, "string")
+        }
+        check_fail(%Q{failed assert.\n<"string"> was 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([Module, NilClass], Array)
+        end
+        check_fail(%Q{<Array> was expected to not be instance_of?\n[<Class>, <NilClass>] but was.}) do
+          assert_not_instance_of([Class, NilClass], Array)
+        end
+        check_fail(%Q{<"str"> was 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)
+        }
+        check_nothing_fails {
+          assert_nil(nil, "successful assert_nil")
+        }
+        check_nothing_fails {
+          assert_nil(nil, "successful assert_nil")
+        }
+        check_fail(%Q{<"string"> was expected to be nil.}) {
+          assert_nil("string")
+        }
+        check_fail(%Q{failed assert_nil.\n<"string"> was 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_fail("<nil> was expected to not be nil."){assert_not_nil(nil)}
+        check_fail("message.\n<nil> was 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(String, "string", "successful assert_kind_of")
+        }
+        check_nothing_fails {
+          assert_kind_of(Comparable, 1)
+        }
+        check_fail(%Q{<"string"> was expected to be kind_of?\n<Class> but was\n<String>.}) {
+          assert_kind_of(Class, "string")
+        }
+        check_fail(%Q{failed assert_kind_of.\n<"string"> was expected to be kind_of?\n<Class> but was\n<String>.}) {
+          assert_kind_of(Class, "string", "failed assert_kind_of")
+        }
+
+        check_nothing_fails do
+          assert_kind_of([Class, NilClass], Array)
+        end
+        check_fail(%Q{<"string"> was expected to be kind_of?\n[<Class>, <NilClass>] but was\n<String>.}) do
+          assert_kind_of([Class, NilClass], "string")
+        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> was 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"> was 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{<Array> was expected to not be kind_of?\n[<Class>, <NilClass>] but was.}) do
+          assert_not_kind_of([Class, NilClass], Array)
+        end
+      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_fail(%Q{</slin./> was expected to be =~\n<"string">.}) {
+          assert_match(/slin./, "string")
+        }
+        check_fail(%Q{</strin\\./> was expected to be =~\n<"string">.}) {
+          assert_match("strin.", "string")
+        }
+        check_fail(%Q{failed assert_match.\n</slin./> was expected to be =~\n<"string">.}) {
+          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.dup
+        check_fail(%Q{<"thing">\nwith id <#{thing.__id__}> was expected to be equal? to\n<"thing">\nwith id <#{thing2.__id__}>.}) {
+          assert_same(thing, thing2)
+        }
+        check_fail(%Q{failed assert_same.\n<"thing">\nwith id <#{thing.__id__}> was 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(:dont_care) {
+          assert_nothing_raised {
+            1 + 1
+          }
+        }
+        check_nothing_fails(:dont_care) {
+          assert_nothing_raised("successful assert_nothing_raised") {
+            1 + 1
+          }
+        }
+        check_nothing_fails(:dont_care) {
+          assert_nothing_raised("successful assert_nothing_raised") {
+            1 + 1
+          }
+        }
+        check_nothing_fails(:dont_care) {
+          begin
+            assert_nothing_raised(RuntimeError, StandardError, Comparable, "successful assert_nothing_raised") {
+              raise ZeroDivisionError.new("ArgumentError")
+            }
+          rescue ZeroDivisionError
+          end
+        }
+        expected_message =
+          "<Object> must be a subclass of Exception, " +
+          "an object of Exception subclasses or a Module."
+        check_fail(expected_message) {
+          assert_nothing_raised(Object) {
+            1 + 1
+          }
+        }
+        expected_message = <<-EOM.chomp
+Exception raised:
+RuntimeError(<Error>)
+EOM
+        check_fail_exception(expected_message) {
+          assert_nothing_raised {
+            raise "Error"
+          }
+        }
+        expected_message = <<-EOM.chomp
+failed assert_nothing_raised.
+Exception raised:
+RuntimeError(<Error>)
+EOM
+        check_fail_exception(expected_message) {
+          assert_nothing_raised("failed assert_nothing_raised") {
+            raise "Error"
+          }
+        }
+        expected_message = <<-EOM.chomp
+Exception raised:
+RuntimeError(<Error>)
+EOM
+        check_fail_exception(expected_message) {
+          assert_nothing_raised(StandardError, RuntimeError) {
+            raise "Error"
+          }
+        }
+        check_fail("Failure.") do
+          assert_nothing_raised do
+            flunk("Failure")
+          end
+        end
+      end
+
+      def test_flunk
+        check_fail("Flunked.") {
+          flunk
+        }
+        check_fail("flunk message.") {
+          flunk("flunk message")
+        }
+      end
+
+      def test_assert_not_same
+        thing = "thing"
+        thing2 = thing.dup
+        check_nothing_fails {
+          assert_not_same(thing, thing2)
+        }
+        check_nothing_fails {
+          assert_not_same(thing, thing2, "message")
+        }
+        check_fail(%Q{<"thing">\nwith id <#{thing.__id__}> was expected to not be equal? to\n<"thing">\nwith id <#{thing.__id__}>.}) {
+          assert_not_same(thing, thing)
+        }
+        check_fail(%Q{message.\n<"thing">\nwith id <#{thing.__id__}> was 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_fail(%Q{<"string"> was expected to be != to\n<"string">.}) {
+          assert_not_equal("string", "string")
+        }
+        check_fail(%Q{message.\n<"string"> was expected to be != to\n<"string">.}) {
+          assert_not_equal("string", "string", "message")
+        }
+      end
+
+      def test_assert_not_match_pass
+        check_nothing_fails do
+          assert_not_match(/sling/, "string")
+        end
+      end
+
+      def test_assert_not_match_pass_with_message
+        check_nothing_fails do
+          assert_not_match(/sling/, "string", "message")
+        end
+      end
+
+      def test_assert_not_match_fail_not_regexp
+        check_fail("<REGEXP> in assert_not_match(<REGEXP>, ...) " +
+                    "should be a Regexp.\n" +
+                    "<\"asdf\"> was expected to be instance_of?\n" +
+                    "<Regexp> but was\n" +
+                    "<String>.") do
+          assert_not_match("asdf", "asdf")
+        end
+      end
+
+      def test_assert_not_match_fail_match
+        check_fail("</string/> was expected to not match\n" +
+                    "<\"string\">.") do
+          assert_not_match(/string/, "string")
+        end
+      end
+
+      def test_assert_not_match_fail_match_with_message
+        check_fail("message.\n" +
+                    "</string/> was expected to not match\n" +
+                    "<\"string\">.") do
+          assert_not_match(/string/, "string", "message")
+        end
+      end
+
+      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"> was expected to be instance_of?\n<Regexp> but was\n<String>.}) do
+          assert_no_match("asdf", "asdf")
+        end
+        check_fail(%Q{</string/> was expected to not match\n<"string">.}) do
+          assert_no_match(/string/, "string")
+        end
+        check_fail(%Q{message.\n</string/> was expected to not match\n<"string">.}) do
+          assert_no_match(/string/, "string", "message")
+        end
+      end
+
+      def test_assert_throw
+        check_nothing_fails do
+          assert_throw(:thing, "message") do
+            throw :thing
+          end
+        end
+
+        tag = :thing2
+        check_fail("message.\n" +
+                    "<:thing> was expected to be thrown but\n" +
+                    "<#{inspect_tag(tag)}> was thrown.") do
+          assert_throw(:thing, "message") do
+            throw :thing2
+          end
+        end
+        check_fail("message.\n" +
+                    "<:thing> should have been thrown.") do
+          assert_throw(: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_fail("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_fail(%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_fail(%Q{message.\n<"thing1"> was expected to be\n==\n<"thing2">.}) {
+          assert_operator("thing1", :==, "thing2", "message")
+        }
+      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> was 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")
+        }
+        check_nothing_fails {
+          assert_respond_to("thing", "to_s", "message")
+        }
+        check_fail("<0.15>.kind_of?(Symbol) or\n" +
+                    "<0.15>.respond_to?(:to_str) expected") {
+          assert_respond_to("thing", 0.15)
+        }
+        check_fail("message.\n" +
+                    "<:symbol>.respond_to?(:nonexistence) expected\n" +
+                    "(Class: <Symbol>)") {
+          assert_respond_to(:symbol, :nonexistence, "message")
+        }
+      end
+
+      def test_assert_not_respond_to_pass_symbol
+        check_nothing_fails do
+          assert_not_respond_to("thing", :nonexistent, "message")
+        end
+      end
+
+      def test_assert_not_respond_to_pass_string
+        check_nothing_fails do
+          assert_not_respond_to("thing", :nonexistent, "message")
+        end
+      end
+
+      def test_assert_not_respond_to_fail_number
+        check_fail("<0.15>.kind_of?(Symbol) or\n" +
+                    "<0.15>.respond_to?(:to_str) expected") do
+          assert_respond_to("thing", 0.15)
+        end
+      end
+
+      def tset_assert_not_respond_to_fail_existence
+        check_fail("message.\n" +
+                    "!<:symbol>.respond_to?(:to_s) expected\n" +
+                    "(Class: <Symbol>)") do
+          assert_respond_to(:symbol, :to_s, "message")
+        end
+      end
+
+      def test_assert_send
+        object = Object.new
+        class << object
+          private
+          def return_argument(argument, bogus)
+            return argument
+          end
+        end
+        check_nothing_fails do
+          assert_send([object, :return_argument, true, "bogus"], "message")
+        end
+
+        inspected_object = AssertionMessage.convert(object)
+        expected_message = <<-EOM
+message.
+<#{inspected_object}> was expected to respond to
+<return_argument(*[false, "bogus"])> with a true value but was
+<false>.
+EOM
+        check_fail(expected_message.chomp) do
+          assert_send([object, :return_argument, false, "bogus"], "message")
+        end
+      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_fail("<true> or <false> expected but was\n<1>") do
+          assert_boolean(1)
+        end
+
+        check_fail("<true> or <false> expected but was\n<nil>") do
+          assert_boolean(nil)
+        end
+
+        check_fail("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_fail("<true> expected but was\n<false>") do
+          assert_true(false)
+        end
+
+        check_fail("<true> expected but was\n<1>") do
+          assert_true(1)
+        end
+
+        exception = check_fail("message.\n<true> expected but was\n<nil>") do
+          assert_true(nil, "message")
+        end
+        assert_equal("message", exception.user_message)
+      end
+
+      def test_assert_false
+        check_nothing_fails do
+          assert_false(false)
+        end
+
+        check_fail("<false> expected but was\n<true>") do
+          assert_false(true)
+        end
+
+        check_fail("<false> expected but was\n<nil>") do
+          assert_false(nil)
+        end
+
+        check_fail("message.\n<false> expected but was\n<:false>") do
+          assert_false(:false, "message")
+        end
+      end
+
+      def test_assert_compare
+        check_nothing_fails do
+          assert_compare(1.4, "<", 10.0)
+        end
+
+        check_nothing_fails do
+          assert_compare(2, "<=", 2)
+        end
+
+        check_nothing_fails do
+          assert_compare(14, ">=", 10.0)
+        end
+
+        check_nothing_fails do
+          assert_compare(14, ">", 13.9)
+        end
+
+        expected_message = <<-EOM
+<15> < <10> should be true
+<15> was expected to be less than
+<10>.
+EOM
+        check_fail(expected_message.chomp) do
+          assert_compare(15, "<", 10)
+        end
+
+        expected_message = <<-EOM
+<15> <= <10> should be true
+<15> was expected to be less than or equal to
+<10>.
+EOM
+        check_fail(expected_message.chomp) do
+          assert_compare(15, "<=", 10)
+        end
+
+        expected_message = <<-EOM
+<10> > <15> should be true
+<10> was expected to be greater than
+<15>.
+EOM
+        check_fail(expected_message.chomp) do
+          assert_compare(10, ">", 15)
+        end
+
+        expected_message = <<-EOM
+<10> >= <15> should be true
+<10> was expected to be greater than or equal to
+<15>.
+EOM
+        check_fail(expected_message.chomp) do
+          assert_compare(10, ">=", 15)
+        end
+      end
+
+      def test_assert_fail_assertion
+        check_nothing_fails do
+          assert_fail_assertion do
+            flunk
+          end
+        end
+
+        check_fail("Failed assertion was expected.") do
+          assert_fail_assertion do
+          end
+        end
+      end
+
+      def test_assert_raise_message
+        check_nothing_fails do
+          assert_raise_message("Raise!") do
+            raise "Raise!"
+          end
+        end
+
+        check_nothing_fails do
+          assert_raise_message("Raise!") do
+            raise Exception, "Raise!"
+          end
+        end
+
+        check_nothing_fails do
+          assert_raise_message(/raise/i) do
+            raise "Raise!"
+          end
+        end
+
+        expected_message = <<-EOM
+<"Expected message"> exception message expected but was
+<"Actual message">.
+EOM
+        check_fail(expected_message.chomp) do
+          assert_raise_message("Expected message") do
+            raise "Actual message"
+          end
+        end
+
+        expected_message = <<-EOM
+<"Expected message"> exception message was expected but none was thrown.
+EOM
+        check_fail(expected_message.chomp) do
+          assert_raise_message("Expected message") do
+          end
+        end
+      end
+
+      def test_assert_raise_kind_of
+        check_nothing_fails(true) do
+          assert_raise_kind_of(SystemCallError) do
+            raise Errno::EACCES
+          end
+        end
+
+        expected_message = <<-EOM.chomp
+<SystemCallError> family exception expected but was
+<RuntimeError(<XXX>)>.
+EOM
+        check_fail_exception(expected_message) do
+          assert_raise_kind_of(SystemCallError) do
+            raise RuntimeError, "XXX"
+          end
+        end
+      end
+
+      def test_assert_const_defined
+        check_nothing_fails do
+          assert_const_defined(Test, :Unit)
+        end
+
+        check_nothing_fails do
+          assert_const_defined(Test, "Unit")
+        end
+
+        check_fail("<Test>.const_defined?(<:Nonexistence>) expected.") do
+          assert_const_defined(Test, :Nonexistence)
+        end
+      end
+
+      def test_assert_not_const_defined
+        check_nothing_fails do
+          assert_not_const_defined(Test, :Nonexistence)
+        end
+
+        check_fail("!<Test>.const_defined?(<:Unit>) expected.") do
+          assert_not_const_defined(Test, :Unit)
+        end
+
+        check_fail("!<Test>.const_defined?(<\"Unit\">) expected.") do
+          assert_not_const_defined(Test, "Unit")
+        end
+      end
+
+      def test_assert_predicate
+        check_nothing_fails do
+          assert_predicate([], :empty?)
+        end
+
+        check_fail("<[1]>.empty? is true value expected but was\n<false>") do
+          assert_predicate([1], :empty?)
+        end
+
+        check_fail("<[1]>.respond_to?(:nonexistent?) expected\n" +
+                    "(Class: <Array>)") do
+          assert_predicate([1], :nonexistent?)
+        end
+      end
+
+      def test_assert_not_predicate
+        check_nothing_fails do
+          assert_not_predicate([1], :empty?)
+        end
+
+        check_fail("<[]>.empty? is false value expected but was\n<true>") do
+          assert_not_predicate([], :empty?)
+        end
+
+        check_fail("<[]>.respond_to?(:nonexistent?) expected\n" +
+                    "(Class: <Array>)") do
+          assert_not_predicate([], :nonexistent?)
+        end
+      end
+
+      def test_assert_alias_method
+        object = Object.new
+        class << object
+          def original_method
+          end
+          alias_method :alias_method, :original_method
+
+          def other
+          end
+        end
+
+        check_nothing_fails do
+          assert_alias_method(object, :alias_method, :original_method)
+        end
+
+        check_nothing_fails do
+          assert_alias_method(object, :original_method, :alias_method)
+        end
+
+        check_fail("<#{object.method(:other).inspect}> is alias of\n" +
+                    "<#{object.method(:original_method).inspect}> expected") do
+          assert_alias_method(object, :other, :original_method)
+        end
+
+        inspected_object = AssertionMessage.convert(object)
+        check_fail("<#{inspected_object}>.nonexistent doesn't exist\n" +
+                    "(Class: <Object>)") do
+          assert_alias_method(object, :nonexistent, :original_method)
+        end
+
+        check_fail("<#{inspected_object}>.nonexistent doesn't exist\n" +
+                    "(Class: <Object>)") do
+          assert_alias_method(object, :alias_method, :nonexistent)
+        end
+      end
+
+      def test_assert_path_exist
+        check_nothing_fails do
+          assert_path_exist(__FILE__)
+        end
+
+        nonexistent_file = __FILE__ + ".nonexistent"
+        check_fail("<#{nonexistent_file.inspect}> was expected to exist") do
+          assert_path_exist(nonexistent_file)
+        end
+      end
+
+      def test_assert_path_not_exist
+        nonexistent_file = __FILE__ + ".nonexistent"
+        check_nothing_fails do
+          assert_path_not_exist(nonexistent_file)
+        end
+
+        check_fail("<#{__FILE__.inspect}> was expected to not exist") do
+          assert_path_not_exist(__FILE__)
+        end
+      end
+    end
+
+    class TestAssert < TestCase
+      include AssertionCheckable
+
+      def test_pass
+        check_nothing_fa