~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_globbing.py

• browse files at revision 3408
• compare with another revision
• download diff
• download tarball
• view history from revision 3408

• reverse the comparison (3408 to 6582)
• stop comparing with revision 6582

Show diffs side-by-side

added

removed

bzrlib/tests/test_globbing.py

1

 

# Copyright (C) 2006-2011 Canonical Ltd

 

1

# Copyright (C) 2006 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

17

 

 

18

 

import re

19

 

 

20

 

from bzrlib import errors

 

16

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 

17

 

21

18

from bzrlib.globbing import (

22

19

    Globster,

23

 

    ExceptionGlobster,

24

 

    _OrderedGlobster,

25

 

    normalize_pattern

26

20

    )

27

21

from bzrlib.tests import (

28

 

    TestCase,

 

22

    TestCase, 

 

23

    TestCaseInTempDir,

29

24

    )

30

25

 

31

26

 

37

32

                glob = glob_prefix + glob

38

33

            globster = Globster([glob])

39

34

            for name in positive:

40

 

                self.assertTrue(globster.match(name), repr(

 

35

                self.failUnless(globster.match(name), repr(

41

36

                    u'name "%s" does not match glob "%s" (re=%s)' %

42

37

                    (name, glob, globster._regex_patterns[0][0].pattern)))

43

38

            for name in negative:

44

 

                self.assertFalse(globster.match(name), repr(

 

39

                self.failIf(globster.match(name), repr(

45

40

                    u'name "%s" does match glob "%s" (re=%s)' %

46

41

                    (name, glob, globster._regex_patterns[0][0].pattern)))

47

42

 

54

49

    def test_char_group_digit(self):

55

50

        self.assertMatchBasenameAndFullpath([

56

51

            # The definition of digit this uses includes arabic digits from

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>

 

52

            # non-latin scripts (arabic, indic, etc.) and subscript/superscript

 

53

            # digits, but neither roman numerals nor vulgar fractions.

61

54

            (u'[[:digit:]]',

62

 

             [u'0', u'5', u'\u0663', u'\u06f9', u'\u0f21'],

 

55

             [u'0', u'5', u'\u0663', u'\u06f9', u'\u0f21', u'\xb9'],

63

56

             [u'T', u'q', u' ', u'\u8336', u'.']),

64

57

            (u'[^[:digit:]]',

65

58

             [u'T', u'q', u' ', u'\u8336', u'.'],

66

 

             [u'0', u'5', u'\u0663', u'\u06f9', u'\u0f21']),

 

59

             [u'0', u'5', u'\u0663', u'\u06f9', u'\u0f21', u'\xb9']),

67

60

            ])

68

61

 

69

62

    def test_char_group_space(self):

177

170

             [u'foo/x', u'foo/bax', u'foo/a.x', u'foo/.x', u'foo/.q.x'],

178

171

             [u'foo/bar/bax']),

179

172

            (u'*/*x',

180

 

             [u'\u8336/x', u'foo/x', u'foo/bax', u'x/a.x', u'.foo/x',

 

173

             [u'\u8336/x', u'foo/x', u'foo/bax', u'x/a.x', u'.foo/x', 

181

174

              u'\u8336/.x', u'foo/.q.x'],

182

175

             [u'foo/bar/bax']),

183

176

            (u'f*',

184

177

             [u'foo', u'foo.bar'],

185

178

             [u'.foo', u'foo/bar', u'foo/.bar']),

186

179

            (u'*bar',

187

 

             [u'bar', u'foobar', ur'foo\nbar', u'foo.bar', u'foo/bar',

 

180

             [u'bar', u'foobar', ur'foo\nbar', u'foo.bar', u'foo/bar', 

188

181

              u'foo/foobar', u'foo/f.bar', u'.bar', u'foo/.bar'],

189

182

             []),

190

183

            ])

197

190

             [u'foox', u'foo/bax', u'foo/.x', u'foo/bar/bax']),

198

191

            (u'**/bar',

199

192

             [u'bar', u'foo/bar'],

200

 

             [u'foobar', u'foo.bar', u'foo/foobar', u'foo/f.bar',

 

193

             [u'foobar', u'foo.bar', u'foo/foobar', u'foo/f.bar', 

201

194

              u'.bar', u'foo/.bar']),

202

195

            # check that we ignore extra *s, so *** is treated like ** not *.

203

196

            (u'foo/***/x',

205

198

             [u'foox', u'foo/bax', u'foo/.x', u'foo/bar/bax']),

206

199

            (u'***/bar',

207

200

             [u'bar', u'foo/bar'],

208

 

             [u'foobar', u'foo.bar', u'foo/foobar', u'foo/f.bar',

 

201

             [u'foobar', u'foo.bar', u'foo/foobar', u'foo/f.bar', 

209

202

              u'.bar', u'foo/.bar']),

210

203

            # the remaining tests check that ** is interpreted as *

211

204

            # unless it is a whole path component

222

215

             [u'foo', u'foo.bar'],

223

216

             [u'.foo', u'foo/bar', u'foo/.bar']),

224

217

            (u'**bar',

225

 

             [u'bar', u'foobar', ur'foo\nbar', u'foo.bar', u'foo/bar',

 

218

             [u'bar', u'foobar', ur'foo\nbar', u'foo.bar', u'foo/bar', 

226

219

              u'foo/foobar', u'foo/f.bar', u'.bar', u'foo/.bar'],

227

220

             []),

228

221

            ])

263

256

    def test_leading_asterisk_dot(self):

264

257

        self.assertMatch([

265

258

            (u'*.x',

266

 

             [u'foo/bar/baz.x', u'\u8336/Q.x', u'foo.y.x', u'.foo.x',

 

259

             [u'foo/bar/baz.x', u'\u8336/Q.x', u'foo.y.x', u'.foo.x', 

267

260

              u'bar/.foo.x', u'.x',],

268

261

             [u'foo.x.y']),

269

262

            (u'foo/*.bar',

299

292

    def test_large_globset(self):

300

293

        """tests that the globster can handle a large set of patterns.

301

294

 

302

 

        Large is defined as more than supported by python regex groups,

 

295

        Large is defined as more than supported by python regex groups, 

303

296

        i.e. 99.

304

297

        This test assumes the globs are broken into regexs containing 99

305

298

        groups.

312

305

            self.assertEqual(patterns[x],globster.match(filename))

313

306

        self.assertEqual(None,globster.match('foobar.300'))

314

307

 

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/\\\\/'))

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1