assert 2.18.3 → 2.19.3

data/test/support/factory.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert/config"
 require "assert/default_suite"
 require "assert/factory"
@@ -8,11 +10,17 @@ module Factory
   extend Assert::Factory
 
   def self.context_info_called_from
-    File.expand_path("#{Factory.path}_tests.rb:#{Factory.integer}", Dir.pwd)
+    File.expand_path(
+      "#{Factory.path}_tests.rb:#{Factory.integer}",
+      Dir.pwd,
+    )
   end
 
   def self.context_info(context_klass = nil)
-    Assert::ContextInfo.new(context_klass || self.context_class, context_info_called_from)
+    Assert::ContextInfo.new(
+      context_klass || context_class,
+      context_info_called_from,
+    )
   end
 
   # Generate an anonymous `Context` inherited from `Assert::Context` by default.
@@ -22,9 +30,8 @@ module Factory
     klass = Class.new(inherit_from || Assert::Context, &block)
     default = const_name = "FactoryAssertContext"
 
-    while(Object.const_defined?(const_name)) do
-      const_name = "#{default}#{rand(Time.now.to_i)}"
-    end
+    const_name =
+      "#{default}#{rand(Time.now.to_i)}" while Object.const_defined?(const_name)
     Object.const_set(const_name, klass)
     klass
   end
@@ -33,9 +40,9 @@ module Factory
 
   def self.test(*args, &block)
     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.is_a?(Assert::Config) ? args.pop : modes_off_config,
+      args.last.is_a?(Assert::ContextInfo) ? args.pop : self.context_info,
+      args.last.is_a?(::String) ? args.pop : "a test",
     ]
     Assert::Test.for_block(name, context_info, config, &block)
   end
@@ -43,15 +50,27 @@ module Factory
   # Generate results for use in testing.
 
   def self.pass_result(msg = nil)
-    Assert::Result::Pass.for_test(Factory.test(Factory.string), msg || Factory.string, [])
+    Assert::Result::Pass.for_test(
+      Factory.test(Factory.string),
+      msg || Factory.string,
+      [],
+    )
   end
 
   def self.ignore_result(msg = nil)
-    Assert::Result::Ignore.for_test(Factory.test(Factory.string), msg || Factory.string, [])
+    Assert::Result::Ignore.for_test(
+      Factory.test(Factory.string),
+      msg || Factory.string,
+      [],
+    )
   end
 
   def self.fail_result(msg = nil)
-    Assert::Result::Fail.for_test(Factory.test(Factory.string), msg || Factory.string, [])
+    Assert::Result::Fail.for_test(
+      Factory.test(Factory.string),
+      msg || Factory.string,
+      [],
+    )
   end
 
   def self.skip_result(exception = nil)
@@ -66,23 +85,23 @@ module Factory
 
   def self.modes_off_config
     Assert::Config.new({
-      :capture_output => false,
-      :halt_on_fail   => false,
-      :changed_only   => false,
-      :pp_objects     => false,
-      :debug          => false
+      capture_output: false,
+      halt_on_fail: false,
+      changed_only: false,
+      pp_objects: false,
+      debug: false,
     })
   end
 
   def self.modes_off_suite
-    Assert::DefaultSuite.new(self.modes_off_config)
+    Assert::DefaultSuite.new(modes_off_config)
   end
 
   def self.modes_off_context_class(*args, &block)
-    suite_obj = self.modes_off_suite
-    self.context_class(*args) do
+    suite_obj = modes_off_suite
+    context_class(*args) do
       suite(suite_obj)
-      instance_eval(&block) if !block.nil?
+      instance_eval(&block) unless block.nil?
     end
   end
 
@@ -91,7 +110,7 @@ module Factory
     Factory.modes_off_context_class.new(
       test,
       test.config,
-      result_block || proc { |r| }
+      result_block || proc{ |r| },
     )
   end
 

data/test/support/inherited_stuff.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MixinStuff
   def test_mixin_stuff
     "from mixin"

data/test/system/stub_tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/stub"
 
@@ -8,27 +10,25 @@ class Assert::Stub
 
   class InstanceTests < SystemTests
     desc "for instance methods"
-    subject { instance1 }
+    subject{ TestClass.new }
 
     setup do
-      Assert.stub(instance1, :noargs){ "default" }
-      Assert.stub(instance1, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(instance1, :withargs){ "default" }
-      Assert.stub(instance1, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(instance1, :anyargs){ "default" }
-      Assert.stub(instance1, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      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(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(instance1, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
 
-    let(:instance1) { TestClass.new }
-
     should "allow stubbing a method that doesn't take args" do
       assert_that(subject.noargs).equals("none")
     end
@@ -56,53 +56,51 @@ class Assert::Stub
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_that(-> { Assert.stub(subject, :noargs).with(1){ } }).raises
+      assert_that{ Assert.stub(subject, :noargs).with(1){} }.raises
 
-      assert_that(-> { Assert.stub(subject, :withargs).with{ } }).raises
-      assert_that(-> { Assert.stub(subject, :withargs).with(1, 2){ } }).raises
+      assert_that{ Assert.stub(subject, :withargs).with{} }.raises
+      assert_that{ Assert.stub(subject, :withargs).with(1, 2){} }.raises
 
-      assert_that(-> { Assert.stub(subject, :minargs).with{ } }).raises
-      assert_that(-> { Assert.stub(subject, :minargs).with(1){ } }).raises
+      assert_that{ Assert.stub(subject, :minargs).with{} }.raises
+      assert_that{ Assert.stub(subject, :minargs).with(1){} }.raises
 
-      assert_that(-> { Assert.stub(subject, :withblock).with(1){ } }).raises
+      assert_that{ Assert.stub(subject, :withblock).with(1){} }.raises
     end
 
     should "not allow calling methods with invalid arity" do
-      assert_that(-> { subject.noargs(1) }).raises
+      assert_that{ subject.noargs(1) }.raises
 
-      assert_that(-> { subject.withargs }).raises
-      assert_that(-> { subject.withargs(1, 2) }).raises
+      assert_that{ subject.withargs }.raises
+      assert_that{ subject.withargs(1, 2) }.raises
 
-      assert_that(-> { subject.minargs }).raises
-      assert_that(-> { subject.minargs(1) }).raises
+      assert_that{ subject.minargs }.raises
+      assert_that{ subject.minargs(1) }.raises
 
-      assert_that(-> { subject.withblock(1) }).raises
+      assert_that{ subject.withblock(1) }.raises
     end
   end
 
   class ClassTests < SystemTests
     desc "for singleton methods on a class"
-    subject { class1 }
+    subject{ TestClass }
 
     setup do
-      Assert.stub(class1, :noargs){ "default" }
-      Assert.stub(class1, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(class1, :withargs){ "default" }
-      Assert.stub(class1, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(class1, :anyargs){ "default" }
-      Assert.stub(class1, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      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(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(class1, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
 
-    let(:class1) { TestClass }
-
     should "allow stubbing a method that doesn't take args" do
       assert_that(subject.noargs).equals("none")
     end
@@ -131,53 +129,51 @@ class Assert::Stub
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_that(-> { Assert.stub(subject, :noargs).with(1){ } }).raises
+      assert_that{ Assert.stub(subject, :noargs).with(1){} }.raises
 
-      assert_that(-> { Assert.stub(subject, :withargs).with{ } }).raises
-      assert_that(-> { Assert.stub(subject, :withargs).with(1, 2){ } }).raises
+      assert_that{ Assert.stub(subject, :withargs).with{} }.raises
+      assert_that{ Assert.stub(subject, :withargs).with(1, 2){} }.raises
 
-      assert_that(-> { Assert.stub(subject, :minargs).with{ } }).raises
-      assert_that(-> { Assert.stub(subject, :minargs).with(1){ } }).raises
+      assert_that{ Assert.stub(subject, :minargs).with{} }.raises
+      assert_that{ Assert.stub(subject, :minargs).with(1){} }.raises
 
-      assert_that(-> { Assert.stub(subject, :withblock).with(1){ } }).raises
+      assert_that{ Assert.stub(subject, :withblock).with(1){} }.raises
     end
 
     should "not allow calling methods with invalid arity" do
-      assert_that(-> { subject.noargs(1) }).raises
+      assert_that{ subject.noargs(1) }.raises
 
-      assert_that(-> { subject.withargs }).raises
-      assert_that(-> { subject.withargs(1, 2) }).raises
+      assert_that{ subject.withargs }.raises
+      assert_that{ subject.withargs(1, 2) }.raises
 
-      assert_that(-> { subject.minargs }).raises
-      assert_that(-> { subject.minargs(1) }).raises
+      assert_that{ subject.minargs }.raises
+      assert_that{ subject.minargs(1) }.raises
 
-      assert_that(-> { subject.withblock(1) }).raises
+      assert_that{ subject.withblock(1) }.raises
     end
   end
 
   class ModuleTests < SystemTests
     desc "for singleton methods on a module"
-    subject { module1 }
+    subject{ TestModule }
 
     setup do
-      Assert.stub(module1, :noargs){ "default" }
-      Assert.stub(module1, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(module1, :withargs){ "default" }
-      Assert.stub(module1, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(module1, :anyargs){ "default" }
-      Assert.stub(module1, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      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(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(module1, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
 
-    let(:module1) { TestModule }
-
     should "allow stubbing a method that doesn't take args" do
       assert_that(subject.noargs).equals("none")
     end
@@ -206,53 +202,51 @@ class Assert::Stub
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_that(-> { Assert.stub(subject, :noargs).with(1){ } }).raises
+      assert_that{ Assert.stub(subject, :noargs).with(1){} }.raises
 
-      assert_that(-> { Assert.stub(subject, :withargs).with{ } }).raises
-      assert_that(-> { Assert.stub(subject, :withargs).with(1, 2){ } }).raises
+      assert_that{ Assert.stub(subject, :withargs).with{} }.raises
+      assert_that{ Assert.stub(subject, :withargs).with(1, 2){} }.raises
 
-      assert_that(-> { Assert.stub(subject, :minargs).with{ } }).raises
-      assert_that(-> { Assert.stub(subject, :minargs).with(1){ } }).raises
+      assert_that{ Assert.stub(subject, :minargs).with{} }.raises
+      assert_that{ Assert.stub(subject, :minargs).with(1){} }.raises
 
-      assert_that(-> { Assert.stub(subject, :withblock).with(1){ } }).raises
+      assert_that{ Assert.stub(subject, :withblock).with(1){} }.raises
     end
 
     should "not allow calling methods with invalid arity" do
-      assert_that(-> { subject.noargs(1) }).raises
+      assert_that{ subject.noargs(1) }.raises
 
-      assert_that(-> { subject.withargs }).raises
-      assert_that(-> { subject.withargs(1, 2) }).raises
+      assert_that{ subject.withargs }.raises
+      assert_that{ subject.withargs(1, 2) }.raises
 
-      assert_that(-> { subject.minargs }).raises
-      assert_that(-> { subject.minargs(1) }).raises
+      assert_that{ subject.minargs }.raises
+      assert_that{ subject.minargs(1) }.raises
 
-      assert_that(-> { subject.withblock(1) }).raises
+      assert_that{ subject.withblock(1) }.raises
     end
   end
 
   class ExtendedTests < SystemTests
     desc "for extended methods"
-    subject { class1 }
+    subject{ Class.new{ extend TestMixin } }
 
     setup do
-      Assert.stub(class1, :noargs){ "default" }
-      Assert.stub(class1, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(class1, :withargs){ "default" }
-      Assert.stub(class1, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(class1, :anyargs){ "default" }
-      Assert.stub(class1, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      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(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(class1, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
 
-    let(:class1) { Class.new{ extend TestMixin } }
-
     should "allow stubbing a method that doesn't take args" do
       assert_that(subject.noargs).equals("none")
     end
@@ -281,53 +275,53 @@ class Assert::Stub
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_that(-> { Assert.stub(subject, :noargs).with(1){ } }).raises
+      assert_that{ Assert.stub(subject, :noargs).with(1){} }.raises
 
-      assert_that(-> { Assert.stub(subject, :withargs).with{ } }).raises
-      assert_that(-> { Assert.stub(subject, :withargs).with(1, 2){ } }).raises
+      assert_that{ Assert.stub(subject, :withargs).with{} }.raises
+      assert_that{ Assert.stub(subject, :withargs).with(1, 2){} }.raises
 
-      assert_that(-> { Assert.stub(subject, :minargs).with{ } }).raises
-      assert_that(-> { Assert.stub(subject, :minargs).with(1){ } }).raises
+      assert_that{ Assert.stub(subject, :minargs).with{} }.raises
+      assert_that{ Assert.stub(subject, :minargs).with(1){} }.raises
 
-      assert_that(-> { Assert.stub(subject, :withblock).with(1){ } }).raises
+      assert_that{ Assert.stub(subject, :withblock).with(1){} }.raises
     end
 
     should "not allow calling methods with invalid arity" do
-      assert_that(-> { subject.noargs(1) }).raises
+      assert_that{ subject.noargs(1) }.raises
 
-      assert_that(-> { subject.withargs }).raises
-      assert_that(-> { subject.withargs(1, 2) }).raises
+      assert_that{ subject.withargs }.raises
+      assert_that{ subject.withargs(1, 2) }.raises
 
-      assert_that(-> { subject.minargs }).raises
-      assert_that(-> { subject.minargs(1) }).raises
+      assert_that{ subject.minargs }.raises
+      assert_that{ subject.minargs(1) }.raises
 
-      assert_that(-> { subject.withblock(1) }).raises
+      assert_that{ subject.withblock(1) }.raises
     end
   end
 
   class IncludedTests < SystemTests
     desc "for an included method"
-    subject { instance1 }
+    subject do
+      Class.new{ include TestMixin }.new
+    end
 
     setup do
-      Assert.stub(instance1, :noargs){ "default" }
-      Assert.stub(instance1, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(instance1, :withargs){ "default" }
-      Assert.stub(instance1, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(instance1, :anyargs){ "default" }
-      Assert.stub(instance1, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      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(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(instance1, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
 
-    let(:instance1) { Class.new { include TestMixin }.new }
-
     should "allow stubbing a method that doesn't take args" do
       assert_that(subject.noargs).equals("none")
     end
@@ -356,53 +350,51 @@ class Assert::Stub
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_that(-> { Assert.stub(subject, :noargs).with(1){ } }).raises
+      assert_that{ Assert.stub(subject, :noargs).with(1){} }.raises
 
-      assert_that(-> { Assert.stub(subject, :withargs).with{ } }).raises
-      assert_that(-> { Assert.stub(subject, :withargs).with(1, 2){ } }).raises
+      assert_that{ Assert.stub(subject, :withargs).with{} }.raises
+      assert_that{ Assert.stub(subject, :withargs).with(1, 2){} }.raises
 
-      assert_that(-> { Assert.stub(subject, :minargs).with{ } }).raises
-      assert_that(-> { Assert.stub(subject, :minargs).with(1){ } }).raises
+      assert_that{ Assert.stub(subject, :minargs).with{} }.raises
+      assert_that{ Assert.stub(subject, :minargs).with(1){} }.raises
 
-      assert_that(-> { Assert.stub(subject, :withblock).with(1){ } }).raises
+      assert_that{ Assert.stub(subject, :withblock).with(1){} }.raises
     end
 
     should "not allow calling methods with invalid arity" do
-      assert_that(-> { subject.noargs(1) }).raises
+      assert_that{ subject.noargs(1) }.raises
 
-      assert_that(-> { subject.withargs }).raises
-      assert_that(-> { subject.withargs(1, 2) }).raises
+      assert_that{ subject.withargs }.raises
+      assert_that{ subject.withargs(1, 2) }.raises
 
-      assert_that(-> { subject.minargs }).raises
-      assert_that(-> { subject.minargs(1) }).raises
+      assert_that{ subject.minargs }.raises
+      assert_that{ subject.minargs(1) }.raises
 
-      assert_that(-> { subject.withblock(1) }).raises
+      assert_that{ subject.withblock(1) }.raises
     end
   end
 
   class InheritedClassTests < SystemTests
     desc "for an inherited class method"
-    subject { class1 }
+    subject{ Class.new(TestClass) }
 
     setup do
-      Assert.stub(class1, :noargs){ "default" }
-      Assert.stub(class1, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(class1, :withargs){ "default" }
-      Assert.stub(class1, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(class1, :anyargs){ "default" }
-      Assert.stub(class1, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      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(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(class1, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
 
-    let(:class1) { Class.new(TestClass) }
-
     should "allow stubbing a method that doesn't take args" do
       assert_that(subject.noargs).equals("none")
     end
@@ -431,53 +423,51 @@ class Assert::Stub
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_that(-> { Assert.stub(subject, :noargs).with(1){ } }).raises
+      assert_that{ Assert.stub(subject, :noargs).with(1){} }.raises
 
-      assert_that(-> { Assert.stub(subject, :withargs).with{ } }).raises
-      assert_that(-> { Assert.stub(subject, :withargs).with(1, 2){ } }).raises
+      assert_that{ Assert.stub(subject, :withargs).with{} }.raises
+      assert_that{ Assert.stub(subject, :withargs).with(1, 2){} }.raises
 
-      assert_that(-> { Assert.stub(subject, :minargs).with{ } }).raises
-      assert_that(-> { Assert.stub(subject, :minargs).with(1){ } }).raises
+      assert_that{ Assert.stub(subject, :minargs).with{} }.raises
+      assert_that{ Assert.stub(subject, :minargs).with(1){} }.raises
 
-      assert_that(-> { Assert.stub(subject, :withblock).with(1){ } }).raises
+      assert_that{ Assert.stub(subject, :withblock).with(1){} }.raises
     end
 
     should "not allow calling methods with invalid arity" do
-      assert_that(-> { subject.noargs(1) }).raises
+      assert_that{ subject.noargs(1) }.raises
 
-      assert_that(-> { subject.withargs }).raises
-      assert_that(-> { subject.withargs(1, 2) }).raises
+      assert_that{ subject.withargs }.raises
+      assert_that{ subject.withargs(1, 2) }.raises
 
-      assert_that(-> { subject.minargs }).raises
-      assert_that(-> { subject.minargs(1) }).raises
+      assert_that{ subject.minargs }.raises
+      assert_that{ subject.minargs(1) }.raises
 
-      assert_that(-> { subject.withblock(1) }).raises
+      assert_that{ subject.withblock(1) }.raises
     end
   end
 
   class InheritedInstanceTests < SystemTests
     desc "for an inherited instance method"
-    subject { instance1 }
+    subject{ Class.new(TestClass).new }
 
     setup do
-      Assert.stub(instance1, :noargs){ "default" }
-      Assert.stub(instance1, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(instance1, :withargs){ "default" }
-      Assert.stub(instance1, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(instance1, :anyargs){ "default" }
-      Assert.stub(instance1, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      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(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(instance1, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
 
-    let(:instance1) { Class.new(TestClass).new }
-
     should "allow stubbing a method that doesn't take args" do
       assert_that(subject.noargs).equals("none")
     end
@@ -506,53 +496,51 @@ class Assert::Stub
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_that(-> { Assert.stub(subject, :noargs).with(1){ } }).raises
+      assert_that{ Assert.stub(subject, :noargs).with(1){} }.raises
 
-      assert_that(-> { Assert.stub(subject, :withargs).with{ } }).raises
-      assert_that(-> { Assert.stub(subject, :withargs).with(1, 2){ } }).raises
+      assert_that{ Assert.stub(subject, :withargs).with{} }.raises
+      assert_that{ Assert.stub(subject, :withargs).with(1, 2){} }.raises
 
-      assert_that(-> { Assert.stub(subject, :minargs).with{ } }).raises
-      assert_that(-> { Assert.stub(subject, :minargs).with(1){ } }).raises
+      assert_that{ Assert.stub(subject, :minargs).with{} }.raises
+      assert_that{ Assert.stub(subject, :minargs).with(1){} }.raises
 
-      assert_that(-> { Assert.stub(subject, :withblock).with(1){ } }).raises
+      assert_that{ Assert.stub(subject, :withblock).with(1){} }.raises
     end
 
     should "not allow calling methods with invalid arity" do
-      assert_that(-> { subject.noargs(1) }).raises
+      assert_that{ subject.noargs(1) }.raises
 
-      assert_that(-> { subject.withargs }).raises
-      assert_that(-> { subject.withargs(1, 2) }).raises
+      assert_that{ subject.withargs }.raises
+      assert_that{ subject.withargs(1, 2) }.raises
 
-      assert_that(-> { subject.minargs }).raises
-      assert_that(-> { subject.minargs(1) }).raises
+      assert_that{ subject.minargs }.raises
+      assert_that{ subject.minargs(1) }.raises
 
-      assert_that(-> { subject.withblock(1) }).raises
+      assert_that{ subject.withblock(1) }.raises
     end
   end
 
   class DelegateClassTests < SystemTests
     desc "a class that delegates another object"
-    subject { class1 }
+    subject{ DelegateClass }
 
     setup do
-      Assert.stub(class1, :noargs){ "default" }
-      Assert.stub(class1, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(class1, :withargs){ "default" }
-      Assert.stub(class1, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(class1, :anyargs){ "default" }
-      Assert.stub(class1, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      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(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(class1, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
 
-    let(:class1) { DelegateClass }
-
     should "allow stubbing a method that doesn't take args" do
       assert_that(subject.noargs).equals("none")
     end
@@ -581,53 +569,51 @@ class Assert::Stub
     end
 
     should "allow stubbing methods with invalid arity" do
-      assert_that(-> { Assert.stub(subject, :noargs).with(1){ } }).does_not_raise
+      assert_that{ Assert.stub(subject, :noargs).with(1){} }.does_not_raise
 
-      assert_that(-> { Assert.stub(subject, :withargs).with{ } }).does_not_raise
-      assert_that(-> { Assert.stub(subject, :withargs).with(1, 2){ } }).does_not_raise
+      assert_that{ Assert.stub(subject, :withargs).with{} }.does_not_raise
+      assert_that{ Assert.stub(subject, :withargs).with(1, 2){} }.does_not_raise
 
-      assert_that(-> { Assert.stub(subject, :minargs).with{ } }).does_not_raise
-      assert_that(-> { Assert.stub(subject, :minargs).with(1){ } }).does_not_raise
+      assert_that{ Assert.stub(subject, :minargs).with{} }.does_not_raise
+      assert_that{ Assert.stub(subject, :minargs).with(1){} }.does_not_raise
 
-      assert_that(-> { Assert.stub(subject, :withblock).with(1){ } }).does_not_raise
+      assert_that{ Assert.stub(subject, :withblock).with(1){} }.does_not_raise
     end
 
     should "allow calling methods with invalid arity" do
-      assert_that(-> { subject.noargs(1) }).does_not_raise
+      assert_that{ subject.noargs(1) }.does_not_raise
 
-      assert_that(-> { subject.withargs }).does_not_raise
-      assert_that(-> { subject.withargs(1, 2) }).does_not_raise
+      assert_that{ subject.withargs }.does_not_raise
+      assert_that{ subject.withargs(1, 2) }.does_not_raise
 
-      assert_that(-> { subject.minargs }).does_not_raise
-      assert_that(-> { subject.minargs(1) }).does_not_raise
+      assert_that{ subject.minargs }.does_not_raise
+      assert_that{ subject.minargs(1) }.does_not_raise
 
-      assert_that(-> { subject.withblock(1) }).does_not_raise
+      assert_that{ subject.withblock(1) }.does_not_raise
     end
   end
 
   class DelegateInstanceTests < SystemTests
     desc "an instance that delegates another object"
-    subject { instance1 }
+    subject{ DelegateClass.new }
 
     setup do
-      Assert.stub(instance1, :noargs){ "default" }
-      Assert.stub(instance1, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(instance1, :withargs){ "default" }
-      Assert.stub(instance1, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(instance1, :anyargs){ "default" }
-      Assert.stub(instance1, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      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(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(instance1, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
 
-    let(:instance1) { DelegateClass.new }
-
     should "allow stubbing a method that doesn't take args" do
       assert_that(subject.noargs).equals("none")
     end
@@ -656,27 +642,27 @@ class Assert::Stub
     end
 
     should "allow stubbing methods with invalid arity" do
-      assert_that(-> { Assert.stub(subject, :noargs).with(1){ } }).does_not_raise
+      assert_that{ Assert.stub(subject, :noargs).with(1){} }.does_not_raise
 
-      assert_that(-> { Assert.stub(subject, :withargs).with{ } }).does_not_raise
-      assert_that(-> { Assert.stub(subject, :withargs).with(1, 2){ } }).does_not_raise
+      assert_that{ Assert.stub(subject, :withargs).with{} }.does_not_raise
+      assert_that{ Assert.stub(subject, :withargs).with(1, 2){} }.does_not_raise
 
-      assert_that(-> { Assert.stub(subject, :minargs).with{ } }).does_not_raise
-      assert_that(-> { Assert.stub(subject, :minargs).with(1){ } }).does_not_raise
+      assert_that{ Assert.stub(subject, :minargs).with{} }.does_not_raise
+      assert_that{ Assert.stub(subject, :minargs).with(1){} }.does_not_raise
 
-      assert_that(-> { Assert.stub(subject, :withblock).with(1){ } }).does_not_raise
+      assert_that{ Assert.stub(subject, :withblock).with(1){} }.does_not_raise
     end
 
     should "allow calling methods with invalid arity" do
-      assert_that(-> { subject.noargs(1) }).does_not_raise
+      assert_that{ subject.noargs(1) }.does_not_raise
 
-      assert_that(-> { subject.withargs }).does_not_raise
-      assert_that(-> { subject.withargs(1, 2) }).does_not_raise
+      assert_that{ subject.withargs }.does_not_raise
+      assert_that{ subject.withargs(1, 2) }.does_not_raise
 
-      assert_that(-> { subject.minargs }).does_not_raise
-      assert_that(-> { subject.minargs(1) }).does_not_raise
+      assert_that{ subject.minargs }.does_not_raise
+      assert_that{ subject.minargs(1) }.does_not_raise
 
-      assert_that(-> { subject.withblock(1) }).does_not_raise
+      assert_that{ subject.withblock(1) }.does_not_raise
     end
   end
 
@@ -687,8 +673,8 @@ class Assert::Stub
       Assert.stub(child_class, :new){ "child" }
     end
 
-    let(:parent_class) { Class.new }
-    let(:child_class) { Class.new(parent_class) }
+    let(:parent_class){ Class.new }
+    let(:child_class){ Class.new(parent_class) }
 
     should "allow stubbing the methods individually" do
       assert_that(parent_class.new).equals("parent")
@@ -697,37 +683,73 @@ class Assert::Stub
   end
 
   class TestClass
-    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
-
-    def noargs; end
-    def withargs(a); end
-    def anyargs(*args); end
-    def minargs(a, b, *args); end
-    def withblock(&block); end
+    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
+
+    def noargs
+    end
+
+    def withargs(a)
+    end
+
+    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
+    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
+    def noargs
+    end
+
+    def withargs(a)
+    end
+
+    def anyargs(*args)
+    end
+
+    def minargs(a, b, *args)
+    end
+
+    def withblock(&block)
+    end
   end
 
   class DelegateClass
-    def self.respond_to?(*args)
+    def self.respond_to_missing?(*args)
       TestClass.respond_to?(*args) || super
     end
 
@@ -739,7 +761,7 @@ class Assert::Stub
       @delegate = TestClass.new
     end
 
-    def respond_to?(*args)
+    def respond_to_missing?(*args)
       @delegate.respond_to?(*args) || super
     end