--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/symbian-qemu-0.9.1-12/python-2.6.1/Lib/test/test_unicode_file.py Fri Jul 31 15:01:17 2009 +0100
@@ -0,0 +1,200 @@
+# 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, TestSkipped, TESTFN_UNICODE
+from test.test_support import TESTFN_ENCODING, TESTFN_UNICODE_UNENCODEABLE
+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 TestSkipped("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 TestSkipped("Cannot find a suiteable filename.")
+
+if TESTFN_ENCODED.decode(TESTFN_ENCODING) != TESTFN_UNICODE:
+ raise TestSkipped("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.failUnless(os.path.exists(filename))
+ self.failUnless(os.path.isfile(filename))
+ self.failUnless(os.access(filename, os.R_OK))
+ self.failUnless(os.path.exists(os.path.abspath(filename)))
+ self.failUnless(os.path.isfile(os.path.abspath(filename)))
+ self.failUnless(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.failUnless(
+ 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.failUnless(base in 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.failUnless(type(filename1)!=type(filename2),
+ "No point checking equivalent filenames of the same type")
+ # stat and lstat should return the same results.
+ self.failUnlessEqual(os.stat(filename1),
+ os.stat(filename2))
+ self.failUnlessEqual(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.failUnless(os.path.isfile(filename1)) # must exist.
+ os.rename(filename1, filename2 + ".new")
+ self.failUnless(os.path.isfile(filename1+".new"))
+ os.rename(filename1 + ".new", filename2)
+ self.failUnless(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.failUnless(not os.path.exists(filename2))
+ shutil.move(filename1 + ".new", filename2)
+ self.failUnless(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.failUnlessEqual(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.failUnless(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.failUnless(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_UNICODE_UNENCODEABLE is not None:
+ self._test_single(TESTFN_UNICODE_UNENCODEABLE)
+
+ 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_UNICODE_UNENCODEABLE is not None:
+ self._do_directory(TESTFN_UNICODE_UNENCODEABLE+ext,
+ TESTFN_UNICODE_UNENCODEABLE+ext,
+ False)
+
+def test_main():
+ run_unittest(__name__)
+
+if __name__ == "__main__":
+ test_main()