• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1"""
2Tests common to genericpath, macpath, ntpath and posixpath
3"""
4
5import unittest
6from test import test_support
7import os
8import genericpath
9import sys
10
11
12def safe_rmdir(dirname):
13    try:
14        os.rmdir(dirname)
15    except OSError:
16        pass
17
18
19class 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
161class 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"), "bar}bar")
203            self.assertEqual(expandvars("${foo"), "${foo")
204            self.assertEqual(expandvars("${{foo}}"), "baz1}")
205            self.assertEqual(expandvars("$foo$foo"), "barbar")
206            self.assertEqual(expandvars("$bar$bar"), "$bar$bar")
207
208    @unittest.skipUnless(test_support.FS_NONASCII, 'need test_support.FS_NONASCII')
209    def test_expandvars_nonascii(self):
210        if self.pathmodule.__name__ == 'macpath':
211            self.skipTest('macpath.expandvars is a stub')
212        expandvars = self.pathmodule.expandvars
213        def check(value, expected):
214            self.assertEqual(expandvars(value), expected)
215        encoding = sys.getfilesystemencoding()
216        with test_support.EnvironmentVarGuard() as env:
217            env.clear()
218            unonascii = test_support.FS_NONASCII
219            snonascii = unonascii.encode(encoding)
220            env['spam'] = snonascii
221            env[snonascii] = 'ham' + snonascii
222            check(snonascii, snonascii)
223            check('$spam bar', '%s bar' % snonascii)
224            check('${spam}bar', '%sbar' % snonascii)
225            check('${%s}bar' % snonascii, 'ham%sbar' % snonascii)
226            check('$bar%s bar' % snonascii, '$bar%s bar' % snonascii)
227            check('$spam}bar', '%s}bar' % snonascii)
228
229            check(unonascii, unonascii)
230            check(u'$spam bar', u'%s bar' % unonascii)
231            check(u'${spam}bar', u'%sbar' % unonascii)
232            check(u'${%s}bar' % unonascii, u'ham%sbar' % unonascii)
233            check(u'$bar%s bar' % unonascii, u'$bar%s bar' % unonascii)
234            check(u'$spam}bar', u'%s}bar' % unonascii)
235
236    def test_abspath(self):
237        self.assertIn("foo", self.pathmodule.abspath("foo"))
238
239        # Abspath returns bytes when the arg is bytes
240        for path in ('', 'foo', 'f\xf2\xf2', '/foo', 'C:\\'):
241            self.assertIsInstance(self.pathmodule.abspath(path), str)
242
243    def test_realpath(self):
244        self.assertIn("foo", self.pathmodule.realpath("foo"))
245
246    @test_support.requires_unicode
247    def test_normpath_issue5827(self):
248        # Make sure normpath preserves unicode
249        for path in (u'', u'.', u'/', u'\\', u'///foo/.//bar//'):
250            self.assertIsInstance(self.pathmodule.normpath(path), unicode)
251
252    @test_support.requires_unicode
253    def test_abspath_issue3426(self):
254        # Check that abspath returns unicode when the arg is unicode
255        # with both ASCII and non-ASCII cwds.
256        abspath = self.pathmodule.abspath
257        for path in (u'', u'fuu', u'f\xf9\xf9', u'/fuu', u'U:\\'):
258            self.assertIsInstance(abspath(path), unicode)
259
260        unicwd = u'\xe7w\xf0'
261        try:
262            fsencoding = test_support.TESTFN_ENCODING or "ascii"
263            unicwd.encode(fsencoding)
264        except (AttributeError, UnicodeEncodeError):
265            # FS encoding is probably ASCII
266            pass
267        else:
268            with test_support.temp_cwd(unicwd):
269                for path in (u'', u'fuu', u'f\xf9\xf9', u'/fuu', u'U:\\'):
270                    self.assertIsInstance(abspath(path), unicode)
271
272    @unittest.skipIf(sys.platform == 'darwin',
273        "Mac OS X denies the creation of a directory with an invalid utf8 name")
274    def test_nonascii_abspath(self):
275        # Test non-ASCII, non-UTF8 bytes in the path.
276        with test_support.temp_cwd('\xe7w\xf0'):
277            self.test_abspath()
278
279
280def test_main():
281    test_support.run_unittest(GenericTest)
282
283
284if __name__=="__main__":
285    test_main()
286