ULTRA [ www.resource.optimyar.com ]

Linux uranus.pws-dns.net 5.14.0-427.42.1.el9_4.x86_64 #1 SMP PREEMPT_DYNAMIC Fri Nov 1 14:58:02 EDT 2024 x86_64

LiteSpeed

31.214.174.197 | Your IP: 216.73.216.157

Cant read [ /etc/named.conf ]

[ drwxr-xr-x ]

/ proc / thread-self / root / opt / alt / python310 / lib64 / python3.10 / test / test_importlib /

Home Upload Mass Deface Mass Delete Back Connect Notify

test_api.py

from . import util as test_util

init = test_util.import_importlib('importlib')
util = test_util.import_importlib('importlib.util')
machinery = test_util.import_importlib('importlib.machinery')

import os.path
import sys
from test import support
from test.support import import_helper
from test.support import os_helper
import types
import unittest
import warnings

class ImportModuleTests:

"""Test importlib.import_module."""

def test_module_import(self):
        # Test importing a top-level module.
        with test_util.mock_spec('top_level') as mock:
            with test_util.import_state(meta_path=[mock]):
                module = self.init.import_module('top_level')
                self.assertEqual(module.__name__, 'top_level')

def test_absolute_package_import(self):
        # Test importing a module from a package with an absolute name.
        pkg_name = 'pkg'
        pkg_long_name = '{0}.__init__'.format(pkg_name)
        name = '{0}.mod'.format(pkg_name)
        with test_util.mock_spec(pkg_long_name, name) as mock:
            with test_util.import_state(meta_path=[mock]):
                module = self.init.import_module(name)
                self.assertEqual(module.__name__, name)

def test_shallow_relative_package_import(self):
        # Test importing a module from a package through a relative import.
        pkg_name = 'pkg'
        pkg_long_name = '{0}.__init__'.format(pkg_name)
        module_name = 'mod'
        absolute_name = '{0}.{1}'.format(pkg_name, module_name)
        relative_name = '.{0}'.format(module_name)
        with test_util.mock_spec(pkg_long_name, absolute_name) as mock:
            with test_util.import_state(meta_path=[mock]):
                self.init.import_module(pkg_name)
                module = self.init.import_module(relative_name, pkg_name)
                self.assertEqual(module.__name__, absolute_name)

def test_deep_relative_package_import(self):
        modules = ['a.__init__', 'a.b.__init__', 'a.c']
        with test_util.mock_spec(*modules) as mock:
            with test_util.import_state(meta_path=[mock]):
                self.init.import_module('a')
                self.init.import_module('a.b')
                module = self.init.import_module('..c', 'a.b')
                self.assertEqual(module.__name__, 'a.c')

def test_absolute_import_with_package(self):
        # Test importing a module from a package with an absolute name with
        # the 'package' argument given.
        pkg_name = 'pkg'
        pkg_long_name = '{0}.__init__'.format(pkg_name)
        name = '{0}.mod'.format(pkg_name)
        with test_util.mock_spec(pkg_long_name, name) as mock:
            with test_util.import_state(meta_path=[mock]):
                self.init.import_module(pkg_name)
                module = self.init.import_module(name, pkg_name)
                self.assertEqual(module.__name__, name)

def test_relative_import_wo_package(self):
        # Relative imports cannot happen without the 'package' argument being
        # set.
        with self.assertRaises(TypeError):
            self.init.import_module('.support')

def test_loaded_once(self):
        # Issue #13591: Modules should only be loaded once when
        # initializing the parent package attempts to import the
        # module currently being imported.
        b_load_count = 0
        def load_a():
            self.init.import_module('a.b')
        def load_b():
            nonlocal b_load_count
            b_load_count += 1
        code = {'a': load_a, 'a.b': load_b}
        modules = ['a.__init__', 'a.b']
        with test_util.mock_spec(*modules, module_code=code) as mock:
            with test_util.import_state(meta_path=[mock]):
                self.init.import_module('a.b')
        self.assertEqual(b_load_count, 1)

(Frozen_ImportModuleTests,
 Source_ImportModuleTests
 ) = test_util.test_both(ImportModuleTests, init=init)

class FindLoaderTests:

FakeMetaFinder = None

def test_sys_modules(self):
        # If a module with __loader__ is in sys.modules, then return it.
        name = 'some_mod'
        with test_util.uncache(name):
            module = types.ModuleType(name)
            loader = 'a loader!'
            module.__loader__ = loader
            sys.modules[name] = module
            with warnings.catch_warnings():
                warnings.simplefilter('ignore', DeprecationWarning)
                found = self.init.find_loader(name)
            self.assertEqual(loader, found)

def test_sys_modules_loader_is_None(self):
        # If sys.modules[name].__loader__ is None, raise ValueError.
        name = 'some_mod'
        with test_util.uncache(name):
            module = types.ModuleType(name)
            module.__loader__ = None
            sys.modules[name] = module
            with self.assertRaises(ValueError):
                with warnings.catch_warnings():
                    warnings.simplefilter('ignore', DeprecationWarning)
                    self.init.find_loader(name)

def test_sys_modules_loader_is_not_set(self):
        # Should raise ValueError
        # Issue #17099
        name = 'some_mod'
        with test_util.uncache(name):
            module = types.ModuleType(name)
            try:
                del module.__loader__
            except AttributeError:
                pass
            sys.modules[name] = module
            with self.assertRaises(ValueError):
                with warnings.catch_warnings():
                    warnings.simplefilter('ignore', DeprecationWarning)
                    self.init.find_loader(name)

def test_success(self):
        # Return the loader found on sys.meta_path.
        name = 'some_mod'
        with test_util.uncache(name):
            with test_util.import_state(meta_path=[self.FakeMetaFinder]):
                with warnings.catch_warnings():
                    warnings.simplefilter('ignore', DeprecationWarning)
                    warnings.simplefilter('ignore', ImportWarning)
                    self.assertEqual((name, None), self.init.find_loader(name))

def test_success_path(self):
        # Searching on a path should work.
        name = 'some_mod'
        path = 'path to some place'
        with test_util.uncache(name):
            with test_util.import_state(meta_path=[self.FakeMetaFinder]):
                with warnings.catch_warnings():
                    warnings.simplefilter('ignore', DeprecationWarning)
                    warnings.simplefilter('ignore', ImportWarning)
                    self.assertEqual((name, path),
                                     self.init.find_loader(name, path))

def test_nothing(self):
        # None is returned upon failure to find a loader.
        with warnings.catch_warnings():
            warnings.simplefilter('ignore', DeprecationWarning)
            self.assertIsNone(self.init.find_loader('nevergoingtofindthismodule'))

class FindLoaderPEP451Tests(FindLoaderTests):

class FakeMetaFinder:
        @staticmethod
        def find_spec(name, path=None, target=None):
            return machinery['Source'].ModuleSpec(name, (name, path))

(Frozen_FindLoaderPEP451Tests,
 Source_FindLoaderPEP451Tests
 ) = test_util.test_both(FindLoaderPEP451Tests, init=init)

class FindLoaderPEP302Tests(FindLoaderTests):

class FakeMetaFinder:
        @staticmethod
        def find_module(name, path=None):
            return name, path

(Frozen_FindLoaderPEP302Tests,
 Source_FindLoaderPEP302Tests
 ) = test_util.test_both(FindLoaderPEP302Tests, init=init)

class ReloadTests:

def test_reload_modules(self):
        for mod in ('tokenize', 'time', 'marshal'):
            with self.subTest(module=mod):
                with import_helper.CleanImport(mod):
                    module = self.init.import_module(mod)
                    self.init.reload(module)

def test_module_replaced(self):
        def code():
            import sys
            module = type(sys)('top_level')
            module.spam = 3
            sys.modules['top_level'] = module
        mock = test_util.mock_spec('top_level',
                                   module_code={'top_level': code})
        with mock:
            with test_util.import_state(meta_path=[mock]):
                module = self.init.import_module('top_level')
                reloaded = self.init.reload(module)
                actual = sys.modules['top_level']
                self.assertEqual(actual.spam, 3)
                self.assertEqual(reloaded.spam, 3)

def test_reload_missing_loader(self):
        with import_helper.CleanImport('types'):
            import types
            loader = types.__loader__
            del types.__loader__
            reloaded = self.init.reload(types)

self.assertIs(reloaded, types)
            self.assertIs(sys.modules['types'], types)
            self.assertEqual(reloaded.__loader__.path, loader.path)

def test_reload_loader_replaced(self):
        with import_helper.CleanImport('types'):
            import types
            types.__loader__ = None
            self.init.invalidate_caches()
            reloaded = self.init.reload(types)

self.assertIsNot(reloaded.__loader__, None)
            self.assertIs(reloaded, types)
            self.assertIs(sys.modules['types'], types)

def test_reload_location_changed(self):
        name = 'spam'
        with os_helper.temp_cwd(None) as cwd:
            with test_util.uncache('spam'):
                with import_helper.DirsOnSysPath(cwd):
                    # Start as a plain module.
                    self.init.invalidate_caches()
                    path = os.path.join(cwd, name + '.py')
                    cached = self.util.cache_from_source(path)
                    expected = {'__name__': name,
                                '__package__': '',
                                '__file__': path,
                                '__cached__': cached,
                                '__doc__': None,
                                }
                    os_helper.create_empty_file(path)
                    module = self.init.import_module(name)
                    ns = vars(module).copy()
                    loader = ns.pop('__loader__')
                    spec = ns.pop('__spec__')
                    ns.pop('__builtins__', None)  # An implementation detail.
                    self.assertEqual(spec.name, name)
                    self.assertEqual(spec.loader, loader)
                    self.assertEqual(loader.path, path)
                    self.assertEqual(ns, expected)

# Change to a package.
                    self.init.invalidate_caches()
                    init_path = os.path.join(cwd, name, '__init__.py')
                    cached = self.util.cache_from_source(init_path)
                    expected = {'__name__': name,
                                '__package__': name,
                                '__file__': init_path,
                                '__cached__': cached,
                                '__path__': [os.path.dirname(init_path)],
                                '__doc__': None,
                                }
                    os.mkdir(name)
                    os.rename(path, init_path)
                    reloaded = self.init.reload(module)
                    ns = vars(reloaded).copy()
                    loader = ns.pop('__loader__')
                    spec = ns.pop('__spec__')
                    ns.pop('__builtins__', None)  # An implementation detail.
                    self.assertEqual(spec.name, name)
                    self.assertEqual(spec.loader, loader)
                    self.assertIs(reloaded, module)
                    self.assertEqual(loader.path, init_path)
                    self.maxDiff = None
                    self.assertEqual(ns, expected)

def test_reload_namespace_changed(self):
        name = 'spam'
        with os_helper.temp_cwd(None) as cwd:
            with test_util.uncache('spam'):
                with import_helper.DirsOnSysPath(cwd):
                    # Start as a namespace package.
                    self.init.invalidate_caches()
                    bad_path = os.path.join(cwd, name, '__init.py')
                    cached = self.util.cache_from_source(bad_path)
                    expected = {'__name__': name,
                                '__package__': name,
                                '__doc__': None,
                                '__file__': None,
                                }
                    os.mkdir(name)
                    with open(bad_path, 'w', encoding='utf-8') as init_file:
                        init_file.write('eggs = None')
                    module = self.init.import_module(name)
                    ns = vars(module).copy()
                    loader = ns.pop('__loader__')
                    path = ns.pop('__path__')
                    spec = ns.pop('__spec__')
                    ns.pop('__builtins__', None)  # An implementation detail.
                    self.assertEqual(spec.name, name)
                    self.assertIsNotNone(spec.loader)
                    self.assertIsNotNone(loader)
                    self.assertEqual(spec.loader, loader)
                    self.assertEqual(set(path),
                                     set([os.path.dirname(bad_path)]))
                    with self.assertRaises(AttributeError):
                        # a NamespaceLoader
                        loader.path
                    self.assertEqual(ns, expected)

# Change to a regular package.
                    self.init.invalidate_caches()
                    init_path = os.path.join(cwd, name, '__init__.py')
                    cached = self.util.cache_from_source(init_path)
                    expected = {'__name__': name,
                                '__package__': name,
                                '__file__': init_path,
                                '__cached__': cached,
                                '__path__': [os.path.dirname(init_path)],
                                '__doc__': None,
                                'eggs': None,
                                }
                    os.rename(bad_path, init_path)
                    reloaded = self.init.reload(module)
                    ns = vars(reloaded).copy()
                    loader = ns.pop('__loader__')
                    spec = ns.pop('__spec__')
                    ns.pop('__builtins__', None)  # An implementation detail.
                    self.assertEqual(spec.name, name)
                    self.assertEqual(spec.loader, loader)
                    self.assertIs(reloaded, module)
                    self.assertEqual(loader.path, init_path)
                    self.assertEqual(ns, expected)

def test_reload_submodule(self):
        # See #19851.
        name = 'spam'
        subname = 'ham'
        with test_util.temp_module(name, pkg=True) as pkg_dir:
            fullname, _ = test_util.submodule(name, subname, pkg_dir)
            ham = self.init.import_module(fullname)
            reloaded = self.init.reload(ham)
            self.assertIs(reloaded, ham)

def test_module_missing_spec(self):
        #Test that reload() throws ModuleNotFounderror when reloading
        # a module whose missing a spec. (bpo-29851)
        name = 'spam'
        with test_util.uncache(name):
            module = sys.modules[name] = types.ModuleType(name)
            # Sanity check by attempting an import.
            module = self.init.import_module(name)
            self.assertIsNone(module.__spec__)
            with self.assertRaises(ModuleNotFoundError):
                self.init.reload(module)

(Frozen_ReloadTests,
 Source_ReloadTests
 ) = test_util.test_both(ReloadTests, init=init, util=util)

class InvalidateCacheTests:

def test_method_called(self):
        # If defined the method should be called.
        class InvalidatingNullFinder:
            def __init__(self, *ignored):
                self.called = False
            def find_module(self, *args):
                return None
            def invalidate_caches(self):
                self.called = True

key = 'gobledeegook'
        meta_ins = InvalidatingNullFinder()
        path_ins = InvalidatingNullFinder()
        sys.meta_path.insert(0, meta_ins)
        self.addCleanup(lambda: sys.path_importer_cache.__delitem__(key))
        sys.path_importer_cache[key] = path_ins
        self.addCleanup(lambda: sys.meta_path.remove(meta_ins))
        self.init.invalidate_caches()
        self.assertTrue(meta_ins.called)
        self.assertTrue(path_ins.called)

def test_method_lacking(self):
        # There should be no issues if the method is not defined.
        key = 'gobbledeegook'
        sys.path_importer_cache[key] = None
        self.addCleanup(lambda: sys.path_importer_cache.pop(key, None))
        self.init.invalidate_caches()  # Shouldn't trigger an exception.

(Frozen_InvalidateCacheTests,
 Source_InvalidateCacheTests
 ) = test_util.test_both(InvalidateCacheTests, init=init)

class FrozenImportlibTests(unittest.TestCase):

def test_no_frozen_importlib(self):
        # Should be able to import w/o _frozen_importlib being defined.
        # Can't do an isinstance() check since separate copies of importlib
        # may have been used for import, so just check the name is not for the
        # frozen loader.
        source_init = init['Source']
        self.assertNotEqual(source_init.__loader__.__class__.__name__,
                            'FrozenImporter')

class StartupTests:

def test_everyone_has___loader__(self):
        # Issue #17098: all modules should have __loader__ defined.
        for name, module in sys.modules.items():
            if isinstance(module, types.ModuleType):
                with self.subTest(name=name):
                    self.assertTrue(hasattr(module, '__loader__'),
                                    '{!r} lacks a __loader__ attribute'.format(name))
                    if self.machinery.BuiltinImporter.find_spec(name):
                        self.assertIsNot(module.__loader__, None)
                    elif self.machinery.FrozenImporter.find_spec(name):
                        self.assertIsNot(module.__loader__, None)

def test_everyone_has___spec__(self):
        for name, module in sys.modules.items():
            if isinstance(module, types.ModuleType):
                with self.subTest(name=name):
                    self.assertTrue(hasattr(module, '__spec__'))
                    if self.machinery.BuiltinImporter.find_spec(name):
                        self.assertIsNot(module.__spec__, None)
                    elif self.machinery.FrozenImporter.find_spec(name):
                        self.assertIsNot(module.__spec__, None)

(Frozen_StartupTests,
 Source_StartupTests
 ) = test_util.test_both(StartupTests, machinery=machinery)

if __name__ == '__main__':
    unittest.main()

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:26
..	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:26
__pycache__	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:26
builtin	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:26
data	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:26
data01	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:26
data02	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:26
data03	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:26
extension	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:26
frozen	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:26
import_	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:26
namespace_pkgs	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:26
namespacedata01	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:26
partial	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:26
source	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:26
zipdata01	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:26
zipdata02	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:26
__init__.py	text/x-script.python	142 B	root/linksafe	-rw-r--r--	2025-06-03 06:23:41
__main__.py	text/x-script.python	58 B	root/linksafe	-rw-r--r--	2025-06-03 06:23:41
abc.py	text/x-script.python	2.22 KB	root/linksafe	-rw-r--r--	2025-06-03 06:23:41
fixtures.py	text/x-script.python	7.28 KB	root/linksafe	-rw-r--r--	2025-06-03 06:23:41
stubs.py	text/x-script.python	233 B	root/linksafe	-rw-r--r--	2025-06-03 06:23:41
test_abc.py	text/x-script.python	34.19 KB	root/linksafe	-rw-r--r--	2025-06-03 06:23:41
test_api.py	text/x-script.python	18.59 KB	root/linksafe	-rw-r--r--	2025-06-03 06:23:41
test_files.py	text/plain	1011 B	root/linksafe	-rw-r--r--	2025-06-03 06:23:41
test_lazy.py	text/x-script.python	4.81 KB	root/linksafe	-rw-r--r--	2025-06-03 06:23:41
test_locks.py	text/x-script.python	4.41 KB	root/linksafe	-rw-r--r--	2025-06-03 06:23:41
test_main.py	text/x-script.python	8.75 KB	root/linksafe	-rw-r--r--	2025-06-03 06:23:41
test_metadata_api.py	text/x-script.python	11.41 KB	root/linksafe	-rw-r--r--	2025-06-03 06:23:41
test_namespace_pkgs.py	text/x-script.python	12.11 KB	root/linksafe	-rw-r--r--	2025-06-03 06:23:41
test_open.py	text/plain	2.31 KB	root/linksafe	-rw-r--r--	2025-06-03 06:23:41
test_path.py	text/plain	1.88 KB	root/linksafe	-rw-r--r--	2025-06-03 06:23:41
test_pkg_import.py	text/x-script.python	2.69 KB	root/linksafe	-rw-r--r--	2025-06-03 06:23:41
test_read.py	text/plain	1.94 KB	root/linksafe	-rw-r--r--	2025-06-03 06:23:41
test_reader.py	text/x-script.python	4.18 KB	root/linksafe	-rw-r--r--	2025-06-03 06:23:41
test_resource.py	text/x-script.python	8.18 KB	root/linksafe	-rw-r--r--	2025-06-03 06:23:41
test_spec.py	text/x-script.python	30.88 KB	root/linksafe	-rw-r--r--	2025-06-03 06:23:41
test_threaded_import.py	text/x-script.python	9.49 KB	root/linksafe	-rw-r--r--	2025-06-03 06:23:41
test_util.py	text/x-script.python	34.67 KB	root/linksafe	-rw-r--r--	2025-06-03 06:23:41
test_windows.py	text/x-script.python	7.26 KB	root/linksafe	-rw-r--r--	2025-06-03 06:23:41
test_zip.py	text/x-script.python	2.61 KB	root/linksafe	-rw-r--r--	2025-06-03 06:23:41
threaded_import_hangers.py	text/x-script.python	1.45 KB	root/linksafe	-rw-r--r--	2025-06-03 06:23:41
update-zips.py	text/plain	1.38 KB	root/linksafe	-rw-r--r--	2025-06-03 06:23:41
util.py	text/x-script.python	18.22 KB	root/linksafe	-rw-r--r--	2025-06-03 06:23:41