assert 2.17.0 → 2.18.4

data/lib/assert/runner.rb

@@ -3,7 +3,6 @@ require "assert/suite"
 require "assert/view"
 
 module Assert
-
   class Runner
     include Assert::ConfigHelpers
 
@@ -103,7 +102,5 @@ module Assert
         self.suite.sorted_tests_to_run{ rand self.tests_to_run_count }
       end
     end
-
   end
-
 end

data/lib/assert/stub.rb

@@ -1,7 +1,6 @@
 require "much-stub"
 
 module Assert
-
   def self.stubs
     MuchStub.stubs
   end
@@ -10,6 +9,10 @@ module Assert
     MuchStub.stub(*args, &block)
   end
 
+  def self.stub_on_call(*args, &block)
+    MuchStub.stub_on_call(*args, &block)
+  end
+
   def self.unstub(*args)
     MuchStub.unstub(*args)
   end
@@ -28,4 +31,15 @@ module Assert
     end
   end
 
+  def self.stub_tap(*args, &block)
+    MuchStub.tap(*args, &block)
+  end
+
+  def self.stub_tap_on_call(*args, &block)
+    MuchStub.tap_on_call(*args, &block)
+  end
+
+  def self.stub_spy(*args, &block)
+    MuchStub.spy(*args, &block)
+  end
 end

data/lib/assert/suite.rb

@@ -2,13 +2,11 @@ require "assert/config_helpers"
 require "assert/test"
 
 module Assert
-
   # This is the base suite. It loads the tests to run in memory and provides
   # methods for these tests that the runner/view uses for handling and
   # presentation purposes. It also stores suite-level setups and teardowns.
   # Override the test/result count methods and the callbacks as needed.  See
   # the default suite for example usage.
-
   class Suite
     include Assert::ConfigHelpers
 
@@ -101,7 +99,5 @@ module Assert
       " test_count=#{self.test_count.inspect}"\
       " result_count=#{self.result_count.inspect}>"
     end
-
   end
-
 end

data/lib/assert/test.rb

@@ -3,12 +3,9 @@ require "assert/file_line"
 require "assert/result"
 
 module Assert
-
   class Test
-
-    # a Test is some code/method to run in the scope of a Context that may
-    # produce results
-
+    # Test is some code/method to run in the scope of a Context that may
+    # produce results.
     def self.name_file_line_context_data(ci, name)
       { :name      => ci.test_name(name),
         :file_line => ci.called_from
@@ -147,7 +144,5 @@ module Assert
     def capture_io
       StringIO.new(self.output, "a+")
     end
-
   end
-
 end

data/lib/assert/utils.rb

@@ -1,9 +1,7 @@
 require "assert"
 
 module Assert
-
   module Utils
-
     # show objects in a human-readable manner.  Either inspects or pretty-prints
     # them depending on settings.
     def self.show(obj, config)
@@ -73,10 +71,8 @@ module Assert
         files
       end
     end
-
   end
 
   # alias for brevity
   U = Utils
-
 end

data/lib/assert/version.rb

@@ -1,3 +1,3 @@
 module Assert
-  VERSION = "2.17.0"
+  VERSION = "2.18.4"
 end

data/lib/assert/view.rb

@@ -4,7 +4,6 @@ require "assert/suite"
 require "assert/view_helpers"
 
 module Assert
-
   class View
     include Assert::ConfigHelpers
     include Assert::ViewHelpers
@@ -92,7 +91,5 @@ module Assert
 
     def puts(*args); @output_io.puts(*args); end
     def print(*args); @output_io.print(*args); end
-
   end
-
 end

data/lib/assert/view_helpers.rb

@@ -1,9 +1,7 @@
 require "assert/config_helpers"
 
 module Assert
-
   module ViewHelpers
-
     def self.included(receiver)
       receiver.class_eval do
         include Assert::ConfigHelpers
@@ -13,7 +11,6 @@ module Assert
     end
 
     module ClassMethods
-
       def option(name, *default_vals)
         default = default_vals.size > 1 ? default_vals : default_vals.first
         define_method(name) do |*args|
@@ -23,11 +20,9 @@ module Assert
           (val = instance_variable_get("@#{name}")).nil? ? default : val
         end
       end
-
     end
 
     module InstanceMethods
-
       # show any captured output
       def captured_output(output)
         "--- stdout ---\n"\
@@ -86,13 +81,10 @@ module Assert
         end
         self.to_sentence(summaries)
       end
-
     end
 
     module Ansi
-
       # Table of supported styles/codes (http://en.wikipedia.org/wiki/ANSI_escape_code)
-
       CODES = {
         :clear            => 0,
         :reset            => 0,
@@ -182,9 +174,6 @@ module Assert
         return msg if code.empty?
         code + msg + Assert::ViewHelpers::Ansi.code_for(:reset)
       end
-
     end
-
   end
-
 end

data/test/helper.rb

@@ -9,42 +9,36 @@ $LOAD_PATH.unshift(ROOT_PATH)
 require "pry"
 require "test/support/factory"
 
-class Assert::Test
-
-  module TestHelpers
-
-    def self.included(receiver)
-      receiver.class_eval do
-        setup do
-          @test_run_results = []
-          @run_callback = proc{ |result| @test_run_results << result }
-        end
+module Assert::Test::TestHelpers
+  def self.included(receiver)
+    receiver.class_eval do
+      setup do
+        @test_run_results = []
+        @run_callback = proc { |result| @test_run_results << result }
       end
+    end
 
-      private
+    private
 
-      def test_run_callback
-        @run_callback
-      end
-
-      def test_run_results(type = nil)
-        return @test_run_results if type.nil?
-        @test_run_results.select{ |r| r.type == type }
-      end
+    def test_run_callback
+      @run_callback
+    end
 
-      def test_run_result_count(type = nil)
-        test_run_results(type).count
-      end
+    def test_run_results(type = nil)
+      return @test_run_results if type.nil?
+      @test_run_results.select{ |r| r.type == type }
+    end
 
-      def test_run_result_messages
-        @test_run_results.map(&:message)
-      end
+    def test_run_result_count(type = nil)
+      test_run_results(type).count
+    end
 
-      def last_test_run_result
-        @test_run_results.last
-      end
+    def test_run_result_messages
+      @test_run_results.map(&:message)
     end
 
+    def last_test_run_result
+      @test_run_results.last
+    end
   end
-
 end

data/test/support/factory.rb

@@ -86,4 +86,18 @@ module Factory
     end
   end
 
+  def self.modes_off_context(&result_block)
+    test = Factory.test
+    Factory.modes_off_context_class.new(
+      test,
+      test.config,
+      result_block || proc { |r| }
+    )
+  end
+
+  def self.backtrace
+    assert_lib_path =
+      File.join(ROOT_PATH, "lib/#{Factory.string}:#{Factory.integer}")
+    (Factory.integer(3).times.map{ Factory.string } + [assert_lib_path]).shuffle
+  end
 end

data/test/support/inherited_stuff.rb

@@ -24,7 +24,6 @@ class SuperStuff
   def test_repeated
     "repeated test from super"
   end
-
 end
 
 class SubStuff < SuperStuff
@@ -45,5 +44,4 @@ class SubStuff < SuperStuff
   def test_repeated
     "repeated test from sub"
   end
-
 end

data/test/system/stub_tests.rb

@@ -2,699 +2,685 @@ require "assert"
 require "assert/stub"
 
 class Assert::Stub
-
   class SystemTests < Assert::Context
     desc "Assert::Stub"
-
   end
 
   class InstanceTests < SystemTests
     desc "for instance methods"
+    subject { TestClass.new }
+
     setup do
-      @instance = TestClass.new
-      Assert.stub(@instance, :noargs){ "default" }
-      Assert.stub(@instance, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(@instance, :withargs){ "default" }
-      Assert.stub(@instance, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(@instance, :anyargs){ "default" }
-      Assert.stub(@instance, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      Assert.stub(@instance, :minargs){ "default" }
-      Assert.stub(@instance, :minargs).with(1, 2){ "one-two" }
-      Assert.stub(@instance, :minargs).with(1, 2, 3){ "one-two-three" }
+      Assert.stub(subject, :minargs){ "default" }
+      Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(@instance, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
-    subject{ @instance }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal "none", subject.noargs
+      assert_that(subject.noargs).equals("none")
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal "one",     subject.withargs(1)
-      assert_equal "default", subject.withargs(2)
+      assert_that(subject.withargs(2)).equals("default")
     end
 
     should "allow stubbing a method that takes any args" do
-      assert_equal "default", subject.anyargs
-      assert_equal "default", subject.anyargs(1)
-      assert_equal "one-two", subject.anyargs(1, 2)
+      assert_that(subject.anyargs).equals("default")
+      assert_that(subject.anyargs(1)).equals("default")
+      assert_that(subject.anyargs(1, 2)).equals("one-two")
     end
 
     should "allow stubbing a method that takes a minimum number of args" do
-      assert_equal "one-two",       subject.minargs(1, 2)
-      assert_equal "one-two-three", subject.minargs(1, 2, 3)
-      assert_equal "default",       subject.minargs(1, 2, 4)
-      assert_equal "default",       subject.minargs(1, 2, 3, 4)
+      assert_that(subject.minargs(1, 2)).equals("one-two")
+      assert_that(subject.minargs(1, 2, 3)).equals("one-two-three")
+      assert_that(subject.minargs(1, 2, 4)).equals("default")
+      assert_that(subject.minargs(1, 2, 3, 4)).equals("default")
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal "default", subject.withblock
-      assert_equal "default", subject.withblock{ "my-block" }
+      assert_that(subject.withblock).equals("default")
+      assert_that(subject.withblock{ "my-block" }).equals("default")
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_raises{ Assert.stub(subject, :noargs).with(1){ } }
+      assert_that(-> { Assert.stub(subject, :noargs).with(1){ } }).raises
 
-      assert_raises{ Assert.stub(subject, :withargs).with{ } }
-      assert_raises{ Assert.stub(subject, :withargs).with(1, 2){ } }
+      assert_that(-> { Assert.stub(subject, :withargs).with{ } }).raises
+      assert_that(-> { Assert.stub(subject, :withargs).with(1, 2){ } }).raises
 
-      assert_raises{ Assert.stub(subject, :minargs).with{ } }
-      assert_raises{ Assert.stub(subject, :minargs).with(1){ } }
+      assert_that(-> { Assert.stub(subject, :minargs).with{ } }).raises
+      assert_that(-> { Assert.stub(subject, :minargs).with(1){ } }).raises
 
-      assert_raises{ Assert.stub(subject, :withblock).with(1){ } }
+      assert_that(-> { Assert.stub(subject, :withblock).with(1){ } }).raises
     end
 
     should "not allow calling methods with invalid arity" do
-      assert_raises{ subject.noargs(1) }
+      assert_that(-> { subject.noargs(1) }).raises
 
-      assert_raises{ subject.withargs }
-      assert_raises{ subject.withargs(1, 2) }
+      assert_that(-> { subject.withargs }).raises
+      assert_that(-> { subject.withargs(1, 2) }).raises
 
-      assert_raises{ subject.minargs }
-      assert_raises{ subject.minargs(1) }
+      assert_that(-> { subject.minargs }).raises
+      assert_that(-> { subject.minargs(1) }).raises
 
-      assert_raises{ subject.withblock(1) }
+      assert_that(-> { subject.withblock(1) }).raises
     end
-
   end
 
   class ClassTests < SystemTests
     desc "for singleton methods on a class"
+    subject { TestClass }
+
     setup do
-      @class = TestClass
-      Assert.stub(@class, :noargs){ "default" }
-      Assert.stub(@class, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(@class, :withargs){ "default" }
-      Assert.stub(@class, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(@class, :anyargs){ "default" }
-      Assert.stub(@class, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      Assert.stub(@class, :minargs){ "default" }
-      Assert.stub(@class, :minargs).with(1, 2){ "one-two" }
-      Assert.stub(@class, :minargs).with(1, 2, 3){ "one-two-three" }
+      Assert.stub(subject, :minargs){ "default" }
+      Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(@class, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
-    subject{ @class }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal "none", subject.noargs
+      assert_that(subject.noargs).equals("none")
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal "one",     subject.withargs(1)
-      assert_equal "default", subject.withargs(2)
+      assert_that(subject.withargs(1)).equals("one")
+      assert_that(subject.withargs(2)).equals("default")
     end
 
     should "allow stubbing a method that takes any args" do
-      assert_equal "default", subject.anyargs
-      assert_equal "default", subject.anyargs(1)
-      assert_equal "one-two", subject.anyargs(1, 2)
+      assert_that(subject.anyargs).equals("default")
+      assert_that(subject.anyargs(1)).equals("default")
+      assert_that(subject.anyargs(1, 2)).equals("one-two")
     end
 
     should "allow stubbing a method that takes a minimum number of args" do
-      assert_equal "one-two",       subject.minargs(1, 2)
-      assert_equal "one-two-three", subject.minargs(1, 2, 3)
-      assert_equal "default",       subject.minargs(1, 2, 4)
-      assert_equal "default",       subject.minargs(1, 2, 3, 4)
+      assert_that(subject.minargs(1, 2)).equals("one-two")
+      assert_that(subject.minargs(1, 2, 3)).equals("one-two-three")
+      assert_that(subject.minargs(1, 2, 4)).equals("default")
+      assert_that(subject.minargs(1, 2, 3, 4)).equals("default")
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal "default", subject.withblock
-      assert_equal "default", subject.withblock{ "my-block" }
+      assert_that(subject.withblock).equals("default")
+      assert_that(subject.withblock{ "my-block" }).equals("default")
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_raises{ Assert.stub(subject, :noargs).with(1){ } }
+      assert_that(-> { Assert.stub(subject, :noargs).with(1){ } }).raises
 
-      assert_raises{ Assert.stub(subject, :withargs).with{ } }
-      assert_raises{ Assert.stub(subject, :withargs).with(1, 2){ } }
+      assert_that(-> { Assert.stub(subject, :withargs).with{ } }).raises
+      assert_that(-> { Assert.stub(subject, :withargs).with(1, 2){ } }).raises
 
-      assert_raises{ Assert.stub(subject, :minargs).with{ } }
-      assert_raises{ Assert.stub(subject, :minargs).with(1){ } }
+      assert_that(-> { Assert.stub(subject, :minargs).with{ } }).raises
+      assert_that(-> { Assert.stub(subject, :minargs).with(1){ } }).raises
 
-      assert_raises{ Assert.stub(subject, :withblock).with(1){ } }
+      assert_that(-> { Assert.stub(subject, :withblock).with(1){ } }).raises
     end
 
     should "not allow calling methods with invalid arity" do
-      assert_raises{ subject.noargs(1) }
+      assert_that(-> { subject.noargs(1) }).raises
 
-      assert_raises{ subject.withargs }
-      assert_raises{ subject.withargs(1, 2) }
+      assert_that(-> { subject.withargs }).raises
+      assert_that(-> { subject.withargs(1, 2) }).raises
 
-      assert_raises{ subject.minargs }
-      assert_raises{ subject.minargs(1) }
+      assert_that(-> { subject.minargs }).raises
+      assert_that(-> { subject.minargs(1) }).raises
 
-      assert_raises{ subject.withblock(1) }
+      assert_that(-> { subject.withblock(1) }).raises
     end
-
   end
 
   class ModuleTests < SystemTests
     desc "for singleton methods on a module"
+    subject { TestModule }
+
     setup do
-      @module = TestModule
-      Assert.stub(@module, :noargs){ "default" }
-      Assert.stub(@module, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(@module, :withargs){ "default" }
-      Assert.stub(@module, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(@module, :anyargs){ "default" }
-      Assert.stub(@module, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      Assert.stub(@module, :minargs){ "default" }
-      Assert.stub(@module, :minargs).with(1, 2){ "one-two" }
-      Assert.stub(@module, :minargs).with(1, 2, 3){ "one-two-three" }
+      Assert.stub(subject, :minargs){ "default" }
+      Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(@module, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
-    subject{ @module }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal "none", subject.noargs
+      assert_that(subject.noargs).equals("none")
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal "one",     subject.withargs(1)
-      assert_equal "default", subject.withargs(2)
+      assert_that(subject.withargs(1)).equals("one")
+      assert_that(subject.withargs(2)).equals("default")
     end
 
     should "allow stubbing a method that takes any args" do
-      assert_equal "default", subject.anyargs
-      assert_equal "default", subject.anyargs(1)
-      assert_equal "one-two", subject.anyargs(1, 2)
+      assert_that(subject.anyargs).equals("default")
+      assert_that(subject.anyargs(1)).equals("default")
+      assert_that(subject.anyargs(1, 2)).equals("one-two")
     end
 
     should "allow stubbing a method that takes a minimum number of args" do
-      assert_equal "one-two",       subject.minargs(1, 2)
-      assert_equal "one-two-three", subject.minargs(1, 2, 3)
-      assert_equal "default",       subject.minargs(1, 2, 4)
-      assert_equal "default",       subject.minargs(1, 2, 3, 4)
+      assert_that(subject.minargs(1, 2)).equals("one-two")
+      assert_that(subject.minargs(1, 2, 3)).equals("one-two-three")
+      assert_that(subject.minargs(1, 2, 4)).equals("default")
+      assert_that(subject.minargs(1, 2, 3, 4)).equals("default")
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal "default", subject.withblock
-      assert_equal "default", subject.withblock{ "my-block" }
+      assert_that(subject.withblock).equals("default")
+      assert_that(subject.withblock{ "my-block" }).equals("default")
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_raises{ Assert.stub(subject, :noargs).with(1){ } }
+      assert_that(-> { Assert.stub(subject, :noargs).with(1){ } }).raises
 
-      assert_raises{ Assert.stub(subject, :withargs).with{ } }
-      assert_raises{ Assert.stub(subject, :withargs).with(1, 2){ } }
+      assert_that(-> { Assert.stub(subject, :withargs).with{ } }).raises
+      assert_that(-> { Assert.stub(subject, :withargs).with(1, 2){ } }).raises
 
-      assert_raises{ Assert.stub(subject, :minargs).with{ } }
-      assert_raises{ Assert.stub(subject, :minargs).with(1){ } }
+      assert_that(-> { Assert.stub(subject, :minargs).with{ } }).raises
+      assert_that(-> { Assert.stub(subject, :minargs).with(1){ } }).raises
 
-      assert_raises{ Assert.stub(subject, :withblock).with(1){ } }
+      assert_that(-> { Assert.stub(subject, :withblock).with(1){ } }).raises
     end
 
     should "not allow calling methods with invalid arity" do
-      assert_raises{ subject.noargs(1) }
+      assert_that(-> { subject.noargs(1) }).raises
 
-      assert_raises{ subject.withargs }
-      assert_raises{ subject.withargs(1, 2) }
+      assert_that(-> { subject.withargs }).raises
+      assert_that(-> { subject.withargs(1, 2) }).raises
 
-      assert_raises{ subject.minargs }
-      assert_raises{ subject.minargs(1) }
+      assert_that(-> { subject.minargs }).raises
+      assert_that(-> { subject.minargs(1) }).raises
 
-      assert_raises{ subject.withblock(1) }
+      assert_that(-> { subject.withblock(1) }).raises
     end
-
   end
 
   class ExtendedTests < SystemTests
     desc "for extended methods"
+    subject { Class.new{ extend TestMixin } }
+
     setup do
-      @class = Class.new{ extend TestMixin }
-      Assert.stub(@class, :noargs){ "default" }
-      Assert.stub(@class, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(@class, :withargs){ "default" }
-      Assert.stub(@class, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(@class, :anyargs){ "default" }
-      Assert.stub(@class, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      Assert.stub(@class, :minargs){ "default" }
-      Assert.stub(@class, :minargs).with(1, 2){ "one-two" }
-      Assert.stub(@class, :minargs).with(1, 2, 3){ "one-two-three" }
+      Assert.stub(subject, :minargs){ "default" }
+      Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(@class, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
-    subject{ @class }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal "none", subject.noargs
+      assert_that(subject.noargs).equals("none")
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal "one",     subject.withargs(1)
-      assert_equal "default", subject.withargs(2)
+      assert_that(subject.withargs(1)).equals("one")
+      assert_that(subject.withargs(2)).equals("default")
     end
 
     should "allow stubbing a method that takes any args" do
-      assert_equal "default", subject.anyargs
-      assert_equal "default", subject.anyargs(1)
-      assert_equal "one-two", subject.anyargs(1, 2)
+      assert_that(subject.anyargs).equals("default")
+      assert_that(subject.anyargs(1)).equals("default")
+      assert_that(subject.anyargs(1, 2)).equals("one-two")
     end
 
     should "allow stubbing a method that takes a minimum number of args" do
-      assert_equal "one-two",       subject.minargs(1, 2)
-      assert_equal "one-two-three", subject.minargs(1, 2, 3)
-      assert_equal "default",       subject.minargs(1, 2, 4)
-      assert_equal "default",       subject.minargs(1, 2, 3, 4)
+      assert_that(subject.minargs(1, 2)).equals("one-two")
+      assert_that(subject.minargs(1, 2, 3)).equals("one-two-three")
+      assert_that(subject.minargs(1, 2, 4)).equals("default")
+      assert_that(subject.minargs(1, 2, 3, 4)).equals("default")
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal "default", subject.withblock
-      assert_equal "default", subject.withblock{ "my-block" }
+      assert_that(subject.withblock).equals("default")
+      assert_that(subject.withblock{ "my-block" }).equals("default")
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_raises{ Assert.stub(subject, :noargs).with(1){ } }
+      assert_that(-> { Assert.stub(subject, :noargs).with(1){ } }).raises
 
-      assert_raises{ Assert.stub(subject, :withargs).with{ } }
-      assert_raises{ Assert.stub(subject, :withargs).with(1, 2){ } }
+      assert_that(-> { Assert.stub(subject, :withargs).with{ } }).raises
+      assert_that(-> { Assert.stub(subject, :withargs).with(1, 2){ } }).raises
 
-      assert_raises{ Assert.stub(subject, :minargs).with{ } }
-      assert_raises{ Assert.stub(subject, :minargs).with(1){ } }
+      assert_that(-> { Assert.stub(subject, :minargs).with{ } }).raises
+      assert_that(-> { Assert.stub(subject, :minargs).with(1){ } }).raises
 
-      assert_raises{ Assert.stub(subject, :withblock).with(1){ } }
+      assert_that(-> { Assert.stub(subject, :withblock).with(1){ } }).raises
     end
 
     should "not allow calling methods with invalid arity" do
-      assert_raises{ subject.noargs(1) }
+      assert_that(-> { subject.noargs(1) }).raises
 
-      assert_raises{ subject.withargs }
-      assert_raises{ subject.withargs(1, 2) }
+      assert_that(-> { subject.withargs }).raises
+      assert_that(-> { subject.withargs(1, 2) }).raises
 
-      assert_raises{ subject.minargs }
-      assert_raises{ subject.minargs(1) }
+      assert_that(-> { subject.minargs }).raises
+      assert_that(-> { subject.minargs(1) }).raises
 
-      assert_raises{ subject.withblock(1) }
+      assert_that(-> { subject.withblock(1) }).raises
     end
-
   end
 
   class IncludedTests < SystemTests
     desc "for an included method"
+    subject {
+      Class.new { include TestMixin }.new
+    }
+
     setup do
-      @class = Class.new{ include TestMixin }
-      @instance = @class.new
-      Assert.stub(@instance, :noargs){ "default" }
-      Assert.stub(@instance, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(@instance, :withargs){ "default" }
-      Assert.stub(@instance, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(@instance, :anyargs){ "default" }
-      Assert.stub(@instance, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      Assert.stub(@instance, :minargs){ "default" }
-      Assert.stub(@instance, :minargs).with(1, 2){ "one-two" }
-      Assert.stub(@instance, :minargs).with(1, 2, 3){ "one-two-three" }
+      Assert.stub(subject, :minargs){ "default" }
+      Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(@instance, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
-    subject{ @instance }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal "none", subject.noargs
+      assert_that(subject.noargs).equals("none")
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal "one",     subject.withargs(1)
-      assert_equal "default", subject.withargs(2)
+      assert_that(subject.withargs(1)).equals("one")
+      assert_that(subject.withargs(2)).equals("default")
     end
 
     should "allow stubbing a method that takes any args" do
-      assert_equal "default", subject.anyargs
-      assert_equal "default", subject.anyargs(1)
-      assert_equal "one-two", subject.anyargs(1, 2)
+      assert_that(subject.anyargs).equals("default")
+      assert_that(subject.anyargs(1)).equals("default")
+      assert_that(subject.anyargs(1, 2)).equals("one-two")
     end
 
     should "allow stubbing a method that takes a minimum number of args" do
-      assert_equal "one-two",       subject.minargs(1, 2)
-      assert_equal "one-two-three", subject.minargs(1, 2, 3)
-      assert_equal "default",       subject.minargs(1, 2, 4)
-      assert_equal "default",       subject.minargs(1, 2, 3, 4)
+      assert_that(subject.minargs(1, 2)).equals("one-two")
+      assert_that(subject.minargs(1, 2, 3)).equals("one-two-three")
+      assert_that(subject.minargs(1, 2, 4)).equals("default")
+      assert_that(subject.minargs(1, 2, 3, 4)).equals("default")
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal "default", subject.withblock
-      assert_equal "default", subject.withblock{ "my-block" }
+      assert_that(subject.withblock).equals("default")
+      assert_that(subject.withblock{ "my-block" }).equals("default")
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_raises{ Assert.stub(subject, :noargs).with(1){ } }
+      assert_that(-> { Assert.stub(subject, :noargs).with(1){ } }).raises
 
-      assert_raises{ Assert.stub(subject, :withargs).with{ } }
-      assert_raises{ Assert.stub(subject, :withargs).with(1, 2){ } }
+      assert_that(-> { Assert.stub(subject, :withargs).with{ } }).raises
+      assert_that(-> { Assert.stub(subject, :withargs).with(1, 2){ } }).raises
 
-      assert_raises{ Assert.stub(subject, :minargs).with{ } }
-      assert_raises{ Assert.stub(subject, :minargs).with(1){ } }
+      assert_that(-> { Assert.stub(subject, :minargs).with{ } }).raises
+      assert_that(-> { Assert.stub(subject, :minargs).with(1){ } }).raises
 
-      assert_raises{ Assert.stub(subject, :withblock).with(1){ } }
+      assert_that(-> { Assert.stub(subject, :withblock).with(1){ } }).raises
     end
 
     should "not allow calling methods with invalid arity" do
-      assert_raises{ subject.noargs(1) }
+      assert_that(-> { subject.noargs(1) }).raises
 
-      assert_raises{ subject.withargs }
-      assert_raises{ subject.withargs(1, 2) }
+      assert_that(-> { subject.withargs }).raises
+      assert_that(-> { subject.withargs(1, 2) }).raises
 
-      assert_raises{ subject.minargs }
-      assert_raises{ subject.minargs(1) }
+      assert_that(-> { subject.minargs }).raises
+      assert_that(-> { subject.minargs(1) }).raises
 
-      assert_raises{ subject.withblock(1) }
+      assert_that(-> { subject.withblock(1) }).raises
     end
-
   end
 
   class InheritedClassTests < SystemTests
     desc "for an inherited class method"
+    subject { Class.new(TestClass) }
+
     setup do
-      @class = Class.new(TestClass)
-      Assert.stub(@class, :noargs){ "default" }
-      Assert.stub(@class, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(@class, :withargs){ "default" }
-      Assert.stub(@class, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(@class, :anyargs){ "default" }
-      Assert.stub(@class, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      Assert.stub(@class, :minargs){ "default" }
-      Assert.stub(@class, :minargs).with(1, 2){ "one-two" }
-      Assert.stub(@class, :minargs).with(1, 2, 3){ "one-two-three" }
+      Assert.stub(subject, :minargs){ "default" }
+      Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(@class, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
-    subject{ @class }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal "none", subject.noargs
+      assert_that(subject.noargs).equals("none")
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal "one",     subject.withargs(1)
-      assert_equal "default", subject.withargs(2)
+      assert_that(subject.withargs(1)).equals("one")
+      assert_that(subject.withargs(2)).equals("default")
     end
 
     should "allow stubbing a method that takes any args" do
-      assert_equal "default", subject.anyargs
-      assert_equal "default", subject.anyargs(1)
-      assert_equal "one-two", subject.anyargs(1, 2)
+      assert_that(subject.anyargs).equals("default")
+      assert_that(subject.anyargs(1)).equals("default")
+      assert_that(subject.anyargs(1, 2)).equals("one-two")
     end
 
     should "allow stubbing a method that takes a minimum number of args" do
-      assert_equal "one-two",       subject.minargs(1, 2)
-      assert_equal "one-two-three", subject.minargs(1, 2, 3)
-      assert_equal "default",       subject.minargs(1, 2, 4)
-      assert_equal "default",       subject.minargs(1, 2, 3, 4)
+      assert_that(subject.minargs(1, 2)).equals("one-two")
+      assert_that(subject.minargs(1, 2, 3)).equals("one-two-three")
+      assert_that(subject.minargs(1, 2, 4)).equals("default")
+      assert_that(subject.minargs(1, 2, 3, 4)).equals("default")
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal "default", subject.withblock
-      assert_equal "default", subject.withblock{ "my-block" }
+      assert_that(subject.withblock).equals("default")
+      assert_that(subject.withblock{ "my-block" }).equals("default")
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_raises{ Assert.stub(subject, :noargs).with(1){ } }
+      assert_that(-> { Assert.stub(subject, :noargs).with(1){ } }).raises
 
-      assert_raises{ Assert.stub(subject, :withargs).with{ } }
-      assert_raises{ Assert.stub(subject, :withargs).with(1, 2){ } }
+      assert_that(-> { Assert.stub(subject, :withargs).with{ } }).raises
+      assert_that(-> { Assert.stub(subject, :withargs).with(1, 2){ } }).raises
 
-      assert_raises{ Assert.stub(subject, :minargs).with{ } }
-      assert_raises{ Assert.stub(subject, :minargs).with(1){ } }
+      assert_that(-> { Assert.stub(subject, :minargs).with{ } }).raises
+      assert_that(-> { Assert.stub(subject, :minargs).with(1){ } }).raises
 
-      assert_raises{ Assert.stub(subject, :withblock).with(1){ } }
+      assert_that(-> { Assert.stub(subject, :withblock).with(1){ } }).raises
     end
 
     should "not allow calling methods with invalid arity" do
-      assert_raises{ subject.noargs(1) }
+      assert_that(-> { subject.noargs(1) }).raises
 
-      assert_raises{ subject.withargs }
-      assert_raises{ subject.withargs(1, 2) }
+      assert_that(-> { subject.withargs }).raises
+      assert_that(-> { subject.withargs(1, 2) }).raises
 
-      assert_raises{ subject.minargs }
-      assert_raises{ subject.minargs(1) }
+      assert_that(-> { subject.minargs }).raises
+      assert_that(-> { subject.minargs(1) }).raises
 
-      assert_raises{ subject.withblock(1) }
+      assert_that(-> { subject.withblock(1) }).raises
     end
-
   end
 
   class InheritedInstanceTests < SystemTests
     desc "for an inherited instance method"
+    subject { Class.new(TestClass).new }
+
     setup do
-      @class = Class.new(TestClass)
-      @instance = @class.new
-      Assert.stub(@instance, :noargs){ "default" }
-      Assert.stub(@instance, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(@instance, :withargs){ "default" }
-      Assert.stub(@instance, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(@instance, :anyargs){ "default" }
-      Assert.stub(@instance, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      Assert.stub(@instance, :minargs){ "default" }
-      Assert.stub(@instance, :minargs).with(1, 2){ "one-two" }
-      Assert.stub(@instance, :minargs).with(1, 2, 3){ "one-two-three" }
+      Assert.stub(subject, :minargs){ "default" }
+      Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(@instance, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
-    subject{ @instance }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal "none", subject.noargs
+      assert_that(subject.noargs).equals("none")
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal "one",     subject.withargs(1)
-      assert_equal "default", subject.withargs(2)
+      assert_that(subject.withargs(1)).equals("one")
+      assert_that(subject.withargs(2)).equals("default")
     end
 
     should "allow stubbing a method that takes any args" do
-      assert_equal "default", subject.anyargs
-      assert_equal "default", subject.anyargs(1)
-      assert_equal "one-two", subject.anyargs(1, 2)
+      assert_that(subject.anyargs).equals("default")
+      assert_that(subject.anyargs(1)).equals("default")
+      assert_that(subject.anyargs(1, 2)).equals("one-two")
     end
 
     should "allow stubbing a method that takes a minimum number of args" do
-      assert_equal "one-two",       subject.minargs(1, 2)
-      assert_equal "one-two-three", subject.minargs(1, 2, 3)
-      assert_equal "default",       subject.minargs(1, 2, 4)
-      assert_equal "default",       subject.minargs(1, 2, 3, 4)
+      assert_that(subject.minargs(1, 2)).equals("one-two")
+      assert_that(subject.minargs(1, 2, 3)).equals("one-two-three")
+      assert_that(subject.minargs(1, 2, 4)).equals("default")
+      assert_that(subject.minargs(1, 2, 3, 4)).equals("default")
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal "default", subject.withblock
-      assert_equal "default", subject.withblock{ "my-block" }
+      assert_that(subject.withblock).equals("default")
+      assert_that(subject.withblock{ "my-block" }).equals("default")
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_raises{ Assert.stub(subject, :noargs).with(1){ } }
+      assert_that(-> { Assert.stub(subject, :noargs).with(1){ } }).raises
 
-      assert_raises{ Assert.stub(subject, :withargs).with{ } }
-      assert_raises{ Assert.stub(subject, :withargs).with(1, 2){ } }
+      assert_that(-> { Assert.stub(subject, :withargs).with{ } }).raises
+      assert_that(-> { Assert.stub(subject, :withargs).with(1, 2){ } }).raises
 
-      assert_raises{ Assert.stub(subject, :minargs).with{ } }
-      assert_raises{ Assert.stub(subject, :minargs).with(1){ } }
+      assert_that(-> { Assert.stub(subject, :minargs).with{ } }).raises
+      assert_that(-> { Assert.stub(subject, :minargs).with(1){ } }).raises
 
-      assert_raises{ Assert.stub(subject, :withblock).with(1){ } }
+      assert_that(-> { Assert.stub(subject, :withblock).with(1){ } }).raises
     end
 
     should "not allow calling methods with invalid arity" do
-      assert_raises{ subject.noargs(1) }
+      assert_that(-> { subject.noargs(1) }).raises
 
-      assert_raises{ subject.withargs }
-      assert_raises{ subject.withargs(1, 2) }
+      assert_that(-> { subject.withargs }).raises
+      assert_that(-> { subject.withargs(1, 2) }).raises
 
-      assert_raises{ subject.minargs }
-      assert_raises{ subject.minargs(1) }
+      assert_that(-> { subject.minargs }).raises
+      assert_that(-> { subject.minargs(1) }).raises
 
-      assert_raises{ subject.withblock(1) }
+      assert_that(-> { subject.withblock(1) }).raises
     end
-
   end
 
   class DelegateClassTests < SystemTests
     desc "a class that delegates another object"
+    subject { DelegateClass }
+
     setup do
-      @class = DelegateClass
-      Assert.stub(@class, :noargs){ "default" }
-      Assert.stub(@class, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(@class, :withargs){ "default" }
-      Assert.stub(@class, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(@class, :anyargs){ "default" }
-      Assert.stub(@class, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      Assert.stub(@class, :minargs){ "default" }
-      Assert.stub(@class, :minargs).with(1, 2){ "one-two" }
-      Assert.stub(@class, :minargs).with(1, 2, 3){ "one-two-three" }
+      Assert.stub(subject, :minargs){ "default" }
+      Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(@class, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
-    subject{ @class }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal "none", subject.noargs
+      assert_that(subject.noargs).equals("none")
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal "one",     subject.withargs(1)
-      assert_equal "default", subject.withargs(2)
+      assert_that(subject.withargs(1)).equals("one")
+      assert_that(subject.withargs(2)).equals("default")
     end
 
     should "allow stubbing a method that takes any args" do
-      assert_equal "default", subject.anyargs
-      assert_equal "default", subject.anyargs(1)
-      assert_equal "one-two", subject.anyargs(1, 2)
+      assert_that(subject.anyargs).equals("default")
+      assert_that(subject.anyargs(1)).equals("default")
+      assert_that(subject.anyargs(1, 2)).equals("one-two")
     end
 
     should "allow stubbing a method that takes a minimum number of args" do
-      assert_equal "one-two",       subject.minargs(1, 2)
-      assert_equal "one-two-three", subject.minargs(1, 2, 3)
-      assert_equal "default",       subject.minargs(1, 2, 4)
-      assert_equal "default",       subject.minargs(1, 2, 3, 4)
+      assert_that(subject.minargs(1, 2)).equals("one-two")
+      assert_that(subject.minargs(1, 2, 3)).equals("one-two-three")
+      assert_that(subject.minargs(1, 2, 4)).equals("default")
+      assert_that(subject.minargs(1, 2, 3, 4)).equals("default")
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal "default", subject.withblock
-      assert_equal "default", subject.withblock{ "my-block" }
+      assert_that(subject.withblock).equals("default")
+      assert_that(subject.withblock{ "my-block" }).equals("default")
     end
 
     should "allow stubbing methods with invalid arity" do
-      assert_nothing_raised{ Assert.stub(subject, :noargs).with(1){ } }
+      assert_that(-> { Assert.stub(subject, :noargs).with(1){ } }).does_not_raise
 
-      assert_nothing_raised{ Assert.stub(subject, :withargs).with{ } }
-      assert_nothing_raised{ Assert.stub(subject, :withargs).with(1, 2){ } }
+      assert_that(-> { Assert.stub(subject, :withargs).with{ } }).does_not_raise
+      assert_that(-> { Assert.stub(subject, :withargs).with(1, 2){ } }).does_not_raise
 
-      assert_nothing_raised{ Assert.stub(subject, :minargs).with{ } }
-      assert_nothing_raised{ Assert.stub(subject, :minargs).with(1){ } }
+      assert_that(-> { Assert.stub(subject, :minargs).with{ } }).does_not_raise
+      assert_that(-> { Assert.stub(subject, :minargs).with(1){ } }).does_not_raise
 
-      assert_nothing_raised{ Assert.stub(subject, :withblock).with(1){ } }
+      assert_that(-> { Assert.stub(subject, :withblock).with(1){ } }).does_not_raise
     end
 
     should "allow calling methods with invalid arity" do
-      assert_nothing_raised{ subject.noargs(1) }
+      assert_that(-> { subject.noargs(1) }).does_not_raise
 
-      assert_nothing_raised{ subject.withargs }
-      assert_nothing_raised{ subject.withargs(1, 2) }
+      assert_that(-> { subject.withargs }).does_not_raise
+      assert_that(-> { subject.withargs(1, 2) }).does_not_raise
 
-      assert_nothing_raised{ subject.minargs }
-      assert_nothing_raised{ subject.minargs(1) }
+      assert_that(-> { subject.minargs }).does_not_raise
+      assert_that(-> { subject.minargs(1) }).does_not_raise
 
-      assert_nothing_raised{ subject.withblock(1) }
+      assert_that(-> { subject.withblock(1) }).does_not_raise
     end
-
   end
 
   class DelegateInstanceTests < SystemTests
     desc "an instance that delegates another object"
+    subject { DelegateClass.new }
+
     setup do
-      @instance = DelegateClass.new
-      Assert.stub(@instance, :noargs){ "default" }
-      Assert.stub(@instance, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(@instance, :withargs){ "default" }
-      Assert.stub(@instance, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(@instance, :anyargs){ "default" }
-      Assert.stub(@instance, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      Assert.stub(@instance, :minargs){ "default" }
-      Assert.stub(@instance, :minargs).with(1, 2){ "one-two" }
-      Assert.stub(@instance, :minargs).with(1, 2, 3){ "one-two-three" }
+      Assert.stub(subject, :minargs){ "default" }
+      Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(@instance, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
-    subject{ @instance }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal "none", subject.noargs
+      assert_that(subject.noargs).equals("none")
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal "one",     subject.withargs(1)
-      assert_equal "default", subject.withargs(2)
+      assert_that(subject.withargs(1)).equals("one")
+      assert_that(subject.withargs(2)).equals("default")
     end
 
     should "allow stubbing a method that takes any args" do
-      assert_equal "default", subject.anyargs
-      assert_equal "default", subject.anyargs(1)
-      assert_equal "one-two", subject.anyargs(1, 2)
+      assert_that(subject.anyargs).equals("default")
+      assert_that(subject.anyargs(1)).equals("default")
+      assert_that(subject.anyargs(1, 2)).equals("one-two")
     end
 
     should "allow stubbing a method that takes a minimum number of args" do
-      assert_equal "one-two",       subject.minargs(1, 2)
-      assert_equal "one-two-three", subject.minargs(1, 2, 3)
-      assert_equal "default",       subject.minargs(1, 2, 4)
-      assert_equal "default",       subject.minargs(1, 2, 3, 4)
+      assert_that(subject.minargs(1, 2)).equals("one-two")
+      assert_that(subject.minargs(1, 2, 3)).equals("one-two-three")
+      assert_that(subject.minargs(1, 2, 4)).equals("default")
+      assert_that(subject.minargs(1, 2, 3, 4)).equals("default")
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal "default", subject.withblock
-      assert_equal "default", subject.withblock{ "my-block" }
+      assert_that(subject.withblock).equals("default")
+      assert_that(subject.withblock{ "my-block" }).equals("default")
     end
 
     should "allow stubbing methods with invalid arity" do
-      assert_nothing_raised{ Assert.stub(subject, :noargs).with(1){ } }
+      assert_that(-> { Assert.stub(subject, :noargs).with(1){ } }).does_not_raise
 
-      assert_nothing_raised{ Assert.stub(subject, :withargs).with{ } }
-      assert_nothing_raised{ Assert.stub(subject, :withargs).with(1, 2){ } }
+      assert_that(-> { Assert.stub(subject, :withargs).with{ } }).does_not_raise
+      assert_that(-> { Assert.stub(subject, :withargs).with(1, 2){ } }).does_not_raise
 
-      assert_nothing_raised{ Assert.stub(subject, :minargs).with{ } }
-      assert_nothing_raised{ Assert.stub(subject, :minargs).with(1){ } }
+      assert_that(-> { Assert.stub(subject, :minargs).with{ } }).does_not_raise
+      assert_that(-> { Assert.stub(subject, :minargs).with(1){ } }).does_not_raise
 
-      assert_nothing_raised{ Assert.stub(subject, :withblock).with(1){ } }
+      assert_that(-> { Assert.stub(subject, :withblock).with(1){ } }).does_not_raise
     end
 
     should "allow calling methods with invalid arity" do
-      assert_nothing_raised{ subject.noargs(1) }
+      assert_that(-> { subject.noargs(1) }).does_not_raise
 
-      assert_nothing_raised{ subject.withargs }
-      assert_nothing_raised{ subject.withargs(1, 2) }
+      assert_that(-> { subject.withargs }).does_not_raise
+      assert_that(-> { subject.withargs(1, 2) }).does_not_raise
 
-      assert_nothing_raised{ subject.minargs }
-      assert_nothing_raised{ subject.minargs(1) }
+      assert_that(-> { subject.minargs }).does_not_raise
+      assert_that(-> { subject.minargs(1) }).does_not_raise
 
-      assert_nothing_raised{ subject.withblock(1) }
+      assert_that(-> { subject.withblock(1) }).does_not_raise
     end
-
   end
 
   class ParentAndChildClassTests < SystemTests
     desc "for a parent method stubbed on both the parent and child"
     setup do
-      @parent_class = Class.new
-      @child_class = Class.new(@parent_class)
-
-      Assert.stub(@parent_class, :new){ "parent" }
-      Assert.stub(@child_class, :new){ "child" }
+      Assert.stub(parent_class, :new){ "parent" }
+      Assert.stub(child_class, :new){ "child" }
     end
 
+    let(:parent_class) { Class.new }
+    let(:child_class) { Class.new(parent_class) }
+
     should "allow stubbing the methods individually" do
-      assert_equal "parent", @parent_class.new
-      assert_equal "child", @child_class.new
+      assert_that(parent_class.new).equals("parent")
+      assert_that(child_class.new).equals("child")
     end
-
   end
 
   class TestClass
-
     def self.noargs; end
     def self.withargs(a); end
     def self.anyargs(*args); end
@@ -706,27 +692,22 @@ class Assert::Stub
     def anyargs(*args); end
     def minargs(a, b, *args); end
     def withblock(&block); end
-
   end
 
   module TestModule
-
     def self.noargs; end
     def self.withargs(a); end
     def self.anyargs(*args); end
     def self.minargs(a, b, *args); end
     def self.withblock(&block); end
-
   end
 
   module TestMixin
-
     def noargs; end
     def withargs(a); end
     def anyargs(*args); end
     def minargs(a, b, *args); end
     def withblock(&block); end
-
   end
 
   class DelegateClass
@@ -750,5 +731,4 @@ class Assert::Stub
       @delegate.respond_to?(name) ? @delegate.send(name, *args, &block) : super
     end
   end
-
 end