   _throw_throws_usage(error) unless error?
   _throw_throws_must_be_after_expects_or_args() unless _is_state_in(mock, "expects", "args")
 
-_check_for_duplicate_signatures = (mock) ->
+_check_for_duplicate_expectations = (mock) ->
   # TODO: use each with index and slice to avoid last element
-  signatures = _signatures(mock)
-  return if signatures.length < 2
-  for outer in [0..signatures.length-2]
-    for inner in [outer+1..signatures.length-1]
-      _throw_duplicate_expectation("#{signatures[outer].method_name}(#{signatures[outer].args})") if signatures[outer].equals( signatures[inner] )
-
-_current_signature = (mock) ->
-  _signatures(mock)[0]
+  expectations = _expectations(mock)
+  return if expectations.length < 2
+  for outer in [0..expectations.length-2]
+    for inner in [outer+1..expectations.length-1]
+      _throw_duplicate_expectation("#{expectations[outer].method_name}(#{expectations[outer].args})") if expectations[outer].equals( expectations[inner] )
+
+_current_expectation = (mock) ->
+  _expectations(mock)[0]
 
 _current_method_name = (mock) ->
-  _current_signature(mock)?.method_name
-
-_find_signature = (mock, method_name, args...) ->
-  for signature in _signatures(mock) when signature.matches(method_name, args...)
-    return signature
+  _current_expectation(mock)?.method_name
+
+_find_expectation = (mock, method_name, args...) ->
+  for expectation in _expectations(mock) when expectation.matches(method_name, args...)
+    return expectation
   undefined
 
 _build_mocked_method = (mock, method_name) ->
   (args...) ->
-    signature = _find_signature(mock, method_name, args...)
-    _throw_unknown_expectation("#{method_name}(#{args})") unless signature?
-    _check_for_duplicate_signatures(mock)
-    signature.called = true
-    throw signature.throws if signature.throws?
-    signature.returns
+    expectation = _find_expectation(mock, method_name, args...)
+    _throw_unknown_expectation("#{method_name}(#{args})") unless expectation?
+    _check_for_duplicate_expectations(mock)
+    expectation.called = true
+    throw expectation.throws if expectation.throws?
+    expectation.returns
 
 _build_errors = (mock) ->
   errors = ""
-  for signature in _signatures(mock) when signature.called == false
-    errors += "'#{signature.method_name}(#{signature.args})' was never called\n"
+  for expectation in _expectations(mock) when expectation.called == false
+    errors += "'#{expectation.method_name}(#{expectation.args})' was never called\n"
   errors
     
-_start_new_signature = (mock, method_name) ->
-  _signatures(mock).unshift( new MethodSignature(method_name) )     # .unshift pushes to front of array
+_start_new_expectation = (mock, method_name) ->
+  _expectations(mock).unshift( new Expectation(method_name) )     # .unshift pushes to front of array
 
 _add_method_to_mock = (mock, method_name) ->
   mock[ method_name ] ?= _build_mocked_method(mock, method_name)
 
-_set_args_for_current_signature = (mock, args) ->
-  _current_signature(mock).args = args
-
-_set_return_for_current_signature = (mock, value) ->
-  _current_signature(mock).returns = value
-
-_set_throws_for_current_signature = (mock, error) ->
-  _current_signature(mock).throws = error
+_set_args_for_current_expectation = (mock, args) ->
+  _current_expectation(mock).args = args
+
+_set_return_for_current_expectation = (mock, value) ->
+  _current_expectation(mock).returns = value
+
+_set_throws_for_current_expectation = (mock, error) ->
+  _current_expectation(mock).throws = error
 
 _throw_expects_usage = ->
   throw "you need to supply a method name to .expects(), e.g. my_mock.expects('my_method')"

#
# MethodSignature is an internal data structure that represents
# a mocked method.  Stores the method name, the expected arguments,
# the value to return or throw, and whether it has actually been
# called.  For example, the following:
#
#   my_mock = (new Mock).expects("my_method").args(1,2,3).returns(42)
#
# would result in a MethodSignature with @method_name = "my_method",
# @args = [1,2,3], @returns = 42, @throws = undefined, and @called =
# false.  Doing:
#
#   my_mock.my_method(1,2,3)
#
# would result in @called = true.  Note that a mocked function can
# either return a value or throw an error but not both, so either
# @returns or @throws (or both) must be undefined.
#
class MethodSignature

  constructor: (method_name) ->
    @method_name = method_name

_throw_args_must_be_after_expects = ->
  throw ".args() must be called immediately after .expects(), e.g. my_mock.expects('my_method').args(42)"

_throw_duplicate_expectation = (expectation) ->
  throw "#{expectation} is a duplicate expectation"

_throw_returns_usage = ->
  throw "you need to supply an argument to .returns(), e.g. my_mock.expects('my_method').returns(123)"
