glib2 0.90.7 → 0.90.8

data/test-unit/lib/test/unit/ui/testrunnermediator.rb

@@ -33,9 +33,15 @@ module Test
           Unit.run = true
 
           result = create_result
-          result_listener = result.add_listener(TestResult::CHANGED) do |*args|
+          finished_listener = result.add_listener(TestResult::FINISHED) do |*args|
+            notify_listeners(TestResult::FINISHED, *args)
+          end
+          changed_listener = result.add_listener(TestResult::CHANGED) do |*args|
             notify_listeners(TestResult::CHANGED, *args)
           end
+          pass_assertion_listener = result.add_listener(TestResult::PASS_ASSERTION) do |*args|
+            notify_listeners(TestResult::PASS_ASSERTION, *args)
+          end
           fault_listener = result.add_listener(TestResult::FAULT) do |*args|
             notify_listeners(TestResult::FAULT, *args)
           end
@@ -51,7 +57,10 @@ module Test
           ensure
             elapsed_time = Time.now - start_time
             result.remove_listener(TestResult::FAULT, fault_listener)
-            result.remove_listener(TestResult::CHANGED, result_listener)
+            result.remove_listener(TestResult::CHANGED, changed_listener)
+            result.remove_listener(TestResult::FINISHED, finished_listener)
+            result.remove_listener(TestResult::PASS_ASSERTION,
+                                   pass_assertion_listener)
             notify_listeners(FINISHED, elapsed_time)
           end
 

data/test-unit/lib/test/unit/ui/xml/testrunner.rb

@@ -0,0 +1,224 @@
+#--
+#
+# Author:: Kouhei Sutou
+# Copyright::
+#   * Copyright (c) 2011 Kouhei Sutou <kou@clear-code.com>
+# License:: Ruby license.
+
+require 'erb'
+require 'time'
+require 'test/unit/ui/testrunner'
+require 'test/unit/ui/testrunnermediator'
+
+module Test
+  module Unit
+    module UI
+      module XML
+
+        # Runs a Test::Unit::TestSuite and outputs XML.
+        class TestRunner < UI::TestRunner
+          include ERB::Util
+
+          # Creates a new TestRunner for running the passed
+          # suite. :output option specifies where runner
+          # output should go to; defaults to STDOUT.
+          def initialize(suite, options={})
+            super
+            @output = @options[:output] || STDOUT
+            if @options[:output_file_descriptor]
+              @output = IO.new(@options[:output_file_descriptor], "w")
+            end
+            @already_outputted = false
+            @indent = 0
+            @top_level = true
+            @current_test = nil
+            @current_test_suite = nil
+            @already_outputted = false
+          end
+
+          private
+          def attach_to_mediator
+            @mediator.add_listener(TestResult::PASS_ASSERTION,
+                                   &method(:result_pass_assertion))
+            @mediator.add_listener(TestResult::FAULT,
+                                   &method(:result_fault))
+            @mediator.add_listener(TestRunnerMediator::STARTED,
+                                   &method(:started))
+            @mediator.add_listener(TestRunnerMediator::FINISHED,
+                                   &method(:finished))
+            @mediator.add_listener(TestCase::STARTED_OBJECT,
+                                   &method(:test_started))
+            @mediator.add_listener(TestCase::FINISHED_OBJECT,
+                                   &method(:test_finished))
+            @mediator.add_listener(TestSuite::STARTED_OBJECT,
+                                   &method(:test_suite_started))
+            @mediator.add_listener(TestSuite::FINISHED_OBJECT,
+                                   &method(:test_suite_finished))
+          end
+
+          def result_pass_assertion(result)
+            open_tag("pass-assertion") do
+              output_test(@current_test)
+            end
+          end
+
+          def result_fault(fault)
+            open_tag("test-result") do
+              open_tag("result") do
+                output_test_suite(@current_test_suite)
+                output_test(@current_test)
+                open_tag("backtrace") do
+                  fault.location.each do |entry|
+                    file, line, info = entry.split(/:/, 3)
+                    open_tag("entry") do
+                      add_content("file", file)
+                      add_content("line", line)
+                      add_content("info", info)
+                    end
+                  end
+                end
+                if fault.respond_to?(:expected)
+                  add_content("expected", fault.expected)
+                end
+                if fault.respond_to?(:actual)
+                  add_content("actual", fault.actual)
+                end
+                add_content("detail", fault.message)
+                add_content("status", fault.label.downcase)
+              end
+            end
+            @already_outputted = true if fault.critical?
+          end
+
+          def started(result)
+            @result = result
+            output_started
+          end
+
+          def output_started
+            open_tag("stream")
+          end
+
+          def finished(elapsed_time)
+            add_content("success", @result.passed?)
+            close_tag("stream")
+          end
+
+          def test_started(test)
+            @already_outputted = false
+            @current_test = test
+            open_tag("start-test") do
+              output_test(test)
+            end
+          end
+
+          def test_finished(test)
+            unless @already_outputted
+              open_tag("test-result") do
+                output_test(test)
+                open_tag("result") do
+                  output_test_suite(@current_test_suite)
+                  output_test(test)
+                  add_content("status", "success")
+                end
+              end
+            end
+
+            open_tag("complete-test") do
+              output_test(test)
+              add_content("success", test.passed?)
+            end
+            @current_test = nil
+          end
+
+          def test_suite_started(suite)
+            @current_test_suite = suite
+            if suite.test_case.nil?
+              open_tag("ready-test-suite") do
+                add_content("n-tests", suite.size)
+              end
+              open_tag("start-test-suite") do
+                output_test_suite(suite)
+              end
+            else
+              open_tag("ready-test-case") do
+                output_test_suite(suite)
+                add_content("n-tests", suite.size)
+              end
+              open_tag("start-test-case") do
+                output_test_suite(suite)
+              end
+            end
+          end
+
+          def test_suite_finished(suite)
+            if suite.test_case.nil?
+              open_tag("complete-test-suite") do
+                output_test_suite(suite)
+                add_content("success", suite.passed?)
+              end
+            else
+              open_tag("complete-test-case") do
+                output_test_suite(suite)
+                add_content("success", suite.passed?)
+              end
+            end
+            @current_test_suite = nil
+          end
+
+          def indent
+            " " * @indent
+          end
+
+          def open_tag(name)
+            @output.puts("#{indent}<#{name}>")
+            @indent += 2
+            if block_given?
+              yield
+              close_tag(name)
+            end
+          end
+
+          def add_content(name, content)
+            return if content.nil?
+            case content
+            when Time
+              content = content.iso8601
+            end
+            @output.puts("#{indent}<#{name}>#{h(content)}</#{name}>")
+          end
+
+          def close_tag(name)
+            @indent -= 2
+            @output.puts("#{indent}</#{name}>")
+          end
+
+          def output_test(test)
+            open_tag("test") do
+              add_content("name", test.method_name)
+              add_content("start-time", test.start_time)
+              add_content("elapsed", test.elapsed_time)
+            end
+          end
+
+          def output_test_suite(test_suite)
+            test_case = test_suite.test_case
+            if test_case.nil?
+              open_tag("test-suite") do
+                add_content("name", test_suite.name)
+                add_content("start-time", test_suite.start_time)
+                add_content("elapsed", test_suite.elapsed_time)
+              end
+            else
+              open_tag("test-case") do
+                add_content("name", test_suite.name)
+                add_content("start-time", test_suite.start_time)
+                add_content("elapsed", test_suite.elapsed_time)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/test-unit/lib/test/unit/version.rb

@@ -2,6 +2,6 @@
 # HACK: quick and dirty to get integrated into the new project - ryan
 module Test
   module Unit
-    VERSION = '2.1.3'
+    VERSION = '2.2.1'
   end
 end

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

@@ -12,4 +12,11 @@ $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/test-unit/test/{test_assertions.rb → test-assertions.rb}

@@ -9,11 +9,12 @@ require 'test/unit'
 
 module Test
   module Unit
-    class TC_Assertions < TestCase
+    module AssertionCheckable
       backtrace_pre  = "---Backtrace---"
       backtrace_post = "---------------"
       BACKTRACE_RE = /#{backtrace_pre}\n.+\n#{backtrace_post}/m
 
+      private
       def check(value, message="")
         add_assertion
         raise AssertionFailedError.new(message) unless value
@@ -92,6 +93,24 @@ module Test
         end
       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
+
       def test_assert_block
         check_nothing_fails {
           assert_block {true}
@@ -109,16 +128,7 @@ module Test
           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")
@@ -328,6 +338,24 @@ EOM
         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
+<{"Lisp"=>"John McCarthy", "Ruby"=>"Matz"}> expected but was
+<{"Heavy"=>["C", "C++"], "LL"=>["Ruby", "Python"]}>.
+EOM
+        check_fails(message) do
+          assert_equal(designers, categories)
+        end
+      end
+
       def test_assert_raise_success
         return_value = nil
         check_nothing_fails(true) do
@@ -729,7 +757,44 @@ EOM
           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_fails("<REGEXP> in assert_not_match(<REGEXP>, ...) " +
+                    "should be a Regexp.\n" +
+                    "<\"asdf\"> expected to be an instance of\n" +
+                    "<Regexp> but was\n" +
+                    "<String>.") do
+          assert_not_match("asdf", "asdf")
+        end
+      end
+
+      def test_assert_not_match_fail_match
+        check_fails("</string/> expected to not match\n" +
+                    "<\"string\">.") do
+          assert_not_match(/string/, "string")
+        end
+      end
+
+      def test_assert_not_match_fail_match_with_message
+        check_fails("message.\n" +
+                    "</string/> 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")}
@@ -743,7 +808,7 @@ EOM
           assert_no_match(/string/, "string", "message")
         end
       end
-      
+
       def test_assert_throw
         check_nothing_fails do
           assert_throw(:thing, "message") do
@@ -795,7 +860,7 @@ EOM
           assert_operator("thing1", :==, "thing2", "message")
         }
       end
-      
+
       def test_assert_respond_to
         check_nothing_fails {
           assert_respond_to("thing", :to_s, "message")
@@ -808,67 +873,37 @@ EOM
           assert_respond_to("thing", 0.15)
         }
         check_fails("message.\n" +
-                    "<:symbol>.respond_to?(:non_existent) expected\n" +
+                    "<:symbol>.respond_to?(:nonexistence) expected\n" +
                     "(Class: <Symbol>)") {
-          assert_respond_to(:symbol, :non_existent, "message")
-        }
-      end
-
-      def test_assert_in_delta_pass
-        check_nothing_fails {
-          assert_in_delta(1.4, 1.4, 0)
-        }
-      end
-
-      def test_assert_in_delta_pass_with_message
-        check_nothing_fails {
-          assert_in_delta(0.5, 0.4, 0.1, "message")
-        }
-      end
-
-      def test_assert_in_delta_pass_float_like_object
-        check_nothing_fails {
-          float_thing = Object.new
-          def float_thing.to_f
-            0.2
-          end
-          assert_in_delta(0.1, float_thing, 0.1)
+          assert_respond_to(:symbol, :nonexistence, "message")
         }
       end
 
-      def test_assert_in_delta_pass_string_delta
+      def test_assert_not_respond_to_pass_symbol
         check_nothing_fails do
-          assert_in_delta("0.5", 0.4, 0.1)
+          assert_not_respond_to("thing", :nonexistent, "message")
         end
       end
 
-      def test_assert_in_delta_fail_with_message
-        check_fails("message.\n" +
-                    "<0.5> expected but was\n" +
-                    "<0.4> (tolerance <0.05>).\n" +
-                    "\n" +
-                    "Relation:\n" +
-                    "<<0.4> < <0.5>-<0.05>(0.45) <= <0.5>+<0.05>(0.55)>") {
-          assert_in_delta(0.5, 0.4, 0.05, "message")
-        }
+      def test_assert_not_respond_to_pass_string
+        check_nothing_fails do
+          assert_not_respond_to("thing", :nonexistent, "message")
+        end
       end
 
-      def test_assert_in_delta_fail_because_not_float_like_object
-        object = Object.new
-        inspected_object = AssertionMessage.convert(object)
-        check_fails("The arguments must respond to to_f; " +
-                    "the first float did not.\n" +
-                    "<#{inspected_object}>.respond_to?(:to_f) expected\n" +
-                    "(Class: <Object>)") {
-          assert_in_delta(object, 0.4, 0.1)
-        }
+      def test_assert_not_respond_to_fail_number
+        check_fails("<0.15>.kind_of?(Symbol) or\n" +
+                    "<0.15>.respond_to?(:to_str) expected") do
+          assert_respond_to("thing", 0.15)
+        end
       end
 
-      def test_assert_in_delta_fail_because_negaitve_delta
-        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")
-        }
+      def tset_assert_not_respond_to_fail_existence
+        check_fails("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
@@ -879,14 +914,22 @@ EOM
             return argument
           end
         end
-        check_nothing_fails {
+        check_nothing_fails do
           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}) {
+        end
+
+        inspected_object = AssertionMessage.convert(object)
+        expected_message = <<-EOM
+message.
+<#{inspected_object}> expected to respond to
+<return_argument(*[false, "bogus"])> with a true value but was
+<false>.
+EOM
+        check_fails(expected_message.chomp) do
           assert_send([object, :return_argument, false, "bogus"], "message")
-        }
+        end
       end
-      
+
       def test_condition_invariant
         object = Object.new
         def object.inspect
@@ -1198,19 +1241,607 @@ EOM
           assert_path_not_exist(__FILE__)
         end
       end
+    end
 
-      private
-      def add_failure(message, location=caller, options=nil)
-        unless @catch_assertions
-          super
+    class TestAssert < TestCase
+      include AssertionCheckable
+
+      def test_pass
+        check_nothing_fails do
+          assert(true)
         end
       end
 
-      def add_assertion
-        if @catch_assertions
-          @actual_assertion_count += 1
-        else
-          super
+      def test_pass_neither_false_or_nil
+        check_nothing_fails do
+          assert("a")
+        end
+      end
+
+      def test_pass_with_message
+        check_nothing_fails do
+          assert(true, "successful assert")
+        end
+      end
+
+      def test_fail_nil
+        check_fails("<nil> is not true.") do
+          assert(nil)
+        end
+      end
+
+      def test_fail_false
+        check_fails("<false> is not true.") do
+          assert(false)
+        end
+      end
+
+      def test_fail_false_with_message
+        check_fails("failed assert.\n" +
+                    "<false> is not true.") do
+          assert(false, "failed assert")
+        end
+      end
+
+      def test_error_invalid_message
+        check_fails("assertion message must be String or Proc: " +
+                    "<true>(<TrueClass>)") do
+          begin
+            assert(true, true)
+          rescue ArgumentError
+            raise AssertionFailedError, $!.message
+          end
+        end
+      end
+    end
+
+    class TestAssertInDelta < TestCase
+      include AssertionCheckable
+
+      def test_pass
+        check_nothing_fails do
+          assert_in_delta(1.4, 1.4, 0)
+        end
+      end
+
+      def test_pass_without_delta
+        check_nothing_fails do
+          assert_in_delta(1.401, 1.402)
+        end
+      end
+
+      def test_pass_with_message
+        check_nothing_fails do
+          assert_in_delta(0.5, 0.4, 0.1, "message")
+        end
+      end
+
+      def test_pass_float_like_object
+        check_nothing_fails do
+          float_thing = Object.new
+          def float_thing.to_f
+            0.2
+          end
+          assert_in_delta(0.1, float_thing, 0.1)
+        end
+      end
+
+      def test_pass_string_expected
+        check_nothing_fails do
+          assert_in_delta("0.5", 0.4, 0.1)
+        end
+      end
+
+      def test_fail_with_message
+        check_fails("message.\n" +
+                    "<0.5> -/+ <0.05> expected to include\n" +
+                    "<0.4>.\n" +
+                    "\n" +
+                    "Relation:\n" +
+                    "<<0.4> < <0.5>-<0.05>[0.45] <= <0.5>+<0.05>[0.55]>") do
+          assert_in_delta(0.5, 0.4, 0.05, "message")
+        end
+      end
+
+      def test_fail_because_not_float_like_object
+        object = Object.new
+        inspected_object = AssertionMessage.convert(object)
+        check_fails("The arguments must respond to to_f; " +
+                    "the first float did not.\n" +
+                    "<#{inspected_object}>.respond_to?(:to_f) expected\n" +
+                    "(Class: <Object>)") do
+          assert_in_delta(object, 0.4, 0.1)
+        end
+      end
+
+      def test_fail_because_negaitve_delta
+        check_fails("The delta should not be negative.\n" +
+                    "<-0.1> expected to be\n>=\n<0.0>.") do
+          assert_in_delta(0.5, 0.4, -0.1, "message")
+        end
+      end
+
+      def test_fail_without_delta
+        check_fails("<1.402> -/+ <0.001> expected to include\n" +
+                    "<1.404>.\n" +
+                    "\n" +
+                    "Relation:\n" +
+                    "<" +
+                    "<1.402>-<0.001>[#{1.402 - 0.001}] <= " +
+                    "<1.402>+<0.001>[#{1.402 + 0.001}] < " +
+                    "<1.404>" +
+                    ">") do
+          assert_in_delta(1.402, 1.404)
+        end
+      end
+    end
+
+    class TestAssertNotInDelta < Test::Unit::TestCase
+      include AssertionCheckable
+
+      def test_pass
+        check_nothing_fails do
+          assert_not_in_delta(1.42, 1.44, 0.01)
+        end
+      end
+
+      def test_pass_without_delta
+        check_nothing_fails do
+          assert_not_in_delta(1.402, 1.404)
+        end
+      end
+
+      def test_pass_with_message
+        check_nothing_fails do
+          assert_not_in_delta(0.5, 0.4, 0.09, "message")
+        end
+      end
+
+      def test_pass_float_like_object
+        check_nothing_fails do
+          float_thing = Object.new
+          def float_thing.to_f
+            0.2
+          end
+          assert_not_in_delta(0.1, float_thing, 0.09)
+        end
+      end
+
+      def test_pass_string_epxected
+        check_nothing_fails do
+          assert_not_in_delta("0.5", 0.4, 0.09)
+        end
+      end
+
+      def test_fail
+        check_fails("<1.4> -/+ <0.11> expected to not include\n" +
+                    "<1.5>.\n" +
+                    "\n" +
+                    "Relation:\n" +
+                    "<" +
+                    "<1.4>-<0.11>[#{1.4 - 0.11}] <= " +
+                    "<1.5> <= " +
+                    "<1.4>+<0.11>[#{1.4 + 0.11}]" +
+                    ">") do
+          assert_not_in_delta(1.4, 1.5, 0.11)
+        end
+      end
+
+      def test_fail_without_delta
+        check_fails("<1.402> -/+ <0.001> expected to not include\n" +
+                    "<1.4021>.\n" +
+                    "\n" +
+                    "Relation:\n" +
+                    "<" +
+                    "<1.402>-<0.001>[#{1.402 - 0.001}] <= " +
+                    "<1.4021> <= " +
+                    "<1.402>+<0.001>[#{1.402 + 0.001}]" +
+                    ">") do
+          assert_not_in_delta(1.402, 1.4021)
+        end
+      end
+
+      def test_fail_with_message
+        check_fails("message.\n" +
+                    "<0.5> -/+ <0.11> expected to not include\n" +
+                    "<0.4>.\n" +
+                    "\n" +
+                    "Relation:\n" +
+                    "<" +
+                    "<0.5>-<0.11>[0.39] <= " +
+                    "<0.4> <= " +
+                    "<0.5>+<0.11>[0.61]" +
+                    ">") do
+          assert_not_in_delta(0.5, 0.4, 0.11, "message")
+        end
+      end
+
+      def test_fail_because_not_float_like_object
+        object = Object.new
+        inspected_object = AssertionMessage.convert(object)
+        check_fails("The arguments must respond to to_f; " +
+                    "the first float did not.\n" +
+                    "<#{inspected_object}>.respond_to?(:to_f) expected\n" +
+                    "(Class: <Object>)") do
+          assert_not_in_delta(object, 0.4, 0.1)
+        end
+      end
+
+      def test_fail_because_negaitve_delta
+        check_fails("The delta should not be negative.\n" +
+                    "<-0.11> expected to be\n>=\n<0.0>.") do
+          assert_not_in_delta(0.5, 0.4, -0.11, "message")
+        end
+      end
+    end
+
+    class TestAssertInEpsilon < TestCase
+      include AssertionCheckable
+
+      def test_pass
+        check_nothing_fails do
+          assert_in_epsilon(10000, 9000, 0.1)
+        end
+      end
+
+      def test_pass_without_epsilon
+        check_nothing_fails do
+          assert_in_epsilon(10000, 9991)
+        end
+      end
+
+      def test_pass_with_message
+        check_nothing_fails do
+          assert_in_epsilon(10000, 9000, 0.1, "message")
+        end
+      end
+
+      def test_pass_float_like_object
+        check_nothing_fails do
+          float_thing = Object.new
+          def float_thing.to_f
+            9000.0
+          end
+          assert_in_epsilon(10000, float_thing, 0.1)
+        end
+      end
+
+      def test_pass_string_expected
+        check_nothing_fails do
+          assert_in_epsilon("10000", 9000, 0.1)
+        end
+      end
+
+      def test_fail_with_message
+        check_fails("message.\n" +
+                    "<10000> -/+ (<10000> * <0.1>)[1000.0] " +
+                    "expected to include\n" +
+                    "<8999>.\n" +
+                    "\n" +
+                    "Relation:\n" +
+                    "<" +
+                    "<8999> < " +
+                    "<10000>-(<10000>*<0.1>)[9000.0] <= " +
+                    "<10000>+(<10000>*<0.1>)[11000.0]" +
+                    ">") do
+          assert_in_epsilon(10000, 8999, 0.1, "message")
+        end
+      end
+
+      def test_fail_because_not_float_like_object
+        object = Object.new
+        inspected_object = AssertionMessage.convert(object)
+        check_fails("The arguments must respond to to_f; " +
+                    "the first float did not.\n" +
+                    "<#{inspected_object}>.respond_to?(:to_f) expected\n" +
+                    "(Class: <Object>)") do
+          assert_in_epsilon(object, 9000, 0.1)
+        end
+      end
+
+      def test_fail_because_negaitve_epsilon
+        check_fails("The epsilon should not be negative.\n" +
+                    "<-0.1> expected to be\n>=\n<0.0>.") do
+          assert_in_epsilon(10000, 9000, -0.1, "message")
+        end
+      end
+
+      def test_fail_without_epsilon
+        check_fails("<10000> -/+ (<10000> * <0.001>)[10.0] " +
+                    "expected to include\n" +
+                    "<10011>.\n" +
+                    "\n" +
+                    "Relation:\n" +
+                    "<" +
+                    "<10000>-(<10000>*<0.001>)[9990.0] <= " +
+                    "<10000>+(<10000>*<0.001>)[10010.0] < " +
+                    "<10011>" +
+                    ">") do
+          assert_in_epsilon(10000, 10011)
+        end
+      end
+    end
+
+    class TestAssertNotInEpsilon < Test::Unit::TestCase
+      include AssertionCheckable
+
+      def test_pass
+        check_nothing_fails do
+          assert_not_in_epsilon(10000, 8999, 0.1)
+        end
+      end
+
+      def test_pass_without_epsilon
+        check_nothing_fails do
+          assert_not_in_epsilon(10000, 9989)
+        end
+      end
+
+      def test_pass_with_message
+        check_nothing_fails do
+          assert_not_in_epsilon(10000, 8999, 0.1, "message")
+        end
+      end
+
+      def test_pass_float_like_object
+        check_nothing_fails do
+          float_thing = Object.new
+          def float_thing.to_f
+            8999.0
+          end
+          assert_not_in_epsilon(10000, float_thing, 0.1)
+        end
+      end
+
+      def test_pass_string_epxected
+        check_nothing_fails do
+          assert_not_in_epsilon("10000", 8999, 0.1)
+        end
+      end
+
+      def test_fail
+        check_fails("<10000> -/+ (<10000> * <0.1>)[1000.0] " +
+                    "expected to not include\n" +
+                    "<9000>.\n" +
+                    "\n" +
+                    "Relation:\n" +
+                    "<" +
+                    "<10000>-(<10000>*<0.1>)[9000.0] <= " +
+                    "<9000> <= " +
+                    "<10000>+(<10000>*<0.1>)[11000.0]" +
+                    ">") do
+          assert_not_in_epsilon(10000, 9000, 0.1)
+        end
+      end
+
+      def test_fail_without_epsilon
+        check_fails("<10000> -/+ (<10000> * <0.001>)[10.0] " +
+                    "expected to not include\n" +
+                    "<9990>.\n" +
+                    "\n" +
+                    "Relation:\n" +
+                    "<" +
+                    "<10000>-(<10000>*<0.001>)[9990.0] <= " +
+                    "<9990> <= " +
+                    "<10000>+(<10000>*<0.001>)[10010.0]" +
+                    ">") do
+          assert_not_in_epsilon(10000, 9990)
+        end
+      end
+
+      def test_fail_with_message
+        check_fails("message.\n" +
+                    "<10000> -/+ (<10000> * <0.1>)[1000.0] " +
+                    "expected to not include\n" +
+                    "<9000>.\n" +
+                    "\n" +
+                    "Relation:\n" +
+                    "<" +
+                    "<10000>-(<10000>*<0.1>)[9000.0] <= " +
+                    "<9000> <= " +
+                    "<10000>+(<10000>*<0.1>)[11000.0]" +
+                    ">") do
+          assert_not_in_epsilon(10000, 9000, 0.1, "message")
+        end
+      end
+
+      def test_fail_because_not_float_like_object
+        object = Object.new
+        inspected_object = AssertionMessage.convert(object)
+        check_fails("The arguments must respond to to_f; " +
+                    "the first float did not.\n" +
+                    "<#{inspected_object}>.respond_to?(:to_f) expected\n" +
+                    "(Class: <Object>)") do
+          assert_not_in_epsilon(object, 9000, 0.1)
+        end
+      end
+
+      def test_fail_because_negaitve_epsilon
+        check_fails("The epsilon should not be negative.\n" +
+                    "<-0.1> expected to be\n>=\n<0.0>.") do
+          assert_not_in_epsilon(10000, 9000, -0.1, "message")
+        end
+      end
+    end
+
+    class TestAssertInclude < Test::Unit::TestCase
+      include AssertionCheckable
+
+      def test_pass
+        check_nothing_fails do
+          assert_include([1, 2, 3], 1)
+        end
+      end
+
+      def test_pass_with_message
+        check_nothing_fails do
+          assert_include([1, 2, 3], 1, "message")
+        end
+      end
+
+      def test_fail
+        check_fails("<[1, 2, 3]> expected to include\n" +
+                    "<4>.") do
+          assert_include([1, 2, 3], 4)
+        end
+      end
+
+      def test_fail_with_message
+        check_fails("message.\n" +
+                    "<[1, 2, 3]> expected to include\n" +
+                    "<4>.") do
+          assert_include([1, 2, 3], 4, "message")
+        end
+      end
+
+      def test_fail_because_not_collection_like_object
+        object = Object.new
+        inspected_object = AssertionMessage.convert(object)
+        check_fails("The collection must respond to :include?.\n" +
+                    "<#{inspected_object}>.respond_to?(:include?) expected\n" +
+                    "(Class: <Object>)") do
+          assert_include(object, 1)
+        end
+      end
+    end
+
+    class TestAssertNotInclude < Test::Unit::TestCase
+      include AssertionCheckable
+
+      def test_pass
+        check_nothing_fails do
+          assert_not_include([1, 2, 3], 5)
+        end
+      end
+
+      def test_pass_with_message
+        check_nothing_fails do
+          assert_not_include([1, 2, 3], 5, "message")
+        end
+      end
+
+      def test_fail
+        check_fails("<[1, 2, 3]> expected to not include\n" +
+                    "<2>.") do
+          assert_not_include([1, 2, 3], 2)
+        end
+      end
+
+      def test_fail_with_message
+        check_fails("message.\n" +
+                    "<[1, 2, 3]> expected to not include\n" +
+                    "<2>.") do
+          assert_not_include([1, 2, 3], 2, "message")
+        end
+      end
+
+      def test_fail_because_not_collection_like_object
+        object = Object.new
+        inspected_object = AssertionMessage.convert(object)
+        check_fails("The collection must respond to :include?.\n" +
+                    "<#{inspected_object}>.respond_to?(:include?) expected\n" +
+                    "(Class: <Object>)") do
+          assert_not_include(object, 1)
+        end
+      end
+    end
+
+    class TestAssertEmpty < Test::Unit::TestCase
+      include AssertionCheckable
+
+      def test_pass
+        check_nothing_fails do
+          assert_empty([])
+        end
+      end
+
+      def test_pass_with_message
+        check_nothing_fails do
+          assert_empty([], "message")
+        end
+      end
+
+      def test_fail
+        check_fails("<[1]> expected to be empty.") do
+          assert_empty([1])
+        end
+      end
+
+      def test_fail_with_message
+        check_fails("message.\n" +
+                    "<[1]> expected to be empty.") do
+          assert_empty([1], "message")
+        end
+      end
+
+      def test_fail_because_no_empty_method
+        object = Object.new
+        inspected_object = AssertionMessage.convert(object)
+        check_fails("The object must respond to :empty?.\n" +
+                    "<#{inspected_object}>.respond_to?(:empty?) expected\n" +
+                    "(Class: <Object>)") do
+          assert_empty(object)
+        end
+      end
+    end
+
+    class TestAssertNotEmpty < Test::Unit::TestCase
+      include AssertionCheckable
+
+      def test_pass
+        check_nothing_fails do
+          assert_not_empty([1])
+        end
+      end
+
+      def test_pass_with_message
+        check_nothing_fails do
+          assert_not_empty([1], "message")
+        end
+      end
+
+      def test_fail
+        check_fails("<[]> expected to not be empty.") do
+          assert_not_empty([])
+        end
+      end
+
+      def test_fail_with_message
+        check_fails("message.\n" +
+                    "<[]> expected to not be empty.") do
+          assert_not_empty([], "message")
+        end
+      end
+
+      def test_fail_because_no_empty_method
+        object = Object.new
+        inspected_object = AssertionMessage.convert(object)
+        check_fails("The object must respond to :empty?.\n" +
+                    "<#{inspected_object}>.respond_to?(:empty?) expected\n" +
+                    "(Class: <Object>)") do
+          assert_not_empty(object)
+        end
+      end
+    end
+
+    class TestAssertNotSend < Test::Unit::TestCase
+      include AssertionCheckable
+
+      def test_pass
+        check_nothing_fails do
+          assert_not_send([[1, 2], :member?, 4], "message")
+        end
+      end
+
+      def test_fail
+        expected_message = <<-EOM
+message.
+<[1, 2]> expected to respond to
+<member?(*[2])> with not a true value but was
+<true>.
+EOM
+        check_fails(expected_message.chomp) do
+          assert_not_send([[1, 2], :member?, 2], "message")
         end
       end
     end