Intermediate changes

commit_hash:7a203c6d0c248df6f8cf32d7de94727084be033c

1 files changed, 292 insertions, 280 deletions

diff --git a/contrib/python/zope.interface/py3/zope/interface/tests/test_registry.py b/contrib/python/zope.interface/py3/zope/interface/tests/test_registry.py
index fbe1ed2b54..0da200ebed 100644
--- a/contrib/python/zope.interface/py3/zope/interface/tests/test_registry.py
+++ b/contrib/python/zope.interface/py3/zope/interface/tests/test_registry.py
@@ -43,8 +43,8 @@ class ComponentsTests(unittest.TestCase):
         comp = self._makeOne('testing')
         self.assertEqual(comp.__name__, 'testing')
         self.assertEqual(comp.__bases__, ())
-        self.assertTrue(isinstance(comp.adapters, AdapterRegistry))
-        self.assertTrue(isinstance(comp.utilities, AdapterRegistry))
+        self.assertIsInstance(comp.adapters, AdapterRegistry)
+        self.assertIsInstance(comp.utilities, AdapterRegistry)
         self.assertEqual(comp.adapters.__bases__, ())
         self.assertEqual(comp.utilities.__bases__, ())
         self.assertEqual(comp._utility_registrations, {})
@@ -123,7 +123,7 @@ class ComponentsTests(unittest.TestCase):
         _monkey, _events = self._wrapEvents()
         with _monkey:
             comp.registerUtility(_to_reg, ifoo, _name, _info)
-        self.assertTrue(comp.utilities._adapters[0][ifoo][_name] is _to_reg)
+        self.assertIs(comp.utilities._adapters[0][ifoo][_name], _to_reg)
         self.assertEqual(comp._utility_registrations[ifoo, _name],
                          (_to_reg, _info, None))
         self.assertEqual(comp.utilities._subscribers[0][ifoo][''], (_to_reg,))
@@ -131,14 +131,14 @@ class ComponentsTests(unittest.TestCase):
         args, kw = _events[0]
         event, = args
         self.assertEqual(kw, {})
-        self.assertTrue(isinstance(event, Registered))
-        self.assertTrue(isinstance(event.object, UtilityRegistration))
-        self.assertTrue(event.object.registry is comp)
-        self.assertTrue(event.object.provided is ifoo)
-        self.assertTrue(event.object.name is _name)
-        self.assertTrue(event.object.component is _to_reg)
-        self.assertTrue(event.object.info is _info)
-        self.assertTrue(event.object.factory is None)
+        self.assertIsInstance(event, Registered)
+        self.assertIsInstance(event.object, UtilityRegistration)
+        self.assertIs(event.object.registry, comp)
+        self.assertIs(event.object.provided, ifoo)
+        self.assertIs(event.object.name, _name)
+        self.assertIs(event.object.component, _to_reg)
+        self.assertIs(event.object.info, _info)
+        self.assertIsNone(event.object.factory)
 
     def test_registerUtility_w_factory(self):
         from zope.interface.declarations import InterfaceClass
@@ -164,14 +164,14 @@ class ComponentsTests(unittest.TestCase):
         args, kw = _events[0]
         event, = args
         self.assertEqual(kw, {})
-        self.assertTrue(isinstance(event, Registered))
-        self.assertTrue(isinstance(event.object, UtilityRegistration))
-        self.assertTrue(event.object.registry is comp)
-        self.assertTrue(event.object.provided is ifoo)
-        self.assertTrue(event.object.name is _name)
-        self.assertTrue(event.object.component is _to_reg)
-        self.assertTrue(event.object.info is _info)
-        self.assertTrue(event.object.factory is _factory)
+        self.assertIsInstance(event, Registered)
+        self.assertIsInstance(event.object, UtilityRegistration)
+        self.assertIs(event.object.registry, comp)
+        self.assertIs(event.object.provided, ifoo)
+        self.assertIs(event.object.name, _name)
+        self.assertIs(event.object.component, _to_reg)
+        self.assertIs(event.object.info, _info)
+        self.assertIs(event.object.factory, _factory)
 
     def test_registerUtility_no_provided_available(self):
 
@@ -210,14 +210,14 @@ class ComponentsTests(unittest.TestCase):
         args, kw = _events[0]
         event, = args
         self.assertEqual(kw, {})
-        self.assertTrue(isinstance(event, Registered))
-        self.assertTrue(isinstance(event.object, UtilityRegistration))
-        self.assertTrue(event.object.registry is comp)
-        self.assertTrue(event.object.provided is ifoo)
-        self.assertTrue(event.object.name is _name)
-        self.assertTrue(event.object.component is _to_reg)
-        self.assertTrue(event.object.info is _info)
-        self.assertTrue(event.object.factory is None)
+        self.assertIsInstance(event, Registered)
+        self.assertIsInstance(event.object, UtilityRegistration)
+        self.assertIs(event.object.registry, comp)
+        self.assertIs(event.object.provided, ifoo)
+        self.assertIs(event.object.name, _name)
+        self.assertIs(event.object.component, _to_reg)
+        self.assertIs(event.object.info, _info)
+        self.assertIsNone(event.object.factory)
 
     def test_registerUtility_duplicates_existing_reg(self):
         from zope.interface.declarations import InterfaceClass
@@ -305,25 +305,25 @@ class ComponentsTests(unittest.TestCase):
         args, kw = _events[0]
         event, = args
         self.assertEqual(kw, {})
-        self.assertTrue(isinstance(event, Unregistered))
-        self.assertTrue(isinstance(event.object, UtilityRegistration))
-        self.assertTrue(event.object.registry is comp)
-        self.assertTrue(event.object.provided is ifoo)
-        self.assertTrue(event.object.name is _name)
-        self.assertTrue(event.object.component is _before)
-        self.assertTrue(event.object.info is _info)
-        self.assertTrue(event.object.factory is None)
+        self.assertIsInstance(event, Unregistered)
+        self.assertIsInstance(event.object, UtilityRegistration)
+        self.assertIs(event.object.registry, comp)
+        self.assertIs(event.object.provided, ifoo)
+        self.assertIs(event.object.name, _name)
+        self.assertIs(event.object.component, _before)
+        self.assertIs(event.object.info, _info)
+        self.assertIsNone(event.object.factory)
         args, kw = _events[1]
         event, = args
         self.assertEqual(kw, {})
-        self.assertTrue(isinstance(event, Registered))
-        self.assertTrue(isinstance(event.object, UtilityRegistration))
-        self.assertTrue(event.object.registry is comp)
-        self.assertTrue(event.object.provided is ifoo)
-        self.assertTrue(event.object.name is _name)
-        self.assertTrue(event.object.component is _after)
-        self.assertTrue(event.object.info is _info)
-        self.assertTrue(event.object.factory is None)
+        self.assertIsInstance(event, Registered)
+        self.assertIsInstance(event.object, UtilityRegistration)
+        self.assertIs(event.object.registry, comp)
+        self.assertIs(event.object.provided, ifoo)
+        self.assertIs(event.object.name, _name)
+        self.assertIs(event.object.component, _after)
+        self.assertIs(event.object.info, _info)
+        self.assertIsNone(event.object.factory)
 
     def test_registerUtility_w_existing_subscr(self):
         from zope.interface.declarations import InterfaceClass
@@ -463,19 +463,19 @@ class ComponentsTests(unittest.TestCase):
             unreg = comp.unregisterUtility(_to_reg, ifoo, _name)
         self.assertTrue(unreg)
         self.assertFalse(comp.utilities._adapters)  # all erased
-        self.assertFalse((ifoo, _name) in comp._utility_registrations)
+        self.assertNotIn((ifoo, _name), comp._utility_registrations)
         self.assertFalse(comp.utilities._subscribers)
         self.assertEqual(len(_events), 1)
         args, kw = _events[0]
         event, = args
         self.assertEqual(kw, {})
-        self.assertTrue(isinstance(event, Unregistered))
-        self.assertTrue(isinstance(event.object, UtilityRegistration))
-        self.assertTrue(event.object.registry is comp)
-        self.assertTrue(event.object.provided is ifoo)
-        self.assertTrue(event.object.name is _name)
-        self.assertTrue(event.object.component is _to_reg)
-        self.assertTrue(event.object.factory is None)
+        self.assertIsInstance(event, Unregistered)
+        self.assertIsInstance(event.object, UtilityRegistration)
+        self.assertIs(event.object.registry, comp)
+        self.assertIs(event.object.provided, ifoo)
+        self.assertIs(event.object.name, _name)
+        self.assertIs(event.object.component, _to_reg)
+        self.assertIsNone(event.object.factory)
 
     def test_unregisterUtility_w_factory(self):
         from zope.interface.declarations import InterfaceClass
@@ -503,13 +503,13 @@ class ComponentsTests(unittest.TestCase):
         args, kw = _events[0]
         event, = args
         self.assertEqual(kw, {})
-        self.assertTrue(isinstance(event, Unregistered))
-        self.assertTrue(isinstance(event.object, UtilityRegistration))
-        self.assertTrue(event.object.registry is comp)
-        self.assertTrue(event.object.provided is ifoo)
-        self.assertTrue(event.object.name is _name)
-        self.assertTrue(event.object.component is _to_reg)
-        self.assertTrue(event.object.factory is _factory)
+        self.assertIsInstance(event, Unregistered)
+        self.assertIsInstance(event.object, UtilityRegistration)
+        self.assertIs(event.object.registry, comp)
+        self.assertIs(event.object.provided, ifoo)
+        self.assertIs(event.object.name, _name)
+        self.assertIs(event.object.component, _to_reg)
+        self.assertIs(event.object.factory, _factory)
 
     def test_unregisterUtility_wo_explicit_provided(self):
         from zope.interface.declarations import InterfaceClass
@@ -538,14 +538,14 @@ class ComponentsTests(unittest.TestCase):
         args, kw = _events[0]
         event, = args
         self.assertEqual(kw, {})
-        self.assertTrue(isinstance(event, Unregistered))
-        self.assertTrue(isinstance(event.object, UtilityRegistration))
-        self.assertTrue(event.object.registry is comp)
-        self.assertTrue(event.object.provided is ifoo)
-        self.assertTrue(event.object.name is _name)
-        self.assertTrue(event.object.component is _to_reg)
-        self.assertTrue(event.object.info is _info)
-        self.assertTrue(event.object.factory is None)
+        self.assertIsInstance(event, Unregistered)
+        self.assertIsInstance(event.object, UtilityRegistration)
+        self.assertIs(event.object.registry, comp)
+        self.assertIs(event.object.provided, ifoo)
+        self.assertIs(event.object.name, _name)
+        self.assertIs(event.object.component, _to_reg)
+        self.assertIs(event.object.info, _info)
+        self.assertIsNone(event.object.factory)
 
     def test_unregisterUtility_wo_component_or_factory(self):
         from zope.interface.declarations import InterfaceClass
@@ -575,14 +575,14 @@ class ComponentsTests(unittest.TestCase):
         args, kw = _events[0]
         event, = args
         self.assertEqual(kw, {})
-        self.assertTrue(isinstance(event, Unregistered))
-        self.assertTrue(isinstance(event.object, UtilityRegistration))
-        self.assertTrue(event.object.registry is comp)
-        self.assertTrue(event.object.provided is ifoo)
-        self.assertTrue(event.object.name is _name)
-        self.assertTrue(event.object.component is _to_reg)
-        self.assertTrue(event.object.info is _info)
-        self.assertTrue(event.object.factory is None)
+        self.assertIsInstance(event, Unregistered)
+        self.assertIsInstance(event.object, UtilityRegistration)
+        self.assertIs(event.object.registry, comp)
+        self.assertIs(event.object.provided, ifoo)
+        self.assertIs(event.object.name, _name)
+        self.assertIs(event.object.component, _to_reg)
+        self.assertIs(event.object.info, _info)
+        self.assertIsNone(event.object.factory)
 
     def test_unregisterUtility_w_existing_subscr(self):
         from zope.interface.declarations import InterfaceClass
@@ -738,20 +738,20 @@ class ComponentsTests(unittest.TestCase):
         comp.registerUtility(_to_reg, ifoo, _name2, _info)
         reg = sorted(comp.registeredUtilities(), key=lambda r: r.name)
         self.assertEqual(len(reg), 2)
-        self.assertTrue(isinstance(reg[0], UtilityRegistration))
-        self.assertTrue(reg[0].registry is comp)
-        self.assertTrue(reg[0].provided is ifoo)
-        self.assertTrue(reg[0].name is _name1)
-        self.assertTrue(reg[0].component is _to_reg)
-        self.assertTrue(reg[0].info is _info)
-        self.assertTrue(reg[0].factory is None)
-        self.assertTrue(isinstance(reg[1], UtilityRegistration))
-        self.assertTrue(reg[1].registry is comp)
-        self.assertTrue(reg[1].provided is ifoo)
-        self.assertTrue(reg[1].name is _name2)
-        self.assertTrue(reg[1].component is _to_reg)
-        self.assertTrue(reg[1].info is _info)
-        self.assertTrue(reg[1].factory is None)
+        self.assertIsInstance(reg[0], UtilityRegistration)
+        self.assertIs(reg[0].registry, comp)
+        self.assertIs(reg[0].provided, ifoo)
+        self.assertIs(reg[0].name, _name1)
+        self.assertIs(reg[0].component, _to_reg)
+        self.assertIs(reg[0].info, _info)
+        self.assertIsNone(reg[0].factory)
+        self.assertIsInstance(reg[1], UtilityRegistration)
+        self.assertIs(reg[1].registry, comp)
+        self.assertIs(reg[1].provided, ifoo)
+        self.assertIs(reg[1].name, _name2)
+        self.assertIs(reg[1].component, _to_reg)
+        self.assertIs(reg[1].info, _info)
+        self.assertIsNone(reg[1].factory)
 
     def test_queryUtility_miss_no_default(self):
         from zope.interface.declarations import InterfaceClass
@@ -761,7 +761,7 @@ class ComponentsTests(unittest.TestCase):
 
         ifoo = IFoo('IFoo')
         comp = self._makeOne()
-        self.assertTrue(comp.queryUtility(ifoo) is None)
+        self.assertIsNone(comp.queryUtility(ifoo))
 
     def test_queryUtility_miss_w_default(self):
         from zope.interface.declarations import InterfaceClass
@@ -772,7 +772,7 @@ class ComponentsTests(unittest.TestCase):
         ifoo = IFoo('IFoo')
         comp = self._makeOne()
         _default = object()
-        self.assertTrue(comp.queryUtility(ifoo, default=_default) is _default)
+        self.assertIs(comp.queryUtility(ifoo, default=_default), _default)
 
     def test_queryUtility_hit(self):
         from zope.interface.declarations import InterfaceClass
@@ -784,7 +784,7 @@ class ComponentsTests(unittest.TestCase):
         _to_reg = object()
         comp = self._makeOne()
         comp.registerUtility(_to_reg, ifoo)
-        self.assertTrue(comp.queryUtility(ifoo) is _to_reg)
+        self.assertIs(comp.queryUtility(ifoo), _to_reg)
 
     def test_getUtility_miss(self):
         from zope.interface.declarations import InterfaceClass
@@ -807,7 +807,7 @@ class ComponentsTests(unittest.TestCase):
         _to_reg = object()
         comp = self._makeOne()
         comp.registerUtility(_to_reg, ifoo)
-        self.assertTrue(comp.getUtility(ifoo) is _to_reg)
+        self.assertIs(comp.getUtility(ifoo), _to_reg)
 
     def test_getUtilitiesFor_miss(self):
         from zope.interface.declarations import InterfaceClass
@@ -902,22 +902,24 @@ class ComponentsTests(unittest.TestCase):
         _monkey, _events = self._wrapEvents()
         with _monkey:
             comp.registerAdapter(_factory, (ibar,), ifoo, _name, _info)
-        self.assertTrue(comp.adapters._adapters[1][ibar][ifoo][_name]
-                        is _factory)
+        self.assertIs(
+            comp.adapters._adapters[1][ibar][ifoo][_name],
+            _factory
+        )
         self.assertEqual(comp._adapter_registrations[(ibar,), ifoo, _name],
                          (_factory, _info))
         self.assertEqual(len(_events), 1)
         args, kw = _events[0]
         event, = args
         self.assertEqual(kw, {})
-        self.assertTrue(isinstance(event, Registered))
-        self.assertTrue(isinstance(event.object, AdapterRegistration))
-        self.assertTrue(event.object.registry is comp)
-        self.assertTrue(event.object.provided is ifoo)
+        self.assertIsInstance(event, Registered)
+        self.assertIsInstance(event.object, AdapterRegistration)
+        self.assertIs(event.object.registry, comp)
+        self.assertIs(event.object.provided, ifoo)
         self.assertEqual(event.object.required, (ibar,))
-        self.assertTrue(event.object.name is _name)
-        self.assertTrue(event.object.info is _info)
-        self.assertTrue(event.object.factory is _factory)
+        self.assertIs(event.object.name, _name)
+        self.assertIs(event.object.info, _info)
+        self.assertIs(event.object.factory, _factory)
 
     def test_registerAdapter_no_provided_available(self):
         from zope.interface.declarations import InterfaceClass
@@ -958,22 +960,24 @@ class ComponentsTests(unittest.TestCase):
         _monkey, _events = self._wrapEvents()
         with _monkey:
             comp.registerAdapter(_Factory, (ibar,), name=_name, info=_info)
-        self.assertTrue(comp.adapters._adapters[1][ibar][ifoo][_name]
-                        is _Factory)
+        self.assertIs(
+            comp.adapters._adapters[1][ibar][ifoo][_name],
+            _Factory
+        )
         self.assertEqual(comp._adapter_registrations[(ibar,), ifoo, _name],
                          (_Factory, _info))
         self.assertEqual(len(_events), 1)
         args, kw = _events[0]
         event, = args
         self.assertEqual(kw, {})
-        self.assertTrue(isinstance(event, Registered))
-        self.assertTrue(isinstance(event.object, AdapterRegistration))
-        self.assertTrue(event.object.registry is comp)
-        self.assertTrue(event.object.provided is ifoo)
+        self.assertIsInstance(event, Registered)
+        self.assertIsInstance(event.object, AdapterRegistration)
+        self.assertIs(event.object.registry, comp)
+        self.assertIs(event.object.provided, ifoo)
         self.assertEqual(event.object.required, (ibar,))
-        self.assertTrue(event.object.name is _name)
-        self.assertTrue(event.object.info is _info)
-        self.assertTrue(event.object.factory is _Factory)
+        self.assertIs(event.object.name, _name)
+        self.assertIs(event.object.info, _info)
+        self.assertIs(event.object.factory, _Factory)
 
     def test_registerAdapter_no_required_available(self):
         from zope.interface.declarations import InterfaceClass
@@ -1032,8 +1036,9 @@ class ComponentsTests(unittest.TestCase):
         with _monkey:
             comp.registerAdapter(_Factory, [None], provided=ifoo,
                                  name=_name, info=_info)
-        self.assertTrue(
-            comp.adapters._adapters[1][Interface][ifoo][_name] is _Factory
+        self.assertIs(
+            comp.adapters._adapters[1][Interface][ifoo][_name],
+            _Factory
         )
         self.assertEqual(
             comp._adapter_registrations[(Interface,), ifoo, _name],
@@ -1043,14 +1048,14 @@ class ComponentsTests(unittest.TestCase):
         args, kw = _events[0]
         event, = args
         self.assertEqual(kw, {})
-        self.assertTrue(isinstance(event, Registered))
-        self.assertTrue(isinstance(event.object, AdapterRegistration))
-        self.assertTrue(event.object.registry is comp)
-        self.assertTrue(event.object.provided is ifoo)
+        self.assertIsInstance(event, Registered)
+        self.assertIsInstance(event.object, AdapterRegistration)
+        self.assertIs(event.object.registry, comp)
+        self.assertIs(event.object.provided, ifoo)
         self.assertEqual(event.object.required, (Interface,))
-        self.assertTrue(event.object.name is _name)
-        self.assertTrue(event.object.info is _info)
-        self.assertTrue(event.object.factory is _Factory)
+        self.assertIs(event.object.name, _name)
+        self.assertIs(event.object.info, _info)
+        self.assertIs(event.object.factory, _Factory)
 
     def test_registerAdapter_w_required_containing_class(self):
         from zope.interface.declarations import InterfaceClass
@@ -1080,8 +1085,9 @@ class ComponentsTests(unittest.TestCase):
         with _monkey:
             comp.registerAdapter(_Factory, [_Context], provided=ifoo,
                                  name=_name, info=_info)
-        self.assertTrue(
-            comp.adapters._adapters[1][_ctx_impl][ifoo][_name] is _Factory
+        self.assertIs(
+            comp.adapters._adapters[1][_ctx_impl][ifoo][_name],
+            _Factory
         )
         self.assertEqual(
             comp._adapter_registrations[(_ctx_impl,), ifoo, _name],
@@ -1091,14 +1097,14 @@ class ComponentsTests(unittest.TestCase):
         args, kw = _events[0]
         event, = args
         self.assertEqual(kw, {})
-        self.assertTrue(isinstance(event, Registered))
-        self.assertTrue(isinstance(event.object, AdapterRegistration))
-        self.assertTrue(event.object.registry is comp)
-        self.assertTrue(event.object.provided is ifoo)
+        self.assertIsInstance(event, Registered)
+        self.assertIsInstance(event.object, AdapterRegistration)
+        self.assertIs(event.object.registry, comp)
+        self.assertIs(event.object.provided, ifoo)
         self.assertEqual(event.object.required, (_ctx_impl,))
-        self.assertTrue(event.object.name is _name)
-        self.assertTrue(event.object.info is _info)
-        self.assertTrue(event.object.factory is _Factory)
+        self.assertIs(event.object.name, _name)
+        self.assertIs(event.object.info, _info)
+        self.assertIs(event.object.factory, _Factory)
 
     def test_registerAdapter_w_required_containing_junk(self):
         from zope.interface.declarations import InterfaceClass
@@ -1141,22 +1147,24 @@ class ComponentsTests(unittest.TestCase):
         with _monkey:
             comp.registerAdapter(_Factory, provided=ifoo, name=_name,
                                  info=_info)
-        self.assertTrue(comp.adapters._adapters[1][ibar][ifoo][_name]
-                        is _Factory)
+        self.assertIs(
+            comp.adapters._adapters[1][ibar][ifoo][_name],
+            _Factory
+        )
         self.assertEqual(comp._adapter_registrations[(ibar,), ifoo, _name],
                          (_Factory, _info))
         self.assertEqual(len(_events), 1)
         args, kw = _events[0]
         event, = args
         self.assertEqual(kw, {})
-        self.assertTrue(isinstance(event, Registered))
-        self.assertTrue(isinstance(event.object, AdapterRegistration))
-        self.assertTrue(event.object.registry is comp)
-        self.assertTrue(event.object.provided is ifoo)
+        self.assertIsInstance(event, Registered)
+        self.assertIsInstance(event.object, AdapterRegistration)
+        self.assertIs(event.object.registry, comp)
+        self.assertIs(event.object.provided, ifoo)
         self.assertEqual(event.object.required, (ibar,))
-        self.assertTrue(event.object.name is _name)
-        self.assertTrue(event.object.info is _info)
-        self.assertTrue(event.object.factory is _Factory)
+        self.assertIs(event.object.name, _name)
+        self.assertIs(event.object.info, _info)
+        self.assertIs(event.object.factory, _Factory)
 
     def test_registerAdapter_wo_event(self):
         from zope.interface.declarations import InterfaceClass
@@ -1238,14 +1246,14 @@ class ComponentsTests(unittest.TestCase):
         args, kw = _events[0]
         event, = args
         self.assertEqual(kw, {})
-        self.assertTrue(isinstance(event, Unregistered))
-        self.assertTrue(isinstance(event.object, AdapterRegistration))
-        self.assertTrue(event.object.registry is comp)
-        self.assertTrue(event.object.provided is ifoo)
+        self.assertIsInstance(event, Unregistered)
+        self.assertIsInstance(event.object, AdapterRegistration)
+        self.assertIs(event.object.registry, comp)
+        self.assertIs(event.object.provided, ifoo)
         self.assertEqual(event.object.required, (ibar,))
         self.assertEqual(event.object.name, '')
         self.assertEqual(event.object.info, '')
-        self.assertTrue(event.object.factory is _Factory)
+        self.assertIs(event.object.factory, _Factory)
 
     def test_unregisterAdapter_wo_explicit_provided(self):
         from zope.interface.declarations import InterfaceClass
@@ -1273,14 +1281,14 @@ class ComponentsTests(unittest.TestCase):
         args, kw = _events[0]
         event, = args
         self.assertEqual(kw, {})
-        self.assertTrue(isinstance(event, Unregistered))
-        self.assertTrue(isinstance(event.object, AdapterRegistration))
-        self.assertTrue(event.object.registry is comp)
-        self.assertTrue(event.object.provided is ifoo)
+        self.assertIsInstance(event, Unregistered)
+        self.assertIsInstance(event.object, AdapterRegistration)
+        self.assertIs(event.object.registry, comp)
+        self.assertIs(event.object.provided, ifoo)
         self.assertEqual(event.object.required, (ibar,))
         self.assertEqual(event.object.name, '')
         self.assertEqual(event.object.info, '')
-        self.assertTrue(event.object.factory is _Factory)
+        self.assertIs(event.object.factory, _Factory)
 
     def test_unregisterAdapter_wo_explicit_required(self):
         from zope.interface.declarations import InterfaceClass
@@ -1306,14 +1314,14 @@ class ComponentsTests(unittest.TestCase):
         args, kw = _events[0]
         event, = args
         self.assertEqual(kw, {})
-        self.assertTrue(isinstance(event, Unregistered))
-        self.assertTrue(isinstance(event.object, AdapterRegistration))
-        self.assertTrue(event.object.registry is comp)
-        self.assertTrue(event.object.provided is ifoo)
+        self.assertIsInstance(event, Unregistered)
+        self.assertIsInstance(event.object, AdapterRegistration)
+        self.assertIs(event.object.registry, comp)
+        self.assertIs(event.object.provided, ifoo)
         self.assertEqual(event.object.required, (ibar,))
         self.assertEqual(event.object.name, '')
         self.assertEqual(event.object.info, '')
-        self.assertTrue(event.object.factory is _Factory)
+        self.assertIs(event.object.factory, _Factory)
 
     def test_registeredAdapters_empty(self):
         comp = self._makeOne()
@@ -1340,20 +1348,20 @@ class ComponentsTests(unittest.TestCase):
         comp.registerAdapter(_Factory, (ibar,), ifoo, _name2, _info)
         reg = sorted(comp.registeredAdapters(), key=lambda r: r.name)
         self.assertEqual(len(reg), 2)
-        self.assertTrue(isinstance(reg[0], AdapterRegistration))
-        self.assertTrue(reg[0].registry is comp)
-        self.assertTrue(reg[0].provided is ifoo)
+        self.assertIsInstance(reg[0], AdapterRegistration)
+        self.assertIs(reg[0].registry, comp)
+        self.assertIs(reg[0].provided, ifoo)
         self.assertEqual(reg[0].required, (ibar,))
-        self.assertTrue(reg[0].name is _name1)
-        self.assertTrue(reg[0].info is _info)
-        self.assertTrue(reg[0].factory is _Factory)
-        self.assertTrue(isinstance(reg[1], AdapterRegistration))
-        self.assertTrue(reg[1].registry is comp)
-        self.assertTrue(reg[1].provided is ifoo)
+        self.assertIs(reg[0].name, _name1)
+        self.assertIs(reg[0].info, _info)
+        self.assertIs(reg[0].factory, _Factory)
+        self.assertIsInstance(reg[1], AdapterRegistration)
+        self.assertIs(reg[1].registry, comp)
+        self.assertIs(reg[1].provided, ifoo)
         self.assertEqual(reg[1].required, (ibar,))
-        self.assertTrue(reg[1].name is _name2)
-        self.assertTrue(reg[1].info is _info)
-        self.assertTrue(reg[1].factory is _Factory)
+        self.assertIs(reg[1].name, _name2)
+        self.assertIs(reg[1].info, _info)
+        self.assertIs(reg[1].factory, _Factory)
 
     def test_queryAdapter_miss_no_default(self):
         from zope.interface.declarations import InterfaceClass
@@ -1364,7 +1372,7 @@ class ComponentsTests(unittest.TestCase):
         ifoo = IFoo('IFoo')
         comp = self._makeOne()
         _context = object()
-        self.assertTrue(comp.queryAdapter(_context, ifoo) is None)
+        self.assertIsNone(comp.queryAdapter(_context, ifoo))
 
     def test_queryAdapter_miss_w_default(self):
         from zope.interface.declarations import InterfaceClass
@@ -1376,8 +1384,10 @@ class ComponentsTests(unittest.TestCase):
         comp = self._makeOne()
         _context = object()
         _default = object()
-        self.assertTrue(
-            comp.queryAdapter(_context, ifoo, default=_default) is _default)
+        self.assertIs(
+            comp.queryAdapter(_context, ifoo, default=_default),
+            _default
+        )
 
     def test_queryAdapter_hit(self):
         from zope.interface.declarations import InterfaceClass
@@ -1401,8 +1411,8 @@ class ComponentsTests(unittest.TestCase):
         comp = self._makeOne()
         comp.registerAdapter(_Factory, (ibar,), ifoo)
         adapter = comp.queryAdapter(_context, ifoo)
-        self.assertTrue(isinstance(adapter, _Factory))
-        self.assertTrue(adapter.context is _context)
+        self.assertIsInstance(adapter, _Factory)
+        self.assertIs(adapter.context, _context)
 
     def test_getAdapter_miss(self):
         from zope.interface.declarations import InterfaceClass
@@ -1590,9 +1600,11 @@ class ComponentsTests(unittest.TestCase):
         _context2 = _Context2()
         _default = object()
         comp = self._makeOne()
-        self.assertTrue(
+        self.assertIs(
             comp.queryMultiAdapter((_context1, _context2), ifoo,
-                                   default=_default) is _default)
+                                   default=_default),
+            _default
+        )
 
     def test_queryMultiAdapter_hit(self):
         from zope.interface.declarations import InterfaceClass
@@ -1623,7 +1635,7 @@ class ComponentsTests(unittest.TestCase):
         comp = self._makeOne()
         comp.registerAdapter(_Factory, (ibar, ibaz), ifoo)
         adapter = comp.queryMultiAdapter((_context1, _context2), ifoo)
-        self.assertTrue(isinstance(adapter, _Factory))
+        self.assertIsInstance(adapter, _Factory)
         self.assertEqual(adapter.context, (_context1, _context2))
 
     def test_getMultiAdapter_miss(self):
@@ -1681,7 +1693,7 @@ class ComponentsTests(unittest.TestCase):
         comp = self._makeOne()
         comp.registerAdapter(_Factory, (ibar, ibaz), ifoo)
         adapter = comp.getMultiAdapter((_context1, _context2), ifoo)
-        self.assertTrue(isinstance(adapter, _Factory))
+        self.assertIsInstance(adapter, _Factory)
         self.assertEqual(adapter.context, (_context1, _context2))
 
     def _should_not_change(self, comp):
@@ -1837,9 +1849,9 @@ class ComponentsTests(unittest.TestCase):
         found = sorted(comp.getAdapters((_context1, _context2), ifoo))
         self.assertEqual(len(found), 2)
         self.assertEqual(found[0][0], _name1)
-        self.assertTrue(isinstance(found[0][1], _Factory1))
+        self.assertIsInstance(found[0][1], _Factory1)
         self.assertEqual(found[1][0], _name2)
-        self.assertTrue(isinstance(found[1][1], _Factory2))
+        self.assertIsInstance(found[1][1], _Factory2)
 
     def test_registerSubscriptionAdapter_w_nonblank_name(self):
         from zope.interface.declarations import InterfaceClass
@@ -1882,21 +1894,21 @@ class ComponentsTests(unittest.TestCase):
                                              info=_info)
         reg = comp.adapters._subscribers[1][ibar][ifoo][_blank]
         self.assertEqual(len(reg), 1)
-        self.assertTrue(reg[0] is _factory)
+        self.assertIs(reg[0], _factory)
         self.assertEqual(comp._subscription_registrations,
                          [((ibar,), ifoo, _blank, _factory, _info)])
         self.assertEqual(len(_events), 1)
         args, kw = _events[0]
         event, = args
         self.assertEqual(kw, {})
-        self.assertTrue(isinstance(event, Registered))
-        self.assertTrue(isinstance(event.object, SubscriptionRegistration))
-        self.assertTrue(event.object.registry is comp)
-        self.assertTrue(event.object.provided is ifoo)
+        self.assertIsInstance(event, Registered)
+        self.assertIsInstance(event.object, SubscriptionRegistration)
+        self.assertIs(event.object.registry, comp)
+        self.assertIs(event.object.provided, ifoo)
         self.assertEqual(event.object.required, (ibar,))
         self.assertEqual(event.object.name, _blank)
-        self.assertTrue(event.object.info is _info)
-        self.assertTrue(event.object.factory is _factory)
+        self.assertIs(event.object.info, _info)
+        self.assertIs(event.object.factory, _factory)
 
     def test_registerSubscriptionAdapter_wo_explicit_provided(self):
         from zope.interface.declarations import InterfaceClass
@@ -1922,21 +1934,21 @@ class ComponentsTests(unittest.TestCase):
             comp.registerSubscriptionAdapter(_Factory, (ibar,), info=_info)
         reg = comp.adapters._subscribers[1][ibar][ifoo][_blank]
         self.assertEqual(len(reg), 1)
-        self.assertTrue(reg[0] is _Factory)
+        self.assertIs(reg[0], _Factory)
         self.assertEqual(comp._subscription_registrations,
                          [((ibar,), ifoo, _blank, _Factory, _info)])
         self.assertEqual(len(_events), 1)
         args, kw = _events[0]
         event, = args
         self.assertEqual(kw, {})
-        self.assertTrue(isinstance(event, Registered))
-        self.assertTrue(isinstance(event.object, SubscriptionRegistration))
-        self.assertTrue(event.object.registry is comp)
-        self.assertTrue(event.object.provided is ifoo)
+        self.assertIsInstance(event, Registered)
+        self.assertIsInstance(event.object, SubscriptionRegistration)
+        self.assertIs(event.object.registry, comp)
+        self.assertIs(event.object.provided, ifoo)
         self.assertEqual(event.object.required, (ibar,))
         self.assertEqual(event.object.name, _blank)
-        self.assertTrue(event.object.info is _info)
-        self.assertTrue(event.object.factory is _Factory)
+        self.assertIs(event.object.info, _info)
+        self.assertIs(event.object.factory, _Factory)
 
     def test_registerSubscriptionAdapter_wo_explicit_required(self):
         from zope.interface.declarations import InterfaceClass
@@ -1962,21 +1974,21 @@ class ComponentsTests(unittest.TestCase):
             )
         reg = comp.adapters._subscribers[1][ibar][ifoo][_blank]
         self.assertEqual(len(reg), 1)
-        self.assertTrue(reg[0] is _Factory)
+        self.assertIs(reg[0], _Factory)
         self.assertEqual(comp._subscription_registrations,
                          [((ibar,), ifoo, _blank, _Factory, _info)])
         self.assertEqual(len(_events), 1)
         args, kw = _events[0]
         event, = args
         self.assertEqual(kw, {})
-        self.assertTrue(isinstance(event, Registered))
-        self.assertTrue(isinstance(event.object, SubscriptionRegistration))
-        self.assertTrue(event.object.registry is comp)
-        self.assertTrue(event.object.provided is ifoo)
+        self.assertIsInstance(event, Registered)
+        self.assertIsInstance(event.object, SubscriptionRegistration)
+        self.assertIs(event.object.registry, comp)
+        self.assertIs(event.object.provided, ifoo)
         self.assertEqual(event.object.required, (ibar,))
         self.assertEqual(event.object.name, _blank)
-        self.assertTrue(event.object.info is _info)
-        self.assertTrue(event.object.factory is _Factory)
+        self.assertIs(event.object.info, _info)
+        self.assertIs(event.object.factory, _Factory)
 
     def test_registerSubscriptionAdapter_wo_event(self):
         from zope.interface.declarations import InterfaceClass
@@ -2022,20 +2034,20 @@ class ComponentsTests(unittest.TestCase):
         comp.registerSubscriptionAdapter(_Factory, (ibar,), ifoo, info=_info)
         reg = list(comp.registeredSubscriptionAdapters())
         self.assertEqual(len(reg), 2)
-        self.assertTrue(isinstance(reg[0], SubscriptionRegistration))
-        self.assertTrue(reg[0].registry is comp)
-        self.assertTrue(reg[0].provided is ifoo)
+        self.assertIsInstance(reg[0], SubscriptionRegistration)
+        self.assertIs(reg[0].registry, comp)
+        self.assertIs(reg[0].provided, ifoo)
         self.assertEqual(reg[0].required, (ibar,))
         self.assertEqual(reg[0].name, _blank)
-        self.assertTrue(reg[0].info is _info)
-        self.assertTrue(reg[0].factory is _Factory)
-        self.assertTrue(isinstance(reg[1], SubscriptionRegistration))
-        self.assertTrue(reg[1].registry is comp)
-        self.assertTrue(reg[1].provided is ifoo)
+        self.assertIs(reg[0].info, _info)
+        self.assertIs(reg[0].factory, _Factory)
+        self.assertIsInstance(reg[1], SubscriptionRegistration)
+        self.assertIs(reg[1].registry, comp)
+        self.assertIs(reg[1].provided, ifoo)
         self.assertEqual(reg[1].required, (ibar,))
         self.assertEqual(reg[1].name, _blank)
-        self.assertTrue(reg[1].info is _info)
-        self.assertTrue(reg[1].factory is _Factory)
+        self.assertIs(reg[1].info, _info)
+        self.assertIs(reg[1].factory, _Factory)
 
     def test_unregisterSubscriptionAdapter_w_nonblank_name(self):
         from zope.interface.declarations import InterfaceClass
@@ -2111,14 +2123,14 @@ class ComponentsTests(unittest.TestCase):
         args, kw = _events[0]
         event, = args
         self.assertEqual(kw, {})
-        self.assertTrue(isinstance(event, Unregistered))
-        self.assertTrue(isinstance(event.object, SubscriptionRegistration))
-        self.assertTrue(event.object.registry is comp)
-        self.assertTrue(event.object.provided is ifoo)
+        self.assertIsInstance(event, Unregistered)
+        self.assertIsInstance(event.object, SubscriptionRegistration)
+        self.assertIs(event.object.registry, comp)
+        self.assertIs(event.object.provided, ifoo)
         self.assertEqual(event.object.required, (ibar,))
         self.assertEqual(event.object.name, '')
         self.assertEqual(event.object.info, '')
-        self.assertTrue(event.object.factory is None)
+        self.assertIsNone(event.object.factory)
 
     def test_unregisterSubscriptionAdapter_hit_w_factory(self):
         from zope.interface.declarations import InterfaceClass
@@ -2146,14 +2158,14 @@ class ComponentsTests(unittest.TestCase):
         args, kw = _events[0]
         event, = args
         self.assertEqual(kw, {})
-        self.assertTrue(isinstance(event, Unregistered))
-        self.assertTrue(isinstance(event.object, SubscriptionRegistration))
-        self.assertTrue(event.object.registry is comp)
-        self.assertTrue(event.object.provided is ifoo)
+        self.assertIsInstance(event, Unregistered)
+        self.assertIsInstance(event.object, SubscriptionRegistration)
+        self.assertIs(event.object.registry, comp)
+        self.assertIs(event.object.provided, ifoo)
         self.assertEqual(event.object.required, (ibar,))
         self.assertEqual(event.object.name, '')
         self.assertEqual(event.object.info, '')
-        self.assertTrue(event.object.factory is _Factory)
+        self.assertIs(event.object.factory, _Factory)
 
     def test_unregisterSubscriptionAdapter_wo_explicit_provided(self):
         from zope.interface.declarations import InterfaceClass
@@ -2181,14 +2193,14 @@ class ComponentsTests(unittest.TestCase):
         args, kw = _events[0]
         event, = args
         self.assertEqual(kw, {})
-        self.assertTrue(isinstance(event, Unregistered))
-        self.assertTrue(isinstance(event.object, SubscriptionRegistration))
-        self.assertTrue(event.object.registry is comp)
-        self.assertTrue(event.object.provided is ifoo)
+        self.assertIsInstance(event, Unregistered)
+        self.assertIsInstance(event.object, SubscriptionRegistration)
+        self.assertIs(event.object.registry, comp)
+        self.assertIs(event.object.provided, ifoo)
         self.assertEqual(event.object.required, (ibar,))
         self.assertEqual(event.object.name, '')
         self.assertEqual(event.object.info, '')
-        self.assertTrue(event.object.factory is _Factory)
+        self.assertIs(event.object.factory, _Factory)
 
     def test_unregisterSubscriptionAdapter_wo_explicit_required(self):
         from zope.interface.declarations import InterfaceClass
@@ -2214,14 +2226,14 @@ class ComponentsTests(unittest.TestCase):
         args, kw = _events[0]
         event, = args
         self.assertEqual(kw, {})
-        self.assertTrue(isinstance(event, Unregistered))
-        self.assertTrue(isinstance(event.object, SubscriptionRegistration))
-        self.assertTrue(event.object.registry is comp)
-        self.assertTrue(event.object.provided is ifoo)
+        self.assertIsInstance(event, Unregistered)
+        self.assertIsInstance(event.object, SubscriptionRegistration)
+        self.assertIs(event.object.registry, comp)
+        self.assertIs(event.object.provided, ifoo)
         self.assertEqual(event.object.required, (ibar,))
         self.assertEqual(event.object.name, '')
         self.assertEqual(event.object.info, '')
-        self.assertTrue(event.object.factory is _Factory)
+        self.assertIs(event.object.factory, _Factory)
 
     def test_subscribers_empty(self):
         from zope.interface.declarations import InterfaceClass
@@ -2276,8 +2288,8 @@ class ComponentsTests(unittest.TestCase):
 
         subscribers = sorted(subscribers, key=_klassname)
         self.assertEqual(len(subscribers), 2)
-        self.assertTrue(isinstance(subscribers[0], _Derived))
-        self.assertTrue(isinstance(subscribers[1], _Factory))
+        self.assertIsInstance(subscribers[0], _Derived)
+        self.assertIsInstance(subscribers[1], _Factory)
 
     def test_registerHandler_w_nonblank_name(self):
         from zope.interface.declarations import InterfaceClass
@@ -2316,20 +2328,20 @@ class ComponentsTests(unittest.TestCase):
             comp.registerHandler(_factory, (ifoo,), info=_info)
         reg = comp.adapters._subscribers[1][ifoo][None][_blank]
         self.assertEqual(len(reg), 1)
-        self.assertTrue(reg[0] is _factory)
+        self.assertIs(reg[0], _factory)
         self.assertEqual(comp._handler_registrations,
                          [((ifoo,), _blank, _factory, _info)])
         self.assertEqual(len(_events), 1)
         args, kw = _events[0]
         event, = args
         self.assertEqual(kw, {})
-        self.assertTrue(isinstance(event, Registered))
-        self.assertTrue(isinstance(event.object, HandlerRegistration))
-        self.assertTrue(event.object.registry is comp)
+        self.assertIsInstance(event, Registered)
+        self.assertIsInstance(event.object, HandlerRegistration)
+        self.assertIs(event.object.registry, comp)
         self.assertEqual(event.object.required, (ifoo,))
         self.assertEqual(event.object.name, _blank)
-        self.assertTrue(event.object.info is _info)
-        self.assertTrue(event.object.factory is _factory)
+        self.assertIs(event.object.info, _info)
+        self.assertIs(event.object.factory, _factory)
 
     def test_registerHandler_wo_explicit_required_no_event(self):
         from zope.interface.declarations import InterfaceClass
@@ -2351,7 +2363,7 @@ class ComponentsTests(unittest.TestCase):
             comp.registerHandler(_Factory, info=_info, event=False)
         reg = comp.adapters._subscribers[1][ifoo][None][_blank]
         self.assertEqual(len(reg), 1)
-        self.assertTrue(reg[0] is _Factory)
+        self.assertIs(reg[0], _Factory)
         self.assertEqual(comp._handler_registrations,
                          [((ifoo,), _blank, _Factory, _info)])
         self.assertEqual(len(_events), 0)
@@ -2384,12 +2396,12 @@ class ComponentsTests(unittest.TestCase):
 
         subscribers = sorted(comp.registeredHandlers(), key=_factory_name)
         self.assertEqual(len(subscribers), 2)
-        self.assertTrue(isinstance(subscribers[0], HandlerRegistration))
+        self.assertIsInstance(subscribers[0], HandlerRegistration)
         self.assertEqual(subscribers[0].required, (ifoo,))
         self.assertEqual(subscribers[0].name, '')
         self.assertEqual(subscribers[0].factory, _factory1)
         self.assertEqual(subscribers[0].info, '')
-        self.assertTrue(isinstance(subscribers[1], HandlerRegistration))
+        self.assertIsInstance(subscribers[1], HandlerRegistration)
         self.assertEqual(subscribers[1].required, (ifoo,))
         self.assertEqual(subscribers[1].name, '')
         self.assertEqual(subscribers[1].factory, _factory2)
@@ -2446,12 +2458,12 @@ class ComponentsTests(unittest.TestCase):
         args, kw = _events[0]
         event, = args
         self.assertEqual(kw, {})
-        self.assertTrue(isinstance(event, Unregistered))
-        self.assertTrue(isinstance(event.object, HandlerRegistration))
-        self.assertTrue(event.object.registry is comp)
+        self.assertIsInstance(event, Unregistered)
+        self.assertIsInstance(event.object, HandlerRegistration)
+        self.assertIs(event.object.registry, comp)
         self.assertEqual(event.object.required, (ifoo,))
         self.assertEqual(event.object.name, '')
-        self.assertTrue(event.object.factory is _factory)
+        self.assertIs(event.object.factory, _factory)
 
     def test_unregisterHandler_hit_w_only_explicit_provided(self):
         from zope.interface.declarations import InterfaceClass
@@ -2477,12 +2489,12 @@ class ComponentsTests(unittest.TestCase):
         args, kw = _events[0]
         event, = args
         self.assertEqual(kw, {})
-        self.assertTrue(isinstance(event, Unregistered))
-        self.assertTrue(isinstance(event.object, HandlerRegistration))
-        self.assertTrue(event.object.registry is comp)
+        self.assertIsInstance(event, Unregistered)
+        self.assertIsInstance(event.object, HandlerRegistration)
+        self.assertIs(event.object.registry, comp)
         self.assertEqual(event.object.required, (ifoo,))
         self.assertEqual(event.object.name, '')
-        self.assertTrue(event.object.factory is None)
+        self.assertIsNone(event.object.factory)
 
     def test_unregisterHandler_wo_explicit_required(self):
         from zope.interface.declarations import InterfaceClass
@@ -2507,13 +2519,13 @@ class ComponentsTests(unittest.TestCase):
         args, kw = _events[0]
         event, = args
         self.assertEqual(kw, {})
-        self.assertTrue(isinstance(event, Unregistered))
-        self.assertTrue(isinstance(event.object, HandlerRegistration))
-        self.assertTrue(event.object.registry is comp)
+        self.assertIsInstance(event, Unregistered)
+        self.assertIsInstance(event.object, HandlerRegistration)
+        self.assertIs(event.object.registry, comp)
         self.assertEqual(event.object.required, (ifoo,))
         self.assertEqual(event.object.name, '')
         self.assertEqual(event.object.info, '')
-        self.assertTrue(event.object.factory is _Factory)
+        self.assertIs(event.object.factory, _Factory)
 
     def test_handle_empty(self):
         from zope.interface.declarations import InterfaceClass
@@ -2802,38 +2814,38 @@ class UtilityRegistrationTests(unittest.TestCase):
     def test___eq___identity(self):
         _component = object()
         ur, _registry, _name = self._makeOne(_component)
-        self.assertTrue(ur == ur)
+        self.assertEqual(ur, ur)
 
     def test___eq___hit(self):
         _component = object()
         ur, _registry, _name = self._makeOne(_component)
         ur2, _, _ = self._makeOne(_component)
-        self.assertTrue(ur == ur2)
+        self.assertEqual(ur, ur2)
 
     def test___eq___miss(self):
         _component = object()
         _component2 = object()
         ur, _registry, _name = self._makeOne(_component)
         ur2, _, _ = self._makeOne(_component2)
-        self.assertFalse(ur == ur2)
+        self.assertNotEqual(ur, ur2)
 
     def test___ne___identity(self):
         _component = object()
         ur, _registry, _name = self._makeOne(_component)
-        self.assertFalse(ur != ur)
+        self.assertEqual(ur, ur)
 
     def test___ne___hit(self):
         _component = object()
         ur, _registry, _name = self._makeOne(_component)
         ur2, _, _ = self._makeOne(_component)
-        self.assertFalse(ur != ur2)
+        self.assertEqual(ur, ur2)
 
     def test___ne___miss(self):
         _component = object()
         _component2 = object()
         ur, _registry, _name = self._makeOne(_component)
         ur2, _, _ = self._makeOne(_component2)
-        self.assertTrue(ur != ur2)
+        self.assertNotEqual(ur, ur2)
 
     def test___lt___identity(self):
         _component = object()
@@ -2852,18 +2864,18 @@ class UtilityRegistrationTests(unittest.TestCase):
         ur, _registry, _name = self._makeOne(_component)
         ur2, _, _ = self._makeOne(_component2)
         ur2.name = _name + '2'
-        self.assertTrue(ur < ur2)
+        self.assertLess(ur, ur2)
 
     def test___le___identity(self):
         _component = object()
         ur, _registry, _name = self._makeOne(_component)
-        self.assertTrue(ur <= ur)
+        self.assertLessEqual(ur, ur)
 
     def test___le___hit(self):
         _component = object()
         ur, _registry, _name = self._makeOne(_component)
         ur2, _, _ = self._makeOne(_component)
-        self.assertTrue(ur <= ur2)
+        self.assertLessEqual(ur, ur2)
 
     def test___le___miss(self):
         _component = object()
@@ -2871,7 +2883,7 @@ class UtilityRegistrationTests(unittest.TestCase):
         ur, _registry, _name = self._makeOne(_component)
         ur2, _, _ = self._makeOne(_component2)
         ur2.name = _name + '2'
-        self.assertTrue(ur <= ur2)
+        self.assertLessEqual(ur, ur2)
 
     def test___gt___identity(self):
         _component = object()
@@ -2884,7 +2896,7 @@ class UtilityRegistrationTests(unittest.TestCase):
         ur, _registry, _name = self._makeOne(_component)
         ur2, _, _ = self._makeOne(_component2)
         ur2.name = _name + '2'
-        self.assertTrue(ur2 > ur)
+        self.assertGreater(ur2, ur)
 
     def test___gt___miss(self):
         _component = object()
@@ -2895,7 +2907,7 @@ class UtilityRegistrationTests(unittest.TestCase):
     def test___ge___identity(self):
         _component = object()
         ur, _registry, _name = self._makeOne(_component)
-        self.assertTrue(ur >= ur)
+        self.assertGreaterEqual(ur, ur)
 
     def test___ge___miss(self):
         _component = object()
@@ -2910,7 +2922,7 @@ class UtilityRegistrationTests(unittest.TestCase):
         ur, _registry, _name = self._makeOne(_component)
         ur2, _, _ = self._makeOne(_component)
         ur2.name = _name + '2'
-        self.assertTrue(ur2 >= ur)
+        self.assertGreaterEqual(ur2, ur)
 
 
 class AdapterRegistrationTests(unittest.TestCase):
@@ -3007,38 +3019,38 @@ class AdapterRegistrationTests(unittest.TestCase):
     def test___eq___identity(self):
         _component = object()
         ar, _registry, _name = self._makeOne(_component)
-        self.assertTrue(ar == ar)
+        self.assertEqual(ar, ar)
 
     def test___eq___hit(self):
         _component = object()
         ar, _registry, _name = self._makeOne(_component)
         ar2, _, _ = self._makeOne(_component)
-        self.assertTrue(ar == ar2)
+        self.assertEqual(ar, ar2)
 
     def test___eq___miss(self):
         _component = object()
         _component2 = object()
         ar, _registry, _name = self._makeOne(_component)
         ar2, _, _ = self._makeOne(_component2)
-        self.assertFalse(ar == ar2)
+        self.assertNotEqual(ar, ar2)
 
     def test___ne___identity(self):
         _component = object()
         ar, _registry, _name = self._makeOne(_component)
-        self.assertFalse(ar != ar)
+        self.assertEqual(ar, ar)
 
     def test___ne___miss(self):
         _component = object()
         ar, _registry, _name = self._makeOne(_component)
         ar2, _, _ = self._makeOne(_component)
-        self.assertFalse(ar != ar2)
+        self.assertEqual(ar, ar2)
 
     def test___ne___hit_component(self):
         _component = object()
         _component2 = object()
         ar, _registry, _name = self._makeOne(_component)
         ar2, _, _ = self._makeOne(_component2)
-        self.assertTrue(ar != ar2)
+        self.assertNotEqual(ar, ar2)
 
     def test___ne___hit_provided(self):
         from zope.interface.declarations import InterfaceClass
@@ -3051,7 +3063,7 @@ class AdapterRegistrationTests(unittest.TestCase):
         ar, _registry, _name = self._makeOne(_component)
         ar2, _, _ = self._makeOne(_component)
         ar2.provided = ibaz
-        self.assertTrue(ar != ar2)
+        self.assertNotEqual(ar, ar2)
 
     def test___ne___hit_required(self):
         from zope.interface.declarations import InterfaceClass
@@ -3065,7 +3077,7 @@ class AdapterRegistrationTests(unittest.TestCase):
         ar, _registry, _name = self._makeOne(_component)
         ar2, _, _ = self._makeOne(_component2)
         ar2.required = (ibaz,)
-        self.assertTrue(ar != ar2)
+        self.assertNotEqual(ar, ar2)
 
     def test___lt___identity(self):
         _component = object()
@@ -3084,18 +3096,18 @@ class AdapterRegistrationTests(unittest.TestCase):
         ar, _registry, _name = self._makeOne(_component)
         ar2, _, _ = self._makeOne(_component2)
         ar2.name = _name + '2'
-        self.assertTrue(ar < ar2)
+        self.assertLess(ar, ar2)
 
     def test___le___identity(self):
         _component = object()
         ar, _registry, _name = self._makeOne(_component)
-        self.assertTrue(ar <= ar)
+        self.assertLessEqual(ar, ar)
 
     def test___le___hit(self):
         _component = object()
         ar, _registry, _name = self._makeOne(_component)
         ar2, _, _ = self._makeOne(_component)
-        self.assertTrue(ar <= ar2)
+        self.assertLessEqual(ar, ar2)
 
     def test___le___miss(self):
         _component = object()
@@ -3103,7 +3115,7 @@ class AdapterRegistrationTests(unittest.TestCase):
         ar, _registry, _name = self._makeOne(_component)
         ar2, _, _ = self._makeOne(_component2)
         ar2.name = _name + '2'
-        self.assertTrue(ar <= ar2)
+        self.assertLessEqual(ar, ar2)
 
     def test___gt___identity(self):
         _component = object()
@@ -3116,7 +3128,7 @@ class AdapterRegistrationTests(unittest.TestCase):
         ar, _registry, _name = self._makeOne(_component)
         ar2, _, _ = self._makeOne(_component2)
         ar2.name = _name + '2'
-        self.assertTrue(ar2 > ar)
+        self.assertGreater(ar2, ar)
 
     def test___gt___miss(self):
         _component = object()
@@ -3127,7 +3139,7 @@ class AdapterRegistrationTests(unittest.TestCase):
     def test___ge___identity(self):
         _component = object()
         ar, _registry, _name = self._makeOne(_component)
-        self.assertTrue(ar >= ar)
+        self.assertGreaterEqual(ar, ar)
 
     def test___ge___miss(self):
         _component = object()
@@ -3142,7 +3154,7 @@ class AdapterRegistrationTests(unittest.TestCase):
         ar, _registry, _name = self._makeOne(_component)
         ar2, _, _ = self._makeOne(_component)
         ar2.name = _name + '2'
-        self.assertTrue(ar2 >= ar)
+        self.assertGreaterEqual(ar2, ar)
 
 
 class SubscriptionRegistrationTests(unittest.TestCase):
@@ -3229,9 +3241,9 @@ class HandlerRegistrationTests(unittest.TestCase):
         def _factory(context):
             raise NotImplementedError()
         hr, _, _ = self._makeOne(_factory)
-        self.assertTrue(hr.handler is _factory)
-        self.assertTrue(hr.factory is hr.handler)
-        self.assertTrue(hr.provided is None)
+        self.assertIs(hr.handler, _factory)
+        self.assertIs(hr.factory, hr.handler)
+        self.assertIsNone(hr.provided)
 
     def test___repr___factory_w_name(self):