Home | History | Annotate | Download | only in test
      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()
    257