100% coverage for the test_* files.

.coveragerc

@@ -7,3 +7,4 @@ exclude_lines =
     class I[A-Z]\w+\((Interface|I[A-Z].*)\):
     raise NotImplementedError
     raise AssertionError
+    if __name__ == '__main__':

persistent/tests/test_list.py

@@ -57,9 +57,9 @@ def testTheWorld(self):
         uu1 = pl(u1)
         uu2 = pl(u2)
 
-        v = pl(tuple(u))
-        v0 = pl(OtherList(u0))
-        vv = pl("this is also a sequence")
+        pl(tuple(u))
+        pl(OtherList(u0))
+        pl("this is also a sequence")
 
         # Test __repr__
         eq = self.assertEqual
@@ -68,46 +68,48 @@ def testTheWorld(self):
         eq(repr(u1), repr(l1), "repr(u1) == repr(l1)")
 
         # Test __cmp__ and __len__
-
-        if PYTHON2:
-            def mycmp(a, b):
-                r = cmp(a, b)
-                if r < 0: return -1
-                if r > 0: return 1
-                return r
-
-            all = [l0, l1, l2, u, u0, u1, u2, uu, uu0, uu1, uu2]
-            for a in all:
-                for b in all:
-                    eq(mycmp(a, b), mycmp(len(a), len(b)),
-                        "mycmp(a, b) == mycmp(len(a), len(b))")
+        try:
+            cmp
+        except NameError:
+            def cmp(a, b):
+                if a == b:
+                    return 0
+                if a < b:
+                    return -1
+                return 1
+
+        def mycmp(a, b):
+            r = cmp(a, b)
+            if r < 0:
+                return -1
+            if r > 0:
+                return 1
+            return r
+
+        to_test = [l0, l1, l2, u, u0, u1, u2, uu, uu0, uu1, uu2]
+        for a in to_test:
+            for b in to_test:
+                eq(mycmp(a, b), mycmp(len(a), len(b)),
+                   "mycmp(a, b) == mycmp(len(a), len(b))")
 
         # Test __getitem__
 
-        for i in range(len(u2)):
-            eq(u2[i], i, "u2[i] == i")
+        for i, val in enumerate(u2):
+            eq(val, i, "u2[i] == i")
 
         # Test __setitem__
 
         uu2[0] = 0
         uu2[1] = 100
-        try:
+        with self.assertRaises(IndexError):
             uu2[2] = 200
-        except IndexError:
-            pass
-        else:
-            raise TestFailed("uu2[2] shouldn't be assignable")
 
         # Test __delitem__
 
         del uu2[1]
         del uu2[0]
-        try:
+        with self.assertRaises(IndexError):
             del uu2[0]
-        except IndexError:
-            pass
-        else:
-            raise TestFailed("uu2[0] shouldn't be deletable")
 
         # Test __getslice__
 
@@ -198,12 +200,8 @@ def mycmp(a, b):
 
         eq(u2.index(0), 0, "u2.index(0) == 0")
         eq(u2.index(1), 1, "u2.index(1) == 1")
-        try:
+        with self.assertRaises(ValueError):
             u2.index(2)
-        except ValueError:
-            pass
-        else:
-            raise TestFailed("expected ValueError")
 
         # Test reverse
 
@@ -220,23 +218,19 @@ def mycmp(a, b):
         eq(u, u2, "u == u2")
 
         # Test keyword arguments to sort
-        if PYTHON2:
-            u.sort(cmp=lambda x,y: cmp(y, x))
+        if PYTHON2: # pragma: no cover
+            u.sort(cmp=lambda x, y: cmp(y, x))
             eq(u, [1, 0], "u == [1, 0]")
 
-        u.sort(key=lambda x:-x)
+        u.sort(key=lambda x: -x)
         eq(u, [1, 0], "u == [1, 0]")
 
         u.sort(reverse=True)
         eq(u, [1, 0], "u == [1, 0]")
 
         # Passing any other keyword arguments results in a TypeError
-        try:
+        with self.assertRaises(TypeError):
             u.sort(blah=True)
-        except TypeError:
-            pass
-        else:
-            raise TestFailed("expected TypeError")
 
         # Test extend
 
@@ -256,8 +250,7 @@ def mycmp(a, b):
 
 
 def test_suite():
-    return unittest.makeSuite(TestPList)
+    return unittest.defaultTestLoader.loadTestsFromName(__name__)
 
-if __name__ == "__main__":
-    loader = unittest.TestLoader()
-    unittest.main(testLoader=loader)
+if __name__ == '__main__':
+    unittest.main()

persistent/tests/test_mapping.py

@@ -13,7 +13,7 @@
 ##############################################################################
 import unittest
 
-
+# pylint:disable=blacklisted-name, protected-access
 
 class Test_default(unittest.TestCase):
 
@@ -25,15 +25,14 @@ def _makeOne(self, func):
         return self._getTargetClass()(func)
 
     def test___get___from_class(self):
-        _called_with = []
         def _test(inst):
-            _called_with.append(inst)
-            return '_test'
+            raise AssertionError("Must not be caled")
+
         descr = self._makeOne(_test)
         class Foo(object):
             testing = descr
-        self.assertTrue(Foo.testing is descr)
-        self.assertEqual(_called_with, [])
+        self.assertIs(Foo.testing, descr)
+
 
     def test___get___from_instance(self):
         _called_with = []
@@ -86,9 +85,9 @@ class OtherMapping(dict):
             def __init__(self, initmapping):
                 self.__data = initmapping
             def items(self):
-                return self.__data.items()
-        v0 = self._makeOne(OtherMapping(u0))
-        vv = self._makeOne([(0, 0), (1, 1)])
+                raise AssertionError("Not called")
+        self._makeOne(OtherMapping(u0))
+        self._makeOne([(0, 0), (1, 1)])
 
         # Test __repr__
         eq = self.assertEqual
@@ -97,24 +96,37 @@ def items(self):
         eq(repr(u1), repr(l1), "repr(u1) == repr(l1)")
 
         # Test __cmp__ and __len__
-
-        if PYTHON2:
-            def mycmp(a, b):
-                r = cmp(a, b)
-                if r < 0: return -1
-                if r > 0: return 1
-                return r
-
-            all = [l0, l1, l2, u, u0, u1, u2, uu, uu0, uu1, uu2]
-            for a in all:
-                for b in all:
-                    eq(mycmp(a, b), mycmp(len(a), len(b)),
-                        "mycmp(a, b) == mycmp(len(a), len(b))")
+        try:
+            cmp
+        except NameError:
+            def cmp(a, b):
+                if a == b:
+                    return 0
+                if hasattr(a, 'items'):
+                    a = sorted(a.items())
+                    b = sorted(b.items())
+                if a < b:
+                    return -1
+                return 1
+
+        def mycmp(a, b):
+            r = cmp(a, b)
+            if r < 0:
+                return -1
+            if r > 0:
+                return 1
+            return r
+
+        to_test = [l0, l1, l2, u, u0, u1, u2, uu, uu0, uu1, uu2]
+        for a in to_test:
+            for b in to_test:
+                eq(mycmp(a, b), mycmp(len(a), len(b)),
+                   "mycmp(a, b) == mycmp(len(a), len(b))")
 
         # Test __getitem__
 
-        for i in range(len(u2)):
-            eq(u2[i], i, "u2[i] == i")
+        for i, val in enumerate(u2):
+            eq(val, i, "u2[i] == i")
 
         # Test get
 
@@ -136,12 +148,8 @@ def mycmp(a, b):
 
         del uu2[1]
         del uu2[0]
-        try:
+        with self.assertRaises(KeyError):
             del uu2[0]
-        except KeyError:
-            pass
-        else:
-            raise TestFailed("uu2[0] shouldn't be deletable")
 
         # Test __contains__
         for i in u2:
@@ -176,12 +184,8 @@ def mycmp(a, b):
         eq(x, 1, "u2.pop(1) == 1")
         self.assertTrue(1 not in u2, "1 not in u2")
 
-        try:
+        with self.assertRaises(KeyError):
             u2.pop(1)
-        except KeyError:
-            pass
-        else:
-            self.fail("1 should not be poppable from u2")
 
         x = u2.pop(1, 7)
         eq(x, 7, "u2.pop(1, 7) == 7")
@@ -230,8 +234,4 @@ def test_PD_is_alias_to_PM(self):
 
 
 def test_suite():
-    return unittest.TestSuite((
-        unittest.makeSuite(Test_default),
-        unittest.makeSuite(PersistentMappingTests),
-        unittest.makeSuite(Test_legacy_PersistentDict),
-    ))
+    return unittest.defaultTestLoader.loadTestsFromName(__name__)