AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_genericpath.py

   1 """
   2 Tests common to genericpath, macpath, ntpath and posixpath
   3 """
   4
   5 import unittest
   6 from test import test_support
   7 import os
   8 import genericpath
   9 import sys
  10
  11
  12 def safe_rmdir(dirname):
  13     try:
  14         os.rmdir(dirname)
  15     except OSError:
  16         pass
  17
  18
  19 class GenericTest(unittest.TestCase):
  20     # The path module to be tested
  21     pathmodule = genericpath
  22     common_attributes = ['commonprefix', 'getsize', 'getatime', 'getctime',
  23                          'getmtime', 'exists', 'isdir', 'isfile']
  24     attributes = []
  25
  26     def test_no_argument(self):
  27         for attr in self.common_attributes + self.attributes:
  28             with self.assertRaises(TypeError):
  29                 getattr(self.pathmodule, attr)()
  30                 raise self.fail("{}.{}() did not raise a TypeError"
  31                                 .format(self.pathmodule.__name__, attr))
  32
  33     def test_commonprefix(self):
  34         commonprefix = self.pathmodule.commonprefix
  35         self.assertEqual(
  36             commonprefix([]),
  37             ""
  38         )
  39         self.assertEqual(
  40             commonprefix(["/home/swenson/spam", "/home/swen/spam"]),
  41             "/home/swen"
  42         )
  43         self.assertEqual(
  44             commonprefix(["/home/swen/spam", "/home/swen/eggs"]),
  45             "/home/swen/"
  46         )
  47         self.assertEqual(
  48             commonprefix(["/home/swen/spam", "/home/swen/spam"]),
  49             "/home/swen/spam"
  50         )
  51         self.assertEqual(
  52             commonprefix(["home:swenson:spam", "home:swen:spam"]),
  53             "home:swen"
  54         )
  55         self.assertEqual(
  56             commonprefix([":home:swen:spam", ":home:swen:eggs"]),
  57             ":home:swen:"
  58         )
  59         self.assertEqual(
  60             commonprefix([":home:swen:spam", ":home:swen:spam"]),
  61             ":home:swen:spam"
  62         )
  63
  64         testlist = ['', 'abc', 'Xbcd', 'Xb', 'XY', 'abcd',
  65                     'aXc', 'abd', 'ab', 'aX', 'abcX']
  66         for s1 in testlist:
  67             for s2 in testlist:
  68                 p = commonprefix([s1, s2])
  69                 self.assertTrue(s1.startswith(p))
  70                 self.assertTrue(s2.startswith(p))
  71                 if s1 != s2:
  72                     n = len(p)
  73                     self.assertNotEqual(s1[n:n+1], s2[n:n+1])
  74
  75     def test_getsize(self):
  76         f = open(test_support.TESTFN, "wb")
  77         try:
  78             f.write("foo")
  79             f.close()
  80             self.assertEqual(self.pathmodule.getsize(test_support.TESTFN), 3)
  81         finally:
  82             if not f.closed:
  83                 f.close()
  84             test_support.unlink(test_support.TESTFN)
  85
  86     def test_time(self):
  87         f = open(test_support.TESTFN, "wb")
  88         try:
  89             f.write("foo")
  90             f.close()
  91             f = open(test_support.TESTFN, "ab")
  92             f.write("bar")
  93             f.close()
  94             f = open(test_support.TESTFN, "rb")
  95             d = f.read()
  96             f.close()
  97             self.assertEqual(d, "foobar")
  98
  99             self.assertLessEqual(
 100                 self.pathmodule.getctime(test_support.TESTFN),
 101                 self.pathmodule.getmtime(test_support.TESTFN)
 102             )
 103         finally:
 104             if not f.closed:
 105                 f.close()
 106             test_support.unlink(test_support.TESTFN)
 107
 108     def test_exists(self):
 109         self.assertIs(self.pathmodule.exists(test_support.TESTFN), False)
 110         f = open(test_support.TESTFN, "wb")
 111         try:
 112             f.write("foo")
 113             f.close()
 114             self.assertIs(self.pathmodule.exists(test_support.TESTFN), True)
 115             if not self.pathmodule == genericpath:
 116                 self.assertIs(self.pathmodule.lexists(test_support.TESTFN),
 117                               True)
 118         finally:
 119             if not f.close():
 120                 f.close()
 121             test_support.unlink(test_support.TESTFN)
 122
 123     def test_isdir(self):
 124         self.assertIs(self.pathmodule.isdir(test_support.TESTFN), False)
 125         f = open(test_support.TESTFN, "wb")
 126         try:
 127             f.write("foo")
 128             f.close()
 129             self.assertIs(self.pathmodule.isdir(test_support.TESTFN), False)
 130             os.remove(test_support.TESTFN)
 131             os.mkdir(test_support.TESTFN)
 132             self.assertIs(self.pathmodule.isdir(test_support.TESTFN), True)
 133             os.rmdir(test_support.TESTFN)
 134         finally:
 135             if not f.close():
 136                 f.close()
 137             test_support.unlink(test_support.TESTFN)
 138             safe_rmdir(test_support.TESTFN)
 139
 140     def test_isfile(self):
 141         self.assertIs(self.pathmodule.isfile(test_support.TESTFN), False)
 142         f = open(test_support.TESTFN, "wb")
 143         try:
 144             f.write("foo")
 145             f.close()
 146             self.assertIs(self.pathmodule.isfile(test_support.TESTFN), True)
 147             os.remove(test_support.TESTFN)
 148             os.mkdir(test_support.TESTFN)
 149             self.assertIs(self.pathmodule.isfile(test_support.TESTFN), False)
 150             os.rmdir(test_support.TESTFN)
 151         finally:
 152             if not f.close():
 153                 f.close()
 154             test_support.unlink(test_support.TESTFN)
 155             safe_rmdir(test_support.TESTFN)
 156
 157
 158 # Following TestCase is not supposed to be run from test_genericpath.
 159 # It is inherited by other test modules (macpath, ntpath, posixpath).
 160
 161 class CommonTest(GenericTest):
 162     # The path module to be tested
 163     pathmodule = None
 164     common_attributes = GenericTest.common_attributes + [
 165         # Properties
 166         'curdir', 'pardir', 'extsep', 'sep',
 167         'pathsep', 'defpath', 'altsep', 'devnull',
 168         # Methods
 169         'normcase', 'splitdrive', 'expandvars', 'normpath', 'abspath',
 170         'join', 'split', 'splitext', 'isabs', 'basename', 'dirname',
 171         'lexists', 'islink', 'ismount', 'expanduser', 'normpath', 'realpath',
 172     ]
 173
 174     def test_normcase(self):
 175         # Check that normcase() is idempotent
 176         p = "FoO/./BaR"
 177         p = self.pathmodule.normcase(p)
 178         self.assertEqual(p, self.pathmodule.normcase(p))
 179
 180     def test_splitdrive(self):
 181         # splitdrive for non-NT paths
 182         splitdrive = self.pathmodule.splitdrive
 183         self.assertEqual(splitdrive("/foo/bar"), ("", "/foo/bar"))
 184         self.assertEqual(splitdrive("foo:bar"), ("", "foo:bar"))
 185         self.assertEqual(splitdrive(":foo:bar"), ("", ":foo:bar"))
 186
 187     def test_expandvars(self):
 188         if self.pathmodule.__name__ == 'macpath':
 189             self.skipTest('macpath.expandvars is a stub')
 190         expandvars = self.pathmodule.expandvars
 191         with test_support.EnvironmentVarGuard() as env:
 192             env.clear()
 193             env["foo"] = "bar"
 194             env["{foo"] = "baz1"
 195             env["{foo}"] = "baz2"
 196             self.assertEqual(expandvars("foo"), "foo")
 197             self.assertEqual(expandvars("$foo bar"), "bar bar")
 198             self.assertEqual(expandvars("${foo}bar"), "barbar")
 199             self.assertEqual(expandvars("$[foo]bar"), "$[foo]bar")
 200             self.assertEqual(expandvars("$bar bar"), "$bar bar")
 201             self.assertEqual(expandvars("$?bar"), "$?bar")
 202             self.assertEqual(expandvars("${foo}bar"), "barbar")
 203             self.assertEqual(expandvars("$foo}bar"), "bar}bar")
 204             self.assertEqual(expandvars("${foo"), "${foo")
 205             self.assertEqual(expandvars("${{foo}}"), "baz1}")
 206             self.assertEqual(expandvars("$foo$foo"), "barbar")
 207             self.assertEqual(expandvars("$bar$bar"), "$bar$bar")
 208
 209     def test_abspath(self):
 210         self.assertIn("foo", self.pathmodule.abspath("foo"))
 211
 212         # Abspath returns bytes when the arg is bytes
 213         for path in ('', 'foo', 'f\xf2\xf2', '/foo', 'C:\\'):
 214             self.assertIsInstance(self.pathmodule.abspath(path), str)
 215
 216     def test_realpath(self):
 217         self.assertIn("foo", self.pathmodule.realpath("foo"))
 218
 219     def test_normpath_issue5827(self):
 220         # Make sure normpath preserves unicode
 221         for path in (u'', u'.', u'/', u'\\', u'///foo/.//bar//'):
 222             self.assertIsInstance(self.pathmodule.normpath(path), unicode)
 223
 224     def test_abspath_issue3426(self):
 225         # Check that abspath returns unicode when the arg is unicode
 226         # with both ASCII and non-ASCII cwds.
 227         abspath = self.pathmodule.abspath
 228         for path in (u'', u'fuu', u'f\xf9\xf9', u'/fuu', u'U:\\'):
 229             self.assertIsInstance(abspath(path), unicode)
 230
 231         unicwd = u'\xe7w\xf0'
 232         try:
 233             fsencoding = test_support.TESTFN_ENCODING or "ascii"
 234             unicwd.encode(fsencoding)
 235         except (AttributeError, UnicodeEncodeError):
 236             # FS encoding is probably ASCII
 237             pass
 238         else:
 239             with test_support.temp_cwd(unicwd):
 240                 for path in (u'', u'fuu', u'f\xf9\xf9', u'/fuu', u'U:\\'):
 241                     self.assertIsInstance(abspath(path), unicode)
 242
 243     @unittest.skipIf(sys.platform == 'darwin',
 244         "Mac OS X denies the creation of a directory with an invalid utf8 name")
 245     def test_nonascii_abspath(self):
 246         # Test non-ASCII, non-UTF8 bytes in the path.
 247         with test_support.temp_cwd('\xe7w\xf0'):
 248             self.test_abspath()
 249
 250
 251 def test_main():
 252     test_support.run_unittest(GenericTest)
 253
 254
 255 if __name__=="__main__":
 256     test_main()