test-unit 1.2.3 → 2.0.0

data/lib/test/unit/runner/emacs.rb

@@ -0,0 +1,8 @@
+module Test
+  module Unit
+    AutoRunner.register_runner(:emacs) do |auto_runner|
+      require 'test/unit/ui/emacs/testrunner'
+      Test::Unit::UI::Emacs::TestRunner
+    end
+  end
+end

data/lib/test/unit/testcase.rb

@@ -4,9 +4,16 @@
 # Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
 # License:: Ruby license.
 
+require 'test/unit/attribute'
+require 'test/unit/fixture'
+require 'test/unit/exceptionhandler'
 require 'test/unit/assertions'
 require 'test/unit/failure'
 require 'test/unit/error'
+require 'test/unit/pending'
+require 'test/unit/omission'
+require 'test/unit/notification'
+require 'test/unit/priority'
 require 'test/unit/testsuite'
 require 'test/unit/assertionfailederror'
 require 'test/unit/util/backtracefilter'
@@ -19,89 +26,193 @@ module Test
     # wrapping those tests into a suite. It also does the
     # nitty-gritty of actually running an individual test and
     # collecting its results into a Test::Unit::TestResult object.
+    #
+    # You can run two hooks before/after a TestCase run.
+    #
+    # Example:
+    #   class TestMyClass < Test::Unit::TestCase
+    #     class << self
+    #       def startup
+    #         ...
+    #       end
+    #
+    #       def shutdown
+    #         ...
+    #       end
+    #     end
+    #
+    #     def setup
+    #       ...
+    #     end
+    #
+    #     def teardown
+    #       ...
+    #     end
+    #
+    #     def test_my_method1
+    #       ...
+    #     end
+    #
+    #     def test_my_method2
+    #       ...
+    #     end
+    #   end
+    #
+    # Here is a call order:
+    #  * startup
+    #  * setup
+    #  * test_my_method1
+    #  * teardown
+    #  * setup
+    #  * test_my_method2
+    #  * teardown
+    #  * shutdown
     class TestCase
+      include Attribute
+      include Fixture
+      include ExceptionHandler
+      include ErrorHandler
+      include FailureHandler
+      include TestCasePendingSupport
+      include TestCaseOmissionSupport
+      include TestCaseNotificationSupport
+      include Priority
       include Assertions
       include Util::BacktraceFilter
-      
-      attr_reader :method_name
-      
+
       STARTED = name + "::STARTED"
       FINISHED = name + "::FINISHED"
 
-      ##
-      # These exceptions are not caught by #run.
+      DESCENDANTS = []
 
-      PASSTHROUGH_EXCEPTIONS = [NoMemoryError, SignalException, Interrupt,
-                                SystemExit]
+      class << self
+        def inherited(sub_class)
+          DESCENDANTS << sub_class
+        end
+
+        # Rolls up all of the test* methods in the fixture into
+        # one suite, creating a new instance of the fixture for
+        # each method.
+        def suite
+          method_names = public_instance_methods(true).collect {|name| name.to_s}
+          tests = method_names.delete_if {|method_name| method_name !~ /^test./}
+          suite = TestSuite.new(name, self)
+          tests.sort.each do |test|
+            catch(:invalid_test) do
+              suite << new(test)
+            end
+          end
+          if suite.empty?
+            catch(:invalid_test) do
+              suite << new("default_test")
+            end
+          end
+          suite
+        end
+      end
+
+      attr_reader :method_name
 
       # Creates a new instance of the fixture for running the
       # test represented by test_method_name.
       def initialize(test_method_name)
-        unless(respond_to?(test_method_name) and
-               (method(test_method_name).arity == 0 ||
-                method(test_method_name).arity == -1))
-          throw :invalid_test
-        end
+        throw :invalid_test unless respond_to?(test_method_name)
+        throw :invalid_test if method(test_method_name).arity > 0
         @method_name = test_method_name
         @test_passed = true
-      end
-
-      # Rolls up all of the test* methods in the fixture into
-      # one suite, creating a new instance of the fixture for
-      # each method.
-      def self.suite
-        method_names = public_instance_methods(true)
-        tests = method_names.delete_if {|method_name| method_name !~ /^test./}
-        suite = TestSuite.new(name)
-        tests.sort.each do
-          |test|
-          catch(:invalid_test) do
-            suite << new(test)
-          end
-        end
-        if (suite.empty?)
-          catch(:invalid_test) do
-            suite << new("default_test")
-          end
-        end
-        return suite
+        @interrupted = false
       end
 
       # Runs the individual test method represented by this
       # instance of the fixture, collecting statistics, failures
       # and errors in result.
       def run(result)
-        yield(STARTED, name)
-        @_result = result
         begin
-          setup
-          __send__(@method_name)
-        rescue AssertionFailedError => e
-          add_failure(e.message, e.backtrace)
-        rescue Exception
-          raise if PASSTHROUGH_EXCEPTIONS.include? $!.class
-          add_error($!)
-        ensure
+          @_result = result
+          yield(STARTED, name)
           begin
-            teardown
-          rescue AssertionFailedError => e
-            add_failure(e.message, e.backtrace)
+            run_setup
+            __send__(@method_name)
           rescue Exception
-            raise if PASSTHROUGH_EXCEPTIONS.include? $!.class
-            add_error($!)
+            @interrupted = true
+            raise unless handle_exception($!)
+          ensure
+            begin
+              run_teardown
+            rescue Exception
+              raise unless handle_exception($!)
+            end
           end
+          result.add_run
+          yield(FINISHED, name)
+        ensure
+          @_result = nil
         end
-        result.add_run
-        yield(FINISHED, name)
       end
 
       # Called before every test method runs. Can be used
       # to set up fixture information.
+      #
+      # You can add additional setup tasks by the following
+      # code:
+      #   class TestMyClass < Test::Unit::TestCase
+      #     def setup
+      #       ...
+      #     end
+      #
+      #     setup
+      #     def my_setup1
+      #       ...
+      #     end
+      #
+      #     setup
+      #     def my_setup2
+      #       ...
+      #     end
+      #
+      #     def test_my_class
+      #       ...
+      #     end
+      #   end
+      #
+      # Here is a call order:
+      #   * setup
+      #   * my_setup1
+      #   * my_setup2
+      #   * test_my_class
       def setup
       end
 
       # Called after every test method runs. Can be used to tear
       # down fixture information.
+      #
+      # You can add additional teardown tasks by the following
+      # code:
+      #   class TestMyClass < Test::Unit::TestCase
+      #     def teardown
+      #       ...
+      #     end
+      #
+      #     teardown
+      #     def my_teardown1
+      #       ...
+      #     end
+      #
+      #     teardown
+      #     def my_teardown2
+      #       ...
+      #     end
+      #
+      #     def test_my_class
+      #       ...
+      #     end
+      #   end
+      #
+      # Here is a call order:
+      #   * test_my_class
+      #   * my_teardown2
+      #   * my_teardown1
+      #   * teardown
       def teardown
       end
       
@@ -109,35 +220,10 @@ module Test
         flunk("No tests were specified")
       end
 
-      # Returns whether this individual test passed or
-      # not. Primarily for use in teardown so that artifacts
-      # can be left behind if the test fails.
-      def passed?
-        return @test_passed
-      end
-      private :passed?
-
       def size
         1
       end
 
-      def add_assertion
-        @_result.add_assertion
-      end
-      private :add_assertion
-
-      def add_failure(message, all_locations=caller())
-        @test_passed = false
-        @_result.add_failure(Failure.new(name, filter_backtrace(all_locations), message))
-      end
-      private :add_failure
-
-      def add_error(exception)
-        @test_passed = false
-        @_result.add_error(Error.new(name, exception))
-      end
-      private :add_error
-
       # Returns a human-readable name for the specific test that
       # this instance of TestCase represents.
       def name
@@ -148,13 +234,44 @@ module Test
       def to_s
         name
       end
-      
+
       # It's handy to be able to compare TestCase instances.
       def ==(other)
         return false unless(other.kind_of?(self.class))
         return false unless(@method_name == other.method_name)
         self.class == other.class
       end
+
+      def interrupted?
+        @interrupted
+      end
+
+      private
+      def current_result
+        @_result
+      end
+
+      def handle_exception(exception)
+        self.class.exception_handlers.each do |handler|
+          return true if send(handler, exception)
+        end
+        false
+      end
+
+      # Returns whether this individual test passed or
+      # not. Primarily for use in teardown so that artifacts
+      # can be left behind if the test fails.
+      def passed?
+        @test_passed
+      end
+
+      def problem_occurred
+        @test_passed = false
+      end
+
+      def add_assertion
+        current_result.add_assertion
+      end
     end
   end
 end

data/lib/test/unit/testresult.rb

@@ -4,9 +4,19 @@
 # License:: Ruby license.
 
 require 'test/unit/util/observable'
+require 'test/unit/failure'
+require 'test/unit/error'
+require 'test/unit/omission'
+require 'test/unit/pending'
+require 'test/unit/notification'
 
 module Test
   module Unit
+    module NullResultContainerInitializer
+      private
+      def initialize_containers
+      end
+    end
 
     # Collects Test::Unit::Failure and Test::Unit::Error so that
     # they can be displayed to the user. To this end, observers
@@ -14,66 +24,65 @@ module Test
     # UI.
     class TestResult
       include Util::Observable
+      include NullResultContainerInitializer
+      include TestResultFailureSupport
+      include TestResultErrorSupport
+      include TestResultPendingSupport
+      include TestResultOmissionSupport
+      include TestResultNotificationSupport
 
       CHANGED = "CHANGED"
       FAULT = "FAULT"
 
-      attr_reader(:run_count, :assertion_count)
+      attr_reader :run_count, :assertion_count, :faults
 
       # Constructs a new, empty TestResult.
       def initialize
         @run_count, @assertion_count = 0, 0
-        @failures, @errors = Array.new, Array.new
+        @summary_generators = []
+        @problem_checkers = []
+        @faults = []
+        initialize_containers
       end
 
       # Records a test run.
       def add_run
         @run_count += 1
-        notify_listeners(CHANGED, self)
-      end
-
-      # Records a Test::Unit::Failure.
-      def add_failure(failure)
-        @failures << failure
-        notify_listeners(FAULT, failure)
-        notify_listeners(CHANGED, self)
-      end
-
-      # Records a Test::Unit::Error.
-      def add_error(error)
-        @errors << error
-        notify_listeners(FAULT, error)
-        notify_listeners(CHANGED, self)
+        notify_changed
       end
 
       # Records an individual assertion.
       def add_assertion
         @assertion_count += 1
-        notify_listeners(CHANGED, self)
+        notify_changed
       end
 
       # Returns a string contain the recorded runs, assertions,
       # failures and errors in this TestResult.
+      def summary
+        ["#{run_count} tests",
+         "#{assertion_count} assertions",
+         *@summary_generators.collect {|generator| send(generator)}].join(", ")
+      end
+
       def to_s
-        "#{run_count} tests, #{assertion_count} assertions, #{failure_count} failures, #{error_count} errors"
+        summary
       end
 
       # Returns whether or not this TestResult represents
       # successful completion.
       def passed?
-        return @failures.empty? && @errors.empty?
+        @problem_checkers.all? {|checker| not send(checker)}
       end
 
-      # Returns the number of failures this TestResult has
-      # recorded.
-      def failure_count
-        return @failures.size
+      private
+      def notify_changed
+        notify_listeners(CHANGED, self)
       end
 
-      # Returns the number of errors this TestResult has
-      # recorded.
-      def error_count
-        return @errors.size
+      def notify_fault(fault)
+        @faults << fault
+        notify_listeners(FAULT, fault)
       end
     end
   end