← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_globbing.py

(jelmer) Support upgrading between the 2a and development-colo formats.
 (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_globbing.py
1
 
# Copyright (C) 2006 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
13
13
#
14
14
# You should have received a copy of the GNU General Public License
15
15
# along with this program; if not, write to the Free Software
16
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
 
 
 
16
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
17
 
 
18
import re
 
19
 
 
20
from bzrlib import errors
18
21
from bzrlib.globbing import (
19
22
    Globster,
 
23
    ExceptionGlobster,
 
24
    _OrderedGlobster,
 
25
    normalize_pattern
20
26
    )
21
27
from bzrlib.tests import (
22
 
    TestCase, 
23
 
    TestCaseInTempDir,
 
28
    TestCase,
24
29
    )
25
30
 
26
31
 
32
37
                glob = glob_prefix + glob
33
38
            globster = Globster([glob])
34
39
            for name in positive:
35
 
                self.failUnless(globster.match(name), repr(
 
40
                self.assertTrue(globster.match(name), repr(
36
41
                    u'name "%s" does not match glob "%s" (re=%s)' %
37
42
                    (name, glob, globster._regex_patterns[0][0].pattern)))
38
43
            for name in negative:
39
 
                self.failIf(globster.match(name), repr(
 
44
                self.assertFalse(globster.match(name), repr(
40
45
                    u'name "%s" does match glob "%s" (re=%s)' %
41
46
                    (name, glob, globster._regex_patterns[0][0].pattern)))
42
47
 
49
54
    def test_char_group_digit(self):
50
55
        self.assertMatchBasenameAndFullpath([
51
56
            # The definition of digit this uses includes arabic digits from
52
 
            # non-latin scripts (arabic, indic, etc.) and subscript/superscript
53
 
            # 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>
54
61
            (u'[[:digit:]]',
55
 
             [u'0', u'5', u'\u0663', u'\u06f9', u'\u0f21', u'\xb9'],
 
62
             [u'0', u'5', u'\u0663', u'\u06f9', u'\u0f21'],
56
63
             [u'T', u'q', u' ', u'\u8336', u'.']),
57
64
            (u'[^[:digit:]]',
58
65
             [u'T', u'q', u' ', u'\u8336', u'.'],
59
 
             [u'0', u'5', u'\u0663', u'\u06f9', u'\u0f21', u'\xb9']),
 
66
             [u'0', u'5', u'\u0663', u'\u06f9', u'\u0f21']),
60
67
            ])
61
68
 
62
69
    def test_char_group_space(self):
170
177
             [u'foo/x', u'foo/bax', u'foo/a.x', u'foo/.x', u'foo/.q.x'],
171
178
             [u'foo/bar/bax']),
172
179
            (u'*/*x',
173
 
             [u'\u8336/x', u'foo/x', u'foo/bax', u'x/a.x', u'.foo/x', 
 
180
             [u'\u8336/x', u'foo/x', u'foo/bax', u'x/a.x', u'.foo/x',
174
181
              u'\u8336/.x', u'foo/.q.x'],
175
182
             [u'foo/bar/bax']),
176
183
            (u'f*',
177
184
             [u'foo', u'foo.bar'],
178
185
             [u'.foo', u'foo/bar', u'foo/.bar']),
179
186
            (u'*bar',
180
 
             [u'bar', u'foobar', ur'foo\nbar', u'foo.bar', u'foo/bar', 
 
187
             [u'bar', u'foobar', ur'foo\nbar', u'foo.bar', u'foo/bar',
181
188
              u'foo/foobar', u'foo/f.bar', u'.bar', u'foo/.bar'],
182
189
             []),
183
190
            ])
190
197
             [u'foox', u'foo/bax', u'foo/.x', u'foo/bar/bax']),
191
198
            (u'**/bar',
192
199
             [u'bar', u'foo/bar'],
193
 
             [u'foobar', u'foo.bar', u'foo/foobar', u'foo/f.bar', 
 
200
             [u'foobar', u'foo.bar', u'foo/foobar', u'foo/f.bar',
194
201
              u'.bar', u'foo/.bar']),
195
202
            # check that we ignore extra *s, so *** is treated like ** not *.
196
203
            (u'foo/***/x',
198
205
             [u'foox', u'foo/bax', u'foo/.x', u'foo/bar/bax']),
199
206
            (u'***/bar',
200
207
             [u'bar', u'foo/bar'],
201
 
             [u'foobar', u'foo.bar', u'foo/foobar', u'foo/f.bar', 
 
208
             [u'foobar', u'foo.bar', u'foo/foobar', u'foo/f.bar',
202
209
              u'.bar', u'foo/.bar']),
203
210
            # the remaining tests check that ** is interpreted as *
204
211
            # unless it is a whole path component
215
222
             [u'foo', u'foo.bar'],
216
223
             [u'.foo', u'foo/bar', u'foo/.bar']),
217
224
            (u'**bar',
218
 
             [u'bar', u'foobar', ur'foo\nbar', u'foo.bar', u'foo/bar', 
 
225
             [u'bar', u'foobar', ur'foo\nbar', u'foo.bar', u'foo/bar',
219
226
              u'foo/foobar', u'foo/f.bar', u'.bar', u'foo/.bar'],
220
227
             []),
221
228
            ])
256
263
    def test_leading_asterisk_dot(self):
257
264
        self.assertMatch([
258
265
            (u'*.x',
259
 
             [u'foo/bar/baz.x', u'\u8336/Q.x', u'foo.y.x', u'.foo.x', 
 
266
             [u'foo/bar/baz.x', u'\u8336/Q.x', u'foo.y.x', u'.foo.x',
260
267
              u'bar/.foo.x', u'.x',],
261
268
             [u'foo.x.y']),
262
269
            (u'foo/*.bar',
292
299
    def test_large_globset(self):
293
300
        """tests that the globster can handle a large set of patterns.
294
301
 
295
 
        Large is defined as more than supported by python regex groups, 
 
302
        Large is defined as more than supported by python regex groups,
296
303
        i.e. 99.
297
304
        This test assumes the globs are broken into regexs containing 99
298
305
        groups.
305
312
            self.assertEqual(patterns[x],globster.match(filename))
306
313
        self.assertEqual(None,globster.match('foobar.300'))
307
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(errors.InvalidPattern, g.match, 'filename')
 
320
        self.assertContainsRe(e.msg,
 
321
            "File.*ignore.*contains error.*RE:\[.*RE:\*\.cpp", flags=re.DOTALL)
 
322
 
 
323
 
 
324
class TestExceptionGlobster(TestCase):
 
325
 
 
326
    def test_exclusion_patterns(self):
 
327
        """test that exception patterns are not matched"""
 
328
        patterns = [ u'*', u'!./local', u'!./local/**/*', u'!RE:\.z.*',u'!!./.zcompdump' ]
 
329
        globster = ExceptionGlobster(patterns)
 
330
        self.assertEqual(u'*', globster.match('tmp/foo.txt'))
 
331
        self.assertEqual(None, globster.match('local'))
 
332
        self.assertEqual(None, globster.match('local/bin/wombat'))
 
333
        self.assertEqual(None, globster.match('.zshrc'))
 
334
        self.assertEqual(None, globster.match('.zfunctions/fiddle/flam'))
 
335
        self.assertEqual(u'!!./.zcompdump', globster.match('.zcompdump'))
 
336
 
 
337
    def test_exclusion_order(self):
 
338
        """test that ordering of exclusion patterns does not matter"""
 
339
        patterns = [ u'static/**/*.html', u'!static/**/versionable.html']
 
340
        globster = ExceptionGlobster(patterns)
 
341
        self.assertEqual(u'static/**/*.html', globster.match('static/foo.html'))
 
342
        self.assertEqual(None, globster.match('static/versionable.html'))
 
343
        self.assertEqual(None, globster.match('static/bar/versionable.html'))
 
344
        globster = ExceptionGlobster(reversed(patterns))
 
345
        self.assertEqual(u'static/**/*.html', globster.match('static/foo.html'))
 
346
        self.assertEqual(None, globster.match('static/versionable.html'))
 
347
        self.assertEqual(None, globster.match('static/bar/versionable.html'))
 
348
 
 
349
class TestOrderedGlobster(TestCase):
 
350
 
 
351
    def test_ordered_globs(self):
 
352
        """test that the first match in a list is the one found"""
 
353
        patterns = [ u'*.foo', u'bar.*']
 
354
        globster = _OrderedGlobster(patterns)
 
355
        self.assertEqual(u'*.foo', globster.match('bar.foo'))
 
356
        self.assertEqual(None, globster.match('foo.bar'))
 
357
        globster = _OrderedGlobster(reversed(patterns))
 
358
        self.assertEqual(u'bar.*', globster.match('bar.foo'))
 
359
        self.assertEqual(None, globster.match('foo.bar'))
 
360
 
 
361
 
 
362
class TestNormalizePattern(TestCase):
 
363
 
 
364
    def test_backslashes(self):
 
365
        """tests that backslashes are converted to forward slashes, multiple
 
366
        backslashes are collapsed to single forward slashes and trailing
 
367
        backslashes are removed"""
 
368
        self.assertEqual(u'/', normalize_pattern(u'\\'))
 
369
        self.assertEqual(u'/', normalize_pattern(u'\\\\'))
 
370
        self.assertEqual(u'/foo/bar', normalize_pattern(u'\\foo\\bar'))
 
371
        self.assertEqual(u'foo/bar', normalize_pattern(u'foo\\bar\\'))
 
372
        self.assertEqual(u'/foo/bar', normalize_pattern(u'\\\\foo\\\\bar\\\\'))
 
373
 
 
374
    def test_forward_slashes(self):
 
375
        """tests that multiple foward slashes are collapsed to single forward
 
376
        slashes and trailing forward slashes are removed"""
 
377
        self.assertEqual(u'/', normalize_pattern(u'/'))
 
378
        self.assertEqual(u'/', normalize_pattern(u'//'))
 
379
        self.assertEqual(u'/foo/bar', normalize_pattern(u'/foo/bar'))
 
380
        self.assertEqual(u'foo/bar', normalize_pattern(u'foo/bar/'))
 
381
        self.assertEqual(u'/foo/bar', normalize_pattern(u'//foo//bar//'))
 
382
 
 
383
    def test_mixed_slashes(self):
 
384
        """tests that multiple mixed slashes are collapsed to single forward
 
385
        slashes and trailing mixed slashes are removed"""
 
386
        self.assertEqual(u'/foo/bar', normalize_pattern(u'\\/\\foo//\\///bar/\\\\/'))