mocha 1.4.0 → 1.7.0

data/test/mini_test_result.rb

@@ -2,16 +2,15 @@ require 'stringio'
 require 'minitest/unit'
 
 class MiniTestResult
-
   minitest_version = Gem::Version.new(::MiniTest::Unit::VERSION)
   if Gem::Requirement.new('<= 4.6.1').satisfied_by?(minitest_version)
-    FAILURE_PATTERN = %r{(Failure)\:\n([^\(]+)\(([^\)]+)\) \[([^\]]+)\]\:\n(.*)\n}m
-    ERROR_PATTERN   = %r{(Error)\:\n([^\(]+)\(([^\)]+)\)\:\n(.+?)\n}m
-    PATTERN_INDICES = { :method => 2, :testcase => 3 }
+    FAILURE_PATTERN = /(Failure)\:\n([^\(]+)\(([^\)]+)\) \[([^\]]+)\]\:\n(.*)\n/m
+    ERROR_PATTERN   = /(Error)\:\n([^\(]+)\(([^\)]+)\)\:\n(.+?)\n/m
+    PATTERN_INDICES = { :method => 2, :testcase => 3 }.freeze
   else
-    FAILURE_PATTERN = %r{(Failure)\:\n.([^#]+)\#([^ ]+) \[([^\]]+)\]\:\n(.*)\n}m
-    ERROR_PATTERN   = %r{(Error)\:\n.([^#]+)\#([^ ]+)\:\n(.+?)\n}m
-    PATTERN_INDICES = { :method => 3, :testcase => 2 }
+    FAILURE_PATTERN = /(Failure)\:\n.([^#]+)\#([^ ]+) \[([^\]]+)\]\:\n(.*)\n/m
+    ERROR_PATTERN   = /(Error)\:\n.([^#]+)\#([^ ]+)\:\n(.+?)\n/m
+    PATTERN_INDICES = { :method => 3, :testcase => 2 }.freeze
   end
 
   def self.parse_failure(raw)
@@ -30,7 +29,10 @@ class MiniTestResult
   class Failure
     attr_reader :method, :test_case, :location, :message
     def initialize(method, test_case, location, message)
-      @method, @test_case, @location, @message = method, test_case, location, message
+      @method = method
+      @test_case = test_case
+      @location = location
+      @message = message
     end
   end
 
@@ -38,18 +40,22 @@ class MiniTestResult
     class Exception
       attr_reader :message, :backtrace
       def initialize(message, location)
-        @message, @backtrace = message, location
+        @message = message
+        @backtrace = location
       end
     end
 
     attr_reader :method, :test_case, :exception
     def initialize(method, test_case, message, backtrace)
-      @method, @test_case, @exception = method, test_case, Exception.new(message, backtrace)
+      @method = method
+      @test_case = test_case
+      @exception = Exception.new(message, backtrace)
     end
   end
 
   def initialize(runner, tests)
-    @runner, @tests = runner, tests
+    @runner = runner
+    @tests = tests
   end
 
   def failure_count

data/test/minitest_result.rb

@@ -1,7 +1,6 @@
 require 'forwardable'
 
 class MinitestResult
-
   class Failure
     extend Forwardable
     def_delegators :@failure, :message, :backtrace

data/test/simple_counter.rb

@@ -1,5 +1,4 @@
 class SimpleCounter
-
   attr_reader :count
 
   def initialize
@@ -9,5 +8,4 @@ class SimpleCounter
   def increment
     @count += 1
   end
-
 end

data/test/test_helper.rb

@@ -2,22 +2,26 @@ unless defined?(STANDARD_OBJECT_PUBLIC_INSTANCE_METHODS)
   STANDARD_OBJECT_PUBLIC_INSTANCE_METHODS = Object.instance_methods + Object.private_instance_methods
 end
 
-$:.unshift File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
-$:.unshift File.expand_path(File.join(File.dirname(__FILE__)))
-$:.unshift File.expand_path(File.join(File.dirname(__FILE__), 'unit'))
-$:.unshift File.expand_path(File.join(File.dirname(__FILE__), 'unit', 'parameter_matchers'))
-$:.unshift File.expand_path(File.join(File.dirname(__FILE__), 'acceptance'))
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__)))
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), 'unit'))
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), 'unit', 'parameter_matchers'))
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), 'acceptance'))
 
 require 'mocha/detection/mini_test'
 
 begin
   require 'minitest'
+# rubocop:disable Lint/HandleExceptions
 rescue LoadError
 end
+# rubocop:enable Lint/HandleExceptions
 begin
   require 'minitest/unit'
+# rubocop:disable Lint/HandleExceptions
 rescue LoadError
 end
+# rubocop:enable Lint/HandleExceptions
 
 module Mocha; end
 
@@ -27,6 +31,7 @@ if (minitest_testcase = Mocha::Detection::MiniTest.testcase) && (ENV['MOCHA_RUN_
   rescue LoadError
     MiniTest::Unit.autorun
   end
+  # rubocop:disable Style/ClassAndModuleChildren
   class Mocha::TestCase < minitest_testcase
     def assert_nothing_raised(exception = StandardError)
       yield
@@ -39,12 +44,15 @@ if (minitest_testcase = Mocha::Detection::MiniTest.testcase) && (ENV['MOCHA_RUN_
     alias_method :assert_not_same, :refute_same
     alias_method :assert_no_match, :refute_match
   end
+  # rubocop:enable Style/ClassAndModuleChildren
 else
   require 'test/unit'
+  # rubocop:disable Style/ClassAndModuleChildren
   class Mocha::TestCase < Test::Unit::TestCase
     def test_dummy
       # Some versions (?) of Test::Unit try to run this base class as a test case
       # and it fails because it has no test methods, so I'm adding a dummy test.
     end
   end
+  # rubocop:enable Style/ClassAndModuleChildren
 end

data/test/test_runner.rb

@@ -23,9 +23,7 @@ module TestRunner
       minitest_version = Gem::Version.new(Mocha::Detection::MiniTest.version)
       if Gem::Requirement.new('>= 5.0.0').satisfied_by?(minitest_version)
         require File.expand_path('../minitest_result', __FILE__)
-        tests.each do |test|
-          test.run
-        end
+        tests.each(&:run)
         Minitest::Runnable.runnables.delete(test_class)
         test_result = MinitestResult.new(tests)
       elsif Gem::Requirement.new('> 0.0.0', '< 5.0.0').satisfied_by?(minitest_version)
@@ -53,6 +51,6 @@ module TestRunner
   end
 
   def assert_failed(test_result)
-    flunk "Test passed unexpectedly" unless test_result.failure_count + test_result.error_count > 0
+    flunk 'Test passed unexpectedly' unless test_result.failure_count + test_result.error_count > 0
   end
 end

data/test/test_unit_result.rb

@@ -6,13 +6,15 @@ class TestUnitResult
     class << test_result
       attr_reader :failures, :errors
       def failure_messages
-        failures.map { |failure| failure.message }
+        failures.map(&:message)
       end
+
       def failure_message_lines
         failure_messages.map { |message| message.split("\n") }.flatten
       end
+
       def error_messages
-        errors.map { |error| error.message }
+        errors.map(&:message)
       end
     end
     test_result

data/test/unit/any_instance_method_test.rb

@@ -4,19 +4,18 @@ require 'mocha/mock'
 require 'mocha/any_instance_method'
 
 class AnyInstanceMethodTest < Mocha::TestCase
-
   include Mocha
 
-unless RUBY_V2_PLUS
-  def test_should_hide_original_method
-    klass = Class.new { def method_x; end }
-    method = AnyInstanceMethod.new(klass, :method_x)
+  unless RUBY_V2_PLUS
+    def test_should_hide_original_method
+      klass = Class.new { def method_x; end }
+      method = AnyInstanceMethod.new(klass, :method_x)
 
-    method.hide_original_method
+      method.hide_original_method
 
-    assert_equal false, klass.method_defined?(:method_x)
+      assert_equal false, klass.method_defined?(:method_x)
+    end
   end
-end
 
   def test_should_not_raise_error_hiding_method_that_isnt_defined
     klass = Class.new
@@ -45,7 +44,11 @@ end
   end
 
   def test_should_restore_original_method
-    klass = Class.new { def method_x; :original_result; end }
+    klass = Class.new do
+      def method_x
+        :original_result
+      end
+    end
     method = AnyInstanceMethod.new(klass, :method_x)
 
     method.hide_original_method
@@ -59,7 +62,11 @@ end
   end
 
   def test_should_not_restore_original_method_if_none_was_defined_in_first_place
-    klass = Class.new { def method_x; :new_result; end }
+    klass = Class.new do
+      def method_x
+        :new_result
+      end
+    end
     method = AnyInstanceMethod.new(klass, :method_x)
 
     method.restore_original_method
@@ -75,8 +82,8 @@ end
     any_instance.stubs(:mocha).returns(any_instance_mocha)
     klass.define_instance_method(:any_instance) { any_instance }
     method = AnyInstanceMethod.new(klass, :method_x)
-    method.replace_instance_method(:restore_original_method) { }
-    method.replace_instance_method(:reset_mocha) { }
+    method.replace_instance_method(:restore_original_method) {}
+    method.replace_instance_method(:reset_mocha) {}
     method.define_instance_accessor(:remove_called)
     method.replace_instance_method(:remove_new_method) { self.remove_called = true }
 
@@ -92,8 +99,8 @@ end
     any_instance.stubs(:mocha).returns(any_instance_mocha)
     klass.define_instance_method(:any_instance) { any_instance }
     method = AnyInstanceMethod.new(klass, :method_x)
-    method.replace_instance_method(:remove_new_method) { }
-    method.replace_instance_method(:reset_mocha) { }
+    method.replace_instance_method(:remove_new_method) {}
+    method.replace_instance_method(:reset_mocha) {}
     method.define_instance_accessor(:restore_called)
     method.replace_instance_method(:restore_original_method) { self.restore_called = true }
 
@@ -107,9 +114,16 @@ end
 
     method = AnyInstanceMethod.new(klass, :method_x)
 
-    method.replace_instance_method(:remove_new_method) { }
-    method.replace_instance_method(:restore_original_method) { }
-    mocha = Class.new { class << self; attr_accessor :unstub_method; end; def self.unstub(method); self.unstub_method = method; end; }
+    method.replace_instance_method(:remove_new_method) {}
+    method.replace_instance_method(:restore_original_method) {}
+    mocha = Class.new do
+      class << self
+        attr_accessor :unstub_method
+      end
+      def self.unstub(method)
+        self.unstub_method = method
+      end
+    end
     mocha.define_instance_method(:any_expectations?) { true }
     method.replace_instance_method(:mock) { mocha }
 

data/test/unit/array_inspect_test.rb

@@ -2,15 +2,13 @@ require File.expand_path('../../test_helper', __FILE__)
 require 'mocha/inspect'
 
 class ArrayInspectTest < Mocha::TestCase
-
   def test_should_use_inspect
     array = [1, 2]
     assert_equal array.inspect, array.mocha_inspect
   end
 
   def test_should_use_mocha_inspect_on_each_item
-    array = [1, 2, "chris"]
-    assert_equal %{[1, 2, "chris"]}, array.mocha_inspect
+    array = [1, 2, 'chris']
+    assert_equal %([1, 2, "chris"]), array.mocha_inspect
   end
-
 end

data/test/unit/backtrace_filter_test.rb

@@ -2,18 +2,16 @@ require File.expand_path('../../test_helper', __FILE__)
 require 'mocha/backtrace_filter'
 
 class BacktraceFilterTest < Mocha::TestCase
-
   include Mocha
 
   def test_should_exclude_mocha_locations_from_backtrace
-    mocha_lib = "/username/workspace/mocha_wibble/lib/"
-    backtrace = [ mocha_lib + 'exclude/me/1', mocha_lib + 'exclude/me/2', '/keep/me', mocha_lib + 'exclude/me/3']
+    mocha_lib = '/username/workspace/mocha_wibble/lib/'
+    backtrace = [mocha_lib + 'exclude/me/1', mocha_lib + 'exclude/me/2', '/keep/me', mocha_lib + 'exclude/me/3']
     filter = BacktraceFilter.new(mocha_lib)
     assert_equal ['/keep/me'], filter.filtered(backtrace)
   end
 
   def test_should_determine_path_for_mocha_lib_directory
-    assert_match Regexp.new("/lib/$"), BacktraceFilter::LIB_DIRECTORY
+    assert_match Regexp.new('/lib/$'), BacktraceFilter::LIB_DIRECTORY
   end
-
 end

data/test/unit/cardinality_test.rb

@@ -2,7 +2,6 @@ require File.expand_path('../../test_helper', __FILE__)
 require 'mocha/cardinality'
 
 class CardinalityTest < Mocha::TestCase
-
   include Mocha
 
   def test_should_allow_invocations_if_invocation_count_has_not_yet_reached_maximum
@@ -52,5 +51,4 @@ class CardinalityTest < Mocha::TestCase
   def test_should_not_need_verifying
     assert_equal false, Cardinality.at_least(0).needs_verifying?
   end
-
 end

data/test/unit/central_test.rb

@@ -5,7 +5,6 @@ require 'mocha/mock'
 require 'method_definer'
 
 class CentralTest < Mocha::TestCase
-
   include Mocha
 
   def test_should_start_with_empty_stubba_methods
@@ -48,48 +47,48 @@ class CentralTest < Mocha::TestCase
 
   def test_should_unstub_specified_method
     stubba = Central.new
-    method_1 = build_mock
-    method_1.stubs(:matches?).returns(false)
-    method_2 = build_mock
-    method_2.stubs(:matches?).returns(true)
-    method_2.expects(:unstub)
-    stubba.stubba_methods = [method_1, method_2]
+    method1 = build_mock
+    method1.stubs(:matches?).returns(false)
+    method2 = build_mock
+    method2.stubs(:matches?).returns(true)
+    method2.expects(:unstub)
+    stubba.stubba_methods = [method1, method2]
 
-    stubba.unstub(method_2)
+    stubba.unstub(method2)
 
-    assert_equal [method_1], stubba.stubba_methods
-    assert method_2.__verified__?
+    assert_equal [method1], stubba.stubba_methods
+    assert method2.__verified__?
   end
 
   def test_should_not_unstub_specified_method_if_not_already_stubbed
     stubba = Central.new
-    method_1 = build_mock
-    method_1.stubs(:matches?).returns(false)
-    method_2 = build_mock
-    method_2.expects(:unstub).never
-    stubba.stubba_methods = [method_1]
+    method1 = build_mock
+    method1.stubs(:matches?).returns(false)
+    method2 = build_mock
+    method2.expects(:unstub).never
+    stubba.stubba_methods = [method1]
 
-    stubba.unstub(method_2)
+    stubba.unstub(method2)
 
-    assert_equal [method_1], stubba.stubba_methods
-    assert method_2.__verified__?
+    assert_equal [method1], stubba.stubba_methods
+    assert method2.__verified__?
   end
 
   def test_should_unstub_all_methods
     stubba = Central.new
-    method_1 = build_mock
-    method_1.stubs(:matches?).returns(true)
-    method_1.expects(:unstub)
-    method_2 = build_mock
-    method_2.stubs(:matches?).returns(true)
-    method_2.expects(:unstub)
-    stubba.stubba_methods = [method_1, method_2]
+    method1 = build_mock
+    method1.stubs(:matches?).returns(true)
+    method1.expects(:unstub)
+    method2 = build_mock
+    method2.stubs(:matches?).returns(true)
+    method2.expects(:unstub)
+    stubba.stubba_methods = [method1, method2]
 
     stubba.unstub_all
 
     assert_equal [], stubba.stubba_methods
-    assert method_1.__verified__?
-    assert method_2.__verified__?
+    assert method1.__verified__?
+    assert method2.__verified__?
   end
 
   private

data/test/unit/change_state_side_effect_test.rb

@@ -3,11 +3,9 @@ require File.expand_path('../../test_helper', __FILE__)
 require 'mocha/change_state_side_effect'
 
 class ChangeStateSideEffectTest < Mocha::TestCase
-
   include Mocha
 
   class FakeState
-
     attr_reader :active
     attr_writer :description
 
@@ -18,7 +16,6 @@ class ChangeStateSideEffectTest < Mocha::TestCase
     def mocha_inspect
       @description
     end
-
   end
 
   def test_should_activate_the_given_state
@@ -37,5 +34,4 @@ class ChangeStateSideEffectTest < Mocha::TestCase
 
     assert_equal 'then the-new-state', side_effect.mocha_inspect
   end
-
 end

data/test/unit/class_method_test.rb

@@ -5,20 +5,19 @@ require 'mocha/mock'
 require 'mocha/class_method'
 
 class ClassMethodTest < Mocha::TestCase
-
   include Mocha
 
-unless RUBY_V2_PLUS
-  def test_should_hide_original_method
-    klass = Class.new { def self.method_x; end }
-    klass.__metaclass__.send(:alias_method, :_method, :method)
-    method = ClassMethod.new(klass, :method_x)
+  unless RUBY_V2_PLUS
+    def test_should_hide_original_method
+      klass = Class.new { def self.method_x; end }
+      klass.__metaclass__.send(:alias_method, :_method, :method)
+      method = ClassMethod.new(klass, :method_x)
 
-    method.hide_original_method
+      method.hide_original_method
 
-    assert_equal false, klass.respond_to?(:method_x)
+      assert_equal false, klass.respond_to?(:method_x)
+    end
   end
-end
 
   def test_should_not_raise_error_hiding_method_that_isnt_defined
     klass = Class.new
@@ -59,7 +58,11 @@ end
   end
 
   def test_should_restore_original_method
-    klass = Class.new { def self.method_x; :original_result; end }
+    klass = Class.new do
+      def self.method_x
+        :original_result
+      end
+    end
     klass.__metaclass__.send(:alias_method, :_method, :method)
     method = ClassMethod.new(klass, :method_x)
 
@@ -73,7 +76,11 @@ end
   end
 
   def test_should_restore_original_method_accepting_a_block_parameter
-    klass = Class.new { def self.method_x(&block); block.call if block_given? ; end }
+    klass = Class.new do
+      def self.method_x(&block)
+        block.call if block_given?
+      end
+    end
     klass.__metaclass__.send(:alias_method, :_method, :method)
     method = ClassMethod.new(klass, :method_x)
 
@@ -88,7 +95,11 @@ end
   end
 
   def test_should_not_restore_original_method_if_none_was_defined_in_first_place
-    klass = Class.new { def self.method_x; :new_result; end }
+    klass = Class.new do
+      def self.method_x
+        :new_result
+      end
+    end
     method = ClassMethod.new(klass, :method_x)
 
     method.restore_original_method
@@ -124,7 +135,7 @@ end
     method = ClassMethod.new(klass, :method_x)
     mocha = build_mock
     klass.define_instance_method(:mocha) { mocha }
-    method.replace_instance_method(:reset_mocha) { }
+    method.replace_instance_method(:reset_mocha) {}
     method.define_instance_accessor(:remove_called)
     method.replace_instance_method(:remove_new_method) { self.remove_called = true }
 
@@ -138,7 +149,7 @@ end
     mocha = build_mock
     klass.define_instance_method(:mocha) { mocha }
     method = ClassMethod.new(klass, :method_x)
-    method.replace_instance_method(:reset_mocha) { }
+    method.replace_instance_method(:reset_mocha) {}
     method.define_instance_accessor(:restore_called)
     method.replace_instance_method(:restore_original_method) { self.restore_called = true }
 
@@ -150,8 +161,15 @@ end
   def test_should_call_mocha_unstub
     klass = Class.new { def self.method_x; end }
     method = ClassMethod.new(klass, :method_x)
-    method.replace_instance_method(:restore_original_method) { }
-    mocha = Class.new { class << self; attr_accessor :unstub_method; end; def self.unstub(method); self.unstub_method = method; end; }
+    method.replace_instance_method(:restore_original_method) {}
+    mocha = Class.new do
+      class << self
+        attr_accessor :unstub_method
+      end
+      def self.unstub(method)
+        self.unstub_method = method
+      end
+    end
     mocha.define_instance_method(:any_expectations?) { true }
     method.replace_instance_method(:mock) { mocha }
 
@@ -162,13 +180,18 @@ end
   def test_should_call_stubbee_reset_mocha_if_no_expectations_remaining
     klass = Class.new { def self.method_x; end }
     method = ClassMethod.new(klass, :method_x)
-    method.replace_instance_method(:remove_new_method) { }
-    method.replace_instance_method(:restore_original_method) { }
+    method.replace_instance_method(:remove_new_method) {}
+    method.replace_instance_method(:restore_original_method) {}
     mocha = Class.new
     mocha.define_instance_method(:unstub) { |method_name| }
     mocha.define_instance_method(:any_expectations?) { false }
     method.replace_instance_method(:mock) { mocha }
-    stubbee = Class.new { attr_accessor :reset_mocha_called; def reset_mocha; self.reset_mocha_called = true; end; }.new
+    stubbee = Class.new do
+      attr_accessor :reset_mocha_called
+      def reset_mocha
+        self.reset_mocha_called = true
+      end
+    end.new
     method.replace_instance_method(:stubbee) { stubbee }
 
     method.unstub
@@ -191,34 +214,36 @@ end
   end
 
   def test_should_not_match_if_other_class_method_has_different_stubbee
-    stubbee_1 = Object.new
-    stubbee_2 = Object.new
-    class_method_1 = ClassMethod.new(stubbee_1, :method)
-    class_method_2 = ClassMethod.new(stubbee_2, :method)
-    assert !class_method_1.matches?(class_method_2)
+    stubbee1 = Object.new
+    stubbee2 = Object.new
+    class_method1 = ClassMethod.new(stubbee1, :method)
+    class_method2 = ClassMethod.new(stubbee2, :method)
+    assert !class_method1.matches?(class_method2)
   end
 
   def test_should_not_match_if_other_class_method_has_different_method
     stubbee = Object.new
-    class_method_1 = ClassMethod.new(stubbee, :method_1)
-    class_method_2 = ClassMethod.new(stubbee, :method_2)
-    assert !class_method_1.matches?(class_method_2)
+    class_method1 = ClassMethod.new(stubbee, :method_1)
+    class_method2 = ClassMethod.new(stubbee, :method_2)
+    assert !class_method1.matches?(class_method2)
   end
 
   def test_should_match_if_other_class_method_has_same_stubbee_and_same_method_so_no_attempt_is_made_to_stub_a_method_twice
     stubbee = Object.new
-    class_method_1 = ClassMethod.new(stubbee, :method)
-    class_method_2 = ClassMethod.new(stubbee, :method)
-    assert class_method_1.matches?(class_method_2)
+    class_method1 = ClassMethod.new(stubbee, :method)
+    class_method2 = ClassMethod.new(stubbee, :method)
+    assert class_method1.matches?(class_method2)
   end
 
   def test_should_match_if_other_class_method_has_same_stubbee_and_same_method_but_stubbee_equal_method_lies_like_active_record_association_proxy
     stubbee = Class.new do
-      def equal?(other); false; end
+      def equal?(_other)
+        false
+      end
     end.new
-    class_method_1 = ClassMethod.new(stubbee, :method)
-    class_method_2 = ClassMethod.new(stubbee, :method)
-    assert class_method_1.matches?(class_method_2)
+    class_method1 = ClassMethod.new(stubbee, :method)
+    class_method2 = ClassMethod.new(stubbee, :method)
+    assert class_method1.matches?(class_method2)
   end
 
   private

data/test/unit/class_methods_test.rb

@@ -1,13 +1,19 @@
 require File.expand_path('../../test_helper', __FILE__)
 require 'mocha/class_methods'
 require 'mocha/object_methods'
+require 'mocha/mockery'
+require 'mocha/names'
 
 class ClassMethodsTest < Mocha::TestCase
-
   def setup
+    Mocha::Mockery.setup
     @klass = Class.new.extend(Mocha::ClassMethods, Mocha::ObjectMethods)
   end
 
+  def teardown
+    Mocha::Mockery.teardown
+  end
+
   def test_should_build_any_instance_object
     any_instance = @klass.any_instance
     assert_not_nil any_instance
@@ -15,9 +21,33 @@ class ClassMethodsTest < Mocha::TestCase
   end
 
   def test_should_return_same_any_instance_object
-    any_instance_1 = @klass.any_instance
-    any_instance_2 = @klass.any_instance
-    assert_equal any_instance_1, any_instance_2
+    any_instance1 = @klass.any_instance
+    any_instance2 = @klass.any_instance
+    assert_equal any_instance1, any_instance2
+  end
+
+  def test_any_instance_should_build_mocha_referring_to_klass
+    mocha = @klass.any_instance.mocha
+    assert_not_nil mocha
+    assert mocha.is_a?(Mocha::Mock)
+    expected_name = Mocha::ImpersonatingAnyInstanceName.new(@klass).mocha_inspect
+    assert_equal expected_name, mocha.mocha_inspect
+  end
+
+  def test_any_instance_should_not_build_mocha_if_instantiate_is_false
+    assert_nil @klass.any_instance.mocha(false)
+  end
+
+  def test_any_instance_should_reuse_existing_mocha
+    mocha1 = @klass.any_instance.mocha
+    mocha2 = @klass.any_instance.mocha
+    assert_equal mocha1, mocha2
+  end
+
+  def test_any_instance_should_reuse_existing_mocha_even_if_instantiate_is_false
+    mocha1 = @klass.any_instance.mocha
+    mocha2 = @klass.any_instance.mocha(false)
+    assert_equal mocha1, mocha2
   end
 
   def test_should_use_stubba_class_method_for_class
@@ -36,5 +66,4 @@ class ClassMethodsTest < Mocha::TestCase
     any_instance = @klass.any_instance
     assert_equal @klass, any_instance.stubba_object
   end
-
 end