1
# Copyright (C) 2010, 2011, 2012, 2016 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
from __future__ import absolute_import
21
import unicodedata as ud
23
from .. import tests, osutils
24
from ..sixish import PY3
25
from .._termcolor import color_string, FG
27
from ..tests.features import (
28
UnicodeFilenameFeature,
31
# NOTE: As bzr-grep optimizes PATTERN search to -F/--fixed-string
32
# for patterns that are not alphanumeric+whitespace, we test grep
33
# specfically with patterns that have special characters so that
34
# regex path is tested. alphanumeric patterns test the -F path.
37
class GrepTestBase(tests.TestCaseWithTransport):
38
"""Base class for testing grep.
40
Provides support methods for creating directory and file revisions.
42
_reflags = re.MULTILINE | re.DOTALL
44
def _mk_file(self, path, line_prefix, total_lines, versioned):
46
for i in range(total_lines):
47
text += line_prefix + str(i + 1) + "\n"
49
with open(path, 'w') as f:
52
self.run_bzr(['add', path])
53
self.run_bzr(['ci', '-m', '"' + path + '"'])
55
def _update_file(self, path, text, checkin=True):
56
"""append text to file 'path' and check it in"""
57
with open(path, 'a') as f:
60
self.run_bzr(['ci', path, '-m', '"' + path + '"'])
62
def _mk_unknown_file(self, path, line_prefix='line', total_lines=10):
63
self._mk_file(path, line_prefix, total_lines, versioned=False)
65
def _mk_versioned_file(self, path, line_prefix='line', total_lines=10):
66
self._mk_file(path, line_prefix, total_lines, versioned=True)
68
def _mk_dir(self, path, versioned):
71
self.run_bzr(['add', path])
72
self.run_bzr(['ci', '-m', '"' + path + '"'])
74
def _mk_unknown_dir(self, path):
75
self._mk_dir(path, versioned=False)
77
def _mk_versioned_dir(self, path):
78
self._mk_dir(path, versioned=True)
81
class TestGrep(GrepTestBase):
82
"""Core functional tests for grep."""
84
def test_basic_unknown_file(self):
85
"""Search for pattern in specfic file.
87
If specified file is unknown, grep it anyway."""
89
self.make_branch_and_tree(wd)
91
self._mk_unknown_file('file0.txt')
93
out, err = self.run_bzr(['grep', 'line1', 'file0.txt'])
94
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
95
self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
97
out, err = self.run_bzr(['grep', 'line\\d+', 'file0.txt'])
98
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
99
self.assertEqual(len(out.splitlines()), 10)
101
# unknown file is not grepped unless explicitely specified
102
out, err = self.run_bzr(['grep', 'line1'])
103
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
104
self.assertEqual(len(out.splitlines()), 0)
106
# unknown file is not grepped unless explicitely specified
107
out, err = self.run_bzr(['grep', 'line1$'])
108
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
109
self.assertEqual(len(out.splitlines()), 0)
111
def test_ver_basic_file(self):
112
"""(versioned) Search for pattern in specfic file.
115
self.make_branch_and_tree(wd)
117
self._mk_versioned_file('file0.txt')
119
out, err = self.run_bzr(['grep', '-r', '1', 'line1', 'file0.txt'])
120
self.assertContainsRe(out, "file0.txt~1:line1",
121
flags=TestGrep._reflags)
122
self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
124
out, err = self.run_bzr(['grep', '-r', '1', 'line[0-9]$', 'file0.txt'])
125
self.assertContainsRe(out, "file0.txt~1:line1",
126
flags=TestGrep._reflags)
127
self.assertEqual(len(out.splitlines()), 9)
129
# finds all the lines
130
out, err = self.run_bzr(['grep', '-r', '1', 'line[0-9]', 'file0.txt'])
131
self.assertContainsRe(out, "file0.txt~1:line1",
132
flags=TestGrep._reflags)
133
self.assertEqual(len(out.splitlines()), 10)
135
def test_wtree_basic_file(self):
136
"""(wtree) Search for pattern in specfic file.
139
self.make_branch_and_tree(wd)
141
self._mk_versioned_file('file0.txt')
142
self._update_file('file0.txt', 'ABC\n', checkin=False)
144
out, err = self.run_bzr(['grep', 'ABC', 'file0.txt'])
145
self.assertContainsRe(out, "file0.txt:ABC", flags=TestGrep._reflags)
146
self.assertEqual(len(out.splitlines()), 1)
148
out, err = self.run_bzr(['grep', '[A-Z]{3}', 'file0.txt'])
149
self.assertContainsRe(out, "file0.txt:ABC", flags=TestGrep._reflags)
150
self.assertEqual(len(out.splitlines()), 1)
152
out, err = self.run_bzr(['grep', '-r', 'last:1', 'ABC', 'file0.txt'])
153
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
154
self.assertEqual(len(out.splitlines()), 0)
156
out, err = self.run_bzr(
157
['grep', '-r', 'last:1', '[A-Z]{3}', 'file0.txt'])
158
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
159
self.assertEqual(len(out.splitlines()), 0)
161
def test_ver_basic_include(self):
162
"""(versioned) Ensure that -I flag is respected.
165
self.make_branch_and_tree(wd)
167
self._mk_versioned_file('file0.aa')
168
self._mk_versioned_file('file0.bb')
169
self._mk_versioned_file('file0.cc')
171
out, err = self.run_bzr(['grep', '-r', 'last:1',
172
'--include', '*.aa', '--include', '*.bb', 'line1'])
173
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
174
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
175
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
176
# two lines each (line1, line10) from file0.aa and file0.bb
177
self.assertEqual(len(out.splitlines()), 4)
179
out, err = self.run_bzr(['grep', '-r', 'last:1',
180
'--include', '*.aa', '--include', '*.bb', 'line1$'])
181
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
182
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
183
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
184
# one lines each (line1) from file0.aa and file0.bb
185
self.assertEqual(len(out.splitlines()), 2)
187
out, err = self.run_bzr(['grep', '-r', 'last:1',
188
'-I', '*.aa', '-I', '*.bb', 'line1'])
189
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
190
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
191
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
192
# two lines each (line1, line10) from file0.aa and file0.bb
193
self.assertEqual(len(out.splitlines()), 4)
195
out, err = self.run_bzr(['grep', '-r', 'last:1',
196
'-I', '*.aa', '-I', '*.bb', 'line1$'])
197
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
198
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
199
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
200
# one lines each (line1) from file0.aa and file0.bb
201
self.assertEqual(len(out.splitlines()), 2)
203
def test_wtree_basic_include(self):
204
"""(wtree) Ensure that --include flag is respected.
207
self.make_branch_and_tree(wd)
209
self._mk_versioned_file('file0.aa')
210
self._mk_versioned_file('file0.bb')
211
self._mk_versioned_file('file0.cc')
213
out, err = self.run_bzr(['grep', '--include', '*.aa',
214
'--include', '*.bb', 'line1'])
215
self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
216
self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
217
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
218
# two lines each (line1, line10) from file0.aa and file0.bb
219
self.assertEqual(len(out.splitlines()), 4)
221
out, err = self.run_bzr(['grep', '--include', '*.aa',
222
'--include', '*.bb', 'line1$'])
223
self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
224
self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
225
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
226
# one line each (line1) from file0.aa and file0.bb
227
self.assertEqual(len(out.splitlines()), 2)
229
def test_ver_basic_exclude(self):
230
"""(versioned) Ensure that --exclude flag is respected.
233
self.make_branch_and_tree(wd)
235
self._mk_versioned_file('file0.aa')
236
self._mk_versioned_file('file0.bb')
237
self._mk_versioned_file('file0.cc')
239
out, err = self.run_bzr(['grep', '-r', 'last:1',
240
'--exclude', '*.cc', 'line1'])
241
self.assertContainsRe(out, "file0.aa~.:line1$",
242
flags=TestGrep._reflags)
243
self.assertContainsRe(out, "file0.bb~.:line1$",
244
flags=TestGrep._reflags)
245
self.assertContainsRe(out, "file0.aa~.:line10",
246
flags=TestGrep._reflags)
247
self.assertContainsRe(out, "file0.bb~.:line10",
248
flags=TestGrep._reflags)
249
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
250
# two lines each (line1, line10) from file0.aa and file0.bb
251
self.assertEqual(len(out.splitlines()), 4)
253
out, err = self.run_bzr(['grep', '-r', 'last:1',
254
'--exclude', '*.cc', 'line1$'])
255
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
256
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
257
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
258
# one line each (line1) from file0.aa and file0.bb
259
self.assertEqual(len(out.splitlines()), 2)
261
out, err = self.run_bzr(['grep', '-r', 'last:1',
262
'-X', '*.cc', 'line1'])
263
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
264
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
265
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
266
# two lines each (line1, line10) from file0.aa and file0.bb
267
self.assertEqual(len(out.splitlines()), 4)
269
def test_wtree_basic_exclude(self):
270
"""(wtree) Ensure that --exclude flag is respected.
273
self.make_branch_and_tree(wd)
275
self._mk_versioned_file('file0.aa')
276
self._mk_versioned_file('file0.bb')
277
self._mk_versioned_file('file0.cc')
279
out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'line1'])
280
self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
281
self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
282
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
283
# two lines each (line1, line10) from file0.aa and file0.bb
284
self.assertEqual(len(out.splitlines()), 4)
286
out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'lin.1$'])
287
self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
288
self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
289
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
290
# one line each (line1) from file0.aa and file0.bb
291
self.assertEqual(len(out.splitlines()), 2)
293
def test_ver_multiple_files(self):
294
"""(versioned) Search for pattern in multiple files.
297
self.make_branch_and_tree(wd)
299
self._mk_versioned_file('file0.txt', total_lines=2)
300
self._mk_versioned_file('file1.txt', total_lines=2)
301
self._mk_versioned_file('file2.txt', total_lines=2)
303
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line[1-2]$'])
304
self.assertContainsRe(out, "file0.txt~.:line1",
305
flags=TestGrep._reflags)
306
self.assertContainsRe(out, "file0.txt~.:line2",
307
flags=TestGrep._reflags)
308
self.assertContainsRe(out, "file1.txt~.:line1",
309
flags=TestGrep._reflags)
310
self.assertContainsRe(out, "file1.txt~.:line2",
311
flags=TestGrep._reflags)
312
self.assertContainsRe(out, "file2.txt~.:line1",
313
flags=TestGrep._reflags)
314
self.assertContainsRe(out, "file2.txt~.:line2",
315
flags=TestGrep._reflags)
316
self.assertEqual(len(out.splitlines()), 6)
318
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line'])
319
self.assertContainsRe(out, "file0.txt~.:line1",
320
flags=TestGrep._reflags)
321
self.assertContainsRe(out, "file0.txt~.:line2",
322
flags=TestGrep._reflags)
323
self.assertContainsRe(out, "file1.txt~.:line1",
324
flags=TestGrep._reflags)
325
self.assertContainsRe(out, "file1.txt~.:line2",
326
flags=TestGrep._reflags)
327
self.assertContainsRe(out, "file2.txt~.:line1",
328
flags=TestGrep._reflags)
329
self.assertContainsRe(out, "file2.txt~.:line2",
330
flags=TestGrep._reflags)
331
self.assertEqual(len(out.splitlines()), 6)
333
def test_multiple_wtree_files(self):
334
"""(wtree) Search for pattern in multiple files in working tree.
337
self.make_branch_and_tree(wd)
339
self._mk_versioned_file('file0.txt', total_lines=2)
340
self._mk_versioned_file('file1.txt', total_lines=2)
341
self._mk_versioned_file('file2.txt', total_lines=2)
342
self._update_file('file0.txt', 'HELLO\n', checkin=False)
343
self._update_file('file1.txt', 'HELLO\n', checkin=True)
344
self._update_file('file2.txt', 'HELLO\n', checkin=False)
346
out, err = self.run_bzr(['grep', 'HELLO',
347
'file0.txt', 'file1.txt', 'file2.txt'])
349
self.assertContainsRe(out, "file0.txt:HELLO", flags=TestGrep._reflags)
350
self.assertContainsRe(out, "file1.txt:HELLO", flags=TestGrep._reflags)
351
self.assertContainsRe(out, "file2.txt:HELLO", flags=TestGrep._reflags)
352
self.assertEqual(len(out.splitlines()), 3)
354
out, err = self.run_bzr(['grep', 'HELLO', '-r', 'last:1',
355
'file0.txt', 'file1.txt', 'file2.txt'])
357
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
358
self.assertContainsRe(out, "file1.txt~.:HELLO",
359
flags=TestGrep._reflags)
360
self.assertNotContainsRe(out, "file2.txt", flags=TestGrep._reflags)
361
self.assertEqual(len(out.splitlines()), 1)
363
out, err = self.run_bzr(['grep', 'HE..O',
364
'file0.txt', 'file1.txt', 'file2.txt'])
366
self.assertContainsRe(out, "file0.txt:HELLO", flags=TestGrep._reflags)
367
self.assertContainsRe(out, "file1.txt:HELLO", flags=TestGrep._reflags)
368
self.assertContainsRe(out, "file2.txt:HELLO", flags=TestGrep._reflags)
369
self.assertEqual(len(out.splitlines()), 3)
371
out, err = self.run_bzr(['grep', 'HE..O', '-r', 'last:1',
372
'file0.txt', 'file1.txt', 'file2.txt'])
374
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
375
self.assertContainsRe(out, "file1.txt~.:HELLO",
376
flags=TestGrep._reflags)
377
self.assertNotContainsRe(out, "file2.txt", flags=TestGrep._reflags)
378
self.assertEqual(len(out.splitlines()), 1)
380
def test_ver_null_option(self):
381
"""(versioned) --null option should use NUL instead of newline.
384
self.make_branch_and_tree(wd)
386
self._mk_versioned_file('file0.txt', total_lines=3)
389
u'NFC', u"file0.txt~1:line1\0file0.txt~1:line2\0file0.txt~1:line3\0")
391
out, err = self.run_bzr(
392
['grep', '-r', 'last:1', '--null', 'line[1-3]'])
394
out = out.decode('utf-8', 'ignore')
395
nout = ud.normalize(u'NFC', out)
396
self.assertEqual(nout, nref)
397
self.assertEqual(len(out.splitlines()), 1)
399
out, err = self.run_bzr(['grep', '-r', 'last:1', '-Z', 'line[1-3]'])
401
out = out.decode('utf-8', 'ignore')
402
nout = ud.normalize(u'NFC', out)
403
self.assertEqual(nout, nref)
404
self.assertEqual(len(out.splitlines()), 1)
406
out, err = self.run_bzr(['grep', '-r', 'last:1', '--null', 'line'])
408
out = out.decode('utf-8', 'ignore')
409
nout = ud.normalize(u'NFC', out)
410
self.assertEqual(nout, nref)
411
self.assertEqual(len(out.splitlines()), 1)
413
def test_wtree_null_option(self):
414
"""(wtree) --null option should use NUL instead of newline.
417
self.make_branch_and_tree(wd)
419
self._mk_versioned_file('file0.txt', total_lines=3)
421
out, err = self.run_bzr(['grep', '--null', 'line[1-3]'])
423
out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
424
self.assertEqual(len(out.splitlines()), 1)
426
out, err = self.run_bzr(['grep', '-Z', 'line[1-3]'])
428
out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
429
self.assertEqual(len(out.splitlines()), 1)
431
out, err = self.run_bzr(['grep', '-Z', 'line'])
433
out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
434
self.assertEqual(len(out.splitlines()), 1)
436
def test_versioned_file_in_dir_no_recursive(self):
437
"""(versioned) Should not recurse with --no-recursive"""
439
self.make_branch_and_tree(wd)
441
self._mk_versioned_file('fileX.txt', line_prefix='lin')
442
self._mk_versioned_dir('dir0')
443
self._mk_versioned_file('dir0/file0.txt')
445
out, err = self.run_bzr(
446
['grep', '-r', 'last:1', '--no-recursive', 'line1'])
447
self.assertNotContainsRe(
448
out, "file0.txt~.:line1", flags=TestGrep._reflags)
449
self.assertEqual(len(out.splitlines()), 0)
451
out, err = self.run_bzr(
452
['grep', '-r', 'last:1', '--no-recursive', 'line1$'])
453
self.assertNotContainsRe(
454
out, "file0.txt~.:line1", flags=TestGrep._reflags)
455
self.assertEqual(len(out.splitlines()), 0)
457
def test_wtree_file_in_dir_no_recursive(self):
458
"""(wtree) Should not recurse with --no-recursive"""
460
self.make_branch_and_tree(wd)
462
self._mk_versioned_file('fileX.txt', line_prefix='lin')
463
self._mk_versioned_dir('dir0')
464
self._mk_versioned_file('dir0/file0.txt')
466
out, err = self.run_bzr(['grep', '--no-recursive', 'line1'])
467
self.assertNotContainsRe(
468
out, "file0.txt:line1", flags=TestGrep._reflags)
469
self.assertEqual(len(out.splitlines()), 0)
471
out, err = self.run_bzr(['grep', '--no-recursive', 'lin.1'])
472
self.assertNotContainsRe(
473
out, "file0.txt:line1", flags=TestGrep._reflags)
474
self.assertEqual(len(out.splitlines()), 0)
476
def test_versioned_file_in_dir_recurse(self):
477
"""(versioned) Should recurse by default.
480
self.make_branch_and_tree(wd)
482
self._mk_versioned_dir('dir0')
483
self._mk_versioned_file('dir0/file0.txt')
485
out, err = self.run_bzr(['grep', '-r', '-1', '.i.e1'])
486
self.assertContainsRe(
487
out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
488
# find line1 and line10
489
self.assertEqual(len(out.splitlines()), 2)
491
out, err = self.run_bzr(['grep', '-r', '-1', 'line1'])
492
self.assertContainsRe(
493
out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
494
# find line1 and line10
495
self.assertEqual(len(out.splitlines()), 2)
497
def test_wtree_file_in_dir_recurse(self):
498
"""(wtree) Should recurse by default.
501
self.make_branch_and_tree(wd)
503
self._mk_versioned_dir('dir0')
504
self._mk_versioned_file('dir0/file0.txt')
506
out, err = self.run_bzr(['grep', 'line1'])
507
self.assertContainsRe(out, "^dir0/file0.txt:line1",
508
flags=TestGrep._reflags)
509
# find line1 and line10
510
self.assertEqual(len(out.splitlines()), 2)
512
out, err = self.run_bzr(['grep', 'lin.1'])
513
self.assertContainsRe(out, "^dir0/file0.txt:line1",
514
flags=TestGrep._reflags)
515
# find line1 and line10
516
self.assertEqual(len(out.splitlines()), 2)
518
def test_versioned_file_within_dir(self):
519
"""(versioned) Search for pattern while in nested dir.
522
self.make_branch_and_tree(wd)
524
self._mk_versioned_dir('dir0')
525
self._mk_versioned_file('dir0/file0.txt')
528
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
529
self.assertContainsRe(out, "^file0.txt~.:line1",
530
flags=TestGrep._reflags)
531
# finds line1 and line10
532
self.assertEqual(len(out.splitlines()), 2)
534
out, err = self.run_bzr(['grep', '-r', 'last:1', '.i.e1'])
535
self.assertContainsRe(out, "^file0.txt~.:line1",
536
flags=TestGrep._reflags)
537
# finds line1 and line10
538
self.assertEqual(len(out.splitlines()), 2)
540
def test_versioned_include_file_within_dir(self):
541
"""(versioned) Ensure --include is respected with file within dir.
544
self.make_branch_and_tree(wd)
546
self._mk_versioned_dir('dir0') # revno 1
547
self._mk_versioned_file('dir0/file0.txt') # revno 2
548
self._mk_versioned_file('dir0/file1.aa') # revno 3
549
self._update_file('dir0/file1.aa', 'hello\n') # revno 4
550
self._update_file('dir0/file0.txt', 'hello\n') # revno 5
553
out, err = self.run_bzr(['grep', '-r', 'last:1',
554
'--include', '*.aa', 'line1'])
555
self.assertContainsRe(out, "^file1.aa~5:line1$",
556
flags=TestGrep._reflags)
557
self.assertContainsRe(out, "^file1.aa~5:line10$",
558
flags=TestGrep._reflags)
559
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
560
# finds line1 and line10
561
self.assertEqual(len(out.splitlines()), 2)
563
out, err = self.run_bzr(['grep', '-r', 'last:2..last:1',
564
'--include', '*.aa', 'line1'])
565
self.assertContainsRe(out, "^file1.aa~4:line1$",
566
flags=TestGrep._reflags)
567
self.assertContainsRe(out, "^file1.aa~4:line10$",
568
flags=TestGrep._reflags)
569
self.assertContainsRe(out, "^file1.aa~5:line1$",
570
flags=TestGrep._reflags)
571
self.assertContainsRe(out, "^file1.aa~5:line10$",
572
flags=TestGrep._reflags)
573
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
574
# finds line1 and line10 over two revisions
575
self.assertEqual(len(out.splitlines()), 4)
577
out, err = self.run_bzr(['grep', '-r', 'last:1',
578
'--include', '*.aa', 'lin.1'])
579
self.assertContainsRe(out, "^file1.aa~5:line1$",
580
flags=TestGrep._reflags)
581
self.assertContainsRe(out, "^file1.aa~5:line10$",
582
flags=TestGrep._reflags)
583
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
584
# finds line1 and line10
585
self.assertEqual(len(out.splitlines()), 2)
587
out, err = self.run_bzr(['grep', '-r', 'last:3..last:1',
588
'--include', '*.aa', 'lin.1'])
589
self.assertContainsRe(out, "^file1.aa~3:line1$",
590
flags=TestGrep._reflags)
591
self.assertContainsRe(out, "^file1.aa~4:line1$",
592
flags=TestGrep._reflags)
593
self.assertContainsRe(out, "^file1.aa~5:line1$",
594
flags=TestGrep._reflags)
595
self.assertContainsRe(out, "^file1.aa~3:line10$",
596
flags=TestGrep._reflags)
597
self.assertContainsRe(out, "^file1.aa~4:line10$",
598
flags=TestGrep._reflags)
599
self.assertContainsRe(out, "^file1.aa~5:line10$",
600
flags=TestGrep._reflags)
601
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
602
# finds line1 and line10 over 3 revisions
603
self.assertEqual(len(out.splitlines()), 6)
605
def test_versioned_exclude_file_within_dir(self):
606
"""(versioned) Ensure --exclude is respected with file within dir.
609
self.make_branch_and_tree(wd)
611
self._mk_versioned_dir('dir0')
612
self._mk_versioned_file('dir0/file0.txt')
613
self._mk_versioned_file('dir0/file1.aa')
616
out, err = self.run_bzr(['grep', '-r', 'last:1',
617
'--exclude', '*.txt', 'line1'])
618
self.assertContainsRe(out, "^file1.aa~.:line1",
619
flags=TestGrep._reflags)
620
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
621
# finds line1 and line10
622
self.assertEqual(len(out.splitlines()), 2)
624
out, err = self.run_bzr(['grep', '-r', 'last:1',
625
'--exclude', '*.txt', 'l[a-z]ne1'])
626
self.assertContainsRe(out, "^file1.aa~.:line1",
627
flags=TestGrep._reflags)
628
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
629
# finds line1 and line10
630
self.assertEqual(len(out.splitlines()), 2)
632
def test_wtree_file_within_dir(self):
633
"""(wtree) Search for pattern while in nested dir.
636
self.make_branch_and_tree(wd)
638
self._mk_versioned_dir('dir0')
639
self._mk_versioned_file('dir0/file0.txt')
642
out, err = self.run_bzr(['grep', 'line1'])
643
self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
644
# finds line1 and line10
645
self.assertEqual(len(out.splitlines()), 2)
647
out, err = self.run_bzr(['grep', 'l[aeiou]ne1'])
648
self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
649
# finds line1 and line10
650
self.assertEqual(len(out.splitlines()), 2)
652
def test_wtree_include_file_within_dir(self):
653
"""(wtree) Ensure --include is respected with file within dir.
656
self.make_branch_and_tree(wd)
658
self._mk_versioned_dir('dir0')
659
self._mk_versioned_file('dir0/file0.txt')
660
self._mk_versioned_file('dir0/file1.aa')
663
out, err = self.run_bzr(['grep', '--include', '*.aa', 'line1'])
664
self.assertContainsRe(out, "^file1.aa:line1", flags=TestGrep._reflags)
665
# finds line1 and line10
666
self.assertEqual(len(out.splitlines()), 2)
668
out, err = self.run_bzr(['grep', '--include', '*.aa', 'l[ixn]ne1'])
669
self.assertContainsRe(out, "^file1.aa:line1", flags=TestGrep._reflags)
670
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
671
# finds line1 and line10
672
self.assertEqual(len(out.splitlines()), 2)
674
def test_wtree_exclude_file_within_dir(self):
675
"""(wtree) Ensure --exclude is respected with file within dir.
678
self.make_branch_and_tree(wd)
680
self._mk_versioned_dir('dir0')
681
self._mk_versioned_file('dir0/file0.txt')
682
self._mk_versioned_file('dir0/file1.aa')
685
out, err = self.run_bzr(['grep', '--exclude', '*.txt', 'li.e1'])
686
self.assertContainsRe(out, "^file1.aa:line1$", flags=TestGrep._reflags)
687
self.assertContainsRe(out, "^file1.aa:line10$",
688
flags=TestGrep._reflags)
689
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
690
# finds line1 and line10
691
self.assertEqual(len(out.splitlines()), 2)
693
out, err = self.run_bzr(['grep', '--exclude', '*.txt', 'line1'])
694
self.assertContainsRe(out, "^file1.aa:line1$", flags=TestGrep._reflags)
695
self.assertContainsRe(out, "^file1.aa:line10$",
696
flags=TestGrep._reflags)
697
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
698
# finds line1 and line10
699
self.assertEqual(len(out.splitlines()), 2)
701
def test_versioned_include_from_outside_dir(self):
702
"""(versioned) Ensure --include is respected during recursive search.
705
self.make_branch_and_tree(wd)
708
self._mk_versioned_dir('dir0')
709
self._mk_versioned_file('dir0/file0.aa')
711
self._mk_versioned_dir('dir1')
712
self._mk_versioned_file('dir1/file1.bb')
714
self._mk_versioned_dir('dir2')
715
self._mk_versioned_file('dir2/file2.cc')
717
out, err = self.run_bzr(['grep', '-r', 'last:1',
718
'--include', '*.aa', '--include', '*.bb', 'l..e1'])
719
self.assertContainsRe(
720
out, "^dir0/file0.aa~.:line1$", flags=TestGrep._reflags)
721
self.assertContainsRe(
722
out, "^dir1/file1.bb~.:line1$", flags=TestGrep._reflags)
723
self.assertContainsRe(
724
out, "^dir0/file0.aa~.:line10$", flags=TestGrep._reflags)
725
self.assertContainsRe(
726
out, "^dir1/file1.bb~.:line10$", flags=TestGrep._reflags)
727
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
728
# finds line1 and line10
729
self.assertEqual(len(out.splitlines()), 4)
731
out, err = self.run_bzr(['grep', '-r', 'last:1',
732
'--include', '*.aa', '--include', '*.bb', 'line1'])
733
self.assertContainsRe(
734
out, "^dir0/file0.aa~.:line1$", flags=TestGrep._reflags)
735
self.assertContainsRe(
736
out, "^dir1/file1.bb~.:line1$", flags=TestGrep._reflags)
737
self.assertContainsRe(
738
out, "^dir0/file0.aa~.:line10$", flags=TestGrep._reflags)
739
self.assertContainsRe(
740
out, "^dir1/file1.bb~.:line10$", flags=TestGrep._reflags)
741
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
742
# finds line1 and line10
743
self.assertEqual(len(out.splitlines()), 4)
745
def test_wtree_include_from_outside_dir(self):
746
"""(wtree) Ensure --include is respected during recursive search.
749
self.make_branch_and_tree(wd)
752
self._mk_versioned_dir('dir0')
753
self._mk_versioned_file('dir0/file0.aa')
755
self._mk_versioned_dir('dir1')
756
self._mk_versioned_file('dir1/file1.bb')
758
self._mk_versioned_dir('dir2')
759
self._mk_versioned_file('dir2/file2.cc')
761
out, err = self.run_bzr(['grep', '--include', '*.aa',
762
'--include', '*.bb', 'l.n.1'])
763
self.assertContainsRe(out, "^dir0/file0.aa:line1$",
764
flags=TestGrep._reflags)
765
self.assertContainsRe(out, "^dir1/file1.bb:line1$",
766
flags=TestGrep._reflags)
767
self.assertContainsRe(
768
out, "^dir0/file0.aa:line10$", flags=TestGrep._reflags)
769
self.assertContainsRe(
770
out, "^dir1/file1.bb:line10$", flags=TestGrep._reflags)
771
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
772
# finds line1 and line10
773
self.assertEqual(len(out.splitlines()), 4)
775
out, err = self.run_bzr(['grep', '--include', '*.aa',
776
'--include', '*.bb', 'line1'])
777
self.assertContainsRe(out, "^dir0/file0.aa:line1$",
778
flags=TestGrep._reflags)
779
self.assertContainsRe(out, "^dir1/file1.bb:line1$",
780
flags=TestGrep._reflags)
781
self.assertContainsRe(
782
out, "^dir0/file0.aa:line10$", flags=TestGrep._reflags)
783
self.assertContainsRe(
784
out, "^dir1/file1.bb:line10$", flags=TestGrep._reflags)
785
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
786
# finds line1 and line10
787
self.assertEqual(len(out.splitlines()), 4)
789
def test_versioned_exclude_from_outside_dir(self):
790
"""(versioned) Ensure --exclude is respected during recursive search.
793
self.make_branch_and_tree(wd)
796
self._mk_versioned_dir('dir0')
797
self._mk_versioned_file('dir0/file0.aa')
799
self._mk_versioned_dir('dir1')
800
self._mk_versioned_file('dir1/file1.bb')
802
self._mk_versioned_dir('dir2')
803
self._mk_versioned_file('dir2/file2.cc')
805
out, err = self.run_bzr(['grep', '-r', 'last:1',
806
'--exclude', '*.cc', 'l..e1'])
807
self.assertContainsRe(
808
out, "^dir0/file0.aa~.:line1", flags=TestGrep._reflags)
809
self.assertContainsRe(
810
out, "^dir1/file1.bb~.:line1", flags=TestGrep._reflags)
811
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
813
out, err = self.run_bzr(['grep', '-r', 'last:1',
814
'--exclude', '*.cc', 'line1'])
815
self.assertContainsRe(
816
out, "^dir0/file0.aa~.:line1", flags=TestGrep._reflags)
817
self.assertContainsRe(
818
out, "^dir1/file1.bb~.:line1", flags=TestGrep._reflags)
819
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
821
def test_wtree_exclude_from_outside_dir(self):
822
"""(wtree) Ensure --exclude is respected during recursive search.
825
self.make_branch_and_tree(wd)
828
self._mk_versioned_dir('dir0')
829
self._mk_versioned_file('dir0/file0.aa')
831
self._mk_versioned_dir('dir1')
832
self._mk_versioned_file('dir1/file1.bb')
834
self._mk_versioned_dir('dir2')
835
self._mk_versioned_file('dir2/file2.cc')
837
out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'l[hijk]ne1'])
838
self.assertContainsRe(out, "^dir0/file0.aa:line1",
839
flags=TestGrep._reflags)
840
self.assertContainsRe(out, "^dir1/file1.bb:line1",
841
flags=TestGrep._reflags)
842
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
844
out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'line1'])
845
self.assertContainsRe(out, "^dir0/file0.aa:line1",
846
flags=TestGrep._reflags)
847
self.assertContainsRe(out, "^dir1/file1.bb:line1",
848
flags=TestGrep._reflags)
849
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
851
def test_workingtree_files_from_outside_dir(self):
852
"""(wtree) Grep for pattern with dirs passed as argument.
855
self.make_branch_and_tree(wd)
858
self._mk_versioned_dir('dir0')
859
self._mk_versioned_file('dir0/file0.txt')
861
self._mk_versioned_dir('dir1')
862
self._mk_versioned_file('dir1/file1.txt')
864
out, err = self.run_bzr(['grep', 'l[aeiou]ne1', 'dir0', 'dir1'])
865
self.assertContainsRe(out, "^dir0/file0.txt:line1",
866
flags=TestGrep._reflags)
867
self.assertContainsRe(out, "^dir1/file1.txt:line1",
868
flags=TestGrep._reflags)
870
out, err = self.run_bzr(['grep', 'line1', 'dir0', 'dir1'])
871
self.assertContainsRe(out, "^dir0/file0.txt:line1",
872
flags=TestGrep._reflags)
873
self.assertContainsRe(out, "^dir1/file1.txt:line1",
874
flags=TestGrep._reflags)
876
def test_versioned_files_from_outside_dir(self):
877
"""(versioned) Grep for pattern with dirs passed as argument.
880
self.make_branch_and_tree(wd)
883
self._mk_versioned_dir('dir0')
884
self._mk_versioned_file('dir0/file0.txt')
886
self._mk_versioned_dir('dir1')
887
self._mk_versioned_file('dir1/file1.txt')
889
out, err = self.run_bzr(
890
['grep', '-r', 'last:1', '.ine1', 'dir0', 'dir1'])
891
self.assertContainsRe(
892
out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
893
self.assertContainsRe(
894
out, "^dir1/file1.txt~.:line1", flags=TestGrep._reflags)
896
out, err = self.run_bzr(
897
['grep', '-r', 'last:1', 'line1', 'dir0', 'dir1'])
898
self.assertContainsRe(
899
out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
900
self.assertContainsRe(
901
out, "^dir1/file1.txt~.:line1", flags=TestGrep._reflags)
903
def test_wtree_files_from_outside_dir(self):
904
"""(wtree) Grep for pattern with dirs passed as argument.
907
self.make_branch_and_tree(wd)
910
self._mk_versioned_dir('dir0')
911
self._mk_versioned_file('dir0/file0.txt')
913
self._mk_versioned_dir('dir1')
914
self._mk_versioned_file('dir1/file1.txt')
916
out, err = self.run_bzr(['grep', 'li.e1', 'dir0', 'dir1'])
917
self.assertContainsRe(out, "^dir0/file0.txt:line1",
918
flags=TestGrep._reflags)
919
self.assertContainsRe(out, "^dir1/file1.txt:line1",
920
flags=TestGrep._reflags)
922
out, err = self.run_bzr(['grep', 'line1', 'dir0', 'dir1'])
923
self.assertContainsRe(out, "^dir0/file0.txt:line1",
924
flags=TestGrep._reflags)
925
self.assertContainsRe(out, "^dir1/file1.txt:line1",
926
flags=TestGrep._reflags)
928
def test_versioned_files_from_outside_two_dirs(self):
929
"""(versioned) Grep for pattern with two levels of nested dir.
932
self.make_branch_and_tree(wd)
935
self._mk_versioned_dir('dir0')
936
self._mk_versioned_file('dir0/file0.txt')
938
self._mk_versioned_dir('dir1')
939
self._mk_versioned_file('dir1/file1.txt')
941
self._mk_versioned_dir('dir0/dir00')
942
self._mk_versioned_file('dir0/dir00/file0.txt')
944
out, err = self.run_bzr(
945
['grep', '-r', 'last:1', 'l.ne1', 'dir0/dir00'])
946
self.assertContainsRe(
947
out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
949
out, err = self.run_bzr(['grep', '-r', 'last:1', 'l.ne1'])
950
self.assertContainsRe(
951
out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
953
out, err = self.run_bzr(
954
['grep', '-r', 'last:1', 'line1', 'dir0/dir00'])
955
self.assertContainsRe(
956
out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
958
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
959
self.assertContainsRe(
960
out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
962
def test_wtree_files_from_outside_two_dirs(self):
963
"""(wtree) Grep for pattern with two levels of nested dir.
966
self.make_branch_and_tree(wd)
969
self._mk_versioned_dir('dir0')
970
self._mk_versioned_file('dir0/file0.txt')
972
self._mk_versioned_dir('dir1')
973
self._mk_versioned_file('dir1/file1.txt')
975
self._mk_versioned_dir('dir0/dir00')
976
self._mk_versioned_file('dir0/dir00/file0.txt')
978
out, err = self.run_bzr(['grep', 'lin.1', 'dir0/dir00'])
979
self.assertContainsRe(
980
out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
982
out, err = self.run_bzr(['grep', 'li.e1'])
983
self.assertContainsRe(
984
out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
986
out, err = self.run_bzr(['grep', 'line1', 'dir0/dir00'])
987
self.assertContainsRe(
988
out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
990
out, err = self.run_bzr(['grep', 'line1'])
991
self.assertContainsRe(
992
out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
994
def test_versioned_file_within_dir_two_levels(self):
995
"""(versioned) Search for pattern while in nested dir (two levels).
998
self.make_branch_and_tree(wd)
1000
self._mk_versioned_dir('dir0')
1001
self._mk_versioned_dir('dir0/dir1')
1002
self._mk_versioned_file('dir0/dir1/file0.txt')
1005
out, err = self.run_bzr(['grep', '-r', 'last:1', '.ine1'])
1006
self.assertContainsRe(
1007
out, "^dir1/file0.txt~.:line1", flags=TestGrep._reflags)
1009
out, err = self.run_bzr(
1010
['grep', '-r', 'last:1', '--from-root', 'l.ne1'])
1011
self.assertContainsRe(
1012
out, "^dir0/dir1/file0.txt~.:line1", flags=TestGrep._reflags)
1014
out, err = self.run_bzr(
1015
['grep', '-r', 'last:1', '--no-recursive', 'line1'])
1016
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1018
out, err = self.run_bzr(['grep', '-r', 'last:1', 'lin.1'])
1019
self.assertContainsRe(
1020
out, "^dir1/file0.txt~.:line1", flags=TestGrep._reflags)
1022
out, err = self.run_bzr(
1023
['grep', '-r', 'last:1', '--from-root', 'line1'])
1024
self.assertContainsRe(
1025
out, "^dir0/dir1/file0.txt~.:line1", flags=TestGrep._reflags)
1027
out, err = self.run_bzr(
1028
['grep', '-r', 'last:1', '--no-recursive', 'line1'])
1029
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1030
self.assertEqual(len(out.splitlines()), 0)
1032
def test_wtree_file_within_dir_two_levels(self):
1033
"""(wtree) Search for pattern while in nested dir (two levels).
1036
self.make_branch_and_tree(wd)
1038
self._mk_versioned_dir('dir0')
1039
self._mk_versioned_dir('dir0/dir1')
1040
self._mk_versioned_file('dir0/dir1/file0.txt')
1043
out, err = self.run_bzr(['grep', 'l[hij]ne1'])
1044
self.assertContainsRe(out, "^dir1/file0.txt:line1",
1045
flags=TestGrep._reflags)
1047
out, err = self.run_bzr(['grep', '--from-root', 'l.ne1'])
1048
self.assertContainsRe(
1049
out, "^dir0/dir1/file0.txt:line1", flags=TestGrep._reflags)
1051
out, err = self.run_bzr(['grep', '--no-recursive', 'lin.1'])
1052
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1054
out, err = self.run_bzr(['grep', 'line1'])
1055
self.assertContainsRe(out, "^dir1/file0.txt:line1",
1056
flags=TestGrep._reflags)
1058
out, err = self.run_bzr(['grep', '--from-root', 'line1'])
1059
self.assertContainsRe(
1060
out, "^dir0/dir1/file0.txt:line1", flags=TestGrep._reflags)
1062
out, err = self.run_bzr(['grep', '--no-recursive', 'line1'])
1063
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1065
def test_versioned_ignore_case_no_match(self):
1066
"""(versioned) Match fails without --ignore-case.
1069
self.make_branch_and_tree(wd)
1071
self._mk_versioned_file('file0.txt')
1073
out, err = self.run_bzr(['grep', '-r', 'last:1', 'LinE1', 'file0.txt'])
1074
self.assertNotContainsRe(
1075
out, "file0.txt~.:line1", flags=TestGrep._reflags)
1077
out, err = self.run_bzr(['grep', '-r', 'last:1', 'Li.E1', 'file0.txt'])
1078
self.assertNotContainsRe(
1079
out, "file0.txt~.:line1", flags=TestGrep._reflags)
1081
def test_wtree_ignore_case_no_match(self):
1082
"""(wtree) Match fails without --ignore-case.
1085
self.make_branch_and_tree(wd)
1087
self._mk_versioned_file('file0.txt')
1089
out, err = self.run_bzr(['grep', 'LinE1', 'file0.txt'])
1090
self.assertNotContainsRe(
1091
out, "file0.txt:line1", flags=TestGrep._reflags)
1093
out, err = self.run_bzr(['grep', '.inE1', 'file0.txt'])
1094
self.assertNotContainsRe(
1095
out, "file0.txt:line1", flags=TestGrep._reflags)
1097
def test_versioned_ignore_case_match(self):
1098
"""(versioned) Match fails without --ignore-case.
1101
self.make_branch_and_tree(wd)
1103
self._mk_versioned_file('file0.txt')
1105
out, err = self.run_bzr(['grep', '-r', 'last:1',
1106
'-i', 'Li.E1', 'file0.txt'])
1107
self.assertContainsRe(out, "file0.txt~.:line1",
1108
flags=TestGrep._reflags)
1110
out, err = self.run_bzr(['grep', '-r', 'last:1',
1111
'-i', 'LinE1', 'file0.txt'])
1112
self.assertContainsRe(out, "file0.txt~.:line1",
1113
flags=TestGrep._reflags)
1115
out, err = self.run_bzr(['grep', '-r', 'last:1',
1116
'--ignore-case', 'LinE1', 'file0.txt'])
1117
self.assertContainsRe(out, "^file0.txt~.:line1",
1118
flags=TestGrep._reflags)
1120
def test_wtree_ignore_case_match(self):
1121
"""(wtree) Match fails without --ignore-case.
1124
self.make_branch_and_tree(wd)
1126
self._mk_versioned_file('file0.txt')
1128
out, err = self.run_bzr(['grep', '-i', 'LinE1', 'file0.txt'])
1129
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
1131
out, err = self.run_bzr(
1132
['grep', '--ignore-case', 'LinE1', 'file0.txt'])
1133
self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
1135
out, err = self.run_bzr(
1136
['grep', '--ignore-case', 'Li.E1', 'file0.txt'])
1137
self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
1139
def test_versioned_from_root_fail(self):
1140
"""(versioned) Match should fail without --from-root.
1143
self.make_branch_and_tree(wd)
1145
self._mk_versioned_file('file0.txt')
1146
self._mk_versioned_dir('dir0')
1149
out, err = self.run_bzr(['grep', '-r', 'last:1', 'li.e1'])
1150
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1152
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
1153
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1155
def test_wtree_from_root_fail(self):
1156
"""(wtree) Match should fail without --from-root.
1159
self.make_branch_and_tree(wd)
1161
self._mk_versioned_file('file0.txt')
1162
self._mk_versioned_dir('dir0')
1165
out, err = self.run_bzr(['grep', 'line1'])
1166
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1168
out, err = self.run_bzr(['grep', 'li.e1'])
1169
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1171
def test_versioned_from_root_pass(self):
1172
"""(versioned) Match pass with --from-root.
1175
self.make_branch_and_tree(wd)
1177
self._mk_versioned_file('file0.txt')
1178
self._mk_versioned_dir('dir0')
1181
out, err = self.run_bzr(['grep', '-r', 'last:1',
1182
'--from-root', 'l.ne1'])
1183
self.assertContainsRe(out, "file0.txt~.:line1",
1184
flags=TestGrep._reflags)
1186
out, err = self.run_bzr(['grep', '-r', 'last:1',
1187
'--from-root', 'line1'])
1188
self.assertContainsRe(out, "file0.txt~.:line1",
1189
flags=TestGrep._reflags)
1191
def test_wtree_from_root_pass(self):
1192
"""(wtree) Match pass with --from-root.
1195
self.make_branch_and_tree(wd)
1197
self._mk_versioned_file('file0.txt')
1198
self._mk_versioned_dir('dir0')
1201
out, err = self.run_bzr(['grep', '--from-root', 'lin.1'])
1202
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
1204
out, err = self.run_bzr(['grep', '--from-root', 'line1'])
1205
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
1207
def test_versioned_with_line_number(self):
1208
"""(versioned) Search for pattern with --line-number.
1211
self.make_branch_and_tree(wd)
1213
self._mk_versioned_file('file0.txt')
1215
out, err = self.run_bzr(['grep', '-r', 'last:1',
1216
'--line-number', 'li.e3', 'file0.txt'])
1217
self.assertContainsRe(out, "file0.txt~.:3:line3",
1218
flags=TestGrep._reflags)
1220
out, err = self.run_bzr(['grep', '-r', 'last:1',
1221
'--line-number', 'line3', 'file0.txt'])
1222
self.assertContainsRe(out, "file0.txt~.:3:line3",
1223
flags=TestGrep._reflags)
1225
out, err = self.run_bzr(['grep', '-r', 'last:1',
1226
'-n', 'line1', 'file0.txt'])
1227
self.assertContainsRe(out, "file0.txt~.:1:line1",
1228
flags=TestGrep._reflags)
1230
out, err = self.run_bzr(['grep', '-n', 'line[0-9]', 'file0.txt'])
1231
self.assertContainsRe(out, "file0.txt:3:line3",
1232
flags=TestGrep._reflags)
1234
def test_wtree_with_line_number(self):
1235
"""(wtree) Search for pattern with --line-number.
1238
self.make_branch_and_tree(wd)
1240
self._mk_versioned_file('file0.txt')
1242
out, err = self.run_bzr(
1243
['grep', '--line-number', 'line3', 'file0.txt'])
1244
self.assertContainsRe(out, "file0.txt:3:line3",
1245
flags=TestGrep._reflags)
1247
out, err = self.run_bzr(['grep', '-n', 'line1', 'file0.txt'])
1248
self.assertContainsRe(out, "file0.txt:1:line1",
1249
flags=TestGrep._reflags)
1251
out, err = self.run_bzr(['grep', '-n', '[hjkl]ine1', 'file0.txt'])
1252
self.assertContainsRe(out, "file0.txt:1:line1",
1253
flags=TestGrep._reflags)
1255
out, err = self.run_bzr(['grep', '-n', 'line[0-9]', 'file0.txt'])
1256
self.assertContainsRe(out, "file0.txt:3:line3",
1257
flags=TestGrep._reflags)
1259
def test_revno_basic_history_grep_file(self):
1260
"""Search for pattern in specific revision number in a file.
1264
self.make_branch_and_tree(wd)
1266
self._mk_versioned_file(fname, total_lines=0)
1267
self._update_file(fname, text="v2 text\n")
1268
self._update_file(fname, text="v3 text\n")
1269
self._update_file(fname, text="v4 text\n")
1271
# rev 2 should not have text 'v3'
1272
out, err = self.run_bzr(['grep', '-r', '2', 'v3', fname])
1273
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1275
# rev 3 should not have text 'v3'
1276
out, err = self.run_bzr(['grep', '-r', '3', 'v3', fname])
1277
self.assertContainsRe(out, "file0.txt~3:v3.*", flags=TestGrep._reflags)
1279
# rev 3 should not have text 'v3' with line number
1280
out, err = self.run_bzr(['grep', '-r', '3', '-n', 'v3', fname])
1281
self.assertContainsRe(out, "file0.txt~3:2:v3.*",
1282
flags=TestGrep._reflags)
1284
# rev 2 should not have text 'v3'
1285
out, err = self.run_bzr(['grep', '-r', '2', '[tuv]3', fname])
1286
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1288
# rev 3 should not have text 'v3'
1289
out, err = self.run_bzr(['grep', '-r', '3', '[tuv]3', fname])
1290
self.assertContainsRe(out, "file0.txt~3:v3.*", flags=TestGrep._reflags)
1292
# rev 3 should not have text 'v3' with line number
1293
out, err = self.run_bzr(['grep', '-r', '3', '-n', '[tuv]3', fname])
1294
self.assertContainsRe(out, "file0.txt~3:2:v3.*",
1295
flags=TestGrep._reflags)
1297
def test_revno_basic_history_grep_full(self):
1298
"""Search for pattern in specific revision number in a file.
1302
self.make_branch_and_tree(wd)
1304
self._mk_versioned_file(fname, total_lines=0) # rev1
1305
self._mk_versioned_file('file1.txt') # rev2
1306
self._update_file(fname, text="v3 text\n") # rev3
1307
self._update_file(fname, text="v4 text\n") # rev4
1308
self._update_file(fname, text="v5 text\n") # rev5
1310
# rev 2 should not have text 'v3'
1311
out, err = self.run_bzr(['grep', '-r', '2', 'v3'])
1312
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1314
# rev 3 should not have text 'v3'
1315
out, err = self.run_bzr(['grep', '-r', '3', 'v3'])
1316
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1318
# rev 3 should not have text 'v3' with line number
1319
out, err = self.run_bzr(['grep', '-r', '3', '-n', 'v3'])
1320
self.assertContainsRe(out, "file0.txt~3:1:v3", flags=TestGrep._reflags)
1322
# rev 2 should not have text 'v3'
1323
out, err = self.run_bzr(['grep', '-r', '2', '[tuv]3'])
1324
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1326
# rev 3 should not have text 'v3'
1327
out, err = self.run_bzr(['grep', '-r', '3', '[tuv]3'])
1328
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1330
# rev 3 should not have text 'v3' with line number
1331
out, err = self.run_bzr(['grep', '-r', '3', '-n', '[tuv]3'])
1332
self.assertContainsRe(out, "file0.txt~3:1:v3", flags=TestGrep._reflags)
1334
def test_revno_versioned_file_in_dir(self):
1335
"""Grep specific version of file withing dir.
1338
self.make_branch_and_tree(wd)
1340
self._mk_versioned_dir('dir0') # rev1
1341
self._mk_versioned_file('dir0/file0.txt') # rev2
1342
self._update_file('dir0/file0.txt', "v3 text\n") # rev3
1343
self._update_file('dir0/file0.txt', "v4 text\n") # rev4
1344
self._update_file('dir0/file0.txt', "v5 text\n") # rev5
1346
# v4 should not be present in revno 3
1347
out, err = self.run_bzr(['grep', '-r', 'last:3', 'v4'])
1348
self.assertNotContainsRe(
1349
out, "^dir0/file0.txt", flags=TestGrep._reflags)
1351
# v4 should be present in revno 4
1352
out, err = self.run_bzr(['grep', '-r', 'last:2', 'v4'])
1353
self.assertContainsRe(out, "^dir0/file0.txt~4:v4",
1354
flags=TestGrep._reflags)
1356
# v4 should not be present in revno 3
1357
out, err = self.run_bzr(['grep', '-r', 'last:3', '[tuv]4'])
1358
self.assertNotContainsRe(
1359
out, "^dir0/file0.txt", flags=TestGrep._reflags)
1361
# v4 should be present in revno 4
1362
out, err = self.run_bzr(['grep', '-r', 'last:2', '[tuv]4'])
1363
self.assertContainsRe(out, "^dir0/file0.txt~4:v4",
1364
flags=TestGrep._reflags)
1366
def test_revno_range_basic_history_grep(self):
1367
"""Search for pattern in revision range for file.
1371
self.make_branch_and_tree(wd)
1373
self._mk_versioned_file(fname, total_lines=0) # rev1
1374
self._mk_versioned_file('file1.txt') # rev2
1375
self._update_file(fname, text="v3 text\n") # rev3
1376
self._update_file(fname, text="v4 text\n") # rev4
1377
self._update_file(fname, text="v5 text\n") # rev5
1378
self._update_file(fname, text="v6 text\n") # rev6
1380
out, err = self.run_bzr(['grep', '-r', '1..', 'v3'])
1381
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1382
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1383
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1384
self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1385
self.assertEqual(len(out.splitlines()), 4)
1387
out, err = self.run_bzr(['grep', '-r', '..1', 'v3'])
1388
# searching only rev1 gives nothing
1389
self.assertEqual(len(out.splitlines()), 0)
1391
out, err = self.run_bzr(['grep', '-r', '..6', 'v3'])
1392
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1393
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1394
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1395
self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1396
self.assertEqual(len(out.splitlines()), 4)
1398
out, err = self.run_bzr(['grep', '-r', '..', 'v3'])
1399
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1400
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1401
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1402
self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1403
self.assertEqual(len(out.splitlines()), 4)
1405
out, err = self.run_bzr(['grep', '-r', '1..5', 'v3'])
1406
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1407
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1408
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1409
self.assertNotContainsRe(
1410
out, "file0.txt~6:v3", flags=TestGrep._reflags)
1411
self.assertEqual(len(out.splitlines()), 3)
1413
out, err = self.run_bzr(['grep', '-r', '5..1', 'v3'])
1414
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1415
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1416
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1417
self.assertNotContainsRe(
1418
out, "file0.txt~6:v3", flags=TestGrep._reflags)
1419
self.assertEqual(len(out.splitlines()), 3)
1421
out, err = self.run_bzr(['grep', '-r', '1..', '[tuv]3'])
1422
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1423
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1424
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1425
self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1426
self.assertEqual(len(out.splitlines()), 4)
1428
out, err = self.run_bzr(['grep', '-r', '1..5', '[tuv]3'])
1429
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1430
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1431
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1432
self.assertNotContainsRe(
1433
out, "file0.txt~6:v3", flags=TestGrep._reflags)
1434
self.assertEqual(len(out.splitlines()), 3)
1436
out, err = self.run_bzr(['grep', '-r', '5..1', '[tuv]3'])
1437
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1438
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1439
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1440
self.assertNotContainsRe(
1441
out, "file0.txt~6:v3", flags=TestGrep._reflags)
1442
self.assertEqual(len(out.splitlines()), 3)
1444
def test_revno_range_versioned_file_in_dir(self):
1445
"""Grep rev-range for pattern for file withing a dir.
1448
self.make_branch_and_tree(wd)
1450
self._mk_versioned_dir('dir0') # rev1
1451
self._mk_versioned_file('dir0/file0.txt') # rev2
1452
self._update_file('dir0/file0.txt', "v3 text\n") # rev3
1453
self._update_file('dir0/file0.txt', "v4 text\n") # rev4
1454
self._update_file('dir0/file0.txt', "v5 text\n") # rev5
1455
self._update_file('dir0/file0.txt', "v6 text\n") # rev6
1457
out, err = self.run_bzr(['grep', '-r', '2..5', 'v3'])
1458
self.assertContainsRe(out, "^dir0/file0.txt~3:v3",
1459
flags=TestGrep._reflags)
1460
self.assertContainsRe(out, "^dir0/file0.txt~4:v3",
1461
flags=TestGrep._reflags)
1462
self.assertContainsRe(out, "^dir0/file0.txt~5:v3",
1463
flags=TestGrep._reflags)
1464
self.assertNotContainsRe(
1465
out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1466
self.assertEqual(len(out.splitlines()), 3)
1468
out, err = self.run_bzr(['grep', '-r', '2..5', '[tuv]3'])
1469
self.assertContainsRe(out, "^dir0/file0.txt~3:v3",
1470
flags=TestGrep._reflags)
1471
self.assertContainsRe(out, "^dir0/file0.txt~4:v3",
1472
flags=TestGrep._reflags)
1473
self.assertContainsRe(out, "^dir0/file0.txt~5:v3",
1474
flags=TestGrep._reflags)
1475
self.assertNotContainsRe(
1476
out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1477
self.assertEqual(len(out.splitlines()), 3)
1479
def test_revno_range_versioned_file_from_outside_dir(self):
1480
"""Grep rev-range for pattern from outside dir.
1483
self.make_branch_and_tree(wd)
1485
self._mk_versioned_dir('dir0') # rev1
1486
self._mk_versioned_file('dir0/file0.txt') # rev2
1487
self._update_file('dir0/file0.txt', "v3 text\n") # rev3
1488
self._update_file('dir0/file0.txt', "v4 text\n") # rev4
1489
self._update_file('dir0/file0.txt', "v5 text\n") # rev5
1490
self._update_file('dir0/file0.txt', "v6 text\n") # rev6
1492
out, err = self.run_bzr(['grep', '-r', '2..5', 'v3', 'dir0'])
1493
self.assertContainsRe(out, "^dir0/file0.txt~3:v3",
1494
flags=TestGrep._reflags)
1495
self.assertContainsRe(out, "^dir0/file0.txt~4:v3",
1496
flags=TestGrep._reflags)
1497
self.assertContainsRe(out, "^dir0/file0.txt~5:v3",
1498
flags=TestGrep._reflags)
1499
self.assertNotContainsRe(
1500
out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1502
out, err = self.run_bzr(['grep', '-r', '2..5', '[tuv]3', 'dir0'])
1503
self.assertContainsRe(out, "^dir0/file0.txt~3:v3",
1504
flags=TestGrep._reflags)
1505
self.assertContainsRe(out, "^dir0/file0.txt~4:v3",
1506
flags=TestGrep._reflags)
1507
self.assertContainsRe(out, "^dir0/file0.txt~5:v3",
1508
flags=TestGrep._reflags)
1509
self.assertNotContainsRe(
1510
out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1512
def test_levels(self):
1513
"""--levels=0 should show findings from merged revision.
1518
self.make_branch_and_tree(wd0)
1520
self._mk_versioned_file('file0.txt')
1523
out, err = self.run_bzr(['branch', wd0, wd1])
1525
self._mk_versioned_file('file1.txt')
1526
os.chdir(osutils.pathjoin('..', wd0))
1528
out, err = self.run_bzr(['merge', osutils.pathjoin('..', wd1)])
1529
out, err = self.run_bzr(['ci', '-m', 'merged'])
1531
out, err = self.run_bzr(['grep', 'line1'])
1532
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
1533
self.assertContainsRe(out, "file1.txt:line1", flags=TestGrep._reflags)
1535
# levels should be ignored by wtree grep
1536
out, err = self.run_bzr(['grep', '--levels=0', 'line1'])
1537
self.assertContainsRe(out, "^file0.txt:line1$",
1538
flags=TestGrep._reflags)
1539
self.assertContainsRe(out, "^file1.txt:line1$",
1540
flags=TestGrep._reflags)
1541
self.assertContainsRe(out, "^file0.txt:line10$",
1542
flags=TestGrep._reflags)
1543
self.assertContainsRe(out, "^file1.txt:line10$",
1544
flags=TestGrep._reflags)
1545
self.assertEqual(len(out.splitlines()), 4)
1547
out, err = self.run_bzr(
1548
['grep', '-r', 'last:1..', '--levels=0', 'line1'])
1549
self.assertContainsRe(out, "^file0.txt~2:line1$",
1550
flags=TestGrep._reflags)
1551
self.assertContainsRe(out, "^file1.txt~2:line1$",
1552
flags=TestGrep._reflags)
1553
self.assertContainsRe(
1554
out, "^file0.txt~1.1.1:line1$", flags=TestGrep._reflags)
1555
self.assertContainsRe(
1556
out, "^file1.txt~1.1.1:line1$", flags=TestGrep._reflags)
1557
self.assertContainsRe(out, "^file0.txt~2:line10$",
1558
flags=TestGrep._reflags)
1559
self.assertContainsRe(out, "^file1.txt~2:line10$",
1560
flags=TestGrep._reflags)
1561
self.assertContainsRe(
1562
out, "^file0.txt~1.1.1:line10$", flags=TestGrep._reflags)
1563
self.assertContainsRe(
1564
out, "^file1.txt~1.1.1:line10$", flags=TestGrep._reflags)
1565
self.assertEqual(len(out.splitlines()), 8)
1567
out, err = self.run_bzr(
1568
['grep', '-r', '-1..', '-n', '--levels=0', 'line1'])
1569
self.assertContainsRe(out, "^file0.txt~2:1:line1$",
1570
flags=TestGrep._reflags)
1571
self.assertContainsRe(out, "^file1.txt~2:1:line1$",
1572
flags=TestGrep._reflags)
1573
self.assertContainsRe(
1574
out, "^file0.txt~1.1.1:1:line1$", flags=TestGrep._reflags)
1575
self.assertContainsRe(
1576
out, "^file1.txt~1.1.1:1:line1$", flags=TestGrep._reflags)
1577
self.assertContainsRe(
1578
out, "^file0.txt~2:10:line10$", flags=TestGrep._reflags)
1579
self.assertContainsRe(
1580
out, "^file1.txt~2:10:line10$", flags=TestGrep._reflags)
1581
self.assertContainsRe(
1582
out, "^file0.txt~1.1.1:10:line10$", flags=TestGrep._reflags)
1583
self.assertContainsRe(
1584
out, "^file1.txt~1.1.1:10:line10$", flags=TestGrep._reflags)
1585
self.assertEqual(len(out.splitlines()), 8)
1587
# levels should be ignored by wtree grep
1588
out, err = self.run_bzr(['grep', '--levels=0', 'l.ne1'])
1589
self.assertContainsRe(out, "^file0.txt:line1$",
1590
flags=TestGrep._reflags)
1591
self.assertContainsRe(out, "^file1.txt:line1$",
1592
flags=TestGrep._reflags)
1593
self.assertContainsRe(out, "^file0.txt:line10$",
1594
flags=TestGrep._reflags)
1595
self.assertContainsRe(out, "^file1.txt:line10$",
1596
flags=TestGrep._reflags)
1597
self.assertEqual(len(out.splitlines()), 4)
1599
out, err = self.run_bzr(
1600
['grep', '-r', 'last:1..', '--levels=0', 'lin.1'])
1601
self.assertContainsRe(out, "^file0.txt~2:line1$",
1602
flags=TestGrep._reflags)
1603
self.assertContainsRe(out, "^file1.txt~2:line1$",
1604
flags=TestGrep._reflags)
1605
self.assertContainsRe(
1606
out, "^file0.txt~1.1.1:line1$", flags=TestGrep._reflags)
1607
self.assertContainsRe(
1608
out, "^file1.txt~1.1.1:line1$", flags=TestGrep._reflags)
1609
self.assertContainsRe(out, "^file0.txt~2:line10$",
1610
flags=TestGrep._reflags)
1611
self.assertContainsRe(out, "^file1.txt~2:line10$",
1612
flags=TestGrep._reflags)
1613
self.assertContainsRe(
1614
out, "^file0.txt~1.1.1:line10$", flags=TestGrep._reflags)
1615
self.assertContainsRe(
1616
out, "^file1.txt~1.1.1:line10$", flags=TestGrep._reflags)
1617
self.assertEqual(len(out.splitlines()), 8)
1619
out, err = self.run_bzr(
1620
['grep', '-r', '-1..', '-n', '--levels=0', '.ine1'])
1621
self.assertContainsRe(out, "file0.txt~2:1:line1",
1622
flags=TestGrep._reflags)
1623
self.assertContainsRe(out, "file1.txt~2:1:line1",
1624
flags=TestGrep._reflags)
1625
self.assertContainsRe(
1626
out, "file0.txt~1.1.1:1:line1", flags=TestGrep._reflags)
1627
self.assertContainsRe(
1628
out, "file1.txt~1.1.1:1:line1", flags=TestGrep._reflags)
1630
def test_dotted_rev_grep(self):
1631
"""Grep in dotted revs
1636
self.make_branch_and_tree(wd0)
1638
self._mk_versioned_file('file0.txt')
1641
out, err = self.run_bzr(['branch', wd0, wd1])
1643
self._mk_versioned_file('file1.txt') # revno 1.1.1
1644
self._update_file('file1.txt', "text 0\n") # revno 1.1.2
1645
self._update_file('file1.txt', "text 1\n") # revno 1.1.3
1646
self._update_file('file1.txt', "text 2\n") # revno 1.1.4
1647
os.chdir(osutils.pathjoin('..', wd0))
1649
out, err = self.run_bzr(['merge', osutils.pathjoin('..', wd1)])
1650
out, err = self.run_bzr(['ci', '-m', 'merged'])
1652
out, err = self.run_bzr(['grep', '-r', '1.1.1..1.1.4', 'text'])
1653
self.assertContainsRe(
1654
out, "file1.txt~1.1.2:text 0", flags=TestGrep._reflags)
1655
self.assertContainsRe(
1656
out, "file1.txt~1.1.3:text 1", flags=TestGrep._reflags)
1657
self.assertContainsRe(
1658
out, "file1.txt~1.1.3:text 1", flags=TestGrep._reflags)
1659
self.assertContainsRe(
1660
out, "file1.txt~1.1.4:text 0", flags=TestGrep._reflags)
1661
self.assertContainsRe(
1662
out, "file1.txt~1.1.4:text 1", flags=TestGrep._reflags)
1663
self.assertContainsRe(
1664
out, "file1.txt~1.1.4:text 2", flags=TestGrep._reflags)
1665
self.assertEqual(len(out.splitlines()), 6)
1667
def test_versioned_binary_file_grep(self):
1668
"""(versioned) Grep for pattern in binary file.
1671
self.make_branch_and_tree(wd)
1673
self._mk_versioned_file('file.txt')
1674
self._mk_versioned_file('file0.bin')
1675
self._update_file('file0.bin', "\x00lineNN\x00\n")
1677
# note: set --verbose/-v flag to get the skip message.
1678
out, err = self.run_bzr(['grep', '-v', '-r', 'last:1',
1679
'lineNN', 'file0.bin'])
1680
self.assertNotContainsRe(out, "file0.bin", flags=TestGrep._reflags)
1681
self.assertContainsRe(
1682
err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
1683
self.assertEqual(len(out.splitlines()), 0)
1684
self.assertEqual(len(err.splitlines()), 1)
1686
out, err = self.run_bzr(['grep', '-v', '-r', 'last:1',
1687
'line.N', 'file0.bin'])
1688
self.assertNotContainsRe(out, "file0.bin", flags=TestGrep._reflags)
1689
self.assertContainsRe(
1690
err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
1691
self.assertEqual(len(out.splitlines()), 0)
1692
self.assertEqual(len(err.splitlines()), 1)
1694
def test_wtree_binary_file_grep(self):
1695
"""(wtree) Grep for pattern in binary file.
1698
self.make_branch_and_tree(wd)
1700
self._mk_versioned_file('file0.bin')
1701
self._update_file('file0.bin', "\x00lineNN\x00\n")
1703
# note: set --verbose/-v flag to get the skip message.
1704
out, err = self.run_bzr(['grep', '-v', 'lineNN', 'file0.bin'])
1705
self.assertNotContainsRe(
1706
out, "file0.bin:line1", flags=TestGrep._reflags)
1707
self.assertContainsRe(
1708
err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
1710
# binary warning should not be shown without --verbose
1711
out, err = self.run_bzr(['grep', 'lineNN', 'file0.bin'])
1712
self.assertNotContainsRe(
1713
out, "file0.bin:line1", flags=TestGrep._reflags)
1714
self.assertNotContainsRe(err, "Binary file", flags=TestGrep._reflags)
1716
def test_revspec(self):
1717
"""Ensure various revspecs work
1720
self.make_branch_and_tree(wd)
1722
self._mk_versioned_dir('dir0') # rev1
1723
self._mk_versioned_file('dir0/file0.txt') # rev2
1724
self._update_file('dir0/file0.txt', "v3 text\n") # rev3
1725
self._update_file('dir0/file0.txt', "v4 text\n") # rev4
1726
self._update_file('dir0/file0.txt', "v5 text\n") # rev5
1728
out, err = self.run_bzr(['grep', '-r', 'revno:1..2', 'v3'])
1729
self.assertNotContainsRe(out, "file0", flags=TestGrep._reflags)
1730
self.assertEqual(len(out.splitlines()), 0)
1732
out, err = self.run_bzr(['grep', '-r', 'revno:4..', 'v4'])
1733
self.assertContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
1734
self.assertEqual(len(out.splitlines()), 2) # find v4 in rev4 and rev5
1736
out, err = self.run_bzr(['grep', '-r', '..revno:3', 'v4'])
1737
self.assertNotContainsRe(out, "file0", flags=TestGrep._reflags)
1738
self.assertEqual(len(out.splitlines()), 0)
1740
out, err = self.run_bzr(['grep', '-r', '..revno:3', 'v3'])
1741
self.assertContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
1742
self.assertEqual(len(out.splitlines()), 1)
1744
def test_wtree_files_with_matches(self):
1745
"""(wtree) Ensure --files-with-matches, -l works
1748
self.make_branch_and_tree(wd)
1751
self._mk_versioned_file('file0.txt', total_lines=2)
1752
self._mk_versioned_file('file1.txt', total_lines=2)
1753
self._mk_versioned_dir('dir0')
1754
self._mk_versioned_file('dir0/file00.txt', total_lines=2)
1755
self._mk_versioned_file('dir0/file01.txt', total_lines=2)
1757
self._update_file('file0.txt', 'HELLO\n', checkin=False)
1758
self._update_file('dir0/file00.txt', 'HELLO\n', checkin=False)
1761
out, err = self.run_bzr(['grep', '--files-with-matches', 'HELLO'])
1763
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1764
self.assertContainsRe(out, "^dir0/file00.txt$",
1765
flags=TestGrep._reflags)
1766
self.assertEqual(len(out.splitlines()), 2)
1769
out, err = self.run_bzr(['grep', '--files-with-matches', 'HE.LO'])
1771
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1772
self.assertContainsRe(out, "^dir0/file00.txt$",
1773
flags=TestGrep._reflags)
1774
self.assertEqual(len(out.splitlines()), 2)
1777
out, err = self.run_bzr(['grep', '-l', 'HELLO'])
1779
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1780
self.assertContainsRe(out, "^dir0/file00.txt$",
1781
flags=TestGrep._reflags)
1782
self.assertEqual(len(out.splitlines()), 2)
1785
out, err = self.run_bzr(['grep', '-l', 'HE.LO'])
1787
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1788
self.assertContainsRe(out, "^dir0/file00.txt$",
1789
flags=TestGrep._reflags)
1790
self.assertEqual(len(out.splitlines()), 2)
1793
out, err = self.run_bzr(['grep', '-l', 'HELLO', 'dir0', 'file1.txt'])
1795
self.assertContainsRe(out, "^dir0/file00.txt$",
1796
flags=TestGrep._reflags)
1797
self.assertEqual(len(out.splitlines()), 1)
1800
out, err = self.run_bzr(['grep', '-l', '.ELLO', 'dir0', 'file1.txt'])
1802
self.assertContainsRe(out, "^dir0/file00.txt$",
1803
flags=TestGrep._reflags)
1804
self.assertEqual(len(out.splitlines()), 1)
1807
out, err = self.run_bzr(['grep', '-l', 'HELLO', 'file0.txt'])
1809
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1810
self.assertEqual(len(out.splitlines()), 1)
1813
out, err = self.run_bzr(['grep', '-l', '.ELLO', 'file0.txt'])
1815
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1816
self.assertEqual(len(out.splitlines()), 1)
1819
out, err = self.run_bzr(['grep', '--no-recursive', '-l', 'HELLO'])
1821
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1822
self.assertEqual(len(out.splitlines()), 1)
1825
out, err = self.run_bzr(['grep', '--no-recursive', '-l', '.ELLO'])
1827
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1828
self.assertEqual(len(out.splitlines()), 1)
1830
def test_ver_files_with_matches(self):
1831
"""(ver) Ensure --files-with-matches, -l works
1834
self.make_branch_and_tree(wd)
1837
self._mk_versioned_file('file0.txt', total_lines=2) # rev 1
1838
self._mk_versioned_file('file1.txt', total_lines=2) # rev 2
1839
self._mk_versioned_dir('dir0') # rev 3
1840
self._mk_versioned_file('dir0/file00.txt', total_lines=2) # rev 4
1841
self._mk_versioned_file('dir0/file01.txt', total_lines=2) # rev 5
1843
self._update_file('file0.txt', 'HELLO\n') # rev 6
1844
self._update_file('dir0/file00.txt', 'HELLO\n') # rev 7
1847
out, err = self.run_bzr(['grep', '-r', '-1', '--files-with-matches',
1850
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1851
self.assertContainsRe(out, "^dir0/file00.txt~7$",
1852
flags=TestGrep._reflags)
1853
self.assertEqual(len(out.splitlines()), 2)
1856
out, err = self.run_bzr(['grep', '-r', '-1', '--files-with-matches',
1859
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1860
self.assertContainsRe(out, "^dir0/file00.txt~7$",
1861
flags=TestGrep._reflags)
1862
self.assertEqual(len(out.splitlines()), 2)
1865
out, err = self.run_bzr(['grep', '-r', '6..7', '--files-with-matches',
1868
self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1869
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1870
self.assertContainsRe(out, "^dir0/file00.txt~7$",
1871
flags=TestGrep._reflags)
1872
self.assertEqual(len(out.splitlines()), 3)
1875
out, err = self.run_bzr(['grep', '-r', '6..7', '--files-with-matches',
1878
self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1879
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1880
self.assertContainsRe(out, "^dir0/file00.txt~7$",
1881
flags=TestGrep._reflags)
1882
self.assertEqual(len(out.splitlines()), 3)
1885
out, err = self.run_bzr(['grep', '-r', '-1', '-l', 'HELLO'])
1887
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1888
self.assertContainsRe(out, "^dir0/file00.txt~7$",
1889
flags=TestGrep._reflags)
1890
self.assertEqual(len(out.splitlines()), 2)
1893
out, err = self.run_bzr(['grep', '-r', '-1', '-l', 'H.LLO'])
1895
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1896
self.assertContainsRe(out, "^dir0/file00.txt~7$",
1897
flags=TestGrep._reflags)
1898
self.assertEqual(len(out.splitlines()), 2)
1901
out, err = self.run_bzr(['grep', '-l', 'HELLO', '-r', '-1',
1902
'dir0', 'file1.txt'])
1904
self.assertContainsRe(out, "^dir0/file00.txt~7$",
1905
flags=TestGrep._reflags)
1906
self.assertEqual(len(out.splitlines()), 1)
1909
out, err = self.run_bzr(['grep', '-l', 'H.LLO', '-r', '-1',
1910
'dir0', 'file1.txt'])
1912
self.assertContainsRe(out, "^dir0/file00.txt~7$",
1913
flags=TestGrep._reflags)
1914
self.assertEqual(len(out.splitlines()), 1)
1917
out, err = self.run_bzr(['grep', '-l', 'HELLO',
1918
'-r', '-2', 'file0.txt'])
1920
self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1921
self.assertEqual(len(out.splitlines()), 1)
1924
out, err = self.run_bzr(['grep', '-l', 'HE.LO',
1925
'-r', '-2', 'file0.txt'])
1927
self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1928
self.assertEqual(len(out.splitlines()), 1)
1931
out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
1934
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1935
self.assertEqual(len(out.splitlines()), 1)
1938
out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
1941
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1942
self.assertEqual(len(out.splitlines()), 1)
1944
def test_wtree_files_without_matches(self):
1945
"""(wtree) Ensure --files-without-match, -L works
1948
self.make_branch_and_tree(wd)
1951
self._mk_versioned_file('file0.txt', total_lines=2)
1952
self._mk_versioned_file('file1.txt', total_lines=2)
1953
self._mk_versioned_dir('dir0')
1954
self._mk_versioned_file('dir0/file00.txt', total_lines=2)
1955
self._mk_versioned_file('dir0/file01.txt', total_lines=2)
1957
self._update_file('file0.txt', 'HELLO\n', checkin=False)
1958
self._update_file('dir0/file00.txt', 'HELLO\n', checkin=False)
1961
out, err = self.run_bzr(['grep', '--files-without-match', 'HELLO'])
1963
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1964
self.assertContainsRe(out, "^dir0/file01.txt$",
1965
flags=TestGrep._reflags)
1966
self.assertEqual(len(out.splitlines()), 2)
1969
out, err = self.run_bzr(['grep', '--files-without-match', 'HE.LO'])
1971
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1972
self.assertContainsRe(out, "^dir0/file01.txt$",
1973
flags=TestGrep._reflags)
1974
self.assertEqual(len(out.splitlines()), 2)
1977
out, err = self.run_bzr(['grep', '-L', 'HELLO'])
1979
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1980
self.assertContainsRe(out, "^dir0/file01.txt$",
1981
flags=TestGrep._reflags)
1982
self.assertEqual(len(out.splitlines()), 2)
1985
out, err = self.run_bzr(['grep', '-L', 'HE.LO'])
1987
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1988
self.assertContainsRe(out, "^dir0/file01.txt$",
1989
flags=TestGrep._reflags)
1990
self.assertEqual(len(out.splitlines()), 2)
1993
out, err = self.run_bzr(['grep', '-L', 'HELLO', 'dir0', 'file1.txt'])
1995
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1996
self.assertContainsRe(out, "^dir0/file01.txt$",
1997
flags=TestGrep._reflags)
1998
self.assertEqual(len(out.splitlines()), 2)
2001
out, err = self.run_bzr(['grep', '-L', '.ELLO', 'dir0', 'file1.txt'])
2003
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
2004
self.assertContainsRe(out, "^dir0/file01.txt$",
2005
flags=TestGrep._reflags)
2006
self.assertEqual(len(out.splitlines()), 2)
2009
out, err = self.run_bzr(['grep', '-L', 'HELLO', 'file1.txt'])
2011
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
2012
self.assertEqual(len(out.splitlines()), 1)
2015
out, err = self.run_bzr(['grep', '-L', '.ELLO', 'file1.txt'])
2017
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
2018
self.assertEqual(len(out.splitlines()), 1)
2021
out, err = self.run_bzr(['grep', '--no-recursive', '-L', 'HELLO'])
2023
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
2024
self.assertEqual(len(out.splitlines()), 1)
2027
out, err = self.run_bzr(['grep', '--no-recursive', '-L', '.ELLO'])
2029
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
2030
self.assertEqual(len(out.splitlines()), 1)
2032
def test_ver_files_without_matches(self):
2033
"""(ver) Ensure --files-without-match, -L works
2036
self.make_branch_and_tree(wd)
2039
self._mk_versioned_file('file0.txt', total_lines=2) # rev 1
2040
self._mk_versioned_file('file1.txt', total_lines=2) # rev 2
2041
self._mk_versioned_dir('dir0') # rev 3
2042
self._mk_versioned_file('dir0/file00.txt', total_lines=2) # rev 4
2043
self._mk_versioned_file('dir0/file01.txt', total_lines=2) # rev 5
2045
self._update_file('file0.txt', 'HELLO\n') # rev 6
2046
self._update_file('dir0/file00.txt', 'HELLO\n') # rev 7
2049
out, err = self.run_bzr(['grep', '-r', '-1', '--files-without-match',
2052
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2053
self.assertContainsRe(out, "^dir0/file01.txt~7$",
2054
flags=TestGrep._reflags)
2055
self.assertEqual(len(out.splitlines()), 2)
2058
out, err = self.run_bzr(['grep', '-r', '-1', '--files-without-match',
2061
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2062
self.assertContainsRe(out, "^dir0/file01.txt~7$",
2063
flags=TestGrep._reflags)
2064
self.assertEqual(len(out.splitlines()), 2)
2067
out, err = self.run_bzr(['grep', '-r', '6..7', '--files-without-match',
2070
self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
2071
self.assertContainsRe(out, "^dir0/file00.txt~6$",
2072
flags=TestGrep._reflags)
2073
self.assertContainsRe(out, "^dir0/file01.txt~6$",
2074
flags=TestGrep._reflags)
2075
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2076
self.assertContainsRe(out, "^dir0/file01.txt~7$",
2077
flags=TestGrep._reflags)
2078
self.assertEqual(len(out.splitlines()), 5)
2081
out, err = self.run_bzr(['grep', '-r', '6..7', '--files-without-match',
2084
self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
2085
self.assertContainsRe(out, "^dir0/file00.txt~6$",
2086
flags=TestGrep._reflags)
2087
self.assertContainsRe(out, "^dir0/file01.txt~6$",
2088
flags=TestGrep._reflags)
2089
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2090
self.assertContainsRe(out, "^dir0/file01.txt~7$",
2091
flags=TestGrep._reflags)
2092
self.assertEqual(len(out.splitlines()), 5)
2095
out, err = self.run_bzr(['grep', '-r', '-1', '-L', 'HELLO'])
2097
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2098
self.assertContainsRe(out, "^dir0/file01.txt~7$",
2099
flags=TestGrep._reflags)
2100
self.assertEqual(len(out.splitlines()), 2)
2103
out, err = self.run_bzr(['grep', '-r', '-1', '-L', 'H.LLO'])
2105
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2106
self.assertContainsRe(out, "^dir0/file01.txt~7$",
2107
flags=TestGrep._reflags)
2108
self.assertEqual(len(out.splitlines()), 2)
2111
out, err = self.run_bzr(['grep', '-L', 'HELLO', '-r', '-1',
2112
'dir0', 'file1.txt'])
2114
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2115
self.assertContainsRe(out, "^dir0/file01.txt~7$",
2116
flags=TestGrep._reflags)
2117
self.assertEqual(len(out.splitlines()), 2)
2120
out, err = self.run_bzr(['grep', '-L', 'H.LLO', '-r', '-1',
2121
'dir0', 'file1.txt'])
2123
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2124
self.assertContainsRe(out, "^dir0/file01.txt~7$",
2125
flags=TestGrep._reflags)
2126
self.assertEqual(len(out.splitlines()), 2)
2129
out, err = self.run_bzr(['grep', '-L', 'HELLO',
2130
'-r', '-2', 'file1.txt'])
2132
self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
2133
self.assertEqual(len(out.splitlines()), 1)
2136
out, err = self.run_bzr(['grep', '-L', 'HE.LO',
2137
'-r', '-2', 'file1.txt'])
2139
self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
2140
self.assertEqual(len(out.splitlines()), 1)
2143
out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
2146
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2147
self.assertEqual(len(out.splitlines()), 1)
2150
out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
2153
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2154
self.assertEqual(len(out.splitlines()), 1)
2156
def test_no_tree(self):
2157
"""Ensure grep works without working tree.
2161
self.make_branch_and_tree(wd0)
2163
self._mk_versioned_file('file0.txt')
2165
out, err = self.run_bzr(['branch', '--no-tree', wd0, wd1])
2168
out, err = self.run_bzr(['grep', 'line1'], 3)
2169
self.assertContainsRe(
2170
err, "Cannot search working tree", flags=TestGrep._reflags)
2171
self.assertEqual(out, '')
2173
out, err = self.run_bzr(['grep', '-r', '1', 'line1'])
2174
self.assertContainsRe(out, "file0.txt~1:line1",
2175
flags=TestGrep._reflags)
2176
self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
2179
class TestNonAscii(GrepTestBase):
2180
"""Tests for non-ascii filenames and file contents"""
2182
_test_needs_features = [UnicodeFilenameFeature]
2184
def test_unicode_only_file(self):
2185
"""Test filename and contents that requires a unicode encoding"""
2186
tree = self.make_branch_and_tree(".")
2187
contents = [u"\u1234"]
2188
self.build_tree(contents)
2190
tree.commit("Initial commit")
2193
# GZ 2010-06-07: Note we can't actually grep for \u1234 as the pattern
2194
# is mangled according to the user encoding.
2195
streams = self.run_bzr_raw(["grep", "--files-with-matches",
2196
u"contents"], encoding="UTF-8")
2197
as_utf8 = as_utf8.encode("UTF-8")
2198
self.assertEqual(streams, (as_utf8 + b"\n", b""))
2200
streams = self.run_bzr_raw(["grep", "-r", "1", "--files-with-matches",
2201
u"contents"], encoding="UTF-8")
2202
self.assertEqual(streams, (as_utf8 + b"~1\n", b""))
2204
fileencoding = osutils.get_user_encoding()
2205
as_mangled = as_utf8.decode(fileencoding, "replace").encode("UTF-8")
2207
streams = self.run_bzr_raw(["grep", "-n",
2208
u"contents"], encoding="UTF-8")
2209
self.assertEqual(streams, (b"%s:1:contents of %s\n" %
2210
(as_utf8, as_mangled), b""))
2212
streams = self.run_bzr_raw(["grep", "-n", "-r", "1",
2213
u"contents"], encoding="UTF-8")
2214
self.assertEqual(streams, (b"%s~1:1:contents of %s\n" %
2215
(as_utf8, as_mangled), b""))
2218
class TestColorGrep(GrepTestBase):
2219
"""Tests for the --color option."""
2221
_rev_sep = color_string('~', fg=FG.BOLD_YELLOW)
2222
_sep = color_string(':', fg=FG.BOLD_CYAN)
2224
def test_color_option(self):
2225
"""Ensure options for color are valid.
2227
out, err = self.run_bzr(['grep', '--color', 'foo', 'bar'], 3)
2228
self.assertEqual(out, '')
2229
self.assertContainsRe(
2230
err, 'Valid values for --color are', flags=TestGrep._reflags)
2232
def test_ver_matching_files(self):
2233
"""(versioned) Search for matches or no matches only"""
2234
tree = self.make_branch_and_tree(".")
2235
contents = ["d/", "d/aaa", "bbb"]
2236
self.build_tree(contents)
2238
tree.commit("Initial commit")
2240
# GZ 2010-06-05: Maybe modify the working tree here
2242
streams = self.run_bzr(["grep", "--color", "always", "-r", "1",
2243
"--files-with-matches", "aaa"])
2244
self.assertEqual(streams, ("".join([
2245
FG.MAGENTA, "d/aaa", self._rev_sep, "1", "\n"
2248
streams = self.run_bzr(["grep", "--color", "always", "-r", "1",
2249
"--files-without-match", "aaa"])
2250
self.assertEqual(streams, ("".join([
2251
FG.MAGENTA, "bbb", self._rev_sep, "1", "\n"
2254
def test_wtree_matching_files(self):
2255
"""(wtree) Search for matches or no matches only"""
2256
tree = self.make_branch_and_tree(".")
2257
contents = ["d/", "d/aaa", "bbb"]
2258
self.build_tree(contents)
2260
tree.commit("Initial commit")
2262
# GZ 2010-06-05: Maybe modify the working tree here
2264
streams = self.run_bzr(["grep", "--color", "always",
2265
"--files-with-matches", "aaa"])
2266
self.assertEqual(streams, ("".join([
2267
FG.MAGENTA, "d/aaa", FG.NONE, "\n"
2270
streams = self.run_bzr(["grep", "--color", "always",
2271
"--files-without-match", "aaa"])
2272
self.assertEqual(streams, ("".join([
2273
FG.MAGENTA, "bbb", FG.NONE, "\n"
2276
def test_ver_basic_file(self):
2277
"""(versioned) Search for pattern in specfic file.
2280
self.make_branch_and_tree(wd)
2282
lp = 'foo is foobar'
2283
self._mk_versioned_file('file0.txt', line_prefix=lp, total_lines=1)
2285
# prepare colored result
2286
foo = color_string('foo', fg=FG.BOLD_RED)
2287
res = (FG.MAGENTA + 'file0.txt'
2288
+ self._rev_sep + '1' + self._sep
2289
+ foo + ' is ' + foo + 'bar1' + '\n')
2290
txt_res = 'file0.txt~1:foo is foobar1\n'
2292
nres = (FG.MAGENTA + 'file0.txt'
2293
+ self._rev_sep + '1' + self._sep + '1' + self._sep
2294
+ foo + ' is ' + foo + 'bar1' + '\n')
2296
out, err = self.run_bzr(['grep', '--color',
2297
'always', '-r', '1', 'foo'])
2298
self.assertEqual(out, res)
2299
self.assertEqual(len(out.splitlines()), 1)
2301
# auto should produce plain text result
2302
# as stdout is redireched here.
2303
out, err = self.run_bzr(['grep', '--color',
2304
'auto', '-r', '1', 'foo'])
2305
self.assertEqual(out, txt_res)
2306
self.assertEqual(len(out.splitlines()), 1)
2308
out, err = self.run_bzr(['grep', '-i', '--color',
2309
'always', '-r', '1', 'FOO'])
2310
self.assertEqual(out, res)
2311
self.assertEqual(len(out.splitlines()), 1)
2313
out, err = self.run_bzr(['grep', '--color',
2314
'always', '-r', '1', 'f.o'])
2315
self.assertEqual(out, res)
2316
self.assertEqual(len(out.splitlines()), 1)
2318
out, err = self.run_bzr(['grep', '-i', '--color',
2319
'always', '-r', '1', 'F.O'])
2320
self.assertEqual(out, res)
2321
self.assertEqual(len(out.splitlines()), 1)
2323
out, err = self.run_bzr(['grep', '-n', '--color',
2324
'always', '-r', '1', 'foo'])
2325
self.assertEqual(out, nres)
2326
self.assertEqual(len(out.splitlines()), 1)
2328
out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2329
'always', '-r', '1', 'FOO'])
2330
self.assertEqual(out, nres)
2331
self.assertEqual(len(out.splitlines()), 1)
2333
out, err = self.run_bzr(['grep', '-n', '--color',
2334
'always', '-r', '1', 'f.o'])
2335
self.assertEqual(out, nres)
2336
self.assertEqual(len(out.splitlines()), 1)
2338
out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2339
'always', '-r', '1', 'F.O'])
2340
self.assertEqual(out, nres)
2341
self.assertEqual(len(out.splitlines()), 1)
2343
def test_wtree_basic_file(self):
2344
"""(wtree) Search for pattern in specfic file.
2347
self.make_branch_and_tree(wd)
2349
lp = 'foo is foobar'
2350
self._mk_versioned_file('file0.txt', line_prefix=lp, total_lines=1)
2352
# prepare colored result
2353
foo = color_string('foo', fg=FG.BOLD_RED)
2354
res = (FG.MAGENTA + 'file0.txt'
2355
+ self._sep + foo + ' is ' + foo + 'bar1' + '\n')
2357
nres = (FG.MAGENTA + 'file0.txt'
2358
+ self._sep + '1' + self._sep
2359
+ foo + ' is ' + foo + 'bar1' + '\n')
2361
out, err = self.run_bzr(['grep', '--color',
2363
self.assertEqual(out, res)
2364
self.assertEqual(len(out.splitlines()), 1)
2366
out, err = self.run_bzr(['grep', '-i', '--color',
2368
self.assertEqual(out, res)
2369
self.assertEqual(len(out.splitlines()), 1)
2371
out, err = self.run_bzr(['grep', '--color',
2373
self.assertEqual(out, res)
2374
self.assertEqual(len(out.splitlines()), 1)
2376
out, err = self.run_bzr(['grep', '-i', '--color',
2378
self.assertEqual(out, res)
2379
self.assertEqual(len(out.splitlines()), 1)
2381
out, err = self.run_bzr(['grep', '-n', '--color',
2383
self.assertEqual(out, nres)
2384
self.assertEqual(len(out.splitlines()), 1)
2386
out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2388
self.assertEqual(out, nres)
2389
self.assertEqual(len(out.splitlines()), 1)
2391
out, err = self.run_bzr(['grep', '-n', '--color',
2393
self.assertEqual(out, nres)
2394
self.assertEqual(len(out.splitlines()), 1)
2396
out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2398
self.assertEqual(out, nres)
2399
self.assertEqual(len(out.splitlines()), 1)
2402
# copied from breezy.tests.blackbox.test_diff
2403
def subst_dates(string):
2404
"""Replace date strings with constant values."""
2405
return re.sub(r'\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} [-\+]\d{4}',
2406
'YYYY-MM-DD HH:MM:SS +ZZZZ', string)
2409
class TestGrepDiff(tests.TestCaseWithTransport):
2411
def make_example_branch(self):
2412
tree = self.make_branch_and_tree('.')
2413
self.build_tree_contents([
2414
('hello', b'foo\n'),
2415
('goodbye', b'baz\n')])
2417
tree.commit('setup')
2418
tree.add(['goodbye'])
2419
tree.commit('setup')
2422
def test_grep_diff_basic(self):
2423
"""grep -p basic test."""
2424
tree = self.make_example_branch()
2425
self.build_tree_contents([('hello', b'hello world!\n')])
2426
tree.commit('updated hello')
2427
out, err = self.run_bzr(['grep', '-p', 'hello'])
2428
self.assertEqual(err, '')
2429
self.assertEqualDiff(subst_dates(out), '''\
2431
=== modified file 'hello'
2432
--- hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2433
+++ hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2436
=== added file 'hello'
2437
--- hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2438
+++ hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2441
def test_grep_diff_revision(self):
2442
"""grep -p specific revision."""
2443
tree = self.make_example_branch()
2444
self.build_tree_contents([('hello', b'hello world!\n')])
2445
tree.commit('updated hello')
2446
out, err = self.run_bzr(['grep', '-p', '-r', '3', 'hello'])
2447
self.assertEqual(err, '')
2448
self.assertEqualDiff(subst_dates(out), '''\
2450
=== modified file 'hello'
2451
--- hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2452
+++ hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2456
def test_grep_diff_revision_range(self):
2457
"""grep -p revision range."""
2458
tree = self.make_example_branch()
2459
self.build_tree_contents([('hello', b'hello world!1\n')]) # rev 3
2461
self.build_tree_contents([('blah', b'hello world!2\n')]) # rev 4
2464
with open('hello', 'a') as f:
2465
f.write('hello world!3\n')
2466
# self.build_tree_contents([('hello', 'hello world!3\n')]) # rev 5
2468
out, err = self.run_bzr(['grep', '-p', '-r', '2..5', 'hello'])
2469
self.assertEqual(err, '')
2470
self.assertEqualDiff(subst_dates(out), '''\
2472
=== modified file 'hello'
2473
--- hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2474
+++ hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2477
=== added file 'blah'
2480
=== modified file 'hello'
2481
--- hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2482
+++ hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2486
def test_grep_diff_color(self):
2487
"""grep -p color test."""
2488
tree = self.make_example_branch()
2489
self.build_tree_contents([('hello', b'hello world!\n')])
2490
tree.commit('updated hello')
2491
out, err = self.run_bzr(['grep', '--diff', '-r', '3',
2492
'--color', 'always', 'hello'])
2493
self.assertEqual(err, '')
2494
revno = color_string('=== revno:3 ===', fg=FG.BOLD_BLUE) + '\n'
2495
filename = color_string(
2496
" === modified file 'hello'", fg=FG.BOLD_MAGENTA) + '\n'
2497
redhello = color_string('hello', fg=FG.BOLD_RED)
2499
--- hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2500
+++ hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2503
diffstr = diffstr.replace('hello', redhello)
2504
self.assertEqualDiff(subst_dates(out), revno + filename + diffstr)
2506
def test_grep_norevs(self):
2507
"""grep -p with zero revisions."""
2508
out, err = self.run_bzr(['init'])
2509
out, err = self.run_bzr(['grep', '--diff', 'foo'], 3)
2510
self.assertEqual(out, '')
2511
self.assertContainsRe(
2512
err, "ERROR:.*revision.* does not exist in branch")
added
removed
breezy/tests/test_grep.py
