test-unit 2.0.0 → 2.0.1

data/History.txt

@@ -1,3 +1,33 @@
+=== 2.0.1 / 2008-11-09
+
+* 19 major enhancements
+
+  * support ruby 1.9.1.
+  * add run_test method to be extensible.
+  * improve priority-mode auto off.
+  * improve startup/shutdown RDoc. [Daniel Berger]
+  * add assert_compare. [#20851] [Designing Patterns]
+  * add assert_fail_assertion. [#20851] [Designing Patterns]
+  * add assert_raise_message. [#20851] [Designing Patterns]
+  * support folded diff.
+  * add assert_raise_kind_of. [Daniel Berger]
+  * ingore inherited test for nested test case.
+  * add assert_const_defined.
+  * add assert_not_const_defined.
+  * support assert_raise with an exception object.
+  * support assert_raise with no arguments that asserts any
+    exception is raised. [#22602] [Daniel Berger]
+  * support folded dot progress.
+  * add --progress-row-max option.
+  * support color scheme customize.
+  * support configuration file. (YAML)
+  * recognize test-XXX.rb files as test files not only test_XXX.rb
+
+* Thanks
+
+  * Daniel Berger
+  * Designing Patterns
+
 === 2.0.0 / 2008-06-18
 
 * 15 major enhancements

data/Manifest.txt

@@ -2,7 +2,12 @@ History.txt
 Manifest.txt
 README.txt
 Rakefile
+TODO
 bin/testrb
+html/classic.html
+html/index.html
+html/index.html.ja
+html/test-unit-classic.png
 lib/test/unit.rb
 lib/test/unit/assertionfailederror.rb
 lib/test/unit/assertions.rb
@@ -13,6 +18,7 @@ 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-scheme.rb
 lib/test/unit/color.rb
 lib/test/unit/diff.rb
 lib/test/unit/error.rb
@@ -42,28 +48,30 @@ sample/adder.rb
 sample/subtracter.rb
 sample/tc_adder.rb
 sample/tc_subtracter.rb
+sample/test_user.rb
 sample/ts_examples.rb
-test/collector/test_descendant.rb
+test/collector/test-descendant.rb
+test/collector/test-load.rb
 test/collector/test_dir.rb
-test/collector/test_load.rb
 test/collector/test_objectspace.rb
 test/run-test.rb
+test/test-attribute.rb
+test/test-color-scheme.rb
+test/test-color.rb
+test/test-diff.rb
+test/test-emacs-runner.rb
+test/test-fixture.rb
+test/test-notification.rb
+test/test-omission.rb
+test/test-pending.rb
+test/test-priority.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/testunit-test-util.rb
 test/ui/test_testrunmediator.rb
 test/util/test_backtracefilter.rb
 test/util/test_observable.rb

data/README.txt

@@ -1,13 +1,17 @@
-= Test::Unit (Classic)
+= Test::Unit 2.x
 
 * http://rubyforge.org/projects/test-unit/
 
-== DESCRIPTION:
+== DESCRIPTION
 
-Test::Unit (Classic) - Nathaniel Talbott's originial test-unit,
-externalized from the ruby project as a gem (for tool developers).
+Test::Unit 2.x - Improved version of Test::Unit bundled in
+Ruby 1.8.x.
 
-== FEATURES/PROBLEMS:
+Ruby 1.9.x bundles miniunit not Test::Unit. Test::Unit
+bundled in Ruby 1.8.x had not been improved but unbundled
+Test::Unit (Test::Unit 2.x) will be improved actively.
+
+== FEATURES
 
 * Test::Unit 1.2.3 is the original Test::Unit, taken
   straight from the ruby distribution. It is being
@@ -15,18 +19,30 @@ externalized from the ruby project as a gem (for tool developers).
   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.x will be improved actively and may break
+  compatiblity with Test::Unit 1.2.3. (We will not hope it
+  if it isn't needed.)
+
+* Some features exist as separated gems like GUI test
+  runner. (Tk, GTK+ and Fox) test-unit-full gem package
+  provides for installing all Test::Unit related gems
+  easily.
+
+== INSTALL
 
-* Test::Unit 2.0.0 or later are extended versions of the
-  original Test::Unit (== Tset::Unit 1.2.3).
+  % sudo gem install test-unit
 
-== INSTALL:
+If you want to use full Test::Unit features:
 
-* sudo gem install test-unit
+  % sudo gem install test-unit-full
 
-== LICENSE:
+== LICENSE
 
 (The Ruby License)
 
 This software is distributed under the same terms as ruby.
+
+== Thanks
+
+* Daniel Berger: suggestions.
+* Designing Patterns: Suggestions.

data/Rakefile

@@ -15,12 +15,17 @@ Hoe.new('test-unit', version) do |p|
 end
 
 task :check_manifest => :clean_test_result
+task :check_manifest => :clean_coverage
 
 task :clean_test_result do
   test_results = Dir.glob("**/.test-result")
   sh("rm", "-rf", *test_results) unless test_results.empty?
 end
 
+task :clean_coverage do
+  sh("rm", "-rf", "coverage")
+end
+
 task :tag do
   message = "Released Test::Unit #{version}!"
   base = "svn+ssh://#{ENV['USER']}@rubyforge.org/var/svn/test-unit/"

data/TODO

@@ -0,0 +1 @@
+* mock.

data/html/classic.html

@@ -0,0 +1,15 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+<head>
+<title>Test::Unit (Classic)</title>
+</head>
+<body bgcolor="red">
+<p style="text-align: center">
+  <img height="161" width="308" src="test-unit-classic.png">
+  <br>
+  <br>
+  <br>
+  Read the <a href="classic/test-unit/">rdoc</a>
+</p>
+</body>
+</html>

data/html/index.html

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE html
+  PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
+  <head>
+    <meta http-equiv="Content-type" content="text/html; charset=utf-8" />
+    <title>Test::Unit - a Unit Testing Framework for Ruby</title>
+  </head>
+  <body>
+    <h1>Test::Unit - a Unit Testing Framework for Ruby</h1>
+    <p>[<a href="index.html.ja">Japanese</a>]</p>
+    <ul>
+      <li><a href="http://rubyforge.org/projects/test-unit/">Project Page</a></li>
+      <li>
+        <a href="test-unit/">RDoc</a>
+        <!--(<a href="ja/test-unit/">ja</a>)-->
+      </li>
+      <li>
+        <a href="classic.html">Classic</a>
+        <!--(<a href="ja/classic.html">ja</a>)-->
+      </li>
+    </ul>
+  </body>
+</html>

data/html/index.html.ja

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE html
+  PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" lang="ja" xml:lang="ja">
+  <head>
+    <meta http-equiv="Content-type" content="text/html; charset=utf-8" />
+    <title>Test::Unit - Ruby用単体テストフレームワーク</title>
+  </head>
+  <body>
+    <h1>Test::Unit - Ruby用単体テストフレームワーク</h1>
+    <p>[<a href="./">English</a>]</p>
+    <ul>
+      <li>
+        <a href="http://rubyforge.org/projects/test-unit/">プロジェクトページ</a>
+      </li>
+      <li>
+        <!--<a href="ja/test-unit/">RDoc</a>-->
+        RDoc(<a href="test-unit/">en</a>)
+      </li>
+      <li>
+        <!--<a href="classic.html.html">Classic</a>-->
+        Classic(<a href="classic.html">en</a>)
+      </li>
+    </ul>
+  </body>
+</html>

data/lib/test/unit.rb

@@ -253,6 +253,68 @@ module Test # :nodoc:
   # the dynamic suite using the console TestRunner.
   #
   #
+  # == Configuration file
+  #
+  # Test::Unit reads 'test-unit.yml' in the current working
+  # directory as Test::Unit's configuration file. It can
+  # contain the following configurations:
+  #
+  # * color scheme definitions
+  # * test runner to be used
+  # * test runner options
+  # * test collector to be used
+  #
+  # Except color scheme definitions, all of them are
+  # specified by command line option.
+  #
+  # Here are sample color scheme definitions:
+  #
+  #   color_schemes:
+  #     inverted:
+  #       success:
+  #         name: red
+  #         bold: true
+  #       failure:
+  #         name: green
+  #         bold: true
+  #     other_scheme:
+  #       ...
+  #
+  # Here are the syntax of color scheme definitions:
+  #
+  #  color_schemes:
+  #    SCHEME_NAME:
+  #      EVENT_NAME:
+  #        name: COLOR_NAME
+  #        intensity: BOOLEAN
+  #        bold: BOOLEAN
+  #        italic: BOOLEAN
+  #        underline: BOOLEAN
+  #      ...
+  #    ...
+  #
+  # SCHEME_NAME:: the name of the color scheme
+  # EVENT_NAME:: one of [success, failure, pending,
+  #              omission, notification, error]
+  # COLOR_NAME:: one of [black, red, green, yellow, blue,
+  #              magenta, cyan, white]
+  # BOOLEAN:: true or false
+  #
+  # You can use the above 'inverted' color scheme with the
+  # following configuration:
+  #
+  #   runner: console
+  #   console_options:
+  #     color_scheme: inverted
+  #   color_schemes:
+  #     inverted:
+  #       success:
+  #         name: red
+  #         bold: true
+  #       failure:
+  #         name: green
+  #         bold: true
+  #
   # == Questions?
   #
   # I'd really like to get feedback from all levels of Ruby

data/lib/test/unit/assertions.rb

@@ -77,21 +77,7 @@ module Test
 
       public
       def assert_equal(expected, actual, message=nil)
-        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
+        diff = AssertionMessage.delayed_diff(expected, actual)
         full_message = build_message(message, <<EOT, expected, actual, diff)
 <?> expected but was
 <?>.?
@@ -99,53 +85,36 @@ EOT
         assert_block(full_message) { expected == actual }
       end
 
-      private
-      def _check_exception_class(args) # :nodoc:
-        args.partition do |klass|
-          next if klass.instance_of?(Module)
-          assert(Exception >= klass, "Should expect a class of exception, #{klass}")
-          true
-        end
-      end
-
-      private
-      def _expected_exception?(actual_exception, exceptions, modules) # :nodoc:
-        exceptions.include?(actual_exception.class) or
-          modules.any? {|mod| actual_exception.is_a?(mod)}
-      end
-
       ##
-      # Passes if the block raises one of the given exceptions.
+      # Passes if the block raises one of the expected
+      # exceptions. When an expected exception is an Exception
+      # object, passes if expected_exception == actual_exception.
       #
       # Example:
-      #   assert_raise RuntimeError, LoadError do
+      #   assert_raise(RuntimeError, LoadError) do
       #     raise 'Boom!!!'
-      #   end
-
+      #   end # -> pass
+      #
+      #   assert_raise do
+      #     raise Exception, 'Any exception should be raised!!!'
+      #   end # -> pass
+      #
+      #   assert_raise(RuntimeError.new("XXX")) {raise "XXX"} # -> pass
+      #   assert_raise(MyError.new("XXX"))      {raise "XXX"} # -> fail
+      #   assert_raise(RuntimeError.new("ZZZ")) {raise "XXX"} # -> fail
       public
-      def assert_raise(*args)
-        _wrap_assertion do
-          if Module === args.last
-            message = ""
-          else
-            message = args.pop
-          end
-          exceptions, modules = _check_exception_class(args)
-          expected = args.size == 1 ? args.first : args
-          actual_exception = nil
-          full_message = build_message(message, "<?> exception expected but none was thrown.", expected)
+      def assert_raise(*args, &block)
+        assert_expected_exception = Proc.new do |*_args|
+          message, assert_exception_helper, actual_exception = _args
+          expected = assert_exception_helper.expected_exceptions
+          full_message = build_message(message,
+                                       "<?> exception expected but was\n?",
+                                       expected, actual_exception)
           assert_block(full_message) do
-            begin
-              yield
-            rescue Exception => actual_exception
-              break
-            end
-            false
+            expected == [] or assert_exception_helper.expected?(actual_exception)
           end
-          full_message = build_message(message, "<?> exception expected but was\n?", expected, actual_exception)
-          assert_block(full_message) {_expected_exception?(actual_exception, exceptions, modules)}
-          actual_exception
         end
+        _assert_raise(assert_expected_exception, *args, &block)
       end
 
       ##
@@ -158,6 +127,30 @@ EOT
         assert_raise(*args, &block)
       end
 
+      ##
+      # Passes if the block raises one of the given
+      # exceptions or sub exceptions of the given exceptions.
+      #
+      # Example:
+      #   assert_raise_kind_of(SystemCallError) do
+      #     raise Errno::EACCES
+      #   end
+      def assert_raise_kind_of(*args, &block)
+        assert_expected_exception = Proc.new do |*_args|
+          message, assert_exception_helper, actual_exception = _args
+          expected = assert_exception_helper.expected_exceptions
+          full_message = build_message(message,
+                                       "<?> family exception expected " +
+                                       "but was\n?",
+                                       expected, actual_exception)
+          assert_block(full_message) do
+            assert_exception_helper.expected?(actual_exception, :kind_of?)
+          end
+        end
+        _assert_raise(assert_expected_exception, *args, &block)
+      end
+
+
       ##
       # Passes if +object+ .instance_of? +klass+
       #
@@ -301,18 +294,20 @@ EOT
       public
       def assert_nothing_raised(*args)
         _wrap_assertion do
-          if Module === args.last
-            message = ""
-          else
+          if args.last.is_a?(String)
             message = args.pop
+          else
+            message = ""
           end
-          exceptions, modules = _check_exception_class(args)
+
+          assert_exception_helper = AssertExceptionHelper.new(self, args)
           begin
             yield
           rescue Exception => e
             if ((args.empty? && !e.instance_of?(AssertionFailedError)) ||
-                _expected_exception?(e, exceptions, modules))
-              assert_block(build_message(message, "Exception raised:\n?", e)){false}
+                assert_exception_helper.expected?(e))
+              failure_message = build_message(message, "Exception raised:\n?", e)
+              assert_block(failure_message) {false}
             else
               raise
             end
@@ -398,12 +393,12 @@ EOT
       # Passes if the block throws +expected_object+
       #
       # Example:
-      #   assert_throws :done do
-      #     throw :done
+      #   assert_throw(:done) do
+      #     throw(:done)
       #   end
 
       public
-      def assert_throws(expected_object, message="", &proc)
+      def assert_throw(expected_object, message="", &proc)
         _wrap_assertion do
           begin
             catch([]) {}
@@ -411,7 +406,7 @@ EOT
             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
+          assert_block("Should have passed a block to assert_throw.") do
             block_given?
           end
           caught = true
@@ -437,6 +432,14 @@ EOT
         end
       end
 
+      ##
+      # Alias of assert_throw.
+      #
+      # Will be deprecated in 1.9, and removed in 2.0.
+      def assert_throws(*args, &block)
+        assert_throw(*args, &block)
+      end
+
       ##
       # Passes if block does not throw anything.
       #
@@ -559,6 +562,136 @@ EOT
         end
       end
 
+      ##
+      # Passes if expression "+expected+ +operator+
+      # +actual+" is true.
+      #
+      # Example:
+      #   assert_compare(1, "<", 10)  # -> pass
+      #   assert_compare(1, ">=", 10) # -> fail
+      def assert_compare(expected, operator, actual, message=nil)
+        _wrap_assertion do
+          assert_send([["<", "<=", ">", ">="], :include?, operator.to_s])
+          case operator.to_s
+          when "<"
+            operator_description = "less than"
+          when "<="
+            operator_description = "less than or equal to"
+          when ">"
+            operator_description = "greater than"
+          when ">="
+            operator_description = "greater than or equal to"
+          end
+          template = <<-EOT
+<?> #{operator} <?> should be true
+<?> expected #{operator_description}
+<?>.
+EOT
+          full_message = build_message(message, template,
+                                       expected, actual,
+                                       expected, actual)
+          assert_block(full_message) do
+            expected.send(operator, actual)
+          end
+        end
+      end
+
+      ##
+      # Passes if assertion is failed in block.
+      #
+      # Example:
+      #   assert_fail_assertion {assert_equal("A", "B")}  # -> pass
+      #   assert_fail_assertion {assert_equal("A", "A")}  # -> fail
+      def assert_fail_assertion(message=nil)
+        _wrap_assertion do
+          full_message = build_message(message,
+                                       "Failed assertion was expected.")
+          assert_block(full_message) do
+            begin
+              yield
+              false
+            rescue AssertionFailedError
+              true
+            end
+          end
+        end
+      end
+
+      ##
+      # Passes if an exception is raised in block and its
+      # message is +expected+.
+      #
+      # Example:
+      #   assert_raise_message("exception") {raise "exception"}  # -> pass
+      #   assert_raise_message(/exc/i) {raise "exception"}       # -> pass
+      #   assert_raise_message("exception") {raise "EXCEPTION"}  # -> fail
+      #   assert_raise_message("exception") {}                   # -> fail
+      def assert_raise_message(expected, message=nil)
+        _wrap_assertion do
+          full_message = build_message(message,
+                                       "<?> exception message expected " +
+                                       "but none was thrown.",
+                                       expected)
+          exception = nil
+          assert_block(full_message) do
+            begin
+              yield
+              false
+            rescue Exception => exception
+              true
+            end
+          end
+
+          actual = exception.message
+          diff = AssertionMessage.delayed_diff(expected, actual)
+          full_message =
+            build_message(message,
+                          "<?> exception message expected but was\n" +
+                          "<?>.?", expected, actual, diff)
+          assert_block(full_message) do
+            if expected.is_a?(Regexp)
+              expected =~ actual
+            else
+              expected == actual
+            end
+          end
+        end
+      end
+
+      ##
+      # Passes if +object+.const_defined?(+constant_name+)
+      #
+      # Example:
+      #   assert_const_defined(Test, :Unit)          # -> pass
+      #   assert_const_defined(Object, :Nonexistent) # -> fail
+      def assert_const_defined(object, constant_name, message=nil)
+        _wrap_assertion do
+          full_message = build_message(message,
+                                       "<?>.const_defined\\?(<?>) expected.",
+                                       object, constant_name)
+          assert_block(full_message) do
+            object.const_defined?(constant_name)
+          end
+        end
+      end
+
+      ##
+      # Passes if !+object+.const_defined?(+constant_name+)
+      #
+      # Example:
+      #   assert_not_const_defined(Object, :Nonexistent) # -> pass
+      #   assert_not_const_defined(Test, :Unit)          # -> fail
+      def assert_not_const_defined(object, constant_name, message=nil)
+        _wrap_assertion do
+          full_message = build_message(message,
+                                       "!<?>.const_defined\\?(<?>) expected.",
+                                       object, constant_name)
+          assert_block(full_message) do
+            !object.const_defined?(constant_name)
+          end
+        end
+      end
+
       ##
       # Builds a failure message.  +head+ is added before the +template+ and
       # +arguments+ replaces the '?'s positionally in the template.
@@ -601,8 +734,37 @@ EOT
       def self.use_pp=(value)
         AssertionMessage.use_pp = value
       end
-      
+
       # :stopdoc:
+      private
+      def _assert_raise(assert_expected_exception, *args, &block)
+        _wrap_assertion do
+          if args.last.is_a?(String)
+            message = args.pop
+          else
+            message = ""
+          end
+
+          assert_exception_helper = AssertExceptionHelper.new(self, args)
+          expected = assert_exception_helper.expected_exceptions
+          actual_exception = nil
+          full_message = build_message(message,
+                                       "<?> exception expected " +
+                                       "but none was thrown.",
+                                       expected)
+          assert_block(full_message) do
+            begin
+              yield
+              false
+            rescue Exception => actual_exception
+              true
+            end
+          end
+          assert_expected_exception.call(message, assert_exception_helper,
+                                         actual_exception)
+          actual_exception
+        end
+      end
 
       class AssertionMessage
         @use_pp = true
@@ -617,6 +779,31 @@ EOT
             DelayedLiteral.new(block)
           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
+
+              diff = Diff.readable(from, to)
+              if /^[-+]/ !~ diff
+                diff = ""
+              elsif /^[ ?]/ =~ diff or /(?:.*\n){2,}/ =~ diff
+                diff = "\n\ndiff:\n#{diff}"
+              else
+                diff = ""
+              end
+
+              if Diff.need_fold?(diff)
+                folded_diff = Diff.folded_readable(from, to)
+                diff << "\n\nfolded diff:\n#{folded_diff}"
+              end
+
+              diff
+            end
+          end
+
           def convert(object)
             case object
             when Exception
@@ -715,8 +902,105 @@ EOM
         end
       end
 
-      # :startdoc:
+      class AssertExceptionHelper
+        class WrappedException
+          def initialize(exception)
+            @exception = exception
+          end
+
+          def inspect
+            inspect_method = @exception.method(:inspect)
+            if inspect_method.respond_to?(:owner) and
+                inspect_method.owner == Exception
+              "#{@exception.class.inspect}(#{@exception.message.inspect})"
+            else
+              @exception.inspect
+            end
+          end
+
+          def method_missing(name, *args, &block)
+            @exception.send(name, *args, &block)
+          end
+        end
+
+        def initialize(test_case, expected_exceptions)
+          @test_case = test_case
+          @expected_exceptions = expected_exceptions
+          @expected_classes, @expected_modules, @expected_objects =
+            split_expected_exceptions(expected_exceptions)
+        end
+
+        def expected_exceptions
+          exceptions = @expected_exceptions.collect do |exception|
+            if exception.is_a?(Exception)
+              WrappedException.new(exception)
+            else
+              exception
+            end
+          end
+          if exceptions.size == 1
+            exceptions[0]
+          else
+            exceptions
+          end
+        end
+
+        def expected?(actual_exception, equality=nil)
+          equality ||= :instance_of?
+          expected_class?(actual_exception, equality) or
+            expected_module?(actual_exception) or
+            expected_object?(actual_exception)
+        end
+
+        private
+        def split_expected_exceptions(expected_exceptions)
+          exception_modules = []
+          exception_objects = []
+          exception_classes = []
+          expected_exceptions.each do |exception_type|
+            if exception_type.instance_of?(Module)
+              exception_modules << exception_type
+            elsif exception_type.is_a?(Exception)
+              exception_objects << exception_type
+            else
+              @test_case.send(:assert,
+                              Exception >= exception_type,
+                              "Should expect a class of exception, " +
+                              "#{exception_type}")
+              exception_classes << exception_type
+            end
+          end
+          [exception_classes, exception_modules, exception_objects]
+        end
+
+        def expected_class?(actual_exception, equality)
+          @expected_classes.any? do |expected_class|
+            actual_exception.send(equality, expected_class)
+          end
+        end
 
+        def expected_module?(actual_exception)
+          @expected_modules.any? do |expected_module|
+            actual_exception.is_a?(expected_module)
+          end
+        end
+
+        def expected_object?(actual_exception)
+          @expected_objects.any? do |expected_object|
+            equal_method = expected_object.method(:==)
+            if equal_method.respond_to?(:owner) and
+                (equal_method.owner == Kernel or
+                 equal_method.owner == Exception)
+              expected_object.class == actual_exception.class and
+                expected_object.message == actual_exception.message
+            else
+              expected_object == actual_exception
+            end
+          end
+        end
+      end
+
+      # :startdoc:
     end
   end
 end