D4497: tests: rewrite test-lrucachedict.py to use unittest

[indygreg (Gregory Szorc)]

indygreg created this revision.
Herald added a subscriber: mercurial-devel.
Herald added a reviewer: hg-reviewers.

REVISION SUMMARY
  This makes the code so much easier to test and debug.
  
  Along the way, I discovered a bug in copy(), which I kind of
  added test coverage for.

REPOSITORY
  rHG Mercurial

REVISION DETAIL
  https://phab.mercurial-scm.org/D4497

AFFECTED FILES
  tests/test-lrucachedict.py
  tests/test-lrucachedict.py.out

CHANGE DETAILS

diff --git a/tests/test-lrucachedict.py.out b/tests/test-lrucachedict.py.out
deleted file mode 100644
--- a/tests/test-lrucachedict.py.out
+++ /dev/null
@@ -1,62 +0,0 @@
-'a' in d: True
-d['a']: va
-'b' in d: True
-d['b']: vb
-'c' in d: True
-d['c']: vc
-'d' in d: True
-d['d']: vd
-'a' in d: False
-'b' in d: True
-d['b']: vb
-'c' in d: True
-d['c']: vc
-'d' in d: True
-d['d']: vd
-'e' in d: True
-d['e']: ve
-'b' in d: True
-d['b']: vb2
-'c' in d: True
-d['c']: vc2
-'d' in d: True
-d['d']: vd
-'e' in d: False
-'f' in d: True
-d['f']: vf
-'b' in d: False
-'c' in d: False
-'d' in d: False
-'e' in d: False
-'f' in d: False
-'a' in d: True
-d['a']: 1
-'b' in d: True
-d['b']: 2
-
-All of these should be present:
-'a' in dc: True
-dc['a']: va3
-'b' in dc: True
-dc['b']: vb3
-'c' in dc: True
-dc['c']: vc3
-'d' in dc: True
-dc['d']: vd3
-
-All of these except 'a' should be present:
-'a' in dc: False
-'b' in dc: True
-dc['b']: vb3
-'c' in dc: True
-dc['c']: vc3
-'d' in dc: True
-dc['d']: vd3
-'e' in dc: True
-dc['e']: ve3
-
-These should be in reverse alphabetical order and read 'v?3':
-d['d']: vd3
-d['c']: vc3
-d['b']: vb3
-d['a']: va3
diff --git a/tests/test-lrucachedict.py b/tests/test-lrucachedict.py
--- a/tests/test-lrucachedict.py
+++ b/tests/test-lrucachedict.py
@@ -1,77 +1,105 @@
 from __future__ import absolute_import, print_function
 
+import unittest
+
+import silenttestrunner
+
 from mercurial import (
     util,
 )
 
-def printifpresent(d, xs, name='d'):
-    for x in xs:
-        present = x in d
-        print("'%s' in %s: %s" % (x, name, present))
-        if present:
-            print("%s['%s']: %s" % (name, x, d[x]))
+class testlrucachedict(unittest.TestCase):
+    def testsimple(self):
+        d = util.lrucachedict(4)
+        d['a'] = 'va'
+        d['b'] = 'vb'
+        d['c'] = 'vc'
+        d['d'] = 'vd'
 
-def test_lrucachedict():
-    d = util.lrucachedict(4)
-    d['a'] = 'va'
-    d['b'] = 'vb'
-    d['c'] = 'vc'
-    d['d'] = 'vd'
+        self.assertEqual(d['a'], 'va')
+        self.assertEqual(d['b'], 'vb')
+        self.assertEqual(d['c'], 'vc')
+        self.assertEqual(d['d'], 'vd')
 
-    # all of these should be present
-    printifpresent(d, ['a', 'b', 'c', 'd'])
+        # 'a' should be dropped because it was least recently used.
+        d['e'] = 've'
+        self.assertNotIn('a', d)
+
+        self.assertIsNone(d.get('a'))
 
-    # 'a' should be dropped because it was least recently used
-    d['e'] = 've'
-    printifpresent(d, ['a', 'b', 'c', 'd', 'e'])
+        self.assertEqual(d['b'], 'vb')
+        self.assertEqual(d['c'], 'vc')
+        self.assertEqual(d['d'], 'vd')
+        self.assertEqual(d['e'], 've')
 
-    assert d.get('a') is None
-    assert d.get('e') == 've'
+        # Touch entries in some order (both get and set).
+        d['e']
+        d['c'] = 'vc2'
+        d['d']
+        d['b'] = 'vb2'
 
-    # touch entries in some order (get or set).
-    d['e']
-    d['c'] = 'vc2'
-    d['d']
-    d['b'] = 'vb2'
+        # 'e' should be dropped now
+        d['f'] = 'vf'
+        self.assertNotIn('e', d)
+        self.assertEqual(d['b'], 'vb2')
+        self.assertEqual(d['c'], 'vc2')
+        self.assertEqual(d['d'], 'vd')
+        self.assertEqual(d['f'], 'vf')
 
-    # 'e' should be dropped now
-    d['f'] = 'vf'
-    printifpresent(d, ['b', 'c', 'd', 'e', 'f'])
+        d.clear()
+        for key in ('a', 'b', 'c', 'd', 'e', 'f'):
+            self.assertNotIn(key, d)
 
-    d.clear()
-    printifpresent(d, ['b', 'c', 'd', 'e', 'f'])
+    def testunfull(self):
+        d = util.lrucachedict(4)
+        d['a'] = 1
+        d['b'] = 2
+        d['a']
+        d['b']
+
+        for key in ('a', 'b'):
+            self.assertIn(key, d)
 
-    # Now test dicts that aren't full.
-    d = util.lrucachedict(4)
-    d['a'] = 1
-    d['b'] = 2
-    d['a']
-    d['b']
-    printifpresent(d, ['a', 'b'])
+    def testcopypartial(self):
+        d = util.lrucachedict(4)
+        d['a'] = 'va'
+        d['b'] = 'vb'
+
+        dc = d.copy()
+
+        self.assertEqual(len(dc), 2)
+        # TODO this fails
+        return
+        for key in ('a', 'b'):
+            self.assertIn(key, dc)
+            self.assertEqual(dc[key], 'v%s' % key)
 
-    # test copy method
-    d = util.lrucachedict(4)
-    d['a'] = 'va3'
-    d['b'] = 'vb3'
-    d['c'] = 'vc3'
-    d['d'] = 'vd3'
+    def testcopyfull(self):
+        d = util.lrucachedict(4)
+        d['a'] = 'va'
+        d['b'] = 'vb'
+        d['c'] = 'vc'
+        d['d'] = 'vd'
 
-    dc = d.copy()
+        dc = d.copy()
+
+        for key in ('a', 'b', 'c', 'd'):
+            self.assertIn(key, dc)
+            self.assertEqual(dc[key], 'v%s' % key)
 
-    # all of these should be present
-    print("\nAll of these should be present:")
-    printifpresent(dc, ['a', 'b', 'c', 'd'], 'dc')
+        # 'a' should be dropped because it was least recently used.
+        dc['e'] = 've'
+        self.assertNotIn('a', dc)
+        for key in ('b', 'c', 'd', 'e'):
+            self.assertIn(key, dc)
+            self.assertEqual(dc[key], 'v%s' % key)
 
-    # 'a' should be dropped because it was least recently used
-    print("\nAll of these except 'a' should be present:")
-    dc['e'] = 've3'
-    printifpresent(dc, ['a', 'b', 'c', 'd', 'e'], 'dc')
+        # Contents and order of original dict should remain unchanged.
+        dc['b'] = 'vb_new'
 
-    # contents and order of original dict should remain unchanged
-    print("\nThese should be in reverse alphabetical order and read 'v?3':")
-    dc['b'] = 'vb3_new'
-    for k in list(iter(d)):
-        print("d['%s']: %s" % (k, d[k]))
+        self.assertEqual(list(iter(d)), ['d', 'c', 'b', 'a'])
+        for key in ('a', 'b', 'c', 'd'):
+            self.assertEqual(d[key], 'v%s' % key)
 
 if __name__ == '__main__':
-    test_lrucachedict()
+    silenttestrunner.main(__name__)



To: indygreg, #hg-reviewers
Cc: mercurial-devel