Test::Unit::Assertions (Module)

In: test/unit/assertions.rb

Contains all of the standard Test::Unit assertions. Mixed in to Test::Unit::TestCase. To mix it in and use its functionality, you simply need to rescue Test::Unit::AssertionFailedError, and you can additionally override add_assertion to be notified whenever an assertion is made.

Notes:

  • The message to each assertion, if given, will be propagated with the failure.
  • It’s easy to add your own assertions based on assert_block().

Constants

UncaughtThrow = {NameError => /^uncaught throw \`(.+)\'$/, ThreadError => /^uncaught throw \`(.+)\' in thread /}

Public Class methods

Select whether or not to use the prettyprinter. If this option is set to false before any assertions are made, the prettyprinter will not be required at all.

[Source]

# File test/unit/assertions.rb, line 370
      def self.use_pp=(value)
        AssertionMessage.use_pp = value
      end

Public Instance methods

The assertion upon which all other assertions are based. Passes if the block yields true.

[Source]

# File test/unit/assertions.rb, line 29
      def assert_block(message="assert_block failed.") # :yields: 

        _wrap_assertion do
          if (! yield)
            raise AssertionFailedError.new(message.to_s)
          end
        end
      end

Passes if boolean is true.

[Source]

# File test/unit/assertions.rb, line 39
      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 }
        end
      end

Passes if expected == actual. Note that the ordering of arguments is important, since a helpful error message is generated when this one fails that tells you the values of expected and actual.

[Source]

# File test/unit/assertions.rb, line 51
      def assert_equal(expected, actual, message=nil)
        full_message = build_message(message, "<?> expected but was\n<?>.\n", expected, actual)
        assert_block(full_message) { expected == actual }
      end

Passes if block raises one of the given exceptions.

[Source]

# File test/unit/assertions.rb, line 62
      def assert_raise(*args)
        _wrap_assertion do
          if Class === args.last
            message = ""
          else
            message = args.pop
          end
          args.each do |klass|
            assert(Exception >= klass, "Should expect a class of exception, #{klass}")
          end
          expected = args.size == 1 ? args.first : args
          actual_exception = nil
          full_message = build_message(message, "<?> exception expected but none was thrown.", expected)
          assert_block(full_message) do
            begin
              yield
            rescue Exception => actual_exception
              break
            end
            false
          end
          full_message = build_message(message, "<?> exception expected but was\n?", expected, actual_exception)
          assert_block(full_message) { args.include?(actual_exception.class) }
          actual_exception
        end
      end

Alias of assert_raise. Will be deprecated in 1.9, and removed in 2.0.

[Source]

# File test/unit/assertions.rb, line 91
      def assert_raises(*args, &block)
        assert_raise(*args, &block)
      end

Passes if object.class == klass.

[Source]

# File test/unit/assertions.rb, line 97
      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, "<?> expected to be an instance of\n<?> but was\n<?>.\n", object, klass, object.class)
          assert_block(full_message){object.instance_of?(klass)}
        end
      end

Passes if object.nil?.

[Source]

# File test/unit/assertions.rb, line 112
      def assert_nil(object, message="")
        assert_equal(nil, object, message)
      end

Passes if object.kind_of?(klass).

[Source]

# File test/unit/assertions.rb, line 118
      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)}
        end
      end

Passes if object.respond_to?(method) is true.

[Source]

# File test/unit/assertions.rb, line 128
      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)

          assert_block(full_message) do
            method.kind_of?(Symbol) || method.respond_to?(:to_str)
          end
          full_message = build_message(message, "<?>\nof type <?>\nexpected to respond_to\\\\?<?>.\n", object, object.class, method)
          assert_block(full_message) { object.respond_to?(method) }
        end
      end

Passes if string =~ pattern.

[Source]

# File test/unit/assertions.rb, line 147
      def assert_match(pattern, string, message="")
        _wrap_assertion do
          pattern = case(pattern)
            when String
              Regexp.new(Regexp.escape(pattern))
            else
              pattern
          end
          full_message = build_message(message, "<?> expected to be =~\n<?>.", string, pattern)
          assert_block(full_message) { string =~ pattern }
        end
      end

Passes if actual.equal?(expected) (i.e. they are the same instance).

[Source]

# File test/unit/assertions.rb, line 163
      def assert_same(expected, actual, message="")
        full_message = build_message(message, "<?>\nwith id <?> expected to be equal\\\\? to\n<?>\nwith id <?>.\n", expected, expected.__id__, actual, actual.__id__)
        assert_block(full_message) { actual.equal?(expected) }
      end

Compares the two objects based on the passed operator. Passes if object1.send(operator, object2) is true.

[Source]

# File test/unit/assertions.rb, line 178
      def assert_operator(object1, operator, object2, message="")
        _wrap_assertion do
          full_message = build_message(nil, "<?>\ngiven as the operator for #assert_operator must be a Symbol or #respond_to\\?(:to_str).", operator)
          assert_block(full_message){operator.kind_of?(Symbol) || operator.respond_to?(:to_str)}
          full_message = build_message(message, "<?> expected to be\n?\n<?>.\n", object1, AssertionMessage.literal(operator), object2)
          assert_block(full_message) { object1.__send__(operator, object2) }
        end
      end

Passes if block does not raise an exception.

[Source]

# File test/unit/assertions.rb, line 194
      def assert_nothing_raised(*args)
        _wrap_assertion do
          if Class === args.last
            message = ""
          else
            message = args.pop
          end
          args.each do |klass|
            assert(Exception >= klass, "Should expect a class of exception, #{klass}")
          end
          begin
            yield
          rescue Exception => e
            if ((args.empty? && !e.instance_of?(AssertionFailedError)) || args.include?(e.class))
              assert_block(build_message(message, "Exception raised:\n?", e)){false}
            else
              raise e.class, e.message, e.backtrace
            end
          end
          nil
        end
      end

Always fails.

[Source]

# File test/unit/assertions.rb, line 219
      def flunk(message="Flunked")
        assert_block(build_message(message)){false}
      end

Passes if !actual.equal?(expected).

[Source]

# File test/unit/assertions.rb, line 225
      def assert_not_same(expected, actual, message="")
        full_message = build_message(message, "<?>\nwith id <?> expected to not be equal\\\\? to\n<?>\nwith id <?>.\n", expected, expected.__id__, actual, actual.__id__)
        assert_block(full_message) { !actual.equal?(expected) }
      end

Passes if expected != actual.

[Source]

# File test/unit/assertions.rb, line 238
      def assert_not_equal(expected, actual, message="")
        full_message = build_message(message, "<?> expected to be != to\n<?>.", expected, actual)
        assert_block(full_message) { expected != actual }
      end

Passes if !object.nil?.

[Source]

# File test/unit/assertions.rb, line 245
      def assert_not_nil(object, message="")
        full_message = build_message(message, "<?> expected to not be nil.", object)
        assert_block(full_message){!object.nil?}
      end

Passes if string !~ regularExpression.

[Source]

# File test/unit/assertions.rb, line 252
      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.")
          full_message = build_message(message, "<?> expected to not match\n<?>.", regexp, string)
          assert_block(full_message) { regexp !~ string }
        end
      end

Passes if block throws symbol.

[Source]

# File test/unit/assertions.rb, line 265
      def assert_throws(expected_symbol, 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?}
          caught = true
          begin
            catch(expected_symbol) 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)
            flunk(full_message)
          end
        end
      end

Passes if block does not throw anything.

[Source]

# File test/unit/assertions.rb, line 289
      def assert_nothing_thrown(message="", &proc)
        _wrap_assertion do
          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)
            flunk(full_message)
          end
          assert(true, "Expected nothing to be thrown")
        end
      end

Passes if expected_float and actual_float are equal within delta tolerance.

[Source]

# File test/unit/assertions.rb, line 308
      def assert_in_delta(expected_float, actual_float, delta, message="")
        _wrap_assertion do
          {expected_float => "first float", actual_float => "second float", delta => "delta"}.each do |float, name|
            assert_respond_to(float, :to_f, "The arguments must respond to to_f; the #{name} did not")
          end
          assert_operator(delta, :>=, 0.0, "The delta should not be negative")
          full_message = build_message(message, "<?> and\n<?> expected to be within\n<?> of each other.\n", expected_float, actual_float, delta)
          assert_block(full_message) { (expected_float.to_f - actual_float.to_f).abs <= delta.to_f }
        end
      end

Passes if the method sent returns a true value.

[Source]

# File test/unit/assertions.rb, line 326
      def assert_send(send_array, message="")
        _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, "<?> expected to respond to\n<?(?)> with a true value.\n", send_array[0], AssertionMessage.literal(send_array[1].to_s), send_array[2..-1])
          assert_block(full_message) { send_array[0].__send__(send_array[1], *send_array[2..-1]) }
        end
      end

[Validate]