baretest 0.2.4 → 0.4.0.pre1

data/test/suite/lib/baretest/assertion.rb

@@ -6,66 +6,104 @@
 
 
 
-BareTest.suite "BareTest" do
-  suite "Assertion" do
-    suite "::new" do
-      assert "Should return a ::BareTest::Assertion instance" do
-        ::BareTest::Assertion.new(nil, "description") { nil }.class ==
-        ::BareTest::Assertion
+BareTest.suite 'BareTest' do
+  suite 'Assertion' do
+    suite '::new' do
+      assert 'Returns a ::BareTest::Assertion instance' do
+        instance_of ::BareTest::Assertion, ::BareTest::Assertion.new(nil, 'description') { nil }
       end
+    end
 
-      assert "Should expect exactly 2 arguments" do
-        raises(ArgumentError) { ::BareTest::Assertion.new() } &&
-        raises(ArgumentError) { ::BareTest::Assertion.new(nil) } &&
-        raises(ArgumentError) { ::BareTest::Assertion.new(nil, "foo", "bar") }
+    suite '#execute' do
+      suite 'An assertion with a block that returns true' do
+        assert 'Returns a Status with status :success' do
+          assertion = ::BareTest::Assertion.new(nil, 'description') do true end
+          status    = assertion.execute
+          same(:success, status.status)
+        end
       end
-    end
 
-    suite "#status" do
-      assert "A new Assertion should have a status of nil" do
-        ::BareTest::Assertion.new(nil, "description") {}.status.nil?
+      suite 'An assertion with a block that returns false' do
+        setup do
+          @assertion = ::BareTest::Assertion.new(nil, 'description') do false end
+        end
+
+        assert 'Returns a Status with status :failure' do
+          status = @assertion.execute
+          same(:failure, status.status)
+        end
+
+        assert 'Returns a Status with failure reason "Assertion failed"' do
+          status = @assertion.execute
+          equal("Assertion failed", status.failure_reason)
+        end
       end
 
-      assert "Executing an assertion with a block that returns true should be :success" do
-        assertion_success = ::BareTest::Assertion.new(nil, "description") { true }
-        assertion_success.execute
-        assertion_success.status == :success
+      assert 'Executing an assertion with a block that raises a Failure should be :failure' do
+        assertion = ::BareTest::Assertion.new(nil, 'description') { raise ::BareTest::Assertion::Failure, 'just fail' }
+        status    = assertion.execute
+        same(:failure, status.status)
       end
 
-      assert "Executing an assertion with a block that returns false should be :failure" do
-        assertion_success = ::BareTest::Assertion.new(nil, "description") { false }
-        assertion_success.execute
-        assertion_success.status == :failure
+      assert 'Executing an assertion with a block that raises should be :error' do
+        assertion = ::BareTest::Assertion.new(nil, 'description') { raise }
+        status    = assertion.execute
+        same(:error, status.status)
       end
 
-      assert "Executing an assertion with a block that raises a Failure should be :failure" do
-        assertion_success = ::BareTest::Assertion.new(nil, "description") { raise ::BareTest::Assertion::Failure, "just fail" }
-        assertion_success.execute
-        assertion_success.status == :failure
+      assert 'Executing an assertion without a block should be :pending' do
+        assertion = ::BareTest::Assertion.new(nil, 'description')
+        status    = assertion.execute
+        same(:pending, status.status)
       end
 
-      assert "Executing an assertion with a block that raises should be :error" do
-        assertion_success = ::BareTest::Assertion.new(nil, "description") { raise }
-        assertion_success.execute
-        assertion_success.status == :error
+      assert 'Executing an assertion with a block that raises a Skip should be :manually_skipped' do
+        assertion = ::BareTest::Assertion.new(nil, 'description') { raise ::BareTest::Assertion::Skip, 'just skip' }
+        status    = assertion.execute
+        same(:manually_skipped, status.status)
       end
 
-      assert "Executing an assertion without a block should be :pending" do
-        assertion_success = ::BareTest::Assertion.new(nil, "description")
-        assertion_success.execute
+      suite "With a skipped assertion" do
+        suite "That is pending" do
+          assert "Has status :manually_skipped" do
+            assertion = ::BareTest::Assertion.new(nil, "", :skip => true)
+            status    = assertion.execute
 
-        same :expected => :pending, :actual => assertion_success.status
-      end
+            equal(:manually_skipped, status.status)
+          end
+        end
+
+        suite "Given a test that succeeds" do
+          assert "Should have status :skipped" do
+            assertion = ::BareTest::Assertion.new(nil, "", :skip => true) do true end
+            status    = assertion.execute
+
+            equal(:manually_skipped, status.status)
+          end
+        end
 
-      assert "Executing an assertion with a block that raises a Skip should be :skipped" do
-        assertion_success = ::BareTest::Assertion.new(nil, "description") { raise ::BareTest::Assertion::Skip, "just skip" }
-        assertion_success.execute
-        assertion_success.status == :skipped
+        suite "Given a test that fails" do
+          assert "Should have status :skipped" do
+            assertion = ::BareTest::Assertion.new(nil, "", :skip => true) do false end
+            status    = assertion.execute
+
+            equal(:manually_skipped, status.status)
+          end
+        end
+
+        suite "Given a test that errors" do
+          assert "Should have status :skipped" do
+            assertion = ::BareTest::Assertion.new(nil, "", :skip => true) do raise "something" end
+            status    = assertion.execute
+
+            equal(:manually_skipped, status.status)
+          end
+        end
       end
-    end
+    end # '#execute'
 
-    suite "meta information" do
-      assert "An assertion should have a valid line number and file" do
+    suite 'meta information' do
+      assert 'An assertion should have a valid line number and file' do
         suite = ::BareTest::Suite.new
         assertion = suite.assert do true end
 
@@ -73,98 +111,70 @@ BareTest.suite "BareTest" do
       end
     end
 
-    suite "#exception" do
+    suite '#exception' do
       assert "An assertion that doesn't raise should have nil as exception" do
-        assertion_success = ::BareTest::Assertion.new(nil, "description") { true }
-        assertion_success.execute
-        same :expected => nil, :actual => assertion_success.exception
+        assertion = ::BareTest::Assertion.new(nil, 'description') { true }
+        status    = assertion.execute
+        same(nil, status.exception)
       end
     end
 
-    suite "#description" do
-      assert "An assertion should have a description" do
-        description = "The assertion description"
+    suite '#description' do
+      assert 'An assertion should have a description' do
+        description = 'The assertion description'
         assertion   = ::BareTest::Assertion.new(nil, description) { true }
         same :expected => description, :actual => assertion.description
       end
     end
 
-    suite "#suite" do
-      assert "An assertion can belong to a suite" do
+    suite '#suite' do
+      assert 'An assertion can belong to a suite' do
         suite     = ::BareTest::Suite.new
-        assertion = ::BareTest::Assertion.new(suite, "") { true }
+        assertion = ::BareTest::Assertion.new(suite, '') { true }
         same :expected => suite, :actual => assertion.suite
       end
     end
 
-    suite "#block" do
-      assert "An assertion can have a block" do
+    suite '#block' do
+      assert 'An assertion can have a block' do
         block     = proc { true }
-        assertion = ::BareTest::Assertion.new(nil, "", &block)
+        assertion = ::BareTest::Assertion.new(nil, '', &block)
         same :expected => block, :actual => assertion.block
       end
     end
 
-    suite "#setup" do
-      assert "Should run all enclosing suite's setup blocks, outermost first" do
-        executed  = []
-        block1    = proc { executed << :block1 }
-        block2    = proc { executed << :block2 }
-        suite1    = ::BareTest::Suite.new("block1") do setup(&block1) end
-        suite2    = ::BareTest::Suite.new("suite2", suite1) do setup(&block2) end
-        assertion = ::BareTest::Assertion.new(suite2, "assertion")
-
-        raises_nothing do assertion.setup end &&
-        equal([:block1, :block2], executed)
-      end
-
-      assert "Should fail if setup raises an exception" do
-        block     = proc { raise "Some error" }
-        suite     = ::BareTest::Suite.new("block") do setup(&block) end
-        assertion = ::BareTest::Assertion.new(suite, "assertion") do true end
+    suite '#setup' do
+      assert 'Fails if setup raises an exception' do
+        setup     = proc { raise 'Some error' }
+        assertion = ::BareTest::Assertion.new(nil, 'assertion') do true end
+        status    = assertion.execute([setup])
 
-        assertion.execute
-
-        equal(:error, assertion.status, "assertion.status")
+        same(:error, status.status, 'status.status')
       end
     end
 
-    suite "#teardown" do
-      assert "Should run all enclosing suite's teardown blocks, innermost first" do
-        executed  = []
-        block1    = proc { executed << :block1 }
-        block2    = proc { executed << :block2 }
-        suite1    = ::BareTest::Suite.new("block1") do teardown(&block1) end
-        suite2    = ::BareTest::Suite.new("suite2", suite1) do teardown(&block2) end
-        assertion = ::BareTest::Assertion.new(suite2, "assertion")
-
-        raises_nothing do assertion.teardown end &&
-        equal([:block2, :block1], executed)
-      end
-
-      assert "Should fail if teardown raises an exception" do
-        block     = proc { raise "Some error" }
-        suite     = ::BareTest::Suite.new("block") do teardown(&block) end
-        assertion = ::BareTest::Assertion.new(suite, "assertion") do true end
-
-        assertion.execute
+    suite '#teardown' do
+      assert 'Fails if teardown raises an exception' do
+        teardown  = proc { raise 'Some error' }
+        assertion = ::BareTest::Assertion.new(nil, 'assertion') do true end
+        status    = assertion.execute(nil, [teardown])
 
-        assertion.status == :error
+        same(:error, status.status, 'status.status')
       end
     end
 
-    suite "#execute" do
-      assert "Execute will run the assertion's block" do
+    suite '#execute' do
+      assert "Runs the assertion's block" do
         this      = self # needed because touch is called in the block of another assertion, so otherwise it'd be local to that assertion
-        assertion = ::BareTest::Assertion.new(nil, "") { this.touch(:execute) }
+        assertion = ::BareTest::Assertion.new(nil, '') { this.touch(:execute) }
         assertion.execute
         touched(:execute)
       end
     end
 
-    suite "#to_s" do
-      assert "Assertion should have a to_s which contains the classname and the description" do
-        description  = "the description"
+    suite '#to_s' do
+      assert 'Assertion should have a to_s which contains the classname and the description' do
+        description  = 'the description'
         assertion    = ::BareTest::Assertion.new(nil, description)
         print_string = assertion.to_s
 
@@ -173,19 +183,30 @@ BareTest.suite "BareTest" do
       end
     end
 
-    suite "#inspect" do
-      assert "Assertion should have an inspect which contains the classname, the shifted object-id in zero-padded hex, the suite's inspect and the description's inspect" do
-        suite          = ::BareTest::Suite.new
-        description    = "the description"
-        assertion      = ::BareTest::Assertion.new(suite, description)
-        def suite.inspect; "<inspect of suite>"; end
+    suite '#inspect' do
+      setup do
+        @suite          = ::BareTest::Suite.new
+        def @suite.inspect; '<inspect of suite>'; end
 
-        inspect_string = assertion.inspect
+        @description    = 'the description'
+        @assertion      = ::BareTest::Assertion.new(@suite, @description)
+        @inspect_string = @assertion.inspect
+      end
+
+      assert 'Should contain the classname' do
+        @inspect_string.include?(@assertion.class.name)
+      end
+
+      assert 'Should contain the shifted object-id in zero-padded hex' do
+        @inspect_string.include?('%08x' % (@assertion.object_id >> 1))
+      end
+
+      assert "Should contain the suite's inspect" do
+        @inspect_string.include?(@suite.inspect)
+      end
 
-        inspect_string.include?(assertion.class.name) &&
-        inspect_string.include?("%08x" % (assertion.object_id >> 1)) &&
-        inspect_string.include?(suite.inspect) &&
-        inspect_string.include?(description.inspect)
+      assert "Should contain the  description's inspect" do
+        @inspect_string.include?(@description.inspect)
       end
     end
   end

data/test/suite/lib/baretest/assertion/context.rb

@@ -0,0 +1,40 @@
+#--
+# Copyright 2010 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+BareTest.suite "BareTest" do
+  suite "Assertion" do
+    suite "Context" do
+      suite "::new" do
+        suite "Expects 1 argument" do
+          assert "Raises ArgumentError with less than 1 argument" do
+            raises ArgumentError do BareTest::Assertion::Context.new end
+          end
+
+          assert "Returns a Context with 1 argument" do
+            kind_of BareTest::Assertion::Context, BareTest::Assertion::Context.new(Object.new)
+          end
+
+          assert "Raises ArgumentError with more than 1 argument" do
+            raises ArgumentError do BareTest::Assertion::Context.new(Object.new, Object.new) end
+          end
+        end
+      end # ::new
+
+      suite "#__assertion__" do
+        setup do
+          @assertion = Object.new
+          @context   = BareTest::Assertion::Context.new(@assertion)
+        end
+
+        assert "Returns the assertion the context was constructed with" do
+          same(@assertion, @context.__assertion__)
+        end
+      end
+    end # Context
+  end # Assertion
+end # BareTest

data/test/suite/lib/baretest/assertion/failure.rb

@@ -0,0 +1,19 @@
+#--
+# Copyright 2010 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+BareTest.suite "BareTest" do
+  suite "Assertion" do
+    suite "Failure" do
+      assert "Can be raised" do
+        raises BareTest::Assertion::Failure do
+          raise BareTest::Assertion::Failure, "raised"
+        end
+      end
+    end # Context
+  end # Assertion
+end # BareTest

data/test/suite/lib/baretest/assertion/skip.rb

@@ -0,0 +1,19 @@
+#--
+# Copyright 2010 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+BareTest.suite "BareTest" do
+  suite "Assertion" do
+    suite "Skip" do
+      assert "Can be raised" do
+        raises BareTest::Assertion::Skip do
+          raise BareTest::Assertion::Skip, "raised"
+        end
+      end
+    end # Context
+  end # Assertion
+end # BareTest

data/test/suite/lib/baretest/assertion/support.rb

@@ -6,50 +6,295 @@
 
 
 
-module BareTest
-  class Assertion
-    class Context
-      # used here to test for failure
-      def fails # :nodoc:
-        failed = false
-        begin
-          failed = !yield
-        rescue ::BareTest::Assertion::Failure
-          failed = true
-        end
-        unless failed then
-          failure "Expected the block to fail, but it returned a true value."
-        end
-
-        true
-      end
-    end
-  end
-end
+# FIXME: These tests are actually integration tests and not properly isolated
+#        (they depend on Assertion, Status and their own integration).
+#        Slated to be fixed in version 0.9
+
+
 
 BareTest.suite "BareTest" do
   suite "Assertion" do
     suite "Support" do
+      suite "#yields" do
+        suite "If the expected values are yielded" do
+          setup do
+            @assertion = BareTest::Assertion.new nil, "test" do yields([1,2,3], :each, [], [1],[2],[3]) end
+            @status    = @assertion.execute
+          end
+
+          assert "Succeeds" do
+            same(:success, @status.status)
+          end
+        end
+
+        suite "If different values than expected are yielded" do
+          setup do
+            @assertion = BareTest::Assertion.new nil, "test" do yields([1,2,3], :each, [], [2],[4],[8]) end
+            @status    = @assertion.execute
+          end
+
+          assert "Fails" do
+            same(:failure, @status.status)
+          end
+        end
+      end
+
+      suite "#throws" do
+        suite "If the expected symbol is thrown" do
+          setup do
+            @assertion = BareTest::Assertion.new nil, "test" do
+              throws :catchme do
+                throw :catchme
+              end
+            end
+            @status    = @assertion.execute
+          end
+
+          assert "Succeeds" do
+            same(:success, @status.status)
+          end
+        end
+
+        suite "If a different symbol than the expected is thrown" do
+          setup do
+            @assertion = BareTest::Assertion.new nil, "test" do
+              throws :catchme do
+                throw :something_else
+              end
+            end
+            @status    = @assertion.execute
+          end
+
+          assert "Fails" do
+            same(:failure, @status.status)
+          end
+
+          assert "The message states what symbol was expected to be thrown and what was thrown instead" do
+            equal("Expected the code to throw :catchme, but it threw :something_else instead", @status.failure_reason)
+          end
+        end
+
+        suite "If nothing is thrown" do
+          setup do
+            @assertion = BareTest::Assertion.new nil, "test" do
+              throws :catchme do
+                true # don't throw anything, just return
+              end
+            end
+            @status    = @assertion.execute
+          end
+
+          assert "Fails" do
+            same(:failure, @status.status)
+          end
+
+          assert "The message states what symbol was expected to be thrown and that nothing was thrown instead" do
+            equal("Expected the code to throw :catchme, but nothing was thrown", @status.failure_reason)
+          end
+        end
+      end
+
       suite "#raises" do
-        assert "Should not fail when used without argument and the block raises an exception derived from StandardError." do
-          raises do raise "foo" end
+        suite "Used without an argument and a block that raises an exception" do
+          setup do
+            @assertion = BareTest::Assertion.new nil, "test" do
+              raises do
+                raise "foo"
+              end
+            end
+            @status    = @assertion.execute
+          end
+
+          assert "Succeeds" do
+            same(:success, @status.status)
+          end
         end
 
-        assert "Should not fail when the block raises an exception derived from the provided exception-class." do
-          raises(ArgumentError) do raise ArgumentError, "foo" end
+        suite "Used with an exception class as argument and a block that raises an exception of that class" do
+          setup do
+            @assertion = BareTest::Assertion.new nil, "test" do
+              raises(ArgumentError) do
+                raise ArgumentError, "foo"
+              end
+            end
+            @status    = @assertion.execute
+          end
+
+          assert "Succeeds" do
+            same(:success, @status.status)
+          end
         end
 
-        assert "Should fail when used without argument and the block doesn't raise." do
-          begin
-            raises do "nothing raised -> should fail" end
-          rescue ::BareTest::Assertion::Failure
-            true
-          else
-            false
+        suite "Used with an exception class and a message string as arguments and a block that raises an exception of that class with that message" do
+          setup do
+            @assertion = BareTest::Assertion.new nil, "test" do
+              raises(ArgumentError, "foo") do
+                raise ArgumentError, "foo"
+              end
+            end
+            @status    = @assertion.execute
+          end
+
+          assert "Succeeds" do
+            same(:success, @status.status)
+          end
+        end
+
+        suite "Used with an exception class and a message regex as arguments and a block that raises an exception of that class with a matching message" do
+          setup do
+            @assertion = BareTest::Assertion.new nil, "test" do
+              raises(ArgumentError, /fo[aeiou]/) do
+                raise ArgumentError, "foo"
+              end
+            end
+            @status    = @assertion.execute
+          end
+
+          assert "Succeeds" do
+            same(:success, @status.status)
+          end
+        end
+
+        suite "Used with an exception class as argument and a block that raises an exception that is a subclass of that class" do
+          setup do
+            @expected = StandardError
+            @actual   = ArgumentError
+            expected  = @expected
+            actual    = @actual
+            @assertion = BareTest::Assertion.new nil, "test" do
+              raises(expected) do
+                raise actual, "foo"
+              end
+            end
+            @status    = @assertion.execute
+          end
+
+          guard "Actual exception class is a subclass of expected exception class" do
+            @actual < @expected
+          end
+
+          assert "Fails" do
+            same(:failure, @status.status)
+          end
+
+          assert "The message states what exception-class was expected to be raised and what was raised instead" do
+            equal("Expected the code to raise #{@expected.name}, but it raised #{@actual.name} instead", @status.failure_reason)
+          end
+        end
+
+        suite "Used with an exception class as argument and a block that raises an exception that is of a different class" do
+          setup do
+            @expected  = expected = NameError
+            @actual    = actual   = ArgumentError
+            @assertion = BareTest::Assertion.new nil, "test" do
+              raises(expected) do
+                raise actual, "foo"
+              end
+            end
+            @status    = @assertion.execute
+          end
+
+          guard "Actual exception class is a different class than expected exception class" do
+            (@actual <=> @expected).nil?
+          end
+
+          assert "Fails" do
+            same(:failure, @status.status)
+          end
+
+          assert "The message states what message was expected to be raised and what was raised instead" do
+            equal("Expected the code to raise #{@expected.name}, but it raised #{@actual.name} instead", @status.failure_reason)
+          end
+        end
+
+        suite "Used with an exception class and a message string as arguments and a block that raises an exception of that class but with a different message" do
+          setup do
+            @expected_message = expected_message = "foo"
+            @actual_message   = actual_message   = "bar"
+            @assertion = BareTest::Assertion.new nil, "test" do
+              raises(ArgumentError, expected_message) do
+                raise ArgumentError, actual_message
+              end
+            end
+            @status    = @assertion.execute
+          end
+
+          assert "Fails" do
+            same(:failure, @status.status)
+          end
+
+          assert "The message states what exception-class was expected to be raised and what was raised instead" do
+            equal(
+              "Expected the code to raise with the message #{@expected_message.inspect}, but the message was #{@actual_message.inspect}",
+              @status.failure_reason
+            )
+          end
+        end
+
+        suite "Used with an exception class and a message regex as arguments and a block that raises an exception of that class with a different message" do
+          setup do
+            @expected_message = expected_message = /fo[aeiou]/
+            @actual_message   = actual_message   = "bar"
+            @assertion = BareTest::Assertion.new nil, "test" do
+              raises(ArgumentError, expected_message) do
+                raise ArgumentError, actual_message
+              end
+            end
+            @status    = @assertion.execute
+          end
+
+          assert "Fails" do
+            same(:failure, @status.status)
+          end
+
+          assert "The message states what exception-class was expected to be raised and what was raised instead" do
+            equal(
+              "Expected the code to raise with the message #{@expected_message.inspect}, but the message was #{@actual_message.inspect}",
+              @status.failure_reason
+            )
+          end
+        end
+
+        suite "Used without argument and a block that doesn't raise" do
+          setup do
+            @assertion = BareTest::Assertion.new nil, "test" do
+              raises do
+                "nothing raised -> should fail"
+              end
+            end
+            @status    = @assertion.execute
+          end
+
+          assert "Fails" do
+            same(:failure, @status.status)
+          end
+
+          assert "The message states what exception-class was expected to be raised and what was raised instead" do
+            equal("Expected the code to raise, but nothing was raised", @status.failure_reason)
           end
         end
 
-        assert "Should fail when the block raises an exception not derived from the provided exception-class." do
+        suite "Used with an exception class as argument and a block that doesn't raise" do
+          setup do
+            @expected  = expected = ArgumentError
+            @assertion = BareTest::Assertion.new nil, "test" do
+              raises(ArgumentError) do
+                "nothing raised -> should fail"
+              end
+            end
+            @status    = @assertion.execute
+          end
+
+          assert "Fails" do
+            same(:failure, @status.status)
+          end
+
+          assert "The message states what exception-class was expected to be raised and that nothing was raised instead" do
+            equal("Expected the code to raise ArgumentError, but nothing was raised", @status.failure_reason)
+          end
+        end
+
+        assert "Should fail when the block raises an exception not derived from the provided exception-class" do
           begin
             raises(TypeError) do raise ArgumentError, "different class -> should fail" end
           rescue ::BareTest::Assertion::Failure
@@ -61,17 +306,37 @@ BareTest.suite "BareTest" do
       end # raises
 
       suite "#raises_nothing" do
-        assert "Should not fail when the block doesn't raise." do
-          raises_nothing do; end
+        suite "Used with a block that doesn't raise" do
+          setup do
+            @assertion = BareTest::Assertion.new nil, "test" do
+              raises_nothing do
+                "nothing raised -> should succeed"
+              end
+            end
+            @status    = @assertion.execute
+          end
+
+          assert "Succeeds" do
+            same(:success, @status.status)
+          end
         end
 
-        assert "Should fail when the block raises." do
-          begin
-            raises_nothing do raise "anything" end
-          rescue ::BareTest::Assertion::Failure
-            true
-          else
-            false
+        suite "Used with a block that raises" do
+          setup do
+            @assertion = BareTest::Assertion.new nil, "test" do
+              raises_nothing do
+                raise "Something"
+              end
+            end
+            @status    = @assertion.execute
+          end
+
+          assert "Fails" do
+            same(:failure, @status.status)
+          end
+
+          assert "The message states that it was not expected to raise anything but that something was raised" do
+            equal("Expected the code to raise nothing, but it raised RuntimeError (Something)", @status.failure_reason)
           end
         end
       end
@@ -79,13 +344,13 @@ BareTest.suite "BareTest" do
       suite "#touch/#touched" do
         suite "When you don't touch(x), touched(x) should fail" do
           assert "When you don't touch at all, touched(x) should fail" do
-            fails do
+            raises ::BareTest::Assertion::Failure do
               touched :foo1
             end
           end
 
           assert "When you don't touch something else, touched(x) should fail" do
-            fails do
+            raises ::BareTest::Assertion::Failure do
               touch :bar2
               touched :foo2
             end
@@ -109,68 +374,68 @@ BareTest.suite "BareTest" do
             touch(:foo5)
           end
 
-          assert "No touch x, touched x should raise." do
-            fails do touched(:foo5) end
+          assert "No touch x, touched x should raise" do
+            raises ::BareTest::Assertion::Failure do touched(:foo5) end
           end
         end
       end # #touch/#touched
 
       suite "#within_delta" do
-        assert "Should not fail when the value is within the delta." do
+        assert "Should not fail when the value is within the delta" do
           within_delta(3.0, 3.01, 0.02)
         end
 
-        assert "Should fail when the value is not within the delta." do
-          fails do
+        assert "Should fail when the value is not within the delta" do
+          raises ::BareTest::Assertion::Failure do
             within_delta(3.0, 3.03, 0.02)
           end
         end
 
-        assert "Should fail with invalid input." do
-          fails do
+        assert "Should fail with invalid input" do
+          raises ::BareTest::Assertion::Failure do
             within_delta(nil, nil, 0.02)
           end
         end
       end # within_delta
 
       suite "#equal_unordered" do
-        assert "Should not fail when the two arrays contain the same items the same number of times." do
+        assert "Should not fail when the two arrays contain the same items the same number of times" do
           equal_unordered([1,2,3], [3,1,2])
         end
 
-        assert "Should fail when the two arrays don't contain the same items." do
-          fails do
+        assert "Should fail when the two arrays don't contain the same items" do
+          raises ::BareTest::Assertion::Failure do
             equal_unordered([1,2,3], [5,6,1])
           end
         end
 
-        assert "Should fail when the two arrays contain the same items a different number of times." do
-          fails do
+        assert "Should fail when the two arrays contain the same items a different number of times" do
+          raises ::BareTest::Assertion::Failure do
             equal_unordered([1,2,3], [3,1,2,2])
           end
         end
 
-        assert "Should fail with invalid input." do
-          fails do
+        assert "Should fail with invalid input" do
+          raises ::BareTest::Assertion::Failure do
             equal_unordered(nil, nil)
           end
         end
       end # equal_unordered
 
       suite "#same" do
-        assert "Should not fail when the values are the same object." do
+        assert "Should not fail when the values are the same object" do
           a = "foo"
           same(a, a)
         end
 
-        assert "Should fail when the values are not the same object." do
-          fails do
+        assert "Should fail when the values are not the same object" do
+          raises ::BareTest::Assertion::Failure do
             same("a", "b")
           end
         end
 
-        assert "Should fail with invalid input." do
-          fails do
+        assert "Should fail with invalid input" do
+          raises ::BareTest::Assertion::Failure do
             x = Class.new do undef equal? end # really, who does that?
             y = x.new
             equal_unordered(y, y)
@@ -179,18 +444,18 @@ BareTest.suite "BareTest" do
       end # same
 
       suite "#order_equal" do
-        assert "Should not fail when the values are equal by ==." do
+        assert "Should not fail when the values are equal by ==" do
           order_equal(1, 1.0)
         end
 
-        assert "Should fail when the values are not equal by ==." do
-          fails do
+        assert "Should fail when the values are not equal by ==" do
+          raises ::BareTest::Assertion::Failure do
             order_equal(1, 1.1)
           end
         end
 
-        assert "Should fail with invalid input." do
-          fails do
+        assert "Should fail with invalid input" do
+          raises ::BareTest::Assertion::Failure do
             x = Class.new do undef == end
             y = x.new
             order_equal(y, y)
@@ -199,18 +464,18 @@ BareTest.suite "BareTest" do
       end # order_equal
 
       suite "#hash_key_equal" do
-        assert "Should not fail when the values are the same object." do
+        assert "Should not fail when the values are the same object" do
           hash_key_equal("foo", "foo")
         end
 
-        assert "Should fail when the values are not the same object." do
-          fails do
+        assert "Should fail when the values are not the same object" do
+          raises ::BareTest::Assertion::Failure do
             hash_key_equal("foo", "bar")
           end
         end
 
-        assert "Should fail with invalid input." do
-          fails do
+        assert "Should fail with invalid input" do
+          raises ::BareTest::Assertion::Failure do
             x = Class.new do undef eql? end
             y = x.new
             hash_key_equal(y, y)
@@ -219,18 +484,18 @@ BareTest.suite "BareTest" do
       end # hash_key_equal
 
       suite "#case_equal" do
-        assert "Should not fail when the values are the same object." do
+        assert "Should not fail when the values are the same object" do
           case_equal(String, "foo")
         end
 
-        assert "Should fail when the values are not the same object." do
-          fails do
+        assert "Should fail when the values are not the same object" do
+          raises ::BareTest::Assertion::Failure do
             case_equal(String, [])
           end
         end
 
-        assert "Should fail with invalid input." do
-          fails do
+        assert "Should fail with invalid input" do
+          raises ::BareTest::Assertion::Failure do
             x = Class.new do undef === end
             y = x.new
             case_equal(y, y)
@@ -248,12 +513,29 @@ BareTest.suite "BareTest" do
         end
 
         assert "Should fail when the value is not instance of the given class or subclass" do
-          fails do
+          raises ::BareTest::Assertion::Failure do
             kind_of(String, [])
           end
         end
       end
 
+      suite "#respond_to" do
+        assert "Should not fail when the object responds to all methods required" do
+          obj = Object.new
+          def obj.foo; end
+          def obj.bar; end
+          respond_to(obj, :foo, :bar)
+        end
+
+        assert "Should fail when the object doesn't respond to all methods required" do
+          raises ::BareTest::Assertion::Failure do
+            obj = Object.new
+            def obj.foo; end
+            respond_to(obj, :foo, :bar)
+          end
+        end
+      end
+
       suite "#failure_with_optional_message" do
         assert "Should raise a BareTest::Assertion::Failure" do
           raises(::BareTest::Assertion::Failure) do
@@ -262,30 +544,30 @@ BareTest.suite "BareTest" do
         end
 
         assert "Should use the string with message if message is given" do
-          raises(::BareTest::Assertion::Failure, :with_message => "With message") do
+          raises(::BareTest::Assertion::Failure, "With message") do
             failure_with_optional_message "With %s", "Without message", "message"
           end
         end
 
         assert "Should use the string without message if no message is given" do
-          raises(::BareTest::Assertion::Failure, :with_message => "Without message") do
+          raises(::BareTest::Assertion::Failure, "Without message") do
             failure_with_optional_message "With %s", "Without message", nil
           end
         end
       end
 
       suite "#failure" do
-        assert "Should raise a BareTest::Assertion::Failure." do
+        assert "Should raise a BareTest::Assertion::Failure" do
           raises(::BareTest::Assertion::Failure) do
-            failure "Should raise that exception."
+            failure "Should raise that exception"
           end
         end
       end
 
       suite "#skip" do
-        assert "Should raise a BareTest::Assertion::Skip." do
+        assert "Should raise a BareTest::Assertion::Skip" do
           raises(::BareTest::Assertion::Skip) do
-            skip "Should raise that exception."
+            skip "Should raise that exception"
           end
         end
       end