with support.EnvironmentVarGuard() as env:
env.unset('PYTHONCASEOK')
loader = self.find_module()
- self.assert_(loader is None)
+ self.assertIsNone(loader)
def test_case_insensitivity(self):
with support.EnvironmentVarGuard() as env:
env.set('PYTHONCASEOK', '1')
loader = self.find_module()
- self.assert_(hasattr(loader, 'load_module'))
+ self.assertTrue(hasattr(loader, 'load_module'))
mock = self.mocker({name: path})
with util.uncache(name):
module = mock.load_module(name)
- self.assert_(name in sys.modules)
+ self.assertIn(name, sys.modules)
self.eq_attrs(module, __name__=name, __file__=path, __package__='pkg',
__loader__=mock)
- self.assert_(not hasattr(module, '__path__'))
+ self.assertFalse(hasattr(module, '__path__'))
return mock, name
def test_module_reuse(self):
mocker = PyPycLoaderMock
- @source_util.writes_bytecode
+ @source_util.writes_bytecode_files
def verify_bytecode(self, mock, name):
assert name in mock.module_paths
- self.assert_(name in mock.module_bytecode)
+ self.assertIn(name, mock.module_bytecode)
magic = mock.module_bytecode[name][:4]
self.assertEqual(magic, imp.get_magic())
mtime = importlib._r_long(mock.module_bytecode[name][4:8])
self.assertEqual(mtime, 1)
bc = mock.module_bytecode[name][8:]
-
+ self.assertEqual(bc, mock.compile_bc(name))
def test_module(self):
mock, name = super().test_module()
"""Test that bytecode is properly handled based on
sys.dont_write_bytecode."""
- @source_util.writes_bytecode
+ @source_util.writes_bytecode_files
def run_test(self, dont_write_bytecode):
name = 'mod'
mock = PyPycLoaderMock({name: os.path.join('path', 'to', 'mod')})
"""Test that bytecode is regenerated as expected."""
- @source_util.writes_bytecode
+ @source_util.writes_bytecode_files
def test_different_magic(self):
# A different magic number should lead to new bytecode.
name = 'mod'
magic = mock.module_bytecode[name][:4]
self.assertEqual(magic, imp.get_magic())
- @source_util.writes_bytecode
+ @source_util.writes_bytecode_files
def test_old_mtime(self):
# Bytecode with an older mtime should be regenerated.
name = 'mod'
with test_support.EnvironmentVarGuard() as env:
env.unset('PYTHONCASEOK')
sensitive, insensitive = self.sensitivity_test()
- self.assert_(hasattr(sensitive, 'load_module'))
- self.assert_(self.name in sensitive._base_path)
- self.assert_(insensitive is None)
+ self.assertTrue(hasattr(sensitive, 'load_module'))
+ self.assertIn(self.name, sensitive._base_path)
+ self.assertIsNone(insensitive)
def test_insensitive(self):
with test_support.EnvironmentVarGuard() as env:
env.set('PYTHONCASEOK', '1')
sensitive, insensitive = self.sensitivity_test()
- self.assert_(hasattr(sensitive, 'load_module'))
- self.assert_(self.name in sensitive._base_path)
- self.assert_(hasattr(insensitive, 'load_module'))
- self.assert_(self.name in insensitive._base_path)
+ self.assertTrue(hasattr(sensitive, 'load_module'))
+ self.assertIn(self.name, sensitive._base_path)
+ self.assertTrue(hasattr(insensitive, 'load_module'))
+ self.assertIn(self.name, insensitive._base_path)
def test_main():
self.assert_(module_name in sys.modules)
# [bad magic]
- @source_util.writes_bytecode
+ @source_util.writes_bytecode_files
def test_bad_magic(self):
with source_util.create_modules('_temp') as mapping:
py_compile.compile(mapping['_temp'])
self.assertEqual(bytecode_file.read(4), imp.get_magic())
# [bad timestamp]
- @source_util.writes_bytecode
+ @source_util.writes_bytecode_files
def test_bad_bytecode(self):
zeros = b'\x00\x00\x00\x00'
with source_util.create_modules('_temp') as mapping:
from test import support
-def writes_bytecode(fxn):
- """Decorator to protect sys.dont_write_bytecode from mutation."""
+def writes_bytecode_files(fxn):
+ """Decorator to protect sys.dont_write_bytecode from mutation and to skip
+ tests that require it to be set to False."""
+ if sys.dont_write_bytecode:
+ return lambda *args, **kwargs: None
@functools.wraps(fxn)
def wrapper(*args, **kwargs):
original = sys.dont_write_bytecode
sys.dont_write_bytecode = False
- to_return = fxn(*args, **kwargs)
- sys.dont_write_bytecode = original
+ try:
+ to_return = fxn(*args, **kwargs)
+ finally:
+ sys.dont_write_bytecode = original
return to_return
return wrapper
-def writes_bytecode_files(fxn):
- """Decorator that returns the function if writing bytecode is enabled, else
- a stub function that accepts anything and simply returns None."""
- if sys.dont_write_bytecode:
- return lambda *args, **kwargs: None
- else:
- @functools.wraps(fxn)
- def wrapper(*args, **kwargs):
- to_return = fxn(*args, **kwargs)
- sys.dont_write_bytecode = False
- return to_return
- return wrapper
-
-
def bytecode_path(source_path):
for suffix, _, type_ in imp.get_suffixes():
if type_ == imp.PY_COMPILED:
def case_insensitive_tests(class_):
- """Class decorator that nullifies tests that require a case-insensitive
+ """Class decorator that nullifies tests requiring a case-insensitive
file system."""
- if sys.platform not in ('win32', 'darwin', 'cygwin'):
- original_name = os.listdir('.')[0]
- if original_name.upper() != original_name:
- changed_name = original_name.upper()
- else:
- changed_name = original_name.lower()
+ # Windows is the only OS that is *always* case-insensitive
+ # (OS X *can* be case-sensitive).
+ if sys.platform not in ('win32', 'cygwin'):
+ changed_name = __file__.upper()
+ if changed_name == __file__:
+ changed_name = __file__.lower()
if os.path.exists(changed_name):
return class_
- return unittest.TestCase
+ else:
+ return unittest.TestCase
else:
return class_
now it does. This also means getfp method now returns the real fp.
+Tests
+-----
+
+- Issue 5442: Tests for importlib were not properly skipping case-sensitivity
+ tests on darwin even when the OS was installed on a case-sensitive
+ filesystem. Also fixed tests that should not be run when
+ sys.dont_write_bytecode is true.
+
+
What's New in Python 3.1 beta 1?
================================
projects / python / commitdiff