ceedling 0.0.2 → 0.0.3

data/new_project_template/vendor/ceedling/vendor/hardmock/test/functional/direct_mock_usage_test.rb

@@ -1,396 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
-require 'hardmock'
-
-class DirectMockUsageTest < Test::Unit::TestCase
-
-  def setup
-    @bird = Mock.new('bird')
-  end
-
-  def teardown
-  end
-
-  #
-  # TESTS
-  #
-
-  it "raises VerifyError if expected method not called" do
-    @bird.expects.flap_flap
-
-    err = assert_raise VerifyError do
-      @bird._verify
-    end
-    assert_match(/unmet expectations/i, err.message)
-  end
-
-  should "not raise when expected calls are made in order" do
-    @bird.expects.flap_flap
-    @bird.expects.bang
-    @bird.expects.plop
-
-    @bird.flap_flap
-    @bird.bang
-    @bird.plop
-
-    @bird._verify
-  end
-
-  it "raises ExpectationError when unexpected method are called" do
-    @bird.expects.flap_flap
-
-    err = assert_raise ExpectationError do
-      @bird.shoot
-    end
-    assert_match(/wrong method/i, err.message) 
-  end
-
-  it "raises ExpectationError on bad arguments" do
-    @bird.expects.flap_flap(:swoosh)
-
-    err = assert_raise ExpectationError do
-      @bird.flap_flap(:rip)
-    end
-    assert_match(/wrong arguments/i, err.message) 
-  end
-  
-  it "raises VerifyError when not all expected methods are called" do
-    @bird.expects.flap_flap
-    @bird.expects.bang
-    @bird.expects.plop
-
-    @bird.flap_flap
-
-    err = assert_raise VerifyError do
-      @bird._verify
-    end
-    assert_match(/unmet expectations/i, err.message)
-  end
-
-  it "raises ExpectationError when calls are made out of order" do
-    @bird.expects.flap_flap
-    @bird.expects.bang
-    @bird.expects.plop
-
-    @bird.flap_flap
-    err = assert_raise ExpectationError do
-      @bird.plop
-    end
-    assert_match(/wrong method/i, err.message) 
-  end
-
-  it "returns the configured value" do 
-    @bird.expects.plop.returns(':P')
-    assert_equal ':P', @bird.plop
-    @bird._verify
-
-    @bird.expects.plop.returns(':x')
-    assert_equal ':x', @bird.plop
-    @bird._verify
-  end
-
-  it "returns nil when no return is specified" do
-    @bird.expects.plop
-    assert_nil @bird.plop
-    @bird._verify
-  end
-
-  it "raises the configured exception" do
-    err = RuntimeError.new('shaq')
-    @bird.expects.plop.raises(err)
-    actual_err = assert_raise RuntimeError do
-      @bird.plop
-    end
-    assert_same err, actual_err, 'should be the same error'
-    @bird._verify
-  end
-
-  it "raises a RuntimeError when told to 'raise' a string" do
-    @bird.expects.plop.raises('shaq')
-    err = assert_raise RuntimeError do
-      @bird.plop
-    end
-    assert_match(/shaq/i, err.message) 
-    @bird._verify
-  end
-
-  it "raises a default RuntimeError" do
-    @bird.expects.plop.raises
-    err = assert_raise RuntimeError do
-      @bird.plop
-    end
-    assert_match(/error/i, err.message) 
-    @bird._verify
-  end
-
-  it "is quiet when correct arguments given" do
-    thing = Object.new
-    @bird.expects.plop(:big,'one',thing)
-    @bird.plop(:big,'one',thing)
-    @bird._verify
-  end
-
-  it "raises ExpectationError when wrong number of arguments specified" do
-    thing = Object.new
-    @bird.expects.plop(:big,'one',thing)
-    err = assert_raise ExpectationError do
-      # more
-      @bird.plop(:big,'one',thing,:other)
-    end
-    assert_match(/wrong arguments/i, err.message)
-    @bird._verify
-
-    @bird.expects.plop(:big,'one',thing)
-    err = assert_raise ExpectationError do
-      # less
-      @bird.plop(:big,'one')
-    end
-    assert_match(/wrong arguments/i, err.message)
-    @bird._verify
-    
-    @bird.expects.plop
-    err = assert_raise ExpectationError do
-      # less
-      @bird.plop(:big)
-    end
-    assert_match(/wrong arguments/i, err.message)
-    @bird._verify
-  end
-
-  it "raises ExpectationError when arguments don't match" do
-    thing = Object.new
-    @bird.expects.plop(:big,'one',thing)
-    err = assert_raise ExpectationError do
-      @bird.plop(:big,'two',thing,:other)
-    end
-    assert_match(/wrong arguments/i, err.message)
-    @bird._verify
-  end
-
-  it "can use a block for custom reactions" do
-    mitt = nil
-    @bird.expects.plop { mitt = :ball }
-    assert_nil mitt
-    @bird.plop
-    assert_equal :ball, mitt, 'didnt catch the ball'
-    @bird._verify
-
-    @bird.expects.plop { raise 'ball' }
-    err = assert_raise RuntimeError do
-      @bird.plop
-    end
-    assert_match(/ball/i, err.message) 
-    @bird._verify
-  end
-
-  it "passes mock-call arguments to the expectation block" do
-    ball = nil
-    mitt = nil
-    @bird.expects.plop {|arg1,arg2| 
-      ball = arg1  
-      mitt = arg2  
-    }
-    assert_nil ball
-    assert_nil mitt
-    @bird.plop(:ball,:mitt)
-    assert_equal :ball, ball
-    assert_equal :mitt, mitt
-    @bird._verify
-  end
-
-  it "validates arguments if specified in addition to a block" do
-    ball = nil
-    mitt = nil
-    @bird.expects.plop(:ball,:mitt) {|arg1,arg2| 
-      ball = arg1  
-      mitt = arg2  
-    }
-    assert_nil ball
-    assert_nil mitt
-    @bird.plop(:ball,:mitt)
-    assert_equal :ball, ball
-    assert_equal :mitt, mitt
-    @bird._verify
-
-    ball = nil
-    mitt = nil
-    @bird.expects.plop(:bad,:stupid) {|arg1,arg2| 
-      ball = arg1  
-      mitt = arg2  
-    }
-    assert_nil ball
-    assert_nil mitt
-    err = assert_raise ExpectationError do
-      @bird.plop(:ball,:mitt)
-    end
-    assert_match(/wrong arguments/i, err.message) 
-    assert_nil ball
-    assert_nil mitt
-    @bird._verify
-
-    ball = nil
-    mitt = nil
-    @bird.expects.plop(:ball,:mitt) {|arg1,arg2| 
-      ball = arg1  
-      mitt = arg2  
-    }
-    assert_nil ball
-    assert_nil mitt
-    err = assert_raise ExpectationError do
-      @bird.plop(:ball)
-    end
-    assert_match(/wrong arguments/i, err.message) 
-    assert_nil ball
-    assert_nil mitt
-    @bird._verify
-  end
-
-  it "passes runtime blocks to the expectation block as the final argument" do
-    runtime_block_called = false
-    got_arg = nil
-
-    # Eg, bird expects someone to subscribe to :tweet using the 'when' method
-    @bird.expects.when(:tweet) { |arg1, block| 
-      got_arg = arg1
-      block.call
-    }
-
-    @bird.when(:tweet) do 
-      runtime_block_called = true
-    end
-
-    assert_equal :tweet, got_arg, "Wrong arg"
-    assert runtime_block_called, "The runtime block should have been invoked by the user block"
-
-    @bird.expects.when(:warnk) { |e,blk| }
-
-    err = assert_raise ExpectationError do
-      @bird.when(:honk) { }
-    end
-    assert_match(/wrong arguments/i, err.message) 
-
-    @bird._verify
-  end
-
-  it "passes the runtime block to the expectation block as sole argument if no other args come into play" do
-    runtime_block_called = false
-    @bird.expects.subscribe { |block| block.call }
-    @bird.subscribe do 
-      runtime_block_called = true
-    end
-    assert runtime_block_called, "The runtime block should have been invoked by the user block"
-  end
-
-  it "provides nil as final argument if expectation block seems to want a block" do
-    invoked = false
-    @bird.expects.kablam(:scatter) { |shot,block| 
-      assert_equal :scatter, shot, "Wrong shot"
-      assert_nil block, "The expectation block should get a nil block when user neglects to pass one"
-      invoked = true
-    }
-    @bird.kablam :scatter
-    assert invoked, "Expectation block not invoked"
-
-    @bird._verify
-  end
-
-  it "can set explicit return after an expectation block" do
-    got = nil
-    @bird.expects.kablam(:scatter) { |shot|
-      got = shot
-    }.returns(:death)
-
-    val = @bird.kablam :scatter 
-    assert_equal :death, val, "Wrong return value"
-    assert_equal :scatter, got, "Wrong argument"
-    @bird._verify
-  end
-
-  it "can raise after an expectation block" do
-    got = nil
-    @bird.expects.kablam(:scatter) do |shot|
-      got = shot
-    end.raises "hell"
-
-    err = assert_raise RuntimeError do
-      @bird.kablam :scatter 
-    end
-    assert_match(/hell/i, err.message) 
-
-    @bird._verify
-  end
-
-  it "stores the semantic value of the expectation block after it executes" do
-    expectation = @bird.expects.kablam(:slug) { |shot|
-      "The shot was #{shot}"
-    }
-
-    assert_not_nil expectation, "Expectation nil"
-    assert_nil expectation.block_value, "Block value should start out nil"
-
-    ret_val = @bird.kablam :slug 
-
-    assert_equal "The shot was slug", expectation.block_value
-    assert_equal "The shot was slug", ret_val, "Block value should also be used for return"
-
-    @bird._verify
-  end
-
-
-  it "uses the value of the expectation block as the default return value" do 
-    @bird.expects.kablam(:scatter) { |shot|
-      "The shot was #{shot}"
-    }
-    val = @bird.kablam :scatter 
-    assert_equal "The shot was scatter", val, "Wrong return value"
-    @bird._verify
-  end
-
-  it "returns the Expectation even if 'returns' is used" do
-    expectation = @bird.expects.kablam(:slug) { |shot|
-      "The shot was #{shot}"
-    }.returns :hosed
-
-    assert_not_nil expectation, "Expectation nil"
-    assert_nil expectation.block_value, "Block value should start out nil"
-
-    ret_val = @bird.kablam :slug 
-
-    assert_equal "The shot was slug", expectation.block_value
-    assert_equal :hosed, ret_val, "Block value should also be used for return"
-
-    @bird._verify
-  end
-
-  it "returns the Expectation even if 'raises' is used" do
-    expectation = @bird.expects.kablam(:slug) { |shot|
-      "The shot was #{shot}"
-    }.raises "aiee!"
-
-    assert_not_nil expectation, "Expectation nil"
-    assert_nil expectation.block_value, "Block value should start out nil"
-
-    err = assert_raise RuntimeError do
-     @bird.kablam :slug 
-    end
-    assert_match(/aiee!/i, err.message)
-    assert_equal "The shot was slug", expectation.block_value
-    @bird._verify
-  end
-
-
-  it "supports assignment-style methods" do
-    @bird.expects.size = "large"
-    @bird.size = "large"
-    @bird._verify
-  end
-
-  it "supports assignments and raising (using explicit-method syntax)" do
-    @bird.expects('size=','large').raises "boom"
-
-    err = assert_raise RuntimeError do
-      @bird.size = "large"
-    end
-    assert_match(/boom/i, err.message) 
-  end
-
-end

data/new_project_template/vendor/ceedling/vendor/hardmock/test/functional/hardmock_test.rb

@@ -1,434 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
-require 'hardmock'
-require 'assert_error'
-
-class HardmockTest < Test::Unit::TestCase
-
-  #
-  # TESTS
-  # 
-
-  it "conveniently creates mocks using create_mock and create_mocks" do
-
-    h = create_mock :donkey
-    assert_equal [ :donkey ], h.keys
-
-    assert_mock_exists :donkey
-    assert_same @donkey, h[:donkey]
-
-    assert_equal [ :donkey ], @all_mocks.keys, "Wrong keyset for @all_mocks"
-
-    h2 = create_mocks :cat, 'dog' # symbol/string indifference at this level
-    assert_equal [:cat,:dog].to_set, h2.keys.to_set, "Wrong keyset for second hash"
-    assert_equal [:cat,:dog,:donkey].to_set, @all_mocks.keys.to_set, "@all_mocks wrong"   
-
-    assert_mock_exists :cat
-    assert_same @cat, h2[:cat]
-    assert_mock_exists :dog
-    assert_same @dog, h2[:dog]
-
-    assert_mock_exists :donkey
-  end
-
-  it "provides literal 'expects' syntax" do 
-    assert_nil @order, "Should be no @order yet"
-    create_mock :order
-    assert_not_nil @order, "@order should be built"
-
-    # Setup an expectation
-    @order.expects.update_stuff :key1 => 'val1', :key2 => 'val2'
-
-    # Use the mock
-    @order.update_stuff :key1 => 'val1', :key2 => 'val2'
-
-    # Verify
-    verify_mocks
-
-    # See that it's ok to do it again
-    verify_mocks
-  end
-
-  it "supports 'with' for specifying argument expectations" do
-    create_mocks :car
-    @car.expects(:fill).with('gas','booze')
-    @car.fill('gas', 'booze')
-    verify_mocks
-  end
-
-  it "supports several mocks at once" do
-    create_mocks :order_builder, :order, :customer
-
-    @order_builder.expects.create_new_order.returns @order
-    @customer.expects.account_number.returns(1234)
-    @order.expects.account_no = 1234
-    @order.expects.save!
-
-    # Run "the code"
-    o = @order_builder.create_new_order
-    o.account_no = @customer.account_number
-    o.save!
-
-    verify_mocks
-  end
-
-  it "enforces inter-mock call ordering" do
-    create_mocks :order_builder, :order, :customer
-
-    @order_builder.expects.create_new_order.returns @order
-    @customer.expects.account_number.returns(1234)
-    @order.expects.account_no = 1234
-    @order.expects.save!
-
-    # Run "the code"
-    o = @order_builder.create_new_order
-    err = assert_raise ExpectationError do
-      o.save!
-    end
-    assert_match(/wrong object/i, err.message) 
-    assert_match(/order.save!/i, err.message) 
-    assert_match(/customer.account_number/i, err.message) 
-
-    assert_error VerifyError, /unmet expectations/i do
-      verify_mocks
-    end
-  end
-
-  class UserPresenter
-    def initialize(args)
-      view = args[:view]
-      model = args[:model]
-      model.when :data_changes do
-        view.user_name = model.user_name
-      end
-      view.when :user_edited do
-        model.user_name = view.user_name
-      end
-    end
-  end
-
-  it "makes MVP testing simple" do
-    mox = create_mocks :model, :view
-
-    data_change = @model.expects.when(:data_changes) { |evt,block| block }
-    user_edit = @view.expects.when(:user_edited) { |evt,block| block }
-    
-    UserPresenter.new mox
-
-    # Expect user name transfer from model to view
-    @model.expects.user_name.returns 'Da Croz'
-    @view.expects.user_name = 'Da Croz'
-    # Trigger data change event in model
-    data_change.block_value.call
-
-    # Expect user name transfer from view to model
-    @view.expects.user_name.returns '6:8'
-    @model.expects.user_name = '6:8'
-    # Trigger edit event in view
-    user_edit.block_value.call
-
-    verify_mocks 
-  end
-
-  it "continues to function after verify, if verification error is controlled" do
-    mox = create_mocks :model, :view
-    data_change = @model.expects.when(:data_changes) { |evt,block| block }
-    user_edit = @view.expects.when(:user_edited) { |evt,block| block }
-    UserPresenter.new mox
-
-    # Expect user name transfer from model to view
-    @model.expects.user_name.returns 'Da Croz'
-    @view.expects.user_name = 'Da Croz'
-
-    assert_error ExpectationError, /model.monkey_wrench/i do
-      @model.monkey_wrench
-    end
-
-    # This should raise because of unmet expectations
-    assert_error VerifyError, /unmet expectations/i, /user_name/i do
-      verify_mocks
-    end
-
-    # See that the non-forced verification remains quiet
-    assert_nothing_raised VerifyError do
-      verify_mocks(false)
-    end
-    
-    @model.expects.never_gonna_happen
-    
-    assert_error VerifyError, /unmet expectations/i, /never_gonna_happen/i do
-      verify_mocks
-    end
-  end
-
-  class UserPresenterBroken
-    def initialize(args)
-      view = args[:view]
-      model = args[:model]
-      model.when :data_changes do
-        view.user_name = model.user_name
-      end
-      # no view stuff, will break appropriately
-    end
-  end
-
-  it "flunks for typical Presenter constructor wiring failure" do
-    mox = create_mocks :model, :view
-
-    data_change = @model.expects.when(:data_changes) { |evt,block| block }
-    user_edit = @view.expects.when(:user_edited) { |evt,block| block }
-    
-    UserPresenterBroken.new mox
-
-    err = assert_raise VerifyError do
-      verify_mocks
-    end
-    assert_match(/unmet expectations/i, err.message) 
-    assert_match(/view.when\(:user_edited\)/i, err.message) 
-
-  end
-
-  it "provides convenient event-subscription trap syntax for MVP testing" do
-    mox = create_mocks :model, :view
-
-    data_change = @model.trap.when(:data_changes) 
-    user_edit = @view.trap.when(:user_edited) 
-    
-    UserPresenter.new mox
-
-    # Expect user name transfer from model to view
-    @model.expects.user_name.returns 'Da Croz'
-    @view.expects.user_name = 'Da Croz'
-    # Trigger data change event in model
-    data_change.trigger
-
-    # Expect user name transfer from view to model
-    @view.expects.user_name.returns '6:8'
-    @model.expects.user_name = '6:8'
-    # Trigger edit event in view
-    user_edit.trigger
-
-    verify_mocks 
-  end
-
-  it "raises if you try to pass an expectation block to 'trap'" do
-    create_mock :model
-    assert_error Hardmock::ExpectationError, /blocks/i, /trap/i do
-      @model.trap.when(:some_event) do raise "huh?" end
-    end
-  end
-
-  class Grinder
-    def initialize(objects)
-      @chute = objects[:chute]
-      @bucket = objects[:bucket]
-      @blade = objects[:blade]
-    end
-
-    def grind(slot)
-      @chute.each_bean(slot) do |bean|
-        @bucket << @blade.chop(bean)
-      end
-    end
-  end
-
-  it "lets you write clear iteration-oriented expectations" do
-    grinder = Grinder.new create_mocks(:blade, :chute, :bucket)
-    
-    # Style 1: assertions on method args is done explicitly in block
-    @chute.expects.each_bean { |slot,block| 
-      assert_equal :side_slot, slot, "Wrong slot"
-      block.call :bean1
-      block.call :bean2
-    }
-
-    @blade.expects.chop(:bean1).returns(:grounds1)
-    @bucket.expects('<<', :grounds1)
-
-    @blade.expects.chop(:bean2).returns(:grounds2)
-    @bucket.expects('<<', :grounds2)
-
-    # Run "the code"
-    grinder.grind(:side_slot)
-
-    verify_mocks
-
-    # Style 2: assertions on method arguments done implicitly in the expectation code
-    @chute.expects.each_bean(:main_slot) { |slot,block| 
-      block.call :bean3
-    }
-    @blade.expects.chop(:bean3).returns(:grounds3)
-    @bucket.expects('<<', :grounds3)
-    grinder.grind :main_slot
-    verify_mocks
-  end
-
-  it "further supports iteration testing using 'yield'" do
-    grinder = Grinder.new create_mocks(:blade, :chute, :bucket)
-    
-    @chute.expects.each_bean(:side_slot).yields :bean1, :bean2
-
-    @blade.expects.chop(:bean1).returns(:grounds1)
-    @bucket.expects('<<', :grounds1)
-
-    @blade.expects.chop(:bean2).returns(:grounds2)
-    @bucket.expects('<<', :grounds2)
-
-    grinder.grind :side_slot
-
-    verify_mocks
-  end
-
-  class HurtLocker
-    attr_reader :caught
-    def initialize(opts)
-      @locker = opts[:locker]
-      @store = opts[:store]
-    end
-
-    def do_the_thing(area,data)
-      @locker.with_lock(area) do
-        @store.eat(data)
-      end
-    rescue => oops
-      @caught = oops
-    end
-  end
-
-  it "makes mutex-style locking scenarios easy to test" do
-    hurt = HurtLocker.new create_mocks(:locker, :store)
-
-    @locker.expects.with_lock(:main).yields
-    @store.expects.eat("some info")
-
-    hurt.do_the_thing(:main, "some info")
-
-    verify_mocks
-  end
-
-  it "makes it easy to simulate error in mutex-style locking scenarios" do 
-    hurt = HurtLocker.new create_mocks(:locker, :store)
-    err = StandardError.new('fmshooop')  
-    @locker.expects.with_lock(:main).yields
-    @store.expects.eat("some info").raises(err)
-
-    hurt.do_the_thing(:main, "some info")
-
-    assert_same err, hurt.caught, "Expected that error to be handled internally"
-    verify_mocks
-  end
-	
-  it "actually returns 'false' instead of nil when mocking boolean return values" do
-		create_mock :car
-		@car.expects.ignition_on?.returns(true)
-		assert_equal true, @car.ignition_on?, "Should be true"
-		@car.expects.ignition_on?.returns(false)
-		assert_equal false, @car.ignition_on?, "Should be false"
-	end
-
-  it "can mock most methods inherited from object using literal syntax" do
-    target_methods = %w|id clone display dup eql? ==|
-    create_mock :foo
-    target_methods.each do |m|
-      eval %{@foo.expects(m, "some stuff")}
-      eval %{@foo.#{m} "some stuff"}
-    end
-  end
-
-  it "provides 'expect' as an alias for 'expects'" do
-    create_mock :foo
-    @foo.expect.boomboom
-    @foo.boomboom
-    verify_mocks 
-  end
-
-  it "provides 'should_receive' as an alias for 'expects'" do
-    create_mock :foo
-    @foo.should_receive.boomboom
-    @foo.boomboom
-    verify_mocks 
-  end
-
-  it "provides 'and_return' as an alias for 'returns'" do
-    create_mock :foo
-    @foo.expects(:boomboom).and_return :brick
-    assert_equal :brick, @foo.boomboom
-    verify_mocks 
-  end
-
-  it "does not interfere with a core subset of Object methods" do 
-    create_mock :foo
-    @foo.method(:inspect)
-    @foo.inspect
-    @foo.to_s
-    @foo.instance_variables
-    @foo.instance_eval("")
-    verify_mocks 
-  end
-
-  it "can raise errors from within an expectation block" do
-    create_mock :cat
-    @cat.expects.meow do |arg|
-      assert_equal "mix", arg
-      raise 'HAIRBALL'
-    end
-    assert_error RuntimeError, 'HAIRBALL' do 
-      @cat.meow("mix")
-    end
-  end
-
-  it "can raise errors AFTER an expectation block" do
-    create_mock :cat
-    @cat.expects.meow do |arg|
-      assert_equal "mix", arg
-    end.raises('HAIRBALL')
-    assert_error RuntimeError, 'HAIRBALL' do 
-      @cat.meow("mix")
-    end
-  end
-
-  it "raises an immediate error if a mock is created with a nil name (common mistake: create_mock @cat)" do
-    # I make this mistake all the time: Typing in an instance var name instead of a symbol in create_mocks.
-    # When you do that, you're effectively passing nil(s) in as mock names.
-    assert_error ArgumentError, /'nil' is not a valid name for a mock/ do
-      create_mocks @apples, @oranges
-    end
-  end
-
-  it "overrides 'inspect' to make nice output" do
-    create_mock :hay_bailer
-    assert_equal "<Mock hay_bailer>", @hay_bailer.inspect, "Wrong output from 'inspect'"
-  end
-
-  it "raises if prepare_hardmock_control is invoked after create_mocks, or more than once" do
-    create_mock :hi_there
-    create_mocks :another, :one
-    assert_error RuntimeError, /already setup/ do
-      prepare_hardmock_control
-    end
-  end
-
-  should "support alias verify_hardmocks" do
-    create_mock :tree
-    @tree.expects(:grow)
-    assert_error VerifyError, /unmet/i do
-      verify_hardmocks
-    end
-  end
-
-  #
-  # HELPERS
-  #
-
-  def assert_mock_exists(name)
-    assert_not_nil @all_mocks, "@all_mocks not here yet"
-    mo = @all_mocks[name]
-    assert_not_nil mo, "Mock '#{name}' not in @all_mocks"
-    assert_kind_of Mock, mo, "Wrong type of object, wanted a Mock"
-    assert_equal name.to_s, mo._name, "Mock '#{name}' had wrong name"
-    ivar = self.instance_variable_get("@#{name}")
-    assert_not_nil ivar, "Mock '#{name}' not set as ivar"
-    assert_same mo, ivar, "Mock '#{name}' ivar not same as instance in @all_mocks"
-    assert_same @main_mock_control, mo._control, "Mock '#{name}' doesn't share the main mock control"
-  end
-end
-