test-unit 1.2.3 → 2.0.0

data/test/test_pending.rb

@@ -0,0 +1,70 @@
+require 'test/unit'
+require 'testunit_test_util'
+
+class TestUnitPending < Test::Unit::TestCase
+  include TestUnitTestUtil
+
+  class TestCase < Test::Unit::TestCase
+    class << self
+      def suite
+        Test::Unit::TestSuite.new(name)
+      end
+    end
+
+    def test_pend
+      pend("1st pend")
+      pend("2nd pend. Should not be reached here.")
+      assert(true, "Should not be reached here too.")
+    end
+
+    def test_pend_with_failure_in_block
+      pend("Wait a minute") do
+        raise "Not implemented yet"
+      end
+      assert(true, "Reached here.")
+    end
+
+    def test_pend_with_no_failure_in_block
+      pend("Wait a minute") do
+        "Nothing raised"
+      end
+      assert(true, "Not reached here.")
+    end
+  end
+
+  def test_pend
+    test = nil
+    result = run_test("test_pend") {|t| test = t}
+    assert_equal("1 tests, 0 assertions, 0 failures, 0 errors, 1 pendings, " \
+                 "0 omissions, 0 notifications",
+                 result.to_s)
+    assert_fault_messages(["1st pend"], result.pendings)
+    assert_true(test.interrupted?)
+  end
+
+  def test_pend_with_failure_in_block
+    test = nil
+    result = run_test("test_pend_with_failure_in_block") {|t| test = t}
+    assert_equal("1 tests, 1 assertions, 0 failures, 0 errors, 1 pendings, " \
+                 "0 omissions, 0 notifications",
+                 result.to_s)
+    assert_fault_messages(["Wait a minute"], result.pendings)
+    assert_false(test.interrupted?)
+  end
+
+  def test_pend_with_no_failure_in_block
+    test = nil
+    result = run_test("test_pend_with_no_failure_in_block") {|t| test = t}
+    assert_equal("1 tests, 1 assertions, 1 failures, 0 errors, 0 pendings, " \
+                 "0 omissions, 0 notifications",
+                 result.to_s)
+    assert_fault_messages(["Pending block should not be passed: Wait a minute."],
+                          result.failures)
+    assert_true(test.interrupted?)
+  end
+
+  private
+  def run_test(name, &block)
+    super(TestCase, name, &block)
+  end
+end

data/test/test_priority.rb

@@ -0,0 +1,89 @@
+require 'test/unit'
+
+class TestUnitPriority < Test::Unit::TestCase
+  class TestCase < Test::Unit::TestCase
+    class << self
+      def suite
+        Test::Unit::TestSuite.new(name)
+      end
+    end
+
+    priority :must
+    def test_must
+      assert(true)
+    end
+
+    def test_must_inherited
+      assert(true)
+    end
+
+    priority :important
+    def test_important
+      assert(true)
+    end
+
+    def test_important_inherited
+      assert(true)
+    end
+
+    priority :high
+    def test_high
+      assert(true)
+    end
+
+    def test_high_inherited
+      assert(true)
+    end
+
+    priority :normal
+    def test_normal
+      assert(true)
+    end
+
+    def test_normal_inherited
+      assert(true)
+    end
+
+    priority :low
+    def test_low
+      assert(true)
+    end
+
+    def test_low_inherited
+      assert(true)
+    end
+
+    priority :never
+    def test_never
+      assert(true)
+    end
+
+    def test_never_inherited
+      assert(true)
+    end
+  end
+
+  def test_priority
+    assert_priority("must", 1.0, 0.0001)
+    assert_priority("important", 0.9, 0.09)
+    assert_priority("high", 0.70, 0.1)
+    assert_priority("normal", 0.5, 0.1)
+    assert_priority("low", 0.25, 0.1)
+    assert_priority("never", 0.0, 0.0001)
+  end
+
+  def assert_priority(priority, expected, delta)
+    assert_need_to_run("test_#{priority}", expected, delta)
+    assert_need_to_run("test_#{priority}_inherited", expected, delta)
+  end
+
+  def assert_need_to_run(test_name, expected, delta)
+    test = TestCase.new(test_name)
+    n = 1000
+    n_need_to_run = 0
+    n.times do |i|
+      n_need_to_run +=1 if Test::Unit::Priority::Checker.need_to_run?(test)
+    end
+    assert_in_delta(expected, n_need_to_run.to_f / n, delta)
+  end
+end

data/test/test_testcase.rb

@@ -263,13 +263,168 @@ module Test
         check("Should not be equal", test1 != Object.new)
         check("Should not be equal", Object.new != test1)
       end
-      
-      def check(message, passed)
-        @_result.add_assertion
-        if ! passed
-          raise AssertionFailedError.new(message)
+
+      def test_re_raise_exception
+        test_case = Class.new(TestCase) do
+          def test_raise_interrupt
+            raise Interrupt
+          end
+        end
+
+        test = test_case.new("test_raise_interrupt")
+        begin
+          test.run(TestResult.new) {}
+          check("Should not be reached", false)
+        rescue Exception
+          check("Interrupt exception should be re-raised", $!.class == Interrupt)
+        end
+      end
+
+      def test_startup_shutdown
+        called = []
+        test_case = Class.new(TestCase) do
+          @@called = called
+          class << self
+            def startup
+              @@called << :startup
+            end
+
+            def shutdown
+              @@called << :shutdown
+            end
+          end
+
+          def setup
+            @@called << :setup
+          end
+
+          def teardown
+            @@called << :teardown
+          end
+
+          def test1
+          end
+
+          def test2
+          end
+        end
+
+        test_suite = test_case.suite
+        test_suite.run(TestResult.new) {}
+        check("startup/shutdown should be called once per test case" +
+              ": #{called.inspect}",
+              called == [:startup,
+                         :setup, :teardown,
+                         :setup, :teardown,
+                         :shutdown])
+      end
+
+      def test_error_on_startup
+        test_case = Class.new(TestCase) do
+          class << self
+            def startup
+              raise "from startup"
+            end
+          end
+
+          def test_nothing
+          end
+        end
+
+        test_suite = test_case.suite
+        result = TestResult.new
+        test_suite.run(result) {}
+        check("Should record an error on startup: #{result}",
+              result.error_count == 1)
+      end
+
+      def test_pass_through_error_on_startup
+        test_case = Class.new(TestCase) do
+          class << self
+            def startup
+              raise Interrupt
+            end
+          end
+
+          def test_nothing
+          end
+        end
+
+        test_suite = test_case.suite
+        begin
+          test_suite.run(TestResult.new) {}
+          check("Should not be reached", false)
+        rescue Exception
+          check("Interrupt should be passed through: #{$!}",
+                Interrupt === $!)
         end
       end
+
+      def test_error_on_shutdown
+        test_case = Class.new(TestCase) do
+          class << self
+            def shutdown
+              raise "from shutdown"
+            end
+          end
+
+          def test_nothing
+          end
+        end
+
+        test_suite = test_case.suite
+        result = TestResult.new
+        test_suite.run(result) {}
+        check("Should record an error on shutdown: #{result}",
+              result.error_count == 1)
+      end
+
+      def test_pass_through_error_on_shutdown
+        test_case = Class.new(TestCase) do
+          class << self
+            def shutdown
+              raise Interrupt
+            end
+          end
+
+          def test_nothing
+          end
+        end
+
+        test_suite = test_case.suite
+        begin
+          test_suite.run(TestResult.new) {}
+          check("Should not be reached", false)
+        rescue Exception
+          check("Interrupt should be passed through: #{$!}",
+                Interrupt === $!)
+        end
+      end
+
+      def test_interrupted
+        test_case = Class.new(TestCase) do
+          def test_fail
+            flunk
+          end
+
+          def test_nothing
+          end
+        end
+
+        failed_test = test_case.new(:test_fail)
+        failed_test.run(TestResult.new) {}
+        check("Should be interrupted", failed_test.interrupted?)
+
+        success_test = test_case.new(:test_nothing)
+        success_test.run(TestResult.new) {}
+        check("Should not be interrupted", !success_test.interrupted?)
+      end
+
+      private
+      def check(message, passed)
+        add_assertion
+        raise AssertionFailedError.new(message) unless passed
+      end
     end
   end
 end

data/test/test_testresult.rb

@@ -11,93 +11,102 @@ module Test
       def setup
         @my_result = TestResult.new
         @my_result.add_assertion()
-        @my_result.add_failure("")
-        @my_result.add_error("")
+        @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) {
-          |result|
-          assert_block("The result should be correct") { result == @my_result }
+        @my_result.add_listener(TestResult::CHANGED) do |result|
+          assert_equal(@my_result, result)
           called1 = true
-        }
+        end
         @my_result.add_assertion
-        assert_block("Should have been notified when the assertion happened") { called1 }
-        
+        assert_true(called1)
+
         called1, called2 = false, false
-        @my_result.add_listener( TestResult::CHANGED) {
-          |result|
-          assert_block("The result should be correct") { result == @my_result }
+        @my_result.add_listener(TestResult::CHANGED) do |result|
+          assert_equal(@my_result, result)
           called2 = true
-        }
+        end
         @my_result.add_assertion
-        assert_block("Both listeners should have been notified for a success") { called1 && called2 }
-  
+        assert_equal([true, true], [called1, called2])
+
         called1, called2 = false, false
         @my_result.add_failure("")
-        assert_block("Both listeners should have been notified for a failure") { called1 && called2 }
-  
-        called1, called2 = false, false    
+        assert_equal([true, true], [called1, called2])
+
+        called1, called2 = false, false
         @my_result.add_error("")
-        assert_block("Both listeners should have been notified for an error") { called1 && called2 }
-  
-        called1, called2 = false, false    
+        assert_equal([true, true], [called1, called2])
+
+        called1, called2 = false, false
         @my_result.add_run
-        assert_block("Both listeners should have been notified for a run") { called1 && called2 }
+        assert_equal([true, true], [called1, called2])
       end
+
       def test_fault_notification
         called1 = false
         fault = "fault"
-        @my_result.add_listener(TestResult::FAULT) {
-          | passed_fault |
-          assert_block("The fault should be correct") { passed_fault == fault }
+        @my_result.add_listener(TestResult::FAULT) do |passed_fault|
+          assert_equal(fault, passed_fault)
           called1 = true
-        }
-  
+        end
+
         @my_result.add_assertion
-        assert_block("Should not have been notified when the assertion happened") { !called1 }
-        
+        assert_false(called1)
+
         @my_result.add_failure(fault)
-        assert_block("Should have been notified when the failure happened") { called1 }
-        
+        assert_true(called1)
+
         called1, called2 = false, false
-        @my_result.add_listener(TestResult::FAULT) {
-          | passed_fault |
-          assert_block("The fault should be correct") { passed_fault == fault }
+        @my_result.add_listener(TestResult::FAULT) do |passed_fault|
+          assert_equal(fault, passed_fault)
           called2 = true
-        }
-  
+        end
+
         @my_result.add_assertion
-        assert_block("Neither listener should have been notified for a success") { !(called1 || called2) }
-  
+        assert_equal([false, false], [called1, called2])
+
         called1, called2 = false, false
         @my_result.add_failure(fault)
-        assert_block("Both listeners should have been notified for a failure") { called1 && called2 }
-  
-        called1, called2 = false, false    
+        assert_equal([true, true], [called1, called2])
+
+        called1, called2 = false, false
         @my_result.add_error(fault)
-        assert_block("Both listeners should have been notified for an error") { called1 && called2 }
-  
+        assert_equal([true, true], [called1, called2])
+
         called1, called2 = false, false
         @my_result.add_run
-        assert_block("Neither listener should have been notified for a run") { !(called1 || called2) }
+        assert_equal([false, false], [called1, called2])
       end
+
       def test_passed?
         result = TestResult.new
-        assert(result.passed?, "An empty result should have passed")
-  
+        assert_true(result.passed?)
+
         result.add_assertion
-        assert(result.passed?, "Adding an assertion should not cause the result to not pass")
-  
+        assert_true(result.passed?)
+
         result.add_run
-        assert(result.passed?, "Adding a run should not cause the result to not pass")
-  
+        assert_true(result.passed?)
+
         result.add_failure("")
-        assert(!result.passed?, "Adding a failed assertion should cause the result to not pass")
-  
+        assert_false(result.passed?)
+
         result = TestResult.new
         result.add_error("")
-        assert(!result.passed?, "Adding an error should cause the result to not pass")
+        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