test-unit 1.2.3 → 2.0.0

data/History.txt

@@ -1,3 +1,30 @@
+=== 2.0.0 / 2008-06-18
+
+* 15 major enhancements
+
+  * support startup/shutdown. (test case level setup/teardown)
+  * support multiple setup/teardown.
+  * support pending.
+  * support omission.
+  * support notification.
+  * support colorize.
+  * support diff.
+  * support test attribute.
+  * add assert_boolean.
+  * add assert_true.
+  * add assert_false.
+  * add --priority-mode option.
+  * don't use ObjectSpace to collect test cases.
+  * make more customizable. (additional options, exception handling and so on)
+  * improve Emacs integration.
+
+* 4 major changes
+
+  * remove GTK+1 support.
+  * split GTK+ runner as another gem.
+  * split FOX runner as another gem.
+  * split Tk runner as another gem.
+
 === 1.2.3 / 2008-02-25
 
 * 1 major enhancement

data/Manifest.txt

@@ -6,22 +6,34 @@ bin/testrb
 lib/test/unit.rb
 lib/test/unit/assertionfailederror.rb
 lib/test/unit/assertions.rb
+lib/test/unit/attribute.rb
 lib/test/unit/autorunner.rb
 lib/test/unit/collector.rb
+lib/test/unit/collector/descendant.rb
 lib/test/unit/collector/dir.rb
+lib/test/unit/collector/load.rb
 lib/test/unit/collector/objectspace.rb
+lib/test/unit/color.rb
+lib/test/unit/diff.rb
 lib/test/unit/error.rb
+lib/test/unit/exceptionhandler.rb
 lib/test/unit/failure.rb
+lib/test/unit/fixture.rb
+lib/test/unit/notification.rb
+lib/test/unit/omission.rb
+lib/test/unit/pending.rb
+lib/test/unit/priority.rb
+lib/test/unit/runner/console.rb
+lib/test/unit/runner/emacs.rb
 lib/test/unit/testcase.rb
 lib/test/unit/testresult.rb
 lib/test/unit/testsuite.rb
+lib/test/unit/ui/console/outputlevel.rb
 lib/test/unit/ui/console/testrunner.rb
-lib/test/unit/ui/fox/testrunner.rb
-lib/test/unit/ui/gtk/testrunner.rb
-lib/test/unit/ui/gtk2/testrunner.rb
+lib/test/unit/ui/emacs/testrunner.rb
+lib/test/unit/ui/testrunner.rb
 lib/test/unit/ui/testrunnermediator.rb
 lib/test/unit/ui/testrunnerutilities.rb
-lib/test/unit/ui/tk/testrunner.rb
 lib/test/unit/util/backtracefilter.rb
 lib/test/unit/util/observable.rb
 lib/test/unit/util/procwrapper.rb
@@ -31,18 +43,28 @@ sample/subtracter.rb
 sample/tc_adder.rb
 sample/tc_subtracter.rb
 sample/ts_examples.rb
+test/collector/test_descendant.rb
 test/collector/test_dir.rb
+test/collector/test_load.rb
 test/collector/test_objectspace.rb
-test/runit/test_assert.rb
-test/runit/test_testcase.rb
-test/runit/test_testresult.rb
-test/runit/test_testsuite.rb
+test/run-test.rb
 test/test_assertions.rb
+test/test_attribute.rb
+test/test_color.rb
+test/test_diff.rb
+test/test_emacs_runner.rb
 test/test_error.rb
 test/test_failure.rb
+test/test_fixture.rb
+test/test_notification.rb
+test/test_omission.rb
+test/test_pending.rb
+test/test_priority.rb
 test/test_testcase.rb
 test/test_testresult.rb
 test/test_testsuite.rb
+test/testunit_test_util.rb
+test/ui/test_testrunmediator.rb
 test/util/test_backtracefilter.rb
 test/util/test_observable.rb
 test/util/test_procwrapper.rb

data/README.txt

@@ -9,13 +9,18 @@ externalized from the ruby project as a gem (for tool developers).
 
 == FEATURES/PROBLEMS:
 
-* This is the original Test::Unit, taken straight from the ruby
-  distribution. It is being distributed as a gem to allow tool
-  builders to use it as a stand-alone package. (The test framework in
-  ruby is going to radically change very soon).
+* Test::Unit 1.2.3 is the original Test::Unit, taken
+  straight from the ruby distribution. It is being
+  distributed as a gem to allow tool builders to use it as a
+  stand-alone package. (The test framework in ruby is going
+  to radically change very soon).
+
 * DO NOT INSTALL THIS GEM unless you're active state or some other
   development tool provider! You don't need it.
 
+* Test::Unit 2.0.0 or later are extended versions of the
+  original Test::Unit (== Tset::Unit 1.2.3).
+
 == INSTALL:
 
 * sudo gem install test-unit

data/Rakefile

@@ -4,7 +4,9 @@ require 'rubygems'
 require 'hoe'
 require './lib/test/unit/version.rb'
 
-Hoe.new('test-unit', Test::Unit::VERSION) do |p|
+version = Test::Unit::VERSION
+ENV["VERSION"] = version
+Hoe.new('test-unit', version) do |p|
   p.developer('Kouhei Sutou', 'kou@cozmixng.org')
   p.developer('Ryan Davis', 'ryand-ruby@zenspider.com')
 
@@ -12,4 +14,17 @@ Hoe.new('test-unit', Test::Unit::VERSION) do |p|
   # p.developer('Nathaniel Talbott', 'nathaniel@talbott.ws')
 end
 
+task :check_manifest => :clean_test_result
+
+task :clean_test_result do
+  test_results = Dir.glob("**/.test-result")
+  sh("rm", "-rf", *test_results) unless test_results.empty?
+end
+
+task :tag do
+  message = "Released Test::Unit #{version}!"
+  base = "svn+ssh://#{ENV['USER']}@rubyforge.org/var/svn/test-unit/"
+  sh 'svn', 'copy', '-m', message, "#{base}trunk", "#{base}tags/#{version}"
+end
+
 # vim: syntax=Ruby

data/lib/test/unit/assertions.rb

@@ -4,6 +4,7 @@
 
 require 'test/unit/assertionfailederror'
 require 'test/unit/util/backtracefilter'
+require 'test/unit/diff'
 
 module Test
   module Unit
@@ -76,9 +77,24 @@ module Test
 
       public
       def assert_equal(expected, actual, message=nil)
-        full_message = build_message(message, <<EOT, expected, actual)
+        diff = AssertionMessage.delayed_literal do
+          if !expected.is_a?(String) or !actual.is_a?(String)
+            expected = AssertionMessage.convert(expected)
+            actual = AssertionMessage.convert(actual)
+          end
+          diff = Diff.readable(expected, actual)
+          if /^[-+]/ !~ diff
+            diff = ""
+          elsif /^[ ?]/ =~ diff or /(?:.*\n){2,}/ =~ diff
+            diff = "\n\ndiff:\n#{diff}"
+          else
+            diff = ""
+          end
+          diff
+        end
+        full_message = build_message(message, <<EOT, expected, actual, diff)
 <?> expected but was
-<?>.
+<?>.?
 EOT
         assert_block(full_message) { expected == actual }
       end
@@ -169,7 +185,10 @@ EOT
 
       public
       def assert_nil(object, message="")
-        assert_equal(nil, object, message)
+        full_message = build_message(message, <<EOT, object)
+<?> expected to be nil.
+EOT
+        assert_block(full_message) { object.nil? }
       end
 
       ##
@@ -369,11 +388,14 @@ EOT
         end
       end
 
-      UncaughtThrow = {NameError => /^uncaught throw \`(.+)\'$/,
-                       ThreadError => /^uncaught throw \`(.+)\' in thread /} #`
+      UncaughtThrow = {
+        NameError => /^uncaught throw \`(.+)\'$/,
+        ArgumentError => /^uncaught throw (.+)$/,
+        ThreadError => /^uncaught throw \`(.+)\' in thread /
+      } #`
 
       ##
-      # Passes if the block throws +expected_symbol+
+      # Passes if the block throws +expected_object+
       #
       # Example:
       #   assert_throws :done do
@@ -381,23 +403,35 @@ EOT
       #   end
 
       public
-      def assert_throws(expected_symbol, message="", &proc)
+      def assert_throws(expected_object, message="", &proc)
         _wrap_assertion do
-          assert_instance_of(Symbol, expected_symbol, "assert_throws expects the symbol that should be thrown for its first argument")
-          assert_block("Should have passed a block to assert_throws."){block_given?}
+          begin
+            catch([]) {}
+          rescue TypeError
+            assert_instance_of(Symbol, expected_object,
+                               "assert_throws expects the symbol that should be thrown for its first argument")
+          end
+          assert_block("Should have passed a block to assert_throws.") do
+            block_given?
+          end
           caught = true
           begin
-            catch(expected_symbol) do
+            catch(expected_object) do
               proc.call
               caught = false
             end
-            full_message = build_message(message, "<?> should have been thrown.", expected_symbol)
-            assert_block(full_message){caught}
-          rescue NameError, ThreadError => error
-            if UncaughtThrow[error.class] !~ error.message
-              raise error
-            end
-            full_message = build_message(message, "<?> expected to be thrown but\n<?> was thrown.", expected_symbol, $1.intern)
+            full_message = build_message(message,
+                                         "<?> should have been thrown.",
+                                         expected_object)
+            assert_block(full_message) {caught}
+          rescue NameError, ArgumentError, ThreadError => error
+            raise unless UncaughtThrow[error.class] =~ error.message
+            tag = $1
+            tag = tag[1..-1].intern if tag[0, 1] == ":"
+            full_message = build_message(message,
+                                         "<?> expected to be thrown but\n" +
+                                         "<?> was thrown.",
+                                         expected_object, tag)
             flunk(full_message)
           end
         end
@@ -417,11 +451,13 @@ EOT
           assert(block_given?, "Should have passed a block to assert_nothing_thrown")
           begin
             proc.call
-          rescue NameError, ThreadError => error
-            if UncaughtThrow[error.class] !~ error.message
-              raise error
-            end
-            full_message = build_message(message, "<?> was thrown when nothing was expected", $1.intern)
+          rescue NameError, ArgumentError, ThreadError => error
+            raise unless UncaughtThrow[error.class] =~ error.message
+            tag = $1
+            tag = tag[1..-1].intern if tag[0, 1] == ":"
+            full_message = build_message(message,
+                                         "<?> was thrown when nothing was expected",
+                                         tag)
             flunk(full_message)
           end
           assert(true, "Expected nothing to be thrown")
@@ -475,6 +511,54 @@ EOT
         end
       end
 
+      ##
+      # Passes if +actual+ is a boolean value.
+      #
+      # Example:
+      #   assert_boolean(true) # -> pass
+      #   assert_boolean(nil)  # -> fail
+      def assert_boolean(actual, message=nil)
+        _wrap_assertion do
+          assert_block(build_message(message,
+                                     "<true> or <false> expected but was\n<?>",
+                                     actual)) do
+            [true, false].include?(actual)
+          end
+        end
+      end
+
+      ##
+      # Passes if +actual+ is true.
+      #
+      # Example:
+      #   assert_true(true)  # -> pass
+      #   assert_true(:true) # -> fail
+      def assert_true(actual, message=nil)
+        _wrap_assertion do
+          assert_block(build_message(message,
+                                     "<true> expected but was\n<?>",
+                                     actual)) do
+            actual == true
+          end
+        end
+      end
+
+      ##
+      # Passes if +actual+ is false.
+      #
+      # Example:
+      #   assert_false(false)  # -> pass
+      #   assert_false(nil)    # -> fail
+      def assert_false(actual, message=nil)
+        _wrap_assertion do
+          assert_block(build_message(message,
+                                     "<false> expected but was\n<?>",
+                                     actual)) do
+            actual == false
+          end
+        end
+      end
+
       ##
       # Builds a failure message.  +head+ is added before the +template+ and
       # +arguments+ replaces the '?'s positionally in the template.
@@ -524,6 +608,37 @@ EOT
         @use_pp = true
         class << self
           attr_accessor :use_pp
+
+          def literal(value)
+            Literal.new(value)
+          end
+
+          def delayed_literal(&block)
+            DelayedLiteral.new(block)
+          end
+
+          def convert(object)
+            case object
+            when Exception
+              <<EOM.chop
+Class: <#{convert(object.class)}>
+Message: <#{convert(object.message)}>
+---Backtrace---
+#{Util::BacktraceFilter.filter_backtrace(object.backtrace).join("\n")}
+---------------
+EOM
+            else
+              if use_pp
+                begin
+                  require 'pp' unless defined?(PP)
+                  return PP.pp(object, '').chomp
+                rescue LoadError
+                  self.use_pp = false
+                end
+              end
+              object.inspect
+            end
+          end
         end
 
         class Literal
@@ -536,6 +651,16 @@ EOT
           end
         end
 
+        class DelayedLiteral
+          def initialize(value)
+            @value = value
+          end
+          
+          def inspect
+            @value.call.to_s
+          end
+        end
+
         class Template
           def self.create(string)
             parts = (string ? string.scan(/(?=[^\\])\?|(?:\\\?|[^\?])+/m) : [])
@@ -556,10 +681,6 @@ EOT
           end
         end
 
-        def self.literal(value)
-          Literal.new(value)
-        end
-
         include Util::BacktraceFilter
 
         def initialize(head, template_string, parameters)
@@ -569,28 +690,7 @@ EOT
         end
 
         def convert(object)
-          case object
-            when Exception
-              <<EOM.chop
-Class: <#{convert(object.class)}>
-Message: <#{convert(object.message)}>
----Backtrace---
-#{filter_backtrace(object.backtrace).join("\n")}
----------------
-EOM
-            else
-              if(self.class.use_pp)
-                begin
-                  require 'pp'
-                rescue LoadError
-                  self.class.use_pp = false
-                  return object.inspect
-                end unless(defined?(PP))
-                PP.pp(object, '').chomp
-              else
-                object.inspect
-              end
-          end
+          self.class.convert(object)
         end
 
         def template

data/lib/test/unit/attribute.rb

@@ -0,0 +1,125 @@
+module Test
+  module Unit
+    module Attribute
+      class << self
+        def included(base)
+          base.extend(BaseClassMethods)
+          base.extend(ClassMethods)
+        end
+      end
+
+      module BaseClassMethods
+        def attributes_table
+          {}
+        end
+      end
+
+      module ClassMethods
+        def method_added(name)
+          super
+          return unless defined?(@current_attributes)
+
+          attributes = {}
+          kept_attributes = {}
+          @current_attributes.each do |attribute_name, attribute|
+            attributes[attribute_name] = attribute[:value]
+            kept_attributes[attribute_name] = attribute if attribute[:keep]
+          end
+          set_attributes(name, attributes)
+          @current_attributes = kept_attributes
+        end
+
+        def attribute(name, value, options={}, *method_names)
+          unless options.is_a?(Hash)
+            method_names << options
+            options = {}
+          end
+          @current_attributes ||= {}
+          if method_names.empty?
+            @current_attributes[name] = options.merge(:value => value)
+          else
+            method_names.each do |method_name|
+              set_attributes(method_name, {name => value})
+            end
+          end
+        end
+
+        def attributes_table
+          @attributes_table ||= {}
+          super.merge(@attributes_table)
+        end
+
+        def set_attributes(method_name, new_attributes)
+          return if new_attributes.empty?
+          method_name = normalize_method_name(method_name)
+          @attributes_table ||= {}
+          @attributes_table[method_name] ||= {}
+          current_attributes = @attributes_table[method_name]
+          new_attributes.each do |key, value|
+            key = normalize_attribute_name(key)
+            observers = attribute_observers(key) || []
+            observers.each do |observer|
+              observer.call(self,
+                            key,
+                            (attributes(method_name) || {})[key],
+                            value,
+                            method_name)
+            end
+            current_attributes[key] = value
+          end
+        end
+
+        def attributes(method_name)
+          method_name = normalize_method_name(method_name)
+          attributes = attributes_table[method_name]
+          ancestors[1..-1].each do |ancestor|
+            if ancestor.is_a?(Class) and ancestor < Test::Unit::Attribute
+              parent_attributes = ancestor.attributes(method_name)
+              if attributes
+                attributes = (parent_attributes || {}).merge(attributes)
+              else
+                attributes = parent_attributes
+              end
+              break
+            end
+          end
+          attributes
+        end
+
+        def get_attribute(method_name, attribute_name)
+          attribute_name = normalize_attribute_name(attribute_name)
+          (attributes(method_name) || {})[attribute_name]
+        end
+
+        @@attribute_observers = {}
+        def register_attribute_observer(attribute_name, observer=Proc.new)
+          attribute_name = normalize_attribute_name(attribute_name)
+          @@attribute_observers[attribute_name] ||= []
+          @@attribute_observers[attribute_name] << observer
+        end
+
+        def attribute_observers(attribute_name)
+          attribute_name = normalize_attribute_name(attribute_name)
+          @@attribute_observers[attribute_name]
+        end
+
+        private
+        def normalize_attribute_name(name)
+          name.to_s
+        end
+
+        def normalize_method_name(name)
+          name.to_s
+        end
+      end
+
+      def attributes
+        self.class.attributes(@method_name) || {}
+      end
+
+      def [](name)
+        self.class.get_attribute(@method_name, name)
+      end
+    end
+  end
+end