activegroonga 0.0.7 → 1.0.0

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

@@ -90,8 +90,13 @@ module Test # :nodoc:
   # 
   # Test::Unit is copyright (c) 2000-2003 Nathaniel Talbott. It is free
   # software, and is distributed under the Ruby license. See the COPYING
-  # file in the standard Ruby distribution for details.
+  # file.
   # 
+  # Exception: lib/test/unit/diff.rb is copyright (c)
+  # 2008-2010 Kouhei Sutou and 2001-2008 Python Software
+  # Foundation. It is free software, and is distributed
+  # under the Ruby license and/or the PSF license. See the
+  # COPYING file and PSFL file.
   # 
   # == Warranty
   # 
@@ -179,7 +184,7 @@ module Test # :nodoc:
   #
   #     require 'test/unit'
   #     
-  #     class TC_MyTest < Test::Unit::TestCase
+  #     class MyTest < Test::Unit::TestCase
   #       # def setup
   #       # end
   #     
@@ -194,21 +199,17 @@ module Test # :nodoc:
   #
   # == Test Runners
   #
-  # So, now you have this great test class, but you still need a way to
-  # run it and view any failures that occur during the run. This is
-  # where Test::Unit::UI::Console::TestRunner (and others, such as
-  # Test::Unit::UI::GTK::TestRunner) comes into play. The console test
-  # runner is automatically invoked for you if you require 'test/unit'
-  # and simply run the file. To use another runner, or to manually
-  # invoke a runner, simply call its run class method and pass in an
-  # object that responds to the suite message with a
-  # Test::Unit::TestSuite. This can be as simple as passing in your
-  # TestCase class (which has a class suite method). It might look
-  # something like this:
-  #
-  #    require 'test/unit/ui/console/testrunner'
-  #    Test::Unit::UI::Console::TestRunner.run(TC_MyTest)
+  # So, now you have this great test class, but you still
+  # need a way to run it and view any failures that occur
+  # during the run. There are some test runner; console test
+  # runner, GTK+ test runner and so on. The console test
+  # runner is automatically invoked for you if you require
+  # 'test/unit' and simply run the file. To use another
+  # runner simply set default test runner ID to
+  # Test::Unit::AutoRunner:
   #
+  #    require 'test/unit'
+  #    Test::Unit::AutoRunner.default_runner = "gtk2"
   #
   # == Test Suite
   #
@@ -220,33 +221,17 @@ module Test # :nodoc:
   # in response to a suite method. The TestSuite can, in turn, contain
   # other TestSuites or individual tests (typically created by a
   # TestCase). In other words, you can easily wrap up a group of
-  # TestCases and TestSuites like this:
-  #
-  #  require 'test/unit/testsuite'
-  #  require 'tc_myfirsttests'
-  #  require 'tc_moretestsbyme'
-  #  require 'ts_anothersetoftests'
-  #
-  #  class TS_MyTests
-  #    def self.suite
-  #      suite = Test::Unit::TestSuite.new
-  #      suite << TC_MyFirstTests.suite
-  #      suite << TC_MoreTestsByMe.suite
-  #      suite << TS_AnotherSetOfTests.suite
-  #      return suite
-  #    end
-  #  end
-  #  Test::Unit::UI::Console::TestRunner.run(TS_MyTests)
-  #
-  # Now, this is a bit cumbersome, so Test::Unit does a little bit more
-  # for you, by wrapping these up automatically when you require
-  # 'test/unit'. What does this mean? It means you could write the above
-  # test case like this instead:
+  # TestCases and TestSuites.
+  #
+  # Test::Unit does a little bit more for you, by wrapping
+  # these up automatically when you require
+  # 'test/unit'. What does this mean? It means you could
+  # write the above test case like this instead:
   #
   #  require 'test/unit'
-  #  require 'tc_myfirsttests'
-  #  require 'tc_moretestsbyme'
-  #  require 'ts_anothersetoftests'
+  #  require 'test_myfirsttests'
+  #  require 'test_moretestsbyme'
+  #  require 'test_anothersetoftests'
   #
   # Test::Unit is smart enough to find all the test cases existing in
   # the ObjectSpace and wrap them up into a suite for you. It then runs
@@ -323,12 +308,13 @@ module Test # :nodoc:
   #
 
   module Unit
-    # If set to false Test::Unit will not automatically run at exit.
+    # Set true when Test::Unit has run.  If set to true Test::Unit
+    # will not automatically run at exit.
     def self.run=(flag)
       @run = flag
     end
 
-    # Automatically run tests at exit?
+    # Already tests have run?
     def self.run?
       @run ||= false
     end

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

@@ -9,6 +9,17 @@ module Test
 
     # Thrown by Test::Unit::Assertions when an assertion fails.
     class AssertionFailedError < StandardError
+      attr_accessor :expected, :actual, :user_message
+      attr_accessor :inspected_expected, :inspected_actual
+      def initialize(message=nil, options=nil)
+        options ||= {}
+        @expected = options[:expected]
+        @actual = options[:actual]
+        @inspected_expected = options[:inspected_expected]
+        @inspected_actual = options[:inspected_actual]
+        @user_message = options[:user_message]
+        super(message)
+      end
     end
   end
 end

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

@@ -1,6 +1,6 @@
 # Author:: Nathaniel Talbott.
 # Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
-#             Copyright (c) 2009 Kouhei Sutou.
+#             Copyright (c) 2009-2010 Kouhei Sutou. All rights reserved.
 # License:: Ruby license.
 
 require 'test/unit/assertionfailederror'
@@ -80,11 +80,33 @@ module Test
       public
       def assert_equal(expected, actual, message=nil)
         diff = AssertionMessage.delayed_diff(expected, actual)
-        full_message = build_message(message, <<EOT, expected, actual, diff)
+        if expected.respond_to?(:encoding) and
+            actual.respond_to?(:encoding) and
+            expected.encoding != actual.encoding
+          format = <<EOT
+<?>(?) expected but was
+<?>(?).?
+EOT
+          full_message = build_message(message, format,
+                                       expected, expected.encoding.name,
+                                       actual, actual.encoding.name,
+                                       diff)
+        else
+          full_message = build_message(message, <<EOT, expected, actual, diff)
 <?> expected but was
 <?>.?
 EOT
-        assert_block(full_message) { expected == actual }
+        end
+        begin
+          assert_block(full_message) { expected == actual }
+        rescue AssertionFailedError => failure
+          failure.expected = expected
+          failure.actual = actual
+          failure.inspected_expected = AssertionMessage.convert(expected)
+          failure.inspected_actual = AssertionMessage.convert(actual)
+          failure.user_message = message
+          raise
+        end
       end
 
       ##
@@ -530,18 +552,73 @@ EOT
       public
       def assert_in_delta(expected_float, actual_float, delta, message="")
         _wrap_assertion do
-          {expected_float => "first float", actual_float => "second float", delta => "delta"}.each do |float, name|
-            assert_respond_to(float, :to_f, "The arguments must respond to to_f; the #{name} did not")
-          end
-          assert_operator(delta, :>=, 0.0, "The delta should not be negative")
-          full_message = build_message(message, <<EOT, expected_float, actual_float, delta)
-<?> and
-<?> expected to be within
-<?> of each other.
+          _assert_in_delta_validate_arguments(expected_float,
+                                              actual_float,
+                                              delta)
+          full_message = _assert_in_delta_message(expected_float,
+                                                  actual_float,
+                                                  delta,
+                                                  message)
+          assert_block(full_message) do
+            (expected_float.to_f - actual_float.to_f).abs <= delta.to_f
+          end
+        end
+      end
+
+      # :stopdoc:
+      private
+      def _assert_in_delta_validate_arguments(expected_float,
+                                              actual_float,
+                                              delta)
+        {
+          expected_float => "first float",
+          actual_float => "second float",
+          delta => "delta"
+        }.each do |float, name|
+          assert_respond_to(float, :to_f,
+                            "The arguments must respond to to_f; " +
+                            "the #{name} did not")
+        end
+        assert_operator(delta, :>=, 0.0, "The delta should not be negative")
+      end
+
+      def _assert_in_delta_message(expected_float, actual_float, delta,
+                                   message)
+        format = <<-EOT
+<?> expected but was
+<?> (tolerance <?>).
+EOT
+        arguments = [expected_float, actual_float, delta]
+        normalized_expected = expected_float.to_f
+        normalized_actual = actual_float.to_f
+        normalized_delta = delta.to_f
+        relation_format = nil
+        relation_arguments = nil
+        if normalized_actual < normalized_expected - normalized_delta
+          relation_format = "<<?> < <?>-<?>(?) <= <?>+<?>(?)>"
+          relation_arguments = [actual_float,
+                                expected_float, delta, expected_float - delta,
+                                expected_float, delta, expected_float + delta]
+        elsif normalized_expected - normalized_delta < normalized_actual
+          relation_format = "<<?>-<?>(?) <= <?>+<?>(?) < <?>>"
+          relation_arguments = [expected_float, delta, expected_float - delta,
+                                expected_float, delta, expected_float + delta,
+                                actual_float]
+        end
+
+        if relation_format
+          format << <<-EOT
+
+Relation:
+#{relation_format}
 EOT
-          assert_block(full_message) { (expected_float.to_f - actual_float.to_f).abs <= delta.to_f }
+          arguments.concat(relation_arguments)
         end
+
+        build_message(message, format, *arguments)
       end
+      public
+      # :startdoc:
 
       ##
       # Passes if the method send returns a true value.
@@ -789,6 +866,90 @@ EOT
         end
       end
 
+      ##
+      # Passes if +object+#+alias_name+ is an alias method of
+      # +object+#+original_name+.
+      #
+      # Example:
+      #   assert_alias_method([], :length, :size)  # -> pass
+      #   assert_alias_method([], :size, :length)  # -> pass
+      #   assert_alias_method([], :each, :size)    # -> fail
+      def assert_alias_method(object, alias_name, original_name, message=nil)
+        _wrap_assertion do
+          find_method_failure_message = Proc.new do |method_name|
+            build_message(message,
+                          "<?>.? doesn't exist\n" +
+                          "(Class: <?>)",
+                          object,
+                          AssertionMessage.literal(method_name),
+                          object.class)
+          end
+
+          alias_method = original_method = nil
+          assert_block(find_method_failure_message.call(alias_name)) do
+            begin
+              alias_method = object.method(alias_name)
+              true
+            rescue NameError
+              false
+            end
+          end
+          assert_block(find_method_failure_message.call(original_name)) do
+            begin
+              original_method = object.method(original_name)
+              true
+            rescue NameError
+              false
+            end
+          end
+
+          full_message = build_message(message,
+                                       "<?> is alias of\n" +
+                                       "<?> expected",
+                                       alias_method,
+                                       original_method)
+          assert_block(full_message) do
+            alias_method == original_method
+          end
+        end
+      end
+
+      ##
+      # Passes if +path+ exists.
+      #
+      # Example:
+      #   assert_path_exist("/tmp")          # -> pass
+      #   assert_path_exist("/bin/sh")       # -> pass
+      #   assert_path_exist("/nonexistent")  # -> fail
+      def assert_path_exist(path, message=nil)
+        _wrap_assertion do
+          failure_message = build_message(message,
+                                          "<?> expected to exist",
+                                          path)
+          assert_block(failure_message) do
+            File.exist?(path)
+          end
+        end
+      end
+
+      ##
+      # Passes if +path+ doesn't exist.
+      #
+      # Example:
+      #   assert_path_not_exist("/nonexistent")  # -> pass
+      #   assert_path_not_exist("/tmp")          # -> fail
+      #   assert_path_not_exist("/bin/sh")       # -> fail
+      def assert_path_not_exist(path, message=nil)
+        _wrap_assertion do
+          failure_message = build_message(message,
+                                          "<?> expected to not exist",
+                                          path)
+          assert_block(failure_message) do
+            not File.exist?(path)
+          end
+        end
+      end
+
       ##
       # Builds a failure message.  +head+ is added before the +template+ and
       # +arguments+ replaces the '?'s positionally in the template.
@@ -881,23 +1042,44 @@ EOT
           end
 
           MAX_DIFF_TARGET_STRING_SIZE = 1000
+          def max_diff_target_string_size
+            size = ENV["TEST_UNIT_MAX_DIFF_TARGET_STRING_SIZE"]
+            if size
+              begin
+                size = Integer(size)
+              rescue ArgumentError
+                size = nil
+              end
+            end
+            size || MAX_DIFF_TARGET_STRING_SIZE
+          end
+
           def diff_target_string?(string)
             if string.respond_to?(:bytesize)
-              string.bytesize < MAX_DIFF_TARGET_STRING_SIZE
+              string.bytesize < max_diff_target_string_size
             else
-              string.size < MAX_DIFF_TARGET_STRING_SIZE
+              string.size < max_diff_target_string_size
+            end
+          end
+
+          def prepare_for_diff(from, to)
+            if !from.is_a?(String) or !to.is_a?(String)
+              from = convert(from)
+              to = convert(to)
+            end
+
+            if diff_target_string?(from) and diff_target_string?(to)
+              [from, to]
+            else
+              [nil, nil]
             end
           end
 
           def delayed_diff(from, to)
             delayed_literal do
-              if !from.is_a?(String) or !to.is_a?(String)
-                from = convert(from)
-                to = convert(to)
-              end
+              from, to = prepare_for_diff(from, to)
 
-              diff = nil
-              diff = "" if !diff_target_string?(from) or !diff_target_string?(to)
+              diff = "" if from.nil? or to.nil?
               diff ||= Diff.readable(from, to)
               if /^[-+]/ !~ diff
                 diff = ""

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

@@ -7,6 +7,7 @@ module Test
       RUNNERS = {}
       COLLECTORS = {}
       ADDITIONAL_OPTIONS = []
+      PREPARE_HOOKS = []
 
       class << self
         def register_runner(id, runner_builder=Proc.new)
@@ -18,6 +19,15 @@ module Test
           RUNNERS[id.to_s]
         end
 
+        @@default_runner = nil
+        def default_runner
+          runner(@@default_runner)
+        end
+
+        def default_runner=(id)
+          @@default_runner = id
+        end
+
         def register_collector(id, collector_builder=Proc.new)
           COLLECTORS[id] = collector_builder
           COLLECTORS[id.to_s] = collector_builder
@@ -34,15 +44,20 @@ module Test
         def setup_option(option_builder=Proc.new)
           ADDITIONAL_OPTIONS << option_builder
         end
+
+        def prepare(hook=Proc.new)
+          PREPARE_HOOKS << hook
+        end
       end
 
       def self.run(force_standalone=false, default_dir=nil, argv=ARGV, &block)
         r = new(force_standalone || standalone?, &block)
         r.base = default_dir
+        r.prepare
         r.process_args(argv)
         r.run
       end
-      
+
       def self.standalone?
         return false unless("-e" == $0)
         ObjectSpace.each_object(Class) do |klass|
@@ -90,7 +105,7 @@ module Test
 
       attr_reader :suite, :runner_options
       attr_accessor :filters, :to_run, :pattern, :exclude, :base, :workdir
-      attr_accessor :color_scheme
+      attr_accessor :color_scheme, :listeners
       attr_writer :runner, :collector
 
       def initialize(standalone)
@@ -104,31 +119,32 @@ module Test
         @runner_options = {}
         @default_arguments = []
         @workdir = nil
+        @listeners = []
         config_file = "test-unit.yml"
         if File.exist?(config_file)
           load_config(config_file)
         else
-          global_config_file = File.expand_path("~/.test-unit.xml")
-          load_config(global_config_file) if File.exist?(global_config_file)
+          load_global_config
         end
         yield(self) if block_given?
       end
 
+      def prepare
+        PREPARE_HOOKS.each do |handler|
+          handler.call(self)
+        end
+      end
+
       def process_args(args = ARGV)
-        default_arguments = @default_arguments.dup
         begin
-          @default_arguments.concat(args)
-          options.order!(@default_arguments) {|arg| @to_run << arg}
+          args.unshift(*@default_arguments)
+          options.order!(args) {|arg| @to_run << arg}
         rescue OptionParser::ParseError => e
           puts e
           puts options
           exit(false)
-        else
-          @filters << proc{false} unless(@filters.empty?)
         end
         not @to_run.empty?
-      ensure
-        @default_arguments = default_arguments
       end
 
       def options
@@ -177,9 +193,9 @@ module Test
             n = (%r{\A/(.*)/\Z} =~ n ? Regexp.new($1) : n)
             case n
             when Regexp
-              @filters << proc{|t| n =~ t.method_name ? true : nil}
+              @filters << proc{|t| n =~ t.method_name ? true : false}
             else
-              @filters << proc{|t| n == t.method_name ? true : nil}
+              @filters << proc{|t| n == t.method_name}
             end
           end
 
@@ -189,17 +205,17 @@ module Test
             n = (%r{\A/(.*)/\Z} =~ n ? Regexp.new($1) : n)
             case n
             when Regexp
-              @filters << proc{|t| n =~ t.class.name ? true : nil}
+              @filters << proc{|t| n =~ t.class.name ? true : false}
             else
-              @filters << proc{|t| n == t.class.name ? true : nil}
+              @filters << proc{|t| n == t.class.name}
             end
           end
 
           priority_filter = Proc.new do |test|
-            if @filters.size > 2
-              nil
+            if @filters == [priority_filter]
+              Priority::Checker.new(test).need_to_run?
             else
-              Priority::Checker.new(test).need_to_run? or nil
+              nil
             end
           end
           o.on("--[no-]priority-mode",
@@ -297,6 +313,8 @@ module Test
         runner = @runner[self]
         return false if runner.nil?
         @runner_options[:color_scheme] ||= @color_scheme
+        @runner_options[:listeners] ||= []
+        @runner_options[:listeners].concat(@listeners)
         Dir.chdir(@workdir) if @workdir
         runner.run(suite, @runner_options).passed?
       end
@@ -325,16 +343,29 @@ module Test
 
       private
       def default_runner
+        runner = self.class.default_runner
         if ENV["EMACS"] == "t"
-          self.class.runner(:emacs)
+          runner ||= self.class.runner(:emacs)
         else
-          self.class.runner(:console)
+          runner ||= self.class.runner(:console)
         end
+        runner
       end
 
       def default_collector
         self.class.collector(@standalone ? :load : :descendant)
       end
+
+      def global_config_file
+        File.expand_path("~/.test-unit.yml")
+      rescue ArgumentError
+        nil
+      end
+
+      def load_global_config
+        file = global_config_file
+        load_config(file) if file and File.exist?(file)
+      end
     end
   end
 end