test-unit 2.1.2 → 2.2.0

data/lib/test/unit/autorunner.rb

@@ -199,6 +199,18 @@ module Test
             end
           end
 
+          o.on('--ignore-name=NAME', String,
+               "Ignores tests matching NAME.",
+               "(patterns may be used).") do |n|
+            n = (%r{\A/(.*)/\Z} =~ n ? Regexp.new($1) : n)
+            case n
+            when Regexp
+              @filters << proc {|t| n =~ t.method_name ? false : true}
+            else
+              @filters << proc {|t| n != t.method_name}
+            end
+          end
+
           o.on('-t', '--testcase=TESTCASE', String,
                "Runs tests in TestCases matching TESTCASE.",
                "(patterns may be used).") do |n|
@@ -211,6 +223,18 @@ module Test
             end
           end
 
+          o.on('--ignore-testcase=TESTCASE', String,
+               "Ignores tests in TestCases matching TESTCASE.",
+               "(patterns may be used).") do |n|
+            n = (%r{\A/(.*)/\Z} =~ n ? Regexp.new($1) : n)
+            case n
+            when Regexp
+              @filters << proc {|t| n =~ t.class.name ? false : true}
+            else
+              @filters << proc {|t| n != t.class.name}
+            end
+          end
+
           priority_filter = Proc.new do |test|
             if @filters == [priority_filter]
               Priority::Checker.new(test).need_to_run?

data/lib/test/unit/collector.rb

@@ -15,9 +15,9 @@ module Test
       end
 
       def add_suite(destination, suite)
-        to_delete = suite.tests.find_all{|t| !include?(t)}
-        to_delete.each{|t| suite.delete(t)}
-        destination << suite unless(suite.size == 0)
+        to_delete = suite.tests.find_all {|t| !include?(t)}
+        to_delete.each {|t| suite.delete(t)}
+        destination << suite unless suite.empty?
       end
 
       def include?(test)
@@ -29,7 +29,9 @@ module Test
       end
 
       def sort(suites)
-        suites.sort_by {|suite| suite.name || suite.to_s}
+        suites.sort_by do |suite|
+          [suite.priority, suite.name || suite.to_s]
+        end
       end
     end
   end

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

@@ -18,6 +18,7 @@ module Test
           @patterns = [/\Atest[_\-].+\.rb\z/m, /[_\-]test\.rb\z/]
           @excludes = []
           @base = nil
+          @require_failed_infos = []
         end
 
         def base=(base)
@@ -39,16 +40,18 @@ module Test
                 collect_file(from, test_suites, already_gathered)
               end
             end
+            add_require_failed_test_suite(test_suites)
 
             if test_suites.size > 1
               test_suite = TestSuite.new("[#{froms.join(', ')}]")
               sort(test_suites).each do |sub_test_suite|
                 test_suite << sub_test_suite
               end
-              test_suite
             else
-              test_suites.first
+              test_suite = test_suites.first
             end
+
+            test_suite
           end
         end
 
@@ -95,9 +98,14 @@ module Test
 
         def collect_file(path, test_suites, already_gathered)
           @program_file ||= File.expand_path($0)
-          return if @program_file == path.expand_path.to_s
-          add_load_path(path.expand_path.dirname) do
-            require(path.to_s)
+          expanded_path = path.expand_path
+          return if @program_file == expanded_path.to_s
+          add_load_path(expanded_path.dirname) do
+            begin
+              require(path.to_s)
+            rescue LoadError
+              @require_failed_infos << {:path => expanded_path, :exception => $!}
+            end
             find_test_cases(already_gathered).each do |test_case|
               add_suite(test_suites, test_case.suite)
             end
@@ -138,6 +146,41 @@ module Test
 
           false
         end
+
+        def add_require_failed_test_suite(test_suites)
+          return if @require_failed_infos.empty?
+
+          require_failed_infos = @require_failed_infos
+          require_failed_omissions = Class.new(Test::Unit::TestCase)
+          require_failed_omissions.class_eval do
+            class << self
+              def name
+                "RequireFailedOmissions"
+              end
+            end
+
+            require_failed_infos.each do |info|
+              path = info[:path]
+              normalized_path = path.to_s.gsub(/[^a-z0-9\_]+/i, '_')
+              normalized_path = normalized_path.gsub(/\A_+/, '')
+              exception = info[:exception]
+              define_method("test_require_#{normalized_path}") do
+                @require_failed_exception = exception
+                omit("failed to load: <#{path}>: <#{exception.message}>")
+              end
+            end
+
+            def priority
+              100
+            end
+
+            def filter_backtrace(location)
+              super(@require_failed_exception.backtrace)
+            end
+          end
+
+          add_suite(test_suites, require_failed_omissions.suite)
+        end
       end
     end
   end

data/lib/test/unit/fixture.rb

@@ -154,13 +154,22 @@ module Test
       end
 
       private
-      def run_fixture(fixture)
+      def run_fixture(fixture, options={})
         [
          self.class.send("before_#{fixture}_methods"),
          fixture,
          self.class.send("after_#{fixture}_methods")
         ].flatten.each do |method_name|
-          send(method_name) if respond_to?(method_name, true)
+          next unless respond_to?(method_name, true)
+          if options[:handle_exception]
+            begin
+              send(method_name)
+            rescue Exception
+              raise unless handle_exception($!)
+            end
+          else
+            send(method_name)
+          end
         end
       end
 
@@ -169,7 +178,7 @@ module Test
       end
 
       def run_teardown
-        run_fixture(:teardown)
+        run_fixture(:teardown, :handle_exception => true)
       end
     end
   end

data/lib/test/unit/testsuite.rb

@@ -2,6 +2,7 @@
 #
 # Author:: Nathaniel Talbott.
 # Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
+# Copyright:: Copyright (c) 2008-2011 Kouhei Sutou. All rights reserved.
 # License:: Ruby license.
 
 require 'test/unit/error'
@@ -18,7 +19,11 @@ module Test
     # meaningful TestSuite instance.
     class TestSuite
       attr_reader :name, :tests
-      
+
+      # Test suite that has higher priority is ran prior to
+      # test suites that have lower priority.
+      attr_accessor :priority
+
       STARTED = name + "::STARTED"
       FINISHED = name + "::FINISHED"
 
@@ -27,6 +32,8 @@ module Test
         @name = name
         @tests = []
         @test_case = test_case
+        @n_tests = 0
+        @priority = 0
       end
 
       # Runs the tests and/or suites contained in this
@@ -34,7 +41,8 @@ module Test
       def run(result, &progress_block)
         yield(STARTED, name)
         run_startup(result)
-        @tests.each do |test|
+        while test = @tests.shift
+          @n_tests += test.size
           test.run(result, &progress_block)
         end
         run_shutdown(result)
@@ -55,7 +63,7 @@ module Test
       # i.e. if the suite contains other suites, it counts the
       # tests within those suites, not the suites themselves.
       def size
-        total_size = 0
+        total_size = @n_tests
         @tests.each { |test| total_size += test.size }
         total_size
       end

data/lib/test/unit/ui/console/testrunner.rb

@@ -64,13 +64,13 @@ module Test
             @mediator.add_listener(TestSuite::STARTED, &method(:test_suite_started))
             @mediator.add_listener(TestSuite::FINISHED, &method(:test_suite_finished))
           end
-          
+
           def add_fault(fault)
             @faults << fault
             output_progress(fault.single_character_display, fault_color(fault))
             @already_outputted = true if fault.critical?
           end
-          
+
           def started(result)
             @result = result
             output_started
@@ -92,6 +92,15 @@ module Test
             nl
             output(@result, result_color)
             output("%g%% passed" % @result.pass_percentage, result_color)
+            unless elapsed_time.zero?
+              nl
+              throuputs =
+                [
+                 "%.2f tests/s" % [@result.run_count / elapsed_time],
+                 "%.2f assertions/s" % [@result.assertion_count / elapsed_time],
+                ]
+              output(throuputs.join(", "))
+            end
           end
 
           def output_fault(fault)
@@ -133,18 +142,43 @@ module Test
           end
 
           def output_fault_message(fault)
+            if fault.expected.respond_to?(:encoding) and
+                fault.actual.respond_to?(:encoding) and
+                fault.expected.encoding != fault.actual.encoding
+              need_encoding = true
+            else
+              need_encoding = false
+            end
             output(fault.user_message) if fault.user_message
             output_single("<")
             output_single(fault.inspected_expected, color("pass"))
-            output("> expected but was")
+            output_single(">")
+            if need_encoding
+              output_single("(")
+              output_single(fault.expected.encoding.name, color("pass"))
+              output_single(")")
+            end
+            output(" expected but was")
             output_single("<")
             output_single(fault.inspected_actual, color("failure"))
-            output(">")
+            output_single(">")
+            if need_encoding
+              output_single("(")
+              output_single(fault.actual.encoding.name, color("failure"))
+              output_single(")")
+            end
+            output("")
             from, to = prepare_for_diff(fault.expected, fault.actual)
             if from and to
-              differ = ColorizedReadableDiffer.new(from.split(/\r?\n/),
-                                                   to.split(/\r?\n/),
-                                                   self)
+              from_lines = from.split(/\r?\n/)
+              to_lines = to.split(/\r?\n/)
+              if need_encoding
+                from_lines << ""
+                to_lines << ""
+                from_lines << "Encoding: #{fault.expected.encoding.name}"
+                to_lines << "Encoding: #{fault.actual.encoding.name}"
+              end
+              differ = ColorizedReadableDiffer.new(from_lines, to_lines, self)
               if differ.need_diff?
                 output("")
                 output("diff:")
@@ -286,7 +320,7 @@ module Test
           end
 
           def guess_term_width
-            Integer(ENV["TERM_WIDTH"] || 0)
+            Integer(ENV["COLUMNS"] || ENV["TERM_WIDTH"] || 0)
           rescue ArgumentError
             0
           end

data/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.2'
+    VERSION = '2.2.0'
   end
 end

data/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/{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,48 +873,39 @@ 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")
+          assert_respond_to(:symbol, :nonexistence, "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)
-        }
+
+      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_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 tset_assert_not_respond_to_fail_existence
         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")
-        }
-        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)
-        }
-        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")
-        }
+                    "!<: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
@@ -858,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
@@ -1177,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