test-unit 2.4.3 → 2.4.4

data/lib/test/unit/assertions.rb

@@ -753,7 +753,11 @@ EOT
                                                     message)
           assert_block(full_message) do
             normalized_expected_float = expected_float.to_f
-            delta = normalized_expected_float * epsilon.to_f
+            if normalized_expected_float.zero?
+              delta = epsilon.to_f ** 2
+            else
+              delta = normalized_expected_float * epsilon.to_f
+            end
             (normalized_expected_float - actual_float.to_f).abs <= delta
           end
         end

data/lib/test/unit/fixture.rb

@@ -6,12 +6,11 @@ module Test
           base.extend(ClassMethods)
 
           [:setup, :cleanup, :teardown].each do |fixture|
-            observer = Proc.new do |test_case, _, _, value, method_name|
+            observer = lambda do |test_case, _, _, value, callback|
               if value.nil?
-                test_case.send("unregister_#{fixture}_method", method_name)
+                test_case.send("unregister_#{fixture}_callback", callback)
               else
-                test_case.send("register_#{fixture}_method", method_name,
-                               value)
+                test_case.send("register_#{fixture}_callback", callback, value)
               end
             end
             base.register_attribute_observer(fixture, &observer)
@@ -20,89 +19,92 @@ module Test
       end
 
       module ClassMethods
-        def setup(*method_names)
-          register_fixture(:setup, *method_names)
+        def setup(*method_names, &callback)
+          register_fixture(:setup, *method_names, &callback)
         end
 
-        def unregister_setup(*method_names)
-          unregister_fixture(:setup, *method_names)
+        def unregister_setup(*method_names_or_callbacks)
+          unregister_fixture(:setup, *method_names_or_callbacks)
         end
 
-        def cleanup(*method_names)
-          register_fixture(:cleanup, *method_names)
+        def cleanup(*method_names, &callback)
+          register_fixture(:cleanup, *method_names, &callback)
         end
 
-        def unregister_cleanup(*method_names)
-          unregister_fixture(:cleanup, *method_names)
+        def unregister_cleanup(*method_names_or_callbacks)
+          unregister_fixture(:cleanup, *method_names_or_callbacks)
         end
 
-        def teardown(*method_names)
-          register_fixture(:teardown, *method_names)
+        def teardown(*method_names, &callback)
+          register_fixture(:teardown, *method_names, &callback)
         end
 
-        def unregister_teardown(*method_names)
-          unregister_fixture(:teardown, *method_names)
+        def unregister_teardown(*method_names_or_callbacks)
+          unregister_fixture(:teardown, *method_names_or_callbacks)
         end
 
-        def register_setup_method(method_name, options)
-          register_fixture_method(:setup, method_name, options, :after, :append)
+        def register_setup_callback(method_name_or_callback, options)
+          register_fixture_callback(:setup, method_name_or_callback,
+                                    options, :after, :append)
         end
 
-        def unregister_setup_method(method_name)
-          unregister_fixture_method(:setup, method_name)
+        def unregister_setup_callback(method_name_or_callback)
+          unregister_fixture_callback(:setup, method_name_or_callback)
         end
 
-        def register_cleanup_method(method_name, options)
-          register_fixture_method(:cleanup, method_name, options,
-                                  :before, :prepend)
+        def register_cleanup_callback(method_name_or_callback, options)
+          register_fixture_callback(:cleanup, method_name_or_callback,
+                                    options, :before, :prepend)
         end
 
-        def unregister_cleanup_method(method_name)
-          unregister_fixture_method(:cleanup, method_name)
+        def unregister_cleanup_callback(method_name_or_callback)
+          unregister_fixture_callback(:cleanup, method_name_or_callback)
         end
 
-        def register_teardown_method(method_name, options)
-          register_fixture_method(:teardown, method_name, options,
-                                  :before, :prepend)
+        def register_teardown_callback(method_name_or_callback, options)
+          register_fixture_callback(:teardown, method_name_or_callback,
+                                    options, :before, :prepend)
         end
 
-        def unregister_teardown_method(method_name)
-          unregister_fixture_method(:teardown, method_name)
+        def unregister_teardown_callback(method_name_or_callback)
+          unregister_fixture_callback(:teardown, method_name_or_callback)
         end
 
-        def before_setup_methods
-          collect_fixture_methods(:setup, :before)
+        def before_setup_callbacks
+          collect_fixture_callbacks(:setup, :before)
         end
 
-        def after_setup_methods
-          collect_fixture_methods(:setup, :after)
+        def after_setup_callbacks
+          collect_fixture_callbacks(:setup, :after)
         end
 
-        def before_cleanup_methods
-          collect_fixture_methods(:cleanup, :before)
+        def before_cleanup_callbacks
+          collect_fixture_callbacks(:cleanup, :before)
         end
 
-        def after_cleanup_methods
-          collect_fixture_methods(:cleanup, :after)
+        def after_cleanup_callbacks
+          collect_fixture_callbacks(:cleanup, :after)
         end
 
-        def before_teardown_methods
-          collect_fixture_methods(:teardown, :before)
+        def before_teardown_callbacks
+          collect_fixture_callbacks(:teardown, :before)
         end
 
-        def after_teardown_methods
-          collect_fixture_methods(:teardown, :after)
+        def after_teardown_callbacks
+          collect_fixture_callbacks(:teardown, :after)
         end
 
         private
-        def register_fixture(fixture, *method_names)
+        def register_fixture(fixture, *method_names, &callback)
           options = {}
           options = method_names.pop if method_names.last.is_a?(Hash)
-          attribute(fixture, options, *method_names)
+          callbacks = method_names
+          callbacks << callback if callback
+          attribute(fixture, options, *callbacks)
         end
 
-        def unregister_fixture(fixture, *method_names)
-          attribute(fixture, nil, *method_names)
+        def unregister_fixture(fixture, *method_names_or_callbacks)
+          attribute(fixture, nil, *method_names_or_callbacks)
         end
 
         def valid_register_fixture_options?(options)
@@ -114,27 +116,27 @@ module Test
             [:prepend, :append].include?(options[key])
         end
 
-        def add_fixture_method_name(how, variable_name, method_name)
-          methods = instance_eval("#{variable_name} ||= []")
+        def add_fixture_callback(how, variable_name, method_name_or_callback)
+          callbacks = instance_eval("#{variable_name} ||= []")
 
           if how == :prepend
-            methods = [method_name] | methods
+            callbacks = [method_name_or_callback] | callbacks
           else
-            methods = methods | [method_name]
+            callbacks = callbacks | [method_name_or_callback]
           end
-          instance_variable_set(variable_name, methods)
+          instance_variable_set(variable_name, callbacks)
         end
 
-        def registered_methods_variable_name(fixture, order)
-          "@#{order}_#{fixture}_methods"
+        def registered_callbacks_variable_name(fixture, order)
+          "@#{order}_#{fixture}_callbacks"
         end
 
-        def unregistered_methods_variable_name(fixture)
-          "@unregistered_#{fixture}_methods"
+        def unregistered_callbacks_variable_name(fixture)
+          "@unregistered_#{fixture}_callbacks"
         end
 
-        def register_fixture_method(fixture, method_name, options,
-                                    default_order, default_how)
+        def register_fixture_callback(fixture, method_name_or_callback, options,
+                                      default_order, default_how)
           unless valid_register_fixture_options?(options)
             message = "must be {:before => :prepend}, " +
               "{:before => :append}, {:after => :prepend} or " +
@@ -147,29 +149,29 @@ module Test
           else
             order, how = options.to_a.first
           end
-          variable_name = registered_methods_variable_name(fixture, order)
-          add_fixture_method_name(how, variable_name, method_name)
+          variable_name = registered_callbacks_variable_name(fixture, order)
+          add_fixture_callback(how, variable_name, method_name_or_callback)
         end
 
-        def unregister_fixture_method(fixture, method_name)
-          variable_name = unregistered_methods_variable_name(fixture)
-          add_fixture_method_name(:append, variable_name, method_name)
+        def unregister_fixture_callback(fixture, method_name_or_callback)
+          variable_name = unregistered_callbacks_variable_name(fixture)
+          add_fixture_callback(:append, variable_name, method_name_or_callback)
         end
 
-        def collect_fixture_methods(fixture, order)
-          methods_variable = registered_methods_variable_name(fixture, order)
-          unregistered_methods_variable =
-            unregistered_methods_variable_name(fixture)
+        def collect_fixture_callbacks(fixture, order)
+          callbacks_variable = registered_callbacks_variable_name(fixture, order)
+          unregistered_callbacks_variable =
+            unregistered_callbacks_variable_name(fixture)
 
           base_index = ancestors.index(Fixture)
           interested_ancestors = ancestors[0, base_index].reverse
           interested_ancestors.inject([]) do |result, ancestor|
             if ancestor.is_a?(Class)
               ancestor.class_eval do
-                methods = instance_eval("#{methods_variable} ||= []")
-                unregistered_methods =
-                  instance_eval("#{unregistered_methods_variable} ||= []")
-                (result | methods) - unregistered_methods
+                callbacks = instance_eval("#{callbacks_variable} ||= []")
+                unregistered_callbacks =
+                  instance_eval("#{unregistered_callbacks_variable} ||= []")
+                (result | callbacks) - unregistered_callbacks
               end
             else
               result
@@ -181,21 +183,32 @@ module Test
       private
       def run_fixture(fixture, options={})
         [
-         self.class.send("before_#{fixture}_methods"),
+         self.class.send("before_#{fixture}_callbacks"),
          fixture,
-         self.class.send("after_#{fixture}_methods")
-        ].flatten.each do |method_name|
-          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)
+         self.class.send("after_#{fixture}_callbacks")
+        ].flatten.each do |method_name_or_callback|
+          run_fixture_callback(method_name_or_callback, options)
+        end
+      end
+
+      def run_fixture_callback(method_name_or_callback, options)
+        if method_name_or_callback.respond_to?(:call)
+          callback = lambda do
+            instance_eval(&method_name_or_callback)
+          end
+        else
+          return unless respond_to?(method_name_or_callback, true)
+          callback = lambda do
+            send(method_name_or_callback)
           end
         end
+
+        begin
+          callback.call
+        rescue Exception
+          raise unless options[:handle_exception]
+          raise unless handle_exception($!)
+        end
       end
 
       def run_setup

data/lib/test/unit/testcase.rb

@@ -3,7 +3,7 @@
 # Author:: Nathaniel Talbott.
 # Copyright::
 #   * Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
-#   * Copyright (c) 2008-2011 Kouhei Sutou <tt><kou@clear-code.com></tt>
+#   * Copyright (c) 2008-2012 Kouhei Sutou <tt><kou@clear-code.com></tt>
 # License:: Ruby license.
 
 require 'test/unit/attribute'
@@ -360,11 +360,19 @@ module Test
       #       ...
       #     end
       #
+      #     setup do
+      #       ... # setup callback1
+      #     end
+      #
       #     setup
       #     def my_setup2
       #       ...
       #     end
       #
+      #     setup do
+      #       ... # setup callback2
+      #     end
+      #
       #     def test_my_class
       #       ...
       #     end
@@ -373,7 +381,9 @@ module Test
       # Here is a call order:
       # * setup
       # * my_setup1
+      # * setup callback1
       # * my_setup2
+      # * setup callback2
       # * test_my_class
       def setup
       end
@@ -395,11 +405,19 @@ module Test
       #       ...
       #     end
       #
+      #     cleanup do
+      #       ... # cleanup callback1
+      #     end
+      #
       #     cleanup
       #     def my_cleanup2
       #       ...
       #     end
       #
+      #     cleanup do
+      #       ... # cleanup callback2
+      #     end
+      #
       #     def test_my_class
       #       ...
       #     end
@@ -407,7 +425,9 @@ module Test
       #
       # Here is a call order:
       # * test_my_class
+      # * cleanup callback2
       # * my_cleanup2
+      # * cleanup callback1
       # * my_cleanup1
       # * cleanup
       def cleanup
@@ -428,11 +448,19 @@ module Test
       #       ...
       #     end
       #
+      #     teardown do
+      #       ... # teardown callback1
+      #     end
+      #
       #     teardown
       #     def my_teardown2
       #       ...
       #     end
       #
+      #     teardown do
+      #       ... # teardown callback2
+      #     end
+      #
       #     def test_my_class
       #       ...
       #     end
@@ -440,7 +468,9 @@ module Test
       #
       # Here is a call order:
       # * test_my_class
+      # * teardown callback2
       # * my_teardown2
+      # * teardown callback1
       # * my_teardown1
       # * teardown
       def teardown

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

@@ -361,16 +361,25 @@ module Test
             end
           end
 
+          def output_progress_in_detail_marker(fault)
+            if @progress_row_max > 0
+              output("=" * @progress_row_max, fault_color(fault))
+            else
+              nl
+            end
+          end
+
           def output_progress_in_detail(fault)
             return if @output_level == SILENT
             nl
-            nl
+            output_progress_in_detail_marker(fault)
             if categorize_fault(fault) == :need_detail_faults
               output_fault_in_detail(fault)
             else
               output_fault_in_short(fault)
             end
-            nl
+            output_progress_in_detail_marker(fault)
+            @progress_row = 0
           end
 
           def output?(level)

data/lib/test/unit/version.rb

@@ -1,5 +1,5 @@
 module Test
   module Unit
-    VERSION = '2.4.3'
+    VERSION = '2.4.4'
   end
 end

data/test/test-assertions.rb

@@ -1542,6 +1542,12 @@ EOM
         end
       end
 
+      def test_pass_zero_expected
+        check_nothing_fails do
+          assert_in_epsilon(0, 0.00000001)
+        end
+      end
+
       def test_fail_with_message
         check_fails("message.\n" +
                     "<10000> -/+ (<10000> * <0.1>)[1000.0] " +

data/test/test-fixture.rb

@@ -2,460 +2,617 @@ class TestUnitFixture < Test::Unit::TestCase
   module EmptyModule
   end
 
-  def test_setup_without_option
-    expected_setup_calls = [:setup,
-                            :custom_setup_method0,
-                            :custom_setup_method1,
-                            :custom_setup_method3]
-    test_case = assert_setup(expected_setup_calls, [])
-    assert_inherited_setup(expected_setup_calls, test_case)
-
-    assert_inherited_setup([:setup], nil)
-    assert_called_fixtures(expected_setup_calls, test_case)
-  end
+  class TestSetup < self
+    def test_without_option
+      expected_setup_calls = [:setup,
+                              :custom_setup_method0,
+                              :custom_setup_callback0,
+                              :custom_setup_method1,
+                              :custom_setup_callback1,
+                              :custom_setup_method3,
+                              :custom_setup_callback3]
+      test_case = assert_setup(expected_setup_calls, [])
+      assert_inherited_setup(expected_setup_calls, test_case)
+
+      assert_inherited_setup([:setup], nil)
+      assert_called_fixtures(expected_setup_calls, test_case)
+    end
 
-  def test_setup_with_before_option
-    expected_setup_calls = [:custom_setup_method3,
-                            :custom_setup_method0,
-                            :custom_setup_method1,
-                            :setup]
-    test_case = assert_setup(expected_setup_calls,
-                             [[{:before => :append}],
-                              [{:before => :append}],
-                              [{:before => :prepend}],
-                              [{:before => :prepend}]])
-    assert_inherited_setup(expected_setup_calls, test_case)
-
-    assert_inherited_setup([:setup], nil)
-    assert_called_fixtures(expected_setup_calls, test_case)
-  end
+    def test_with_before_option
+      expected_setup_calls = [:custom_setup_callback3,
+                              :custom_setup_method3,
+                              :custom_setup_method0,
+                              :custom_setup_callback0,
+                              :custom_setup_method1,
+                              :custom_setup_callback1,
+                              :setup]
+      test_case = assert_setup(expected_setup_calls,
+                               [[{:before => :append}],
+                                [{:before => :append}],
+                                [{:before => :prepend}],
+                                [{:before => :prepend}]])
+      assert_inherited_setup(expected_setup_calls, test_case)
+
+      assert_inherited_setup([:setup], nil)
+      assert_called_fixtures(expected_setup_calls, test_case)
+    end
 
-  def test_setup_with_after_option
-    expected_setup_calls = [:setup,
-                            :custom_setup_method3,
-                            :custom_setup_method0,
-                            :custom_setup_method1]
-    test_case = assert_setup(expected_setup_calls,
-                             [[{:after => :append}],
-                              [{:after => :append}],
-                              [{:after => :prepend}],
-                              [{:after => :prepend}]])
-    assert_inherited_setup(expected_setup_calls, test_case)
-
-    assert_inherited_setup([:setup], nil)
-    assert_called_fixtures(expected_setup_calls, test_case)
-  end
+    def test_with_after_option
+      expected_setup_calls = [:setup,
+                              :custom_setup_callback3,
+                              :custom_setup_method3,
+                              :custom_setup_method0,
+                              :custom_setup_callback0,
+                              :custom_setup_method1,
+                              :custom_setup_callback1]
+      test_case = assert_setup(expected_setup_calls,
+                               [[{:after => :append}],
+                                [{:after => :append}],
+                                [{:after => :prepend}],
+                                [{:after => :prepend}]])
+      assert_inherited_setup(expected_setup_calls, test_case)
+
+      assert_inherited_setup([:setup], nil)
+      assert_called_fixtures(expected_setup_calls, test_case)
+    end
 
-  def test_setup_with_invalid_option
-    assert_invalid_setup_option(:unknown => true)
-    assert_invalid_setup_option(:before => :unknown)
-    assert_invalid_setup_option(:after => :unknown)
-  end
+    def test_with_invalid_option
+      assert_invalid_setup_option(:unknown => true)
+      assert_invalid_setup_option(:before => :unknown)
+      assert_invalid_setup_option(:after => :unknown)
+    end
 
-  def test_setup_with_option_to_inherited
-    expected_setup_calls = [:setup]
-    test_case = assert_setup(expected_setup_calls, nil)
-    assert_inherited_setup([:setup,
-                            :custom_setup_method0,
-                            :custom_setup_method1,
-                            :custom_setup_method3],
-                           test_case,
-                           [])
-
-    assert_inherited_setup([:setup], nil)
-    assert_called_fixtures(expected_setup_calls, test_case)
-  end
+    def test_with_option_to_inherited
+      expected_setup_calls = [:setup]
+      test_case = assert_setup(expected_setup_calls, nil)
+      assert_inherited_setup([:setup,
+                              :custom_setup_method0,
+                              :custom_setup_callback0,
+                              :custom_setup_method1,
+                              :custom_setup_callback1,
+                              :custom_setup_method3,
+                              :custom_setup_callback3],
+                             test_case,
+                             [])
+
+      assert_inherited_setup([:setup], nil)
+      assert_called_fixtures(expected_setup_calls, test_case)
+    end
 
-  def test_cleanup_without_option
-    expected_cleanup_calls = [:custom_cleanup_method3,
-                              :custom_cleanup_method1,
-                              :custom_cleanup_method0,
-                              :cleanup]
-    test_case = assert_cleanup(expected_cleanup_calls, [])
-    assert_inherited_cleanup(expected_cleanup_calls, test_case)
+    private
+    def assert_setup_customizable(expected, parent, options)
+      test_case = Class.new(parent || Test::Unit::TestCase) do
+        yield(self, :before) if block_given?
 
-    assert_inherited_cleanup([:cleanup], nil)
-    assert_called_fixtures(expected_cleanup_calls, test_case)
-  end
+        def called_ids
+          @called_ids ||= []
+        end
 
-  def test_cleanup_with_before_option
-    expected_cleanup_calls = [:custom_cleanup_method3,
-                              :custom_cleanup_method0,
-                              :custom_cleanup_method1,
-                              :cleanup]
-    test_case = assert_cleanup(expected_cleanup_calls,
-                                [[{:before => :append}],
-                                 [{:before => :append}],
-                                 [{:before => :prepend}],
-                                 [{:before => :prepend}]])
-    assert_inherited_cleanup(expected_cleanup_calls, test_case)
-
-    assert_inherited_cleanup([:cleanup], nil)
-    assert_called_fixtures(expected_cleanup_calls, test_case)
-  end
+        def called(id)
+          called_ids << id
+        end
 
-  def test_cleanup_with_after_option
-    expected_cleanup_calls = [:cleanup,
-                              :custom_cleanup_method3,
-                              :custom_cleanup_method0,
-                              :custom_cleanup_method1]
-    test_case = assert_cleanup(expected_cleanup_calls,
-                                [[{:after => :append}],
-                                 [{:after => :append}],
-                                 [{:after => :prepend}],
-                                 [{:after => :prepend}]])
-    assert_inherited_cleanup(expected_cleanup_calls, test_case)
-
-    assert_inherited_cleanup([:cleanup], nil)
-    assert_called_fixtures(expected_cleanup_calls, test_case)
-  end
+        def setup
+          called(:setup)
+        end
 
-  def test_cleanup_with_invalid_option
-    assert_invalid_cleanup_option(:unknown => true)
-    assert_invalid_cleanup_option(:before => :unknown)
-    assert_invalid_cleanup_option(:after => :unknown)
-  end
+        setup(*(options[0] || [])) if options
+        def custom_setup_method0
+          called(:custom_setup_method0)
+        end
 
-  def test_cleanup_with_option_to_inherited
-    expected_cleanup_calls = [:cleanup]
-    test_case = assert_cleanup(expected_cleanup_calls, nil)
-    assert_inherited_cleanup([:custom_cleanup_method3,
-                              :custom_cleanup_method1,
-                              :custom_cleanup_method0,
-                              :cleanup],
-                              test_case, [])
-
-    assert_inherited_cleanup([:cleanup], nil)
-    assert_called_fixtures(expected_cleanup_calls, test_case)
-  end
+        if options
+          setup(*(options[0] || [])) do
+            called(:custom_setup_callback0)
+          end
+        end
 
-  def test_cleanup_with_exception
-    test_case = Class.new(Test::Unit::TestCase) do
-      def called_ids
-        @called_ids ||= []
-      end
+        def custom_setup_method1
+          called(:custom_setup_method1)
+        end
+        setup(*[:custom_setup_method1, *(options[1] || [])]) if options
 
-      def called(id)
-        called_ids << id
-      end
+        if options
+          setup(*(options[1] || [])) do
+            called(:custom_setup_callback1)
+          end
+        end
 
-      def cleanup
-        called(:cleanup)
-        raise "cleanup"
-      end
+        setup(*(options[2] || [])) if options
+        def custom_setup_method2
+          called(:custom_setup_method2)
+        end
+        unregister_setup(:custom_setup_method2) if options
+
+        if options
+          callback = lambda do
+            called(:custom_setup_callback2)
+          end
+          setup(*(options[2] || []), &callback)
+          unregister_setup(callback)
+        end
 
-      cleanup
-      def custom_cleanup_method0
-        called(:custom_cleanup_method0)
-        raise "custom_cleanup_method0"
+        setup(*(options[3] || [])) if options
+        def custom_setup_method3
+          called(:custom_setup_method3)
+        end
+
+        if options
+          setup(*(options[3] || [])) do
+            called(:custom_setup_callback3)
+          end
+        end
+
+        def test_nothing
+        end
+
+        yield(self, :after) if block_given?
       end
 
-      cleanup
-      def custom_cleanup_method1
-        called(:custom_cleanup_method1)
-        raise "custom_cleanup_method1"
+      assert_called_fixtures(expected, test_case)
+      test_case
+    end
+
+    def assert_setup(expected, options)
+      _test_case = assert_setup_customizable(expected, nil, options)
+      assert_setup_customizable(expected, nil, options) do |test_case, tag|
+        test_case.send(:include, EmptyModule) if tag == :before
       end
+      _test_case
+    end
 
-      def test_nothing
+    def assert_inherited_setup(expected, parent, options=nil)
+      _test_case = assert_setup_customizable(expected, parent, options)
+      assert_setup_customizable(expected, parent, options) do |test_case, tag|
+        test_case.send(:include, EmptyModule) if tag == :before
       end
+      _test_case
     end
 
-    assert_called_fixtures([:custom_cleanup_method1],
-                           test_case)
+    def assert_invalid_setup_option(option)
+      assert_invalid_option(:setup, option)
+    end
   end
 
-  def test_teardown_without_option
-    expected_teardown_calls = [:custom_teardown_method3,
-                               :custom_teardown_method1,
-                               :custom_teardown_method0,
-                               :teardown]
-    test_case = assert_teardown(expected_teardown_calls, [])
-    assert_inherited_teardown(expected_teardown_calls, test_case)
+  class TestCleanup < self
+    def test_without_option
+      expected_cleanup_calls = [:custom_cleanup_callback3,
+                                :custom_cleanup_method3,
+                                :custom_cleanup_callback1,
+                                :custom_cleanup_method1,
+                                :custom_cleanup_callback0,
+                                :custom_cleanup_method0,
+                                :cleanup]
+      test_case = assert_cleanup(expected_cleanup_calls, [])
+      assert_inherited_cleanup(expected_cleanup_calls, test_case)
+
+      assert_inherited_cleanup([:cleanup], nil)
+      assert_called_fixtures(expected_cleanup_calls, test_case)
+    end
 
-    assert_inherited_teardown([:teardown], nil)
-    assert_called_fixtures(expected_teardown_calls, test_case)
-  end
+    def test_with_before_option
+      expected_cleanup_calls = [:custom_cleanup_callback3,
+                                :custom_cleanup_method3,
+                                :custom_cleanup_method0,
+                                :custom_cleanup_callback0,
+                                :custom_cleanup_method1,
+                                :custom_cleanup_callback1,
+                                :cleanup]
+      test_case = assert_cleanup(expected_cleanup_calls,
+                                  [[{:before => :append}],
+                                   [{:before => :append}],
+                                   [{:before => :prepend}],
+                                   [{:before => :prepend}]])
+      assert_inherited_cleanup(expected_cleanup_calls, test_case)
+
+      assert_inherited_cleanup([:cleanup], nil)
+      assert_called_fixtures(expected_cleanup_calls, test_case)
+    end
 
-  def test_teardown_with_before_option
-    expected_teardown_calls = [:custom_teardown_method3,
-                               :custom_teardown_method0,
-                               :custom_teardown_method1,
-                               :teardown]
-    test_case = assert_teardown(expected_teardown_calls,
-                                [[{:before => :append}],
-                                 [{:before => :append}],
-                                 [{:before => :prepend}],
-                                 [{:before => :prepend}]])
-    assert_inherited_teardown(expected_teardown_calls, test_case)
-
-    assert_inherited_teardown([:teardown], nil)
-    assert_called_fixtures(expected_teardown_calls, test_case)
-  end
+    def test_with_after_option
+      expected_cleanup_calls = [:cleanup,
+                                :custom_cleanup_callback3,
+                                :custom_cleanup_method3,
+                                :custom_cleanup_method0,
+                                :custom_cleanup_callback0,
+                                :custom_cleanup_method1,
+                                :custom_cleanup_callback1]
+      test_case = assert_cleanup(expected_cleanup_calls,
+                                  [[{:after => :append}],
+                                   [{:after => :append}],
+                                   [{:after => :prepend}],
+                                   [{:after => :prepend}]])
+      assert_inherited_cleanup(expected_cleanup_calls, test_case)
+
+      assert_inherited_cleanup([:cleanup], nil)
+      assert_called_fixtures(expected_cleanup_calls, test_case)
+    end
 
-  def test_teardown_with_after_option
-    expected_teardown_calls = [:teardown,
-                               :custom_teardown_method3,
-                               :custom_teardown_method0,
-                               :custom_teardown_method1]
-    test_case = assert_teardown(expected_teardown_calls,
-                                [[{:after => :append}],
-                                 [{:after => :append}],
-                                 [{:after => :prepend}],
-                                 [{:after => :prepend}]])
-    assert_inherited_teardown(expected_teardown_calls, test_case)
-
-    assert_inherited_teardown([:teardown], nil)
-    assert_called_fixtures(expected_teardown_calls, test_case)
-  end
+    def test_with_invalid_option
+      assert_invalid_cleanup_option(:unknown => true)
+      assert_invalid_cleanup_option(:before => :unknown)
+      assert_invalid_cleanup_option(:after => :unknown)
+    end
 
-  def test_teardown_with_invalid_option
-    assert_invalid_teardown_option(:unknown => true)
-    assert_invalid_teardown_option(:before => :unknown)
-    assert_invalid_teardown_option(:after => :unknown)
-  end
+    def test_with_option_to_inherited
+      expected_cleanup_calls = [:cleanup]
+      test_case = assert_cleanup(expected_cleanup_calls, nil)
+      assert_inherited_cleanup([:custom_cleanup_callback3,
+                                :custom_cleanup_method3,
+                                :custom_cleanup_callback1,
+                                :custom_cleanup_method1,
+                                :custom_cleanup_callback0,
+                                :custom_cleanup_method0,
+                                :cleanup],
+                                test_case, [])
+
+      assert_inherited_cleanup([:cleanup], nil)
+      assert_called_fixtures(expected_cleanup_calls, test_case)
+    end
 
-  def test_teardown_with_option_to_inherited
-    expected_teardown_calls = [:teardown]
-    test_case = assert_teardown(expected_teardown_calls, nil)
-    assert_inherited_teardown([:custom_teardown_method3,
-                               :custom_teardown_method1,
-                               :custom_teardown_method0,
-                               :teardown],
-                              test_case, [])
-
-    assert_inherited_teardown([:teardown], nil)
-    assert_called_fixtures(expected_teardown_calls, test_case)
-  end
+    def test_with_exception
+      test_case = Class.new(Test::Unit::TestCase) do
+        def called_ids
+          @called_ids ||= []
+        end
 
-  def test_teardown_with_exception
-    test_case = Class.new(Test::Unit::TestCase) do
-      def called_ids
-        @called_ids ||= []
-      end
+        def called(id)
+          called_ids << id
+        end
 
-      def called(id)
-        called_ids << id
-      end
+        def cleanup
+          called(:cleanup)
+          raise "cleanup"
+        end
 
-      def teardown
-        called(:teardown)
-        raise "teardown"
-      end
+        cleanup
+        def custom_cleanup_method0
+          called(:custom_cleanup_method0)
+          raise "custom_cleanup_method0"
+        end
 
-      teardown
-      def custom_teardown_method0
-        called(:custom_teardown_method0)
-        raise "custom_teardown_method0"
-      end
+        cleanup do
+          called(:custom_cleanup_callback0)
+          raise "custom_cleanup_callback0"
+        end
 
-      teardown
-      def custom_teardown_method1
-        called(:custom_teardown_method1)
-        raise "custom_teardown_method1"
-      end
+        cleanup
+        def custom_cleanup_method1
+          called(:custom_cleanup_method1)
+          raise "custom_cleanup_method1"
+        end
+
+        cleanup do
+          called(:custom_cleanup_callback1)
+          raise "custom_cleanup_callback1"
+        end
 
-      def test_nothing
+        def test_nothing
+        end
       end
+
+      assert_called_fixtures([:custom_cleanup_callback1],
+                             test_case)
     end
 
-    assert_called_fixtures([:custom_teardown_method1,
-                            :custom_teardown_method0,
-                            :teardown],
-                           test_case)
-  end
+    private
+    def assert_cleanup_customizable(expected, parent, options)
+      test_case = Class.new(parent || Test::Unit::TestCase) do
+        yield(self, :before) if block_given?
 
-  private
-  def assert_called_fixtures(expected, test_case)
-    test = test_case.new("test_nothing")
-    test.run(Test::Unit::TestResult.new) {}
-    assert_equal(expected, test.called_ids)
-  end
+        def called_ids
+          @called_ids ||= []
+        end
 
-  def assert_setup_customizable(expected, parent, options)
-    test_case = Class.new(parent || Test::Unit::TestCase) do
-      yield(self, :before) if block_given?
+        def called(id)
+          called_ids << id
+        end
 
-      def called_ids
-        @called_ids ||= []
-      end
+        def cleanup
+          called(:cleanup)
+        end
 
-      def called(id)
-        called_ids << id
-      end
+        cleanup(*(options[0] || [])) if options
+        def custom_cleanup_method0
+          called(:custom_cleanup_method0)
+        end
 
-      def setup
-        called(:setup)
-      end
+        if options
+          cleanup(*(options[0] || [])) do
+            called(:custom_cleanup_callback0)
+          end
+        end
 
-      setup(*(options[0] || [])) if options
-      def custom_setup_method0
-        called(:custom_setup_method0)
-      end
+        def custom_cleanup_method1
+          called(:custom_cleanup_method1)
+        end
+        cleanup(*[:custom_cleanup_method1, *(options[1] || [])]) if options
 
-      def custom_setup_method1
-        called(:custom_setup_method1)
-      end
-      setup(*[:custom_setup_method1, *(options[1] || [])]) if options
+        if options
+          cleanup(*(options[1] || [])) do
+            called(:custom_cleanup_callback1)
+          end
+        end
 
-      setup(*(options[2] || [])) if options
-      def custom_setup_method2
-        called(:custom_setup_method2)
-      end
-      unregister_setup(:custom_setup_method2) if options
+        cleanup(*(options[2] || [])) if options
+        def custom_cleanup_method2
+          called(:custom_cleanup_method2)
+        end
+        unregister_cleanup(:custom_cleanup_method2) if options
+
+        if options
+          callback = lambda do
+            called(:custom_cleanup_callback2)
+          end
+          cleanup(*(options[2] || []), &callback)
+          unregister_cleanup(callback)
+        end
 
-      setup(*(options[3] || [])) if options
-      def custom_setup_method3
-        called(:custom_setup_method3)
+        cleanup(*(options[3] || [])) if options
+        def custom_cleanup_method3
+          called(:custom_cleanup_method3)
+        end
+
+        if options
+          cleanup(*(options[3] || [])) do
+            called(:custom_cleanup_callback3)
+          end
+        end
+
+        def test_nothing
+        end
+
+        yield(self, :after) if block_given?
       end
 
-      def test_nothing
+      assert_called_fixtures(expected, test_case)
+      test_case
+    end
+
+    def assert_cleanup(expected, options)
+      assert_cleanup_customizable(expected, nil, options)
+      assert_cleanup_customizable(expected, nil, options) do |test_case, tag|
+        test_case.send(:include, EmptyModule) if tag == :before
       end
+    end
 
-      yield(self, :after) if block_given?
+    def assert_inherited_cleanup(expected, parent, options=nil)
+      assert_cleanup_customizable(expected, parent, options)
+      assert_cleanup_customizable(expected, parent, options) do |test_case, tag|
+        test_case.send(:include, EmptyModule) if tag == :before
+      end
     end
 
-    assert_called_fixtures(expected, test_case)
-    test_case
+    def assert_invalid_cleanup_option(option)
+      assert_invalid_option(:cleanup, option)
+    end
   end
 
-  def assert_setup(expected, options)
-    _test_case = assert_setup_customizable(expected, nil, options)
-    assert_setup_customizable(expected, nil, options) do |test_case, tag|
-      test_case.send(:include, EmptyModule) if tag == :before
+  class TestTeardown < self
+    def test_without_option
+      expected_teardown_calls = [:custom_teardown_callback3,
+                                 :custom_teardown_method3,
+                                 :custom_teardown_callback1,
+                                 :custom_teardown_method1,
+                                 :custom_teardown_callback0,
+                                 :custom_teardown_method0,
+                                 :teardown]
+      test_case = assert_teardown(expected_teardown_calls, [])
+      assert_inherited_teardown(expected_teardown_calls, test_case)
+
+      assert_inherited_teardown([:teardown], nil)
+      assert_called_fixtures(expected_teardown_calls, test_case)
     end
-    _test_case
-  end
 
-  def assert_inherited_setup(expected, parent, options=nil)
-    _test_case = assert_setup_customizable(expected, parent, options)
-    assert_setup_customizable(expected, parent, options) do |test_case, tag|
-      test_case.send(:include, EmptyModule) if tag == :before
+    def test_with_before_option
+      expected_teardown_calls = [:custom_teardown_callback3,
+                                 :custom_teardown_method3,
+                                 :custom_teardown_method0,
+                                 :custom_teardown_callback0,
+                                 :custom_teardown_method1,
+                                 :custom_teardown_callback1,
+                                 :teardown]
+      test_case = assert_teardown(expected_teardown_calls,
+                                  [[{:before => :append}],
+                                   [{:before => :append}],
+                                   [{:before => :prepend}],
+                                   [{:before => :prepend}]])
+      assert_inherited_teardown(expected_teardown_calls, test_case)
+
+      assert_inherited_teardown([:teardown], nil)
+      assert_called_fixtures(expected_teardown_calls, test_case)
     end
-    _test_case
-  end
 
-  def assert_cleanup_customizable(expected, parent, options)
-    test_case = Class.new(parent || Test::Unit::TestCase) do
-      yield(self, :before) if block_given?
+    def test_with_after_option
+      expected_teardown_calls = [:teardown,
+                                 :custom_teardown_callback3,
+                                 :custom_teardown_method3,
+                                 :custom_teardown_method0,
+                                 :custom_teardown_callback0,
+                                 :custom_teardown_method1,
+                                 :custom_teardown_callback1]
+      test_case = assert_teardown(expected_teardown_calls,
+                                  [[{:after => :append}],
+                                   [{:after => :append}],
+                                   [{:after => :prepend}],
+                                   [{:after => :prepend}]])
+      assert_inherited_teardown(expected_teardown_calls, test_case)
+
+      assert_inherited_teardown([:teardown], nil)
+      assert_called_fixtures(expected_teardown_calls, test_case)
+    end
 
-      def called_ids
-        @called_ids ||= []
-      end
+    def test_with_invalid_option
+      assert_invalid_teardown_option(:unknown => true)
+      assert_invalid_teardown_option(:before => :unknown)
+      assert_invalid_teardown_option(:after => :unknown)
+    end
 
-      def called(id)
-        called_ids << id
-      end
+    def test_with_option_to_inherited
+      expected_teardown_calls = [:teardown]
+      test_case = assert_teardown(expected_teardown_calls, nil)
+      assert_inherited_teardown([:custom_teardown_callback3,
+                                 :custom_teardown_method3,
+                                 :custom_teardown_callback1,
+                                 :custom_teardown_method1,
+                                 :custom_teardown_callback0,
+                                 :custom_teardown_method0,
+                                 :teardown],
+                                test_case, [])
+
+      assert_inherited_teardown([:teardown], nil)
+      assert_called_fixtures(expected_teardown_calls, test_case)
+    end
 
-      def cleanup
-        called(:cleanup)
-      end
+    def test_with_exception
+      test_case = Class.new(Test::Unit::TestCase) do
+        def called_ids
+          @called_ids ||= []
+        end
 
-      cleanup(*(options[0] || [])) if options
-      def custom_cleanup_method0
-        called(:custom_cleanup_method0)
-      end
+        def called(id)
+          called_ids << id
+        end
 
-      def custom_cleanup_method1
-        called(:custom_cleanup_method1)
-      end
-      cleanup(*[:custom_cleanup_method1, *(options[1] || [])]) if options
+        def teardown
+          called(:teardown)
+          raise "teardown"
+        end
 
-      cleanup(*(options[2] || [])) if options
-      def custom_cleanup_method2
-        called(:custom_cleanup_method2)
-      end
-      unregister_cleanup(:custom_cleanup_method2) if options
+        teardown
+        def custom_teardown_method0
+          called(:custom_teardown_method0)
+          raise "custom_teardown_method0"
+        end
 
-      cleanup(*(options[3] || [])) if options
-      def custom_cleanup_method3
-        called(:custom_cleanup_method3)
-      end
+        teardown do
+          called(:custom_teardown_callback0)
+          raise "custom_teardown_callback0"
+        end
+
+        teardown
+        def custom_teardown_method1
+          called(:custom_teardown_method1)
+          raise "custom_teardown_method1"
+        end
+
+        teardown do
+          called(:custom_teardown_callback1)
+          raise "custom_teardown_callback1"
+        end
 
-      def test_nothing
+        def test_nothing
+        end
       end
 
-      yield(self, :after) if block_given?
+      assert_called_fixtures([:custom_teardown_callback1,
+                              :custom_teardown_method1,
+                              :custom_teardown_callback0,
+                              :custom_teardown_method0,
+                              :teardown],
+                             test_case)
     end
 
-    assert_called_fixtures(expected, test_case)
-    test_case
-  end
+    private
+    def assert_teardown_customizable(expected, parent, options)
+      test_case = Class.new(parent || Test::Unit::TestCase) do
+        yield(self, :before) if block_given?
 
-  def assert_cleanup(expected, options)
-    assert_cleanup_customizable(expected, nil, options)
-    assert_cleanup_customizable(expected, nil, options) do |test_case, tag|
-      test_case.send(:include, EmptyModule) if tag == :before
-    end
-  end
+        def called_ids
+          @called_ids ||= []
+        end
 
-  def assert_inherited_cleanup(expected, parent, options=nil)
-    assert_cleanup_customizable(expected, parent, options)
-    assert_cleanup_customizable(expected, parent, options) do |test_case, tag|
-      test_case.send(:include, EmptyModule) if tag == :before
-    end
-  end
+        def called(id)
+          called_ids << id
+        end
 
-  def assert_teardown_customizable(expected, parent, options)
-    test_case = Class.new(parent || Test::Unit::TestCase) do
-      yield(self, :before) if block_given?
+        def teardown
+          called(:teardown)
+        end
 
-      def called_ids
-        @called_ids ||= []
-      end
+        teardown(*(options[0] || [])) if options
+        def custom_teardown_method0
+          called(:custom_teardown_method0)
+        end
 
-      def called(id)
-        called_ids << id
-      end
+        if options
+          teardown(*(options[0] || [])) do
+            called(:custom_teardown_callback0)
+          end
+        end
 
-      def teardown
-        called(:teardown)
-      end
+        def custom_teardown_method1
+          called(:custom_teardown_method1)
+        end
+        teardown(*[:custom_teardown_method1, *(options[1] || [])]) if options
 
-      teardown(*(options[0] || [])) if options
-      def custom_teardown_method0
-        called(:custom_teardown_method0)
-      end
+        if options
+          teardown(*(options[1] || [])) do
+            called(:custom_teardown_callback1)
+          end
+        end
 
-      def custom_teardown_method1
-        called(:custom_teardown_method1)
-      end
-      teardown(*[:custom_teardown_method1, *(options[1] || [])]) if options
+        teardown(*(options[2] || [])) if options
+        def custom_teardown_method2
+          called(:custom_teardown_method2)
+        end
+        unregister_teardown(:custom_teardown_method2) if options
+
+        if options
+          callback = lambda do
+            called(:custom_teardown_callback2)
+          end
+          teardown(*(options[2] || []), &callback)
+          unregister_teardown(callback)
+        end
 
-      teardown(*(options[2] || [])) if options
-      def custom_teardown_method2
-        called(:custom_teardown_method2)
-      end
-      unregister_teardown(:custom_teardown_method2) if options
+        teardown(*(options[3] || [])) if options
+        def custom_teardown_method3
+          called(:custom_teardown_method3)
+        end
 
-      teardown(*(options[3] || [])) if options
-      def custom_teardown_method3
-        called(:custom_teardown_method3)
-      end
+        if options
+          teardown(*(options[3] || [])) do
+            called(:custom_teardown_callback3)
+          end
+        end
 
-      def test_nothing
+        def test_nothing
+        end
+
+        yield(self, :after) if block_given?
       end
 
-      yield(self, :after) if block_given?
+      assert_called_fixtures(expected, test_case)
+      test_case
     end
 
-    assert_called_fixtures(expected, test_case)
-    test_case
-  end
+    def assert_teardown(expected, options)
+      assert_teardown_customizable(expected, nil, options)
+      assert_teardown_customizable(expected, nil, options) do |test_case, tag|
+        test_case.send(:include, EmptyModule) if tag == :before
+      end
+    end
 
-  def assert_teardown(expected, options)
-    assert_teardown_customizable(expected, nil, options)
-    assert_teardown_customizable(expected, nil, options) do |test_case, tag|
-      test_case.send(:include, EmptyModule) if tag == :before
+    def assert_inherited_teardown(expected, parent, options=nil)
+      assert_teardown_customizable(expected, parent, options)
+      assert_teardown_customizable(expected, parent, options) do |test_case, tag|
+        test_case.send(:include, EmptyModule) if tag == :before
+      end
     end
-  end
 
-  def assert_inherited_teardown(expected, parent, options=nil)
-    assert_teardown_customizable(expected, parent, options)
-    assert_teardown_customizable(expected, parent, options) do |test_case, tag|
-      test_case.send(:include, EmptyModule) if tag == :before
+    def assert_invalid_teardown_option(option)
+      assert_invalid_option(:teardown, option)
     end
   end
 
+  private
+  def assert_called_fixtures(expected, test_case)
+    test = test_case.new("test_nothing")
+    test.run(Test::Unit::TestResult.new) {}
+    assert_equal(expected, test.called_ids)
+  end
+
   def assert_invalid_option(fixture_type, option)
     exception = assert_raise(ArgumentError) do
       Class.new(Test::Unit::TestCase) do
@@ -472,16 +629,4 @@ class TestUnitFixture < Test::Unit::TestCase
                  ": #{option.inspect}",
                  exception.message)
   end
-
-  def assert_invalid_setup_option(option)
-    assert_invalid_option(:setup, option)
-  end
-
-  def assert_invalid_cleanup_option(option)
-    assert_invalid_option(:cleanup, option)
-  end
-
-  def assert_invalid_teardown_option(option)
-    assert_invalid_option(:teardown, option)
-  end
 end