assert 2.16.5 → 2.17.0

data/lib/assert/version.rb

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

data/lib/assert/view.rb

@@ -1,7 +1,7 @@
-require 'assert/config'
-require 'assert/config_helpers'
-require 'assert/suite'
-require 'assert/view_helpers'
+require "assert/config"
+require "assert/config_helpers"
+require "assert/suite"
+require "assert/view_helpers"
 
 module Assert
 
@@ -15,12 +15,12 @@ module Assert
 
     def self.require_user_view(view_name)
       views_file = File.expand_path(
-        File.join("#{ENV['HOME']}/.assert/views", view_name, 'lib', view_name)
+        File.join("#{ENV["HOME"]}/.assert/views", view_name, "lib", view_name)
       )
 
-      if File.exists?(view_name) || File.exists?(view_name + '.rb')
+      if File.exists?(view_name) || File.exists?(view_name + ".rb")
         require view_name
-      elsif File.exists?(views_file + '.rb')
+      elsif File.exists?(views_file + ".rb")
         require views_file
       else
         msg = "[WARN] Can't find or require #{view_name.inspect} view."
@@ -31,18 +31,18 @@ module Assert
 
     # setup options and their default values
 
-    option 'styled',        false
-    option 'pass_styles'    # none
-    option 'fail_styles'    # none
-    option 'error_styles'   # none
-    option 'skip_styles'    # none
-    option 'ignore_styles'  # none
-
-    option 'pass_abbrev',   '.'
-    option 'fail_abbrev',   'F'
-    option 'ignore_abbrev', 'I'
-    option 'skip_abbrev',   'S'
-    option 'error_abbrev',  'E'
+    option "styled",        false
+    option "pass_styles"    # none
+    option "fail_styles"    # none
+    option "error_styles"   # none
+    option "skip_styles"    # none
+    option "ignore_styles"  # none
+
+    option "pass_abbrev",   "."
+    option "fail_abbrev",   "F"
+    option "ignore_abbrev", "I"
+    option "skip_abbrev",   "S"
+    option "error_abbrev",  "E"
 
     attr_reader :config
 

data/lib/assert/view_helpers.rb

@@ -1,4 +1,4 @@
-require 'assert/config_helpers'
+require "assert/config_helpers"
 
 module Assert
 
@@ -37,21 +37,21 @@ module Assert
 
       # show any captured output
       def re_run_test_cmd(test_id)
-        "assert -t #{test_id.gsub(Dir.pwd, '.')}"
+        "assert -t #{test_id.gsub(Dir.pwd, ".")}"
       end
 
       def tests_to_run_count_statement
-        "#{self.tests_to_run_count} test#{'s' if self.tests_to_run_count != 1}"
+        "#{self.tests_to_run_count} test#{"s" if self.tests_to_run_count != 1}"
       end
 
       def result_count_statement
-        "#{self.result_count} result#{'s' if self.result_count != 1}"
+        "#{self.result_count} result#{"s" if self.result_count != 1}"
       end
 
       # generate a comma-seperated sentence fragment given a list of items
       def to_sentence(items)
         if items.size <= 2
-          items.join(items.size == 2 ? ' and ' : '')
+          items.join(items.size == 2 ? " and " : "")
         else
           [items[0..-2].join(", "), items.last].join(", and ")
         end
@@ -173,7 +173,7 @@ module Assert
       }
 
       def self.code_for(*style_names)
-        style_names.map{ |n| "\e[#{CODES[n]}m" if CODES.key?(n) }.compact.join('')
+        style_names.map{ |n| "\e[#{CODES[n]}m" if CODES.key?(n) }.compact.join("")
       end
 
       def ansi_styled_msg(msg, result_type)

data/test/helper.rb

@@ -6,17 +6,8 @@ ROOT_PATH = File.expand_path("../..", __FILE__)
 $LOAD_PATH.unshift(ROOT_PATH)
 
 # require pry for debugging (`binding.pry`)
-require 'pry'
-require 'test/support/factory'
-
-# 1.8.7 backfills
-
-# Array#sample
-if !(a = Array.new).respond_to?(:sample) && a.respond_to?(:choice)
-  class Array
-    alias_method :sample, :choice
-  end
-end
+require "pry"
+require "test/support/factory"
 
 class Assert::Test
 

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

data/test/system/stub_tests.rb

@@ -1,5 +1,5 @@
-require 'assert'
-require 'assert/stub'
+require "assert"
+require "assert/stub"
 
 class Assert::Stub
 
@@ -12,48 +12,48 @@ class Assert::Stub
     desc "for instance methods"
     setup do
       @instance = TestClass.new
-      Assert.stub(@instance, :noargs){ 'default' }
-      Assert.stub(@instance, :noargs).with{ 'none' }
+      Assert.stub(@instance, :noargs){ "default" }
+      Assert.stub(@instance, :noargs).with{ "none" }
 
-      Assert.stub(@instance, :withargs){ 'default' }
-      Assert.stub(@instance, :withargs).with(1){ 'one' }
+      Assert.stub(@instance, :withargs){ "default" }
+      Assert.stub(@instance, :withargs).with(1){ "one" }
 
-      Assert.stub(@instance, :anyargs){ 'default' }
-      Assert.stub(@instance, :anyargs).with(1, 2){ 'one-two' }
+      Assert.stub(@instance, :anyargs){ "default" }
+      Assert.stub(@instance, :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(@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(@instance, :withblock){ 'default' }
+      Assert.stub(@instance, :withblock){ "default" }
     end
     subject{ @instance }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal 'none', subject.noargs
+      assert_equal "none", subject.noargs
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal 'one',     subject.withargs(1)
-      assert_equal 'default', subject.withargs(2)
+      assert_equal "one",     subject.withargs(1)
+      assert_equal "default", subject.withargs(2)
     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_equal "default", subject.anyargs
+      assert_equal "default", subject.anyargs(1)
+      assert_equal "one-two", subject.anyargs(1, 2)
     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_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)
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal 'default', subject.withblock
-      assert_equal 'default', subject.withblock{ 'my-block' }
+      assert_equal "default", subject.withblock
+      assert_equal "default", subject.withblock{ "my-block" }
     end
 
     should "not allow stubbing methods with invalid arity" do
@@ -86,48 +86,48 @@ class Assert::Stub
     desc "for singleton methods on a class"
     setup do
       @class = TestClass
-      Assert.stub(@class, :noargs){ 'default' }
-      Assert.stub(@class, :noargs).with{ 'none' }
+      Assert.stub(@class, :noargs){ "default" }
+      Assert.stub(@class, :noargs).with{ "none" }
 
-      Assert.stub(@class, :withargs){ 'default' }
-      Assert.stub(@class, :withargs).with(1){ 'one' }
+      Assert.stub(@class, :withargs){ "default" }
+      Assert.stub(@class, :withargs).with(1){ "one" }
 
-      Assert.stub(@class, :anyargs){ 'default' }
-      Assert.stub(@class, :anyargs).with(1, 2){ 'one-two' }
+      Assert.stub(@class, :anyargs){ "default" }
+      Assert.stub(@class, :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(@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(@class, :withblock){ 'default' }
+      Assert.stub(@class, :withblock){ "default" }
     end
     subject{ @class }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal 'none', subject.noargs
+      assert_equal "none", subject.noargs
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal 'one',     subject.withargs(1)
-      assert_equal 'default', subject.withargs(2)
+      assert_equal "one",     subject.withargs(1)
+      assert_equal "default", subject.withargs(2)
     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_equal "default", subject.anyargs
+      assert_equal "default", subject.anyargs(1)
+      assert_equal "one-two", subject.anyargs(1, 2)
     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_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)
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal 'default', subject.withblock
-      assert_equal 'default', subject.withblock{ 'my-block' }
+      assert_equal "default", subject.withblock
+      assert_equal "default", subject.withblock{ "my-block" }
     end
 
     should "not allow stubbing methods with invalid arity" do
@@ -160,48 +160,48 @@ class Assert::Stub
     desc "for singleton methods on a module"
     setup do
       @module = TestModule
-      Assert.stub(@module, :noargs){ 'default' }
-      Assert.stub(@module, :noargs).with{ 'none' }
+      Assert.stub(@module, :noargs){ "default" }
+      Assert.stub(@module, :noargs).with{ "none" }
 
-      Assert.stub(@module, :withargs){ 'default' }
-      Assert.stub(@module, :withargs).with(1){ 'one' }
+      Assert.stub(@module, :withargs){ "default" }
+      Assert.stub(@module, :withargs).with(1){ "one" }
 
-      Assert.stub(@module, :anyargs){ 'default' }
-      Assert.stub(@module, :anyargs).with(1, 2){ 'one-two' }
+      Assert.stub(@module, :anyargs){ "default" }
+      Assert.stub(@module, :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(@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(@module, :withblock){ 'default' }
+      Assert.stub(@module, :withblock){ "default" }
     end
     subject{ @module }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal 'none', subject.noargs
+      assert_equal "none", subject.noargs
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal 'one',     subject.withargs(1)
-      assert_equal 'default', subject.withargs(2)
+      assert_equal "one",     subject.withargs(1)
+      assert_equal "default", subject.withargs(2)
     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_equal "default", subject.anyargs
+      assert_equal "default", subject.anyargs(1)
+      assert_equal "one-two", subject.anyargs(1, 2)
     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_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)
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal 'default', subject.withblock
-      assert_equal 'default', subject.withblock{ 'my-block' }
+      assert_equal "default", subject.withblock
+      assert_equal "default", subject.withblock{ "my-block" }
     end
 
     should "not allow stubbing methods with invalid arity" do
@@ -234,48 +234,48 @@ class Assert::Stub
     desc "for extended methods"
     setup do
       @class = Class.new{ extend TestMixin }
-      Assert.stub(@class, :noargs){ 'default' }
-      Assert.stub(@class, :noargs).with{ 'none' }
+      Assert.stub(@class, :noargs){ "default" }
+      Assert.stub(@class, :noargs).with{ "none" }
 
-      Assert.stub(@class, :withargs){ 'default' }
-      Assert.stub(@class, :withargs).with(1){ 'one' }
+      Assert.stub(@class, :withargs){ "default" }
+      Assert.stub(@class, :withargs).with(1){ "one" }
 
-      Assert.stub(@class, :anyargs){ 'default' }
-      Assert.stub(@class, :anyargs).with(1, 2){ 'one-two' }
+      Assert.stub(@class, :anyargs){ "default" }
+      Assert.stub(@class, :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(@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(@class, :withblock){ 'default' }
+      Assert.stub(@class, :withblock){ "default" }
     end
     subject{ @class }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal 'none', subject.noargs
+      assert_equal "none", subject.noargs
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal 'one',     subject.withargs(1)
-      assert_equal 'default', subject.withargs(2)
+      assert_equal "one",     subject.withargs(1)
+      assert_equal "default", subject.withargs(2)
     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_equal "default", subject.anyargs
+      assert_equal "default", subject.anyargs(1)
+      assert_equal "one-two", subject.anyargs(1, 2)
     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_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)
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal 'default', subject.withblock
-      assert_equal 'default', subject.withblock{ 'my-block' }
+      assert_equal "default", subject.withblock
+      assert_equal "default", subject.withblock{ "my-block" }
     end
 
     should "not allow stubbing methods with invalid arity" do
@@ -309,48 +309,48 @@ class Assert::Stub
     setup do
       @class = Class.new{ include TestMixin }
       @instance = @class.new
-      Assert.stub(@instance, :noargs){ 'default' }
-      Assert.stub(@instance, :noargs).with{ 'none' }
+      Assert.stub(@instance, :noargs){ "default" }
+      Assert.stub(@instance, :noargs).with{ "none" }
 
-      Assert.stub(@instance, :withargs){ 'default' }
-      Assert.stub(@instance, :withargs).with(1){ 'one' }
+      Assert.stub(@instance, :withargs){ "default" }
+      Assert.stub(@instance, :withargs).with(1){ "one" }
 
-      Assert.stub(@instance, :anyargs){ 'default' }
-      Assert.stub(@instance, :anyargs).with(1, 2){ 'one-two' }
+      Assert.stub(@instance, :anyargs){ "default" }
+      Assert.stub(@instance, :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(@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(@instance, :withblock){ 'default' }
+      Assert.stub(@instance, :withblock){ "default" }
     end
     subject{ @instance }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal 'none', subject.noargs
+      assert_equal "none", subject.noargs
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal 'one',     subject.withargs(1)
-      assert_equal 'default', subject.withargs(2)
+      assert_equal "one",     subject.withargs(1)
+      assert_equal "default", subject.withargs(2)
     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_equal "default", subject.anyargs
+      assert_equal "default", subject.anyargs(1)
+      assert_equal "one-two", subject.anyargs(1, 2)
     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_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)
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal 'default', subject.withblock
-      assert_equal 'default', subject.withblock{ 'my-block' }
+      assert_equal "default", subject.withblock
+      assert_equal "default", subject.withblock{ "my-block" }
     end
 
     should "not allow stubbing methods with invalid arity" do
@@ -383,48 +383,48 @@ class Assert::Stub
     desc "for an inherited class method"
     setup do
       @class = Class.new(TestClass)
-      Assert.stub(@class, :noargs){ 'default' }
-      Assert.stub(@class, :noargs).with{ 'none' }
+      Assert.stub(@class, :noargs){ "default" }
+      Assert.stub(@class, :noargs).with{ "none" }
 
-      Assert.stub(@class, :withargs){ 'default' }
-      Assert.stub(@class, :withargs).with(1){ 'one' }
+      Assert.stub(@class, :withargs){ "default" }
+      Assert.stub(@class, :withargs).with(1){ "one" }
 
-      Assert.stub(@class, :anyargs){ 'default' }
-      Assert.stub(@class, :anyargs).with(1, 2){ 'one-two' }
+      Assert.stub(@class, :anyargs){ "default" }
+      Assert.stub(@class, :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(@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(@class, :withblock){ 'default' }
+      Assert.stub(@class, :withblock){ "default" }
     end
     subject{ @class }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal 'none', subject.noargs
+      assert_equal "none", subject.noargs
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal 'one',     subject.withargs(1)
-      assert_equal 'default', subject.withargs(2)
+      assert_equal "one",     subject.withargs(1)
+      assert_equal "default", subject.withargs(2)
     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_equal "default", subject.anyargs
+      assert_equal "default", subject.anyargs(1)
+      assert_equal "one-two", subject.anyargs(1, 2)
     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_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)
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal 'default', subject.withblock
-      assert_equal 'default', subject.withblock{ 'my-block' }
+      assert_equal "default", subject.withblock
+      assert_equal "default", subject.withblock{ "my-block" }
     end
 
     should "not allow stubbing methods with invalid arity" do
@@ -458,48 +458,48 @@ class Assert::Stub
     setup do
       @class = Class.new(TestClass)
       @instance = @class.new
-      Assert.stub(@instance, :noargs){ 'default' }
-      Assert.stub(@instance, :noargs).with{ 'none' }
+      Assert.stub(@instance, :noargs){ "default" }
+      Assert.stub(@instance, :noargs).with{ "none" }
 
-      Assert.stub(@instance, :withargs){ 'default' }
-      Assert.stub(@instance, :withargs).with(1){ 'one' }
+      Assert.stub(@instance, :withargs){ "default" }
+      Assert.stub(@instance, :withargs).with(1){ "one" }
 
-      Assert.stub(@instance, :anyargs){ 'default' }
-      Assert.stub(@instance, :anyargs).with(1, 2){ 'one-two' }
+      Assert.stub(@instance, :anyargs){ "default" }
+      Assert.stub(@instance, :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(@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(@instance, :withblock){ 'default' }
+      Assert.stub(@instance, :withblock){ "default" }
     end
     subject{ @instance }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal 'none', subject.noargs
+      assert_equal "none", subject.noargs
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal 'one',     subject.withargs(1)
-      assert_equal 'default', subject.withargs(2)
+      assert_equal "one",     subject.withargs(1)
+      assert_equal "default", subject.withargs(2)
     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_equal "default", subject.anyargs
+      assert_equal "default", subject.anyargs(1)
+      assert_equal "one-two", subject.anyargs(1, 2)
     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_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)
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal 'default', subject.withblock
-      assert_equal 'default', subject.withblock{ 'my-block' }
+      assert_equal "default", subject.withblock
+      assert_equal "default", subject.withblock{ "my-block" }
     end
 
     should "not allow stubbing methods with invalid arity" do
@@ -532,48 +532,48 @@ class Assert::Stub
     desc "a class that delegates another object"
     setup do
       @class = DelegateClass
-      Assert.stub(@class, :noargs){ 'default' }
-      Assert.stub(@class, :noargs).with{ 'none' }
+      Assert.stub(@class, :noargs){ "default" }
+      Assert.stub(@class, :noargs).with{ "none" }
 
-      Assert.stub(@class, :withargs){ 'default' }
-      Assert.stub(@class, :withargs).with(1){ 'one' }
+      Assert.stub(@class, :withargs){ "default" }
+      Assert.stub(@class, :withargs).with(1){ "one" }
 
-      Assert.stub(@class, :anyargs){ 'default' }
-      Assert.stub(@class, :anyargs).with(1, 2){ 'one-two' }
+      Assert.stub(@class, :anyargs){ "default" }
+      Assert.stub(@class, :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(@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(@class, :withblock){ 'default' }
+      Assert.stub(@class, :withblock){ "default" }
     end
     subject{ @class }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal 'none', subject.noargs
+      assert_equal "none", subject.noargs
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal 'one',     subject.withargs(1)
-      assert_equal 'default', subject.withargs(2)
+      assert_equal "one",     subject.withargs(1)
+      assert_equal "default", subject.withargs(2)
     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_equal "default", subject.anyargs
+      assert_equal "default", subject.anyargs(1)
+      assert_equal "one-two", subject.anyargs(1, 2)
     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_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)
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal 'default', subject.withblock
-      assert_equal 'default', subject.withblock{ 'my-block' }
+      assert_equal "default", subject.withblock
+      assert_equal "default", subject.withblock{ "my-block" }
     end
 
     should "allow stubbing methods with invalid arity" do
@@ -606,48 +606,48 @@ class Assert::Stub
     desc "an instance that delegates another object"
     setup do
       @instance = DelegateClass.new
-      Assert.stub(@instance, :noargs){ 'default' }
-      Assert.stub(@instance, :noargs).with{ 'none' }
+      Assert.stub(@instance, :noargs){ "default" }
+      Assert.stub(@instance, :noargs).with{ "none" }
 
-      Assert.stub(@instance, :withargs){ 'default' }
-      Assert.stub(@instance, :withargs).with(1){ 'one' }
+      Assert.stub(@instance, :withargs){ "default" }
+      Assert.stub(@instance, :withargs).with(1){ "one" }
 
-      Assert.stub(@instance, :anyargs){ 'default' }
-      Assert.stub(@instance, :anyargs).with(1, 2){ 'one-two' }
+      Assert.stub(@instance, :anyargs){ "default" }
+      Assert.stub(@instance, :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(@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(@instance, :withblock){ 'default' }
+      Assert.stub(@instance, :withblock){ "default" }
     end
     subject{ @instance }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal 'none', subject.noargs
+      assert_equal "none", subject.noargs
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal 'one',     subject.withargs(1)
-      assert_equal 'default', subject.withargs(2)
+      assert_equal "one",     subject.withargs(1)
+      assert_equal "default", subject.withargs(2)
     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_equal "default", subject.anyargs
+      assert_equal "default", subject.anyargs(1)
+      assert_equal "one-two", subject.anyargs(1, 2)
     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_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)
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal 'default', subject.withblock
-      assert_equal 'default', subject.withblock{ 'my-block' }
+      assert_equal "default", subject.withblock
+      assert_equal "default", subject.withblock{ "my-block" }
     end
 
     should "allow stubbing methods with invalid arity" do
@@ -682,13 +682,13 @@ class Assert::Stub
       @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
 
     should "allow stubbing the methods individually" do
-      assert_equal 'parent', @parent_class.new
-      assert_equal 'child', @child_class.new
+      assert_equal "parent", @parent_class.new
+      assert_equal "child", @child_class.new
     end
 
   end