ceedling 0.13.0.rc1 → 0.13.0

data/vendor/cmock/vendor/hardmock/test/functional/hardmock_test.rb

@@ -0,0 +1,434 @@
+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
+

data/vendor/cmock/vendor/hardmock/test/functional/stubbing_test.rb

@@ -0,0 +1,479 @@
+require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+require 'hardmock'
+require 'assert_error'
+
+class StubbingTest < Test::Unit::TestCase
+
+  #
+  # TESTS
+  # 
+
+  it "stubs a class method (and un-stubs after reset_stubs)" do
+    assert_equal "stones and gravel", Concrete.pour
+    assert_equal "glug glug", Jug.pour
+
+    Concrete.stubs!(:pour).returns("dust and plaster")
+
+    3.times do
+      assert_equal "dust and plaster", Concrete.pour
+    end
+
+    assert_equal "glug glug", Jug.pour, "Jug's 'pour' method broken"
+    assert_equal "stones and gravel", Concrete._hardmock_original_pour, "Original 'pour' method not aliased"
+
+    assert_equal "For roads", Concrete.describe, "'describe' method broken"
+
+    reset_stubs
+
+    assert_equal "stones and gravel", Concrete.pour, "'pour' method not restored"
+    assert_equal "For roads", Concrete.describe, "'describe' method broken after verify"
+
+  end
+
+  it "stubs several class methods" do
+    Concrete.stubs!(:pour).returns("sludge")
+    Concrete.stubs!(:describe).returns("awful")
+    Jug.stubs!(:pour).returns("milk")
+
+    assert_equal "sludge", Concrete.pour
+    assert_equal "awful", Concrete.describe
+    assert_equal "milk", Jug.pour
+
+    reset_stubs
+
+    assert_equal "stones and gravel", Concrete.pour
+    assert_equal "For roads", Concrete.describe
+    assert_equal "glug glug", Jug.pour
+  end
+
+  it "stubs instance methods" do
+    slab = Concrete.new
+    assert_equal "bonk", slab.hit
+
+    slab.stubs!(:hit).returns("slap")
+    assert_equal "slap", slab.hit, "'hit' not stubbed"
+
+    reset_stubs
+
+    assert_equal "bonk", slab.hit, "'hit' not restored"
+  end
+
+  it "stubs instance methods without breaking class methods or other instances" do
+    slab = Concrete.new
+    scrape = Concrete.new
+    assert_equal "an instance", slab.describe
+    assert_equal "an instance", scrape.describe
+    assert_equal "For roads", Concrete.describe
+
+    slab.stubs!(:describe).returns("new instance describe")
+    assert_equal "new instance describe", slab.describe, "'describe' on instance not stubbed"
+    assert_equal "an instance", scrape.describe, "'describe' on 'scrape' instance broken"
+    assert_equal "For roads", Concrete.describe, "'describe' class method broken"
+
+    reset_stubs
+
+    assert_equal "an instance", slab.describe, "'describe' instance method not restored"
+    assert_equal "an instance", scrape.describe, "'describe' on 'scrape' instance broken after restore"
+    assert_equal "For roads", Concrete.describe, "'describe' class method broken after restore"
+  end
+
+  should "allow stubbing of nonexistant class methods" do
+    Concrete.stubs!(:funky).returns('juice')
+    assert_equal 'juice', Concrete.funky
+  end
+
+  should "allow stubbing of nonexistant instance methods" do
+    chunk = Concrete.new
+    chunk.stubs!(:shark).returns('bite')
+    assert_equal 'bite', chunk.shark
+  end
+
+  should "allow re-stubbing" do
+    Concrete.stubs!(:pour).returns("one")
+    assert_equal "one", Concrete.pour
+
+    Concrete.stubs!(:pour).raises("hell")
+    assert_error RuntimeError, /hell/ do
+      Concrete.pour
+    end
+
+    Concrete.stubs!(:pour).returns("two")
+    assert_equal "two", Concrete.pour
+
+    reset_stubs
+
+    assert_equal "stones and gravel", Concrete.pour
+  end
+
+  it "does nothing with a runtime block when simply stubbing" do
+    slab = Concrete.new
+    slab.stubs!(:hit) do |nothing|
+      raise "BOOOMM!"
+    end
+    slab.hit
+    reset_stubs
+  end
+
+  it "can raise errors from a stubbed method" do
+    Concrete.stubs!(:pour).raises(StandardError.new("no!"))
+    assert_error StandardError, /no!/ do
+      Concrete.pour
+    end
+  end
+
+  it "provides string syntax for convenient raising of RuntimeErrors" do
+    Concrete.stubs!(:pour).raises("never!")
+    assert_error RuntimeError, /never!/ do
+      Concrete.pour
+    end
+  end
+
+
+  #
+  # Per-method mocking on classes or instances
+  #
+
+  it "mocks specific methods on existing classes, and returns the class method to normal after verification" do
+    
+    assert_equal "stones and gravel", Concrete.pour, "Concrete.pour is already messed up"
+
+    Concrete.expects!(:pour).returns("ALIGATORS")
+    assert_equal "ALIGATORS", Concrete.pour
+
+    verify_mocks
+    assert_equal "stones and gravel", Concrete.pour, "Concrete.pour not restored"
+  end
+   
+  it "flunks if expected class method is not invoked" do
+    
+    Concrete.expects!(:pour).returns("ALIGATORS")
+    assert_error(Hardmock::VerifyError, /Concrete.pour/, /unmet expectations/i) do
+      verify_mocks
+    end
+    clear_expectations
+  end
+
+  it "supports all normal mock functionality for class methods" do
+    
+    Concrete.expects!(:pour, "two tons").returns("mice")
+    Concrete.expects!(:pour, "three tons").returns("cats")
+    Concrete.expects!(:pour, "four tons").raises("Can't do it")
+    Concrete.expects!(:pour) do |some, args|
+      "==#{some}+#{args}=="
+    end
+
+    assert_equal "mice", Concrete.pour("two tons")
+    assert_equal "cats", Concrete.pour("three tons")
+    assert_error(RuntimeError, /Can't do it/) do 
+      Concrete.pour("four tons")
+    end
+    assert_equal "==first+second==", Concrete.pour("first","second")
+  end
+
+
+  it "enforces inter-mock ordering when mocking class methods" do
+    create_mocks :truck, :foreman
+    
+    @truck.expects.backup
+    Concrete.expects!(:pour, "something")
+    @foreman.expects.shout
+
+    @truck.backup
+    assert_error Hardmock::ExpectationError, /wrong/i, /expected call/i, /Concrete.pour/ do
+      @foreman.shout
+    end
+    assert_error Hardmock::VerifyError, /unmet expectations/i, /foreman.shout/ do
+      verify_mocks
+    end
+    clear_expectations
+  end
+
+  should "allow mocking non-existant class methods" do
+    Concrete.expects!(:something).returns("else")
+    assert_equal "else", Concrete.something
+  end
+
+  it "mocks specific methods on existing instances, then restore them after verify" do
+    
+    slab = Concrete.new
+    assert_equal "bonk", slab.hit
+
+    slab.expects!(:hit).returns("slap")
+    assert_equal "slap", slab.hit, "'hit' not stubbed"
+
+    verify_mocks
+    assert_equal "bonk", slab.hit, "'hit' not restored"
+  end
+
+  it "flunks if expected instance method is not invoked" do
+    
+    slab = Concrete.new
+    slab.expects!(:hit)
+
+    assert_error Hardmock::VerifyError, /unmet expectations/i, /Concrete.hit/ do
+      verify_mocks
+    end
+    clear_expectations
+  end
+
+  it "supports all normal mock functionality for instance methods" do
+    
+    slab = Concrete.new
+
+    slab.expects!(:hit, "soft").returns("hey")
+    slab.expects!(:hit, "hard").returns("OOF")
+    slab.expects!(:hit).raises("stoppit")
+    slab.expects!(:hit) do |some, args|
+      "==#{some}+#{args}=="
+    end
+
+    assert_equal "hey", slab.hit("soft")
+    assert_equal "OOF", slab.hit("hard")
+    assert_error(RuntimeError, /stoppit/) do 
+      slab.hit
+    end
+    assert_equal "==first+second==", slab.hit("first","second")
+    
+  end
+
+  it "enforces inter-mock ordering when mocking instance methods" do
+    create_mocks :truck, :foreman
+    slab1 = Concrete.new
+    slab2 = Concrete.new
+
+    @truck.expects.backup
+    slab1.expects!(:hit)
+    @foreman.expects.shout
+    slab2.expects!(:hit)
+    @foreman.expects.whatever
+
+    @truck.backup
+    slab1.hit
+    @foreman.shout
+    assert_error Hardmock::ExpectationError, /wrong/i, /expected call/i, /Concrete.hit/ do
+      @foreman.whatever
+    end
+    assert_error Hardmock::VerifyError, /unmet expectations/i, /foreman.whatever/ do
+      verify_mocks
+    end
+    clear_expectations
+  end
+
+  should "allow mocking non-existant instance methods" do
+    slab = Concrete.new
+    slab.expects!(:wholly).returns('happy')
+    assert_equal 'happy', slab.wholly
+  end
+
+  should "support concrete expectations that deal with runtime blocks" do
+
+    Concrete.expects!(:pour, "a lot") do |how_much, block|
+      assert_equal "a lot", how_much, "Wrong how_much arg"
+      assert_not_nil block, "nil runtime block"
+      assert_equal "the block value", block.call, "Wrong runtime block value"
+    end
+
+    Concrete.pour("a lot") do
+      "the block value"
+    end
+
+  end
+
+  it "can stub methods on mock objects" do
+    create_mock :horse
+    @horse.stubs!(:speak).returns("silence")
+    @horse.stubs!(:hello).returns("nothing")
+    @horse.expects(:canter).returns("clip clop")
+
+    assert_equal "silence", @horse.speak
+    assert_equal "clip clop", @horse.canter
+    assert_equal "silence", @horse.speak
+    assert_equal "silence", @horse.speak
+    assert_equal "nothing", @horse.hello
+    assert_equal "nothing", @horse.hello
+
+    verify_mocks
+    reset_stubs
+  end
+  
+  it "can stub the new method and return values" do
+    Concrete.stubs!(:new).returns("this value")
+    assert_equal "this value", Concrete.new, "did not properly stub new class method"
+    reset_stubs
+  end
+  
+  it "can mock the new method and return values" do
+    Concrete.expects!(:new).with("foo").returns("hello")
+    Concrete.expects!(:new).with("bar").returns("world")
+    
+    assert_equal "hello", Concrete.new("foo"), "did not properly mock out new class method"
+    assert_equal "world", Concrete.new("bar"), "did not properly mock out new class method"
+    
+    verify_mocks
+    reset_stubs
+  end
+
+  it "can mock several different class methods at once" do
+    sim_code = lambda do |input|
+      record = Multitool.find_record(input)
+      report = Multitool.generate_report(record)
+      Multitool.format_output(report)
+    end
+
+    @identifier = "the id"
+    @record = "the record"
+    @report = "the report"
+    @output = "the output"
+
+    Multitool.expects!(:find_record).with(@identifier).returns(@record)
+    Multitool.expects!(:generate_report).with(@record).returns(@report)
+    Multitool.expects!(:format_output).with(@report).returns(@output)
+
+    result = sim_code.call(@identifier)
+    assert_equal @output, result, "Wrong output"
+  end
+
+  it "can handle a mix of different and repeat class method mock calls" do
+    prep = lambda {
+      Multitool.expects!(:find_record).with("A").returns("1")
+      Multitool.expects!(:generate_report).with("1")
+      Multitool.expects!(:find_record).with("B").returns("2")
+      Multitool.expects!(:generate_report).with("2")
+    }
+
+    prep[]
+    Multitool.generate_report(Multitool.find_record("A"))
+    Multitool.generate_report(Multitool.find_record("B"))
+
+    prep[]
+    Multitool.generate_report(Multitool.find_record("A"))
+    assert_error Hardmock::ExpectationError, /Wrong arguments/, /find_record\("B"\)/, /find_record\("C"\)/ do
+      Multitool.generate_report(Multitool.find_record("C"))
+    end
+    clear_expectations
+  end
+
+  it "can mock several concrete instance methods at once" do
+    inst = OtherMultitool.new
+    sim_code = lambda do |input|
+      record = inst.find_record(input)
+      report = inst.generate_report(record)
+      inst.format_output(report)
+    end
+
+    @identifier = "the id"
+    @record = "the record"
+    @report = "the report"
+    @output = "the output"
+
+    inst.expects!(:find_record).with(@identifier).returns(@record)
+    inst.expects!(:generate_report).with(@record).returns(@report)
+    inst.expects!(:format_output).with(@report).returns(@output)
+
+    result = sim_code.call(@identifier)
+    assert_equal @output, result, "Wrong output"
+  end
+
+  it "verifies all concrete expects! from several different expectations" do
+    Multitool.expects!(:find_record)
+    Multitool.expects!(:generate_report)
+    Multitool.expects!(:format_output)
+
+    Multitool.find_record
+    Multitool.generate_report
+
+    assert_error Hardmock::VerifyError, /unmet expectations/i, /format_output/i do
+      verify_mocks
+    end
+  end
+
+  it "will not allow expects! to be used on a mock object" do
+    create_mock :cow
+    assert_error Hardmock::StubbingError, /expects!/, /mock/i, /something/ do
+      @cow.expects!(:something)
+    end
+  end
+
+  it "does not allow stubbing on nil objects" do
+    [ nil, @this_is_nil ].each do |nil_obj|
+      assert_error Hardmock::StubbingError, /cannot/i, /nil/i, /intentionally/ do
+        nil_obj.stubs!(:wont_work)
+      end
+    end
+  end
+
+  it "does not allow concrete method mocking on nil objects" do
+    [ nil, @this_is_nil ].each do |nil_obj|
+      assert_error Hardmock::StubbingError, /cannot/i, /nil/i, /intentionally/ do
+        nil_obj.expects!(:wont_work)
+      end
+    end
+  end
+
+  it "provides an alternate method for stubbing on nil objects" do
+    @this_is_nil.intentionally_stubs!(:bogus).returns('output')
+    assert_equal 'output', @this_is_nil.bogus
+  end
+
+  it "provides an alternate method for mocking concreate methods on nil objects" do
+    @this_is_nil.intentionally_expects!(:bogus).returns('output')
+    assert_error Hardmock::VerifyError, /unmet expectations/i, /NilClass.bogus/ do
+      verify_mocks
+    end
+  end
+
+  #
+  # HELPERS
+  #
+
+  class Concrete
+    def initialize; end
+    def self.pour
+      "stones and gravel"
+    end
+
+    def self.describe
+      "For roads"
+    end
+
+    def hit
+      "bonk"
+    end
+
+    def describe
+      "an instance"
+    end
+  end
+
+  class Jug
+    def self.pour
+      "glug glug"
+    end
+  end
+
+  class Multitool
+    def self.find_record(*a)
+      raise "The real Multitool.find_record was called with #{a.inspect}"
+    end
+    def self.generate_report(*a)
+      raise "The real Multitool.generate_report was called with #{a.inspect}"
+    end
+    def self.format_output(*a)
+      raise "The real Multitool.format_output was called with #{a.inspect}"
+    end
+  end
+
+  class OtherMultitool
+    def find_record(*a)
+      raise "The real OtherMultitool#find_record was called with #{a.inspect}"
+    end
+    def generate_report(*a)
+      raise "The real OtherMultitool#generate_report was called with #{a.inspect}"
+    end
+    def format_output(*a)
+      raise "The real OtherMultitool#format_output was called with #{a.inspect}"
+    end
+  end
+
+end
+