glib2 0.90.7 → 0.90.8

data/test-unit/html/test-unit.css

@@ -300,14 +300,14 @@ pre.code
   padding: 5px 10px;
 }
 
-img.eye-catch
+div.eye-catch
 {
   float: right;
 }
 
-dl.feature-list
+div.eye-catch img
 {
-  clear: both;
+  display: block;
 }
 
 dl.feature-list dd

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

@@ -45,7 +45,7 @@ module Test
       #   end
 
       public
-      def assert_block(message="assert_block failed.") # :yields: 
+      def assert_block(message="assert_block failed.") # :yields:
         _wrap_assertion do
           if (! yield)
             raise AssertionFailedError.new(message.to_s)
@@ -62,8 +62,19 @@ module Test
       public
       def assert(boolean, message=nil)
         _wrap_assertion do
-          assert_block("assert should not be called with a block.") { !block_given? }
-          assert_block(build_message(message, "<?> is not true.", boolean)) { boolean }
+          case message
+          when nil, String, Proc
+          else
+            error_message = "assertion message must be String or Proc: "
+            error_message << "<#{message.inspect}>(<#{message.class}>)"
+            raise ArgumentError, error_message, filter_backtrace(caller)
+          end
+          assert_block("assert should not be called with a block.") do
+            !block_given?
+          end
+          assert_block(build_message(message, "<?> is not true.", boolean)) do
+            boolean
+          end
         end
       end
 
@@ -297,6 +308,31 @@ EOT
         end
       end
 
+      ##
+      # Passes if +object+ does not .respond_to? +method+.
+      #
+      # Example:
+      #   assert_not_respond_to('bugbear', :nonexistence) # -> pass
+      #   assert_not_respond_to('bugbear', :size)         # -> fail
+
+      public
+      def assert_not_respond_to(object, method, message="")
+        _wrap_assertion do
+          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) or method.respond_to?(:to_str)
+          end
+          full_message = build_message(message,
+                                       "!<?>.respond_to\\?(?) expected\n" +
+                                       "(Class: <?>)",
+                                       object, method, object.class)
+          assert_block(full_message) {!object.respond_to?(method)}
+        end
+      end
+
       ##
       # Passes if +string+ =~ +pattern+.
       #
@@ -444,25 +480,49 @@ EOT
       end
 
       ##
-      # Passes if +regexp+ !~ +string+ 
+      # Passes if +regexp+ !~ +string+
       #
       # Example:
-      #   assert_no_match(/two/, 'one 2 three')
+      #   assert_not_match(/two/, 'one 2 three')   # -> pass
+      #   assert_not_match(/three/, 'one 2 three') # -> fail
 
       public
-      def assert_no_match(regexp, string, message="")
+      def assert_not_match(regexp, string, message="")
         _wrap_assertion do
-          assert_instance_of(Regexp, regexp, "The first argument to assert_no_match should be a Regexp.")
-          full_message = build_message(message, "<?> expected to not match\n<?>.", regexp, string)
+          assert_instance_of(Regexp, regexp,
+                             "<REGEXP> in assert_not_match(<REGEXP>, ...) " +
+                             "should be a Regexp.")
+          full_message = build_message(message,
+                                       "<?> expected to not match\n<?>.",
+                                       regexp, string)
           assert_block(full_message) { regexp !~ string }
         end
       end
 
+      ##
+      # Deprecated. Use #assert_not_match instead.
+      #
+      # Passes if +regexp+ !~ +string+
+      #
+      # Example:
+      #   assert_no_match(/two/, 'one 2 three')   # -> pass
+      #   assert_no_match(/three/, 'one 2 three') # -> fail
+
+      public
+      def assert_no_match(regexp, string, message="")
+        _wrap_assertion do
+          assert_instance_of(Regexp, regexp,
+                             "The first argument to assert_no_match " +
+                             "should be a Regexp.")
+          assert_not_match(regexp, string, message)
+        end
+      end
+
       UncaughtThrow = {
-        NameError => /^uncaught throw \`(.+)\'$/,
+        NameError => /^uncaught throw \`(.+)\'$/, #`
         ArgumentError => /^uncaught throw (.+)$/,
-        ThreadError => /^uncaught throw \`(.+)\' in thread /
-      } #`
+        ThreadError => /^uncaught throw \`(.+)\' in thread / #`
+      }
 
       ##
       # Passes if the block throws +expected_object+
@@ -550,7 +610,7 @@ EOT
       #   assert_in_delta 0.05, (50000.0 / 10**6), 0.00001
 
       public
-      def assert_in_delta(expected_float, actual_float, delta, message="")
+      def assert_in_delta(expected_float, actual_float, delta=0.001, message="")
         _wrap_assertion do
           _assert_in_delta_validate_arguments(expected_float,
                                               actual_float,
@@ -565,6 +625,31 @@ EOT
         end
       end
 
+      ##
+      # Passes if +expected_float+ and +actual_float+ are
+      # not equal within +delta+ tolerance.
+      #
+      # Example:
+      #   assert_not_in_delta(0.05, (50000.0 / 10**6), 0.00002) # -> pass
+      #   assert_not_in_delta(0.05, (50000.0 / 10**6), 0.00001) # -> fail
+
+      public
+      def assert_not_in_delta(expected_float, actual_float, delta=0.001, message="")
+        _wrap_assertion do
+          _assert_in_delta_validate_arguments(expected_float,
+                                              actual_float,
+                                              delta)
+          full_message = _assert_in_delta_message(expected_float,
+                                                  actual_float,
+                                                  delta,
+                                                  message,
+                                                  :negative_assertion => true)
+          assert_block(full_message) do
+            (expected_float.to_f - actual_float.to_f).abs > delta.to_f
+          end
+        end
+      end
+
       # :stopdoc:
       private
       def _assert_in_delta_validate_arguments(expected_float,
@@ -584,26 +669,40 @@ EOT
       end
 
       def _assert_in_delta_message(expected_float, actual_float, delta,
-                                   message)
-        format = <<-EOT
-<?> expected but was
-<?> (tolerance <?>).
+                                   message, options={})
+        if options[:negative_assertion]
+          format = <<-EOT
+<?> -/+ <?> expected to not include
+<?>.
+EOT
+        else
+          format = <<-EOT
+<?> -/+ <?> expected to include
+<?>.
 EOT
-        arguments = [expected_float, actual_float, delta]
+        end
+        arguments = [expected_float, delta, actual_float]
         normalized_expected = expected_float.to_f
         normalized_actual = actual_float.to_f
         normalized_delta = delta.to_f
         relation_format = nil
         relation_arguments = nil
         if normalized_actual < normalized_expected - normalized_delta
-          relation_format = "<<?> < <?>-<?>(?) <= <?>+<?>(?)>"
+          relation_format = "<<?> < <?>-<?>[?] <= <?>+<?>[?]>"
           relation_arguments = [actual_float,
                                 expected_float, delta,
                                 normalized_expected - normalized_delta,
                                 expected_float, delta,
                                 normalized_expected + normalized_delta]
-        elsif normalized_expected - normalized_delta < normalized_actual
-          relation_format = "<<?>-<?>(?) <= <?>+<?>(?) < <?>>"
+        elsif normalized_actual <= normalized_expected + normalized_delta
+          relation_format = "<<?>-<?>[?] <= <?> <= <?>+<?>[?]>"
+          relation_arguments = [expected_float, delta,
+                                normalized_expected - normalized_delta,
+                                actual_float,
+                                expected_float, delta,
+                                normalized_expected + normalized_delta]
+        else
+          relation_format = "<<?>-<?>[?] <= <?>+<?>[?] < <?>>"
           relation_arguments = [expected_float, delta,
                                 normalized_expected - normalized_delta,
                                 expected_float, delta,
@@ -622,6 +721,142 @@ EOT
 
         build_message(message, format, *arguments)
       end
+
+      public
+      # :startdoc:
+
+      ##
+      # Passes if +expected_float+ and +actual_float+ are equal
+      # within +epsilon+ relative error of +expected_float+.
+      #
+      # Example:
+      #   assert_in_epsilon(10000.0, 9900.0, 0.1) # -> pass
+      #   assert_in_epsilon(10000.0, 9899.0, 0.1) # -> fail
+
+      public
+      def assert_in_epsilon(expected_float, actual_float, epsilon=0.001,
+                            message="")
+        _wrap_assertion do
+          _assert_in_epsilon_validate_arguments(expected_float,
+                                                actual_float,
+                                                epsilon)
+          full_message = _assert_in_epsilon_message(expected_float,
+                                                    actual_float,
+                                                    epsilon,
+                                                    message)
+          assert_block(full_message) do
+            normalized_expected_float = expected_float.to_f
+            delta = normalized_expected_float * epsilon.to_f
+            (normalized_expected_float - actual_float.to_f).abs <= delta
+          end
+        end
+      end
+
+      ##
+      # Passes if +expected_float+ and +actual_float+ are
+      # not equal within +epsilon+ relative error of
+      # +expected_float+.
+      #
+      # Example:
+      #   assert_not_in_epsilon(10000.0, 9900.0, 0.1) # -> fail
+      #   assert_not_in_epsilon(10000.0, 9899.0, 0.1) # -> pass
+
+      public
+      def assert_not_in_epsilon(expected_float, actual_float, epsilon=0.001,
+                                message="")
+        _wrap_assertion do
+          _assert_in_epsilon_validate_arguments(expected_float,
+                                                actual_float,
+                                                epsilon)
+          full_message = _assert_in_epsilon_message(expected_float,
+                                                    actual_float,
+                                                    epsilon,
+                                                    message,
+                                                    :negative_assertion => true)
+          assert_block(full_message) do
+            normalized_expected_float = expected_float.to_f
+            delta = normalized_expected_float * epsilon.to_f
+            (normalized_expected_float - actual_float.to_f).abs > delta
+          end
+        end
+      end
+
+      # :stopdoc:
+      private
+      def _assert_in_epsilon_validate_arguments(expected_float,
+                                                actual_float,
+                                                epsilon)
+        {
+          expected_float => "first float",
+          actual_float => "second float",
+          epsilon => "epsilon"
+        }.each do |float, name|
+          assert_respond_to(float, :to_f,
+                            "The arguments must respond to to_f; " +
+                            "the #{name} did not")
+        end
+        epsilon = epsilon.to_f
+        assert_operator(epsilon, :>=, 0.0, "The epsilon should not be negative")
+      end
+
+      def _assert_in_epsilon_message(expected_float, actual_float, epsilon,
+                                     message, options={})
+        normalized_expected = expected_float.to_f
+        normalized_actual = actual_float.to_f
+        normalized_epsilon = epsilon.to_f
+        delta = normalized_expected * normalized_epsilon
+
+        if options[:negative_assertion]
+          format = <<-EOT
+<?> -/+ (<?> * <?>)[?] expected to not include
+<?>.
+EOT
+        else
+          format = <<-EOT
+<?> -/+ (<?> * <?>)[?] expected to include
+<?>.
+EOT
+        end
+        arguments = [expected_float, expected_float, epsilon, delta,
+                     actual_float]
+
+        relation_format = nil
+        relation_arguments = nil
+        if normalized_actual < normalized_expected - delta
+          relation_format = "<<?> < <?>-(<?>*<?>)[?] <= <?>+(<?>*<?>)[?]>"
+          relation_arguments = [actual_float,
+                                expected_float, expected_float, epsilon,
+                                normalized_expected - delta,
+                                expected_float, expected_float, epsilon,
+                                normalized_expected + delta]
+        elsif normalized_actual <= normalized_expected + delta
+          relation_format = "<<?>-(<?>*<?>)[?] <= <?> <= <?>+(<?>*<?>)[?]>"
+          relation_arguments = [expected_float, expected_float, epsilon,
+                                normalized_expected - delta,
+                                actual_float,
+                                expected_float, expected_float, epsilon,
+                                normalized_expected + delta]
+        else
+          relation_format = "<<?>-(<?>*<?>)[?] <= <?>+(<?>*<?>)[?] < <?>>"
+          relation_arguments = [expected_float, expected_float, epsilon,
+                                normalized_expected - delta,
+                                expected_float, expected_float, epsilon,
+                                normalized_expected + delta,
+                                actual_float]
+        end
+
+        if relation_format
+          format << <<-EOT
+
+Relation:
+#{relation_format}
+EOT
+          arguments.concat(relation_arguments)
+        end
+
+        build_message(message, format, *arguments)
+      end
+
       public
       # :startdoc:
 
@@ -634,18 +869,76 @@ EOT
       # * Arguments to the method
       #
       # Example:
-      #   assert_send [[1, 2], :include?, 4]
+      #   assert_send([[1, 2], :member?, 1]) # -> pass
+      #   assert_send([[1, 2], :member?, 4]) # -> fail
 
       public
-      def assert_send(send_array, message="")
+      def assert_send(send_array, message=nil)
         _wrap_assertion do
-          assert_instance_of(Array, send_array, "assert_send requires an array of send information")
-          assert(send_array.size >= 2, "assert_send requires at least a receiver and a message name")
-          full_message = build_message(message, <<EOT, send_array[0], AssertionMessage.literal(send_array[1].to_s), send_array[2..-1])
+          assert_instance_of(Array, send_array,
+                             "assert_send requires an array " +
+                             "of send information")
+          assert_operator(send_array.size, :>=, 2,
+                          "assert_send requires at least a receiver " +
+                          "and a message name")
+          format = <<EOT
 <?> expected to respond to
-<?(?)> with a true value.
+<?(*?)> with a true value but was
+<?>.
 EOT
-          assert_block(full_message) { send_array[0].__send__(send_array[1], *send_array[2..-1]) }
+          receiver, message_name, *arguments = send_array
+          result = nil
+          full_message =
+            build_message(message,
+                          format,
+                          receiver,
+                          AssertionMessage.literal(message_name.to_s),
+                          arguments,
+                          AssertionMessage.delayed_literal {result})
+          assert_block(full_message) do
+            result = receiver.__send__(message_name, *arguments)
+            result
+          end
+        end
+      end
+
+      ##
+      # Passes if the method send doesn't return a true value.
+      #
+      # +send_array+ is composed of:
+      # * A receiver
+      # * A method
+      # * Arguments to the method
+      #
+      # Example:
+      #   assert_not_send([[1, 2], :member?, 1]) # -> fail
+      #   assert_not_send([[1, 2], :member?, 4]) # -> pass
+      def assert_not_send(send_array, message=nil)
+        _wrap_assertion do
+          assert_instance_of(Array, send_array,
+                             "assert_not_send requires an array " +
+                             "of send information")
+          assert_operator(send_array.size, :>=, 2,
+                          "assert_not_send requires at least a receiver " +
+                          "and a message name")
+          format = <<EOT
+<?> expected to respond to
+<?(*?)> with not a true value but was
+<?>.
+EOT
+          receiver, message_name, *arguments = send_array
+          result = nil
+          full_message =
+            build_message(message,
+                          format,
+                          receiver,
+                          AssertionMessage.literal(message_name.to_s),
+                          arguments,
+                          AssertionMessage.delayed_literal {result})
+          assert_block(full_message) do
+            result = receiver.__send__(message_name, *arguments)
+            not result
+          end
         end
       end
 
@@ -828,7 +1121,7 @@ EOT
       end
 
       ##
-      # Passes if +object+.+predicate+
+      # Passes if +object+.+predicate+ is _true_.
       #
       # Example:
       #   assert_predicate([], :empty?)  # -> pass
@@ -850,7 +1143,7 @@ EOT
       end
 
       ##
-      # Passes if +object+.+predicate+
+      # Passes if +object+.+predicate+ is not _true_.
       #
       # Example:
       #   assert_not_predicate([1], :empty?) # -> pass
@@ -955,6 +1248,96 @@ EOT
         end
       end
 
+      ##
+      # Passes if +collection+ includes +object+.
+      #
+      # Example:
+      #   assert_include([1, 10], 1)            # -> pass
+      #   assert_include(1..10, 5)              # -> pass
+      #   assert_include([1, 10], 5)            # -> fail
+      #   assert_include(1..10, 20)             # -> fail
+      def assert_include(collection, object, message=nil)
+        _wrap_assertion do
+          assert_respond_to(collection, :include?,
+                            "The collection must respond to :include?.")
+          full_message = build_message(message,
+                                       "<?> expected to include\n<?>.",
+                                       collection,
+                                       object)
+          assert_block(full_message) do
+            collection.include?(object)
+          end
+        end
+      end
+
+      ##
+      # Passes if +collection+ doesn't include +object+.
+      #
+      # Example:
+      #   assert_not_include([1, 10], 5)            # -> pass
+      #   assert_not_include(1..10, 20)             # -> pass
+      #   assert_not_include([1, 10], 1)            # -> fail
+      #   assert_not_include(1..10, 5)              # -> fail
+      def assert_not_include(collection, object, message=nil)
+        _wrap_assertion do
+          assert_respond_to(collection, :include?,
+                            "The collection must respond to :include?.")
+          full_message = build_message(message,
+                                       "<?> expected to not include\n<?>.",
+                                       collection,
+                                       object)
+          assert_block(full_message) do
+            not collection.include?(object)
+          end
+        end
+      end
+
+      ##
+      # Passes if +object+ is empty.
+      #
+      # Example:
+      #   assert_empty("")                       # -> pass
+      #   assert_empty([])                       # -> pass
+      #   assert_empty({})                       # -> pass
+      #   assert_empty(" ")                      # -> fail
+      #   assert_empty([nil])                    # -> fail
+      #   assert_empty({1 => 2})                 # -> fail
+      def assert_empty(object, message=nil)
+        _wrap_assertion do
+          assert_respond_to(object, :empty?,
+                            "The object must respond to :empty?.")
+          full_message = build_message(message,
+                                       "<?> expected to be empty.",
+                                       object)
+          assert_block(full_message) do
+            object.empty?
+          end
+        end
+      end
+
+      ##
+      # Passes if +object+ is not empty.
+      #
+      # Example:
+      #   assert_not_empty(" ")                      # -> pass
+      #   assert_not_empty([nil])                    # -> pass
+      #   assert_not_empty({1 => 2})                 # -> pass
+      #   assert_not_empty("")                       # -> fail
+      #   assert_not_empty([])                       # -> fail
+      #   assert_not_empty({})                       # -> fail
+      def assert_not_empty(object, message=nil)
+        _wrap_assertion do
+          assert_respond_to(object, :empty?,
+                            "The object must respond to :empty?.")
+          full_message = build_message(message,
+                                       "<?> expected to not be empty.",
+                                       object)
+          assert_block(full_message) do
+            not object.empty?
+          end
+        end
+      end
+
       ##
       # Builds a failure message.  +head+ is added before the +template+ and
       # +arguments+ replaces the '?'s positionally in the template.
@@ -966,21 +1349,21 @@ EOT
       end
 
       private
-      def _wrap_assertion
+      def _wrap_assertion(&block)
         @_assertion_wrapped ||= false
-        unless (@_assertion_wrapped)
+        if @_assertion_wrapped
+          block.call
+        else
           @_assertion_wrapped = true
           begin
             add_assertion
-            return yield
+            block.call
           ensure
             @_assertion_wrapped = false
           end
-        else
-          return yield
         end
       end
-      
+
       ##
       # Called whenever an assertion is made.  Define this in classes that
       # include Test::Unit::Assertions to record assertion counts.
@@ -1067,6 +1450,14 @@ EOT
             end
           end
 
+          def ensure_diffable_string(string)
+            if string.respond_to?(:encoding) and
+                !string.encoding.ascii_compatible?
+              string = string.dup.force_encoding("ASCII-8BIT")
+            end
+            string
+          end
+
           def prepare_for_diff(from, to)
             if !from.is_a?(String) or !to.is_a?(String)
               from = convert(from)
@@ -1074,6 +1465,8 @@ EOT
             end
 
             if diff_target_string?(from) and diff_target_string?(to)
+              from = ensure_diffable_string(from)
+              to = ensure_diffable_string(to)
               [from, to]
             else
               [nil, nil]
@@ -1117,8 +1510,13 @@ EOM
               if use_pp
                 begin
                   require 'pp' unless defined?(PP)
+                  if HashInspector.target?(object)
+                    pp_target = HashInspector.new(object)
+                  else
+                    pp_target = object
+                  end
                   begin
-                    return PP.pp(object, '').chomp
+                    return PP.pp(pp_target, '').chomp
                   rescue NameError
                   end
                 rescue LoadError
@@ -1130,6 +1528,61 @@ EOM
           end
         end
 
+        class HashInspector
+          class << self
+            def target?(object)
+              object.is_a?(Hash) or object == ENV
+            end
+
+            def normalize(object)
+              if target?(object)
+                new(object)
+              else
+                object
+              end
+            end
+          end
+
+          def initialize(hash)
+            @hash = hash
+          end
+
+          def inspect
+            @hash.inspect
+          end
+
+          def pretty_print(q)
+            q.group(1, '{', '}') do
+              q.seplist(self, nil, :each_pair) do |k, v|
+                q.group do
+                  q.pp(k)
+                  q.text('=>')
+                  q.group(1) do
+                    q.breakable('')
+                    q.pp(v)
+                  end
+                end
+              end
+            end
+          end
+
+          def pretty_print_cycle(q)
+            q.text(@hash.empty? ? '{}' : '{...}')
+          end
+
+          def each_pair
+            keys = @hash.keys
+            begin
+              keys = keys.sort # FIXME: more cleverly
+            rescue ArgumentError
+            end
+            keys.each do |key|
+              yield(self.class.normalize(key),
+                    self.class.normalize(@hash[key]))
+            end
+          end
+        end
+
         class Literal
           def initialize(value)
             @value = value