class MiniTest::Mock

def expect(name, retval, args=[])
  @expected_calls[name] = { :retval => retval, :args => args }
  self
end

def initialize # :nodoc:
  @expected_calls = {}
  @actual_calls = Hash.new {|h,k| h[k] = [] }
end

def method_missing(sym, *args) # :nodoc:
  expected = @expected_calls[sym]
  unless expected then
    raise NoMethodError, "unmocked method %p, expected one of %p" %
      [sym, @expected_calls.keys.sort_by(&:to_s)]
  end
  expected_args, retval = expected[:args], expected[:retval]
  unless expected_args.size == args.size
    raise ArgumentError, "mocked method %p expects %d arguments, got %d" %
      [sym, expected[:args].size, args.size]
  end
  @actual_calls[sym] << {
    :retval => retval,
    :args => expected_args.zip(args).map { |mod, a| mod === a ? mod : a }
  }
  retval
end

def respond_to?(sym) # :nodoc:
  return true if @expected_calls.has_key?(sym.to_sym)
  return __respond_to?(sym)
end

def verify
  @expected_calls.each_key do |name|
    expected = @expected_calls[name]
    msg1 = "expected #{name}, #{expected.inspect}"
    msg2 = "#{msg1}, got #{@actual_calls[name].inspect}"
    raise MockExpectationError, msg2 if
      @actual_calls.has_key? name and
      not @actual_calls[name].include?(expected)
    raise MockExpectationError, msg1 unless
      @actual_calls.has_key? name and @actual_calls[name].include?(expected)
  end
  true
end