* 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.
from importlib import machinery
from .. import abc
-from .. import support
+from .. import util
import sys
import unittest
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):
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)
import importlib
from importlib import machinery
from .. import abc
-from .. import support
+from .. import util
import sys
import types
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)
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)
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):
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'))
def test_main():
- test_support.run_unittest(ExtensionModuleCaseSensitivityTest)
+ support.run_unittest(ExtensionModuleCaseSensitivityTest)
if __name__ == '__main__':
import importlib
from . import test_path_hook
from .. import abc
-from .. import support
+from .. import util
import sys
import unittest
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)]:
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)
+++ /dev/null
-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()
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}
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__']}
(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__'}
(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)
"""
import unittest
-from .. import support
+from .. import util
class Using__package__(unittest.TestCase):
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)
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)
# [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')
"""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
# [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)
# __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']))
"""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):
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')
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'))
-from ..support import import_state, mock_modules, import_
-
+from .. import util
from contextlib import nested
from types import MethodType
import unittest
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):
# [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]
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]
+from .. import util
import sys
import unittest
import importlib
-from .. import support
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():
-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
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)
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 = []
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)
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)
raise ImportError
try:
- import_(to_import)
+ util.import_(to_import)
except ImportError:
pass
def test_path_argument(self):
name = 'total junk'
- with uncache(name):
+ with util.uncache(name):
self.path_argument_test(name)
"""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'])
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)
"""Test relative imports (PEP 328)."""
-
-from ..support import uncache, import_, mock_modules, import_state
-
+from .. import util
import sys
import unittest
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_)
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')
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)
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'))
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)
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__')
{'__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)
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)
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.
'__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)
"""Test case-sensitivity (PEP 235)."""
import importlib
-from .. import support
+from .. import util
from . import util as source_util
import os
import sys
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
import importlib
from .. import abc
-from .. import support
from . import util as source_util
import os
import py_compile
import importlib
from .. import abc
-from .. import support
from . import util as source_util
import imp
import importlib
-from . import util
+from . import util as source_util
import unittest
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'))
import importlib
-from .. import support
from . import util as source_util
import codecs
-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):
import unittest
import importlib
-from . import support
+from . import util
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')
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)
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)
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)
projects / python / commitdiff