mocha 1.4.0 → 1.7.0

data/test/unit/mockery_test.rb

@@ -5,36 +5,50 @@ require 'mocha/expectation_error_factory'
 require 'deprecation_disabler'
 
 class MockeryTest < Mocha::TestCase
-
   include Mocha
   include DeprecationDisabler
 
-  def test_should_build_instance_of_mockery
+  def setup
+    Mockery.setup
+  end
+
+  def teardown
+    Mockery.teardown
+  end
+
+  def test_should_return_null_mockery_if_not_setup
+    Mockery.teardown
+    mockery = Mockery.instance
+    assert_not_nil mockery
+    assert_kind_of Mockery::Null, mockery
+  end
+
+  def test_should_return_instance_of_mockery
     mockery = Mockery.instance
     assert_not_nil mockery
     assert_kind_of Mockery, mockery
   end
 
   def test_should_cache_instance_of_mockery
-    mockery_1 = Mockery.instance
-    mockery_2 = Mockery.instance
-    assert_same mockery_1, mockery_2
+    mockery1 = Mockery.instance
+    mockery2 = Mockery.instance
+    assert_same mockery1, mockery2
   end
 
   def test_should_expire_mockery_instance_cache
-    mockery_1 = Mockery.instance
-    Mockery.reset_instance
-    mockery_2 = Mockery.instance
-    assert_not_same mockery_1, mockery_2
+    mockery1 = Mockery.instance
+    Mockery.teardown
+    mockery2 = Mockery.instance
+    assert_not_same mockery1, mockery2
   end
 
   def test_should_raise_expectation_error_because_not_all_expectations_are_satisfied
     mockery = Mockery.new
     disable_deprecations do
-      mock_1 = mockery.named_mock('mock-1') { expects(:method_1) }
-      mock_2 = mockery.named_mock('mock-2') { expects(:method_2) }
-      1.times { mock_1.method_1 }
-      0.times { mock_2.method_2 }
+      mock1 = mockery.named_mock('mock-1') { expects(:method_1) }
+      mock2 = mockery.named_mock('mock-2') { expects(:method_2) }
+      1.times { mock1.method_1 }
+      0.times { mock2.method_2 }
     end
     assert_raises(ExpectationErrorFactory.exception_class) { mockery.verify }
   end
@@ -56,10 +70,10 @@ class MockeryTest < Mocha::TestCase
 
   def test_should_build_new_instance_of_stubba_on_teardown
     mockery = Mockery.new
-    stubba_1 = mockery.stubba
+    stubba1 = mockery.stubba
     mockery.teardown
-    stubba_2 = mockery.stubba
-    assert_not_same stubba_1, stubba_2
+    stubba2 = mockery.stubba
+    assert_not_same stubba1, stubba2
   end
 
   def test_should_build_and_store_new_state_machine
@@ -78,8 +92,12 @@ class MockeryTest < Mocha::TestCase
 
   class FakeMethod
     def stub; end
+
     def unstub; end
-    def matches?(other); true; end
+
+    def matches?(_other)
+      true
+    end
   end
 
   def test_should_unstub_all_methods_on_teardown
@@ -93,51 +111,51 @@ class MockeryTest < Mocha::TestCase
   def test_should_display_object_id_for_mocha_inspect_if_mock_has_no_name
     mockery = Mockery.new
     mock = mockery.unnamed_mock
-    assert_match Regexp.new("^#<Mock:0x[0-9A-Fa-f]{1,12}>$"), mock.mocha_inspect
+    assert_match Regexp.new('^#<Mock:0x[0-9A-Fa-f]{1,12}>$'), mock.mocha_inspect
   end
 
   def test_should_display_object_id_for_inspect_if_mock_has_no_name
     mockery = Mockery.new
     mock = mockery.unnamed_mock
-    assert_match Regexp.new("^#<Mock:0x[0-9A-Fa-f]{1,12}>$"), mock.inspect
+    assert_match Regexp.new('^#<Mock:0x[0-9A-Fa-f]{1,12}>$'), mock.inspect
   end
 
   def test_should_display_name_for_mocha_inspect_if_mock_has_string_name
     mockery = Mockery.new
     mock = mockery.named_mock('named_mock')
-    assert_equal "#<Mock:named_mock>", mock.mocha_inspect
+    assert_equal '#<Mock:named_mock>', mock.mocha_inspect
   end
 
   def test_should_display_name_for_mocha_inspect_if_mock_has_symbol_name
     mockery = Mockery.new
     mock = mockery.named_mock(:named_mock)
-    assert_equal "#<Mock:named_mock>", mock.mocha_inspect
+    assert_equal '#<Mock:named_mock>', mock.mocha_inspect
   end
 
   def test_should_display_name_for_inspect_if_mock_has_string_name
     mockery = Mockery.new
     mock = mockery.named_mock('named_mock')
-    assert_equal "#<Mock:named_mock>", mock.inspect
+    assert_equal '#<Mock:named_mock>', mock.inspect
   end
 
   def test_should_display_name_for_inspect_if_mock_has_symbol_name
     mockery = Mockery.new
     mock = mockery.named_mock(:named_mock)
-    assert_equal "#<Mock:named_mock>", mock.inspect
+    assert_equal '#<Mock:named_mock>', mock.inspect
   end
 
   def test_should_display_impersonated_object_for_mocha_inspect
     mockery = Mockery.new
     instance = Object.new
     mock = mockery.mock_impersonating(instance)
-    assert_equal "#{instance.mocha_inspect}", mock.mocha_inspect
+    assert_equal instance.mocha_inspect.to_s, mock.mocha_inspect
   end
 
   def test_should_display_impersonated_object_for_inspect
     mockery = Mockery.new
     instance = Object.new
     mock = mockery.mock_impersonating(instance)
-    assert_equal "#{instance.mocha_inspect}", mock.inspect
+    assert_equal instance.mocha_inspect.to_s, mock.inspect
   end
 
   class FakeClass; end
@@ -145,13 +163,12 @@ class MockeryTest < Mocha::TestCase
   def test_should_display_any_instance_prefix_followed_by_class_whose_instances_are_being_impersonated_for_mocha_inspect
     mockery = Mockery.new
     mock = mockery.mock_impersonating_any_instance_of(FakeClass)
-    assert_equal "#<AnyInstance:MockeryTest::FakeClass>", mock.mocha_inspect
+    assert_equal '#<AnyInstance:MockeryTest::FakeClass>', mock.mocha_inspect
   end
 
   def test_should_display_any_instance_prefix_followed_by_class_whose_instances_are_being_impersonated_for_inspect
     mockery = Mockery.new
     mock = mockery.mock_impersonating_any_instance_of(FakeClass)
-    assert_equal "#<AnyInstance:MockeryTest::FakeClass>", mock.inspect
+    assert_equal '#<AnyInstance:MockeryTest::FakeClass>', mock.inspect
   end
-
 end

data/test/unit/module_methods_test.rb

@@ -3,7 +3,6 @@ require 'mocha/module_methods'
 require 'mocha/object_methods'
 
 class ModuleMethodsTest < Mocha::TestCase
-
   def setup
     @module = Module.new.extend(Mocha::ModuleMethods, Mocha::ObjectMethods)
   end
@@ -15,5 +14,4 @@ class ModuleMethodsTest < Mocha::TestCase
   def test_should_stub_self_for_module
     assert_equal @module, @module.stubba_object
   end
-
 end

data/test/unit/multiple_yields_test.rb

@@ -3,7 +3,6 @@ require File.expand_path('../../test_helper', __FILE__)
 require 'mocha/multiple_yields'
 
 class MultipleYieldsTest < Mocha::TestCase
-
   include Mocha
 
   def test_should_provide_parameters_for_multiple_yields_in_single_invocation
@@ -14,5 +13,4 @@ class MultipleYieldsTest < Mocha::TestCase
     end
     assert_equal [[1, 2, 3], [4, 5]], parameter_groups
   end
-
 end

data/test/unit/no_yields_test.rb

@@ -3,7 +3,6 @@ require File.expand_path('../../test_helper', __FILE__)
 require 'mocha/no_yields'
 
 class NoYieldsTest < Mocha::TestCase
-
   include Mocha
 
   def test_should_provide_parameters_for_no_yields_in_single_invocation
@@ -14,5 +13,4 @@ class NoYieldsTest < Mocha::TestCase
     end
     assert_equal [], parameter_groups
   end
-
 end

data/test/unit/object_inspect_test.rb

@@ -4,14 +4,13 @@ require 'mocha/inspect'
 require 'method_definer'
 
 class ObjectInspectTest < Mocha::TestCase
-
   def test_should_return_default_string_representation_of_object_not_including_instance_variables
     object = Object.new
     class << object
       attr_accessor :attribute
     end
     object.attribute = 'instance_variable'
-    assert_match Regexp.new("^#<Object:0x[0-9A-Fa-f]{1,8}.*>$"), object.mocha_inspect
+    assert_match Regexp.new('^#<Object:0x[0-9A-Fa-f]{1,8}.*>$'), object.mocha_inspect
     assert_no_match(/instance_variable/, object.mocha_inspect)
   end
 
@@ -26,14 +25,24 @@ class ObjectInspectTest < Mocha::TestCase
   def test_should_use_underscored_id_instead_of_object_id_or_id_so_that_they_can_be_stubbed
     calls = []
     object = Object.new
-    object.replace_instance_method(:id) { calls << :id; return 1 } if Mocha::PRE_RUBY_V19
-    object.replace_instance_method(:object_id) { calls << :object_id; return 1 }
-    object.replace_instance_method(:__id__) { calls << :__id__; return 1 }
-    object.replace_instance_method(:inspect) { "object-description" }
+    if Mocha::PRE_RUBY_V19
+      object.replace_instance_method(:id) do
+        calls << :id
+        return 1
+      end
+    end
+    object.replace_instance_method(:object_id) do
+      calls << :object_id
+      return 1
+    end
+    object.replace_instance_method(:__id__) do
+      calls << :__id__
+      return 1
+    end
+    object.replace_instance_method(:inspect) { 'object-description' }
 
     object.mocha_inspect
 
     assert_equal [:__id__], calls.uniq
   end
-
 end

data/test/unit/object_methods_test.rb

@@ -1,25 +1,42 @@
 require File.expand_path('../../test_helper', __FILE__)
 require 'mocha/object_methods'
+require 'mocha/mockery'
 require 'mocha/mock'
 require 'mocha/expectation_error_factory'
+require 'mocha/names'
 
 class ObjectMethodsTest < Mocha::TestCase
-
   def setup
+    Mocha::Mockery.setup
     @object = Object.new.extend(Mocha::ObjectMethods)
   end
 
+  def teardown
+    Mocha::Mockery.teardown
+  end
+
   def test_should_build_mocha_referring_to_self
     mocha = @object.mocha
     assert_not_nil mocha
     assert mocha.is_a?(Mocha::Mock)
-    assert_equal @object.mocha_inspect, mocha.mocha_inspect
+    expected_name = Mocha::ImpersonatingName.new(@object).mocha_inspect
+    assert_equal expected_name, mocha.mocha_inspect
+  end
+
+  def test_should_not_build_mocha_if_instantiate_is_false
+    assert_nil @object.mocha(false)
   end
 
   def test_should_reuse_existing_mocha
-    mocha_1 = @object.mocha
-    mocha_2 = @object.mocha
-    assert_equal mocha_1, mocha_2
+    mocha1 = @object.mocha
+    mocha2 = @object.mocha
+    assert_equal mocha1, mocha2
+  end
+
+  def test_should_reuse_existing_mocha_even_if_instantiate_is_false
+    mocha1 = @object.mocha
+    mocha2 = @object.mocha(false)
+    assert_equal mocha1, mocha2
   end
 
   def test_should_reset_mocha
@@ -42,5 +59,4 @@ class ObjectMethodsTest < Mocha::TestCase
     klass = Class.new { def self.method_x; end }
     assert_equal klass._method(:method_x), klass.method(:method_x)
   end
-
 end

data/test/unit/parameter_matchers/all_of_test.rb

@@ -5,7 +5,6 @@ require 'mocha/inspect'
 require 'stub_matcher'
 
 class AllOfTest < Mocha::TestCase
-
   include Mocha::ParameterMatchers
 
   def test_should_match_if_all_matchers_match
@@ -22,5 +21,4 @@ class AllOfTest < Mocha::TestCase
     matcher = all_of(Stub::Matcher.new(true), Stub::Matcher.new(false), Stub::Matcher.new(true))
     assert_equal 'all_of(matcher(true), matcher(false), matcher(true))', matcher.mocha_inspect
   end
-
 end

data/test/unit/parameter_matchers/any_of_test.rb

@@ -5,7 +5,6 @@ require 'mocha/inspect'
 require 'stub_matcher'
 
 class AnyOfTest < Mocha::TestCase
-
   include Mocha::ParameterMatchers
 
   def test_should_match_if_any_matchers_match
@@ -22,5 +21,4 @@ class AnyOfTest < Mocha::TestCase
     matcher = any_of(Stub::Matcher.new(false), Stub::Matcher.new(true), Stub::Matcher.new(false))
     assert_equal 'any_of(matcher(false), matcher(true), matcher(false))', matcher.mocha_inspect
   end
-
 end

data/test/unit/parameter_matchers/anything_test.rb

@@ -4,18 +4,16 @@ require 'mocha/parameter_matchers/anything'
 require 'mocha/inspect'
 
 class AnythingTest < Mocha::TestCase
-
   include Mocha::ParameterMatchers
 
   def test_should_match_anything
     matcher = anything
     assert matcher.matches?([:something])
-    assert matcher.matches?([{'x' => 'y'}])
+    assert matcher.matches?([{ 'x' => 'y' }])
   end
 
   def test_should_describe_matcher
     matcher = anything
-    assert_equal "anything", matcher.mocha_inspect
+    assert_equal 'anything', matcher.mocha_inspect
   end
-
 end

data/test/unit/parameter_matchers/equals_test.rb

@@ -4,7 +4,6 @@ require 'mocha/parameter_matchers/equals'
 require 'mocha/inspect'
 
 class EqualsTest < Mocha::TestCase
-
   include Mocha::ParameterMatchers
 
   def test_should_match_object_that_equals_value
@@ -19,7 +18,6 @@ class EqualsTest < Mocha::TestCase
 
   def test_should_describe_matcher
     matcher = equals('x')
-    assert_equal %{"x"}, matcher.mocha_inspect
+    assert_equal %("x"), matcher.mocha_inspect
   end
-
 end

data/test/unit/parameter_matchers/equivalent_uri_test.rb

@@ -3,7 +3,6 @@ require 'deprecation_disabler'
 require 'mocha/parameter_matchers/equivalent_uri'
 
 class EquivalentUriMatchesTest < Mocha::TestCase
-
   include Mocha::ParameterMatchers
   include DeprecationDisabler
 

data/test/unit/parameter_matchers/has_entries_test.rb

@@ -5,7 +5,6 @@ require 'mocha/parameter_matchers/object'
 require 'mocha/inspect'
 
 class HasEntriesTest < Mocha::TestCase
-
   include Mocha::ParameterMatchers
 
   def test_should_match_hash_including_specified_entries
@@ -23,7 +22,9 @@ class HasEntriesTest < Mocha::TestCase
     description = matcher.mocha_inspect
     matches = /has_entries\((.*)\)/.match(description)
     assert_not_nil matches[0]
+    # rubocop:disable Security/Eval
     entries = eval(matches[1], binding, __FILE__, __LINE__)
+    # rubocop:enable Security/Eval
     assert_equal 'value_1', entries[:key_1]
     assert_equal 'value_2', entries[:key_2]
   end
@@ -47,5 +48,4 @@ class HasEntriesTest < Mocha::TestCase
     matcher = has_entries(:key_1 => equals('value_2'), :key_2 => equals('value_2'), :key_3 => equals('value_3'))
     assert !matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
   end
-
 end

data/test/unit/parameter_matchers/has_entry_test.rb

@@ -6,7 +6,6 @@ require 'mocha/parameter_matchers/equals'
 require 'mocha/inspect'
 
 class HasEntryTest < Mocha::TestCase
-
   include Mocha::ParameterMatchers
 
   def test_should_match_hash_including_specified_key_value_pair
@@ -62,7 +61,7 @@ class HasEntryTest < Mocha::TestCase
   def test_should_not_match_object_that_doesnt_respond_to_keys
     matcher = has_entry(:key_1 => equals('value_2'))
     object = Class.new do
-      def [](key)
+      def [](_key)
         'value_2'
       end
     end.new
@@ -81,49 +80,49 @@ class HasEntryTest < Mocha::TestCase
 
   def test_should_raise_argument_error_if_single_argument_is_not_a_hash
     e = assert_raises(ArgumentError) do
-      has_entry(Array.new)
+      has_entry([])
     end
-    assert_equal "Argument is not a Hash.", e.message
+    assert_equal 'Argument is not a Hash.', e.message
   end
 
   def test_should_raise_argument_error_if_no_entries_are_supplied
     e = assert_raises(ArgumentError) do
       has_entry({})
     end
-    assert_equal "Argument has no entries.", e.message
+    assert_equal 'Argument has no entries.', e.message
   end
 
   def test_should_raise_argument_error_if_multiple_entries_are_supplied
     e = assert_raises(ArgumentError) do
       has_entry(:key_1 => 'value_1', :key_2 => 'value_2')
     end
-    assert_equal "Argument has multiple entries. Use Mocha::ParameterMatchers#has_entries instead.", e.message
+    assert_equal 'Argument has multiple entries. Use Mocha::ParameterMatchers#has_entries instead.', e.message
   end
 
   def test_should_raise_argument_error_if_more_than_two_arguments_are_supplied
     e = assert_raises(ArgumentError) do
       has_entry(1, 2, 3)
     end
-    assert_equal "Too many arguments; use either a single argument (must be a Hash) or two arguments (a key and a value).", e.message
+    assert_equal 'Too many arguments; use either a single argument (must be a Hash) or two arguments (a key and a value).', e.message
   end
 
   def test_should_match_array_as_key
     matcher = has_entry([:key_1, :key_2] => 'value_1')
-    assert matcher.matches?([{[:key_1, :key_2] => 'value_1', :key_3 => 'value_2'}])
+    assert matcher.matches?([{ [:key_1, :key_2] => 'value_1', :key_3 => 'value_2' }])
   end
 
   def test_should_match_array_as_value
-    matcher = has_entry(:key_1 => ['value_1', 'value_2'])
-    assert matcher.matches?([{:key_1 => ['value_1', 'value_2']}])
+    matcher = has_entry(:key_1 => %w[value_1 value_2])
+    assert matcher.matches?([{ :key_1 => %w[value_1 value_2] }])
   end
 
   def test_should_match_hash_as_value_and_key
-    matcher = has_entry({{:key_1 => 'value_1', :key_2 => 'value_2'} => {:key_3 => 'value_3', :key_4 => 'value_4'}})
-    assert matcher.matches?([{{:key_1 => 'value_1', :key_2 => 'value_2'} => {:key_3 => 'value_3', :key_4 => 'value_4'}, :key_5 => 'value_5'}])
+    matcher = has_entry({ :key_1 => 'value_1', :key_2 => 'value_2' } => { :key_3 => 'value_3', :key_4 => 'value_4' })
+    assert matcher.matches?([{ { :key_1 => 'value_1', :key_2 => 'value_2' } => { :key_3 => 'value_3', :key_4 => 'value_4' }, :key_5 => 'value_5' }])
   end
 
   def test_should_match_matcher_as_value_and_key
-    matcher = has_entry({has_entry(:key_1 => 'value_1') => has_entry(:key_3 => 'value_3')})
-    assert matcher.matches?([{{:key_1 => 'value_1', :key_2 => 'value_2'} => {:key_3 => 'value_3', :key_4 => 'value_4'}, :key_5 => 'value_5'}])
+    matcher = has_entry(has_entry(:key_1 => 'value_1') => has_entry(:key_3 => 'value_3'))
+    assert matcher.matches?([{ { :key_1 => 'value_1', :key_2 => 'value_2' } => { :key_3 => 'value_3', :key_4 => 'value_4' }, :key_5 => 'value_5' }])
   end
 end

data/test/unit/parameter_matchers/has_key_test.rb

@@ -5,7 +5,6 @@ require 'mocha/parameter_matchers/object'
 require 'mocha/inspect'
 
 class HasKeyTest < Mocha::TestCase
-
   include Mocha::ParameterMatchers
 
   def test_should_match_hash_including_specified_key

data/test/unit/parameter_matchers/has_value_test.rb

@@ -6,7 +6,6 @@ require 'mocha/parameter_matchers/equals'
 require 'mocha/inspect'
 
 class HasValueTest < Mocha::TestCase
-
   include Mocha::ParameterMatchers
 
   def test_should_match_hash_including_specified_value
@@ -53,5 +52,4 @@ class HasValueTest < Mocha::TestCase
     matcher = has_value('value_1')
     assert !matcher.matches?(['value_1'])
   end
-
 end

data/test/unit/parameter_matchers/includes_test.rb

@@ -7,7 +7,6 @@ require 'mocha/parameter_matchers/regexp_matches'
 require 'mocha/inspect'
 
 class IncludesTest < Mocha::TestCase
-
   include Mocha::ParameterMatchers
 
   def test_should_match_object_including_value
@@ -37,12 +36,12 @@ class IncludesTest < Mocha::TestCase
 
   def test_should_describe_matcher_with_one_item
     matcher = includes(:x)
-    assert_equal "includes(:x)", matcher.mocha_inspect
+    assert_equal 'includes(:x)', matcher.mocha_inspect
   end
 
   def test_should_describe_matcher_with_multiple_items
     matcher = includes(:x, :y, :z)
-    assert_equal "includes(:x, :y, :z)", matcher.mocha_inspect
+    assert_equal 'includes(:x, :y, :z)', matcher.mocha_inspect
   end
 
   def test_should_not_raise_error_on_emtpy_arguments
@@ -67,12 +66,12 @@ class IncludesTest < Mocha::TestCase
 
   def test_should_match_object_including_value_which_matches_nested_matcher
     matcher = includes(has_key(:key))
-    assert matcher.matches?([[:non_matching_element, {:key => 'value'}]])
+    assert matcher.matches?([[:non_matching_element, { :key => 'value' }]])
   end
 
   def test_should_not_match_object_which_doesnt_include_value_that_matches_nested_matcher
     matcher = includes(has_key(:key))
-    assert !matcher.matches?([[:non_matching_element, {:other_key => 'other-value'}]])
+    assert !matcher.matches?([[:non_matching_element, { :other_key => 'other-value' }]])
   end
 
   def test_should_match_string_argument_containing_substring
@@ -87,21 +86,21 @@ class IncludesTest < Mocha::TestCase
 
   def test_should_match_hash_argument_containing_given_key
     matcher = includes(:key)
-    assert matcher.matches?([{:thing => 1, :key => 2}])
+    assert matcher.matches?([{ :thing => 1, :key => 2 }])
   end
 
   def test_should_not_match_hash_argument_missing_given_key
     matcher = includes(:key)
-    assert !matcher.matches?([{:thing => 1, :other => :key}])
+    assert !matcher.matches?([{ :thing => 1, :other => :key }])
   end
 
   def test_should_match_hash_when_nested_matcher_matches_key
     matcher = includes(regexp_matches(/ar/))
-    assert matcher.matches?([{'foo' => 1, 'bar' => 2}])
+    assert matcher.matches?([{ 'foo' => 1, 'bar' => 2 }])
   end
 
   def test_should_not_match_hash_when_nested_matcher_doesn_not_match_key
     matcher = includes(regexp_matches(/az/))
-    assert !matcher.matches?([{'foo' => 1, 'bar' => 2}])
+    assert !matcher.matches?([{ 'foo' => 1, 'bar' => 2 }])
   end
 end

data/test/unit/parameter_matchers/instance_of_test.rb

@@ -4,7 +4,6 @@ require 'mocha/parameter_matchers/instance_of'
 require 'mocha/inspect'
 
 class InstanceOfTest < Mocha::TestCase
-
   include Mocha::ParameterMatchers
 
   def test_should_match_object_that_is_an_instance_of_specified_class
@@ -19,7 +18,6 @@ class InstanceOfTest < Mocha::TestCase
 
   def test_should_describe_matcher
     matcher = instance_of(String)
-    assert_equal "instance_of(String)", matcher.mocha_inspect
+    assert_equal 'instance_of(String)', matcher.mocha_inspect
   end
-
 end

data/test/unit/parameter_matchers/is_a_test.rb

@@ -4,7 +4,6 @@ require 'mocha/parameter_matchers/is_a'
 require 'mocha/inspect'
 
 class IsATest < Mocha::TestCase
-
   include Mocha::ParameterMatchers
 
   def test_should_match_object_that_is_a_specified_class
@@ -19,7 +18,6 @@ class IsATest < Mocha::TestCase
 
   def test_should_describe_matcher
     matcher = is_a(Integer)
-    assert_equal "is_a(Integer)", matcher.mocha_inspect
+    assert_equal 'is_a(Integer)', matcher.mocha_inspect
   end
-
 end

data/test/unit/parameter_matchers/kind_of_test.rb

@@ -4,7 +4,6 @@ require 'mocha/parameter_matchers/kind_of'
 require 'mocha/inspect'
 
 class KindOfTest < Mocha::TestCase
-
   include Mocha::ParameterMatchers
 
   def test_should_match_object_that_is_a_kind_of_specified_class
@@ -19,7 +18,6 @@ class KindOfTest < Mocha::TestCase
 
   def test_should_describe_matcher
     matcher = kind_of(Integer)
-    assert_equal "kind_of(Integer)", matcher.mocha_inspect
+    assert_equal 'kind_of(Integer)', matcher.mocha_inspect
   end
-
 end

data/test/unit/parameter_matchers/not_test.rb

@@ -5,7 +5,6 @@ require 'mocha/inspect'
 require 'stub_matcher'
 
 class NotTest < Mocha::TestCase
-
   include Mocha::ParameterMatchers
 
   def test_should_match_if_matcher_does_not_match
@@ -22,5 +21,4 @@ class NotTest < Mocha::TestCase
     matcher = Not(Stub::Matcher.new(true))
     assert_equal 'Not(matcher(true))', matcher.mocha_inspect
   end
-
 end

data/test/unit/parameter_matchers/regexp_matches_test.rb

@@ -4,7 +4,6 @@ require 'mocha/parameter_matchers/regexp_matches'
 require 'mocha/inspect'
 
 class RegexpMatchesTest < Mocha::TestCase
-
   include Mocha::ParameterMatchers
 
   def test_should_match_parameter_matching_regular_expression
@@ -19,7 +18,7 @@ class RegexpMatchesTest < Mocha::TestCase
 
   def test_should_describe_matcher
     matcher = regexp_matches(/oo/)
-    assert_equal "regexp_matches(/oo/)", matcher.mocha_inspect
+    assert_equal 'regexp_matches(/oo/)', matcher.mocha_inspect
   end
 
   def test_should_not_raise_error_on_empty_arguments