Suppress Py3k nannyisms.

5 files changed, 107 insertions, 107 deletions

diff --git a/src/zope/security/tests/test_checker.py b/src/zope/security/tests/test_checker.py
index 665cb4c..fcd7698 100644
--- a/src/zope/security/tests/test_checker.py
+++ b/src/zope/security/tests/test_checker.py
@@ -881,7 +881,7 @@ class Test_undefineChecker(unittest.TestCase):
             pass
         checker = _checkers[Foo] = object()
         self._callFUT(Foo)
-        self.failIf(Foo in _checkers)
+        self.assertFalse(Foo in _checkers)
 
 
 class CombinedCheckerTests(unittest.TestCase):
@@ -1546,14 +1546,14 @@ class Test(unittest.TestCase):
         rocks = tuple(BasicTypes_examples.values())
         for rock in rocks:
             proxy = checker.proxy(rock)
-            self.failUnless(proxy is rock, (rock, type(proxy)))
+            self.assertTrue(proxy is rock, (rock, type(proxy)))
 
         for class_ in OldInst, NewInst:
             inst = class_()
 
             for ob in inst, class_:
                 proxy = checker.proxy(ob)
-                self.failUnless(removeSecurityProxy(proxy) is ob)
+                self.assertTrue(removeSecurityProxy(proxy) is ob)
                 checker = getChecker(proxy)
                 if ob is inst:
                     self.assertEqual(checker.permission_id('__str__'),
@@ -1577,14 +1577,14 @@ class Test(unittest.TestCase):
             #       return getattr(ob, name)
             #for ob in inst, TransparentProxy(inst):
             #    proxy = checker.proxy(ob)
-            #    self.failUnless(removeSecurityProxy(proxy) is ob)
+            #    self.assertTrue(removeSecurityProxy(proxy) is ob)
             #
             #    checker = getChecker(proxy)
-            #    self.failUnless(checker is special,
+            #    self.assertTrue(checker is special,
             #                    checker.get_permissions)
             #
             #    proxy2 = checker.proxy(proxy)
-            #    self.failUnless(proxy2 is proxy, [proxy, proxy2])
+            #    self.assertTrue(proxy2 is proxy, [proxy, proxy2])
 
     def testLayeredProxies(self):
         #Test that a Proxy will not be re-proxied.
@@ -1599,13 +1599,13 @@ class Test(unittest.TestCase):
 
         # base is not proxied, so we expect a proxy
         proxy1 = checker.proxy(base)
-        self.assert_(type(proxy1) is Proxy)
-        self.assert_(getProxiedObject(proxy1) is base)
+        self.assertTrue(type(proxy1) is Proxy)
+        self.assertTrue(getProxiedObject(proxy1) is base)
 
         # proxy is a proxy, so we don't expect to get another
         proxy2 = checker.proxy(proxy1)
-        self.assert_(proxy2 is proxy1)
-        self.assert_(getProxiedObject(proxy2) is base)
+        self.assertTrue(proxy2 is proxy1)
+        self.assertTrue(getProxiedObject(proxy2) is base)
 
 
     def testMultiChecker(self):
@@ -1705,24 +1705,24 @@ class Test(unittest.TestCase):
         obj = SomeClass()
 
         proxy = ProxyFactory(obj)
-        self.assert_(type(proxy) is Proxy)
-        self.assert_(getChecker(proxy) is _defaultChecker)
+        self.assertTrue(type(proxy) is Proxy)
+        self.assertTrue(getChecker(proxy) is _defaultChecker)
 
         defineChecker(SomeClass, checker)
 
         proxy = ProxyFactory(obj)
-        self.assert_(type(proxy) is Proxy)
-        self.assert_(getChecker(proxy) is checker)
+        self.assertTrue(type(proxy) is Proxy)
+        self.assertTrue(getChecker(proxy) is checker)
 
         obj.__Security_checker__ = checker_as_magic_attr
 
         proxy = ProxyFactory(obj)
-        self.assert_(type(proxy) is Proxy)
-        self.assert_(getChecker(proxy) is checker_as_magic_attr)
+        self.assertTrue(type(proxy) is Proxy)
+        self.assertTrue(getChecker(proxy) is checker_as_magic_attr)
 
         proxy = ProxyFactory(obj, specific_checker)
-        self.assert_(type(proxy) is Proxy)
-        self.assert_(getChecker(proxy) is specific_checker)
+        self.assertTrue(type(proxy) is Proxy)
+        self.assertTrue(getChecker(proxy) is specific_checker)
 
     def test_define_and_undefineChecker(self):
         from zope.security.checker import defineChecker
@@ -1734,11 +1734,11 @@ class Test(unittest.TestCase):
 
         checker = NamesChecker()
         from zope.security.checker import _defaultChecker, selectChecker
-        self.assert_(selectChecker(obj) is _defaultChecker)
+        self.assertTrue(selectChecker(obj) is _defaultChecker)
         defineChecker(SomeClass, checker)
-        self.assert_(selectChecker(obj) is checker)
+        self.assertTrue(selectChecker(obj) is checker)
         undefineChecker(SomeClass)
-        self.assert_(selectChecker(obj) is _defaultChecker)
+        self.assertTrue(selectChecker(obj) is _defaultChecker)
 
     def test_ProxyFactory_using_proxy(self):
         from zope.security.checker import ProxyFactory
@@ -1750,7 +1750,7 @@ class Test(unittest.TestCase):
         proxy1 = ProxyFactory(obj)
 
         proxy2 = ProxyFactory(proxy1)
-        self.assert_(proxy1 is proxy2)
+        self.assertTrue(proxy1 is proxy2)
 
         # Trying to change the checker on a proxy.
         self.assertRaises(TypeError, ProxyFactory, proxy1, checker)
@@ -1758,7 +1758,7 @@ class Test(unittest.TestCase):
         # Setting exactly the same checker as the proxy already has.
         proxy1 = ProxyFactory(obj, checker)
         proxy2 = ProxyFactory(proxy1, checker)
-        self.assert_(proxy1 is proxy2)
+        self.assertTrue(proxy1 is proxy2)
 
     def test_canWrite_canAccess(self):
         # the canWrite and canAccess functions are conveniences.  Often code
@@ -1809,15 +1809,15 @@ class Test(unittest.TestCase):
         defineChecker(SomeClass, checker)
 
         # so, our hapless interaction may write and access foo...
-        self.assert_(canWrite(obj, 'foo'))
-        self.assert_(canAccess(obj, 'foo'))
+        self.assertTrue(canWrite(obj, 'foo'))
+        self.assertTrue(canAccess(obj, 'foo'))
 
         # ...may access, but not write, bar...
-        self.assert_(not canWrite(obj, 'bar'))
-        self.assert_(canAccess(obj, 'bar'))
+        self.assertTrue(not canWrite(obj, 'bar'))
+        self.assertTrue(canAccess(obj, 'bar'))
 
         # ...and may access baz.
-        self.assert_(not canAccess(obj, 'baz'))
+        self.assertTrue(not canAccess(obj, 'baz'))
 
         # there are no security assertions for writing or reading shazam, so
         # checking these actually raises Forbidden.  The rationale behind
@@ -1832,13 +1832,13 @@ class Test(unittest.TestCase):
         # it.  This is a very reasonable configuration.  Therefore, canWrite
         # will hide the Forbidden exception if and only if there is a
         # setting for accessing the attribute.
-        self.assert_(not canWrite(obj, 'baz'))
+        self.assertTrue(not canWrite(obj, 'baz'))
 
         # The reverse is not true at the moment: an unusal case like the
         # write-only 'bing' attribute will return a boolean for canWrite,
         # but canRead will simply raise a Forbidden exception, without checking
         # write settings.
-        self.assert_(not canWrite(obj, 'bing'))
+        self.assertTrue(not canWrite(obj, 'bing'))
         self.assertRaises(Forbidden, canAccess, obj, 'bing')
 
 class TestCheckerPublic(unittest.TestCase):
@@ -1846,14 +1846,14 @@ class TestCheckerPublic(unittest.TestCase):
     def test_that_pickling_CheckerPublic_retains_identity(self):
         from zope.security._compat import _pickle
         from zope.security.checker import CheckerPublic
-        self.assert_(_pickle.loads(_pickle.dumps(CheckerPublic))
+        self.assertTrue(_pickle.loads(_pickle.dumps(CheckerPublic))
                      is
                      CheckerPublic)
 
     def test_that_CheckerPublic_identity_works_even_when_proxied(self):
         from zope.security.checker import ProxyFactory
         from zope.security.checker import CheckerPublic
-        self.assert_(ProxyFactory(CheckerPublic) is CheckerPublic)
+        self.assertTrue(ProxyFactory(CheckerPublic) is CheckerPublic)
 
 
 class TestMixinDecoratedChecker(unittest.TestCase):
@@ -1895,26 +1895,26 @@ class TestMixinDecoratedChecker(unittest.TestCase):
         from zope.security.interfaces import ForbiddenAttribute
         o = self.obj
         checker.check_getattr(o, 'both_get_set')
-        self.assert_(self.interaction.checkChecked(['dc_get_permission']))
+        self.assertTrue(self.interaction.checkChecked(['dc_get_permission']))
         checker.check_getattr(o, 'c_only')
-        self.assert_(self.interaction.checkChecked(['get_permission']))
+        self.assertTrue(self.interaction.checkChecked(['get_permission']))
         checker.check_getattr(o, 'd_only')
-        self.assert_(self.interaction.checkChecked(['dc_get_permission']))
+        self.assertTrue(self.interaction.checkChecked(['dc_get_permission']))
         self.assertRaises(ForbiddenAttribute,
                           checker.check_getattr, o,
                           'completely_different_attr')
-        self.assert_(self.interaction.checkChecked([]))
+        self.assertTrue(self.interaction.checkChecked([]))
         checker.check(o, '__str__')
-        self.assert_(self.interaction.checkChecked(['get_permission']))
+        self.assertTrue(self.interaction.checkChecked(['get_permission']))
 
         checker.check_setattr(o, 'both_get_set')
-        self.assert_(self.interaction.checkChecked(['dc_set_permission']))
+        self.assertTrue(self.interaction.checkChecked(['dc_set_permission']))
         self.assertRaises(ForbiddenAttribute,
                           checker.check_setattr, o, 'c_only')
-        self.assert_(self.interaction.checkChecked([]))
+        self.assertTrue(self.interaction.checkChecked([]))
         self.assertRaises(ForbiddenAttribute,
                           checker.check_setattr, o, 'd_only')
-        self.assert_(self.interaction.checkChecked([]))
+        self.assertTrue(self.interaction.checkChecked([]))
 
     @property
     def originalChecker(self):
@@ -1953,7 +1953,7 @@ class TestCombinedChecker(TestMixinDecoratedChecker, unittest.TestCase):
         # checker.
         self.interaction.permissions['dc_get_permission'] = False
         cc.check_getattr(self.obj, 'both_get_set')
-        self.assert_(
+        self.assertTrue(
             self.interaction.checkChecked(['dc_get_permission',
                                            'get_permission'])
             )
@@ -1984,25 +1984,25 @@ class TestBasicTypes(unittest.TestCase):
         # When an item is added to the basic types, it should also be added to
         # the list of checkers.
         BasicTypes[MyType] = NoProxy
-        self.assert_(MyType in _checkers)
+        self.assertTrue(MyType in _checkers)
 
         # If we clear the checkers, the type should still be there
         _clear()
-        self.assert_(MyType in BasicTypes)
-        self.assert_(MyType in _checkers)
+        self.assertTrue(MyType in BasicTypes)
+        self.assertTrue(MyType in _checkers)
 
         # Now delete the type from the dictionary, will also delete it from
         # the checkers
         del BasicTypes[MyType]
-        self.assert_(MyType not in BasicTypes)
-        self.assert_(MyType not in _checkers)
+        self.assertTrue(MyType not in BasicTypes)
+        self.assertTrue(MyType not in _checkers)
 
         # The quick way of adding new types is using update
         BasicTypes.update({MyType: NoProxy, MyType2: NoProxy})
-        self.assert_(MyType in BasicTypes)
-        self.assert_(MyType2 in BasicTypes)
-        self.assert_(MyType in _checkers)
-        self.assert_(MyType2 in _checkers)
+        self.assertTrue(MyType in BasicTypes)
+        self.assertTrue(MyType2 in BasicTypes)
+        self.assertTrue(MyType in _checkers)
+        self.assertTrue(MyType2 in _checkers)
 
         # Let's remove the two new types
         del BasicTypes[MyType]
@@ -2011,17 +2011,17 @@ class TestBasicTypes(unittest.TestCase):
         # Of course, BasicTypes is a full dictionary. This dictionary is by
         # default filled with several entries:
         keys = BasicTypes.keys()
-        self.assert_(bool in keys)
-        self.assert_(int in keys)
-        self.assert_(float in keys)
-        self.assert_(str in keys)
+        self.assertTrue(bool in keys)
+        self.assertTrue(int in keys)
+        self.assertTrue(float in keys)
+        self.assertTrue(str in keys)
         try:
             unicode
         except NameError: #pragma NO COVER Py3k
             pass
         else:             #pragma NO COVER Python2
-            self.assert_(unicode in keys)
-        self.assert_(object in keys)
+            self.assertTrue(unicode in keys)
+        self.assertTrue(object in keys)
         # ...
 
         # Finally, the ``clear()`` method has been deactivated to avoid
diff --git a/src/zope/security/tests/test_management.py b/src/zope/security/tests/test_management.py
index b5951cd..8eee32b 100644
--- a/src/zope/security/tests/test_management.py
+++ b/src/zope/security/tests/test_management.py
@@ -46,7 +46,7 @@ class Test(unittest.TestCase):
 
         policy = PermissiveSecurityPolicy
         setSecurityPolicy(policy)
-        self.assert_(getSecurityPolicy() is policy)
+        self.assertTrue(getSecurityPolicy() is policy)
 
     def test_getInteraction_none_present(self):
         from zope.security.interfaces import NoInteraction
@@ -55,7 +55,7 @@ class Test(unittest.TestCase):
 
     def test_queryInteraction_none_present(self):
         from zope.security.management import queryInteraction
-        self.assertEquals(queryInteraction(), None)
+        self.assertEqual(queryInteraction(), None)
 
     def test_newInteraction(self):
         from zope.security.management import newInteraction
@@ -76,7 +76,7 @@ class Test(unittest.TestCase):
         from zope.security.management import queryInteraction
         newInteraction()
         endInteraction()
-        self.assertEquals(queryInteraction(), None)
+        self.assertEqual(queryInteraction(), None)
 
     def test_endInteraction_repeated(self):
         from zope.security.management import endInteraction
@@ -85,9 +85,9 @@ class Test(unittest.TestCase):
         newInteraction()
         interaction = queryInteraction()
         endInteraction()
-        self.assertEquals(queryInteraction(), None)
+        self.assertEqual(queryInteraction(), None)
         endInteraction()
-        self.assertEquals(queryInteraction(), None)
+        self.assertEqual(queryInteraction(), None)
 
     def test_restoreInteraction_after_end(self):
         from zope.security.management import endInteraction
@@ -98,16 +98,16 @@ class Test(unittest.TestCase):
         interaction = queryInteraction()
         endInteraction()
         restoreInteraction()
-        self.assert_(interaction is queryInteraction())
+        self.assertTrue(interaction is queryInteraction())
 
     def test_restoreInteraction_after_new(self):
         from zope.security.management import newInteraction
         from zope.security.management import queryInteraction
         from zope.security.management import restoreInteraction
         newInteraction()
-        self.assert_(queryInteraction() is not None)
+        self.assertTrue(queryInteraction() is not None)
         restoreInteraction() # restore to no interaction
-        self.assert_(queryInteraction() is None)
+        self.assertTrue(queryInteraction() is None)
 
     def test_restoreInteraction_after_neither(self):
         from zope.security.management import queryInteraction
@@ -122,7 +122,7 @@ class Test(unittest.TestCase):
         except AttributeError:
             pass
         restoreInteraction()
-        self.assert_(queryInteraction() is None)
+        self.assertTrue(queryInteraction() is None)
 
     def test_checkPermission_w_no_interaction(self):
         from zope.security.management import checkPermission
@@ -142,15 +142,15 @@ class Test(unittest.TestCase):
 
         class PolicyStub(object):
             def checkPermission(s, p, o,):
-                self.assert_(p is permission)
-                self.assert_(o is obj)
-                self.assert_(s is queryInteraction() or s is interaction)
+                self.assertTrue(p is permission)
+                self.assertTrue(o is obj)
+                self.assertTrue(s is queryInteraction() or s is interaction)
                 return s is interaction
 
         setSecurityPolicy(PolicyStub)
         newInteraction()
         interaction = queryInteraction()
-        self.assertEquals(checkPermission(permission, obj), True)
+        self.assertEqual(checkPermission(permission, obj), True)
 
     def test_checkPermission_forbidden_policy(self):
         from zope.security import checkPermission
@@ -166,21 +166,21 @@ class Test(unittest.TestCase):
 
         setSecurityPolicy(ForbiddenPolicyStub)
         newInteraction()
-        self.assertEquals(checkPermission('zope.Test', obj), False)
-        self.assertEquals(checkPermission(None, obj), True)
-        self.assertEquals(checkPermission(CheckerPublic, obj), True)
+        self.assertEqual(checkPermission('zope.Test', obj), False)
+        self.assertEqual(checkPermission(None, obj), True)
+        self.assertEqual(checkPermission(CheckerPublic, obj), True)
 
     def test_system_user(self):
         from zope.security.management import system_user
         from zope.security._compat import TEXT
         from zope.security._compat import _u
-        self.assertEquals(system_user.id,
+        self.assertEqual(system_user.id,
                           _u('zope.security.management.system_user'))
 
-        self.assertEquals(system_user.title, _u('System'))
+        self.assertEqual(system_user.title, _u('System'))
 
         for name in 'id', 'title', 'description':
-            self.assert_(isinstance(getattr(system_user, name), TEXT))
+            self.assertTrue(isinstance(getattr(system_user, name), TEXT))
 
 def test_suite():
     return unittest.TestSuite((
diff --git a/src/zope/security/tests/test_proxy.py b/src/zope/security/tests/test_proxy.py
index d945693..cc76993 100644
--- a/src/zope/security/tests/test_proxy.py
+++ b/src/zope/security/tests/test_proxy.py
@@ -151,7 +151,7 @@ class ProxyTests(unittest.TestCase):
 
     def testDerivation(self):
         from zope.proxy import ProxyBase
-        self.assert_(isinstance(self.p, ProxyBase))
+        self.assertTrue(isinstance(self.p, ProxyBase))
 
     def testStr(self):
         from zope.security.proxy import ProxyFactory
@@ -162,7 +162,7 @@ class ProxyTests(unittest.TestCase):
         c.ok = 0
         p = ProxyFactory(x, c)
         s = str(p)
-        self.failUnless(s.startswith(
+        self.assertTrue(s.startswith(
             "<security proxied %s.%s instance at"
             % (x.__class__.__module__, x.__class__.__name__)),
                         s)
@@ -177,7 +177,7 @@ class ProxyTests(unittest.TestCase):
         c.ok = 0
         p = ProxyFactory(x, c)
         s = repr(p)
-        self.failUnless(s.startswith(
+        self.assertTrue(s.startswith(
             "<security proxied %s.%s instance at"
             % (x.__class__.__module__, x.__class__.__name__)),
                         s)
@@ -228,7 +228,7 @@ class ProxyTests(unittest.TestCase):
         self.shouldFail(self.p, None)
 
     def testRichCompareOK(self):
-        self.failUnless(self.p == self.x)
+        self.assertTrue(self.p == self.x)
 
 ##     def testRichCompareFail(self):
 ##         self.shouldFail(lambda: self.p == self.x)
@@ -287,7 +287,7 @@ class ProxyTests(unittest.TestCase):
         self.shouldFail(doit)
 
     def testContainsOK(self):
-        self.failUnless(42 in self.p)
+        self.assertTrue(42 in self.p)
 
     def testContainsFail(self):
         self.shouldFail(lambda: 42 in self.p)
@@ -383,7 +383,7 @@ class ProxyTests(unittest.TestCase):
         a = [1, 2, 3]
         pa = qa = P(a)
         pa += [4, 5, 6]
-        self.failUnless(pa is qa)
+        self.assertTrue(pa is qa)
         self.assertEqual(a, [1, 2, 3, 4, 5, 6])
 
         def doit():
@@ -412,51 +412,51 @@ class ProxyTests(unittest.TestCase):
         x = P(1)
         y = P(2)
         a, b = coerce(x, y)
-        self.failUnless(a is x and b is y)
+        self.assertTrue(a is x and b is y)
 
         x = P(1)
         y = P(2.1)
         a, b = coerce(x, y)
-        self.failUnless(removeSecurityProxy(a) == 1.0 and b is y)
+        self.assertTrue(removeSecurityProxy(a) == 1.0 and b is y)
         if fixed_coerce:
-            self.failUnless(type(removeSecurityProxy(a)) is float and b is y)
+            self.assertTrue(type(removeSecurityProxy(a)) is float and b is y)
 
         x = P(1.1)
         y = P(2)
         a, b = coerce(x, y)
-        self.failUnless(a is x and removeSecurityProxy(b) == 2.0)
+        self.assertTrue(a is x and removeSecurityProxy(b) == 2.0)
         if fixed_coerce:
-            self.failUnless(a is x and type(removeSecurityProxy(b)) is float)
+            self.assertTrue(a is x and type(removeSecurityProxy(b)) is float)
 
         x = P(1)
         y = 2
         a, b = coerce(x, y)
-        self.failUnless(a is x and b is y)
+        self.assertTrue(a is x and b is y)
 
         x = P(1)
         y = 2.1
         a, b = coerce(x, y)
-        self.failUnless(type(removeSecurityProxy(a)) is float and b is y)
+        self.assertTrue(type(removeSecurityProxy(a)) is float and b is y)
 
         x = P(1.1)
         y = 2
         a, b = coerce(x, y)
-        self.failUnless(a is x and type(removeSecurityProxy(b)) is float)
+        self.assertTrue(a is x and type(removeSecurityProxy(b)) is float)
 
         x = 1
         y = P(2)
         a, b = coerce(x, y)
-        self.failUnless(a is x and b is y)
+        self.assertTrue(a is x and b is y)
 
         x = 1.1
         y = P(2)
         a, b = coerce(x, y)
-        self.failUnless(a is x and type(removeSecurityProxy(b)) is float)
+        self.assertTrue(a is x and type(removeSecurityProxy(b)) is float)
 
         x = 1
         y = P(2.1)
         a, b = coerce(x, y)
-        self.failUnless(type(removeSecurityProxy(a)) is float and b is y)
+        self.assertTrue(type(removeSecurityProxy(a)) is float and b is y)
 
 def test_using_mapping_slots_hack():
     """The security proxy will use mapping slots, on the checker to go faster
diff --git a/src/zope/security/tests/test_simpleinteraction.py b/src/zope/security/tests/test_simpleinteraction.py
index 99f5e50..d5031e4 100644
--- a/src/zope/security/tests/test_simpleinteraction.py
+++ b/src/zope/security/tests/test_simpleinteraction.py
@@ -37,8 +37,8 @@ class TestInteraction(unittest.TestCase):
         rq = RequestStub()
         interaction = ParanoidSecurityPolicy()
         interaction.add(rq)
-        self.assert_(rq in interaction.participations)
-        self.assert_(rq.interaction is interaction)
+        self.assertTrue(rq in interaction.participations)
+        self.assertTrue(rq.interaction is interaction)
 
         # rq already added
         self.assertRaises(ValueError, interaction.add, rq)
@@ -56,8 +56,8 @@ class TestInteraction(unittest.TestCase):
         interaction.add(rq)
 
         interaction.remove(rq)
-        self.assert_(rq not in interaction.participations)
-        self.assert_(rq.interaction is None)
+        self.assertTrue(rq not in interaction.participations)
+        self.assertTrue(rq.interaction is None)
 
     def testCreateInteraction(self):
         from zope.interface.verify import verifyObject
@@ -65,13 +65,13 @@ class TestInteraction(unittest.TestCase):
         from zope.security.simplepolicies import ParanoidSecurityPolicy
         i1 = ParanoidSecurityPolicy()
         verifyObject(IInteraction, i1)
-        self.assertEquals(list(i1.participations), [])
+        self.assertEqual(list(i1.participations), [])
 
         user = object()
         request = RequestStub(user)
         i2 = ParanoidSecurityPolicy(request)
         verifyObject(IInteraction, i2)
-        self.assertEquals(list(i2.participations), [request])
+        self.assertEqual(list(i2.participations), [request])
 
 
 def test_suite():
diff --git a/src/zope/security/tests/test_zcml_functest.py b/src/zope/security/tests/test_zcml_functest.py
index 6e1beb5..5f79fae 100644
--- a/src/zope/security/tests/test_zcml_functest.py
+++ b/src/zope/security/tests/test_zcml_functest.py
@@ -99,7 +99,7 @@ class TestClassDirective(unittest.TestCase):
 </class>
                        """)
         xmlconfig(f)
-        self.failUnless(IExample.implementedBy(ExampleClass))
+        self.assertTrue(IExample.implementedBy(ExampleClass))
 
         self.assertEqual(queryInterface(
             "zope.security.tests.exampleclass.IExample"), IExample)
@@ -127,8 +127,8 @@ class TestClassDirective(unittest.TestCase):
 </class>
                        """)
         xmlconfig(f)
-        self.failUnless(IExample.implementedBy(ExampleClass))
-        self.failUnless(IExample2.implementedBy(ExampleClass))
+        self.assertTrue(IExample.implementedBy(ExampleClass))
+        self.assertTrue(IExample2.implementedBy(ExampleClass))
 
         self.assertEqual(queryInterface(
             "zope.security.tests.exampleclass.IExample"), IExample)
@@ -214,8 +214,8 @@ class TestFactorySubdirective(unittest.TestCase):
                        """)
         xmlconfig(f)
         factory = getUtility(IFactory, 'test.Example')
-        self.assertEquals(factory.title, "Example content")
-        self.assertEquals(factory.description, "Example description")
+        self.assertEqual(factory.title, "Example content")
+        self.assertEqual(factory.description, "Example description")
 
     @_skip_wo_zope_configuration
     def testFactoryNoId(self):
@@ -239,8 +239,8 @@ class TestFactorySubdirective(unittest.TestCase):
                           IFactory, 'Example')
         factory = getUtility(
             IFactory, 'zope.security.tests.exampleclass.ExampleClass')
-        self.assertEquals(factory.title, "Example content")
-        self.assertEquals(factory.description, "Example description")
+        self.assertEqual(factory.title, "Example content")
+        self.assertEqual(factory.description, "Example description")
 
 
     @_skip_wo_zope_configuration
@@ -260,7 +260,7 @@ class TestFactorySubdirective(unittest.TestCase):
             """)
         xmlconfig(f)
         factory = getUtility(IFactory, 'test.Example')
-        self.assert_(hasattr(factory, '__Security_checker__'))
+        self.assertTrue(hasattr(factory, '__Security_checker__'))
 
 
 class Context(object):
@@ -330,7 +330,7 @@ class TestFactoryDirective(unittest.TestCase):
 </class>''')
         xmlconfig(f)
         obj = createObject('test.Example')
-        self.failUnless(proxy.isinstance(obj, exampleclass.ExampleClass))
+        self.assertTrue(proxy.isinstance(obj, exampleclass.ExampleClass))