Stowage/cpython
2
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2026-01-06 15:32:22 +00:00
Code Issues Projects Releases Packages Wiki Activity

Rename importlib.test.support to importlib.test.util.

Browse source
This commit is contained in:
Brett Cannon 2009-02-01 04:00:05 +00:00
parent ae9ad186d0
commit bcb26c53c0
22 changed files with 163 additions and 191 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Lib/importlib/NOTES
View file

@ -3,6 +3,10 @@ to do
* Reorganize support code.
+ Separate out support code for extensions out of test_support_hook.
+ Move util.import_ and utill.mock_modules to import_, importlib_only,
mock_path_hook?
+ Add a file loader mock that returns monotonically increasing mtime.
- Use in source/test_reload.
- Use in source/test_load_module_mixed.

6
Lib/importlib/test/builtin/test_finder.py
View file

@ -1,6 +1,6 @@
from importlib import machinery
from .. import abc
from .. import support
from .. import util
import sys
import unittest
@ -14,7 +14,7 @@ class FinderTests(abc.FinderTests):
def test_module(self):
# Common case.
with support.uncache(self.name):
with util.uncache(self.name):
self.assert_(machinery.BuiltinImporter.find_module(self.name))
def test_package(self):
@ -40,7 +40,7 @@ def test_failure(self):
def test_ignore_path(self):
# The value for 'path' should always trigger a failed import.
with support.uncache(self.name):
with util.uncache(self.name):
loader = machinery.BuiltinImporter.find_module(self.name, ['pkg'])
self.assert_(loader is None)

6
Lib/importlib/test/builtin/test_loader.py
View file

@ -1,7 +1,7 @@
import importlib
from importlib import machinery
from .. import abc
from .. import support
from .. import util
import sys
import types
@ -29,7 +29,7 @@ def verify(self, module):
def test_module(self):
# Common case.
with support.uncache(self.name):
with util.uncache(self.name):
module = self.load_module(self.name)
self.verify(module)
@ -47,7 +47,7 @@ def test_state_after_failure(self):
def test_module_reuse(self):
# Test that the same module is used in a reload.
with support.uncache(self.name):
with util.uncache(self.name):
module1 = self.load_module(self.name)
module2 = self.load_module(self.name)
self.assert_(module1 is module2)

12
Lib/importlib/test/extension/test_case_sensitivity.py
View file

@ -1,12 +1,12 @@
import sys
from test import support as test_support
from test import support
import unittest
import importlib
from .. import support
from .. import util
from . import test_path_hook
@support.case_insensitive_tests
@util.case_insensitive_tests
class ExtensionModuleCaseSensitivityTest(unittest.TestCase):
def find_module(self):
@ -17,13 +17,13 @@ def find_module(self):
return finder.find_module(bad_name)
def test_case_sensitive(self):
with test_support.EnvironmentVarGuard() as env:
with support.EnvironmentVarGuard() as env:
env.unset('PYTHONCASEOK')
loader = self.find_module()
self.assert_(loader is None)
def test_case_insensitivity(self):
with test_support.EnvironmentVarGuard() as env:
with support.EnvironmentVarGuard() as env:
env.set('PYTHONCASEOK', '1')
loader = self.find_module()
self.assert_(hasattr(loader, 'load_module'))
@ -32,7 +32,7 @@ def test_case_insensitivity(self):
def test_main():
test_support.run_unittest(ExtensionModuleCaseSensitivityTest)
support.run_unittest(ExtensionModuleCaseSensitivityTest)
if __name__ == '__main__':

6
Lib/importlib/test/extension/test_loader.py
View file

@ -1,7 +1,7 @@
import importlib
from . import test_path_hook
from .. import abc
from .. import support
from .. import util
import sys
import unittest
@ -18,7 +18,7 @@ def load_module(self, fullname):
return loader.load_module(fullname)
def test_module(self):
with support.uncache(test_path_hook.NAME):
with util.uncache(test_path_hook.NAME):
module = self.load_module(test_path_hook.NAME)
for attr, value in [('__name__', test_path_hook.NAME),
('__file__', test_path_hook.FILEPATH)]:
@ -34,7 +34,7 @@ def test_lacking_parent(self):
pass
def test_module_reuse(self):
with support.uncache(test_path_hook.NAME):
with util.uncache(test_path_hook.NAME):
module1 = self.load_module(test_path_hook.NAME)
module2 = self.load_module(test_path_hook.NAME)
self.assert_(module1 is module2)

24
Lib/importlib/test/frozen/support.py
View file

@ -1,24 +0,0 @@
import sys
class Null:
"""Just absorb what is given."""
def __getattr__(self):
return lambda *args, **kwargs: None
class SilenceStdout:
"""Silence sys.stdout."""
def setUp(self):
"""Substitute sys.stdout with something that does not print to the
screen thanks to what bytecode is frozen."""
sys.stdout = Null()
super().setUp()
def tearDown(self):
sys.stdout = sys.__stdout__
super().tearDown()

10
Lib/importlib/test/frozen/test_loader.py
View file

@ -1,12 +1,12 @@
from importlib import machinery
from .. import abc
from .. import support
from .. import util
class LoaderTests(abc.LoaderTests):
def test_module(self):
with support.uncache('__hello__'):
with util.uncache('__hello__'):
module = machinery.FrozenImporter.load_module('__hello__')
check = {'__name__': '__hello__', '__file__': '<frozen>',
'__package__': None}
@ -14,7 +14,7 @@ def test_module(self):
self.assertEqual(getattr(module, attr), value)
def test_package(self):
with support.uncache('__phello__'):
with util.uncache('__phello__'):
module = machinery.FrozenImporter.load_module('__phello__')
check = {'__name__': '__phello__', '__file__': '<frozen>',
'__package__': '__phello__', '__path__': ['__phello__']}
@ -25,7 +25,7 @@ def test_package(self):
(attr, attr_value, value))
def test_lacking_parent(self):
with support.uncache('__phello__', '__phello__.spam'):
with util.uncache('__phello__', '__phello__.spam'):
module = machinery.FrozenImporter.load_module('__phello__.spam')
check = {'__name__': '__phello__.spam', '__file__': '<frozen>',
'__package__': '__phello__'}
@ -36,7 +36,7 @@ def test_lacking_parent(self):
(attr, attr_value, value))
def test_module_reuse(self):
with support.uncache('__hello__'):
with util.uncache('__hello__'):
module1 = machinery.FrozenImporter.load_module('__hello__')
module2 = machinery.FrozenImporter.load_module('__hello__')
self.assert_(module1 is module2)

40
Lib/importlib/test/import_/test___package__.py
View file

@ -5,7 +5,7 @@
"""
import unittest
from .. import support
from .. import util
class Using__package__(unittest.TestCase):
@ -34,19 +34,19 @@ def calc_package(caller_name, has___path__):
def test_using___package__(self):
# [__package__]
with support.mock_modules('pkg.__init__', 'pkg.fake') as importer:
with support.import_state(meta_path=[importer]):
support.import_('pkg.fake')
module = support.import_('', globals={'__package__': 'pkg.fake'},
with util.mock_modules('pkg.__init__', 'pkg.fake') as importer:
with util.import_state(meta_path=[importer]):
util.import_('pkg.fake')
module = util.import_('', globals={'__package__': 'pkg.fake'},
fromlist=['attr'], level=2)
self.assertEquals(module.__name__, 'pkg')
def test_using___name__(self):
# [__name__]
with support.mock_modules('pkg.__init__', 'pkg.fake') as importer:
with support.import_state(meta_path=[importer]):
support.import_('pkg.fake')
module = support.import_('',
with util.mock_modules('pkg.__init__', 'pkg.fake') as importer:
with util.import_state(meta_path=[importer]):
util.import_('pkg.fake')
module = util.import_('',
globals={'__name__': 'pkg.fake',
'__path__': []},
fromlist=['attr'], level=2)
@ -54,12 +54,12 @@ def test_using___name__(self):
def test_bad__package__(self):
globals = {'__package__': '<not real>'}
self.assertRaises(SystemError, support.import_,'', globals, {},
self.assertRaises(SystemError, util.import_,'', globals, {},
['relimport'], 1)
def test_bunk__package__(self):
globals = {'__package__': 42}
self.assertRaises(ValueError, support.import_, '', globals, {},
self.assertRaises(ValueError, util.import_, '', globals, {},
['relimport'], 1)
@ -77,26 +77,26 @@ class Setting__package__(unittest.TestCase):
# [top-level]
def test_top_level(self):
with support.mock_modules('top_level') as mock:
with support.import_state(meta_path=[mock]):
with util.mock_modules('top_level') as mock:
with util.import_state(meta_path=[mock]):
del mock['top_level'].__package__
module = support.import_('top_level')
module = util.import_('top_level')
self.assert_(module.__package__ is None)
# [package]
def test_package(self):
with support.mock_modules('pkg.__init__') as mock:
with support.import_state(meta_path=[mock]):
with util.mock_modules('pkg.__init__') as mock:
with util.import_state(meta_path=[mock]):
del mock['pkg'].__package__
module = support.import_('pkg')
module = util.import_('pkg')
self.assertEqual(module.__package__, 'pkg')
# [submodule]
def test_submodule(self):
with support.mock_modules('pkg.__init__', 'pkg.mod') as mock:
with support.import_state(meta_path=[mock]):
with util.mock_modules('pkg.__init__', 'pkg.mod') as mock:
with util.import_state(meta_path=[mock]):
del mock['pkg.mod'].__package__
pkg = support.import_('pkg.mod')
pkg = util.import_('pkg.mod')
module = getattr(pkg, 'mod')
self.assertEqual(module.__package__, 'pkg')

25
Lib/importlib/test/import_/test_caching.py
View file

@ -1,6 +1,5 @@
"""Test that sys.modules is used properly by import."""
from ..support import import_, mock_modules, importlib_only, import_state
from .. import util
import sys
from types import MethodType
import unittest
@ -24,11 +23,11 @@ def test_using_cache(self):
# [use cache]
module_to_use = "some module found!"
sys.modules['some_module'] = module_to_use
module = import_('some_module')
module = util.import_('some_module')
self.assertEqual(id(module_to_use), id(module))
def create_mock(self, *names, return_=None):
mock = mock_modules(*names)
mock = util.mock_modules(*names)
original_load = mock.load_module
def load_module(self, fullname):
original_load(fullname)
@ -38,31 +37,31 @@ def load_module(self, fullname):
# __import__ inconsistent between loaders and built-in import when it comes
# to when to use the module in sys.modules and when not to.
@importlib_only
@util.importlib_only
def test_using_cache_after_loader(self):
# [from cache on return]
with self.create_mock('module') as mock:
with import_state(meta_path=[mock]):
module = import_('module')
with util.import_state(meta_path=[mock]):
module = util.import_('module')
self.assertEquals(id(module), id(sys.modules['module']))
# See test_using_cache_after_loader() for reasoning.
@importlib_only
@util.importlib_only
def test_using_cache_for_assigning_to_attribute(self):
# [from cache to attribute]
with self.create_mock('pkg.__init__', 'pkg.module') as importer:
with import_state(meta_path=[importer]):
module = import_('pkg.module')
with util.import_state(meta_path=[importer]):
module = util.import_('pkg.module')
self.assert_(hasattr(module, 'module'))
self.assert_(id(module.module), id(sys.modules['pkg.module']))
# See test_using_cache_after_loader() for reasoning.
@importlib_only
@util.importlib_only
def test_using_cache_for_fromlist(self):
# [from cache for fromlist]
with self.create_mock('pkg.__init__', 'pkg.module') as importer:
with import_state(meta_path=[importer]):
module = import_('pkg', fromlist=['module'])
with util.import_state(meta_path=[importer]):
module = util.import_('pkg', fromlist=['module'])
self.assert_(hasattr(module, 'module'))
self.assertEquals(id(module.module), id(sys.modules['pkg.module']))

57
Lib/importlib/test/import_/test_fromlist.py
View file

@ -1,6 +1,5 @@
"""Test that the semantics relating to the 'fromlist' argument are correct."""
from ..support import import_, mock_modules, import_state
from .. import util
import unittest
class ReturnValue(unittest.TestCase):
@ -16,16 +15,16 @@ class ReturnValue(unittest.TestCase):
def test_return_from_import(self):
# [import return]
with mock_modules('pkg.__init__', 'pkg.module') as importer:
with import_state(meta_path=[importer]):
module = import_('pkg.module')
with util.mock_modules('pkg.__init__', 'pkg.module') as importer:
with util.import_state(meta_path=[importer]):
module = util.import_('pkg.module')
self.assertEquals(module.__name__, 'pkg')
def test_return_from_from_import(self):
# [from return]
with mock_modules('pkg.__init__', 'pkg.module')as importer:
with import_state(meta_path=[importer]):
module = import_('pkg.module', fromlist=['attr'])
with util.mock_modules('pkg.__init__', 'pkg.module')as importer:
with util.import_state(meta_path=[importer]):
module = util.import_('pkg.module', fromlist=['attr'])
self.assertEquals(module.__name__, 'pkg.module')
@ -48,59 +47,59 @@ class HandlingFromlist(unittest.TestCase):
def test_object(self):
# [object case]
with mock_modules('module') as importer:
with import_state(meta_path=[importer]):
module = import_('module', fromlist=['attr'])
with util.mock_modules('module') as importer:
with util.import_state(meta_path=[importer]):
module = util.import_('module', fromlist=['attr'])
self.assertEquals(module.__name__, 'module')
def test_unexistent_object(self):
# [bad object]
with mock_modules('module') as importer:
with import_state(meta_path=[importer]):
module = import_('module', fromlist=['non_existent'])
with util.mock_modules('module') as importer:
with util.import_state(meta_path=[importer]):
module = util.import_('module', fromlist=['non_existent'])
self.assertEquals(module.__name__, 'module')
self.assert_(not hasattr(module, 'non_existent'))
def test_module_from_package(self):
# [module]
with mock_modules('pkg.__init__', 'pkg.module') as importer:
with import_state(meta_path=[importer]):
module = import_('pkg', fromlist=['module'])
with util.mock_modules('pkg.__init__', 'pkg.module') as importer:
with util.import_state(meta_path=[importer]):
module = util.import_('pkg', fromlist=['module'])
self.assertEquals(module.__name__, 'pkg')
self.assert_(hasattr(module, 'module'))
self.assertEquals(module.module.__name__, 'pkg.module')
def test_no_module_from_package(self):
# [no module]
with mock_modules('pkg.__init__') as importer:
with import_state(meta_path=[importer]):
module = import_('pkg', fromlist='non_existent')
with util.mock_modules('pkg.__init__') as importer:
with util.import_state(meta_path=[importer]):
module = util.import_('pkg', fromlist='non_existent')
self.assertEquals(module.__name__, 'pkg')
self.assert_(not hasattr(module, 'non_existent'))
def test_empty_string(self):
with mock_modules('pkg.__init__', 'pkg.mod') as importer:
with import_state(meta_path=[importer]):
module = import_('pkg.mod', fromlist=[''])
with util.mock_modules('pkg.__init__', 'pkg.mod') as importer:
with util.import_state(meta_path=[importer]):
module = util.import_('pkg.mod', fromlist=[''])
self.assertEquals(module.__name__, 'pkg.mod')
def test_using_star(self):
# [using *]
with mock_modules('pkg.__init__', 'pkg.module') as mock:
with import_state(meta_path=[mock]):
with util.mock_modules('pkg.__init__', 'pkg.module') as mock:
with util.import_state(meta_path=[mock]):
mock['pkg'].__all__ = ['module']
module = import_('pkg', fromlist=['*'])
module = util.import_('pkg', fromlist=['*'])
self.assertEquals(module.__name__, 'pkg')
self.assert_(hasattr(module, 'module'))
self.assertEqual(module.module.__name__, 'pkg.module')
def test_star_with_others(self):
# [using * with others]
context = mock_modules('pkg.__init__', 'pkg.module1', 'pkg.module2')
context = util.mock_modules('pkg.__init__', 'pkg.module1', 'pkg.module2')
with context as mock:
with import_state(meta_path=[mock]):
with util.import_state(meta_path=[mock]):
mock['pkg'].__all__ = ['module1']
module = import_('pkg', fromlist=['module2', '*'])
module = util.import_('pkg', fromlist=['module2', '*'])
self.assertEquals(module.__name__, 'pkg')
self.assert_(hasattr(module, 'module1'))
self.assert_(hasattr(module, 'module2'))

34
Lib/importlib/test/import_/test_meta_path.py
View file

@ -1,5 +1,4 @@
from ..support import import_state, mock_modules, import_
from .. import util
from contextlib import nested
from types import MethodType
import unittest
@ -16,24 +15,25 @@ class CallingOrder(unittest.TestCase):
def test_first_called(self):
# [first called]
mod = 'top_level'
first = mock_modules(mod)
second = mock_modules(mod)
with nested(mock_modules(mod), mock_modules(mod)) as (first, second):
first = util.mock_modules(mod)
second = util.mock_modules(mod)
context = nested(util.mock_modules(mod), util.mock_modules(mod))
with context as (first, second):
first.modules[mod] = 42
second.modules[mod] = -13
with import_state(meta_path=[first, second]):
self.assertEquals(import_(mod), 42)
with util.import_state(meta_path=[first, second]):
self.assertEquals(util.import_(mod), 42)
def test_continuing(self):
# [continuing]
mod_name = 'for_real'
first = mock_modules('nonexistent')
second = mock_modules(mod_name)
first = util.mock_modules('nonexistent')
second = util.mock_modules(mod_name)
with nested(first, second):
first.find_module = lambda self, fullname, path=None: None
second.modules[mod_name] = 42
with import_state(meta_path=[first, second]):
self.assertEquals(import_(mod_name), 42)
with util.import_state(meta_path=[first, second]):
self.assertEquals(util.import_(mod_name), 42)
class CallSignature(unittest.TestCase):
@ -54,11 +54,11 @@ def test_no_path(self):
# [no path]
mod_name = 'top_level'
assert '.' not in mod_name
with mock_modules(mod_name) as importer:
with util.mock_modules(mod_name) as importer:
log, wrapped_call = self.log(importer.find_module)
importer.find_module = MethodType(wrapped_call, importer)
with import_state(meta_path=[importer]):
import_(mod_name)
with util.import_state(meta_path=[importer]):
util.import_(mod_name)
assert len(log) == 1
args = log[0][0]
kwargs = log[0][1]
@ -74,12 +74,12 @@ def test_with_path(self):
mod_name = pkg_name + '.module'
path = [42]
assert '.' in mod_name
with mock_modules(pkg_name+'.__init__', mod_name) as importer:
with util.mock_modules(pkg_name+'.__init__', mod_name) as importer:
importer.modules[pkg_name].__path__ = path
log, wrapped_call = self.log(importer.find_module)
importer.find_module = MethodType(wrapped_call, importer)
with import_state(meta_path=[importer]):
import_(mod_name)
with util.import_state(meta_path=[importer]):
util.import_(mod_name)
assert len(log) == 2
args = log[1][0]
kwargs = log[1][1]

14
Lib/importlib/test/import_/test_packages.py
View file

@ -1,7 +1,7 @@
from .. import util
import sys
import unittest
import importlib
from .. import support
class ParentModuleTests(unittest.TestCase):
@ -9,15 +9,15 @@ class ParentModuleTests(unittest.TestCase):
"""Importing a submodule should import the parent modules."""
def test_import_parent(self):
with support.mock_modules('pkg.__init__', 'pkg.module') as mock:
with support.import_state(meta_path=[mock]):
module = support.import_('pkg.module')
with util.mock_modules('pkg.__init__', 'pkg.module') as mock:
with util.import_state(meta_path=[mock]):
module = util.import_('pkg.module')
self.assert_('pkg' in sys.modules)
def test_bad_parent(self):
with support.mock_modules('pkg.module') as mock:
with support.import_state(meta_path=[mock]):
self.assertRaises(ImportError, support.import_, 'pkg.module')
with util.mock_modules('pkg.module') as mock:
with util.import_state(meta_path=[mock]):
self.assertRaises(ImportError, util.import_, 'pkg.module')
def test_main():

36
Lib/importlib/test/import_/test_path.py
View file

@ -1,6 +1,4 @@
from ..support import (mock_modules, import_state, import_, mock_path_hook,
importlib_only, uncache)
from .. import util
from contextlib import nested
from imp import new_module
import sys
@ -32,7 +30,7 @@ class BaseTests(unittest.TestCase):
def order_test(self, to_import, entry, search_path, path=[]):
# [order]
log = []
class LogFindModule(mock_modules):
class LogFindModule(util.mock_modules):
def find_module(self, fullname):
log.append(self)
return super().find_module(fullname)
@ -42,12 +40,12 @@ def find_module(self, fullname):
hitter = LogFindModule(to_import)
with nested(misser, hitter):
cache = dict(zip(search_path, (misser, hitter)))
with import_state(path=path, path_importer_cache=cache):
import_(to_import)
with util.import_state(path=path, path_importer_cache=cache):
util.import_(to_import)
self.assertEquals(log[0], misser)
self.assertEquals(log[1], hitter)
@importlib_only # __import__ uses PyDict_GetItem(), bypassing log.
@util.importlib_only # __import__ uses PyDict_GetItem(), bypassing log.
def cache_use_test(self, to_import, entry, path=[]):
# [cache check], [cache use]
log = []
@ -56,11 +54,11 @@ def __getitem__(self, item):
log.append(item)
return super(LoggingDict, self).__getitem__(item)
with mock_modules(to_import) as importer:
with util.mock_modules(to_import) as importer:
cache = LoggingDict()
cache[entry] = importer
with import_state(path=[entry], path_importer_cache=cache):
module = import_(to_import, fromlist=['a'])
with util.import_state(path=[entry], path_importer_cache=cache):
module = util.import_(to_import, fromlist=['a'])
self.assert_(module is importer[to_import])
self.assertEquals(len(cache), 1)
self.assertEquals([entry], log)
@ -71,11 +69,11 @@ def hooks_order_test(self, to_import, entry, path=[]):
def logging_hook(entry):
log.append(entry)
raise ImportError
with mock_modules(to_import) as importer:
hitter = mock_path_hook(entry, importer=importer)
with util.mock_modules(to_import) as importer:
hitter = util.mock_path_hook(entry, importer=importer)
path_hooks = [logging_hook, logging_hook, hitter]
with import_state(path_hooks=path_hooks, path=path):
import_(to_import)
with util.import_state(path_hooks=path_hooks, path=path):
util.import_(to_import)
self.assertEquals(sys.path_importer_cache[entry], importer)
self.assertEquals(len(log), 2)
@ -90,7 +88,7 @@ def find_module(name):
raise ImportError
try:
import_(to_import)
util.import_(to_import)
except ImportError:
pass
@ -113,7 +111,7 @@ def test_hooks_order(self):
def test_path_argument(self):
name = 'total junk'
with uncache(name):
with util.uncache(name):
self.path_argument_test(name)
@ -122,13 +120,13 @@ class __path__Tests(BaseTests):
"""Tests for __path__."""
def run_test(self, test, entry, path, *args):
with mock_modules('pkg.__init__') as importer:
with util.mock_modules('pkg.__init__') as importer:
importer['pkg'].__path__ = path
importer.load_module('pkg')
test('pkg.hit', entry, *args)
@importlib_only # XXX Unknown reason why this fails.
@util.importlib_only # XXX Unknown reason why this fails.
def test_order(self):
self.run_test(self.order_test, 'second', ('first', 'second'), ['first',
'second'])
@ -146,7 +144,7 @@ def test_path_argument(self):
module.__path__ = ['random __path__']
name = 'pkg.whatever'
sys.modules['pkg'] = module
with uncache('pkg', name):
with util.uncache('pkg', name):
self.path_argument_test(name)

47
Lib/importlib/test/import_/test_relative_imports.py
View file

@ -1,7 +1,5 @@
"""Test relative imports (PEP 328)."""
from ..support import uncache, import_, mock_modules, import_state
from .. import util
import sys
import unittest
@ -65,10 +63,10 @@ def relative_import_test(self, create, globals_, callback):
uncache_names.append(name)
else:
uncache_names.append(name[:-len('.__init__')])
with mock_modules(*create) as importer:
with import_state(meta_path=[importer]):
with util.mock_modules(*create) as importer:
with util.import_state(meta_path=[importer]):
for global_ in globals_:
with uncache(*uncache_names):
with util.uncache(*uncache_names):
callback(global_)
@ -77,8 +75,8 @@ def test_module_from_module(self):
create = 'pkg.__init__', 'pkg.mod2'
globals_ = {'__package__': 'pkg'}, {'__name__': 'pkg.mod1'}
def callback(global_):
import_('pkg') # For __import__().
module = import_('', global_, fromlist=['mod2'], level=1)
util.import_('pkg') # For __import__().
module = util.import_('', global_, fromlist=['mod2'], level=1)
self.assertEqual(module.__name__, 'pkg')
self.assert_(hasattr(module, 'mod2'))
self.assertEqual(module.mod2.attr, 'pkg.mod2')
@ -89,8 +87,8 @@ def test_attr_from_module(self):
create = 'pkg.__init__', 'pkg.mod2'
globals_ = {'__package__': 'pkg'}, {'__name__': 'pkg.mod1'}
def callback(global_):
import_('pkg') # For __import__().
module = import_('mod2', global_, fromlist=['attr'], level=1)
util.import_('pkg') # For __import__().
module = util.import_('mod2', global_, fromlist=['attr'], level=1)
self.assertEqual(module.__name__, 'pkg.mod2')
self.assertEqual(module.attr, 'pkg.mod2')
self.relative_import_test(create, globals_, callback)
@ -101,8 +99,8 @@ def test_package_to_module(self):
globals_ = ({'__package__': 'pkg'},
{'__name__': 'pkg', '__path__': ['blah']})
def callback(global_):
import_('pkg') # For __import__().
module = import_('', global_, fromlist=['module'],
util.import_('pkg') # For __import__().
module = util.import_('', global_, fromlist=['module'],
level=1)
self.assertEqual(module.__name__, 'pkg')
self.assert_(hasattr(module, 'module'))
@ -114,8 +112,8 @@ def test_module_to_package(self):
create = 'pkg.__init__', 'pkg.module'
globals_ = {'__package__': 'pkg'}, {'__name__': 'pkg.module'}
def callback(global_):
import_('pkg') # For __import__().
module = import_('', global_, fromlist=['attr'], level=1)
util.import_('pkg') # For __import__().
module = util.import_('', global_, fromlist=['attr'], level=1)
self.assertEqual(module.__name__, 'pkg')
self.relative_import_test(create, globals_, callback)
@ -126,7 +124,7 @@ def test_package_to_package(self):
globals_ = ({'__package__': 'pkg.subpkg1'},
{'__name__': 'pkg.subpkg1', '__path__': ['blah']})
def callback(global_):
module = import_('', global_, fromlist=['subpkg2'], level=2)
module = util.import_('', global_, fromlist=['subpkg2'], level=2)
self.assertEqual(module.__name__, 'pkg')
self.assert_(hasattr(module, 'subpkg2'))
self.assertEqual(module.subpkg2.attr, 'pkg.subpkg2.__init__')
@ -141,8 +139,8 @@ def test_deep_import(self):
{'__name__': 'pkg.pkg1.pkg2.pkg3.pkg4.pkg5',
'__path__': ['blah']})
def callback(global_):
import_(globals_[0]['__package__'])
module = import_('', global_, fromlist=['attr'], level=6)
util.import_(globals_[0]['__package__'])
module = util.import_('', global_, fromlist=['attr'], level=6)
self.assertEqual(module.__name__, 'pkg')
self.relative_import_test(create, globals_, callback)
@ -152,8 +150,8 @@ def test_too_high_from_package(self):
globals_ = ({'__package__': 'pkg'},
{'__name__': 'pkg', '__path__': ['blah']})
def callback(global_):
import_('pkg')
self.assertRaises(ValueError, import_, '', global_,
util.import_('pkg')
self.assertRaises(ValueError, util.import_, '', global_,
fromlist=['top_level'], level=2)
self.relative_import_test(create, globals_, callback)
@ -162,14 +160,14 @@ def test_too_high_from_module(self):
create = ['top_level', 'pkg.__init__', 'pkg.module']
globals_ = {'__package__': 'pkg'}, {'__name__': 'pkg.module'}
def callback(global_):
import_('pkg')
self.assertRaises(ValueError, import_, '', global_,
util.import_('pkg')
self.assertRaises(ValueError, util.import_, '', global_,
fromlist=['top_level'], level=2)
self.relative_import_test(create, globals_, callback)
def test_empty_name_w_level_0(self):
# [empty name]
self.assertRaises(ValueError, import_, '')
self.assertRaises(ValueError, util.import_, '')
def test_import_from_different_package(self):
# Test importing from a different package than the caller.
@ -183,8 +181,9 @@ def test_import_from_different_package(self):
'__runpy_pkg__.uncle.cousin.nephew']
globals_ = {'__package__': '__runpy_pkg__.__runpy_pkg__'}
def callback(global_):
import_('__runpy_pkg__.__runpy_pkg__')
module = import_('uncle.cousin', globals_, {}, fromlist=['nephew'],
util.import_('__runpy_pkg__.__runpy_pkg__')
module = util.import_('uncle.cousin', globals_, {},
fromlist=['nephew'],
level=2)
self.assertEqual(module.__name__, '__runpy_pkg__.uncle.cousin')
self.relative_import_test(create, globals_, callback)

4
Lib/importlib/test/source/test_case_sensitivity.py
View file

@ -1,6 +1,6 @@
"""Test case-sensitivity (PEP 235)."""
import importlib
from .. import support
from .. import util
from . import util as source_util
import os
import sys
@ -8,7 +8,7 @@
import unittest
@support.case_insensitive_tests
@util.case_insensitive_tests
class CaseSensitivityTest(unittest.TestCase):
"""PEP 235 dictates that on case-preserving, case-insensitive file systems

1
Lib/importlib/test/source/test_finder.py
View file

@ -1,6 +1,5 @@
import importlib
from .. import abc
from .. import support
from . import util as source_util
import os
import py_compile

1
Lib/importlib/test/source/test_loader.py
View file

@ -1,6 +1,5 @@
import importlib
from .. import abc
from .. import support
from . import util as source_util
import imp

4
Lib/importlib/test/source/test_path_hook.py
View file

@ -1,5 +1,5 @@
import importlib
from . import util
from . import util as source_util
import unittest
@ -9,7 +9,7 @@ class PathHookTest(unittest.TestCase):
def test_success(self):
# XXX Only work on existing directories?
with util.create_modules('dummy') as mapping:
with source_util.create_modules('dummy') as mapping:
self.assert_(hasattr(importlib.FileImporter(mapping['.root']),
'find_module'))

1
Lib/importlib/test/source/test_source_encoding.py
View file

@ -1,5 +1,4 @@
import importlib
from .. import support
from . import util as source_util
import codecs

4
Lib/importlib/test/source/util.py
View file

@ -1,11 +1,11 @@
from .. import support as util
from .. import util
import contextlib
import imp
import os
import os.path
import sys
import tempfile
from test import support as support
from test import support
def writes_bytecode(fxn):

18
Lib/importlib/test/test_api.py
View file

@ -1,6 +1,6 @@
import unittest
import importlib
from . import support
from . import util
class ImportModuleTests(unittest.TestCase):
@ -9,8 +9,8 @@ class ImportModuleTests(unittest.TestCase):
def test_module_import(self):
# Test importing a top-level module.
with support.mock_modules('top_level') as mock:
with support.import_state(meta_path=[mock]):
with util.mock_modules('top_level') as mock:
with util.import_state(meta_path=[mock]):
module = importlib.import_module('top_level')
self.assertEqual(module.__name__, 'top_level')
@ -19,8 +19,8 @@ def test_absolute_package_import(self):
pkg_name = 'pkg'
pkg_long_name = '{0}.__init__'.format(pkg_name)
name = '{0}.mod'.format(pkg_name)
with support.mock_modules(pkg_long_name, name) as mock:
with support.import_state(meta_path=[mock]):
with util.mock_modules(pkg_long_name, name) as mock:
with util.import_state(meta_path=[mock]):
module = importlib.import_module(name)
self.assertEqual(module.__name__, name)
@ -31,8 +31,8 @@ def test_relative_package_import(self):
module_name = 'mod'
absolute_name = '{0}.{1}'.format(pkg_name, module_name)
relative_name = '.{0}'.format(module_name)
with support.mock_modules(pkg_long_name, absolute_name) as mock:
with support.import_state(meta_path=[mock]):
with util.mock_modules(pkg_long_name, absolute_name) as mock:
with util.import_state(meta_path=[mock]):
module = importlib.import_module(relative_name, pkg_name)
self.assertEqual(module.__name__, absolute_name)
@ -42,8 +42,8 @@ def test_absolute_import_with_package(self):
pkg_name = 'pkg'
pkg_long_name = '{0}.__init__'.format(pkg_name)
name = '{0}.mod'.format(pkg_name)
with support.mock_modules(pkg_long_name, name) as mock:
with support.import_state(meta_path=[mock]):
with util.mock_modules(pkg_long_name, name) as mock:
with util.import_state(meta_path=[mock]):
module = importlib.import_module(name, pkg_name)
self.assertEqual(module.__name__, name)

0
Lib/importlib/test/support.py → Lib/importlib/test/util.py
View file