Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity

Tests for case-senstivity were not being skipped for darwin when installed on a 

case-sensitive filesystems -- which is not the default case. Along the way also
fixed the skipping of tests when sys.dont_write_bytecode is true.

Closes issue #5442 again.
This commit is contained in:
Brett Cannon 2009-05-11 01:47:11 +00:00
parent cc3b8d6883
commit 1262e7c746
7 changed files with 46 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Lib/importlib/test/extension/test_case_sensitivity.py
View File

@ -20,13 +20,13 @@ class ExtensionModuleCaseSensitivityTest(unittest.TestCase):
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'))

16
Lib/importlib/test/source/test_abc_loader.py
View File

@ -157,10 +157,10 @@ class PyLoaderTests(testing_abc.LoaderTests):
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):
@ -247,16 +247,16 @@ class PyPycLoaderTests(PyLoaderTests):
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()
@ -286,7 +286,7 @@ class SkipWritingBytecodeTests(unittest.TestCase):
"""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')})
@ -307,7 +307,7 @@ class RegeneratedBytecodeTests(unittest.TestCase):
"""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'
@ -323,7 +323,7 @@ class RegeneratedBytecodeTests(unittest.TestCase):
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'

14
Lib/importlib/test/source/test_case_sensitivity.py
View File

@ -36,18 +36,18 @@ class CaseSensitivityTest(unittest.TestCase):
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():

4
Lib/importlib/test/source/test_file_loader.py
View File

@ -127,7 +127,7 @@ class BadBytecodeTest(unittest.TestCase):
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'])
@ -140,7 +140,7 @@ class BadBytecodeTest(unittest.TestCase):
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:

23
Lib/importlib/test/source/util.py
View File

@ -9,32 +9,23 @@ import tempfile
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
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:

15
Lib/importlib/test/util.py
View File

@ -7,16 +7,17 @@ import sys
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_
else:
return unittest.TestCase
else:
return class_

9
Misc/NEWS
View File

@ -19,6 +19,15 @@ Library
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?
================================