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 /}

Classes and Modules

Class Test::Unit::Assertions::AssertionMessage
::Class Test::Unit::Assertions::AssertionMessage::Literal
::Class Test::Unit::Assertions::AssertionMessage::Template

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.

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

Public Instance methods

assert(boolean, message=nil)

Passes if boolean is true.

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

assert_block(message="assert_block failed.") {|| ...}

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

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

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

assert_equal(expected, actual, message=nil)

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.

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

assert_in_delta(expected_float, actual_float, delta, message="")

Passes if expected_float and actual_float are equal within delta tolerance.

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

assert_instance_of(klass, object, message="")

Passes if object.class == klass.

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

assert_kind_of(klass, object, message="")

Passes if object.kind_of?(klass).

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

assert_match(pattern, string, message="")

Passes if string =~ pattern.

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

assert_nil(object, message="")

Passes if object.nil?.

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

assert_no_match(regexp, string, message="")

Passes if string !~ regularExpression.

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

assert_not_equal(expected, actual, message="")

Passes if expected != actual.

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

assert_not_nil(object, message="")

Passes if !object.nil?.

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

assert_not_same(expected, actual, message="")

Passes if !actual.equal?(expected).

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

assert_nothing_raised(*args) {|| ...}

Passes if block does not raise an exception.

# File test/unit/assertions.rb, line 205
      def assert_nothing_raised(*args)
        _wrap_assertion do
          if Module === args.last
            message = ""
          else
            message = args.pop
          end
          exceptions, modules = _check_exception_class(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}
            else
              raise
            end
          end
          nil
        end
      end

assert_nothing_thrown(message="", &proc)

Passes if block does not throw anything.

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

assert_operator(object1, operator, object2, message="")

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

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

assert_raise(*args) {|| ...}

Passes if block raises one of the given exceptions.

# File test/unit/assertions.rb, line 75
      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)
          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) {_expected_exception?(actual_exception, exceptions, modules)}
          actual_exception
        end
      end

assert_raises(*args, &block)

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

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

assert_respond_to(object, method, message="")

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

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

assert_same(expected, actual, message="")

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

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

assert_send(send_array, message="")

Passes if the method sent returns a true value.

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

assert_throws(expected_symbol, message="", &proc)

Passes if block throws symbol.

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

build_message(head, template=nil, *arguments)

# File test/unit/assertions.rb, line 350
      def build_message(head, template=nil, *arguments)
        template &&= template.chomp
        return AssertionMessage.new(head, template, arguments)
      end

flunk(message="Flunked")

Always fails.

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