~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_globbing.py

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

• reverse the comparison (2220.1.14 to 5200.1.2)
• stop comparing with revision 5200.1.2

Show diffs side-by-side

added

removed

bzrlib/tests/test_globbing.py

1

 

# Copyright (C) 2006-2010 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

 

16

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

17

17

 

18

18

from bzrlib.globbing import (

19

19

    Globster,

20

 

    ExceptionGlobster,

21

 

    _OrderedGlobster,

22

 

    normalize_pattern

23

20

    )

24

21

from bzrlib.tests import (

25

 

    TestCase,

 

22

    TestCase, 

26

23

    TestCaseInTempDir,

27

24

    )

28

25

 

117

114

            (u'[a-z]',

118

115

             [u'a', u'q', u'f'],

119

116

             [u'A', u'Q', u'F']),

120

 

            (u'[^a-z]',

 

117

            (ur'[^a-z]',

121

118

             [u'A', u'Q', u'F'],

122

119

             [u'a', u'q', u'f']),

123

120

            (u'[!a-z]foo',

124

121

             [u'Afoo', u'.foo'],

125

122

             [u'afoo', u'ABfoo']),

126

 

            (u'foo[!a-z]bar',

 

123

            (ur'foo[!a-z]bar',

127

124

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

128

125

             [u'foojbar']),

129

 

            (u'[\x20-\x30\u8336]',

 

126

            (ur'[\x20-\x30\u8336]',

130

127

             [u'\040', u'\044', u'\u8336'],

131

128

             [u'\x1f']),

132

 

            (u'[^\x20-\x30\u8336]',

 

129

            (ur'[^\x20-\x30\u8336]',

133

130

             [u'\x1f'],

134

131

             [u'\040', u'\044', u'\u8336']),

135

132

            ])

136

133

 

137

134

    def test_regex(self):

138

135

        self.assertMatch([

139

 

            (u'RE:(a|b|c+)',

140

 

             [u'a', u'b', u'ccc'],

141

 

             [u'd', u'aa', u'c+', u'-a']),

142

 

            (u'RE:(?:a|b|c+)',

143

 

             [u'a', u'b', u'ccc'],

144

 

             [u'd', u'aa', u'c+', u'-a']),

145

 

            (u'RE:(?P<a>.)(?P=a)',

 

136

            (ur'RE:(a|b|c+)',

 

137

             [u'a', u'b', u'ccc'],

 

138

             [u'd', u'aa', u'c+', u'-a']),

 

139

            (ur'RE:(?:a|b|c+)',

 

140

             [u'a', u'b', u'ccc'],

 

141

             [u'd', u'aa', u'c+', u'-a']),

 

142

            (ur'RE:(?P<a>.)(?P=a)',

146

143

             [u'a'],

147

144

             [u'ab', u'aa', u'aaa']),

148

 

            # test we can handle odd numbers of trailing backslashes

149

 

            (u'RE:a\\\\\\',

150

 

             [u'a\\'],

151

 

             [u'a', u'ab', u'aa', u'aaa']),

152

145

            ])

153

146

 

154

147

    def test_question_mark(self):

173

166

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

174

167

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

175

168

            (u'*/*x',

176

 

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

 

169

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

177

170

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

178

171

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

179

172

            (u'f*',

180

173

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

181

174

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

182

175

            (u'*bar',

183

 

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

 

176

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

184

177

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

185

178

             []),

186

179

            ])

193

186

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

194

187

            (u'**/bar',

195

188

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

196

 

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

 

189

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

197

190

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

198

191

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

199

192

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

201

194

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

202

195

            (u'***/bar',

203

196

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

204

 

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

 

197

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

205

198

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

206

199

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

207

200

            # unless it is a whole path component

218

211

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

219

212

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

220

213

            (u'**bar',

221

 

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

 

214

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

222

215

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

223

216

             []),

224

217

            ])

233

226

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

234

227

            ])

235

228

 

236

 

    def test_backslash(self):

237

 

        self.assertMatch([

238

 

            (u'.\\foo',

239

 

             [u'foo'],

240

 

             [u'\u8336/foo', u'barfoo', u'x/y/foo']),

241

 

            (u'.\\f*',

242

 

             [u'foo'],

243

 

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

244

 

            (u'foo\\**\\x',

245

 

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

246

 

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

247

 

            ])

248

 

 

249

 

    def test_trailing_slash(self):

250

 

        self.assertMatch([

251

 

            (u'./foo/',

252

 

             [u'foo'],

253

 

             [u'\u8336/foo', u'barfoo', u'x/y/foo']),

254

 

            (u'.\\foo\\',

255

 

             [u'foo'],

256

 

             [u'foo/', u'\u8336/foo', u'barfoo', u'x/y/foo']),

257

 

            ])

258

 

 

259

229

    def test_leading_asterisk_dot(self):

260

230

        self.assertMatch([

261

231

            (u'*.x',

262

 

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

 

232

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

263

233

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

264

234

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

265

235

            (u'foo/*.bar',

295

265

    def test_large_globset(self):

296

266

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

297

267

 

298

 

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

 

268

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

299

269

        i.e. 99.

300

270

        This test assumes the globs are broken into regexs containing 99

301

271

        groups.

308

278

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

309

279

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

310

280

 

311

 

class TestExceptionGlobster(TestCase):

312

 

 

313

 

    def test_exclusion_patterns(self):

314

 

        """test that exception patterns are not matched"""

315

 

        patterns = [ u'*', u'!./local', u'!./local/**/*', u'!RE:\.z.*',u'!!./.zcompdump' ]

316

 

        globster = ExceptionGlobster(patterns)

317

 

        self.assertEqual(u'*', globster.match('tmp/foo.txt'))

318

 

        self.assertEqual(None, globster.match('local'))

319

 

        self.assertEqual(None, globster.match('local/bin/wombat'))

320

 

        self.assertEqual(None, globster.match('.zshrc'))

321

 

        self.assertEqual(None, globster.match('.zfunctions/fiddle/flam'))

322

 

        self.assertEqual(u'!!./.zcompdump', globster.match('.zcompdump'))

323

 

 

324

 

    def test_exclusion_order(self):

325

 

        """test that ordering of exclusion patterns does not matter"""

326

 

        patterns = [ u'static/**/*.html', u'!static/**/versionable.html']

327

 

        globster = ExceptionGlobster(patterns)

328

 

        self.assertEqual(u'static/**/*.html', globster.match('static/foo.html'))

329

 

        self.assertEqual(None, globster.match('static/versionable.html'))

330

 

        self.assertEqual(None, globster.match('static/bar/versionable.html'))

331

 

        globster = ExceptionGlobster(reversed(patterns))

332

 

        self.assertEqual(u'static/**/*.html', globster.match('static/foo.html'))

333

 

        self.assertEqual(None, globster.match('static/versionable.html'))

334

 

        self.assertEqual(None, globster.match('static/bar/versionable.html'))

335

 

 

336

 

class TestOrderedGlobster(TestCase):

337

 

 

338

 

    def test_ordered_globs(self):

339

 

        """test that the first match in a list is the one found"""

340

 

        patterns = [ u'*.foo', u'bar.*']

341

 

        globster = _OrderedGlobster(patterns)

342

 

        self.assertEqual(u'*.foo', globster.match('bar.foo'))

343

 

        self.assertEqual(None, globster.match('foo.bar'))

344

 

        globster = _OrderedGlobster(reversed(patterns))

345

 

        self.assertEqual(u'bar.*', globster.match('bar.foo'))

346

 

        self.assertEqual(None, globster.match('foo.bar'))

347

 

 

348

 

 

349

 

class TestNormalizePattern(TestCase):

350

 

 

351

 

    def test_backslashes(self):

352

 

        """tests that backslashes are converted to forward slashes, multiple

353

 

        backslashes are collapsed to single forward slashes and trailing

354

 

        backslashes are removed"""

355

 

        self.assertEqual(u'/', normalize_pattern(u'\\'))

356

 

        self.assertEqual(u'/', normalize_pattern(u'\\\\'))

357

 

        self.assertEqual(u'/foo/bar', normalize_pattern(u'\\foo\\bar'))

358

 

        self.assertEqual(u'foo/bar', normalize_pattern(u'foo\\bar\\'))

359

 

        self.assertEqual(u'/foo/bar', normalize_pattern(u'\\\\foo\\\\bar\\\\'))

360

 

 

361

 

    def test_forward_slashes(self):

362

 

        """tests that multiple foward slashes are collapsed to single forward

363

 

        slashes and trailing forward slashes are removed"""

364

 

        self.assertEqual(u'/', normalize_pattern(u'/'))

365

 

        self.assertEqual(u'/', normalize_pattern(u'//'))

366

 

        self.assertEqual(u'/foo/bar', normalize_pattern(u'/foo/bar'))

367

 

        self.assertEqual(u'foo/bar', normalize_pattern(u'foo/bar/'))

368

 

        self.assertEqual(u'/foo/bar', normalize_pattern(u'//foo//bar//'))

369

 

 

370

 

    def test_mixed_slashes(self):

371

 

        """tests that multiple mixed slashes are collapsed to single forward

372

 

        slashes and trailing mixed slashes are removed"""

373

 

        self.assertEqual(u'/foo/bar', normalize_pattern(u'\\/\\foo//\\///bar/\\\\/'))

• Older »

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