mocha 1.11.2 → 1.12.0

data/test/unit/hash_inspect_test.rb

@@ -1,14 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'mocha/inspect'
-
-class HashInspectTest < Mocha::TestCase
-  def test_should_keep_spacing_between_key_value
-    hash = { :a => true }
-    assert_equal '{:a => true}', hash.mocha_inspect
-  end
-
-  def test_should_use_mocha_inspect_on_each_item
-    hash = { :a => 'mocha' }
-    assert_equal %({:a => "mocha"}), hash.mocha_inspect
-  end
-end

data/test/unit/hooks_test.rb

@@ -1,35 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'mocha/hooks'
-require 'mocha/mockery'
-
-class HooksTest < Mocha::TestCase
-  # rubocop:disable Style/ClassAndModuleChildren
-  class Mocha::Mockery
-    class << self
-      attr_writer :instances
-    end
-  end
-  # rubocop:enable Style/ClassAndModuleChildren
-
-  class FakeMockery
-    def verify(*args); end
-
-    def teardown
-      raise 'exception within Mockery#teardown'
-    end
-  end
-
-  def test_ensure_mockery_instance_is_reset_even_when_an_exception_is_raised_in_mockery_teardown
-    fake_test_case = Object.new.extend(Mocha::Hooks)
-    mockery = FakeMockery.new
-    Mocha::Mockery.instances = [mockery]
-
-    begin
-      fake_test_case.mocha_teardown
-    rescue StandardError
-      nil
-    end
-
-    assert_kind_of Mocha::Mockery::Null, Mocha::Mockery.instance
-  end
-end

data/test/unit/in_state_ordering_constraint_test.rb

@@ -1,39 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-require 'mocha/in_state_ordering_constraint'
-
-class InStateOrderingConstraintTest < Mocha::TestCase
-  include Mocha
-
-  class FakeStatePredicate
-    attr_writer :active, :description
-
-    def active?
-      @active
-    end
-
-    def mocha_inspect
-      @description
-    end
-  end
-
-  def test_should_allow_invocation_when_state_is_active
-    state_predicate = FakeStatePredicate.new
-    ordering_constraint = InStateOrderingConstraint.new(state_predicate)
-
-    state_predicate.active = true
-    assert ordering_constraint.allows_invocation_now?
-
-    state_predicate.active = false
-    assert !ordering_constraint.allows_invocation_now?
-  end
-
-  def test_should_describe_itself_in_terms_of_the_state_predicates_description
-    state_predicate = FakeStatePredicate.new
-    ordering_constraint = InStateOrderingConstraint.new(state_predicate)
-
-    state_predicate.description = 'the-state-predicate'
-
-    assert_equal 'when the-state-predicate', ordering_constraint.mocha_inspect
-  end
-end

data/test/unit/instance_method_test.rb

@@ -1,282 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'method_definer'
-require 'mocha/class_methods'
-require 'mocha/mock'
-require 'mocha/singleton_class'
-
-require 'mocha/instance_method'
-
-class InstanceMethodTest < Mocha::TestCase
-  include MethodDefiner
-  include Mocha
-
-  def class_with_method(method, result = nil)
-    Class.new do
-      extend ClassMethods
-      singleton_class.extend(ClassMethods)
-      singleton_class.send(:define_method, method) { result } if method
-    end
-  end
-
-  unless RUBY_V2_PLUS
-    def test_should_hide_original_method
-      klass = class_with_method(:method_x)
-      klass.singleton_class.send(:alias_method, :_method, :method)
-      method = InstanceMethod.new(klass, :method_x)
-
-      method.hide_original_method
-
-      assert_equal false, klass.respond_to?(:method_x)
-    end
-  end
-
-  def test_should_not_raise_error_hiding_method_that_isnt_defined
-    klass = class_with_method(:irrelevant)
-    method = InstanceMethod.new(klass, :method_x)
-
-    assert_nothing_raised { method.hide_original_method }
-  end
-
-  def test_should_not_raise_error_hiding_method_in_class_that_implements_method_called_method
-    klass = class_with_method(:method)
-    method = InstanceMethod.new(klass, :method)
-
-    assert_nothing_raised { method.hide_original_method }
-  end
-
-  def test_should_define_a_new_method_which_should_call_mocha_method_missing
-    klass = class_with_method(:method_x)
-    mocha = build_mock
-    define_instance_method(klass, :mocha) { mocha }
-    mocha.expects(:method_x).with(:param1, :param2).returns(:result)
-    method = InstanceMethod.new(klass, :method_x)
-
-    method.hide_original_method
-    method.define_new_method
-    result = klass.method_x(:param1, :param2)
-
-    assert_equal :result, result
-    assert mocha.__verified__?
-  end
-
-  def test_should_include_the_filename_and_line_number_in_exceptions
-    klass = class_with_method(:method_x)
-    mocha = build_mock
-    define_instance_method(klass, :mocha) { mocha }
-    mocha.stubs(:method_x).raises(Exception)
-    method = InstanceMethod.new(klass, :method_x)
-
-    method.hide_original_method
-    method.define_new_method
-
-    expected_filename = 'stubbed_method.rb'
-    expected_line_number = 61
-
-    exception = assert_raises(Exception) { klass.method_x }
-    matching_line = exception.backtrace.find do |line|
-      filename, line_number, _context = line.split(':')
-      filename.include?(expected_filename) && line_number.to_i == expected_line_number
-    end
-
-    assert_not_nil matching_line, "Expected to find #{expected_filename}:#{expected_line_number} in the backtrace:\n #{exception.backtrace.join("\n")}"
-  end
-
-  def test_should_remove_new_method
-    klass = class_with_method(:method_x)
-    method = InstanceMethod.new(klass, :method_x)
-
-    method.remove_new_method
-
-    assert_equal false, klass.respond_to?(:method_x)
-  end
-
-  def test_should_restore_original_method
-    klass = class_with_method(:method_x, :original_result)
-    klass.singleton_class.send(:alias_method, :_method, :method)
-    method = InstanceMethod.new(klass, :method_x)
-
-    method.hide_original_method
-    method.define_new_method
-    method.remove_new_method
-    method.restore_original_method
-
-    assert klass.respond_to?(:method_x)
-    assert_equal :original_result, klass.method_x
-  end
-
-  def test_should_restore_original_method_accepting_a_block_parameter
-    klass = Class.new do
-      extend ClassMethods
-      singleton_class.extend(ClassMethods)
-      def self.method_x(&block)
-        block.call if block_given?
-      end
-    end
-    klass.singleton_class.send(:alias_method, :_method, :method)
-    method = InstanceMethod.new(klass, :method_x)
-
-    method.hide_original_method
-    method.define_new_method
-    method.remove_new_method
-    method.restore_original_method
-
-    block_called = false
-    klass.method_x { block_called = true }
-    assert block_called
-  end
-
-  def test_should_not_restore_original_method_if_none_was_defined_in_first_place
-    klass = class_with_method(:method_x, :new_result)
-    method = InstanceMethod.new(klass, :method_x)
-
-    method.restore_original_method
-
-    assert_equal :new_result, klass.method_x
-  end
-
-  def test_should_call_hide_original_method
-    klass = class_with_method(:method_x)
-    method = InstanceMethod.new(klass, :method_x)
-    method.hide_original_method
-    define_instance_accessor(method, :hide_called)
-    replace_instance_method(method, :hide_original_method) { self.hide_called = true }
-
-    method.stub
-
-    assert method.hide_called
-  end
-
-  def test_should_call_define_new_method
-    klass = class_with_method(:method_x)
-    method = InstanceMethod.new(klass, :method_x)
-    define_instance_accessor(method, :define_called)
-    replace_instance_method(method, :define_new_method) { self.define_called = true }
-
-    method.stub
-
-    assert method.define_called
-  end
-
-  def test_should_call_remove_new_method
-    klass = class_with_method(:method_x)
-    method = InstanceMethod.new(klass, :method_x)
-    mocha = build_mock
-    define_instance_method(klass, :mocha) { mocha }
-    replace_instance_method(method, :reset_mocha) {}
-    define_instance_accessor(method, :remove_called)
-    replace_instance_method(method, :remove_new_method) { self.remove_called = true }
-
-    method.unstub
-
-    assert method.remove_called
-  end
-
-  def test_should_call_restore_original_method
-    klass = class_with_method(:method_x)
-    mocha = build_mock
-    define_instance_method(klass, :mocha) { mocha }
-    method = InstanceMethod.new(klass, :method_x)
-    replace_instance_method(method, :reset_mocha) {}
-    define_instance_accessor(method, :restore_called)
-    replace_instance_method(method, :restore_original_method) { self.restore_called = true }
-
-    method.unstub
-
-    assert method.restore_called
-  end
-
-  def test_should_call_mocha_unstub
-    klass = class_with_method(:method_x)
-    method = InstanceMethod.new(klass, :method_x)
-    replace_instance_method(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
-    define_instance_method(mocha, :any_expectations?) { true }
-    replace_instance_method(method, :mock) { mocha }
-
-    method.unstub
-    assert_equal mocha.unstub_method, :method_x
-  end
-
-  def test_should_call_stubbee_reset_mocha_if_no_expectations_remaining
-    klass = class_with_method(:method_x)
-    method = InstanceMethod.new(klass, :method_x)
-    replace_instance_method(method, :remove_new_method) {}
-    replace_instance_method(method, :restore_original_method) {}
-    mocha = Class.new
-    define_instance_method(mocha, :unstub) { |method_name| }
-    define_instance_method(mocha, :any_expectations?) { false }
-    replace_instance_method(method, :mock) { mocha }
-    stubbee = Class.new do
-      attr_accessor :reset_mocha_called
-      def reset_mocha
-        self.reset_mocha_called = true
-      end
-    end.new
-    replace_instance_method(method, :stubbee) { stubbee }
-
-    method.unstub
-
-    assert stubbee.reset_mocha_called
-  end
-
-  def test_should_return_mock_for_stubbee
-    mocha = Object.new
-    stubbee = Object.new
-    define_instance_method(stubbee, :mocha) { mocha }
-    method = InstanceMethod.new(stubbee, :method_name)
-    assert_equal mocha, method.mock
-  end
-
-  def test_should_not_match_if_other_object_has_a_different_class
-    method = InstanceMethod.new(Object.new, :method)
-    other_object = Object.new
-    assert !method.matches?(other_object)
-  end
-
-  def test_should_not_match_if_other_instance_method_has_different_stubbee
-    stubbee1 = Object.new
-    stubbee2 = Object.new
-    method1 = InstanceMethod.new(stubbee1, :method)
-    method2 = InstanceMethod.new(stubbee2, :method)
-    assert !method1.matches?(method2)
-  end
-
-  def test_should_not_match_if_other_instance_method_has_different_method
-    stubbee = Object.new
-    method1 = InstanceMethod.new(stubbee, :method_1)
-    method2 = InstanceMethod.new(stubbee, :method_2)
-    assert !method1.matches?(method2)
-  end
-
-  def test_should_match_if_other_instance_method_has_same_stubbee_and_same_method_so_no_attempt_is_made_to_stub_a_method_twice
-    stubbee = Object.new
-    method1 = InstanceMethod.new(stubbee, :method)
-    method2 = InstanceMethod.new(stubbee, :method)
-    assert method1.matches?(method2)
-  end
-
-  def test_should_match_if_other_instance_method_has_same_stubbee_and_same_method_but_stubbee_equal_method_lies_like_active_record_association_proxy
-    stubbee = Class.new do
-      extend ClassMethods
-      def equal?(_other)
-        false
-      end
-    end.new
-    method1 = InstanceMethod.new(stubbee, :method)
-    method2 = InstanceMethod.new(stubbee, :method)
-    assert method1.matches?(method2)
-  end
-
-  private
-
-  def build_mock
-    Mock.new(nil)
-  end
-end

data/test/unit/method_matcher_test.rb

@@ -1,26 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'mocha/method_matcher'
-
-class MethodMatcherTest < Mocha::TestCase
-  include Mocha
-
-  def test_should_match_if_actual_method_name_is_same_as_expected_method_name
-    method_matcher = MethodMatcher.new(:method_name)
-    assert method_matcher.match?(:method_name)
-  end
-
-  def test_should_match_if_actual_method_name_is_expected_method_name_as_string
-    method_matcher = MethodMatcher.new(:method_name)
-    assert method_matcher.match?('method_name')
-  end
-
-  def test_should_not_match_if_actual_method_name_is_not_same_as_expected_method_name
-    method_matcher = MethodMatcher.new(:method_name)
-    assert !method_matcher.match?(:different_method_name)
-  end
-
-  def test_should_describe_what_method_is_expected
-    method_matcher = MethodMatcher.new(:method_name)
-    assert_equal 'method_name', method_matcher.mocha_inspect
-  end
-end

data/test/unit/mock_test.rb

@@ -1,372 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'mocha/ruby_version'
-require 'mocha/macos_version'
-require 'mocha/mock'
-require 'mocha/expectation_error_factory'
-require 'set'
-require 'simple_counter'
-
-class MockTest < Mocha::TestCase
-  include Mocha
-
-  def test_should_set_single_expectation
-    mock = build_mock
-    mock.expects(:method1).returns(1)
-    assert_nothing_raised(ExpectationErrorFactory.exception_class) do
-      assert_equal 1, mock.method1
-    end
-  end
-
-  def test_should_build_and_store_expectations
-    mock = build_mock
-    expectation = mock.expects(:method1)
-    assert_not_nil expectation
-    assert_equal [expectation], mock.__expectations__.to_a
-  end
-
-  def test_should_not_stub_everything_by_default
-    mock = build_mock
-    assert_equal false, mock.everything_stubbed
-  end
-
-  def test_should_stub_everything
-    mock = build_mock
-    mock.stub_everything
-    assert_equal true, mock.everything_stubbed
-  end
-
-  def test_should_be_able_to_extend_mock_object_with_module
-    mock = build_mock
-    assert_nothing_raised(ExpectationErrorFactory.exception_class) { mock.extend(Module.new) }
-  end
-
-  def test_should_be_equal
-    mock = build_mock
-    assert_equal true, mock.eql?(mock)
-  end
-
-  PRE_RUBY_V19_EXCLUDED_METHODS = %w[
-    method_missing
-    singleton_method_undefined
-    initialize
-  ].freeze
-
-  MACOS_EXCLUDED_METHODS =
-    MACOS && MACOS_VERSION >= MACOS_MOJAVE_VERSION ? [:syscall] : []
-
-  RUBY_V19_AND_LATER_EXCLUDED_METHODS = [
-    :object_id,
-    :method_missing,
-    :singleton_method_undefined,
-    :initialize,
-    :String,
-    :singleton_method_added,
-    *MACOS_EXCLUDED_METHODS
-  ].freeze
-
-  OBJECT_METHODS = STANDARD_OBJECT_PUBLIC_INSTANCE_METHODS.reject do |m|
-    (m =~ /^__.*__$/) ||
-      (PRE_RUBY_V19 && PRE_RUBY_V19_EXCLUDED_METHODS.include?(m)) ||
-      (!PRE_RUBY_V19 && RUBY_V19_AND_LATER_EXCLUDED_METHODS.include?(m))
-  end
-
-  def test_should_be_able_to_mock_standard_object_methods
-    mock = build_mock
-    OBJECT_METHODS.each { |method| mock.__expects__(method.to_sym).returns(method) }
-    OBJECT_METHODS.each { |method| assert_equal method, mock.__send__(method.to_sym) }
-    assert mock.__verified__?
-  end
-
-  def test_should_be_able_to_stub_standard_object_methods
-    mock = build_mock
-    OBJECT_METHODS.each { |method| mock.__stubs__(method.to_sym).returns(method) }
-    OBJECT_METHODS.each { |method| assert_equal method, mock.__send__(method.to_sym) }
-  end
-
-  def test_should_create_and_add_expectations
-    mock = build_mock
-    expectation1 = mock.expects(:method1)
-    expectation2 = mock.expects(:method2)
-    assert_equal [expectation1, expectation2].to_set, mock.__expectations__.to_set
-  end
-
-  def test_should_pass_backtrace_into_expectation
-    mock = build_mock
-    backtrace = Object.new
-    expectation = mock.expects(:method1, backtrace)
-    assert_equal backtrace, expectation.backtrace
-  end
-
-  def test_should_pass_backtrace_into_stub
-    mock = build_mock
-    backtrace = Object.new
-    stub = mock.stubs(:method1, backtrace)
-    assert_equal backtrace, stub.backtrace
-  end
-
-  def test_should_create_and_add_stubs
-    mock = build_mock
-    stub1 = mock.stubs(:method1)
-    stub2 = mock.stubs(:method2)
-    assert_equal [stub1, stub2].to_set, mock.__expectations__.to_set
-  end
-
-  def test_should_invoke_expectation_and_return_result
-    mock = build_mock
-    mock.expects(:my_method).returns(:result)
-    result = mock.my_method
-    assert_equal :result, result
-  end
-
-  def test_should_not_raise_error_if_stubbing_everything
-    mock = build_mock
-    mock.stub_everything
-    result = nil
-    assert_nothing_raised(ExpectationErrorFactory.exception_class) do
-      result = mock.unexpected_method
-    end
-    assert_nil result
-  end
-
-  def test_should_raise_assertion_error_for_unexpected_method_call
-    mock = build_mock
-    error = assert_raises(ExpectationErrorFactory.exception_class) do
-      mock.unexpected_method_called(:my_method, :argument1, :argument2)
-    end
-    assert_match(/unexpected invocation/, error.message)
-    assert_match(/my_method/, error.message)
-    assert_match(/argument1/, error.message)
-    assert_match(/argument2/, error.message)
-  end
-
-  def test_should_not_verify_successfully_because_not_all_expectations_have_been_satisfied
-    mock = build_mock
-    mock.expects(:method1)
-    mock.expects(:method2)
-    mock.method1
-    assert !mock.__verified__?
-  end
-
-  def test_should_increment_assertion_counter_for_every_verified_expectation
-    mock = build_mock
-
-    mock.expects(:method1)
-    mock.method1
-
-    mock.expects(:method2)
-    mock.method2
-
-    assertion_counter = SimpleCounter.new
-
-    mock.__verified__?(assertion_counter)
-
-    assert_equal 2, assertion_counter.count
-  end
-
-  def test_should_yield_supplied_parameters_to_block
-    mock = build_mock
-    parameters_for_yield = [1, 2, 3]
-    mock.expects(:method1).yields(*parameters_for_yield)
-    yielded_parameters = nil
-    mock.method1 { |*parameters| yielded_parameters = parameters }
-    assert_equal parameters_for_yield, yielded_parameters
-  end
-
-  def test_should_set_up_multiple_expectations_with_return_values
-    mock = build_mock
-    mock.expects(:method1 => :result1, :method2 => :result2)
-    assert_equal :result1, mock.method1
-    assert_equal :result2, mock.method2
-  end
-
-  def test_should_set_up_multiple_stubs_with_return_values
-    mock = build_mock
-    mock.stubs(:method1 => :result1, :method2 => :result2)
-    assert_equal :result1, mock.method1
-    assert_equal :result2, mock.method2
-  end
-
-  def test_should_keep_returning_specified_value_for_stubs
-    mock = build_mock
-    mock.stubs(:method1).returns(1)
-    assert_equal 1, mock.method1
-    assert_equal 1, mock.method1
-  end
-
-  def test_should_keep_returning_specified_value_for_expects
-    mock = build_mock
-    mock.expects(:method1).times(2).returns(1)
-    assert_equal 1, mock.method1
-    assert_equal 1, mock.method1
-  end
-
-  def test_should_match_most_recent_call_to_expects
-    mock = build_mock
-    mock.expects(:method1).returns(0)
-    mock.expects(:method1).returns(1)
-    assert_equal 1, mock.method1
-  end
-
-  def test_should_match_most_recent_call_to_stubs
-    mock = build_mock
-    mock.stubs(:method1).returns(0)
-    mock.stubs(:method1).returns(1)
-    assert_equal 1, mock.method1
-  end
-
-  def test_should_match_most_recent_call_to_stubs_or_expects
-    mock = build_mock
-    mock.stubs(:method1).returns(0)
-    mock.expects(:method1).returns(1)
-    assert_equal 1, mock.method1
-  end
-
-  def test_should_match_most_recent_call_to_expects_or_stubs
-    mock = build_mock
-    mock.expects(:method1).returns(0)
-    mock.stubs(:method1).returns(1)
-    assert_equal 1, mock.method1
-  end
-
-  def test_should_respond_to_expected_method
-    mock = build_mock
-    mock.expects(:method1)
-    assert_equal true, mock.respond_to?(:method1)
-  end
-
-  def test_should_respond_to_expected_method_as_string
-    mock = build_mock
-    mock.expects(:method1)
-    assert_equal true, mock.respond_to?('method1')
-  end
-
-  def test_should_not_respond_to_unexpected_method
-    mock = build_mock
-    assert_equal false, mock.respond_to?(:method1)
-  end
-
-  def test_should_respond_to_methods_which_the_responder_does_responds_to
-    instance = Class.new do
-      define_method(:respond_to?) { |_symbol| true }
-    end.new
-    mock = build_mock
-    mock.responds_like(instance)
-    assert_equal true, mock.respond_to?(:invoked_method)
-  end
-
-  def test_should_not_respond_to_methods_which_the_responder_does_not_responds_to
-    instance = Class.new do
-      define_method(:respond_to?) { |_symbol| false }
-    end.new
-    mock = build_mock
-    mock.responds_like(instance)
-    assert_equal false, mock.respond_to?(:invoked_method)
-  end
-
-  def test_should_respond_to_methods_which_the_responder_instance_does_responds_to
-    klass = Class.new do
-      define_method(:respond_to?) { |_symbol| true }
-    end
-    mock = build_mock
-    mock.responds_like_instance_of(klass)
-    assert_equal true, mock.respond_to?(:invoked_method)
-  end
-
-  def test_should_not_respond_to_methods_which_the_responder_instance_does_not_responds_to
-    klass = Class.new do
-      define_method(:respond_to?) { |_symbol| false }
-    end
-    mock = build_mock
-    mock.responds_like_instance_of(klass)
-    assert_equal false, mock.respond_to?(:invoked_method)
-  end
-
-  def test_respond_like_should_return_itself_to_allow_method_chaining
-    mock = build_mock
-    assert_same mock.responds_like(Object.new), mock
-  end
-
-  def test_respond_like_instance_of_should_return_itself_to_allow_method_chaining
-    mock = build_mock
-    assert_same mock.responds_like_instance_of(Object), mock
-  end
-
-  def test_should_not_raise_no_method_error_if_mock_is_not_restricted_to_respond_like_a_responder
-    mock = build_mock
-    mock.stubs(:invoked_method)
-    assert_nothing_raised(NoMethodError) { mock.invoked_method }
-  end
-
-  def test_should_not_raise_no_method_error_if_responder_does_respond_to_invoked_method
-    instance = Class.new do
-      define_method(:respond_to?) { |_symbol| true }
-    end.new
-    mock = build_mock
-    mock.responds_like(instance)
-    mock.stubs(:invoked_method)
-    assert_nothing_raised(NoMethodError) { mock.invoked_method }
-  end
-
-  def test_should_raise_no_method_error_if_responder_does_not_respond_to_invoked_method
-    instance = Class.new do
-      define_method(:respond_to?) { |_symbol| false }
-      define_method(:mocha_inspect) { 'mocha_inspect' }
-    end.new
-    mock = build_mock
-    mock.responds_like(instance)
-    mock.stubs(:invoked_method)
-    assert_raises(NoMethodError) { mock.invoked_method }
-  end
-
-  def test_should_raise_no_method_error_with_message_indicating_that_mock_is_constrained_to_respond_like_responder
-    instance = Class.new do
-      define_method(:respond_to?) { |_symbol| false }
-      define_method(:mocha_inspect) { 'mocha_inspect' }
-    end.new
-    mock = build_mock
-    mock.responds_like(instance)
-    mock.stubs(:invoked_method)
-    begin
-      mock.invoked_method
-    rescue NoMethodError => e
-      assert_match(/which responds like mocha_inspect/, e.message)
-    end
-  end
-
-  def test_should_handle_respond_to_with_private_methods_param_without_error
-    mock = build_mock
-    assert_nothing_raised { mock.respond_to?(:object_id, false) }
-  end
-
-  def test_should_respond_to_any_method_if_stubbing_everything
-    mock = build_mock
-    mock.stub_everything
-    assert mock.respond_to?(:abc)
-    assert mock.respond_to?(:xyz)
-  end
-
-  def test_should_remove_expectations_for_unstubbed_methods
-    mock = build_mock
-    mock.expects(:method1)
-    mock.expects(:method2)
-    mock.unstub(:method1, :method2)
-    e = assert_raises(ExpectationErrorFactory.exception_class) { mock.method1 }
-    assert_match(/unexpected invocation/, e.message)
-    e = assert_raises(ExpectationErrorFactory.exception_class) { mock.method2 }
-    assert_match(/unexpected invocation/, e.message)
-  end
-
-  unless PRE_RUBY_V19
-    def test_expectation_is_defined_on_mock
-      mock = build_mock
-      mock.expects(:method1)
-      assert defined? mock.method1
-    end
-  end
-
-  private
-
-  def build_mock
-    Mock.new(nil)
-  end
-end