2 files changed, 86 insertions, 0 deletions

diff --git a/mox.py b/mox.py
index 91ab88b..5739ab1 100755
--- a/mox.py
+++ b/mox.py
@@ -1763,6 +1763,61 @@ class IgnoreArg(Comparator):
     return '<IgnoreArg>'
 
 
+class Value(Comparator):
+  """Compares argument against a remembered value.
+
+  To be used in conjunction with Remember comparator.  See Remember()
+  for example.
+  """
+
+  def __init__(self):
+    self._value = None
+    self._has_value = False
+
+  def store_value(self, rhs):
+    self._value = rhs
+    self._has_value = True
+
+  def equals(self, rhs):
+    if not self._has_value:
+      return False
+    else:
+      return rhs == self._value
+
+  def __repr__(self):
+    if self._has_value:
+      return "<Value %r>" % self._value
+    else:
+      return "<Value>"
+
+
+class Remember(Comparator):
+  """Remembers the argument to a value store.
+
+  To be used in conjunction with Value comparator.
+
+  Example:
+  # Remember the argument for one method call.
+  users_list = Value()
+  mock_dao.ProcessUsers(Remember(users_list))
+
+  # Check argument against remembered value.
+  mock_dao.ReportUsers(users_list)
+  """
+
+  def __init__(self, value_store):
+    if not isinstance(value_store, Value):
+      raise TypeError("value_store is not an instance of the Value class")
+    self._value_store = value_store
+
+  def equals(self, rhs):
+    self._value_store.store_value(rhs)
+    return True
+
+  def __repr__(self):
+    return "<Remember %d>" % id(self._value_store)
+
+
 class MethodGroup(object):
   """Base class containing common behaviour for MethodGroups."""
 
diff --git a/mox_test.py b/mox_test.py
index 7b23397..f6d5026 100755
--- a/mox_test.py
+++ b/mox_test.py
@@ -422,6 +422,37 @@ class IsAlmostTest(unittest.TestCase):
     self.assertNotEquals(mox.IsAlmost('1.8999999999'), '1.9')
 
 
+class ValueRememberTest(unittest.TestCase):
+  """Verify comparing argument against remembered value."""
+
+  def testValueEquals(self):
+    """Verify that value will compare to stored value."""
+    value = mox.Value()
+    value.store_value('hello world')
+    self.assertEquals(value, 'hello world')
+
+  def testNoValue(self):
+    """Verify that uninitialized value does not compare to "empty" values."""
+    value = mox.Value()
+    self.assertNotEquals(value, None)
+    self.assertNotEquals(value, False)
+    self.assertNotEquals(value, 0)
+    self.assertNotEquals(value, '')
+    self.assertNotEquals(value, ())
+    self.assertNotEquals(value, [])
+    self.assertNotEquals(value, {})
+    self.assertNotEquals(value, object())
+    self.assertNotEquals(value, set())
+
+  def testRememberValue(self):
+    """Verify that comparing against remember will store argument."""
+    value = mox.Value()
+    remember = mox.Remember(value)
+    self.assertNotEquals(value, 'hello world')  # value not yet stored.
+    self.assertEquals(remember, 'hello world')  # store value here.
+    self.assertEquals(value, 'hello world')     # compare against stored value.
+
+
 class MockMethodTest(unittest.TestCase):
   """Test class to verify that the MockMethod class is working correctly."""