assert 2.16.5 → 2.18.3

data/test/support/factory.rb

@@ -1,8 +1,8 @@
-require 'assert/config'
-require 'assert/default_suite'
-require 'assert/factory'
-require 'assert/result'
-require 'assert/test'
+require "assert/config"
+require "assert/default_suite"
+require "assert/factory"
+require "assert/result"
+require "assert/test"
 
 module Factory
   extend Assert::Factory
@@ -35,7 +35,7 @@ module Factory
     config, context_info, name = [
       args.last.kind_of?(Assert::Config) ? args.pop : self.modes_off_config,
       args.last.kind_of?(Assert::ContextInfo) ? args.pop : self.context_info,
-      args.last.kind_of?(::String) ? args.pop : 'a test'
+      args.last.kind_of?(::String) ? args.pop : "a test"
     ]
     Assert::Test.for_block(name, context_info, config, &block)
   end
@@ -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

@@ -1,700 +1,702 @@
-require 'assert'
-require 'assert/stub'
+require "assert"
+require "assert/stub"
 
 class Assert::Stub
-
   class SystemTests < Assert::Context
     desc "Assert::Stub"
-
   end
 
   class InstanceTests < SystemTests
     desc "for instance methods"
+    subject { instance1 }
+
     setup do
-      @instance = TestClass.new
-      Assert.stub(@instance, :noargs){ 'default' }
-      Assert.stub(@instance, :noargs).with{ 'none' }
+      Assert.stub(instance1, :noargs){ "default" }
+      Assert.stub(instance1, :noargs).with{ "none" }
 
-      Assert.stub(@instance, :withargs){ 'default' }
-      Assert.stub(@instance, :withargs).with(1){ 'one' }
+      Assert.stub(instance1, :withargs){ "default" }
+      Assert.stub(instance1, :withargs).with(1){ "one" }
 
-      Assert.stub(@instance, :anyargs){ 'default' }
-      Assert.stub(@instance, :anyargs).with(1, 2){ 'one-two' }
+      Assert.stub(instance1, :anyargs){ "default" }
+      Assert.stub(instance1, :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(instance1, :minargs){ "default" }
+      Assert.stub(instance1, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(instance1, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(@instance, :withblock){ 'default' }
+      Assert.stub(instance1, :withblock){ "default" }
     end
-    subject{ @instance }
+
+    let(:instance1) { TestClass.new }
 
     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 { class1 }
+
     setup do
-      @class = TestClass
-      Assert.stub(@class, :noargs){ 'default' }
-      Assert.stub(@class, :noargs).with{ 'none' }
+      Assert.stub(class1, :noargs){ "default" }
+      Assert.stub(class1, :noargs).with{ "none" }
 
-      Assert.stub(@class, :withargs){ 'default' }
-      Assert.stub(@class, :withargs).with(1){ 'one' }
+      Assert.stub(class1, :withargs){ "default" }
+      Assert.stub(class1, :withargs).with(1){ "one" }
 
-      Assert.stub(@class, :anyargs){ 'default' }
-      Assert.stub(@class, :anyargs).with(1, 2){ 'one-two' }
+      Assert.stub(class1, :anyargs){ "default" }
+      Assert.stub(class1, :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(class1, :minargs){ "default" }
+      Assert.stub(class1, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(class1, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(@class, :withblock){ 'default' }
+      Assert.stub(class1, :withblock){ "default" }
     end
-    subject{ @class }
+
+    let(:class1) { TestClass }
 
     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 { module1 }
+
     setup do
-      @module = TestModule
-      Assert.stub(@module, :noargs){ 'default' }
-      Assert.stub(@module, :noargs).with{ 'none' }
+      Assert.stub(module1, :noargs){ "default" }
+      Assert.stub(module1, :noargs).with{ "none" }
 
-      Assert.stub(@module, :withargs){ 'default' }
-      Assert.stub(@module, :withargs).with(1){ 'one' }
+      Assert.stub(module1, :withargs){ "default" }
+      Assert.stub(module1, :withargs).with(1){ "one" }
 
-      Assert.stub(@module, :anyargs){ 'default' }
-      Assert.stub(@module, :anyargs).with(1, 2){ 'one-two' }
+      Assert.stub(module1, :anyargs){ "default" }
+      Assert.stub(module1, :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(module1, :minargs){ "default" }
+      Assert.stub(module1, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(module1, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(@module, :withblock){ 'default' }
+      Assert.stub(module1, :withblock){ "default" }
     end
-    subject{ @module }
+
+    let(:module1) { TestModule }
 
     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 { class1 }
+
     setup do
-      @class = Class.new{ extend TestMixin }
-      Assert.stub(@class, :noargs){ 'default' }
-      Assert.stub(@class, :noargs).with{ 'none' }
+      Assert.stub(class1, :noargs){ "default" }
+      Assert.stub(class1, :noargs).with{ "none" }
 
-      Assert.stub(@class, :withargs){ 'default' }
-      Assert.stub(@class, :withargs).with(1){ 'one' }
+      Assert.stub(class1, :withargs){ "default" }
+      Assert.stub(class1, :withargs).with(1){ "one" }
 
-      Assert.stub(@class, :anyargs){ 'default' }
-      Assert.stub(@class, :anyargs).with(1, 2){ 'one-two' }
+      Assert.stub(class1, :anyargs){ "default" }
+      Assert.stub(class1, :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(class1, :minargs){ "default" }
+      Assert.stub(class1, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(class1, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(@class, :withblock){ 'default' }
+      Assert.stub(class1, :withblock){ "default" }
     end
-    subject{ @class }
+
+    let(:class1) { Class.new{ extend TestMixin } }
 
     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 { instance1 }
+
     setup do
-      @class = Class.new{ include TestMixin }
-      @instance = @class.new
-      Assert.stub(@instance, :noargs){ 'default' }
-      Assert.stub(@instance, :noargs).with{ 'none' }
+      Assert.stub(instance1, :noargs){ "default" }
+      Assert.stub(instance1, :noargs).with{ "none" }
 
-      Assert.stub(@instance, :withargs){ 'default' }
-      Assert.stub(@instance, :withargs).with(1){ 'one' }
+      Assert.stub(instance1, :withargs){ "default" }
+      Assert.stub(instance1, :withargs).with(1){ "one" }
 
-      Assert.stub(@instance, :anyargs){ 'default' }
-      Assert.stub(@instance, :anyargs).with(1, 2){ 'one-two' }
+      Assert.stub(instance1, :anyargs){ "default" }
+      Assert.stub(instance1, :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(instance1, :minargs){ "default" }
+      Assert.stub(instance1, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(instance1, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(@instance, :withblock){ 'default' }
+      Assert.stub(instance1, :withblock){ "default" }
     end
-    subject{ @instance }
+
+    let(:instance1) { Class.new { include TestMixin }.new }
 
     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 { class1 }
+
     setup do
-      @class = Class.new(TestClass)
-      Assert.stub(@class, :noargs){ 'default' }
-      Assert.stub(@class, :noargs).with{ 'none' }
+      Assert.stub(class1, :noargs){ "default" }
+      Assert.stub(class1, :noargs).with{ "none" }
 
-      Assert.stub(@class, :withargs){ 'default' }
-      Assert.stub(@class, :withargs).with(1){ 'one' }
+      Assert.stub(class1, :withargs){ "default" }
+      Assert.stub(class1, :withargs).with(1){ "one" }
 
-      Assert.stub(@class, :anyargs){ 'default' }
-      Assert.stub(@class, :anyargs).with(1, 2){ 'one-two' }
+      Assert.stub(class1, :anyargs){ "default" }
+      Assert.stub(class1, :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(class1, :minargs){ "default" }
+      Assert.stub(class1, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(class1, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(@class, :withblock){ 'default' }
+      Assert.stub(class1, :withblock){ "default" }
     end
-    subject{ @class }
+
+    let(:class1) { Class.new(TestClass) }
 
     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 { instance1 }
+
     setup do
-      @class = Class.new(TestClass)
-      @instance = @class.new
-      Assert.stub(@instance, :noargs){ 'default' }
-      Assert.stub(@instance, :noargs).with{ 'none' }
+      Assert.stub(instance1, :noargs){ "default" }
+      Assert.stub(instance1, :noargs).with{ "none" }
 
-      Assert.stub(@instance, :withargs){ 'default' }
-      Assert.stub(@instance, :withargs).with(1){ 'one' }
+      Assert.stub(instance1, :withargs){ "default" }
+      Assert.stub(instance1, :withargs).with(1){ "one" }
 
-      Assert.stub(@instance, :anyargs){ 'default' }
-      Assert.stub(@instance, :anyargs).with(1, 2){ 'one-two' }
+      Assert.stub(instance1, :anyargs){ "default" }
+      Assert.stub(instance1, :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(instance1, :minargs){ "default" }
+      Assert.stub(instance1, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(instance1, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(@instance, :withblock){ 'default' }
+      Assert.stub(instance1, :withblock){ "default" }
     end
-    subject{ @instance }
+
+    let(:instance1) { Class.new(TestClass).new }
 
     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 { class1 }
+
     setup do
-      @class = DelegateClass
-      Assert.stub(@class, :noargs){ 'default' }
-      Assert.stub(@class, :noargs).with{ 'none' }
+      Assert.stub(class1, :noargs){ "default" }
+      Assert.stub(class1, :noargs).with{ "none" }
 
-      Assert.stub(@class, :withargs){ 'default' }
-      Assert.stub(@class, :withargs).with(1){ 'one' }
+      Assert.stub(class1, :withargs){ "default" }
+      Assert.stub(class1, :withargs).with(1){ "one" }
 
-      Assert.stub(@class, :anyargs){ 'default' }
-      Assert.stub(@class, :anyargs).with(1, 2){ 'one-two' }
+      Assert.stub(class1, :anyargs){ "default" }
+      Assert.stub(class1, :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(class1, :minargs){ "default" }
+      Assert.stub(class1, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(class1, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(@class, :withblock){ 'default' }
+      Assert.stub(class1, :withblock){ "default" }
     end
-    subject{ @class }
+
+    let(:class1) { DelegateClass }
 
     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 { instance1 }
+
     setup do
-      @instance = DelegateClass.new
-      Assert.stub(@instance, :noargs){ 'default' }
-      Assert.stub(@instance, :noargs).with{ 'none' }
+      Assert.stub(instance1, :noargs){ "default" }
+      Assert.stub(instance1, :noargs).with{ "none" }
 
-      Assert.stub(@instance, :withargs){ 'default' }
-      Assert.stub(@instance, :withargs).with(1){ 'one' }
+      Assert.stub(instance1, :withargs){ "default" }
+      Assert.stub(instance1, :withargs).with(1){ "one" }
 
-      Assert.stub(@instance, :anyargs){ 'default' }
-      Assert.stub(@instance, :anyargs).with(1, 2){ 'one-two' }
+      Assert.stub(instance1, :anyargs){ "default" }
+      Assert.stub(instance1, :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(instance1, :minargs){ "default" }
+      Assert.stub(instance1, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(instance1, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(@instance, :withblock){ 'default' }
+      Assert.stub(instance1, :withblock){ "default" }
     end
-    subject{ @instance }
+
+    let(:instance1) { DelegateClass.new }
 
     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 +708,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 +747,4 @@ class Assert::Stub
       @delegate.respond_to?(name) ? @delegate.send(name, *args, &block) : super
     end
   end
-
 end