Debian Codegraph @

Lib/test/test_glob.py

raw
1 import glob
2 import os
3 import re
4 import shutil
5 import sys
6 import unittest
7 import warnings
8
9 from test.support import is_wasi, Py_DEBUG
10 from test.support.os_helper import (TESTFN, skip_unless_symlink,
11 can_symlink, create_empty_file, change_cwd)
12
13
14 class GlobTests(unittest.TestCase):
15 dir_fd = None
16
17 def norm(self, *parts):
18 return os.path.normpath(os.path.join(self.tempdir, *parts))
19
20 def joins(self, *tuples):
21 return [os.path.join(self.tempdir, *parts) for parts in tuples]
22
23 def mktemp(self, *parts):
24 filename = self.norm(*parts)
25 base, file = os.path.split(filename)
26 if not os.path.exists(base):
27 os.makedirs(base)
28 create_empty_file(filename)
29
30 def setUp(self):
31 self.tempdir = TESTFN + "_dir"
32 self.mktemp('a', 'D')
33 self.mktemp('aab', 'F')
34 self.mktemp('.aa', 'G')
35 self.mktemp('.bb', 'H')
36 self.mktemp('.bb', '.J')
37 self.mktemp('aaa', 'zzzF')
38 self.mktemp('ZZZ')
39 self.mktemp('EF')
40 self.mktemp('a', 'bcd', 'EF')
41 self.mktemp('a', 'bcd', 'efg', 'ha')
42 if can_symlink():
43 os.symlink(self.norm('broken'), self.norm('sym1'))
44 os.symlink('broken', self.norm('sym2'))
45 os.symlink(os.path.join('a', 'bcd'), self.norm('sym3'))
46 self.open_dirfd()
47
48 def open_dirfd(self):
49 if self.dir_fd is not None:
50 os.close(self.dir_fd)
51 if {os.open, os.stat} <= os.supports_dir_fd and os.scandir in os.supports_fd:
52 self.dir_fd = os.open(self.tempdir, os.O_RDONLY | os.O_DIRECTORY)
53 else:
54 self.dir_fd = None
55
56 def tearDown(self):
57 if self.dir_fd is not None:
58 os.close(self.dir_fd)
59 shutil.rmtree(self.tempdir)
60
61 def glob(self, *parts, **kwargs):
62 if len(parts) == 1:
63 pattern = parts[0]
64 else:
65 pattern = os.path.join(*parts)
66 p = os.path.join(self.tempdir, pattern)
67 res = glob.glob(p, **kwargs)
68 res2 = glob.iglob(p, **kwargs)
69 self.assertCountEqual(glob.iglob(p, **kwargs), res)
70
71 bres = [os.fsencode(x) for x in res]
72 self.assertCountEqual(glob.glob(os.fsencode(p), **kwargs), bres)
73 self.assertCountEqual(glob.iglob(os.fsencode(p), **kwargs), bres)
74
75 with change_cwd(self.tempdir):
76 res2 = glob.glob(pattern, **kwargs)
77 for x in res2:
78 self.assertFalse(os.path.isabs(x), x)
79 if pattern == '**' or pattern == '**' + os.sep:
80 expected = res[1:]
81 else:
82 expected = res
83 self.assertCountEqual([os.path.join(self.tempdir, x) for x in res2],
84 expected)
85 self.assertCountEqual(glob.iglob(pattern, **kwargs), res2)
86 bpattern = os.fsencode(pattern)
87 bres2 = [os.fsencode(x) for x in res2]
88 self.assertCountEqual(glob.glob(bpattern, **kwargs), bres2)
89 self.assertCountEqual(glob.iglob(bpattern, **kwargs), bres2)
90
91 self.assertCountEqual(glob.glob(pattern, root_dir=self.tempdir, **kwargs), res2)
92 self.assertCountEqual(glob.iglob(pattern, root_dir=self.tempdir, **kwargs), res2)
93 btempdir = os.fsencode(self.tempdir)
94 self.assertCountEqual(
95 glob.glob(bpattern, root_dir=btempdir, **kwargs), bres2)
96 self.assertCountEqual(
97 glob.iglob(bpattern, root_dir=btempdir, **kwargs), bres2)
98
99 if self.dir_fd is not None:
100 self.assertCountEqual(
101 glob.glob(pattern, dir_fd=self.dir_fd, **kwargs), res2)
102 self.assertCountEqual(
103 glob.iglob(pattern, dir_fd=self.dir_fd, **kwargs), res2)
104 self.assertCountEqual(
105 glob.glob(bpattern, dir_fd=self.dir_fd, **kwargs), bres2)
106 self.assertCountEqual(
107 glob.iglob(bpattern, dir_fd=self.dir_fd, **kwargs), bres2)
108
109 return res
110
111 def assertSequencesEqual_noorder(self, l1, l2):
112 l1 = list(l1)
113 l2 = list(l2)
114 self.assertEqual(set(l1), set(l2))
115 self.assertEqual(sorted(l1), sorted(l2))
116
117 def test_glob_literal(self):
118 eq = self.assertSequencesEqual_noorder
119 eq(self.glob('a'), [self.norm('a')])
120 eq(self.glob('a', 'D'), [self.norm('a', 'D')])
121 eq(self.glob('aab'), [self.norm('aab')])
122 eq(self.glob('zymurgy'), [])
123
124 res = glob.glob('*')
125 self.assertEqual({type(r) for r in res}, {str})
126 res = glob.glob(os.path.join(os.curdir, '*'))
127 self.assertEqual({type(r) for r in res}, {str})
128
129 res = glob.glob(b'*')
130 self.assertEqual({type(r) for r in res}, {bytes})
131 res = glob.glob(os.path.join(os.fsencode(os.curdir), b'*'))
132 self.assertEqual({type(r) for r in res}, {bytes})
133
134 def test_glob_empty_pattern(self):
135 self.assertEqual(glob.glob(''), [])
136 self.assertEqual(glob.glob(b''), [])
137 self.assertEqual(glob.glob('', root_dir=self.tempdir), [])
138 self.assertEqual(glob.glob(b'', root_dir=os.fsencode(self.tempdir)), [])
139 self.assertEqual(glob.glob('', dir_fd=self.dir_fd), [])
140 self.assertEqual(glob.glob(b'', dir_fd=self.dir_fd), [])
141
142 def test_glob_one_directory(self):
143 eq = self.assertSequencesEqual_noorder
144 eq(self.glob('a*'), map(self.norm, ['a', 'aab', 'aaa']))
145 eq(self.glob('*a'), map(self.norm, ['a', 'aaa']))
146 eq(self.glob('.*'), map(self.norm, ['.aa', '.bb']))
147 eq(self.glob('?aa'), map(self.norm, ['aaa']))
148 eq(self.glob('aa?'), map(self.norm, ['aaa', 'aab']))
149 eq(self.glob('aa[ab]'), map(self.norm, ['aaa', 'aab']))
150 eq(self.glob('*q'), [])
151
152 def test_glob_nested_directory(self):
153 eq = self.assertSequencesEqual_noorder
154 if os.path.normcase("abCD") == "abCD":
155 # case-sensitive filesystem
156 eq(self.glob('a', 'bcd', 'E*'), [self.norm('a', 'bcd', 'EF')])
157 else:
158 # case insensitive filesystem
159 eq(self.glob('a', 'bcd', 'E*'), [self.norm('a', 'bcd', 'EF'),
160 self.norm('a', 'bcd', 'efg')])
161 eq(self.glob('a', 'bcd', '*g'), [self.norm('a', 'bcd', 'efg')])
162
163 def test_glob_directory_names(self):
164 eq = self.assertSequencesEqual_noorder
165 eq(self.glob('*', 'D'), [self.norm('a', 'D')])
166 eq(self.glob('*', '*a'), [])
167 eq(self.glob('a', '*', '*', '*a'),
168 [self.norm('a', 'bcd', 'efg', 'ha')])
169 eq(self.glob('?a?', '*F'), [self.norm('aaa', 'zzzF'),
170 self.norm('aab', 'F')])
171
172 def test_glob_directory_with_trailing_slash(self):
173 seps = (os.sep, os.altsep) if os.altsep else (os.sep,)
174 for sep in seps:
175 # Patterns ending with a slash shouldn't match non-dirs
176 self.assertEqual(glob.glob(self.norm('Z*Z') + sep), [])
177 self.assertEqual(glob.glob(self.norm('ZZZ') + sep), [])
178 self.assertEqual(glob.glob(self.norm('aaa') + sep),
179 [self.norm('aaa') + sep])
180 # Preserving the redundant separators is an implementation detail.
181 self.assertEqual(glob.glob(self.norm('aaa') + sep*2),
182 [self.norm('aaa') + sep*2])
183 # When there is a wildcard pattern which ends with a pathname
184 # separator, glob() doesn't blow.
185 # The result should end with the pathname separator.
186 # Normalizing the trailing separator is an implementation detail.
187 eq = self.assertSequencesEqual_noorder
188 eq(glob.glob(self.norm('aa*') + sep),
189 [self.norm('aaa') + os.sep, self.norm('aab') + os.sep])
190 # Stripping the redundant separators is an implementation detail.
191 eq(glob.glob(self.norm('aa*') + sep*2),
192 [self.norm('aaa') + os.sep, self.norm('aab') + os.sep])
193
194 def test_glob_bytes_directory_with_trailing_slash(self):
195 # Same as test_glob_directory_with_trailing_slash, but with a
196 # bytes argument.
197 seps = (os.sep, os.altsep) if os.altsep else (os.sep,)
198 for sep in seps:
199 self.assertEqual(glob.glob(os.fsencode(self.norm('Z*Z') + sep)), [])
200 self.assertEqual(glob.glob(os.fsencode(self.norm('ZZZ') + sep)), [])
201 self.assertEqual(glob.glob(os.fsencode(self.norm('aaa') + sep)),
202 [os.fsencode(self.norm('aaa') + sep)])
203 self.assertEqual(glob.glob(os.fsencode(self.norm('aaa') + sep*2)),
204 [os.fsencode(self.norm('aaa') + sep*2)])
205 eq = self.assertSequencesEqual_noorder
206 eq(glob.glob(os.fsencode(self.norm('aa*') + sep)),
207 [os.fsencode(self.norm('aaa') + os.sep),
208 os.fsencode(self.norm('aab') + os.sep)])
209 eq(glob.glob(os.fsencode(self.norm('aa*') + sep*2)),
210 [os.fsencode(self.norm('aaa') + os.sep),
211 os.fsencode(self.norm('aab') + os.sep)])
212
213 @skip_unless_symlink
214 def test_glob_symlinks(self):
215 eq = self.assertSequencesEqual_noorder
216 eq(self.glob('sym3'), [self.norm('sym3')])
217 eq(self.glob('sym3', '*'), [self.norm('sym3', 'EF'),
218 self.norm('sym3', 'efg')])
219 eq(self.glob('sym3' + os.sep), [self.norm('sym3') + os.sep])
220 eq(self.glob('*', '*F'),
221 [self.norm('aaa', 'zzzF'),
222 self.norm('aab', 'F'), self.norm('sym3', 'EF')])
223
224 @skip_unless_symlink
225 def test_glob_broken_symlinks(self):
226 eq = self.assertSequencesEqual_noorder
227 eq(self.glob('sym*'), [self.norm('sym1'), self.norm('sym2'),
228 self.norm('sym3')])
229 eq(self.glob('sym1'), [self.norm('sym1')])
230 eq(self.glob('sym2'), [self.norm('sym2')])
231
232 @unittest.skipUnless(sys.platform == "win32", "Win32 specific test")
233 def test_glob_magic_in_drive(self):
234 eq = self.assertSequencesEqual_noorder
235 eq(glob.glob('*:'), [])
236 eq(glob.glob(b'*:'), [])
237 eq(glob.glob('?:'), [])
238 eq(glob.glob(b'?:'), [])
239 eq(glob.glob('\\\\?\\c:\\'), ['\\\\?\\c:\\'])
240 eq(glob.glob(b'\\\\?\\c:\\'), [b'\\\\?\\c:\\'])
241 eq(glob.glob('\\\\*\\*\\'), [])
242 eq(glob.glob(b'\\\\*\\*\\'), [])
243
244 def check_escape(self, arg, expected):
245 self.assertEqual(glob.escape(arg), expected)
246 self.assertEqual(glob.escape(os.fsencode(arg)), os.fsencode(expected))
247
248 def test_escape(self):
249 check = self.check_escape
250 check('abc', 'abc')
251 check('[', '[[]')
252 check('?', '[?]')
253 check('*', '[*]')
254 check('[[_/*?*/_]]', '[[][[]_/[*][?][*]/_]]')
255 check('/[[_/*?*/_]]/', '/[[][[]_/[*][?][*]/_]]/')
256
257 @unittest.skipUnless(sys.platform == "win32", "Win32 specific test")
258 def test_escape_windows(self):
259 check = self.check_escape
260 check('?:?', '?:[?]')
261 check('*:*', '*:[*]')
262 check(r'\\?\c:\?', r'\\?\c:\[?]')
263 check(r'\\*\*\*', r'\\*\*\[*]')
264 check('//?/c:/?', '//?/c:/[?]')
265 check('//*/*/*', '//*/*/[*]')
266
267 def rglob(self, *parts, **kwargs):
268 return self.glob(*parts, recursive=True, **kwargs)
269
270 def hglob(self, *parts, **kwargs):
271 return self.glob(*parts, include_hidden=True, **kwargs)
272
273 def test_hidden_glob(self):
274 eq = self.assertSequencesEqual_noorder
275 l = [('aaa',), ('.aa',)]
276 eq(self.hglob('?aa'), self.joins(*l))
277 eq(self.hglob('*aa'), self.joins(*l))
278 l2 = [('.aa','G',)]
279 eq(self.hglob('**', 'G'), self.joins(*l2))
280
281 def test_recursive_glob(self):
282 eq = self.assertSequencesEqual_noorder
283 full = [('EF',), ('ZZZ',),
284 ('a',), ('a', 'D'),
285 ('a', 'bcd'),
286 ('a', 'bcd', 'EF'),
287 ('a', 'bcd', 'efg'),
288 ('a', 'bcd', 'efg', 'ha'),
289 ('aaa',), ('aaa', 'zzzF'),
290 ('aab',), ('aab', 'F'),
291 ]
292 if can_symlink():
293 full += [('sym1',), ('sym2',),
294 ('sym3',),
295 ('sym3', 'EF'),
296 ('sym3', 'efg'),
297 ('sym3', 'efg', 'ha'),
298 ]
299 eq(self.rglob('**'), self.joins(('',), *full))
300 eq(self.rglob(os.curdir, '**'),
301 self.joins((os.curdir, ''), *((os.curdir,) + i for i in full)))
302 dirs = [('a', ''), ('a', 'bcd', ''), ('a', 'bcd', 'efg', ''),
303 ('aaa', ''), ('aab', '')]
304 if can_symlink():
305 dirs += [('sym3', ''), ('sym3', 'efg', '')]
306 eq(self.rglob('**', ''), self.joins(('',), *dirs))
307
308 eq(self.rglob('a', '**'), self.joins(
309 ('a', ''), ('a', 'D'), ('a', 'bcd'), ('a', 'bcd', 'EF'),
310 ('a', 'bcd', 'efg'), ('a', 'bcd', 'efg', 'ha')))
311 eq(self.rglob('a**'), self.joins(('a',), ('aaa',), ('aab',)))
312 expect = [('a', 'bcd', 'EF'), ('EF',)]
313 if can_symlink():
314 expect += [('sym3', 'EF')]
315 eq(self.rglob('**', 'EF'), self.joins(*expect))
316 expect = [('a', 'bcd', 'EF'), ('aaa', 'zzzF'), ('aab', 'F'), ('EF',)]
317 if can_symlink():
318 expect += [('sym3', 'EF')]
319 eq(self.rglob('**', '*F'), self.joins(*expect))
320 eq(self.rglob('**', '*F', ''), [])
321 eq(self.rglob('**', 'bcd', '*'), self.joins(
322 ('a', 'bcd', 'EF'), ('a', 'bcd', 'efg')))
323 eq(self.rglob('a', '**', 'bcd'), self.joins(('a', 'bcd')))
324
325 with change_cwd(self.tempdir):
326 join = os.path.join
327 eq(glob.glob('**', recursive=True), [join(*i) for i in full])
328 eq(glob.glob(join('**', ''), recursive=True),
329 [join(*i) for i in dirs])
330 eq(glob.glob(join('**', '*'), recursive=True),
331 [join(*i) for i in full])
332 eq(glob.glob(join(os.curdir, '**'), recursive=True),
333 [join(os.curdir, '')] + [join(os.curdir, *i) for i in full])
334 eq(glob.glob(join(os.curdir, '**', ''), recursive=True),
335 [join(os.curdir, '')] + [join(os.curdir, *i) for i in dirs])
336 eq(glob.glob(join(os.curdir, '**', '*'), recursive=True),
337 [join(os.curdir, *i) for i in full])
338 eq(glob.glob(join('**','zz*F'), recursive=True),
339 [join('aaa', 'zzzF')])
340 eq(glob.glob('**zz*F', recursive=True), [])
341 expect = [join('a', 'bcd', 'EF'), 'EF']
342 if can_symlink():
343 expect += [join('sym3', 'EF')]
344 eq(glob.glob(join('**', 'EF'), recursive=True), expect)
345
346 rec = [('.bb','H'), ('.bb','.J'), ('.aa','G'), ('.aa',), ('.bb',)]
347 eq(glob.glob('**', recursive=True, include_hidden=True),
348 [join(*i) for i in full+rec])
349
350 def test_glob_non_directory(self):
351 eq = self.assertSequencesEqual_noorder
352 eq(self.rglob('EF'), self.joins(('EF',)))
353 eq(self.rglob('EF', ''), [])
354 eq(self.rglob('EF', '*'), [])
355 eq(self.rglob('EF', '**'), [])
356 eq(self.rglob('nonexistent'), [])
357 eq(self.rglob('nonexistent', ''), [])
358 eq(self.rglob('nonexistent', '*'), [])
359 eq(self.rglob('nonexistent', '**'), [])
360
361 @unittest.skipUnless(hasattr(os, "mkfifo"), 'requires os.mkfifo()')
362 @unittest.skipIf(sys.platform == "vxworks",
363 "fifo requires special path on VxWorks")
364 def test_glob_named_pipe(self):
365 path = os.path.join(self.tempdir, 'mypipe')
366 os.mkfifo(path)
367
368 # gh-117127: Reopen self.dir_fd to pick up directory changes
369 self.open_dirfd()
370
371 self.assertEqual(self.rglob('mypipe'), [path])
372 self.assertEqual(self.rglob('mypipe*'), [path])
373 self.assertEqual(self.rglob('mypipe', ''), [])
374 self.assertEqual(self.rglob('mypipe', 'sub'), [])
375 self.assertEqual(self.rglob('mypipe', '*'), [])
376
377
378 @unittest.skipIf(is_wasi and Py_DEBUG, "requires too much stack")
379 def test_glob_many_open_files(self):
380 depth = 30
381 base = os.path.join(self.tempdir, 'deep')
382 p = os.path.join(base, *(['d']*depth))
383 os.makedirs(p)
384 pattern = os.path.join(base, *(['*']*depth))
385 iters = [glob.iglob(pattern, recursive=True) for j in range(100)]
386 for it in iters:
387 self.assertEqual(next(it), p)
388 pattern = os.path.join(base, '**', 'd')
389 iters = [glob.iglob(pattern, recursive=True) for j in range(100)]
390 p = base
391 for i in range(depth):
392 p = os.path.join(p, 'd')
393 for it in iters:
394 self.assertEqual(next(it), p)
395
396 def test_glob0(self):
397 with self.assertWarns(DeprecationWarning):
398 glob.glob0(self.tempdir, 'a')
399
400 with warnings.catch_warnings():
401 warnings.simplefilter('ignore')
402 eq = self.assertSequencesEqual_noorder
403 eq(glob.glob0(self.tempdir, 'a'), ['a'])
404 eq(glob.glob0(self.tempdir, '.bb'), ['.bb'])
405 eq(glob.glob0(self.tempdir, '.b*'), [])
406 eq(glob.glob0(self.tempdir, 'b'), [])
407 eq(glob.glob0(self.tempdir, '?'), [])
408 eq(glob.glob0(self.tempdir, '*a'), [])
409 eq(glob.glob0(self.tempdir, 'a*'), [])
410
411 def test_glob1(self):
412 with self.assertWarns(DeprecationWarning):
413 glob.glob1(self.tempdir, 'a')
414
415 with warnings.catch_warnings():
416 warnings.simplefilter('ignore')
417 eq = self.assertSequencesEqual_noorder
418 eq(glob.glob1(self.tempdir, 'a'), ['a'])
419 eq(glob.glob1(self.tempdir, '.bb'), ['.bb'])
420 eq(glob.glob1(self.tempdir, '.b*'), ['.bb'])
421 eq(glob.glob1(self.tempdir, 'b'), [])
422 eq(glob.glob1(self.tempdir, '?'), ['a'])
423 eq(glob.glob1(self.tempdir, '*a'), ['a', 'aaa'])
424 eq(glob.glob1(self.tempdir, 'a*'), ['a', 'aaa', 'aab'])
425
426 def test_translate_matching(self):
427 match = re.compile(glob.translate('*')).match
428 self.assertIsNotNone(match('foo'))
429 self.assertIsNotNone(match('foo.bar'))
430 self.assertIsNone(match('.foo'))
431 match = re.compile(glob.translate('.*')).match
432 self.assertIsNotNone(match('.foo'))
433 match = re.compile(glob.translate('**', recursive=True)).match
434 self.assertIsNotNone(match('foo'))
435 self.assertIsNone(match('.foo'))
436 self.assertIsNotNone(match(os.path.join('foo', 'bar')))
437 self.assertIsNone(match(os.path.join('foo', '.bar')))
438 self.assertIsNone(match(os.path.join('.foo', 'bar')))
439 self.assertIsNone(match(os.path.join('.foo', '.bar')))
440 match = re.compile(glob.translate('**/*', recursive=True)).match
441 self.assertIsNotNone(match(os.path.join('foo', 'bar')))
442 self.assertIsNone(match(os.path.join('foo', '.bar')))
443 self.assertIsNone(match(os.path.join('.foo', 'bar')))
444 self.assertIsNone(match(os.path.join('.foo', '.bar')))
445 match = re.compile(glob.translate('*/**', recursive=True)).match
446 self.assertIsNotNone(match(os.path.join('foo', 'bar')))
447 self.assertIsNone(match(os.path.join('foo', '.bar')))
448 self.assertIsNone(match(os.path.join('.foo', 'bar')))
449 self.assertIsNone(match(os.path.join('.foo', '.bar')))
450 match = re.compile(glob.translate('**/.bar', recursive=True)).match
451 self.assertIsNotNone(match(os.path.join('foo', '.bar')))
452 self.assertIsNone(match(os.path.join('.foo', '.bar')))
453 match = re.compile(glob.translate('**/*.*', recursive=True)).match
454 self.assertIsNone(match(os.path.join('foo', 'bar')))
455 self.assertIsNone(match(os.path.join('foo', '.bar')))
456 self.assertIsNotNone(match(os.path.join('foo', 'bar.txt')))
457 self.assertIsNone(match(os.path.join('foo', '.bar.txt')))
458
459 def test_translate(self):
460 def fn(pat):
461 return glob.translate(pat, seps='/')
462 self.assertEqual(fn('foo'), r'(?s:foo)\z')
463 self.assertEqual(fn('foo/bar'), r'(?s:foo/bar)\z')
464 self.assertEqual(fn('*'), r'(?s:[^/.][^/]*)\z')
465 self.assertEqual(fn('?'), r'(?s:(?!\.)[^/])\z')
466 self.assertEqual(fn('a*'), r'(?s:a[^/]*)\z')
467 self.assertEqual(fn('*a'), r'(?s:(?!\.)[^/]*a)\z')
468 self.assertEqual(fn('.*'), r'(?s:\.[^/]*)\z')
469 self.assertEqual(fn('?aa'), r'(?s:(?!\.)[^/]aa)\z')
470 self.assertEqual(fn('aa?'), r'(?s:aa[^/])\z')
471 self.assertEqual(fn('aa[ab]'), r'(?s:aa[ab])\z')
472 self.assertEqual(fn('**'), r'(?s:(?!\.)[^/]*)\z')
473 self.assertEqual(fn('***'), r'(?s:(?!\.)[^/]*)\z')
474 self.assertEqual(fn('a**'), r'(?s:a[^/]*)\z')
475 self.assertEqual(fn('**b'), r'(?s:(?!\.)[^/]*b)\z')
476 self.assertEqual(fn('/**/*/*.*/**'),
477 r'(?s:/(?!\.)[^/]*/[^/.][^/]*/(?!\.)[^/]*\.[^/]*/(?!\.)[^/]*)\z')
478
479 def test_translate_include_hidden(self):
480 def fn(pat):
481 return glob.translate(pat, include_hidden=True, seps='/')
482 self.assertEqual(fn('foo'), r'(?s:foo)\z')
483 self.assertEqual(fn('foo/bar'), r'(?s:foo/bar)\z')
484 self.assertEqual(fn('*'), r'(?s:[^/]+)\z')
485 self.assertEqual(fn('?'), r'(?s:[^/])\z')
486 self.assertEqual(fn('a*'), r'(?s:a[^/]*)\z')
487 self.assertEqual(fn('*a'), r'(?s:[^/]*a)\z')
488 self.assertEqual(fn('.*'), r'(?s:\.[^/]*)\z')
489 self.assertEqual(fn('?aa'), r'(?s:[^/]aa)\z')
490 self.assertEqual(fn('aa?'), r'(?s:aa[^/])\z')
491 self.assertEqual(fn('aa[ab]'), r'(?s:aa[ab])\z')
492 self.assertEqual(fn('**'), r'(?s:[^/]*)\z')
493 self.assertEqual(fn('***'), r'(?s:[^/]*)\z')
494 self.assertEqual(fn('a**'), r'(?s:a[^/]*)\z')
495 self.assertEqual(fn('**b'), r'(?s:[^/]*b)\z')
496 self.assertEqual(fn('/**/*/*.*/**'), r'(?s:/[^/]*/[^/]+/[^/]*\.[^/]*/[^/]*)\z')
497
498 def test_translate_recursive(self):
499 def fn(pat):
500 return glob.translate(pat, recursive=True, include_hidden=True, seps='/')
501 self.assertEqual(fn('*'), r'(?s:[^/]+)\z')
502 self.assertEqual(fn('?'), r'(?s:[^/])\z')
503 self.assertEqual(fn('**'), r'(?s:.*)\z')
504 self.assertEqual(fn('**/**'), r'(?s:.*)\z')
505 self.assertEqual(fn('***'), r'(?s:[^/]*)\z')
506 self.assertEqual(fn('a**'), r'(?s:a[^/]*)\z')
507 self.assertEqual(fn('**b'), r'(?s:[^/]*b)\z')
508 self.assertEqual(fn('/**/*/*.*/**'), r'(?s:/(?:.+/)?[^/]+/[^/]*\.[^/]*/.*)\z')
509
510 def test_translate_seps(self):
511 def fn(pat):
512 return glob.translate(pat, recursive=True, include_hidden=True, seps=['/', '\\'])
513 self.assertEqual(fn('foo/bar\\baz'), r'(?s:foo[/\\]bar[/\\]baz)\z')
514 self.assertEqual(fn('**/*'), r'(?s:(?:.+[/\\])?[^/\\]+)\z')
515
516
517 if __name__ == "__main__":
518 unittest.main()