From dc1531c5c46fed0b24ed0175b18f8ba6e3762613 Mon Sep 17 00:00:00 2001 From: Florent Xicluna Date: Sat, 6 Mar 2010 18:07:18 +0000 Subject: Create test_genericpath.CommonTest and reuse it to test other path modules. --- Lib/test/test_genericpath.py | 251 +++++++++++++++++++++++++------------------ Lib/test/test_macpath.py | 19 +--- Lib/test/test_ntpath.py | 24 ++--- Lib/test/test_posixpath.py | 196 ++------------------------------- 4 files changed, 165 insertions(+), 325 deletions(-) diff --git a/Lib/test/test_genericpath.py b/Lib/test/test_genericpath.py index 15f12e4..e54dd10 100644 --- a/Lib/test/test_genericpath.py +++ b/Lib/test/test_genericpath.py @@ -1,38 +1,72 @@ +""" +Tests common to genericpath, macpath, ntpath and posixpath +""" + import unittest from test import test_support import os import genericpath -class AllCommonTest(unittest.TestCase): + +def safe_rmdir(dirname): + try: + os.rmdir(dirname) + except OSError: + pass + + +class GenericTest(unittest.TestCase): + # The path module to be tested + path = genericpath + common_attributes = ['commonprefix', 'getsize', 'getatime', 'getctime', + 'getmtime', 'exists', 'isdir', 'isfile'] + attributes = [] + + def test_no_argument(self): + for attr in self.common_attributes + self.attributes: + with self.assertRaises(TypeError): + getattr(self.path, attr)() + raise self.fail("{}.{}() do not raise a TypeError" + .format(self.path.__name__, attr)) def test_commonprefix(self): self.assertEqual( - genericpath.commonprefix([]), + self.path.commonprefix([]), "" ) self.assertEqual( - genericpath.commonprefix(["/home/swenson/spam", "/home/swen/spam"]), + self.path.commonprefix(["/home/swenson/spam", "/home/swen/spam"]), "/home/swen" ) self.assertEqual( - genericpath.commonprefix(["/home/swen/spam", "/home/swen/eggs"]), + self.path.commonprefix(["/home/swen/spam", "/home/swen/eggs"]), "/home/swen/" ) self.assertEqual( - genericpath.commonprefix(["/home/swen/spam", "/home/swen/spam"]), + self.path.commonprefix(["/home/swen/spam", "/home/swen/spam"]), "/home/swen/spam" ) + testlist = ['', 'abc', 'Xbcd', 'Xb', 'XY', 'abcd', 'aXc', 'abd', 'ab', 'aX', 'abcX'] + for s1 in testlist: + for s2 in testlist: + p = self.path.commonprefix([s1, s2]) + self.assertTrue(s1.startswith(p)) + self.assertTrue(s2.startswith(p)) + if s1 != s2: + n = len(p) + self.assertNotEqual(s1[n:n+1], s2[n:n+1]) + def test_getsize(self): f = open(test_support.TESTFN, "wb") try: f.write("foo") f.close() - self.assertEqual(genericpath.getsize(test_support.TESTFN), 3) + self.assertEqual(self.path.getsize(test_support.TESTFN), 3) finally: if not f.closed: f.close() - os.remove(test_support.TESTFN) + test_support.unlink(test_support.TESTFN) def test_time(self): f = open(test_support.TESTFN, "wb") @@ -48,147 +82,150 @@ class AllCommonTest(unittest.TestCase): self.assertEqual(d, "foobar") self.assertLessEqual( - genericpath.getctime(test_support.TESTFN), - genericpath.getmtime(test_support.TESTFN) + self.path.getctime(test_support.TESTFN), + self.path.getmtime(test_support.TESTFN) ) finally: if not f.closed: f.close() - os.remove(test_support.TESTFN) + test_support.unlink(test_support.TESTFN) def test_exists(self): - self.assertIs(genericpath.exists(test_support.TESTFN), False) + self.assertIs(self.path.exists(test_support.TESTFN), False) f = open(test_support.TESTFN, "wb") try: f.write("foo") f.close() - self.assertIs(genericpath.exists(test_support.TESTFN), True) + self.assertIs(self.path.exists(test_support.TESTFN), True) + if not self.path == genericpath: + self.assertIs(self.path.lexists(test_support.TESTFN), True) finally: if not f.close(): f.close() - try: - os.remove(test_support.TESTFN) - except os.error: - pass - - self.assertRaises(TypeError, genericpath.exists) + test_support.unlink(test_support.TESTFN) def test_isdir(self): - self.assertIs(genericpath.isdir(test_support.TESTFN), False) + self.assertIs(self.path.isdir(test_support.TESTFN), False) f = open(test_support.TESTFN, "wb") try: f.write("foo") f.close() - self.assertIs(genericpath.isdir(test_support.TESTFN), False) + self.assertIs(self.path.isdir(test_support.TESTFN), False) os.remove(test_support.TESTFN) os.mkdir(test_support.TESTFN) - self.assertIs(genericpath.isdir(test_support.TESTFN), True) + self.assertIs(self.path.isdir(test_support.TESTFN), True) os.rmdir(test_support.TESTFN) finally: if not f.close(): f.close() - try: - os.remove(test_support.TESTFN) - except os.error: - pass - try: - os.rmdir(test_support.TESTFN) - except os.error: - pass - - self.assertRaises(TypeError, genericpath.isdir) + test_support.unlink(test_support.TESTFN) + safe_rmdir(test_support.TESTFN) def test_isfile(self): - self.assertIs(genericpath.isfile(test_support.TESTFN), False) + self.assertIs(self.path.isfile(test_support.TESTFN), False) f = open(test_support.TESTFN, "wb") try: f.write("foo") f.close() - self.assertIs(genericpath.isfile(test_support.TESTFN), True) + self.assertIs(self.path.isfile(test_support.TESTFN), True) os.remove(test_support.TESTFN) os.mkdir(test_support.TESTFN) - self.assertIs(genericpath.isfile(test_support.TESTFN), False) + self.assertIs(self.path.isfile(test_support.TESTFN), False) os.rmdir(test_support.TESTFN) finally: if not f.close(): f.close() - try: - os.remove(test_support.TESTFN) - except os.error: - pass - try: - os.rmdir(test_support.TESTFN) - except os.error: - pass - - self.assertRaises(TypeError, genericpath.isdir) - - def test_samefile(self): - f = open(test_support.TESTFN + "1", "wb") - try: - f.write("foo") - f.close() - self.assertIs( - genericpath.samefile( - test_support.TESTFN + "1", - test_support.TESTFN + "1" - ), - True - ) - # If we don't have links, assume that os.stat doesn't return resonable - # inode information and thus, that samefile() doesn't work - if hasattr(os, "symlink"): - os.symlink( - test_support.TESTFN + "1", - test_support.TESTFN + "2" - ) - self.assertIs( - genericpath.samefile( - test_support.TESTFN + "1", - test_support.TESTFN + "2" - ), - True - ) - os.remove(test_support.TESTFN + "2") - f = open(test_support.TESTFN + "2", "wb") - f.write("bar") - f.close() - self.assertIs( - genericpath.samefile( - test_support.TESTFN + "1", - test_support.TESTFN + "2" - ), - False - ) - finally: - if not f.close(): - f.close() - try: - os.remove(test_support.TESTFN + "1") - except os.error: - pass - try: - os.remove(test_support.TESTFN + "2") - except os.error: - pass - - self.assertRaises(TypeError, genericpath.samefile) - - -# XXX at some point this should probably go in some class that contains common -# tests for all test_*path modules. -def _issue3426(self, cwd, abspath): - # Issue 3426: check that abspath retuns unicode when the arg is unicode - # and str when it's str, with both ASCII and non-ASCII cwds - with test_support.temp_cwd(cwd): + test_support.unlink(test_support.TESTFN) + safe_rmdir(test_support.TESTFN) + + +class CommonTest(GenericTest): + # The path module to be tested + path = None + common_attributes = GenericTest.common_attributes + [ + # Properties + 'curdir', 'pardir', 'extsep', 'sep', + 'pathsep', 'defpath', 'altsep', 'devnull', + # Methods + 'normcase', 'splitdrive', 'expandvars', 'normpath', 'abspath', + 'join', 'split', 'splitext', 'isabs', 'basename', 'dirname', + 'lexists', 'islink', 'ismount', 'expanduser', 'normpath', 'realpath', + ] + + def test_normcase(self): + # Check that normcase() is idempotent + p = "FoO/./BaR" + p = self.path.normcase(p) + self.assertEqual(p, self.path.normcase(p)) + + def test_splitdrive(self): + # splitdrive for non-NT paths + self.assertEqual(self.path.splitdrive("/foo/bar"), ("", "/foo/bar")) + self.assertEqual(self.path.splitdrive("foo:bar"), ('', 'foo:bar')) + self.assertEqual(self.path.splitdrive(":foo:bar"), ('', ':foo:bar')) + + def test_expandvars(self): + if self.path.__name__ == 'macpath': + raise unittest.SkipTest('macpath.expandvars is a stub') + with test_support.EnvironmentVarGuard() as env: + env.clear() + env["foo"] = "bar" + env["{foo"] = "baz1" + env["{foo}"] = "baz2" + self.assertEqual(self.path.expandvars("foo"), "foo") + self.assertEqual(self.path.expandvars("$foo bar"), "bar bar") + self.assertEqual(self.path.expandvars("${foo}bar"), "barbar") + self.assertEqual(self.path.expandvars("$[foo]bar"), "$[foo]bar") + self.assertEqual(self.path.expandvars("$bar bar"), "$bar bar") + self.assertEqual(self.path.expandvars("$?bar"), "$?bar") + self.assertEqual(self.path.expandvars("${foo}bar"), "barbar") + self.assertEqual(self.path.expandvars("$foo}bar"), "bar}bar") + self.assertEqual(self.path.expandvars("${foo"), "${foo") + self.assertEqual(self.path.expandvars("${{foo}}"), "baz1}") + self.assertEqual(self.path.expandvars("$foo$foo"), "barbar") + self.assertEqual(self.path.expandvars("$bar$bar"), "$bar$bar") + + def test_abspath(self): + self.assertIn("foo", self.path.abspath("foo")) + + # Abspath returns bytes when the arg is bytes for path in ('', 'foo', 'f\xf2\xf2', '/foo', 'C:\\'): - self.assertIsInstance(abspath(path), str) - for upath in (u'', u'fuu', u'f\xf9\xf9', u'/fuu', u'U:\\'): - self.assertIsInstance(abspath(upath), unicode) + self.assertIsInstance(self.path.abspath(path), str) + + def test_realpath(self): + self.assertIn("foo", self.path.realpath("foo")) + + def test_normpath_issue5827(self): + # Make sure normpath preserves unicode + for path in (u'', u'.', u'/', u'\\', u'///foo/.//bar//'): + self.assertIsInstance(self.path.normpath(path), unicode) + + def test_abspath_issue3426(self): + # Check that abspath returns unicode when the arg is unicode + # with both ASCII and non-ASCII cwds. + for path in (u'', u'fuu', u'f\xf9\xf9', u'/fuu', u'U:\\'): + self.assertIsInstance(self.path.abspath(path), unicode) + + unicwd = u'\xe7w\xf0' + try: + fsencoding = test_support.TESTFN_ENCODING or "ascii" + unicwd.encode(fsencoding) + except (AttributeError, UnicodeEncodeError): + # FS encoding is probably ASCII + pass + else: + with test_support.temp_cwd(unicwd): + for path in (u'', u'fuu', u'f\xf9\xf9', u'/fuu', u'U:\\'): + self.assertIsInstance(self.path.abspath(path), unicode) + + # Test non-ASCII, non-UTF8 bytes in the path. + with test_support.temp_cwd('\xe7w\xf0'): + self.test_abspath() def test_main(): - test_support.run_unittest(AllCommonTest) + test_support.run_unittest(GenericTest) + if __name__=="__main__": test_main() diff --git a/Lib/test/test_macpath.py b/Lib/test/test_macpath.py index 564def7..e81fba2 100644 --- a/Lib/test/test_macpath.py +++ b/Lib/test/test_macpath.py @@ -1,7 +1,6 @@ import macpath -from test import test_support +from test import test_support, test_genericpath import unittest -import test_genericpath class MacPathTestCase(unittest.TestCase): @@ -9,12 +8,6 @@ class MacPathTestCase(unittest.TestCase): def test_abspath(self): self.assertEqual(macpath.abspath("xx:yy"), "xx:yy") - def test_abspath_with_ascii_cwd(self): - test_genericpath._issue3426(self, u'cwd', macpath.abspath) - - def test_abspath_with_nonascii_cwd(self): - test_genericpath._issue3426(self, u'\xe7w\xf0', macpath.abspath) - def test_isabs(self): isabs = macpath.isabs self.assertTrue(isabs("xx:yy")) @@ -46,11 +39,6 @@ class MacPathTestCase(unittest.TestCase): self.assertEqual(split(":conky:mountpoint:"), (':conky:mountpoint', '')) - def test_splitdrive(self): - splitdrive = macpath.splitdrive - self.assertEqual(splitdrive("foo:bar"), ('', 'foo:bar')) - self.assertEqual(splitdrive(":foo:bar"), ('', ':foo:bar')) - def test_splitext(self): splitext = macpath.splitext self.assertEqual(splitext(":foo.ext"), (':foo', '.ext')) @@ -67,9 +55,12 @@ class MacPathTestCase(unittest.TestCase): self.assertIsInstance(macpath.normpath(path), unicode, 'normpath() returned str instead of unicode') +class MacCommonTest(test_genericpath.CommonTest): + path = macpath + def test_main(): - test_support.run_unittest(MacPathTestCase) + test_support.run_unittest(MacPathTestCase, MacCommonTest) if __name__ == "__main__": diff --git a/Lib/test/test_ntpath.py b/Lib/test/test_ntpath.py index f5bc952..d8c576a 100644 --- a/Lib/test/test_ntpath.py +++ b/Lib/test/test_ntpath.py @@ -1,7 +1,7 @@ import ntpath import os from test.test_support import TestFailed -import test.test_support as test_support +from test import test_support, test_genericpath import unittest @@ -123,11 +123,6 @@ class TestNtpath(unittest.TestCase): tester("ntpath.normpath('C:////a/b')", r'C:\a\b') tester("ntpath.normpath('//machine/share//a/b')", r'\\machine\share\a\b') - # Issue 5827: Make sure normpath preserves unicode - for path in (u'', u'.', u'/', u'\\', u'///foo/.//bar//'): - self.assertIsInstance(ntpath.normpath(path), unicode, - 'normpath() returned str instead of unicode') - def test_expandvars(self): with test_support.EnvironmentVarGuard() as env: env.clear() @@ -169,16 +164,6 @@ class TestNtpath(unittest.TestCase): else: tester('ntpath.abspath("C:\\")', "C:\\") - # Issue 3426: check that abspath retuns unicode when the arg is - # unicode and str when it's str, with both ASCII and non-ASCII cwds - for cwd in (u'cwd', u'\xe7w\xf0'): - with test_support.temp_cwd(cwd): - for path in ('', 'foo', 'f\xf2\xf2', '/foo', 'C:\\'): - self.assertIsInstance(ntpath.abspath(path), str) - for upath in (u'', u'fuu', u'f\xf9\xf9', u'/fuu', u'U:\\'): - self.assertIsInstance(ntpath.abspath(upath), unicode) - - def test_relpath(self): currentdir = os.path.split(os.getcwd())[-1] tester('ntpath.relpath("a")', 'a') @@ -192,8 +177,13 @@ class TestNtpath(unittest.TestCase): tester('ntpath.relpath("a", "a")', '.') +class NtCommonTest(test_genericpath.CommonTest): + path = ntpath + attributes = ['relpath', 'splitunc'] + + def test_main(): - test_support.run_unittest(TestNtpath) + test_support.run_unittest(TestNtpath, NtCommonTest) if __name__ == "__main__": diff --git a/Lib/test/test_posixpath.py b/Lib/test/test_posixpath.py index 23a88e3..3af646f 100644 --- a/Lib/test/test_posixpath.py +++ b/Lib/test/test_posixpath.py @@ -1,7 +1,5 @@ import unittest -from test import test_support - -import test_genericpath +from test import test_support, test_genericpath import posixpath, os from posixpath import realpath, abspath, dirname, basename @@ -27,26 +25,11 @@ class PosixPathTest(unittest.TestCase): test_support.unlink(test_support.TESTFN + suffix) safe_rmdir(test_support.TESTFN + suffix) - def test_normcase(self): - # Check that normcase() is idempotent - p = "FoO/./BaR" - p = posixpath.normcase(p) - self.assertEqual(p, posixpath.normcase(p)) - - self.assertRaises(TypeError, posixpath.normcase) - def test_join(self): self.assertEqual(posixpath.join("/foo", "bar", "/bar", "baz"), "/bar/baz") self.assertEqual(posixpath.join("/foo", "bar", "baz"), "/foo/bar/baz") self.assertEqual(posixpath.join("/foo/", "bar/", "baz/"), "/foo/bar/baz/") - self.assertRaises(TypeError, posixpath.join) - - def test_splitdrive(self): - self.assertEqual(posixpath.splitdrive("/foo/bar"), ("", "/foo/bar")) - - self.assertRaises(TypeError, posixpath.splitdrive) - def test_split(self): self.assertEqual(posixpath.split("/foo/bar"), ("/foo", "bar")) self.assertEqual(posixpath.split("/"), ("/", "")) @@ -54,8 +37,6 @@ class PosixPathTest(unittest.TestCase): self.assertEqual(posixpath.split("////foo"), ("////", "foo")) self.assertEqual(posixpath.split("//foo//bar"), ("//foo", "bar")) - self.assertRaises(TypeError, posixpath.split) - def splitextTest(self, path, filename, ext): self.assertEqual(posixpath.splitext(path), (filename, ext)) self.assertEqual(posixpath.splitext("/" + path), ("/" + filename, ext)) @@ -77,7 +58,6 @@ class PosixPathTest(unittest.TestCase): self.splitextTest("..", "..", "") self.splitextTest("........", "........", "") self.splitextTest("", "", "") - self.assertRaises(TypeError, posixpath.splitext) def test_isabs(self): self.assertIs(posixpath.isabs(""), False) @@ -86,8 +66,6 @@ class PosixPathTest(unittest.TestCase): self.assertIs(posixpath.isabs("/foo/bar"), True) self.assertIs(posixpath.isabs("foo/bar"), False) - self.assertRaises(TypeError, posixpath.isabs) - def test_basename(self): self.assertEqual(posixpath.basename("/foo/bar"), "bar") self.assertEqual(posixpath.basename("/"), "") @@ -95,8 +73,6 @@ class PosixPathTest(unittest.TestCase): self.assertEqual(posixpath.basename("////foo"), "foo") self.assertEqual(posixpath.basename("//foo//bar"), "bar") - self.assertRaises(TypeError, posixpath.basename) - def test_dirname(self): self.assertEqual(posixpath.dirname("/foo/bar"), "/foo") self.assertEqual(posixpath.dirname("/"), "/") @@ -104,67 +80,6 @@ class PosixPathTest(unittest.TestCase): self.assertEqual(posixpath.dirname("////foo"), "////") self.assertEqual(posixpath.dirname("//foo//bar"), "//foo") - self.assertRaises(TypeError, posixpath.dirname) - - def test_commonprefix(self): - self.assertEqual( - posixpath.commonprefix([]), - "" - ) - self.assertEqual( - posixpath.commonprefix(["/home/swenson/spam", "/home/swen/spam"]), - "/home/swen" - ) - self.assertEqual( - posixpath.commonprefix(["/home/swen/spam", "/home/swen/eggs"]), - "/home/swen/" - ) - self.assertEqual( - posixpath.commonprefix(["/home/swen/spam", "/home/swen/spam"]), - "/home/swen/spam" - ) - - testlist = ['', 'abc', 'Xbcd', 'Xb', 'XY', 'abcd', 'aXc', 'abd', 'ab', 'aX', 'abcX'] - for s1 in testlist: - for s2 in testlist: - p = posixpath.commonprefix([s1, s2]) - self.assertTrue(s1.startswith(p)) - self.assertTrue(s2.startswith(p)) - if s1 != s2: - n = len(p) - self.assertNotEqual(s1[n:n+1], s2[n:n+1]) - - def test_getsize(self): - f = open(test_support.TESTFN, "wb") - try: - f.write("foo") - f.close() - self.assertEqual(posixpath.getsize(test_support.TESTFN), 3) - finally: - if not f.closed: - f.close() - - def test_time(self): - f = open(test_support.TESTFN, "wb") - try: - f.write("foo") - f.close() - f = open(test_support.TESTFN, "ab") - f.write("bar") - f.close() - f = open(test_support.TESTFN, "rb") - d = f.read() - f.close() - self.assertEqual(d, "foobar") - - self.assertLessEqual( - posixpath.getctime(test_support.TESTFN), - posixpath.getmtime(test_support.TESTFN) - ) - finally: - if not f.closed: - f.close() - def test_islink(self): self.assertIs(posixpath.islink(test_support.TESTFN + "1"), False) f = open(test_support.TESTFN + "1", "wb") @@ -183,56 +98,6 @@ class PosixPathTest(unittest.TestCase): if not f.close(): f.close() - self.assertRaises(TypeError, posixpath.islink) - - def test_exists(self): - self.assertIs(posixpath.exists(test_support.TESTFN), False) - f = open(test_support.TESTFN, "wb") - try: - f.write("foo") - f.close() - self.assertIs(posixpath.exists(test_support.TESTFN), True) - self.assertIs(posixpath.lexists(test_support.TESTFN), True) - finally: - if not f.close(): - f.close() - - self.assertRaises(TypeError, posixpath.exists) - - def test_isdir(self): - self.assertIs(posixpath.isdir(test_support.TESTFN), False) - f = open(test_support.TESTFN, "wb") - try: - f.write("foo") - f.close() - self.assertIs(posixpath.isdir(test_support.TESTFN), False) - os.remove(test_support.TESTFN) - os.mkdir(test_support.TESTFN) - self.assertIs(posixpath.isdir(test_support.TESTFN), True) - os.rmdir(test_support.TESTFN) - finally: - if not f.close(): - f.close() - - self.assertRaises(TypeError, posixpath.isdir) - - def test_isfile(self): - self.assertIs(posixpath.isfile(test_support.TESTFN), False) - f = open(test_support.TESTFN, "wb") - try: - f.write("foo") - f.close() - self.assertIs(posixpath.isfile(test_support.TESTFN), True) - os.remove(test_support.TESTFN) - os.mkdir(test_support.TESTFN) - self.assertIs(posixpath.isfile(test_support.TESTFN), False) - os.rmdir(test_support.TESTFN) - finally: - if not f.close(): - f.close() - - self.assertRaises(TypeError, posixpath.isdir) - def test_samefile(self): f = open(test_support.TESTFN + "1", "wb") try: @@ -274,8 +139,6 @@ class PosixPathTest(unittest.TestCase): if not f.close(): f.close() - self.assertRaises(TypeError, posixpath.samefile) - def test_samestat(self): f = open(test_support.TESTFN + "1", "wb") try: @@ -315,13 +178,9 @@ class PosixPathTest(unittest.TestCase): if not f.close(): f.close() - self.assertRaises(TypeError, posixpath.samestat) - def test_ismount(self): self.assertIs(posixpath.ismount("/"), True) - self.assertRaises(TypeError, posixpath.ismount) - def test_expanduser(self): self.assertEqual(posixpath.expanduser("foo"), "foo") try: @@ -343,29 +202,6 @@ class PosixPathTest(unittest.TestCase): env['HOME'] = '/' self.assertEqual(posixpath.expanduser("~"), "/") - self.assertRaises(TypeError, posixpath.expanduser) - - def test_expandvars(self): - with test_support.EnvironmentVarGuard() as env: - env.clear() - env["foo"] = "bar" - env["{foo"] = "baz1" - env["{foo}"] = "baz2" - self.assertEqual(posixpath.expandvars("foo"), "foo") - self.assertEqual(posixpath.expandvars("$foo bar"), "bar bar") - self.assertEqual(posixpath.expandvars("${foo}bar"), "barbar") - self.assertEqual(posixpath.expandvars("$[foo]bar"), "$[foo]bar") - self.assertEqual(posixpath.expandvars("$bar bar"), "$bar bar") - self.assertEqual(posixpath.expandvars("$?bar"), "$?bar") - self.assertEqual(posixpath.expandvars("${foo}bar"), "barbar") - self.assertEqual(posixpath.expandvars("$foo}bar"), "bar}bar") - self.assertEqual(posixpath.expandvars("${foo"), "${foo") - self.assertEqual(posixpath.expandvars("${{foo}}"), "baz1}") - self.assertEqual(posixpath.expandvars("$foo$foo"), "barbar") - self.assertEqual(posixpath.expandvars("$bar$bar"), "$bar$bar") - - self.assertRaises(TypeError, posixpath.expandvars) - def test_normpath(self): self.assertEqual(posixpath.normpath(""), ".") self.assertEqual(posixpath.normpath("/"), "/") @@ -375,27 +211,6 @@ class PosixPathTest(unittest.TestCase): self.assertEqual(posixpath.normpath("///foo/.//bar//.//..//.//baz"), "/foo/baz") self.assertEqual(posixpath.normpath("///..//./foo/.//bar"), "/foo/bar") - # Issue 5827: Make sure normpath preserves unicode - for path in (u'', u'.', u'/', u'\\', u'///foo/.//bar//'): - self.assertIsInstance(posixpath.normpath(path), unicode, - 'normpath() returned str instead of unicode') - - self.assertRaises(TypeError, posixpath.normpath) - - def test_abspath(self): - self.assertIn("foo", posixpath.abspath("foo")) - self.assertRaises(TypeError, posixpath.abspath) - - def test_abspath_with_ascii_cwd(self): - test_genericpath._issue3426(self, u'cwd', posixpath.abspath) - - def test_abspath_with_nonascii_cwd(self): - test_genericpath._issue3426(self, u'\xe7w\xf0', posixpath.abspath) - - def test_realpath(self): - self.assertIn("foo", realpath("foo")) - self.assertRaises(TypeError, posixpath.realpath) - if hasattr(os, "symlink"): def test_realpath_basic(self): # Basic operation. @@ -510,8 +325,15 @@ class PosixPathTest(unittest.TestCase): finally: os.getcwd = real_getcwd + +class PosixCommonTest(test_genericpath.CommonTest): + path = posixpath + attributes = ['relpath', 'samefile', 'sameopenfile', 'samestat'] + + def test_main(): - test_support.run_unittest(PosixPathTest) + test_support.run_unittest(PosixPathTest, PosixCommonTest) + if __name__=="__main__": test_main() -- cgit v0.12