/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test_globbing.py

  • Committer: Jelmer Vernooij
  • Date: 2020-04-05 19:11:34 UTC
  • mto: (7490.7.16 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200405191134-0aebh8ikiwygxma5
Populate the .gitignore file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_globbing.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2011 Canonical Ltd
2
2
# -*- coding: utf-8 -*-
3
3
#
4
4
# This program is free software; you can redistribute it and/or modify
15
15
# along with this program; if not, write to the Free Software
16
16
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
17
 
18
 
from bzrlib.globbing import (
 
18
import re
 
19
 
 
20
from .. import errors, lazy_regex
 
21
from ..globbing import (
19
22
    Globster,
20
23
    ExceptionGlobster,
21
24
    _OrderedGlobster,
22
25
    normalize_pattern
23
26
    )
24
 
from bzrlib.tests import (
 
27
from . import (
25
28
    TestCase,
26
 
    TestCaseInTempDir,
27
29
    )
28
30
 
29
31
 
35
37
                glob = glob_prefix + glob
36
38
            globster = Globster([glob])
37
39
            for name in positive:
38
 
                self.failUnless(globster.match(name), repr(
 
40
                self.assertTrue(globster.match(name), repr(
39
41
                    u'name "%s" does not match glob "%s" (re=%s)' %
40
42
                    (name, glob, globster._regex_patterns[0][0].pattern)))
41
43
            for name in negative:
42
 
                self.failIf(globster.match(name), repr(
 
44
                self.assertFalse(globster.match(name), repr(
43
45
                    u'name "%s" does match glob "%s" (re=%s)' %
44
46
                    (name, glob, globster._regex_patterns[0][0].pattern)))
45
47
 
52
54
    def test_char_group_digit(self):
53
55
        self.assertMatchBasenameAndFullpath([
54
56
            # The definition of digit this uses includes arabic digits from
55
 
            # non-latin scripts (arabic, indic, etc.) and subscript/superscript
56
 
            # digits, but neither roman numerals nor vulgar fractions.
 
57
            # non-latin scripts (arabic, indic, etc.) but neither roman
 
58
            # numerals nor vulgar fractions. Some characters such as
 
59
            # subscript/superscript digits may or may not match depending on
 
60
            # the Python version used, see: <http://bugs.python.org/issue6561>
57
61
            (u'[[:digit:]]',
58
 
             [u'0', u'5', u'\u0663', u'\u06f9', u'\u0f21', u'\xb9'],
 
62
             [u'0', u'5', u'\u0663', u'\u06f9', u'\u0f21'],
59
63
             [u'T', u'q', u' ', u'\u8336', u'.']),
60
64
            (u'[^[:digit:]]',
61
65
             [u'T', u'q', u' ', u'\u8336', u'.'],
62
 
             [u'0', u'5', u'\u0663', u'\u06f9', u'\u0f21', u'\xb9']),
 
66
             [u'0', u'5', u'\u0663', u'\u06f9', u'\u0f21']),
63
67
            ])
64
68
 
65
69
    def test_char_group_space(self):
180
184
             [u'foo', u'foo.bar'],
181
185
             [u'.foo', u'foo/bar', u'foo/.bar']),
182
186
            (u'*bar',
183
 
             [u'bar', u'foobar', ur'foo\nbar', u'foo.bar', u'foo/bar',
 
187
             [u'bar', u'foobar', u'foo\\nbar', u'foo.bar', u'foo/bar',
184
188
              u'foo/foobar', u'foo/f.bar', u'.bar', u'foo/.bar'],
185
189
             []),
186
190
            ])
218
222
             [u'foo', u'foo.bar'],
219
223
             [u'.foo', u'foo/bar', u'foo/.bar']),
220
224
            (u'**bar',
221
 
             [u'bar', u'foobar', ur'foo\nbar', u'foo.bar', u'foo/bar',
 
225
             [u'bar', u'foobar', u'foo\\nbar', u'foo.bar', u'foo/bar',
222
226
              u'foo/foobar', u'foo/f.bar', u'.bar', u'foo/.bar'],
223
227
             []),
224
228
            ])
260
264
        self.assertMatch([
261
265
            (u'*.x',
262
266
             [u'foo/bar/baz.x', u'\u8336/Q.x', u'foo.y.x', u'.foo.x',
263
 
              u'bar/.foo.x', u'.x',],
 
267
              u'bar/.foo.x', u'.x', ],
264
268
             [u'foo.x.y']),
265
269
            (u'foo/*.bar',
266
270
             [u'foo/b.bar', u'foo/a.b.bar', u'foo/.bar'],
285
289
 
286
290
        The types being extension, basename and full path.
287
291
        """
288
 
        patterns = [ u'*.foo', u'.*.swp', u'./*.png']
 
292
        patterns = [u'*.foo', u'.*.swp', u'./*.png']
289
293
        globster = Globster(patterns)
290
294
        self.assertEqual(u'*.foo', globster.match('bar.foo'))
291
295
        self.assertEqual(u'./*.png', globster.match('foo.png'))
300
304
        This test assumes the globs are broken into regexs containing 99
301
305
        groups.
302
306
        """
303
 
        patterns = [ u'*.%03d' % i for i in xrange(0,300) ]
 
307
        patterns = [u'*.%03d' % i for i in range(300)]
304
308
        globster = Globster(patterns)
305
309
        # test the fence posts
306
 
        for x in (0,98,99,197,198,296,297,299):
 
310
        for x in (0, 98, 99, 197, 198, 296, 297, 299):
307
311
            filename = u'foo.%03d' % x
308
 
            self.assertEqual(patterns[x],globster.match(filename))
309
 
        self.assertEqual(None,globster.match('foobar.300'))
 
312
            self.assertEqual(patterns[x], globster.match(filename))
 
313
        self.assertEqual(None, globster.match('foobar.300'))
 
314
 
 
315
    def test_bad_pattern(self):
 
316
        """Ensure that globster handles bad patterns cleanly."""
 
317
        patterns = [u'RE:[', u'/home/foo', u'RE:*.cpp']
 
318
        g = Globster(patterns)
 
319
        e = self.assertRaises(lazy_regex.InvalidPattern, g.match, 'filename')
 
320
        self.assertContainsRe(e.msg,
 
321
                              r"File.*ignore.*contains error.*RE:\[.*RE:\*\.cpp", flags=re.DOTALL)
 
322
 
310
323
 
311
324
class TestExceptionGlobster(TestCase):
312
325
 
313
326
    def test_exclusion_patterns(self):
314
327
        """test that exception patterns are not matched"""
315
 
        patterns = [ u'*', u'!./local', u'!./local/**/*', u'!RE:\.z.*',u'!!./.zcompdump' ]
 
328
        patterns = [u'*', u'!./local', u'!./local/**/*',
 
329
                    u'!RE:\\.z.*', u'!!./.zcompdump']
316
330
        globster = ExceptionGlobster(patterns)
317
331
        self.assertEqual(u'*', globster.match('tmp/foo.txt'))
318
332
        self.assertEqual(None, globster.match('local'))
323
337
 
324
338
    def test_exclusion_order(self):
325
339
        """test that ordering of exclusion patterns does not matter"""
326
 
        patterns = [ u'static/**/*.html', u'!static/**/versionable.html']
 
340
        patterns = [u'static/**/*.html', u'!static/**/versionable.html']
327
341
        globster = ExceptionGlobster(patterns)
328
 
        self.assertEqual(u'static/**/*.html', globster.match('static/foo.html'))
 
342
        self.assertEqual(u'static/**/*.html',
 
343
                         globster.match('static/foo.html'))
329
344
        self.assertEqual(None, globster.match('static/versionable.html'))
330
345
        self.assertEqual(None, globster.match('static/bar/versionable.html'))
331
346
        globster = ExceptionGlobster(reversed(patterns))
332
 
        self.assertEqual(u'static/**/*.html', globster.match('static/foo.html'))
 
347
        self.assertEqual(u'static/**/*.html',
 
348
                         globster.match('static/foo.html'))
333
349
        self.assertEqual(None, globster.match('static/versionable.html'))
334
350
        self.assertEqual(None, globster.match('static/bar/versionable.html'))
335
351
 
 
352
 
336
353
class TestOrderedGlobster(TestCase):
337
354
 
338
355
    def test_ordered_globs(self):
339
356
        """test that the first match in a list is the one found"""
340
 
        patterns = [ u'*.foo', u'bar.*']
 
357
        patterns = [u'*.foo', u'bar.*']
341
358
        globster = _OrderedGlobster(patterns)
342
359
        self.assertEqual(u'*.foo', globster.match('bar.foo'))
343
360
        self.assertEqual(None, globster.match('foo.bar'))
370
387
    def test_mixed_slashes(self):
371
388
        """tests that multiple mixed slashes are collapsed to single forward
372
389
        slashes and trailing mixed slashes are removed"""
373
 
        self.assertEqual(u'/foo/bar', normalize_pattern(u'\\/\\foo//\\///bar/\\\\/'))
 
390
        self.assertEqual(
 
391
            u'/foo/bar', normalize_pattern(u'\\/\\foo//\\///bar/\\\\/'))