test-unit 3.1.5 → 3.6.1

data/test/test-fixture.rb

@@ -1,659 +0,0 @@
-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
-
-    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

data/test/test-notification.rb

@@ -1,33 +0,0 @@
-require 'test/unit'
-require 'testunit-test-util'
-
-class TestUnitNotification < Test::Unit::TestCase
-  include TestUnitTestUtil
-
-  class TestCase < Test::Unit::TestCase
-    class << self
-      def suite
-        Test::Unit::TestSuite.new(name)
-      end
-    end
-
-    def test_notify
-      notify("1st notify")
-      notify("2nd notify. Reach here.")
-    end
-  end
-
-  def test_notify
-    result = _run_test("test_notify")
-    assert_equal("1 tests, 0 assertions, 0 failures, 0 errors, 0 pendings, " \
-                 "0 omissions, 2 notifications",
-                 result.to_s)
-    assert_fault_messages(["1st notify", "2nd notify. Reach here."],
-                          result.notifications)
-  end
-
-  private
-  def _run_test(name)
-    super(TestCase, name)
-  end
-end