# Test some Unicode file name semantics | |
# We dont test many operations on files other than | |
# that their names can be used with Unicode characters. | |
import os, glob, time, shutil | |
import unicodedata | |
import unittest | |
from test.test_support import run_unittest, TESTFN_UNICODE | |
from test.test_support import TESTFN_ENCODING, TESTFN_UNENCODABLE | |
try: | |
TESTFN_ENCODED = TESTFN_UNICODE.encode(TESTFN_ENCODING) | |
except (UnicodeError, TypeError): | |
# Either the file system encoding is None, or the file name | |
# cannot be encoded in the file system encoding. | |
raise unittest.SkipTest("No Unicode filesystem semantics on this platform.") | |
if TESTFN_ENCODED.decode(TESTFN_ENCODING) != TESTFN_UNICODE: | |
# The file system encoding does not support Latin-1 | |
# (which test_support assumes), so try the file system | |
# encoding instead. | |
import sys | |
try: | |
TESTFN_UNICODE = unicode("@test-\xe0\xf2", sys.getfilesystemencoding()) | |
TESTFN_ENCODED = TESTFN_UNICODE.encode(TESTFN_ENCODING) | |
if '?' in TESTFN_ENCODED: | |
# MBCS will not report the error properly | |
raise UnicodeError, "mbcs encoding problem" | |
except (UnicodeError, TypeError): | |
raise unittest.SkipTest("Cannot find a suiteable filename.") | |
if TESTFN_ENCODED.decode(TESTFN_ENCODING) != TESTFN_UNICODE: | |
raise unittest.SkipTest("Cannot find a suitable filename.") | |
def remove_if_exists(filename): | |
if os.path.exists(filename): | |
os.unlink(filename) | |
class TestUnicodeFiles(unittest.TestCase): | |
# The 'do_' functions are the actual tests. They generally assume the | |
# file already exists etc. | |
# Do all the tests we can given only a single filename. The file should | |
# exist. | |
def _do_single(self, filename): | |
self.assertTrue(os.path.exists(filename)) | |
self.assertTrue(os.path.isfile(filename)) | |
self.assertTrue(os.access(filename, os.R_OK)) | |
self.assertTrue(os.path.exists(os.path.abspath(filename))) | |
self.assertTrue(os.path.isfile(os.path.abspath(filename))) | |
self.assertTrue(os.access(os.path.abspath(filename), os.R_OK)) | |
os.chmod(filename, 0777) | |
os.utime(filename, None) | |
os.utime(filename, (time.time(), time.time())) | |
# Copy/rename etc tests using the same filename | |
self._do_copyish(filename, filename) | |
# Filename should appear in glob output | |
self.assertTrue( | |
os.path.abspath(filename)==os.path.abspath(glob.glob(filename)[0])) | |
# basename should appear in listdir. | |
path, base = os.path.split(os.path.abspath(filename)) | |
if isinstance(base, str): | |
base = base.decode(TESTFN_ENCODING) | |
file_list = os.listdir(path) | |
# listdir() with a unicode arg may or may not return Unicode | |
# objects, depending on the platform. | |
if file_list and isinstance(file_list[0], str): | |
file_list = [f.decode(TESTFN_ENCODING) for f in file_list] | |
# Normalize the unicode strings, as round-tripping the name via the OS | |
# may return a different (but equivalent) value. | |
base = unicodedata.normalize("NFD", base) | |
file_list = [unicodedata.normalize("NFD", f) for f in file_list] | |
self.assertIn(base, file_list) | |
# Do as many "equivalancy' tests as we can - ie, check that although we | |
# have different types for the filename, they refer to the same file. | |
def _do_equivalent(self, filename1, filename2): | |
# Note we only check "filename1 against filename2" - we don't bother | |
# checking "filename2 against 1", as we assume we are called again with | |
# the args reversed. | |
self.assertTrue(type(filename1)!=type(filename2), | |
"No point checking equivalent filenames of the same type") | |
# stat and lstat should return the same results. | |
self.assertEqual(os.stat(filename1), | |
os.stat(filename2)) | |
self.assertEqual(os.lstat(filename1), | |
os.lstat(filename2)) | |
# Copy/rename etc tests using equivalent filename | |
self._do_copyish(filename1, filename2) | |
# Tests that copy, move, etc one file to another. | |
def _do_copyish(self, filename1, filename2): | |
# Should be able to rename the file using either name. | |
self.assertTrue(os.path.isfile(filename1)) # must exist. | |
os.rename(filename1, filename2 + ".new") | |
self.assertTrue(os.path.isfile(filename1+".new")) | |
os.rename(filename1 + ".new", filename2) | |
self.assertTrue(os.path.isfile(filename2)) | |
shutil.copy(filename1, filename2 + ".new") | |
os.unlink(filename1 + ".new") # remove using equiv name. | |
# And a couple of moves, one using each name. | |
shutil.move(filename1, filename2 + ".new") | |
self.assertTrue(not os.path.exists(filename2)) | |
shutil.move(filename1 + ".new", filename2) | |
self.assertTrue(os.path.exists(filename1)) | |
# Note - due to the implementation of shutil.move, | |
# it tries a rename first. This only fails on Windows when on | |
# different file systems - and this test can't ensure that. | |
# So we test the shutil.copy2 function, which is the thing most | |
# likely to fail. | |
shutil.copy2(filename1, filename2 + ".new") | |
os.unlink(filename1 + ".new") | |
def _do_directory(self, make_name, chdir_name, encoded): | |
cwd = os.getcwd() | |
if os.path.isdir(make_name): | |
os.rmdir(make_name) | |
os.mkdir(make_name) | |
try: | |
os.chdir(chdir_name) | |
try: | |
if not encoded: | |
cwd_result = os.getcwdu() | |
name_result = make_name | |
else: | |
cwd_result = os.getcwd().decode(TESTFN_ENCODING) | |
name_result = make_name.decode(TESTFN_ENCODING) | |
cwd_result = unicodedata.normalize("NFD", cwd_result) | |
name_result = unicodedata.normalize("NFD", name_result) | |
self.assertEqual(os.path.basename(cwd_result),name_result) | |
finally: | |
os.chdir(cwd) | |
finally: | |
os.rmdir(make_name) | |
# The '_test' functions 'entry points with params' - ie, what the | |
# top-level 'test' functions would be if they could take params | |
def _test_single(self, filename): | |
remove_if_exists(filename) | |
f = file(filename, "w") | |
f.close() | |
try: | |
self._do_single(filename) | |
finally: | |
os.unlink(filename) | |
self.assertTrue(not os.path.exists(filename)) | |
# and again with os.open. | |
f = os.open(filename, os.O_CREAT) | |
os.close(f) | |
try: | |
self._do_single(filename) | |
finally: | |
os.unlink(filename) | |
def _test_equivalent(self, filename1, filename2): | |
remove_if_exists(filename1) | |
self.assertTrue(not os.path.exists(filename2)) | |
f = file(filename1, "w") | |
f.close() | |
try: | |
self._do_equivalent(filename1, filename2) | |
finally: | |
os.unlink(filename1) | |
# The 'test' functions are unittest entry points, and simply call our | |
# _test functions with each of the filename combinations we wish to test | |
def test_single_files(self): | |
self._test_single(TESTFN_ENCODED) | |
self._test_single(TESTFN_UNICODE) | |
if TESTFN_UNENCODABLE is not None: | |
self._test_single(TESTFN_UNENCODABLE) | |
def test_equivalent_files(self): | |
self._test_equivalent(TESTFN_ENCODED, TESTFN_UNICODE) | |
self._test_equivalent(TESTFN_UNICODE, TESTFN_ENCODED) | |
def test_directories(self): | |
# For all 'equivalent' combinations: | |
# Make dir with encoded, chdir with unicode, checkdir with encoded | |
# (or unicode/encoded/unicode, etc | |
ext = ".dir" | |
self._do_directory(TESTFN_ENCODED+ext, TESTFN_ENCODED+ext, True) | |
self._do_directory(TESTFN_ENCODED+ext, TESTFN_UNICODE+ext, True) | |
self._do_directory(TESTFN_UNICODE+ext, TESTFN_ENCODED+ext, False) | |
self._do_directory(TESTFN_UNICODE+ext, TESTFN_UNICODE+ext, False) | |
# Our directory name that can't use a non-unicode name. | |
if TESTFN_UNENCODABLE is not None: | |
self._do_directory(TESTFN_UNENCODABLE+ext, | |
TESTFN_UNENCODABLE+ext, | |
False) | |
def test_main(): | |
run_unittest(__name__) | |
if __name__ == "__main__": | |
test_main() |