test-unit 3.0.2 → 3.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e5e36432202b99f66240352830e7f0905d6af3fe
-  data.tar.gz: bb182e15b0c60533e216394a5b5a83c093af57ff
+  metadata.gz: a84889d7e64ada72e39b5d39465d56fca7041b25
+  data.tar.gz: 723b397f2691190b10b17e0ba71dafa3d5d3247e
 SHA512:
-  metadata.gz: 227161f5cf91cf319badbcaedb0b2101d033d02b9d354535bc0c7ba0409af84159bec959f769466f21a74899745e022f7e8cfb37cefa6b6910675ada10115848
-  data.tar.gz: 4bbeeef520af902014c9d8f416e34a9350d25b88038c2c426253ac201e77d1981b3300922e435068010a35c8796a03a1fc7ee126a3f438e9f7d329242481bd44
+  metadata.gz: 7cccaddea4b0ddc35b4984a82b0b6fbc637f76f427671efa6c4aeba33e6f7246ac191cc62db8ced399db8128f478557e84e1e27ad0c8fbe35c4a27b966807083
+  data.tar.gz: 64f04e97bd245dbcb02fece0633cd3cfc5cdf14877a5d75cadb817d7743d97db9f2fcab4ea1a918c4aa88a27ed7531116bd68b1085ef00ffd9826272e2dab3b0

data/README.md

@@ -34,7 +34,7 @@ writing tests, checking results and automated testing in Ruby.
 
 ## How To
 
-* {file:doc/text/how-to.textile}
+* [doc/text/how-to.md](doc/text/how-to.md)
 
 ## Install
 

data/doc/text/news.md

@@ -1,5 +1,26 @@
 # News
 
+## 3.0.3 - 2014-10-29 {#version-3-0-3}
+
+It's a minor update release.
+
+### Improvements
+
+  * Improved `Test::Unit::TestCase.test` performance.
+    100 times faster.
+  * Supported `Proc` for user message.
+    [Sugested by Nobuyoshi Nakada]
+
+### Fixes
+
+  * Fixed markup in document.
+    [GitHub#81][Patch by Masafumi Yokoyama]
+
+### Thanks
+
+  * Masafumi Yokoyama
+  * Nobuyoshi Nakada
+
 ## 3.0.2 - 2014-10-15 {#version-3-0-2}
 
 It's a minor update release.

data/lib/test/unit/assertions.rb

@@ -2062,7 +2062,9 @@ EOT
         def to_s
           message_parts = []
           if (@head)
-            head = @head.to_s
+            head = @head
+            head = head.call if head.respond_to?(:call)
+            head = head.to_s
             unless(head.empty?)
               message_parts << add_period(head)
             end

data/lib/test/unit/attribute.rb

@@ -8,6 +8,10 @@ module Test
           end
         end
 
+        def key?(key)
+          super(self.class.stringify(key))
+        end
+
         def [](key)
           super(self.class.stringify(key))
         end
@@ -107,6 +111,26 @@ module Test
           attributes || StringifyKeyHash.new
         end
 
+        def find_attribute(method_name, name)
+          @attributes_table ||= StringifyKeyHash.new
+          if @attributes_table.key?(method_name)
+            attributes = @attributes_table[method_name]
+            if attributes.key?(name)
+              return attributes[name]
+            end
+          end
+
+          return nil if self == TestCase
+
+          @cached_parent_test_case ||= ancestors.find do |ancestor|
+            ancestor != self and
+              ancestor.is_a?(Class) and
+              ancestor < Test::Unit::Attribute
+          end
+
+          @cached_parent_test_case.find_attribute(method_name, name)
+        end
+
         @@attribute_observers = StringifyKeyHash.new
         def register_attribute_observer(attribute_name, observer=Proc.new)
           @@attribute_observers[attribute_name] ||= []
@@ -123,7 +147,7 @@ module Test
       end
 
       def [](name)
-        attributes[name]
+        self.class.find_attribute(@method_name, name)
       end
     end
   end

data/lib/test/unit/diff.rb

@@ -81,7 +81,7 @@ module Test
             each = :each
           end
           i = 0
-          @to.send(each) do |item|
+          @to.__send__(each) do |item|
             @to_indexes[item] ||= []
             @to_indexes[item] << i
             i += 1
@@ -685,7 +685,7 @@ module Test
           to_index = to_start
           while from_index >= 0 or to_index >= 0
             [@from[from_index], @to[to_index]].each do |line|
-              return line if line and send(predicate, line)
+              return line if line and __send__(predicate, line)
             end
 
             from_index -= 1

data/lib/test/unit/fixture.rb

@@ -5,93 +5,160 @@ module Test
         def included(base)
           base.extend(ClassMethods)
 
-          [:setup, :cleanup, :teardown].each do |fixture|
+          [:setup, :cleanup, :teardown].each do |type|
             observer = lambda do |test_case, _, _, value, callback|
               if value.nil?
-                test_case.send("unregister_#{fixture}_callback", callback)
+                test_case.fixture[type].unregister(callback)
               else
-                test_case.send("register_#{fixture}_callback", callback, value)
+                test_case.fixture[type].register(callback, value)
               end
             end
-            base.register_attribute_observer(fixture, &observer)
+            base.register_attribute_observer(type, &observer)
           end
         end
       end
 
-      module ClassMethods
-        def setup(*method_names, &callback)
-          register_fixture(:setup, *method_names, &callback)
+      class Fixture
+        attr_reader :setup
+        attr_reader :cleanup
+        attr_reader :teardown
+        def initialize(test_case)
+          @test_case = test_case
+          @setup = HookPoint.new(:after => :append)
+          @cleanup = HookPoint.new(:before => :prepend)
+          @teardown = HookPoint.new(:before => :prepend)
+        end
+
+        def [](type)
+          case type
+          when :setup
+            @setup
+          when :cleanup
+            @cleanup
+          when :teardown
+            @teardown
+          end
         end
 
-        def unregister_setup(*method_names_or_callbacks)
-          unregister_fixture(:setup, *method_names_or_callbacks)
+        def before_callbacks(type)
+          target_test_cases.inject([]) do |callbacks, ancestor|
+            callbacks | ancestor.fixture[type].before_callbacks
+          end
         end
 
-        def cleanup(*method_names, &callback)
-          register_fixture(:cleanup, *method_names, &callback)
+        def after_callbacks(type)
+          target_test_cases.inject([]) do |callbacks, ancestor|
+            callbacks | ancestor.fixture[type].after_callbacks
+          end
         end
 
-        def unregister_cleanup(*method_names_or_callbacks)
-          unregister_fixture(:cleanup, *method_names_or_callbacks)
+        private
+        def target_test_cases
+          @cached_target_test_cases ||= collect_target_test_cases
         end
 
-        def teardown(*method_names, &callback)
-          register_fixture(:teardown, *method_names, &callback)
+        def collect_target_test_cases
+          ancestors = @test_case.ancestors
+          base_index = ancestors.index(::Test::Unit::Fixture)
+          interested_ancestors = ancestors[0, base_index].find_all do |ancestor|
+            ancestor.is_a?(Class)
+          end
+          interested_ancestors.reverse
         end
+      end
 
-        def unregister_teardown(*method_names_or_callbacks)
-          unregister_fixture(:teardown, *method_names_or_callbacks)
+      class HookPoint
+        def initialize(default_options)
+          @default_options = default_options
+          @before_callbacks = []
+          @after_callbacks = []
+          @unregistered_callbacks = []
         end
 
-        def register_setup_callback(method_name_or_callback, options)
-          register_fixture_callback(:setup, method_name_or_callback,
-                                    options, :after, :append)
+        def register(method_name_or_callback, options=nil)
+          options ||= {}
+          unless valid_register_options?(options)
+            message = "must be {:before => :prepend}, " +
+              "{:before => :append}, {:after => :prepend} or " +
+              "{:after => :append}: #{options.inspect}"
+            raise ArgumentError, message
+          end
+
+          if options.empty?
+            options = @default_options
+          end
+          before_how = options[:before]
+          after_how = options[:after]
+          if before_how
+            @before_callbacks = add_callback(@before_callbacks,
+                                             method_name_or_callback,
+                                             before_how)
+          else
+            @after_callbacks = add_callback(@after_callbacks,
+                                            method_name_or_callback,
+                                            after_how)
+          end
         end
 
-        def unregister_setup_callback(method_name_or_callback)
-          unregister_fixture_callback(:setup, method_name_or_callback)
+        def unregister(method_name_or_callback)
+          @unregistered_callbacks << method_name_or_callback
         end
 
-        def register_cleanup_callback(method_name_or_callback, options)
-          register_fixture_callback(:cleanup, method_name_or_callback,
-                                    options, :before, :prepend)
+        def before_callbacks
+          @before_callbacks - @unregistered_callbacks
         end
 
-        def unregister_cleanup_callback(method_name_or_callback)
-          unregister_fixture_callback(:cleanup, method_name_or_callback)
+        def after_callbacks
+          @after_callbacks - @unregistered_callbacks
         end
 
-        def register_teardown_callback(method_name_or_callback, options)
-          register_fixture_callback(:teardown, method_name_or_callback,
-                                    options, :before, :prepend)
+        private
+        def valid_register_options?(options)
+          return true if options.empty?
+          return false if options.size > 1
+
+          key = options.keys.first
+          [:before, :after].include?(key) and
+            [:prepend, :append].include?(options[key])
         end
 
-        def unregister_teardown_callback(method_name_or_callback)
-          unregister_fixture_callback(:teardown, method_name_or_callback)
+        def add_callback(callbacks, method_name_or_callback, how)
+          case how
+          when :prepend
+            [method_name_or_callback] | callbacks
+          when :append
+            callbacks | [method_name_or_callback]
+          end
         end
+      end
 
-        def before_setup_callbacks
-          collect_fixture_callbacks(:setup, :before)
+      module ClassMethods
+        def fixture
+          @fixture ||= Fixture.new(self)
         end
 
-        def after_setup_callbacks
-          collect_fixture_callbacks(:setup, :after)
+        def setup(*method_names, &callback)
+          register_fixture(:setup, *method_names, &callback)
         end
 
-        def before_cleanup_callbacks
-          collect_fixture_callbacks(:cleanup, :before)
+        def unregister_setup(*method_names_or_callbacks)
+          unregister_fixture(:setup, *method_names_or_callbacks)
         end
 
-        def after_cleanup_callbacks
-          collect_fixture_callbacks(:cleanup, :after)
+        def cleanup(*method_names, &callback)
+          register_fixture(:cleanup, *method_names, &callback)
         end
 
-        def before_teardown_callbacks
-          collect_fixture_callbacks(:teardown, :before)
+        def unregister_cleanup(*method_names_or_callbacks)
+          unregister_fixture(:cleanup, *method_names_or_callbacks)
         end
 
-        def after_teardown_callbacks
-          collect_fixture_callbacks(:teardown, :after)
+        def teardown(*method_names, &callback)
+          register_fixture(:teardown, *method_names, &callback)
+        end
+
+        def unregister_teardown(*method_names_or_callbacks)
+          unregister_fixture(:teardown, *method_names_or_callbacks)
         end
 
         private
@@ -106,86 +173,14 @@ module Test
         def unregister_fixture(fixture, *method_names_or_callbacks)
           attribute(fixture, nil, *method_names_or_callbacks)
         end
-
-        def valid_register_fixture_options?(options)
-          return true if options.empty?
-          return false if options.size > 1
-
-          key = options.keys.first
-          [:before, :after].include?(key) and
-            [:prepend, :append].include?(options[key])
-        end
-
-        def add_fixture_callback(how, variable_name, method_name_or_callback)
-          callbacks = instance_eval("#{variable_name} ||= []")
-
-          if how == :prepend
-            callbacks = [method_name_or_callback] | callbacks
-          else
-            callbacks = callbacks | [method_name_or_callback]
-          end
-          instance_variable_set(variable_name, callbacks)
-        end
-
-        def registered_callbacks_variable_name(fixture, order)
-          "@#{order}_#{fixture}_callbacks"
-        end
-
-        def unregistered_callbacks_variable_name(fixture)
-          "@unregistered_#{fixture}_callbacks"
-        end
-
-        def register_fixture_callback(fixture, method_name_or_callback, options,
-                                      default_order, default_how)
-          unless valid_register_fixture_options?(options)
-            message = "must be {:before => :prepend}, " +
-              "{:before => :append}, {:after => :prepend} or " +
-              "{:after => :append}: #{options.inspect}"
-            raise ArgumentError, message
-          end
-
-          if options.empty?
-            order, how = default_order, default_how
-          else
-            order, how = options.to_a.first
-          end
-          variable_name = registered_callbacks_variable_name(fixture, order)
-          add_fixture_callback(how, variable_name, method_name_or_callback)
-        end
-
-        def unregister_fixture_callback(fixture, method_name_or_callback)
-          variable_name = unregistered_callbacks_variable_name(fixture)
-          add_fixture_callback(:append, variable_name, method_name_or_callback)
-        end
-
-        def collect_fixture_callbacks(fixture, order)
-          callbacks_variable = registered_callbacks_variable_name(fixture, order)
-          unregistered_callbacks_variable =
-            unregistered_callbacks_variable_name(fixture)
-
-          base_index = ancestors.index(Fixture)
-          interested_ancestors = ancestors[0, base_index].reverse
-          interested_ancestors.inject([]) do |result, ancestor|
-            if ancestor.is_a?(Class)
-              ancestor.class_eval do
-                callbacks = instance_eval("#{callbacks_variable} ||= []")
-                unregistered_callbacks =
-                  instance_eval("#{unregistered_callbacks_variable} ||= []")
-                (result | callbacks) - unregistered_callbacks
-              end
-            else
-              result
-            end
-          end
-        end
       end
 
       private
-      def run_fixture(fixture, options={})
+      def run_fixture(type, options={})
         [
-         self.class.send("before_#{fixture}_callbacks"),
-         fixture,
-         self.class.send("after_#{fixture}_callbacks")
+          self.class.fixture.before_callbacks(type),
+          type,
+          self.class.fixture.after_callbacks(type),
         ].flatten.each do |method_name_or_callback|
           run_fixture_callback(method_name_or_callback, options)
         end
@@ -199,7 +194,7 @@ module Test
         else
           return unless respond_to?(method_name_or_callback, true)
           callback = lambda do
-            send(method_name_or_callback)
+            __send__(method_name_or_callback)
           end
         end
 

data/lib/test/unit/priority.rb

@@ -52,7 +52,7 @@ module Test
           def need_to_run?(test)
             priority = test[:priority] || Priority.default
             if have_priority?(priority)
-              send(priority_check_method_name(priority), test)
+              __send__(priority_check_method_name(priority), test)
             else
               true
             end
@@ -105,7 +105,7 @@ module Test
         end
 
         def teardown
-          if @test.send(:passed?)
+          if @test.__send__(:passed?)
             FileUtils.touch(passed_file)
           else
             FileUtils.rm_f(passed_file)

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

@@ -15,7 +15,7 @@ module Test
       def create
         suite = TestSuite.new(@test_case.name, @test_case)
         collect_test_names.each do |test_name|
-          data_sets = @test_case.attributes(test_name)[:data]
+          data_sets = @test_case.find_attribute(test_name, :data)
           if data_sets
             data_sets.each do |data_set|
               data_set = data_set.call if data_set.respond_to?(:call)
@@ -46,9 +46,10 @@ module Test
         methods -= super_test_case.public_instance_methods(true)
         method_names = methods.collect(&:to_s)
         test_names = method_names.find_all do |method_name|
-          method_name =~ /^test./ or @test_case.attributes(method_name)[:test]
+          method_name =~ /^test./ or
+            @test_case.find_attribute(method_name, :test)
         end
-        send("sort_test_names_in_#{@test_case.test_order}_order", test_names)
+        __send__("sort_test_names_in_#{@test_case.test_order}_order", test_names)
       end
 
       def sort_test_names_in_alphabetic_order(test_names)
@@ -60,10 +61,10 @@ module Test
       end
 
       def sort_test_names_in_defined_order(test_names)
-        added_methods = @test_case.added_methods
+        added_method_names = @test_case.added_method_names
         test_names.sort do |test1, test2|
-          test1_defined_order = added_methods.index(test1)
-          test2_defined_order = added_methods.index(test2)
+          test1_defined_order = added_method_names.index(test1)
+          test2_defined_order = added_method_names.index(test2)
           if test1_defined_order and test2_defined_order
             test1_defined_order <=> test2_defined_order
           elsif test1_defined_order

data/lib/test/unit/testcase.rb

@@ -109,16 +109,15 @@ module Test
           super
         end
 
-        @@added_methods = {}
+        @@added_method_names = {}
         def method_added(name) # :nodoc:
           super
-          _added_methods = added_methods
+          added_method_names = (@@added_method_names[self] ||= {})
           stringified_name = name.to_s
-          if _added_methods.include?(stringified_name)
+          if added_method_names.key?(stringified_name)
             attribute(:redefined, {:backtrace => caller}, {}, stringified_name)
           end
-          _attributes = attributes_table[stringified_name] || {}
-          source_location = _attributes[:source_location]
+          source_location = find_attribute(stringified_name, :source_location)
           if source_location
             path, line = source_location
           else
@@ -130,11 +129,11 @@ module Test
             :path => path,
             :line => line,
           }
-          _added_methods << stringified_name
+          added_method_names[stringified_name] = true
         end
 
-        def added_methods # :nodoc:
-          @@added_methods[self] ||= []
+        def added_method_names # :nodoc:
+          (@@added_method_names[self] ||= {}).keys
         end
 
         # Rolls up all of the test* methods in the fixture into
@@ -339,7 +338,7 @@ module Test
           parent_test_case = self
           sub_test_case = Class.new(self) do
             singleton_class = class << self; self; end
-            singleton_class.send(:define_method, :name) do
+            singleton_class.__send__(:define_method, :name) do
               [parent_test_case.name, name].compact.join("::")
             end
           end
@@ -704,7 +703,7 @@ module Test
           if handler.respond_to?(:call)
             handled = handler.call(self, exception)
           else
-            handled = send(handler, exception)
+            handled = __send__(handler, exception)
           end
           return true if handled
         end

data/lib/test/unit/testresult.rb

@@ -70,7 +70,7 @@ module Test
       def summary
         ["#{run_count} tests",
          "#{assertion_count} assertions",
-         *@summary_generators.collect {|generator| send(generator)}].join(", ")
+         *@summary_generators.collect {|generator| __send__(generator)}].join(", ")
       end
 
       # Returnes a string that shows result status.
@@ -99,7 +99,7 @@ module Test
       # Returns whether or not this TestResult represents
       # successful completion.
       def passed?
-        @problem_checkers.all? {|checker| not send(checker)}
+        @problem_checkers.all? {|checker| not __send__(checker)}
       end
 
       def pass_percentage

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

@@ -511,15 +511,15 @@ module Test
 
           private
           def output_single(something, color=nil)
-            @runner.send(:output_single, something, color)
+            @runner.__send__(:output_single, something, color)
           end
 
           def output(something, color=nil)
-            @runner.send(:output, something, color)
+            @runner.__send__(:output, something, color)
           end
 
           def color(name)
-            @runner.send(:color, name)
+            @runner.__send__(:color, name)
           end
 
           def cut_off_ratio

data/lib/test/unit/ui/emacs/testrunner.rb

@@ -16,7 +16,7 @@ module Test
             return super unless fault.respond_to?(:label)
             format_method_name = "format_fault_#{fault.label.downcase}"
             if respond_to?(format_method_name, true)
-              send(format_method_name, fault)
+              __send__(format_method_name, fault)
             else
               super
             end

data/lib/test/unit/version.rb

@@ -1,5 +1,5 @@
 module Test
   module Unit
-    VERSION = '3.0.2'
+    VERSION = '3.0.3'
   end
 end

data/test/test-assertions.rb

@@ -190,6 +190,23 @@ EOM
              assert_equal("string1", "string2", "failed assert_equal")
             }
           end
+
+          def test_with_message_proc
+            message = <<-EOM.chomp
+failed assert_equal.
+<"string1"> expected but was
+<"string2">.
+
+diff:
+- string1
+?       ^
++ string2
+?       ^
+EOM
+           check_fail(message) do
+              assert_equal("string1", "string2", lambda {"failed assert_equal"})
+            end
+          end
         end
 
         class TestSystemMessage < self

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: test-unit
 version: !ruby/object:Gem::Version
-  version: 3.0.2
+  version: 3.0.3
 platform: ruby
 authors:
 - Kouhei Sutou
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-15 00:00:00.000000000 Z
+date: 2014-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: power_assert
@@ -234,44 +234,44 @@ signing_key:
 specification_version: 4
 summary: An xUnit family unit testing framework for Ruby.
 test_files:
-- test/test-failure.rb
-- test/test-emacs-runner.rb
 - test/test-assertions.rb
-- test/test-fault-location-detector.rb
-- test/test-test-suite.rb
+- test/test-color.rb
 - test/test-code-snippet.rb
-- test/test-attribute.rb
-- test/test-omission.rb
+- test/test-test-suite-creator.rb
+- test/test-test-result.rb
 - test/test-error.rb
-- test/test-priority.rb
-- test/collector/test_objectspace.rb
-- test/collector/test-load.rb
-- test/collector/test-descendant.rb
-- test/collector/test_dir.rb
-- test/util/test_backtracefilter.rb
+- test/test-failure.rb
+- test/run-test.rb
+- test/test-pending.rb
+- test/test-color-scheme.rb
+- test/test-attribute-matcher.rb
+- test/testunit-test-util.rb
+- test/test-data.rb
+- test/ui/test_testrunmediator.rb
 - test/util/test-method-owner-finder.rb
 - test/util/test-output.rb
-- test/util/test_procwrapper.rb
 - test/util/test_observable.rb
-- test/test-diff.rb
-- test/ui/test_testrunmediator.rb
-- test/test-color-scheme.rb
-- test/fixtures/header.tsv
+- test/util/test_backtracefilter.rb
+- test/util/test_procwrapper.rb
+- test/test-omission.rb
+- test/test-test-case.rb
+- test/test-fixture.rb
+- test/fixtures/no-header.csv
 - test/fixtures/header-label.tsv
+- test/fixtures/plus.csv
 - test/fixtures/no-header.tsv
 - test/fixtures/header-label.csv
-- test/fixtures/plus.csv
 - test/fixtures/header.csv
-- test/fixtures/no-header.csv
-- test/test-test-result.rb
-- test/testunit-test-util.rb
-- test/run-test.rb
-- test/test-test-suite-creator.rb
-- test/test-attribute-matcher.rb
-- test/test-test-case.rb
-- test/test-pending.rb
+- test/fixtures/header.tsv
+- test/collector/test-descendant.rb
+- test/collector/test_objectspace.rb
+- test/collector/test-load.rb
+- test/collector/test_dir.rb
+- test/test-priority.rb
+- test/test-test-suite.rb
+- test/test-diff.rb
+- test/test-emacs-runner.rb
+- test/test-attribute.rb
+- test/test-fault-location-detector.rb
 - test/test-notification.rb
-- test/test-fixture.rb
-- test/test-data.rb
-- test/test-color.rb
 has_rdoc: