win32-api 1.5.3-universal-mingw32 → 1.6.0-universal-mingw32

data/vendor/bundle/ruby/2.2.0/gems/test-unit-3.1.9/test/test-emacs-runner.rb

@@ -0,0 +1,60 @@
+require 'test/unit'
+require 'test/unit/ui/emacs/testrunner'
+
+class TestUnitEmacsRunner < Test::Unit::TestCase
+  def test_format_failure_with_a_location
+    runner = create_runner
+    test_name = "test_failure"
+    file = "/home/user/test_xxx.rb"
+    line = "3"
+    info = "in `xxx'"
+    location = "#{file}:#{line}: #{info}"
+    message = "FAIL!!!"
+    failure = Test::Unit::Failure.new(test_name, [location], message)
+    assert_equal(<<-EOM.chomp, runner.send(:format_fault, failure))
+Failure:
+#{test_name} [#{file}:#{line}]:
+#{message}
+EOM
+  end
+
+  def test_format_failure_with_locations
+    runner = create_runner
+    test_name = "test_failure"
+    locations = ["/home/user/test_xxx.rb:3: in `xxx'",
+                 "/home/user/yyy/test_yyy.rb:999: in `yyy'",
+                 "/home/user/xyz/zzz.rb:29: in `zzz'"]
+    message = "Many backtrace!!!"
+    failure = Test::Unit::Failure.new(test_name, locations, message)
+    assert_equal(<<-EOM.chomp, runner.send(:format_fault, failure))
+Failure:
+#{test_name}
+#{locations.join("\n")}:
+#{message}
+EOM
+  end
+
+  def test_format_error
+    runner = create_runner
+    test_name = "test_error"
+    message = "Error Message!!!"
+    backtrace = ["/home/user/test_xxx.rb:3: in `xxx'",
+                 "/home/user/yyy/test_yyy.rb:999: in `yyy'",
+                 "/home/user/xyz/zzz.rb:29: in `zzz'"]
+    exception = RuntimeError.new(message)
+    exception.set_backtrace(backtrace)
+    error = Test::Unit::Error.new(test_name, exception)
+    assert_equal(<<-EOM.chomp, runner.send(:format_fault, error))
+Error:
+#{test_name}:
+#{exception.class.name}: #{message}
+#{backtrace.join("\n")}
+EOM
+  end
+
+  private
+  def create_runner(suite=nil)
+    suite ||= Test::Unit::TestSuite.new
+    Test::Unit::UI::Emacs::TestRunner.new(suite)
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/test-unit-3.1.9/test/test-error.rb

@@ -0,0 +1,26 @@
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
+# License:: Ruby license.
+
+require 'test/unit'
+
+module Test
+  module Unit
+    class TC_Error < TestCase
+      TF_Exception = Struct.new('TF_Exception', :message, :backtrace)
+      def test_display
+        ex = TF_Exception.new("message1\nmessage2", ['line1', 'line2'])
+        e = Error.new("name", ex)
+        assert_equal("name: #{TF_Exception.name}: message1", e.short_display)
+        assert_equal(<<EOM.strip, e.long_display)
+Error:
+name:
+Struct::TF_Exception: message1
+message2
+    line1
+    line2
+EOM
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/test-unit-3.1.9/test/test-failure.rb

@@ -0,0 +1,33 @@
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2003 Nathaniel Talbott. All rights reserved.
+# License:: Ruby license.
+
+require 'test/unit'
+require 'test/unit/failure'
+
+module Test::Unit
+  class TestFailure < TestCase
+    def test_display
+      f = Failure.new("name", [%q{location:1 in 'l'}], "message1\nmessage2")
+      assert_equal("name: message1", f.short_display)
+      assert_equal(<<EOM.strip, f.long_display)
+Failure:
+name [location:1]:
+message1
+message2
+EOM
+
+      f = Failure.new("name", [%q{location1:2 in 'l1'}, 'location2:1', %q{location3:3 in 'l3'}], "message1\nmessage2")
+      assert_equal("name: message1", f.short_display)
+      assert_equal(<<EOM.strip, f.long_display)
+Failure:
+name
+    [location1:2 in 'l1'
+     location2:1
+     location3:3 in 'l3']:
+message1
+message2
+EOM
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/test-unit-3.1.9/test/test-fault-location-detector.rb

@@ -0,0 +1,163 @@
+# Copyright (C) 2012  Kouhei Sutou <kou@clear-code.com>
+#
+# License: Ruby's
+
+require "test-unit"
+require "test/unit/fault-location-detector"
+require "testunit-test-util"
+
+class TestFaultLocationDetector < Test::Unit::TestCase
+  include TestUnitTestUtil
+
+  def setup
+    @fetcher = Test::Unit::CodeSnippetFetcher.new
+  end
+
+  private
+  def run_test_case(test_case)
+    suite = test_case.suite
+    result = Test::Unit::TestResult.new
+    suite.run(result) {}
+    result.faults[0]
+  end
+
+  def assert_detect(fault, target_line_number)
+    detector = Test::Unit::FaultLocationDetector.new(fault, @fetcher)
+
+    expected_backtrace_entries_until_detected = []
+    fault.location.each do |backtrace_entry|
+      expected_backtrace_entries_until_detected << backtrace_entry
+      _, line_number, = detector.split_backtrace_entry(backtrace_entry)
+      break if target_line_number == line_number
+    end
+
+    actual_backtrace_entries_until_detected = []
+    fault.location.each do |backtrace_entry|
+      actual_backtrace_entries_until_detected << backtrace_entry
+      break if detector.target?(backtrace_entry)
+    end
+
+    assert_equal(expected_backtrace_entries_until_detected,
+                 actual_backtrace_entries_until_detected)
+  end
+
+  module AlwaysFailAssertion
+    private
+    def assert_always_failed
+      assert_true(false)
+    end
+  end
+
+  class TestSourceLocation < self
+    setup
+    def setup_check_source_location
+      unless lambda {}.respond_to?(:source_location)
+        omit("Need Proc#source_location")
+      end
+    end
+
+    def test_detected
+      target_line_number = nil
+      test_case = Class.new(Test::Unit::TestCase) do
+        include AlwaysFailAssertion
+
+        test "failed" do
+          target_line_number = __LINE__; assert_always_failed
+        end
+      end
+
+      fault = run_test_case(test_case)
+      assert_detect(fault, target_line_number)
+    end
+
+    class TestOneLine < self
+      def test_brace
+        target_line_number = nil
+        test_case = Class.new(Test::Unit::TestCase) do
+          include AlwaysFailAssertion
+
+          test("failed") {target_line_number = __LINE__; assert_always_failed}
+
+          def other_method
+            # body
+          end
+        end
+
+        fault = run_test_case(test_case)
+        assert_detect(fault, target_line_number)
+      end
+
+      def test_do_end
+        target_line_number = nil
+        test_case = Class.new(Test::Unit::TestCase) do
+          include AlwaysFailAssertion
+
+          test "failed" do target_line_number = __LINE__; assert_always_failed; end
+
+          def other_method
+            # body
+          end
+        end
+
+        fault = run_test_case(test_case)
+        assert_detect(fault, target_line_number)
+      end
+    end
+  end
+
+  class TestMethodName < self
+    def test_detected
+      test_case = Class.new(Test::Unit::TestCase) do
+        include AlwaysFailAssertion
+
+        class << self
+          def target_line_number
+            @@target_line_number
+          end
+
+          def target_line_number=(line_number)
+            @@target_line_number = line_number
+          end
+        end
+
+        def test_failed
+          self.class.target_line_number = __LINE__; assert_always_failed
+        end
+      end
+
+      fault = run_test_case(test_case)
+      assert_detect(fault, test_case.target_line_number)
+    end
+  end
+
+  class TestInBlock < self
+    def test_in_block
+      test_case = Class.new(Test::Unit::TestCase) do
+        include AlwaysFailAssertion
+
+        class << self
+          def target_line_number
+            @@target_line_number
+          end
+
+          def target_line_number=(line_number)
+            @@target_line_number = line_number
+          end
+        end
+
+        def run_yield
+          yield
+        end
+
+        def test_failed
+          run_yield do
+            self.class.target_line_number = __LINE__; assert_always_failed
+          end
+        end
+      end
+
+      fault = run_test_case(test_case)
+      assert_detect(fault, test_case.target_line_number)
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/test-unit-3.1.9/test/test-fixture.rb

@@ -0,0 +1,713 @@
+class TestUnitFixture < Test::Unit::TestCase
+  module EmptyModule
+  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_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_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_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_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
+
+    private
+    def assert_setup_customizable(expected, parent, options)
+      test_case = Class.new(parent || Test::Unit::TestCase) do
+        yield(self, :before) if block_given?
+
+        def called_ids
+          @called_ids ||= []
+        end
+
+        def called(id)
+          called_ids << id
+        end
+
+        def setup
+          called(:setup)
+        end
+
+        setup(*(options[0] || [])) if options
+        def custom_setup_method0
+          called(:custom_setup_method0)
+        end
+
+        if options
+          setup(*(options[0] || [])) do
+            called(:custom_setup_callback0)
+          end
+        end
+
+        def custom_setup_method1
+          called(:custom_setup_method1)
+        end
+        setup(*[:custom_setup_method1, *(options[1] || [])]) if options
+
+        if options
+          setup(*(options[1] || [])) do
+            called(:custom_setup_callback1)
+          end
+        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
+
+        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
+
+      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 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
+
+    def assert_invalid_setup_option(option)
+      assert_invalid_option(:setup, option)
+    end
+  end
+
+  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
+
+    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_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_with_invalid_option
+      assert_invalid_cleanup_option(:unknown => true)
+      assert_invalid_cleanup_option(:before => :unknown)
+      assert_invalid_cleanup_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_with_exception
+      test_case = Class.new(Test::Unit::TestCase) do
+        def called_ids
+          @called_ids ||= []
+        end
+
+        def called(id)
+          called_ids << id
+        end
+
+        def cleanup
+          called(:cleanup)
+          raise "cleanup"
+        end
+
+        cleanup
+        def custom_cleanup_method0
+          called(:custom_cleanup_method0)
+          raise "custom_cleanup_method0"
+        end
+
+        cleanup do
+          called(:custom_cleanup_callback0)
+          raise "custom_cleanup_callback0"
+        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
+        end
+      end
+
+      assert_called_fixtures([:custom_cleanup_callback1],
+                             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?
+
+        def called_ids
+          @called_ids ||= []
+        end
+
+        def called(id)
+          called_ids << id
+        end
+
+        def cleanup
+          called(:cleanup)
+        end
+
+        cleanup(*(options[0] || [])) if options
+        def custom_cleanup_method0
+          called(:custom_cleanup_method0)
+        end
+
+        if options
+          cleanup(*(options[0] || [])) do
+            called(:custom_cleanup_callback0)
+          end
+        end
+
+        def custom_cleanup_method1
+          called(:custom_cleanup_method1)
+        end
+        cleanup(*[:custom_cleanup_method1, *(options[1] || [])]) if options
+
+        if options
+          cleanup(*(options[1] || [])) do
+            called(:custom_cleanup_callback1)
+          end
+        end
+
+        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
+
+        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
+
+      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
+
+    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 assert_invalid_cleanup_option(option)
+      assert_invalid_option(:cleanup, option)
+    end
+  end
+
+  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
+
+    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
+
+    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 test_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_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 test_with_exception
+      test_case = Class.new(Test::Unit::TestCase) do
+        def called_ids
+          @called_ids ||= []
+        end
+
+        def called(id)
+          called_ids << id
+        end
+
+        def teardown
+          called(:teardown)
+          raise "teardown"
+        end
+
+        teardown
+        def custom_teardown_method0
+          called(:custom_teardown_method0)
+          raise "custom_teardown_method0"
+        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
+        end
+      end
+
+      assert_called_fixtures([:custom_teardown_callback1,
+                              :custom_teardown_method1,
+                              :custom_teardown_callback0,
+                              :custom_teardown_method0,
+                              :teardown],
+                             test_case)
+    end
+
+    def test_nested
+      called = []
+      parent_test_case = Class.new(Test::Unit::TestCase) do
+        teardown do
+          called << :parent
+        end
+      end
+
+      child_test_case = Class.new(parent_test_case) do
+        teardown do
+          called << :child
+        end
+
+        def test_nothing
+        end
+      end
+
+      run_test_nothing(child_test_case)
+      assert_equal([:child, :parent],
+                   called)
+    end
+
+    def test_setup_with_block
+      test_case = Class.new(Test::Unit::TestCase) do
+        def called_ids
+          @called_ids ||= []
+        end
+
+        def called(id)
+          called_ids << id
+        end
+
+        setup
+        def setup1
+          called(:setup1)
+          begin
+            yield
+            called(:setup1_after_yield)
+          ensure
+            called(:setup1_teardown)
+          end
+        end
+
+        setup
+        def setup2
+          called(:setup2)
+          begin
+            yield
+            called(:setup2_after_yield)
+          ensure
+            called(:setup2_teardown)
+          end
+        end
+
+        def teardown
+          called(:teardown)
+        end
+
+        def test_nothing
+          called(:test)
+          flunk
+          called(:test_after_failure)
+        end
+      end
+
+      assert_called_fixtures([
+                               :setup1,
+                               :setup2,
+                               :test,
+                               :setup2_teardown,
+                               :setup1_teardown,
+                               :teardown,
+                             ],
+                             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 called_ids
+          @called_ids ||= []
+        end
+
+        def called(id)
+          called_ids << id
+        end
+
+        def teardown
+          called(:teardown)
+        end
+
+        teardown(*(options[0] || [])) if options
+        def custom_teardown_method0
+          called(:custom_teardown_method0)
+        end
+
+        if options
+          teardown(*(options[0] || [])) do
+            called(:custom_teardown_callback0)
+          end
+        end
+
+        def custom_teardown_method1
+          called(:custom_teardown_method1)
+        end
+        teardown(*[:custom_teardown_method1, *(options[1] || [])]) if options
+
+        if options
+          teardown(*(options[1] || [])) do
+            called(:custom_teardown_callback1)
+          end
+        end
+
+        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[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
+        end
+
+        yield(self, :after) if block_given?
+      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_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
+
+    def assert_invalid_teardown_option(option)
+      assert_invalid_option(:teardown, option)
+    end
+  end
+
+  private
+  def run_test_nothing(test_case)
+    test = test_case.new("test_nothing")
+    test.run(Test::Unit::TestResult.new) {}
+    test
+  end
+
+  def assert_called_fixtures(expected, test_case)
+    test = run_test_nothing(test_case)
+    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
+        def test_nothing
+        end
+
+        send(fixture_type, option)
+        def fixture
+        end
+      end
+    end
+    assert_equal("must be {:before => :prepend}, {:before => :append}, " +
+                 "{:after => :prepend} or {:after => :append}" +
+                 ": #{option.inspect}",
+                 exception.message)
+  end
+end