rubyunit 0.2.14 → 0.3.15

data/lib/RubyUnit/Assertions/Comparison.rb

@@ -0,0 +1,200 @@
+module RubyUnit
+  module Assertions
+    include AssertionMessage
+
+    #
+    # Assert that two values are equal.
+    # * raises RubyUnit::AssertionFailure unless _expected_ equals _actual_
+    #
+    # expected::
+    #   The value that is forbidden by the assertion
+    #
+    # actual::
+    #   The value that is being checked by the assertion
+    #
+    # message::
+    #   The message provided to be reported for a failure
+    #
+    #  assertEqual 42, 24, "This will fail"  # => fail
+    #
+    def assertEqual expected, actual, message = nil
+      __assert (expected == actual), ASSERT_EQUAL_ERROR, message, {:expected=>expected, :actual=>actual}
+    end
+
+    #
+    # Assert that two values are NOT equal.
+    # * raises RubyUnit::AssertionFailure if _illegal_ equals _actual_
+    #
+    # illegal::
+    #   The value that is not allowed by the assertion
+    #
+    # actual::
+    #   The value that is being checked by the assertion
+    #
+    # message::
+    #   The message provided to be reported for a failure
+    #
+    #  assertNotEqual 3.14, 3.14, "This will fail"  # => fail
+    #
+    def assertNotEqual illegal, actual, message = nil
+      __reject (illegal == actual), ASSERT_NOT_EQUAL_ERROR, message, {:illegal=>illegal, :actual=>actual} 
+    end
+
+    #
+    # Assert that one value is greater than another.
+    # * raises RubyUnit::AssertionFailure unless _greater_ is greater than _value_
+    #
+    # greater::
+    #   The value that should be greater
+    #
+    # value::
+    #   The value that is being checked by the assertion
+    #
+    # message::
+    #   The message provided to be reported for a failure
+    #
+    #  assertGreaterThan 24, 42, "This will fail"  # => fail
+    #
+    def assertGreaterThan greater, value, message = nil
+      __assert (greater > value), ASSERT_GREATERTHAN_ERROR, message, {:greater=>greater, :value=>value}
+    end
+
+    #
+    # Assert that one value is greater than another.
+    # * raises RubyUnit::AssertionFailure unless _greater_ is greater than or equal to _value_
+    #
+    # greater::
+    #   The value that should be greater than or equal
+    #
+    # value::
+    #   The value that is being checked by the assertion
+    #
+    # message::
+    #   The message provided to be reported for a failure
+    #
+    #  assertGreaterThanOrEqual 24, 42, "This will fail"  # => fail
+    #
+    def assertGreaterThanOrEqual greater, value, message = nil
+      __assert (greater >= value), ASSERT_GREATERTHANOREQUAL_ERROR, message, {:greater=>greater, :value=>value}
+    end
+
+    #
+    # Assert that one value is less than another.
+    # * raises RubyUnit::AssertionFailure unless _less_ is less than _value_
+    #
+    # less::
+    #   The value that should be less
+    #
+    # value::
+    #   The value that is being checked by the assertion
+    #
+    # message::
+    #   The message provided to be reported for a failure
+    #
+    #  assertLessThan 42, 24, "This will fail"  # => fail
+    #
+    def assertLessThan less, value, message = nil
+      __assert (less < value), ASSERT_LESSTHAN_ERROR, message, {:less=>less, :value=>value}
+    end
+
+    #
+    # Assert that one value is less than another.
+    # * raises RubyUnit::AssertionFailure unless _less_ is less than or equal to _value_
+    #
+    # less::
+    #   The value that should be less than or equal
+    #
+    # value::
+    #   The value that is being checked by the assertion
+    #
+    # message::
+    #   The message provided to be reported for a failure
+    #
+    #  assertLessThanOrEqual 42, 24, "This will fail"  # => fail
+    #
+    def assertLessThanOrEqual less, value, message = nil
+      __assert (less <= value), ASSERT_LESSTHANOREQUAL_ERROR, message, {:less=>less, :value=>value}
+    end
+
+    #
+    # Assert that a value matches a Regexp pattern.
+    # * raises RubyUnit::AssertionFailure unless _value_ matches _pattern_
+    #
+    # pattern::
+    #   A Regexp pattern expected by the assertion
+    #
+    # value::
+    #   The value that is being checked for the assertion
+    #
+    # message::
+    #   The message provided to be reported for a failure
+    #
+    #  assertMatch /^Hello/, 'Goodbye!', "This will fail"  # => fail
+    #
+    def assertMatch pattern, value, message = nil
+      pattern = [pattern] unless pattern.is_a? Array
+      pattern.each do |regex|
+        __assert (value =~ regex), ASSERT_MATCH_ERROR, message, {:pattern=>pattern, :value=>value}
+      end
+    end
+
+    #
+    # Assert that a value does not match a Regexp pattern.
+    # * raises RubyUnit::AssertionFailure if _value_ matches _pattern_
+    #
+    # pattern::
+    #   A Regexp pattern excluded by the assertion
+    #
+    # value::
+    #   The value that is being checked for the assertion
+    #
+    # message::
+    #   The message provided to be reported for a failure
+    #
+    #  assertMatch /^Good/, 'Goodbye!', "This will fail"  # => fail
+    #
+    def assertNotMatch exclusion, value, message = nil
+      __reject (value =~ exclusion), ASSERT_NO_MATCH_ERROR, message, {:exclusion=>exclusion, :value=>value}
+    end
+
+    #
+    # Assert that two objects are the same object
+    # * raises RubyUnit::AssertionFailure unless _expected_ and _actual_ are
+    #   the same object.
+    #
+    # expected::
+    #   The expected object
+    #
+    # actual::
+    #   The object that is being checked against _expected_
+    #
+    # message::
+    #   The message provided to be reported for a failure
+    #
+    #  assertSame '42', 42, 'Not even close.'  # => fail
+    #
+    def assertSame expected, actual, message = nil
+      __assert (expected.equal? actual), ASSERT_SAME_ERROR, message, {:expected=>expected, :actual=>actual}
+    end
+
+    #
+    # Assert that two objects are not the same object
+    # * raises RubyUnit::AssertionFailure if _illegal_ and _actual_ are the
+    #   same object.
+    #
+    # illegal::
+    #   The expected that it shouldn't be
+    #
+    # actual::
+    #   The object that is being checked against _illegal_
+    #
+    # message::
+    #   The message provided to be reported for a failure
+    #
+    #  assertNotSame value, value, 'Imagine that!'  # => fail
+    #
+    def assertNotSame illegal, actual, message = nil
+      __reject (illegal.equal? actual), ASSERT_NOT_SAME_ERROR, message, {:illegal=>illegal, :actual=>actual}
+    end
+  end
+end

data/lib/RubyUnit/Assertions/Exception.rb

@@ -0,0 +1,105 @@
+module RubyUnit
+  module Assertions
+    include AssertionMessage
+    
+    #
+    # Assert that no exception is raised.
+    # * raises RubyUnit::AssertionFailure if any exception is raised
+    #
+    # message::
+    #   The message provided to be reported for a failure
+    #
+    # &block::
+    #   The code block that is executed
+    #
+    #  assertNothingRaised 'Not expecting an exception!' do
+    #    # do something
+    #  end
+    #
+    def assertNothingRaised message = nil, &block
+      __wrap_assertion do
+        begin
+          yield
+        rescue Exception => e
+          build_message ASSERT_NOTHING_RAISED_ERROR, message, {:exception=>e.message}
+        end
+      end
+    end
+
+    #
+    # Assert that a specified exception message is raised.
+    # * raises RubyUnit::AssertionFailure unless the correct Exception message is raised
+    #
+    # pattern::
+    #   The String or Regexp that will be used to validate the Exception message
+    #
+    # message::
+    #   The message provided to be reported for a failure
+    #
+    # &block::
+    #   The code block that is expected to throw the Exception
+    #
+    #  assertRaiseMessage /^Invalid/, 'Expecting an exception!' do
+    #    # do something
+    #  end
+    #
+    def assertRaiseMessage pattern, message = nil, &block
+      assertRaiseExpected Exception, pattern, message, &block
+    end
+
+    #
+    # Assert that a specified exception type is raised.
+    # * raises RubyUnit::AssertionFailure unless the correct Exception type is raised
+    #
+    # e::
+    #   The Exception class that is expected.
+    #
+    # message::
+    #   The message provided to be reported for a failure
+    #
+    # &block::
+    #   The code block that is expected to throw the Exception
+    #
+    #  assertRaiseKindOf StandardError, 'Expecting an exception!' do # => fail
+    #    # do something
+    #  end
+    #
+    def assertRaiseKindOf e, message = nil, &block
+      assertRaiseExpected e, '', message, &block
+    end
+
+    #
+    # Assert that a specified exception is raised.
+    # * raises RubyUnit::AssertionFailure unless the correct Exception is raised
+    #
+    # exception::
+    #   The Exception class that is expected.
+    #
+    # pattern::
+    #   The String or Regexp that will be used to validate the Exception message
+    #
+    # message::
+    #   The message provided to be reported for a failure
+    #
+    # &block::
+    #   The code block that is expected to throw the Exception
+    #
+    #  assertRaiseExpected StandardError, /^Invalid/, 'Expecting an exception!' do
+    #    raise StandardError, 'Invalid Retroincabulator'
+    #  end
+    #
+    def assertRaiseExpected exception, pattern, message = nil &block
+      __validate_exception pattern, exception
+      __wrap_assertion do
+        begin
+          yield
+          build_message ASSERT_RAISE_EXPECTED_ERROR, message, {:exception=>exception, :pattern=>pattern}
+        rescue exception => e
+          assertEqual pattern, e.message if pattern.is_a? String and pattern.length > 0
+          assertMatch pattern, e.message if pattern.is_a? Regexp
+          e
+        end
+      end
+    end
+  end
+end

data/lib/RubyUnit/Assertions/Method.rb

@@ -0,0 +1,157 @@
+module RubyUnit
+  module Assertions
+    include AssertionMessage
+
+    #
+    # Assert that an object responds to particular method
+    # * raises RubyUnit::AssertionFailure unless _object_ responds to _method_
+    #
+    # object::
+    #   The object to check
+    #
+    # method::
+    #   The method to assert on the object
+    #
+    # message::
+    #   The message provided to be reported for a failure
+    #
+    #  assertRespondTo /^Regexp/, :length, 'It does not, so... no'  # => fail
+    #
+    def assertRespondTo object, method, message = nil
+      __assert (object.respond_to? method), ASSERT_RESPOND_TO_ERROR, message, {:object=>object, :method=>method}
+    end
+
+    #
+    # Assert that an object does not respond to a particular method
+    # * raises RubyUnit::AssertionFailure if _object_ responds to _method_
+    #
+    # object::
+    #   The object to check
+    #
+    # method::
+    #   The method to assert on the object
+    #
+    # message::
+    #   The message provided to be reported for a failure
+    #
+    #  assertNotRespondTo 25, :integer?, 'It does, so close'  # => fail
+    #
+    def assertNotRespondTo object, method, message = nil
+      __assert (object.respond_to? method), ASSERT_NOT_RESPOND_TO_ERROR, message, {:object=>object, :method=>method}
+    end
+
+    #
+    # Assert that an object has defined the specified method.
+    # * raises RubyUnit::AssertionFailure unless _klass_ has defined _method_
+    #
+    # klass::
+    #   The object to check for _method_
+    #
+    # method::
+    #   The method to check
+    #
+    # message::
+    #   The message provided to be reported for a failure
+    #
+    #  assertMethod String, :integer?, 'Nope' # => fail
+    #
+    def assertMethod klass, method, message = nil
+      assertInclude klass.methods, method, message
+    end
+
+    #
+    # Assert that an object has not defined the specified method.
+    # * raises RubyUnit::AssertionFailure if _klass_ has defined _method_
+    #
+    # klass::
+    #   The object to check for _method_
+    #
+    # method::
+    #   The method to check
+    #
+    # message::
+    #   The message provided to be reported for a failure
+    #
+    #  assertNotMethod Integer, :integer?, 'Nope' # => fail
+    #
+    def assertNotMethod klass, not_method, message = nil
+      assertNotInclude klass.methods, not_method, message
+    end
+
+    #
+    # Assert that an object has defined the specified instance method.
+    # * raises RubyUnit::AssertionFailure unless _klass_ has defined _instance_method_
+    #
+    # klass::
+    #   The object to check for _instance_method_
+    #
+    # method::
+    #   The method to check
+    #
+    # message::
+    #   The message provided to be reported for a failure
+    #
+    #  assertInstanceMethod String, :integer?, 'Nope' # => fail
+    #
+    def assertInstanceMethod klass, instance_method, message = nil
+      assertInclude klass.instance_methods, instance_method, message
+    end
+
+    #
+    # Assert that an object has not defined the specified instance method.
+    # * raises RubyUnit::AssertionFailure unless _klass_ has defined _not_instance_method_
+    #
+    # klass::
+    #   The object to check for _not_instance_method_
+    #
+    # method::
+    #   The method to check
+    #
+    # message::
+    #   The message provided to be reported for a failure
+    #
+    #  assertNotInstanceMethod Integer, :integer?, 'Nope' # => fail
+    #
+    def assertNotInstanceMethod klass, not_instance_method, message = nil
+      assertNotInclude klass.instance_methods, not_instance_method, message
+    end
+
+    #
+    # Assert that an Class has defined the specified class method.
+    # * raises RubyUnit::AssertionFailure unless _klass_ has defined _class_method_
+    #
+    # klass::
+    #   The object to check for _class_method_
+    #
+    # method::
+    #   The method to check
+    #
+    # message::
+    #   The message provided to be reported for a failure
+    #
+    #  assertClassMethod String, :integer?, 'Nope' # => fail
+    #
+    def assertClassMethod klass, class_method, message = nil
+      assertInclude klass.singleton_methods, class_method, message
+    end
+
+    #
+    # Assert that an Class has not defined the specified class method.
+    # * raises RubyUnit::AssertionFailure unless _klass_ has defined _not_class_method_
+    #
+    # klass::
+    #   The object to check for _not_class_method_
+    #
+    # method::
+    #   The method to check
+    #
+    # message::
+    #   The message provided to be reported for a failure
+    #
+    #  assertNotClassMethod String, :new, 'Nope' # => fail
+    #
+    def assertNotClassMethod klass, not_class_method, message = nil
+      assertNotInclude klass.singleton_methods, not_class_method, message
+    end
+  end
+end