Changed importlib tests to use assertIs, assertIsInstance, etc., instead of just assertTrue.

Lib/importlib/test/builtin/test_finder.py

@@ -35,14 +35,14 @@ def test_package_over_module(self):
     def test_failure(self):
         assert 'importlib' not in sys.builtin_module_names
         loader = machinery.BuiltinImporter.find_module('importlib')
-        self.assertTrue(loader is None)
+        self.assertIs(loader, None)
 
     def test_ignore_path(self):
         # The value for 'path' should always trigger a failed import.
         with util.uncache(builtin_util.NAME):
             loader = machinery.BuiltinImporter.find_module(builtin_util.NAME,
                                                             ['pkg'])
-            self.assertTrue(loader is None)
+            self.assertIs(loader, None)
 
 
 

Lib/importlib/test/builtin/test_loader.py

@@ -18,10 +18,10 @@ class LoaderTests(abc.LoaderTests):
 
     def verify(self, module):
         """Verify that the module matches against what it should have."""
-        self.assertTrue(isinstance(module, types.ModuleType))
+        self.assertIsInstance(module, types.ModuleType)
         for attr, value in self.verification.items():
             self.assertEqual(getattr(module, attr), value)
-        self.assertTrue(module.__name__ in sys.modules)
+        self.assertIn(module.__name__, sys.modules)
 
     load_module = staticmethod(lambda name:
                                 machinery.BuiltinImporter.load_module(name))
@@ -49,7 +49,7 @@ def test_module_reuse(self):
         with util.uncache(builtin_util.NAME):
             module1 = self.load_module(builtin_util.NAME)
             module2 = self.load_module(builtin_util.NAME)
-            self.assertTrue(module1 is module2)
+            self.assertIs(module1, module2)
 
     def test_unloadable(self):
         name = 'dssdsdfff'
@@ -74,12 +74,12 @@ class InspectLoaderTests(unittest.TestCase):
     def test_get_code(self):
         # There is no code object.
         result = machinery.BuiltinImporter.get_code(builtin_util.NAME)
-        self.assertTrue(result is None)
+        self.assertIs(result, None)
 
     def test_get_source(self):
         # There is no source.
         result = machinery.BuiltinImporter.get_source(builtin_util.NAME)
-        self.assertTrue(result is None)
+        self.assertIs(result, None)
 
     def test_is_package(self):
         # Cannot be a package.

Lib/importlib/test/extension/test_finder.py

@@ -36,7 +36,7 @@ def test_package_over_module(self):
         pass
 
     def test_failure(self):
-        self.assertTrue(self.find_module('asdfjkl;') is None)
+        self.assertIs(self.find_module('asdfjkl;'), None)
 
     # XXX Raise an exception if someone tries to use the 'path' argument?
 

Lib/importlib/test/extension/test_loader.py

@@ -33,9 +33,9 @@ def test_module(self):
                                 ('__file__', ext_util.FILEPATH),
                                 ('__package__', '')]:
                 self.assertEqual(getattr(module, attr), value)
-            self.assertTrue(ext_util.NAME in sys.modules)
+            self.assertIn(ext_util.NAME, sys.modules)
-            self.assertTrue(isinstance(module.__loader__,
+            self.assertIsInstance(module.__loader__,
-                                    machinery.ExtensionFileLoader))
+                                  machinery.ExtensionFileLoader)
 
     def test_package(self):
         # Extensions are not found in packages.
@@ -49,7 +49,7 @@ def test_module_reuse(self):
         with util.uncache(ext_util.NAME):
             module1 = self.load_module(ext_util.NAME)
             module2 = self.load_module(ext_util.NAME)
-            self.assertTrue(module1 is module2)
+            self.assertIs(module1, module2)
 
     def test_state_after_failure(self):
         # No easy way to trigger a failure after a successful import.

Lib/importlib/test/frozen/test_finder.py

@@ -35,7 +35,7 @@ def test_package_over_module(self):
 
     def test_failure(self):
         loader = self.find('<not real>')
-        self.assertTrue(loader is None)
+        self.assertIs(loader, None)
 
 
 def test_main():

Lib/importlib/test/frozen/test_loader.py

@@ -55,7 +55,7 @@ def test_module_reuse(self):
         with util.uncache('__hello__'), captured_stdout() as stdout:
             module1 = machinery.FrozenImporter.load_module('__hello__')
             module2 = machinery.FrozenImporter.load_module('__hello__')
-            self.assertTrue(module1 is module2)
+            self.assertIs(module1, module2)
             self.assertEqual(stdout.getvalue(),
                              'Hello world!\nHello world!\n')
 
@@ -93,7 +93,7 @@ def test_get_code(self):
     def test_get_source(self):
         # Should always return None.
         result = machinery.FrozenImporter.get_source('__hello__')
-        self.assertTrue(result is None)
+        self.assertIs(result, None)
 
     def test_is_package(self):
         # Should be able to tell what is a package.
@@ -101,7 +101,7 @@ def test_is_package(self):
                     ('__phello__.spam', False))
         for name, is_package in test_for:
             result = machinery.FrozenImporter.is_package(name)
-            self.assertTrue(bool(result) == is_package)
+            self.assertEqual(bool(result), is_package)
 
     def test_failure(self):
         # Raise ImportError for modules that are not frozen.

Lib/importlib/test/import_/test_caching.py

@@ -65,7 +65,8 @@ def test_using_cache_for_assigning_to_attribute(self):
             with util.import_state(meta_path=[importer]):
                 module = import_util.import_('pkg.module')
                 self.assertTrue(hasattr(module, 'module'))
-                self.assertTrue(id(module.module), id(sys.modules['pkg.module']))
+                self.assertEqual(id(module.module),
+                                 id(sys.modules['pkg.module']))
 
     # See test_using_cache_after_loader() for reasoning.
     @import_util.importlib_only

Lib/importlib/test/import_/test_meta_path.py

@@ -82,7 +82,7 @@ def test_no_path(self):
                 self.assertEqual(len(args), 2)
                 self.assertEqual(len(kwargs), 0)
                 self.assertEqual(args[0], mod_name)
-                self.assertTrue(args[1] is None)
+                self.assertIs(args[1], None)
 
     def test_with_path(self):
         # [path set]
@@ -102,7 +102,7 @@ def test_with_path(self):
                 # Assuming all arguments are positional.
                 self.assertTrue(not kwargs)
                 self.assertEqual(args[0], mod_name)
-                self.assertTrue(args[1] is path)
+                self.assertIs(args[1], path)
 
 
 

Lib/importlib/test/import_/test_packages.py

@@ -14,7 +14,7 @@ def test_import_parent(self):
         with util.mock_modules('pkg.__init__', 'pkg.module') as mock:
             with util.import_state(meta_path=[mock]):
                 module = import_util.import_('pkg.module')
-                self.assertTrue('pkg' in sys.modules)
+                self.assertIn('pkg', sys.modules)
 
     def test_bad_parent(self):
         with util.mock_modules('pkg.module') as mock:
@@ -33,12 +33,12 @@ def __init__():
             with util.import_state(meta_path=[mock]):
                 with self.assertRaises(ZeroDivisionError):
                     import_util.import_('pkg')
-                self.assertFalse('pkg' in sys.modules)
+                self.assertNotIn('pkg', sys.modules)
-                self.assertTrue('pkg.module' in sys.modules)
+                self.assertIn('pkg.module', sys.modules)
                 with self.assertRaises(ZeroDivisionError):
                     import_util.import_('pkg.module')
-                self.assertFalse('pkg' in sys.modules)
+                self.assertNotIn('pkg', sys.modules)
-                self.assertTrue('pkg.module' in sys.modules)
+                self.assertIn('pkg.module', sys.modules)
 
     def test_raising_parent_after_relative_importing_child(self):
         def __init__():
@@ -52,12 +52,12 @@ def __init__():
                     # This raises ImportError on the "from . import module"
                     # line, not sure why.
                     import_util.import_('pkg')
-                self.assertFalse('pkg' in sys.modules)
+                self.assertNotIn('pkg', sys.modules)
                 with self.assertRaises((ZeroDivisionError, ImportError)):
                     import_util.import_('pkg.module')
-                self.assertFalse('pkg' in sys.modules)
+                self.assertNotIn('pkg', sys.modules)
                 # XXX False
-                #self.assertTrue('pkg.module' in sys.modules)
+                #self.assertIn('pkg.module', sys.modules)
 
     def test_raising_parent_after_double_relative_importing_child(self):
         def __init__():
@@ -72,12 +72,12 @@ def __init__():
                     # This raises ImportError on the "from ..subpkg import module"
                     # line, not sure why.
                     import_util.import_('pkg.subpkg')
-                self.assertFalse('pkg.subpkg' in sys.modules)
+                self.assertNotIn('pkg.subpkg', sys.modules)
                 with self.assertRaises((ZeroDivisionError, ImportError)):
                     import_util.import_('pkg.subpkg.module')
-                self.assertFalse('pkg.subpkg' in sys.modules)
+                self.assertNotIn('pkg.subpkg', sys.modules)
                 # XXX False
-                #self.assertTrue('pkg.subpkg.module' in sys.modules)
+                #self.assertIn('pkg.subpkg.module', sys.modules)
 
     def test_module_not_package(self):
         # Try to import a submodule from a non-package should raise ImportError.

Lib/importlib/test/import_/test_path.py

@@ -20,7 +20,7 @@ def test_failure(self):
         # Test None returned upon not finding a suitable finder.
         module = '<test module>'
         with util.import_state():
-            self.assertTrue(machinery.PathFinder.find_module(module) is None)
+            self.assertIs(machinery.PathFinder.find_module(module), None)
 
     def test_sys_path(self):
         # Test that sys.path is used when 'path' is None.
@@ -31,7 +31,7 @@ def test_sys_path(self):
         with util.import_state(path_importer_cache={path: importer},
                                path=[path]):
             loader = machinery.PathFinder.find_module(module)
-            self.assertTrue(loader is importer)
+            self.assertIs(loader, importer)
 
     def test_path(self):
         # Test that 'path' is used when set.
@@ -41,7 +41,7 @@ def test_path(self):
         importer = util.mock_modules(module)
         with util.import_state(path_importer_cache={path: importer}):
             loader = machinery.PathFinder.find_module(module, [path])
-            self.assertTrue(loader is importer)
+            self.assertIs(loader, importer)
 
     def test_empty_list(self):
         # An empty list should not count as asking for sys.path.
@@ -61,9 +61,9 @@ def test_path_hooks(self):
         hook = import_util.mock_path_hook(path, importer=importer)
         with util.import_state(path_hooks=[hook]):
             loader = machinery.PathFinder.find_module(module, [path])
-            self.assertTrue(loader is importer)
+            self.assertIs(loader, importer)
-            self.assertTrue(path in sys.path_importer_cache)
+            self.assertIn(path, sys.path_importer_cache)
-            self.assertTrue(sys.path_importer_cache[path] is importer)
+            self.assertIs(sys.path_importer_cache[path], importer)
 
     def test_empty_path_hooks(self):
         # Test that if sys.path_hooks is empty a warning is raised,

Lib/importlib/test/source/test_abc_loader.py

@@ -221,7 +221,7 @@ def test_module(self):
         mock = self.mocker({name: path})
         with util.uncache(name):
             module = mock.load_module(name)
-            self.assertTrue(name in sys.modules)
+            self.assertIn(name, sys.modules)
         self.eq_attrs(module, __name__=name, __file__=path, __package__='',
                         __loader__=mock)
         self.assertTrue(not hasattr(module, '__path__'))
@@ -233,7 +233,7 @@ def test_package(self):
         mock = self.mocker({name: path})
         with util.uncache(name):
             module = mock.load_module(name)
-            self.assertTrue(name in sys.modules)
+            self.assertIn(name, sys.modules)
         self.eq_attrs(module, __name__=name, __file__=path,
                 __path__=[os.path.dirname(path)], __package__=name,
                 __loader__=mock)
@@ -259,8 +259,8 @@ def test_module_reuse(self):
         with util.uncache(name):
             sys.modules[name] = module
             loaded_module = mock.load_module(name)
-            self.assertTrue(loaded_module is module)
+            self.assertIs(loaded_module, module)
-            self.assertTrue(sys.modules[name] is module)
+            self.assertIs(sys.modules[name], module)
         return mock, name
 
     def test_state_after_failure(self):
@@ -273,7 +273,7 @@ def test_state_after_failure(self):
             sys.modules[name] = module
             with self.assertRaises(ZeroDivisionError):
                 mock.load_module(name)
-            self.assertTrue(sys.modules[name] is module)
+            self.assertIs(sys.modules[name], module)
             self.assertTrue(hasattr(module, 'blah'))
         return mock
 
@@ -284,7 +284,7 @@ def test_unloadable(self):
         with util.uncache(name):
             with self.assertRaises(ZeroDivisionError):
                 mock.load_module(name)
-            self.assertTrue(name not in sys.modules)
+            self.assertNotIn(name, sys.modules)
         return mock
 
 
@@ -414,8 +414,7 @@ def run_test(self, dont_write_bytecode):
         sys.dont_write_bytecode = dont_write_bytecode
         with util.uncache(name):
             mock.load_module(name)
-        self.assertTrue((name in mock.module_bytecode) is not
+        self.assertIsNot(name in mock.module_bytecode, dont_write_bytecode)
-                        dont_write_bytecode)
 
     def test_no_bytecode_written(self):
         self.run_test(True)
@@ -440,7 +439,7 @@ def test_different_magic(self):
                                         'magic': bad_magic}})
         with util.uncache(name):
             mock.load_module(name)
-        self.assertTrue(name in mock.module_bytecode)
+        self.assertIn(name, mock.module_bytecode)
         magic = mock.module_bytecode[name][:4]
         self.assertEqual(magic, imp.get_magic())
 
@@ -453,7 +452,7 @@ def test_old_mtime(self):
                 {name: {'path': 'path/to/mod.bytecode', 'mtime': old_mtime}})
         with util.uncache(name):
             mock.load_module(name)
-        self.assertTrue(name in mock.module_bytecode)
+        self.assertIn(name, mock.module_bytecode)
         mtime = importlib._r_long(mock.module_bytecode[name][4:8])
         self.assertEqual(mtime, PyPycLoaderMock.default_mtime)
 
@@ -621,7 +620,7 @@ def test_load_module(self):
             module = self.loader.load_module(self.name)
             self.verify_module(module)
             self.assertEqual(module.__path__, [os.path.dirname(self.path)])
-            self.assertTrue(self.name in sys.modules)
+            self.assertIn(self.name, sys.modules)
 
     def test_package_settings(self):
         # __package__ needs to be set, while __path__ is set on if the module

Lib/importlib/test/source/test_file_loader.py

@@ -64,7 +64,7 @@ def test_module(self):
         with source_util.create_modules('_temp') as mapping:
             loader = _bootstrap.SourceFileLoader('_temp', mapping['_temp'])
             module = loader.load_module('_temp')
-            self.assertTrue('_temp' in sys.modules)
+            self.assertIn('_temp', sys.modules)
             check = {'__name__': '_temp', '__file__': mapping['_temp'],
                      '__package__': ''}
             for attr, value in check.items():
@@ -75,7 +75,7 @@ def test_package(self):
             loader = _bootstrap.SourceFileLoader('_pkg',
                                                  mapping['_pkg.__init__'])
             module = loader.load_module('_pkg')
-            self.assertTrue('_pkg' in sys.modules)
+            self.assertIn('_pkg', sys.modules)
             check = {'__name__': '_pkg', '__file__': mapping['_pkg.__init__'],
                      '__path__': [os.path.dirname(mapping['_pkg.__init__'])],
                      '__package__': '_pkg'}
@@ -88,7 +88,7 @@ def test_lacking_parent(self):
             loader = _bootstrap.SourceFileLoader('_pkg.mod',
                                                     mapping['_pkg.mod'])
             module = loader.load_module('_pkg.mod')
-            self.assertTrue('_pkg.mod' in sys.modules)
+            self.assertIn('_pkg.mod', sys.modules)
             check = {'__name__': '_pkg.mod', '__file__': mapping['_pkg.mod'],
                      '__package__': '_pkg'}
             for attr, value in check.items():
@@ -107,7 +107,7 @@ def test_module_reuse(self):
             with open(mapping['_temp'], 'w') as file:
                 file.write("testing_var = 42\n")
             module = loader.load_module('_temp')
-            self.assertTrue('testing_var' in module.__dict__,
+            self.assertIn('testing_var', module.__dict__,
                          "'testing_var' not in "
                             "{0}".format(list(module.__dict__.keys())))
             self.assertEqual(module, sys.modules['_temp'])
@@ -139,7 +139,7 @@ def test_bad_syntax(self):
             loader = _bootstrap.SourceFileLoader('_temp', mapping['_temp'])
             with self.assertRaises(SyntaxError):
                 loader.load_module('_temp')
-            self.assertTrue('_temp' not in sys.modules)
+            self.assertNotIn('_temp', sys.modules)
 
     def test_file_from_empty_string_dir(self):
         # Loading a module found from an empty string entry on sys.path should
@@ -189,7 +189,7 @@ class BadBytecodeTest(unittest.TestCase):
     def import_(self, file, module_name):
         loader = self.loader(module_name, file)
         module = loader.load_module(module_name)
-        self.assertTrue(module_name in sys.modules)
+        self.assertIn(module_name, sys.modules)
 
     def manipulate_bytecode(self, name, mapping, manipulator, *,
                             del_source=False):

Lib/importlib/test/source/test_finder.py

@@ -115,7 +115,7 @@ def test_package_over_module(self):
     def test_failure(self):
         with source_util.create_modules('blah') as mapping:
             nothing = self.import_(mapping['.root'], 'sdfsadsadf')
-            self.assertTrue(nothing is None)
+            self.assertIs(nothing, None)
 
     def test_empty_string_for_dir(self):
         # The empty string from sys.path means to search in the cwd.

Lib/importlib/test/test_util.py

@@ -29,8 +29,8 @@ def test_new_module(self):
         module_name = 'a.b.c'
         with test_util.uncache(module_name):
             module = self.return_module(module_name)
-            self.assertTrue(module_name in sys.modules)
+            self.assertIn(module_name, sys.modules)
-        self.assertTrue(isinstance(module, types.ModuleType))
+        self.assertIsInstance(module, types.ModuleType)
         self.assertEqual(module.__name__, module_name)
 
     def test_reload(self):
@@ -48,7 +48,7 @@ def test_new_module_failure(self):
         name = 'a.b.c'
         with test_util.uncache(name):
             self.raise_exception(name)
-            self.assertTrue(name not in sys.modules)
+            self.assertNotIn(name, sys.modules)
 
     def test_reload_failure(self):
         # Test that a failure on reload leaves the module in-place.
@@ -77,7 +77,7 @@ def __bool__(self): return False
             self.assertFalse(module)
             sys.modules[name] = module
             given = self.return_module(name)
-            self.assertTrue(given is module)
+            self.assertIs(given, module)
 
     def test_attributes_set(self):
         # __name__, __loader__, and __package__ should be set (when