glib2 0.90.7 → 0.90.8

data/test-unit/lib/test/unit/fixture.rb

@@ -154,13 +154,22 @@ module Test
       end
 
       private
-      def run_fixture(fixture)
+      def run_fixture(fixture, options={})
         [
          self.class.send("before_#{fixture}_methods"),
          fixture,
          self.class.send("after_#{fixture}_methods")
         ].flatten.each do |method_name|
-          send(method_name) if respond_to?(method_name, true)
+          next unless respond_to?(method_name, true)
+          if options[:handle_exception]
+            begin
+              send(method_name)
+            rescue Exception
+              raise unless handle_exception($!)
+            end
+          else
+            send(method_name)
+          end
         end
       end
 
@@ -169,7 +178,7 @@ module Test
       end
 
       def run_teardown
-        run_fixture(:teardown)
+        run_fixture(:teardown, :handle_exception => true)
       end
     end
   end

data/test-unit/lib/test/unit/runner/xml.rb

@@ -0,0 +1,15 @@
+module Test
+  module Unit
+    AutoRunner.register_runner(:xml) do |auto_runner|
+      require 'test/unit/ui/xml/testrunner'
+      Test::Unit::UI::XML::TestRunner
+    end
+
+    AutoRunner.setup_option do |auto_runner, opts|
+      opts.on("--output-file-descriptor=FD", Integer,
+              "Outputs to file descriptor FD") do |fd|
+        auto_runner.runner_options[:output_file_descriptor] = fd
+      end
+    end
+  end
+end

data/test-unit/lib/test/unit/testcase.rb

@@ -87,6 +87,8 @@ module Test
 
       STARTED = name + "::STARTED" # :nodoc:
       FINISHED = name + "::FINISHED" # :nodoc:
+      STARTED_OBJECT = name + "::STARTED::OBJECT" # :nodoc:
+      FINISHED_OBJECT = name + "::FINISHED::OBJECT" # :nodoc:
 
       DESCENDANTS = [] # :nodoc:
       AVAILABLE_ORDERS = [:alphabetic, :random, :defined] # :nodoc:
@@ -219,9 +221,11 @@ module Test
           @@test_orders[self] = order
         end
 
-        # Defines a test in declarative syntax.
+        # Defines a test in declarative syntax or marks
+        # following method as a test method.
         #
-        # The following two test definitions are the same:
+        # In declarative syntax usage, the following two
+        # test definitions are the almost same:
         #
         #   description "register user"
         #   def test_register_user
@@ -231,11 +235,33 @@ module Test
         #   test "register user" do
         #     ...
         #   end
-        def test(test_description, &block)
-          normalized_description = test_description.gsub(/[^a-zA-Z\d_]+/, '_')
-          method_name = "test_#{normalized_description}".to_sym
-          define_method(method_name, &block)
-          description(test_description, method_name)
+        #
+        # In test method mark usage, the "my_test_method" is
+        # treated as a test method:
+        #
+        #   test
+        #   def my_test_method
+        #     assert_equal("call me", ...)
+        #   end
+        def test(*test_description_or_targets, &block)
+          if block_given?
+            test_description = test_description_or_targets.first
+            if test_description.nil?
+              raise ArgumentError, "test description is missing"
+            end
+            n_arguments = test_description_or_targets.size
+            if n_arguments > 1
+              message = "wrong number of arguments (#{n_arguments} for 1)"
+              raise ArgumentError, message
+            end
+            method_name = test_description
+            define_method(method_name, &block)
+            description(test_description, method_name)
+            attribute(:test, true, {}, method_name)
+          else
+            targets = test_description_or_targets
+            attribute(:test, true, {}, *targets)
+          end
         end
 
         # Describes a test.
@@ -259,7 +285,7 @@ module Test
             name.to_s
           end
           test_names = method_names.find_all do |method_name|
-            method_name =~ /^test./
+            method_name =~ /^test./ or get_attribute(method_name, :test)
           end
           send("sort_test_names_in_#{test_order}_order", test_names)
         end
@@ -291,7 +317,7 @@ module Test
         # :startdoc:
       end
 
-      attr_reader :method_name
+      attr_reader :method_name, :start_time, :elapsed_time
 
       # Creates a new instance of the fixture for running the
       # test represented by test_method_name.
@@ -306,6 +332,8 @@ module Test
         @method_name = test_method_name
         @test_passed = true
         @interrupted = false
+        @start_time = nil
+        @elapsed_time = nil
       end
 
       # Runs the individual test method represented by this
@@ -314,7 +342,9 @@ module Test
       def run(result)
         begin
           @_result = result
+          @start_time = Time.now
           yield(STARTED, name)
+          yield(STARTED_OBJECT, self)
           begin
             run_setup
             run_test
@@ -328,8 +358,10 @@ module Test
               raise unless handle_exception($!)
             end
           end
+          @elapsed_time = Time.now - @start_time
           result.add_run
           yield(FINISHED, name)
+          yield(FINISHED_OBJECT, self)
         ensure
           # @_result = nil # For test-spec's after_all :<
         end
@@ -440,6 +472,13 @@ module Test
         @interrupted
       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
+
       private
       def current_result
         @_result
@@ -460,13 +499,6 @@ module Test
         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

data/test-unit/lib/test/unit/testresult.rb

@@ -31,8 +31,10 @@ module Test
       include TestResultOmissionSupport
       include TestResultNotificationSupport
 
-      CHANGED = "CHANGED"
-      FAULT = "FAULT"
+      FINISHED = name + "::FINISHED"
+      CHANGED = name + "::CHANGED"
+      PASS_ASSERTION = name + "::PASS_ASSERTION"
+      FAULT = name + "::FAULT"
 
       attr_reader :run_count, :pass_count, :assertion_count, :faults
 
@@ -48,6 +50,7 @@ module Test
       # Records a test run.
       def add_run
         @run_count += 1
+        notify_listeners(FINISHED, self)
         notify_changed
       end
 
@@ -58,6 +61,7 @@ module Test
       # Records an individual assertion.
       def add_assertion
         @assertion_count += 1
+        notify_listeners(PASS_ASSERTION, self)
         notify_changed
       end
 

data/test-unit/lib/test/unit/testsuite.rb

@@ -2,6 +2,7 @@
 #
 # Author:: Nathaniel Talbott.
 # Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
+# Copyright:: Copyright (c) 2008-2011 Kouhei Sutou. All rights reserved.
 # License:: Ruby license.
 
 require 'test/unit/error'
@@ -17,10 +18,16 @@ module Test
     # has a suite method as simply providing a way to get a
     # meaningful TestSuite instance.
     class TestSuite
-      attr_reader :name, :tests
-      
+      attr_reader :name, :tests, :test_case, :start_time, :elapsed_time
+
+      # Test suite that has higher priority is ran prior to
+      # test suites that have lower priority.
+      attr_accessor :priority
+
       STARTED = name + "::STARTED"
+      STARTED_OBJECT = name + "::STARTED::OBJECT"
       FINISHED = name + "::FINISHED"
+      FINISHED_OBJECT = name + "::FINISHED::OBJECT"
 
       # Creates a new TestSuite with the given name.
       def initialize(name="Unnamed TestSuite", test_case=nil)
@@ -28,19 +35,29 @@ module Test
         @tests = []
         @test_case = test_case
         @n_tests = 0
+        @priority = 0
+        @start_time = nil
+        @elapsed_time = nil
+        @passed = true
       end
 
       # Runs the tests and/or suites contained in this
       # TestSuite.
       def run(result, &progress_block)
+        @start_time = Time.now
         yield(STARTED, name)
+        yield(STARTED_OBJECT, self)
         run_startup(result)
         while test = @tests.shift
           @n_tests += test.size
           test.run(result, &progress_block)
+          @passed = false unless test.passed?
         end
         run_shutdown(result)
+      ensure
+        @elapsed_time = Time.now - @start_time
         yield(FINISHED, name)
+        yield(FINISHED_OBJECT, self)
       end
 
       # Adds the test to the suite.
@@ -79,6 +96,10 @@ module Test
         @tests == other.tests
       end
 
+      def passed?
+        @passed
+      end
+
       private
       def run_startup(result)
         return if @test_case.nil? or !@test_case.respond_to?(:startup)
@@ -104,6 +125,7 @@ module Test
           false
         else
           result.add_error(Error.new(@test_case.name, exception))
+          @passed = false
           true
         end
       end

data/test-unit/lib/test/unit/ui/console/testrunner.rb

@@ -56,21 +56,28 @@ module Test
           end
 
           def attach_to_mediator
-            @mediator.add_listener(TestResult::FAULT, &method(:add_fault))
-            @mediator.add_listener(TestRunnerMediator::STARTED, &method(:started))
-            @mediator.add_listener(TestRunnerMediator::FINISHED, &method(:finished))
-            @mediator.add_listener(TestCase::STARTED, &method(:test_started))
-            @mediator.add_listener(TestCase::FINISHED, &method(:test_finished))
-            @mediator.add_listener(TestSuite::STARTED, &method(:test_suite_started))
-            @mediator.add_listener(TestSuite::FINISHED, &method(:test_suite_finished))
+            @mediator.add_listener(TestResult::FAULT,
+                                   &method(:add_fault))
+            @mediator.add_listener(TestRunnerMediator::STARTED,
+                                   &method(:started))
+            @mediator.add_listener(TestRunnerMediator::FINISHED,
+                                   &method(:finished))
+            @mediator.add_listener(TestCase::STARTED_OBJECT,
+                                   &method(:test_started))
+            @mediator.add_listener(TestCase::FINISHED_OBJECT,
+                                   &method(:test_finished))
+            @mediator.add_listener(TestSuite::STARTED_OBJECT,
+                                   &method(:test_suite_started))
+            @mediator.add_listener(TestSuite::FINISHED_OBJECT,
+                                   &method(:test_suite_finished))
           end
-          
+
           def add_fault(fault)
             @faults << fault
             output_progress(fault.single_character_display, fault_color(fault))
             @already_outputted = true if fault.critical?
           end
-          
+
           def started(result)
             @result = result
             output_started
@@ -92,6 +99,15 @@ module Test
             nl
             output(@result, result_color)
             output("%g%% passed" % @result.pass_percentage, result_color)
+            unless elapsed_time.zero?
+              nl
+              throuputs =
+                [
+                 "%.2f tests/s" % [@result.run_count / elapsed_time],
+                 "%.2f assertions/s" % [@result.assertion_count / elapsed_time],
+                ]
+              output(throuputs.join(", "))
+            end
           end
 
           def output_fault(fault)
@@ -133,18 +149,43 @@ module Test
           end
 
           def output_fault_message(fault)
+            if fault.expected.respond_to?(:encoding) and
+                fault.actual.respond_to?(:encoding) and
+                fault.expected.encoding != fault.actual.encoding
+              need_encoding = true
+            else
+              need_encoding = false
+            end
             output(fault.user_message) if fault.user_message
             output_single("<")
             output_single(fault.inspected_expected, color("pass"))
-            output("> expected but was")
+            output_single(">")
+            if need_encoding
+              output_single("(")
+              output_single(fault.expected.encoding.name, color("pass"))
+              output_single(")")
+            end
+            output(" expected but was")
             output_single("<")
             output_single(fault.inspected_actual, color("failure"))
-            output(">")
+            output_single(">")
+            if need_encoding
+              output_single("(")
+              output_single(fault.actual.encoding.name, color("failure"))
+              output_single(")")
+            end
+            output("")
             from, to = prepare_for_diff(fault.expected, fault.actual)
             if from and to
-              differ = ColorizedReadableDiffer.new(from.split(/\r?\n/),
-                                                   to.split(/\r?\n/),
-                                                   self)
+              from_lines = from.split(/\r?\n/)
+              to_lines = to.split(/\r?\n/)
+              if need_encoding
+                from_lines << ""
+                to_lines << ""
+                from_lines << "Encoding: #{fault.expected.encoding.name}"
+                to_lines << "Encoding: #{fault.actual.encoding.name}"
+              end
+              differ = ColorizedReadableDiffer.new(from_lines, to_lines, self)
               if differ.need_diff?
                 output("")
                 output("diff:")
@@ -157,10 +198,10 @@ module Test
             fault.long_display
           end
 
-          def test_started(name)
+          def test_started(test)
             return unless output?(VERBOSE)
 
-            name = name.sub(/\(.+?\)\z/, '')
+            name = test.name.sub(/\(.+?\)\z/, '')
             right_space = 8 * 2
             left_space = @progress_row_max - right_space
             left_space = left_space - indent.size - name.size
@@ -169,7 +210,7 @@ module Test
             @test_start = Time.now
           end
 
-          def test_finished(name)
+          def test_finished(test)
             unless @already_outputted
               output_progress(".", color("pass"))
             end
@@ -180,24 +221,24 @@ module Test
             output(": (%f)" % (Time.now - @test_start), nil, VERBOSE)
           end
 
-          def test_suite_started(name)
+          def test_suite_started(suite)
             if @top_level
               @top_level = false
               return
             end
 
             output_single(indent, nil, VERBOSE)
-            if /\A[A-Z]/ =~ name
-              _color = color("case")
-            else
+            if suite.test_case.nil?
               _color = color("suite")
+            else
+              _color = color("case")
             end
-            output_single(name, _color, VERBOSE)
+            output_single(suite.name, _color, VERBOSE)
             output(": ", nil, VERBOSE)
             @indent += 2
           end
 
-          def test_suite_finished(name)
+          def test_suite_finished(suite)
             @indent -= 2
           end
 
@@ -286,7 +327,7 @@ module Test
           end
 
           def guess_term_width
-            Integer(ENV["TERM_WIDTH"] || 0)
+            Integer(ENV["COLUMNS"] || ENV["TERM_WIDTH"] || 0)
           rescue ArgumentError
             0
           end
@@ -424,7 +465,3 @@ module Test
     end
   end
 end
-
-if __FILE__ == $0
-  Test::Unit::UI::Console::TestRunner.start_command_line_test
-end