activesambaldap 0.0.6 → 0.0.7

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

@@ -1,9 +1,11 @@
 # Author:: Nathaniel Talbott.
 # Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
+#             Copyright (c) 2009 Kouhei Sutou.
 # License:: Ruby license.
 
 require 'test/unit/assertionfailederror'
 require 'test/unit/util/backtracefilter'
+require 'test/unit/util/method-owner-finder'
 require 'test/unit/diff'
 
 module Test
@@ -77,21 +79,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 +87,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
 
       ##
@@ -159,21 +130,67 @@ EOT
       end
 
       ##
-      # Passes if +object+ .instance_of? +klass+
+      # Passes if the block raises one of the given
+      # exceptions or sub exceptions of the given exceptions.
       #
       # Example:
-      #   assert_instance_of String, 'foo'
+      #   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+). When +klass+ is
+      # an array of classes, it passes if any class
+      # satisfies +object.instance_of?(class).
+      #
+      # Example:
+      #   assert_instance_of(String, 'foo')            # -> pass
+      #   assert_instance_of([Fixnum, NilClass], 100)  # -> pass
+      #   assert_instance_of([Numeric, NilClass], 100) # -> fail
 
       public
       def assert_instance_of(klass, object, message="")
         _wrap_assertion do
-          assert_equal(Class, klass.class, "assert_instance_of takes a Class as its first argument")
-          full_message = build_message(message, <<EOT, object, klass, object.class)
+          klasses = nil
+          klasses = klass if klass.is_a?(Array)
+          assert_block("The first parameter to assert_instance_of should be " +
+                       "a Class or an Array of Class.") do
+            if klasses
+              klasses.all? {|k| k.is_a?(Class)}
+            else
+              klass.is_a?(Class)
+            end
+          end
+          klass_message = AssertionMessage.maybe_container(klass) do |value|
+            "<#{value}>"
+          end
+          full_message = build_message(message, <<EOT, object, klass_message, object.class)
 <?> expected to be an instance of
-<?> but was
+? but was
 <?>.
 EOT
-          assert_block(full_message){object.instance_of?(klass)}
+          assert_block(full_message) do
+            if klasses
+              klasses.any? {|k| object.instance_of?(k)}
+            else
+              object.instance_of?(klass)
+            end
+          end
         end
       end
 
@@ -192,17 +209,45 @@ EOT
       end
 
       ##
-      # Passes if +object+ .kind_of? +klass+
+      # Passes if +object+.kind_of?(+klass+). When +klass+ is
+      # an array of classes or modules, it passes if any
+      # class or module satisfies +object.kind_of?(class_or_module).
       #
       # Example:
-      #   assert_kind_of Object, 'foo'
+      #   assert_kind_of(Object, 'foo')                # -> pass
+      #   assert_kind_of([Fixnum, NilClass], 100)      # -> pass
+      #   assert_kind_of([Fixnum, NilClass], "string") # -> fail
 
       public
       def assert_kind_of(klass, object, message="")
         _wrap_assertion do
-          assert(klass.kind_of?(Module), "The first parameter to assert_kind_of should be a kind_of Module.")
-          full_message = build_message(message, "<?>\nexpected to be kind_of\\?\n<?> but was\n<?>.", object, klass, object.class)
-          assert_block(full_message){object.kind_of?(klass)}
+          klasses = nil
+          klasses = klass if klass.is_a?(Array)
+          assert_block("The first parameter to assert_kind_of should be " +
+                       "a kind_of Module or an Array of a kind_of Module.") do
+            if klasses
+              klasses.all? {|k| k.kind_of?(Module)}
+            else
+              klass.kind_of?(Module)
+            end
+          end
+          klass_message = AssertionMessage.maybe_container(klass) do |value|
+            "<#{value}>"
+          end
+          full_message = build_message(message,
+                                       "<?> expected to be kind_of\\?\n" +
+                                       "? but was\n" +
+                                       "<?>.",
+                                       object,
+                                       klass_message,
+                                       object.class)
+          assert_block(full_message) do
+            if klasses
+              klasses.any? {|k| object.kind_of?(k)}
+            else
+              object.kind_of?(klass)
+            end
+          end
         end
       end
 
@@ -215,17 +260,18 @@ EOT
       public
       def assert_respond_to(object, method, message="")
         _wrap_assertion do
-          full_message = build_message(nil, "<?>\ngiven as the method name argument to #assert_respond_to must be a Symbol or #respond_to\\?(:to_str).", method)
-
+          full_message = build_message(message,
+                                       "<?>.kind_of\\?(Symbol) or\n" +
+                                       "<?>.respond_to\\?(:to_str) expected",
+                                       method, method)
           assert_block(full_message) do
-            method.kind_of?(Symbol) || method.respond_to?(:to_str)
+            method.kind_of?(Symbol) or method.respond_to?(:to_str)
           end
-          full_message = build_message(message, <<EOT, object, object.class, method)
-<?>
-of type <?>
-expected to respond_to\\?<?>.
-EOT
-          assert_block(full_message) { object.respond_to?(method) }
+          full_message = build_message(message,
+                                       "<?>.respond_to\\?(?) expected\n" +
+                                       "(Class: <?>)",
+                                       object, method, object.class)
+          assert_block(full_message) {object.respond_to?(method)}
         end
       end
 
@@ -301,18 +347,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 +446,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 +459,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 +485,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 +615,180 @@ 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
+
+      ##
+      # Passes if +object+.+predicate+
+      #
+      # Example:
+      #   assert_predicate([], :empty?)  # -> pass
+      #   assert_predicate([1], :empty?) # -> fail
+      def assert_predicate(object, predicate, message=nil)
+        _wrap_assertion do
+          assert_respond_to(object, predicate, message)
+          actual = object.send(predicate)
+          full_message = build_message(message,
+                                       "<?>.? is true value expected but was\n" +
+                                       "<?>",
+                                       object,
+                                       AssertionMessage.literal(predicate),
+                                       actual)
+          assert_block(full_message) do
+            actual
+          end
+        end
+      end
+
+      ##
+      # Passes if +object+.+predicate+
+      #
+      # Example:
+      #   assert_not_predicate([1], :empty?) # -> pass
+      #   assert_not_predicate([], :empty?)  # -> fail
+      def assert_not_predicate(object, predicate, message=nil)
+        _wrap_assertion do
+          assert_respond_to(object, predicate, message)
+          actual = object.send(predicate)
+          full_message = build_message(message,
+                                       "<?>.? is false value expected but was\n" +
+                                       "<?>",
+                                       object,
+                                       AssertionMessage.literal(predicate),
+                                       actual)
+          assert_block(full_message) do
+            not actual
+          end
+        end
+      end
+
       ##
       # Builds a failure message.  +head+ is added before the +template+ and
       # +arguments+ replaces the '?'s positionally in the template.
@@ -601,8 +831,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 +876,46 @@ EOT
             DelayedLiteral.new(block)
           end
 
+          def maybe_container(value, &formatter)
+            MaybeContainer.new(value, &formatter)
+          end
+
+          MAX_DIFF_TARGET_STRING_SIZE = 300
+          def diff_target_string?(string)
+            if string.respond_to?(:bytesize)
+              string.bytesize < MAX_DIFF_TARGET_STRING_SIZE
+            else
+              string.size < MAX_DIFF_TARGET_STRING_SIZE
+            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
+
+              diff = nil
+              diff = "" if !diff_target_string?(from) or !diff_target_string?(to)
+              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
@@ -645,7 +944,7 @@ EOM
           def initialize(value)
             @value = value
           end
-          
+
           def inspect
             @value.to_s
           end
@@ -655,12 +954,30 @@ EOM
           def initialize(value)
             @value = value
           end
-          
+
           def inspect
             @value.call.to_s
           end
         end
 
+        class MaybeContainer
+          def initialize(value, &formatter)
+            @value = value
+            @formatter = formatter
+          end
+
+          def inspect
+            if @value.is_a?(Array)
+              values = @value.collect do |value|
+                @formatter.call(AssertionMessage.convert(value))
+              end
+              "[#{values.join(', ')}]"
+            else
+              @formatter.call(AssertionMessage.convert(@value))
+            end
+          end
+        end
+
         class Template
           def self.create(string)
             parts = (string ? string.scan(/(?=[^\\])\?|(?:\\\?|[^\?])+/m) : [])
@@ -715,8 +1032,118 @@ EOM
         end
       end
 
-      # :startdoc:
+      class AssertExceptionHelper
+        class WrappedException
+          def initialize(exception)
+            @exception = exception
+          end
+
+          def inspect
+            if default_inspect?
+              "#{@exception.class.inspect}(#{@exception.message.inspect})"
+            else
+              @exception.inspect
+            end
+          end
+
+          def method_missing(name, *args, &block)
+            @exception.send(name, *args, &block)
+          end
+
+          private
+          def default_inspect?
+            inspect_method = @exception.method(:inspect)
+            if inspect_method.respond_to?(:owner) and
+                inspect_method.owner == Exception
+              true
+            else
+              default_inspect_method = Exception.instance_method(:inspect)
+              default_inspect_method.bind(@exception).call == @exception.inspect
+            end
+          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|
+            expected_object == actual_exception or
+              fallback_exception_object_equal(expected_object, actual_exception)
+          end
+        end
+
+        def fallback_exception_object_equal(expected_object, actual_exception)
+          owner = Util::MethodOwnerFinder.find(expected_object, :==)
+          if owner == Kernel or owner == Exception
+            expected_object.class == actual_exception.class and
+              expected_object.message == actual_exception.message
+          else
+            false
+          end
+        end
+      end
+
+      # :startdoc:
     end
   end
 end