python-3.6.zip added from Github

README.cosmo contains the necessary links.

third_party/python/Lib/test/test_imp.py

@@ -0,0 +1,416 @@
+try:
+    import _thread
+except ImportError:
+    _thread = None
+import importlib
+import importlib.util
+import os
+import os.path
+import sys
+from test import support
+import unittest
+import warnings
+with warnings.catch_warnings():
+    warnings.simplefilter('ignore', DeprecationWarning)
+    import imp
+
+
+def requires_load_dynamic(meth):
+    """Decorator to skip a test if not running under CPython or lacking
+    imp.load_dynamic()."""
+    meth = support.cpython_only(meth)
+    return unittest.skipIf(not hasattr(imp, 'load_dynamic'),
+                           'imp.load_dynamic() required')(meth)
+
+
+@unittest.skipIf(_thread is None, '_thread module is required')
+class LockTests(unittest.TestCase):
+
+    """Very basic test of import lock functions."""
+
+    def verify_lock_state(self, expected):
+        self.assertEqual(imp.lock_held(), expected,
+                             "expected imp.lock_held() to be %r" % expected)
+    def testLock(self):
+        LOOPS = 50
+
+        # The import lock may already be held, e.g. if the test suite is run
+        # via "import test.autotest".
+        lock_held_at_start = imp.lock_held()
+        self.verify_lock_state(lock_held_at_start)
+
+        for i in range(LOOPS):
+            imp.acquire_lock()
+            self.verify_lock_state(True)
+
+        for i in range(LOOPS):
+            imp.release_lock()
+
+        # The original state should be restored now.
+        self.verify_lock_state(lock_held_at_start)
+
+        if not lock_held_at_start:
+            try:
+                imp.release_lock()
+            except RuntimeError:
+                pass
+            else:
+                self.fail("release_lock() without lock should raise "
+                            "RuntimeError")
+
+class ImportTests(unittest.TestCase):
+    def setUp(self):
+        mod = importlib.import_module('test.encoded_modules')
+        self.test_strings = mod.test_strings
+        self.test_path = mod.__path__
+
+    def test_import_encoded_module(self):
+        for modname, encoding, teststr in self.test_strings:
+            mod = importlib.import_module('test.encoded_modules.'
+                                          'module_' + modname)
+            self.assertEqual(teststr, mod.test)
+
+    def test_find_module_encoding(self):
+        for mod, encoding, _ in self.test_strings:
+            with imp.find_module('module_' + mod, self.test_path)[0] as fd:
+                self.assertEqual(fd.encoding, encoding)
+
+        path = [os.path.dirname(__file__)]
+        with self.assertRaises(SyntaxError):
+            imp.find_module('badsyntax_pep3120', path)
+
+    def test_issue1267(self):
+        for mod, encoding, _ in self.test_strings:
+            fp, filename, info  = imp.find_module('module_' + mod,
+                                                  self.test_path)
+            with fp:
+                self.assertNotEqual(fp, None)
+                self.assertEqual(fp.encoding, encoding)
+                self.assertEqual(fp.tell(), 0)
+                self.assertEqual(fp.readline(), '# test %s encoding\n'
+                                 % encoding)
+
+        fp, filename, info = imp.find_module("tokenize")
+        with fp:
+            self.assertNotEqual(fp, None)
+            self.assertEqual(fp.encoding, "utf-8")
+            self.assertEqual(fp.tell(), 0)
+            self.assertEqual(fp.readline(),
+                             '"""Tokenization help for Python programs.\n')
+
+    def test_issue3594(self):
+        temp_mod_name = 'test_imp_helper'
+        sys.path.insert(0, '.')
+        try:
+            with open(temp_mod_name + '.py', 'w') as file:
+                file.write("# coding: cp1252\nu = 'test.test_imp'\n")
+            file, filename, info = imp.find_module(temp_mod_name)
+            file.close()
+            self.assertEqual(file.encoding, 'cp1252')
+        finally:
+            del sys.path[0]
+            support.unlink(temp_mod_name + '.py')
+            support.unlink(temp_mod_name + '.pyc')
+
+    def test_issue5604(self):
+        # Test cannot cover imp.load_compiled function.
+        # Martin von Loewis note what shared library cannot have non-ascii
+        # character because init_xxx function cannot be compiled
+        # and issue never happens for dynamic modules.
+        # But sources modified to follow generic way for processing pathes.
+
+        # the return encoding could be uppercase or None
+        fs_encoding = sys.getfilesystemencoding()
+
+        # covers utf-8 and Windows ANSI code pages
+        # one non-space symbol from every page
+        # (http://en.wikipedia.org/wiki/Code_page)
+        known_locales = {
+            'utf-8' : b'\xc3\xa4',
+            'cp1250' : b'\x8C',
+            'cp1251' : b'\xc0',
+            'cp1252' : b'\xc0',
+            'cp1253' : b'\xc1',
+            'cp1254' : b'\xc0',
+            'cp1255' : b'\xe0',
+            'cp1256' : b'\xe0',
+            'cp1257' : b'\xc0',
+            'cp1258' : b'\xc0',
+            }
+
+        if sys.platform == 'darwin':
+            self.assertEqual(fs_encoding, 'utf-8')
+            # Mac OS X uses the Normal Form D decomposition
+            # http://developer.apple.com/mac/library/qa/qa2001/qa1173.html
+            special_char = b'a\xcc\x88'
+        else:
+            special_char = known_locales.get(fs_encoding)
+
+        if not special_char:
+            self.skipTest("can't run this test with %s as filesystem encoding"
+                          % fs_encoding)
+        decoded_char = special_char.decode(fs_encoding)
+        temp_mod_name = 'test_imp_helper_' + decoded_char
+        test_package_name = 'test_imp_helper_package_' + decoded_char
+        init_file_name = os.path.join(test_package_name, '__init__.py')
+        try:
+            # if the curdir is not in sys.path the test fails when run with
+            # ./python ./Lib/test/regrtest.py test_imp
+            sys.path.insert(0, os.curdir)
+            with open(temp_mod_name + '.py', 'w') as file:
+                file.write('a = 1\n')
+            file, filename, info = imp.find_module(temp_mod_name)
+            with file:
+                self.assertIsNotNone(file)
+                self.assertTrue(filename[:-3].endswith(temp_mod_name))
+                self.assertEqual(info[0], '.py')
+                self.assertEqual(info[1], 'r')
+                self.assertEqual(info[2], imp.PY_SOURCE)
+
+                mod = imp.load_module(temp_mod_name, file, filename, info)
+                self.assertEqual(mod.a, 1)
+
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore')
+                mod = imp.load_source(temp_mod_name, temp_mod_name + '.py')
+            self.assertEqual(mod.a, 1)
+
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore')
+                if not sys.dont_write_bytecode:
+                    mod = imp.load_compiled(
+                        temp_mod_name,
+                        imp.cache_from_source(temp_mod_name + '.py'))
+            self.assertEqual(mod.a, 1)
+
+            if not os.path.exists(test_package_name):
+                os.mkdir(test_package_name)
+            with open(init_file_name, 'w') as file:
+                file.write('b = 2\n')
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore')
+                package = imp.load_package(test_package_name, test_package_name)
+            self.assertEqual(package.b, 2)
+        finally:
+            del sys.path[0]
+            for ext in ('.py', '.pyc'):
+                support.unlink(temp_mod_name + ext)
+                support.unlink(init_file_name + ext)
+            support.rmtree(test_package_name)
+            support.rmtree('__pycache__')
+
+    def test_issue9319(self):
+        path = os.path.dirname(__file__)
+        self.assertRaises(SyntaxError,
+                          imp.find_module, "badsyntax_pep3120", [path])
+
+    def test_load_from_source(self):
+        # Verify that the imp module can correctly load and find .py files
+        # XXX (ncoghlan): It would be nice to use support.CleanImport
+        # here, but that breaks because the os module registers some
+        # handlers in copy_reg on import. Since CleanImport doesn't
+        # revert that registration, the module is left in a broken
+        # state after reversion. Reinitialising the module contents
+        # and just reverting os.environ to its previous state is an OK
+        # workaround
+        orig_path = os.path
+        orig_getenv = os.getenv
+        with support.EnvironmentVarGuard():
+            x = imp.find_module("os")
+            self.addCleanup(x[0].close)
+            new_os = imp.load_module("os", *x)
+            self.assertIs(os, new_os)
+            self.assertIs(orig_path, new_os.path)
+            self.assertIsNot(orig_getenv, new_os.getenv)
+
+    @requires_load_dynamic
+    def test_issue15828_load_extensions(self):
+        # Issue 15828 picked up that the adapter between the old imp API
+        # and importlib couldn't handle C extensions
+        example = "_heapq"
+        x = imp.find_module(example)
+        file_ = x[0]
+        if file_ is not None:
+            self.addCleanup(file_.close)
+        mod = imp.load_module(example, *x)
+        self.assertEqual(mod.__name__, example)
+
+    @requires_load_dynamic
+    def test_issue16421_multiple_modules_in_one_dll(self):
+        # Issue 16421: loading several modules from the same compiled file fails
+        m = '_testimportmultiple'
+        fileobj, pathname, description = imp.find_module(m)
+        fileobj.close()
+        mod0 = imp.load_dynamic(m, pathname)
+        mod1 = imp.load_dynamic('_testimportmultiple_foo', pathname)
+        mod2 = imp.load_dynamic('_testimportmultiple_bar', pathname)
+        self.assertEqual(mod0.__name__, m)
+        self.assertEqual(mod1.__name__, '_testimportmultiple_foo')
+        self.assertEqual(mod2.__name__, '_testimportmultiple_bar')
+        with self.assertRaises(ImportError):
+            imp.load_dynamic('nonexistent', pathname)
+
+    @requires_load_dynamic
+    def test_load_dynamic_ImportError_path(self):
+        # Issue #1559549 added `name` and `path` attributes to ImportError
+        # in order to provide better detail. Issue #10854 implemented those
+        # attributes on import failures of extensions on Windows.
+        path = 'bogus file path'
+        name = 'extension'
+        with self.assertRaises(ImportError) as err:
+            imp.load_dynamic(name, path)
+        self.assertIn(path, err.exception.path)
+        self.assertEqual(name, err.exception.name)
+
+    @requires_load_dynamic
+    def test_load_module_extension_file_is_None(self):
+        # When loading an extension module and the file is None, open one
+        # on the behalf of imp.load_dynamic().
+        # Issue #15902
+        name = '_testimportmultiple'
+        found = imp.find_module(name)
+        if found[0] is not None:
+            found[0].close()
+        if found[2][2] != imp.C_EXTENSION:
+            self.skipTest("found module doesn't appear to be a C extension")
+        imp.load_module(name, None, *found[1:])
+
+    @requires_load_dynamic
+    def test_issue24748_load_module_skips_sys_modules_check(self):
+        name = 'test.imp_dummy'
+        try:
+            del sys.modules[name]
+        except KeyError:
+            pass
+        try:
+            module = importlib.import_module(name)
+            spec = importlib.util.find_spec('_testmultiphase')
+            module = imp.load_dynamic(name, spec.origin)
+            self.assertEqual(module.__name__, name)
+            self.assertEqual(module.__spec__.name, name)
+            self.assertEqual(module.__spec__.origin, spec.origin)
+            self.assertRaises(AttributeError, getattr, module, 'dummy_name')
+            self.assertEqual(module.int_const, 1969)
+            self.assertIs(sys.modules[name], module)
+        finally:
+            try:
+                del sys.modules[name]
+            except KeyError:
+                pass
+
+    @unittest.skipIf(sys.dont_write_bytecode,
+        "test meaningful only when writing bytecode")
+    def test_bug7732(self):
+        with support.temp_cwd():
+            source = support.TESTFN + '.py'
+            os.mkdir(source)
+            self.assertRaisesRegex(ImportError, '^No module',
+                imp.find_module, support.TESTFN, ["."])
+
+    def test_multiple_calls_to_get_data(self):
+        # Issue #18755: make sure multiple calls to get_data() can succeed.
+        loader = imp._LoadSourceCompatibility('imp', imp.__file__,
+                                              open(imp.__file__))
+        loader.get_data(imp.__file__)  # File should be closed
+        loader.get_data(imp.__file__)  # Will need to create a newly opened file
+
+    def test_load_source(self):
+        # Create a temporary module since load_source(name) modifies
+        # sys.modules[name] attributes like __loader___
+        modname = f"tmp{__name__}"
+        mod = type(sys.modules[__name__])(modname)
+        with support.swap_item(sys.modules, modname, mod):
+            with self.assertRaisesRegex(ValueError, 'embedded null'):
+                imp.load_source(modname, __file__ + "\0")
+
+    @support.cpython_only
+    def test_issue31315(self):
+        # There shouldn't be an assertion failure in imp.create_dynamic(),
+        # when spec.name is not a string.
+        create_dynamic = support.get_attribute(imp, 'create_dynamic')
+        class BadSpec:
+            name = None
+            origin = 'foo'
+        with self.assertRaises(TypeError):
+            create_dynamic(BadSpec())
+
+
+class ReloadTests(unittest.TestCase):
+
+    """Very basic tests to make sure that imp.reload() operates just like
+    reload()."""
+
+    def test_source(self):
+        # XXX (ncoghlan): It would be nice to use test.support.CleanImport
+        # here, but that breaks because the os module registers some
+        # handlers in copy_reg on import. Since CleanImport doesn't
+        # revert that registration, the module is left in a broken
+        # state after reversion. Reinitialising the module contents
+        # and just reverting os.environ to its previous state is an OK
+        # workaround
+        with support.EnvironmentVarGuard():
+            import os
+            imp.reload(os)
+
+    def test_extension(self):
+        with support.CleanImport('time'):
+            import time
+            imp.reload(time)
+
+    def test_builtin(self):
+        with support.CleanImport('marshal'):
+            import marshal
+            imp.reload(marshal)
+
+    def test_with_deleted_parent(self):
+        # see #18681
+        from html import parser
+        html = sys.modules.pop('html')
+        def cleanup():
+            sys.modules['html'] = html
+        self.addCleanup(cleanup)
+        with self.assertRaisesRegex(ImportError, 'html'):
+            imp.reload(parser)
+
+
+class PEP3147Tests(unittest.TestCase):
+    """Tests of PEP 3147."""
+
+    tag = imp.get_tag()
+
+    @unittest.skipUnless(sys.implementation.cache_tag is not None,
+                         'requires sys.implementation.cache_tag not be None')
+    def test_cache_from_source(self):
+        # Given the path to a .py file, return the path to its PEP 3147
+        # defined .pyc file (i.e. under __pycache__).
+        path = os.path.join('foo', 'bar', 'baz', 'qux.py')
+        expect = os.path.join('foo', 'bar', 'baz', '__pycache__',
+                              'qux.{}.pyc'.format(self.tag))
+        self.assertEqual(imp.cache_from_source(path, True), expect)
+
+    @unittest.skipUnless(sys.implementation.cache_tag is not None,
+                         'requires sys.implementation.cache_tag to not be '
+                         'None')
+    def test_source_from_cache(self):
+        # Given the path to a PEP 3147 defined .pyc file, return the path to
+        # its source.  This tests the good path.
+        path = os.path.join('foo', 'bar', 'baz', '__pycache__',
+                            'qux.{}.pyc'.format(self.tag))
+        expect = os.path.join('foo', 'bar', 'baz', 'qux.py')
+        self.assertEqual(imp.source_from_cache(path), expect)
+
+
+class NullImporterTests(unittest.TestCase):
+    @unittest.skipIf(support.TESTFN_UNENCODABLE is None,
+                     "Need an undecodeable filename")
+    def test_unencodeable(self):
+        name = support.TESTFN_UNENCODABLE
+        os.mkdir(name)
+        try:
+            self.assertRaises(ImportError, imp.NullImporter, name)
+        finally:
+            os.rmdir(name)
+
+
+if __name__ == "__main__":
+    unittest.main()