test-unit 3.4.2 → 3.4.6

data/test/test-test-result.rb

@@ -1,113 +0,0 @@
-# Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
-# License:: Ruby license.
-
-require 'test/unit/testcase'
-require 'test/unit/testresult'
-
-module Test
-  module Unit
-    class TC_TestResult < TestCase
-      def setup
-        @my_result = TestResult.new
-        @my_result.add_assertion()
-        @failure = "failure"
-        @my_result.add_failure(@failure)
-        @error = "error"
-        @my_result.add_error(@error)
-      end
-
-      def test_result_changed_notification
-        called1 = false
-        @my_result.add_listener(TestResult::CHANGED) do |result|
-          assert_equal(@my_result, result)
-          called1 = true
-        end
-        @my_result.add_assertion
-        assert_true(called1)
-
-        called1, called2 = false, false
-        @my_result.add_listener(TestResult::CHANGED) do |result|
-          assert_equal(@my_result, result)
-          called2 = true
-        end
-        @my_result.add_assertion
-        assert_equal([true, true], [called1, called2])
-
-        called1, called2 = false, false
-        @my_result.add_failure("")
-        assert_equal([true, true], [called1, called2])
-
-        called1, called2 = false, false
-        @my_result.add_error("")
-        assert_equal([true, true], [called1, called2])
-
-        called1, called2 = false, false
-        @my_result.add_run
-        assert_equal([true, true], [called1, called2])
-      end
-
-      def test_fault_notification
-        called1 = false
-        fault = "fault"
-        @my_result.add_listener(TestResult::FAULT) do |passed_fault|
-          assert_equal(fault, passed_fault)
-          called1 = true
-        end
-
-        @my_result.add_assertion
-        assert_false(called1)
-
-        @my_result.add_failure(fault)
-        assert_true(called1)
-
-        called1, called2 = false, false
-        @my_result.add_listener(TestResult::FAULT) do |passed_fault|
-          assert_equal(fault, passed_fault)
-          called2 = true
-        end
-
-        @my_result.add_assertion
-        assert_equal([false, false], [called1, called2])
-
-        called1, called2 = false, false
-        @my_result.add_failure(fault)
-        assert_equal([true, true], [called1, called2])
-
-        called1, called2 = false, false
-        @my_result.add_error(fault)
-        assert_equal([true, true], [called1, called2])
-
-        called1, called2 = false, false
-        @my_result.add_run
-        assert_equal([false, false], [called1, called2])
-      end
-
-      def test_passed?
-        result = TestResult.new
-        assert_true(result.passed?)
-
-        result.add_assertion
-        assert_true(result.passed?)
-
-        result.add_run
-        assert_true(result.passed?)
-
-        result.add_failure("")
-        assert_false(result.passed?)
-
-        result = TestResult.new
-        result.add_error("")
-        assert_false(result.passed?)
-      end
-
-      def test_faults
-        assert_equal([@failure, @error], @my_result.faults)
-
-        notification = "notification"
-        @my_result.add_notification(notification)
-        assert_equal([@failure, @error, notification], @my_result.faults)
-      end
-    end
-  end
-end

data/test/test-test-suite-creator.rb

@@ -1,97 +0,0 @@
-require "test/unit"
-
-module Test
-  module Unit
-    class TestTestSuiteCreator < TestCase
-      def collect_test_names(test_case)
-        creator = TestSuiteCreator.new(test_case)
-        creator.send(:collect_test_names)
-      end
-
-      class TestStandalone < self
-        def setup
-          @test_case = Class.new(TestCase) do
-            def test_in_test_case
-            end
-          end
-        end
-
-        def test_collect_test_names
-          assert_equal(["test_in_test_case"], collect_test_names(@test_case))
-        end
-      end
-
-      class TestInherited < self
-        def setup
-          @parent_test_case = Class.new(TestCase) do
-            def test_in_parent
-            end
-          end
-
-          @child_test_case = Class.new(@parent_test_case) do
-            def test_in_child
-            end
-          end
-        end
-
-        def test_collect_test_names
-          assert_equal(["test_in_child"], collect_test_names(@child_test_case))
-        end
-      end
-
-      class TestModule < self
-        def setup
-          test_module = Module.new do
-            def test_in_module
-            end
-          end
-
-          @test_case = Class.new(TestCase) do
-            include test_module
-
-            def test_in_test_case
-            end
-          end
-        end
-
-        def test_collect_test_names
-          assert_equal(["test_in_module", "test_in_test_case"].sort,
-                       collect_test_names(@test_case).sort)
-        end
-      end
-
-      class TestInheritedModule < self
-        def setup
-          parent_test_module = Module.new do
-            def test_in_module_in_parent
-            end
-          end
-
-          child_test_module = Module.new do
-            def test_in_module_in_child
-            end
-          end
-
-          @parent_test_case = Class.new(TestCase) do
-            include parent_test_module
-
-            def test_in_parent
-            end
-          end
-
-          @child_test_case = Class.new(@parent_test_case) do
-            include child_test_module
-
-            def test_in_child
-            end
-          end
-        end
-
-        def test_collect_test_names
-          assert_equal(["test_in_child", "test_in_module_in_child"].sort,
-                       collect_test_names(@child_test_case).sort)
-        end
-      end
-    end
-  end
-end

data/test/test-test-suite.rb

@@ -1,151 +0,0 @@
-# Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
-# License:: Ruby license.
-
-require 'test/unit'
-
-module Test
-  module Unit
-    class TestTestSuite < TestCase
-      def setup
-        @testcase1 = Class.new(TestCase) do
-          def test_succeed1
-            assert_block { true }
-          end
-          def test_fail
-            assert_block { false }
-          end
-        end
-
-        @testcase2 = Class.new(TestCase) do
-          def test_succeed2
-            assert_block { true }
-          end
-          def test_error
-            raise
-          end
-        end
-      end
-
-      def test_add
-        s = TestSuite.new
-        assert_equal(s, s << self.class.new("test_add"))
-      end
-
-      def test_delete
-        s = TestSuite.new
-        t1 = self.class.new("test_delete")
-        s << t1
-        t2 = self.class.new("test_add")
-        s << t2
-        assert_equal(t1, s.delete(t1))
-        assert_nil(s.delete(t1))
-        assert_equal(TestSuite.new << t2, s)
-      end
-
-      def test_delete_tests
-        suite = TestSuite.new
-        test1 = self.class.new("test_delete_1")
-        suite << test1
-        test2 = self.class.new("test_delete_2")
-        suite << test2
-        test3 = self.class.new("test_add")
-        suite << test3
-        suite.delete_tests([test1, test2])
-        assert_equal(1, suite.size)
-        assert_equal(TestSuite.new << test3, suite)
-      end
-
-      def test_size
-        suite = TestSuite.new
-        suite2 = TestSuite.new
-        suite2 << self.class.new("test_size")
-        suite << suite2
-        suite << self.class.new("test_size")
-        assert_equal(2, suite.size, "The count should be correct")
-      end
-
-      def test_run
-        progress = []
-        @testcase1.test_order = :alphabetic
-        suite = @testcase1.suite
-        tests = suite.tests.dup
-        result = TestResult.new
-        suite.run(result) { |*values| progress << values }
-
-        assert_equal(2, result.run_count, "Should have had four test runs")
-        assert_equal(1, result.failure_count, "Should have had one test failure")
-        assert_equal(0, result.error_count, "Should have had one test error")
-        assert_equal([[TestSuite::STARTED, suite.name],
-                      [TestSuite::STARTED_OBJECT, suite],
-                      [TestCase::STARTED, "test_fail(#{suite.name})"],
-                      [TestCase::STARTED_OBJECT, tests[0]],
-                      [TestCase::FINISHED, "test_fail(#{suite.name})"],
-                      [TestCase::FINISHED_OBJECT, tests[0]],
-                      [TestCase::STARTED, "test_succeed1(#{suite.name})"],
-                      [TestCase::STARTED_OBJECT, tests[1]],
-                      [TestCase::FINISHED, "test_succeed1(#{suite.name})"],
-                      [TestCase::FINISHED_OBJECT, tests[1]],
-                      [TestSuite::FINISHED, suite.name],
-                      [TestSuite::FINISHED_OBJECT, suite]],
-                     progress, "Should have had the correct progress")
-
-        suite = TestSuite.new
-        suite << @testcase1.suite
-        suite << @testcase2.suite
-        result = TestResult.new
-        progress = []
-        suite.run(result) { |*values| progress << values }
-
-        assert_equal(4, result.run_count, "Should have had four test runs")
-        assert_equal(1, result.failure_count, "Should have had one test failure")
-        assert_equal(1, result.error_count, "Should have had one test error")
-        assert_equal(28, progress.size,
-                     "Should have had the correct number of progress calls")
-      end
-
-      def test_empty?
-        assert(TestSuite.new.empty?, "A new test suite should be empty?")
-        assert(!@testcase2.suite.empty?, "A test suite with tests should not be empty")
-      end
-
-      def test_equality
-        suite1 = TestSuite.new
-        suite2 = TestSuite.new
-        assert_equal(suite1, suite2)
-        assert_equal(suite2, suite1)
-
-        suite1 = TestSuite.new('name')
-        assert_not_equal(suite1, suite2)
-        assert_not_equal(suite2, suite1)
-
-        suite2 = TestSuite.new('name')
-        assert_equal(suite1, suite2)
-        assert_equal(suite2, suite1)
-
-        suite1 << 'test'
-        assert_not_equal(suite1, suite2)
-        assert_not_equal(suite2, suite1)
-
-        suite2 << 'test'
-        assert_equal(suite1, suite2)
-        assert_equal(suite2, suite1)
-
-        suite2 = Object.new
-        class << suite2
-          def name
-            'name'
-          end
-          def tests
-            ['test']
-          end
-        end
-        assert_not_equal(suite1, suite2)
-        assert_not_equal(suite2, suite1)
-
-        assert_not_equal(suite1, Object.new)
-        assert_not_equal(Object.new, suite1)
-      end
-    end
-  end
-end

data/test/testunit-test-util.rb

@@ -1,33 +0,0 @@
-require "tempfile"
-
-module TestUnitTestUtil
-  private
-  def jruby?
-    RUBY_PLATFORM == "java"
-  end
-
-  def jruby_only_test
-    if jruby?
-      require "java"
-    else
-      omit("test for JRuby")
-    end
-  end
-
-  def assert_fault_messages(expected, faults)
-    assert_equal(expected, faults.collect {|fault| fault.message})
-  end
-
-  def _run_test(test_case, name)
-    result = Test::Unit::TestResult.new
-    test = test_case.new(name)
-    yield(test) if block_given?
-    test.run(result) {}
-    result
-  end
-
-  def fixture_file_path(file_name)
-    base_dir = File.dirname(__FILE__)
-    File.join(base_dir, "fixtures", file_name)
-  end
-end

data/test/ui/test_testrunmediator.rb

@@ -1,20 +0,0 @@
-require 'test/unit/ui/testrunnermediator'
-
-class TestUnitUIMediator < Test::Unit::TestCase
-  def test_run_suite_with_interrupt_exception
-    test_case = Class.new(Test::Unit::TestCase) do
-      def test_raise_interrupt
-        raise Interrupt, "from test"
-      end
-    end
-    mediator = Test::Unit::UI::TestRunnerMediator.new(test_case.suite)
-    finished = false
-    mediator.add_listener(Test::Unit::UI::TestRunnerMediator::FINISHED) do
-      finished = true
-    end
-    assert_raise(Interrupt) do
-      mediator.run
-    end
-    assert(finished)
-  end
-end

data/test/util/test-method-owner-finder.rb

@@ -1,38 +0,0 @@
-require 'test/unit'
-
-require 'test/unit/util/method-owner-finder'
-
-class TestUnitMethodOwnerFinder < Test::Unit::TestCase
-  def test_find
-    assert_equal(Exception, find(RuntimeError.new, :inspect))
-    assert_equal(Exception, find(Exception.new, :inspect))
-
-    anonymous_class = Class.new do
-    end
-    assert_equal(Kernel, find(anonymous_class.new, :inspect))
-
-    anonymous_parent_class = Class.new do
-      def inspect
-        super + " by anonymous parent class"
-      end
-    end
-    anonymous_sub_class = Class.new(anonymous_parent_class) do
-    end
-    assert_equal(anonymous_parent_class, find(anonymous_sub_class.new, :inspect))
-
-    anonymous_module = Module.new do
-      def inspect
-        super + " by anonymous module"
-      end
-    end
-    anonymous_include_class = Class.new do
-      include anonymous_module
-    end
-    assert_equal(anonymous_module, find(anonymous_include_class.new, :inspect))
-  end
-
-  private
-  def find(object, method_name)
-    Test::Unit::Util::MethodOwnerFinder.find(object, method_name)
-  end
-end