diff options
Diffstat (limited to 'lib/python2.7/test/test_unicode_file.py')
| -rw-r--r-- | lib/python2.7/test/test_unicode_file.py | 200 |
1 files changed, 0 insertions, 200 deletions
diff --git a/lib/python2.7/test/test_unicode_file.py b/lib/python2.7/test/test_unicode_file.py deleted file mode 100644 index f04bad3..0000000 --- a/lib/python2.7/test/test_unicode_file.py +++ /dev/null @@ -1,200 +0,0 @@ -# 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() |