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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 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.
36
class GrepTestBase(tests.TestCaseWithTransport):
37
"""Base class for testing grep.
39
Provides support methods for creating directory and file revisions.
41
_reflags = re.MULTILINE|re.DOTALL
43
def _mk_file(self, path, line_prefix, total_lines, versioned):
45
for i in range(total_lines):
46
text += line_prefix + str(i+1) + "\n"
48
with open(path, 'w') as f:
51
self.run_bzr(['add', path])
52
self.run_bzr(['ci', '-m', '"' + path + '"'])
54
def _update_file(self, path, text, checkin=True):
55
"""append text to file 'path' and check it in"""
56
with open(path, 'a') as f:
59
self.run_bzr(['ci', path, '-m', '"' + path + '"'])
61
def _mk_unknown_file(self, path, line_prefix='line', total_lines=10):
62
self._mk_file(path, line_prefix, total_lines, versioned=False)
64
def _mk_versioned_file(self, path, line_prefix='line', total_lines=10):
65
self._mk_file(path, line_prefix, total_lines, versioned=True)
67
def _mk_dir(self, path, versioned):
70
self.run_bzr(['add', path])
71
self.run_bzr(['ci', '-m', '"' + path + '"'])
73
def _mk_unknown_dir(self, path):
74
self._mk_dir(path, versioned=False)
76
def _mk_versioned_dir(self, path):
77
self._mk_dir(path, versioned=True)
80
class TestGrep(GrepTestBase):
81
"""Core functional tests for grep."""
83
def test_basic_unknown_file(self):
84
"""Search for pattern in specfic file.
86
If specified file is unknown, grep it anyway."""
88
self.make_branch_and_tree(wd)
90
self._mk_unknown_file('file0.txt')
92
out, err = self.run_bzr(['grep', 'line1', 'file0.txt'])
93
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
94
self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
96
out, err = self.run_bzr(['grep', 'line\\d+', 'file0.txt'])
97
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
98
self.assertEqual(len(out.splitlines()), 10)
100
# unknown file is not grepped unless explicitely specified
101
out, err = self.run_bzr(['grep', 'line1'])
102
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
103
self.assertEqual(len(out.splitlines()), 0)
105
# unknown file is not grepped unless explicitely specified
106
out, err = self.run_bzr(['grep', 'line1$'])
107
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
108
self.assertEqual(len(out.splitlines()), 0)
110
def test_ver_basic_file(self):
111
"""(versioned) Search for pattern in specfic file.
114
self.make_branch_and_tree(wd)
116
self._mk_versioned_file('file0.txt')
118
out, err = self.run_bzr(['grep', '-r', '1', 'line1', 'file0.txt'])
119
self.assertContainsRe(out, "file0.txt~1:line1", flags=TestGrep._reflags)
120
self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
122
out, err = self.run_bzr(['grep', '-r', '1', 'line[0-9]$', 'file0.txt'])
123
self.assertContainsRe(out, "file0.txt~1:line1", flags=TestGrep._reflags)
124
self.assertEqual(len(out.splitlines()), 9)
126
# finds all the lines
127
out, err = self.run_bzr(['grep', '-r', '1', 'line[0-9]', 'file0.txt'])
128
self.assertContainsRe(out, "file0.txt~1:line1", flags=TestGrep._reflags)
129
self.assertEqual(len(out.splitlines()), 10)
131
def test_wtree_basic_file(self):
132
"""(wtree) Search for pattern in specfic file.
135
self.make_branch_and_tree(wd)
137
self._mk_versioned_file('file0.txt')
138
self._update_file('file0.txt', 'ABC\n', checkin=False)
140
out, err = self.run_bzr(['grep', 'ABC', 'file0.txt'])
141
self.assertContainsRe(out, "file0.txt:ABC", flags=TestGrep._reflags)
142
self.assertEqual(len(out.splitlines()), 1)
144
out, err = self.run_bzr(['grep', '[A-Z]{3}', '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', '-r', 'last:1', 'ABC', 'file0.txt'])
149
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
150
self.assertEqual(len(out.splitlines()), 0)
152
out, err = self.run_bzr(['grep', '-r', 'last:1', '[A-Z]{3}', 'file0.txt'])
153
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
154
self.assertEqual(len(out.splitlines()), 0)
156
def test_ver_basic_include(self):
157
"""(versioned) Ensure that -I flag is respected.
160
self.make_branch_and_tree(wd)
162
self._mk_versioned_file('file0.aa')
163
self._mk_versioned_file('file0.bb')
164
self._mk_versioned_file('file0.cc')
166
out, err = self.run_bzr(['grep', '-r', 'last:1',
167
'--include', '*.aa', '--include', '*.bb', 'line1'])
168
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
169
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
170
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
171
# two lines each (line1, line10) from file0.aa and file0.bb
172
self.assertEqual(len(out.splitlines()), 4)
174
out, err = self.run_bzr(['grep', '-r', 'last:1',
175
'--include', '*.aa', '--include', '*.bb', 'line1$'])
176
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
177
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
178
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
179
# one lines each (line1) from file0.aa and file0.bb
180
self.assertEqual(len(out.splitlines()), 2)
182
out, err = self.run_bzr(['grep', '-r', 'last:1',
183
'-I', '*.aa', '-I', '*.bb', 'line1'])
184
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
185
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
186
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
187
# two lines each (line1, line10) from file0.aa and file0.bb
188
self.assertEqual(len(out.splitlines()), 4)
190
out, err = self.run_bzr(['grep', '-r', 'last:1',
191
'-I', '*.aa', '-I', '*.bb', 'line1$'])
192
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
193
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
194
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
195
# one lines each (line1) from file0.aa and file0.bb
196
self.assertEqual(len(out.splitlines()), 2)
198
def test_wtree_basic_include(self):
199
"""(wtree) Ensure that --include flag is respected.
202
self.make_branch_and_tree(wd)
204
self._mk_versioned_file('file0.aa')
205
self._mk_versioned_file('file0.bb')
206
self._mk_versioned_file('file0.cc')
208
out, err = self.run_bzr(['grep', '--include', '*.aa',
209
'--include', '*.bb', 'line1'])
210
self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
211
self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
212
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
213
# two lines each (line1, line10) from file0.aa and file0.bb
214
self.assertEqual(len(out.splitlines()), 4)
216
out, err = self.run_bzr(['grep', '--include', '*.aa',
217
'--include', '*.bb', 'line1$'])
218
self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
219
self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
220
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
221
# one line each (line1) from file0.aa and file0.bb
222
self.assertEqual(len(out.splitlines()), 2)
224
def test_ver_basic_exclude(self):
225
"""(versioned) Ensure that --exclude flag is respected.
228
self.make_branch_and_tree(wd)
230
self._mk_versioned_file('file0.aa')
231
self._mk_versioned_file('file0.bb')
232
self._mk_versioned_file('file0.cc')
234
out, err = self.run_bzr(['grep', '-r', 'last:1',
235
'--exclude', '*.cc', 'line1'])
236
self.assertContainsRe(out, "file0.aa~.:line1$", flags=TestGrep._reflags)
237
self.assertContainsRe(out, "file0.bb~.:line1$", flags=TestGrep._reflags)
238
self.assertContainsRe(out, "file0.aa~.:line10", flags=TestGrep._reflags)
239
self.assertContainsRe(out, "file0.bb~.:line10", flags=TestGrep._reflags)
240
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
241
# two lines each (line1, line10) from file0.aa and file0.bb
242
self.assertEqual(len(out.splitlines()), 4)
244
out, err = self.run_bzr(['grep', '-r', 'last:1',
245
'--exclude', '*.cc', 'line1$'])
246
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
247
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
248
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
249
# one line each (line1) from file0.aa and file0.bb
250
self.assertEqual(len(out.splitlines()), 2)
252
out, err = self.run_bzr(['grep', '-r', 'last:1',
253
'-X', '*.cc', 'line1'])
254
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
255
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
256
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
257
# two lines each (line1, line10) from file0.aa and file0.bb
258
self.assertEqual(len(out.splitlines()), 4)
260
def test_wtree_basic_exclude(self):
261
"""(wtree) Ensure that --exclude flag is respected.
264
self.make_branch_and_tree(wd)
266
self._mk_versioned_file('file0.aa')
267
self._mk_versioned_file('file0.bb')
268
self._mk_versioned_file('file0.cc')
270
out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'line1'])
271
self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
272
self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
273
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
274
# two lines each (line1, line10) from file0.aa and file0.bb
275
self.assertEqual(len(out.splitlines()), 4)
277
out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'lin.1$'])
278
self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
279
self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
280
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
281
# one line each (line1) from file0.aa and file0.bb
282
self.assertEqual(len(out.splitlines()), 2)
284
def test_ver_multiple_files(self):
285
"""(versioned) Search for pattern in multiple files.
288
self.make_branch_and_tree(wd)
290
self._mk_versioned_file('file0.txt', total_lines=2)
291
self._mk_versioned_file('file1.txt', total_lines=2)
292
self._mk_versioned_file('file2.txt', total_lines=2)
294
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line[1-2]$'])
295
self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
296
self.assertContainsRe(out, "file0.txt~.:line2", flags=TestGrep._reflags)
297
self.assertContainsRe(out, "file1.txt~.:line1", flags=TestGrep._reflags)
298
self.assertContainsRe(out, "file1.txt~.:line2", flags=TestGrep._reflags)
299
self.assertContainsRe(out, "file2.txt~.:line1", flags=TestGrep._reflags)
300
self.assertContainsRe(out, "file2.txt~.:line2", flags=TestGrep._reflags)
301
self.assertEqual(len(out.splitlines()), 6)
303
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line'])
304
self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
305
self.assertContainsRe(out, "file0.txt~.:line2", flags=TestGrep._reflags)
306
self.assertContainsRe(out, "file1.txt~.:line1", flags=TestGrep._reflags)
307
self.assertContainsRe(out, "file1.txt~.:line2", flags=TestGrep._reflags)
308
self.assertContainsRe(out, "file2.txt~.:line1", flags=TestGrep._reflags)
309
self.assertContainsRe(out, "file2.txt~.:line2", flags=TestGrep._reflags)
310
self.assertEqual(len(out.splitlines()), 6)
312
def test_multiple_wtree_files(self):
313
"""(wtree) Search for pattern in multiple files in working tree.
316
self.make_branch_and_tree(wd)
318
self._mk_versioned_file('file0.txt', total_lines=2)
319
self._mk_versioned_file('file1.txt', total_lines=2)
320
self._mk_versioned_file('file2.txt', total_lines=2)
321
self._update_file('file0.txt', 'HELLO\n', checkin=False)
322
self._update_file('file1.txt', 'HELLO\n', checkin=True)
323
self._update_file('file2.txt', 'HELLO\n', checkin=False)
325
out, err = self.run_bzr(['grep', 'HELLO',
326
'file0.txt', 'file1.txt', 'file2.txt'])
328
self.assertContainsRe(out, "file0.txt:HELLO", flags=TestGrep._reflags)
329
self.assertContainsRe(out, "file1.txt:HELLO", flags=TestGrep._reflags)
330
self.assertContainsRe(out, "file2.txt:HELLO", flags=TestGrep._reflags)
331
self.assertEqual(len(out.splitlines()), 3)
333
out, err = self.run_bzr(['grep', 'HELLO', '-r', 'last:1',
334
'file0.txt', 'file1.txt', 'file2.txt'])
336
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
337
self.assertContainsRe(out, "file1.txt~.:HELLO", flags=TestGrep._reflags)
338
self.assertNotContainsRe(out, "file2.txt", flags=TestGrep._reflags)
339
self.assertEqual(len(out.splitlines()), 1)
341
out, err = self.run_bzr(['grep', 'HE..O',
342
'file0.txt', 'file1.txt', 'file2.txt'])
344
self.assertContainsRe(out, "file0.txt:HELLO", flags=TestGrep._reflags)
345
self.assertContainsRe(out, "file1.txt:HELLO", flags=TestGrep._reflags)
346
self.assertContainsRe(out, "file2.txt:HELLO", flags=TestGrep._reflags)
347
self.assertEqual(len(out.splitlines()), 3)
349
out, err = self.run_bzr(['grep', 'HE..O', '-r', 'last:1',
350
'file0.txt', 'file1.txt', 'file2.txt'])
352
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
353
self.assertContainsRe(out, "file1.txt~.:HELLO", flags=TestGrep._reflags)
354
self.assertNotContainsRe(out, "file2.txt", flags=TestGrep._reflags)
355
self.assertEqual(len(out.splitlines()), 1)
357
def test_ver_null_option(self):
358
"""(versioned) --null option should use NUL instead of newline.
361
self.make_branch_and_tree(wd)
363
self._mk_versioned_file('file0.txt', total_lines=3)
365
nref = ud.normalize(u'NFC', u"file0.txt~1:line1\0file0.txt~1:line2\0file0.txt~1:line3\0")
367
out, err = self.run_bzr(['grep', '-r', 'last:1', '--null', 'line[1-3]'])
369
out = out.decode('utf-8', 'ignore')
370
nout = ud.normalize(u'NFC', out)
371
self.assertEqual(nout, nref)
372
self.assertEqual(len(out.splitlines()), 1)
374
out, err = self.run_bzr(['grep', '-r', 'last:1', '-Z', 'line[1-3]'])
376
out = out.decode('utf-8', 'ignore')
377
nout = ud.normalize(u'NFC', out)
378
self.assertEqual(nout, nref)
379
self.assertEqual(len(out.splitlines()), 1)
381
out, err = self.run_bzr(['grep', '-r', 'last:1', '--null', 'line'])
383
out = out.decode('utf-8', 'ignore')
384
nout = ud.normalize(u'NFC', out)
385
self.assertEqual(nout, nref)
386
self.assertEqual(len(out.splitlines()), 1)
388
def test_wtree_null_option(self):
389
"""(wtree) --null option should use NUL instead of newline.
392
self.make_branch_and_tree(wd)
394
self._mk_versioned_file('file0.txt', total_lines=3)
396
out, err = self.run_bzr(['grep', '--null', 'line[1-3]'])
397
self.assertEqual(out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
398
self.assertEqual(len(out.splitlines()), 1)
400
out, err = self.run_bzr(['grep', '-Z', 'line[1-3]'])
401
self.assertEqual(out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
402
self.assertEqual(len(out.splitlines()), 1)
404
out, err = self.run_bzr(['grep', '-Z', 'line'])
405
self.assertEqual(out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
406
self.assertEqual(len(out.splitlines()), 1)
408
def test_versioned_file_in_dir_no_recursive(self):
409
"""(versioned) Should not recurse with --no-recursive"""
411
self.make_branch_and_tree(wd)
413
self._mk_versioned_file('fileX.txt', line_prefix='lin')
414
self._mk_versioned_dir('dir0')
415
self._mk_versioned_file('dir0/file0.txt')
417
out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1'])
418
self.assertNotContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
419
self.assertEqual(len(out.splitlines()), 0)
421
out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1$'])
422
self.assertNotContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
423
self.assertEqual(len(out.splitlines()), 0)
425
def test_wtree_file_in_dir_no_recursive(self):
426
"""(wtree) Should not recurse with --no-recursive"""
428
self.make_branch_and_tree(wd)
430
self._mk_versioned_file('fileX.txt', line_prefix='lin')
431
self._mk_versioned_dir('dir0')
432
self._mk_versioned_file('dir0/file0.txt')
434
out, err = self.run_bzr(['grep', '--no-recursive', 'line1'])
435
self.assertNotContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
436
self.assertEqual(len(out.splitlines()), 0)
438
out, err = self.run_bzr(['grep', '--no-recursive', 'lin.1'])
439
self.assertNotContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
440
self.assertEqual(len(out.splitlines()), 0)
442
def test_versioned_file_in_dir_recurse(self):
443
"""(versioned) Should recurse by default.
446
self.make_branch_and_tree(wd)
448
self._mk_versioned_dir('dir0')
449
self._mk_versioned_file('dir0/file0.txt')
451
out, err = self.run_bzr(['grep', '-r', '-1', '.i.e1'])
452
self.assertContainsRe(out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
453
# find line1 and line10
454
self.assertEqual(len(out.splitlines()), 2)
456
out, err = self.run_bzr(['grep', '-r', '-1', 'line1'])
457
self.assertContainsRe(out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
458
# find line1 and line10
459
self.assertEqual(len(out.splitlines()), 2)
461
def test_wtree_file_in_dir_recurse(self):
462
"""(wtree) Should recurse by default.
465
self.make_branch_and_tree(wd)
467
self._mk_versioned_dir('dir0')
468
self._mk_versioned_file('dir0/file0.txt')
470
out, err = self.run_bzr(['grep', 'line1'])
471
self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
472
# find line1 and line10
473
self.assertEqual(len(out.splitlines()), 2)
475
out, err = self.run_bzr(['grep', 'lin.1'])
476
self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
477
# find line1 and line10
478
self.assertEqual(len(out.splitlines()), 2)
480
def test_versioned_file_within_dir(self):
481
"""(versioned) Search for pattern while in nested dir.
484
self.make_branch_and_tree(wd)
486
self._mk_versioned_dir('dir0')
487
self._mk_versioned_file('dir0/file0.txt')
490
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
491
self.assertContainsRe(out, "^file0.txt~.:line1", flags=TestGrep._reflags)
492
# finds line1 and line10
493
self.assertEqual(len(out.splitlines()), 2)
495
out, err = self.run_bzr(['grep', '-r', 'last:1', '.i.e1'])
496
self.assertContainsRe(out, "^file0.txt~.:line1", flags=TestGrep._reflags)
497
# finds line1 and line10
498
self.assertEqual(len(out.splitlines()), 2)
500
def test_versioned_include_file_within_dir(self):
501
"""(versioned) Ensure --include is respected with file within dir.
504
self.make_branch_and_tree(wd)
506
self._mk_versioned_dir('dir0') # revno 1
507
self._mk_versioned_file('dir0/file0.txt') # revno 2
508
self._mk_versioned_file('dir0/file1.aa') # revno 3
509
self._update_file('dir0/file1.aa', 'hello\n') # revno 4
510
self._update_file('dir0/file0.txt', 'hello\n') # revno 5
513
out, err = self.run_bzr(['grep', '-r', 'last:1',
514
'--include', '*.aa', 'line1'])
515
self.assertContainsRe(out, "^file1.aa~5:line1$", flags=TestGrep._reflags)
516
self.assertContainsRe(out, "^file1.aa~5:line10$", flags=TestGrep._reflags)
517
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
518
# finds line1 and line10
519
self.assertEqual(len(out.splitlines()), 2)
521
out, err = self.run_bzr(['grep', '-r', 'last:2..last:1',
522
'--include', '*.aa', 'line1'])
523
self.assertContainsRe(out, "^file1.aa~4:line1$", flags=TestGrep._reflags)
524
self.assertContainsRe(out, "^file1.aa~4:line10$", flags=TestGrep._reflags)
525
self.assertContainsRe(out, "^file1.aa~5:line1$", flags=TestGrep._reflags)
526
self.assertContainsRe(out, "^file1.aa~5:line10$", flags=TestGrep._reflags)
527
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
528
# finds line1 and line10 over two revisions
529
self.assertEqual(len(out.splitlines()), 4)
531
out, err = self.run_bzr(['grep', '-r', 'last:1',
532
'--include', '*.aa', 'lin.1'])
533
self.assertContainsRe(out, "^file1.aa~5:line1$", flags=TestGrep._reflags)
534
self.assertContainsRe(out, "^file1.aa~5:line10$", flags=TestGrep._reflags)
535
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
536
# finds line1 and line10
537
self.assertEqual(len(out.splitlines()), 2)
539
out, err = self.run_bzr(['grep', '-r', 'last:3..last:1',
540
'--include', '*.aa', 'lin.1'])
541
self.assertContainsRe(out, "^file1.aa~3:line1$", flags=TestGrep._reflags)
542
self.assertContainsRe(out, "^file1.aa~4:line1$", flags=TestGrep._reflags)
543
self.assertContainsRe(out, "^file1.aa~5:line1$", flags=TestGrep._reflags)
544
self.assertContainsRe(out, "^file1.aa~3:line10$", flags=TestGrep._reflags)
545
self.assertContainsRe(out, "^file1.aa~4:line10$", flags=TestGrep._reflags)
546
self.assertContainsRe(out, "^file1.aa~5:line10$", flags=TestGrep._reflags)
547
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
548
# finds line1 and line10 over 3 revisions
549
self.assertEqual(len(out.splitlines()), 6)
551
def test_versioned_exclude_file_within_dir(self):
552
"""(versioned) Ensure --exclude is respected with file within dir.
555
self.make_branch_and_tree(wd)
557
self._mk_versioned_dir('dir0')
558
self._mk_versioned_file('dir0/file0.txt')
559
self._mk_versioned_file('dir0/file1.aa')
562
out, err = self.run_bzr(['grep', '-r', 'last:1',
563
'--exclude', '*.txt', 'line1'])
564
self.assertContainsRe(out, "^file1.aa~.:line1", flags=TestGrep._reflags)
565
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
566
# finds line1 and line10
567
self.assertEqual(len(out.splitlines()), 2)
569
out, err = self.run_bzr(['grep', '-r', 'last:1',
570
'--exclude', '*.txt', 'l[a-z]ne1'])
571
self.assertContainsRe(out, "^file1.aa~.:line1", flags=TestGrep._reflags)
572
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
573
# finds line1 and line10
574
self.assertEqual(len(out.splitlines()), 2)
576
def test_wtree_file_within_dir(self):
577
"""(wtree) Search for pattern while in nested dir.
580
self.make_branch_and_tree(wd)
582
self._mk_versioned_dir('dir0')
583
self._mk_versioned_file('dir0/file0.txt')
586
out, err = self.run_bzr(['grep', 'line1'])
587
self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
588
# finds line1 and line10
589
self.assertEqual(len(out.splitlines()), 2)
591
out, err = self.run_bzr(['grep', 'l[aeiou]ne1'])
592
self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
593
# finds line1 and line10
594
self.assertEqual(len(out.splitlines()), 2)
596
def test_wtree_include_file_within_dir(self):
597
"""(wtree) Ensure --include is respected with file within dir.
600
self.make_branch_and_tree(wd)
602
self._mk_versioned_dir('dir0')
603
self._mk_versioned_file('dir0/file0.txt')
604
self._mk_versioned_file('dir0/file1.aa')
607
out, err = self.run_bzr(['grep', '--include', '*.aa', 'line1'])
608
self.assertContainsRe(out, "^file1.aa:line1", flags=TestGrep._reflags)
609
# finds line1 and line10
610
self.assertEqual(len(out.splitlines()), 2)
612
out, err = self.run_bzr(['grep', '--include', '*.aa', 'l[ixn]ne1'])
613
self.assertContainsRe(out, "^file1.aa:line1", flags=TestGrep._reflags)
614
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
615
# finds line1 and line10
616
self.assertEqual(len(out.splitlines()), 2)
618
def test_wtree_exclude_file_within_dir(self):
619
"""(wtree) Ensure --exclude is respected with file within dir.
622
self.make_branch_and_tree(wd)
624
self._mk_versioned_dir('dir0')
625
self._mk_versioned_file('dir0/file0.txt')
626
self._mk_versioned_file('dir0/file1.aa')
629
out, err = self.run_bzr(['grep', '--exclude', '*.txt', 'li.e1'])
630
self.assertContainsRe(out, "^file1.aa:line1$", flags=TestGrep._reflags)
631
self.assertContainsRe(out, "^file1.aa:line10$", flags=TestGrep._reflags)
632
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
633
# finds line1 and line10
634
self.assertEqual(len(out.splitlines()), 2)
636
out, err = self.run_bzr(['grep', '--exclude', '*.txt', 'line1'])
637
self.assertContainsRe(out, "^file1.aa:line1$", flags=TestGrep._reflags)
638
self.assertContainsRe(out, "^file1.aa:line10$", flags=TestGrep._reflags)
639
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
640
# finds line1 and line10
641
self.assertEqual(len(out.splitlines()), 2)
643
def test_versioned_include_from_outside_dir(self):
644
"""(versioned) Ensure --include is respected during recursive search.
647
self.make_branch_and_tree(wd)
650
self._mk_versioned_dir('dir0')
651
self._mk_versioned_file('dir0/file0.aa')
653
self._mk_versioned_dir('dir1')
654
self._mk_versioned_file('dir1/file1.bb')
656
self._mk_versioned_dir('dir2')
657
self._mk_versioned_file('dir2/file2.cc')
659
out, err = self.run_bzr(['grep', '-r', 'last:1',
660
'--include', '*.aa', '--include', '*.bb', 'l..e1'])
661
self.assertContainsRe(out, "^dir0/file0.aa~.:line1$", flags=TestGrep._reflags)
662
self.assertContainsRe(out, "^dir1/file1.bb~.:line1$", flags=TestGrep._reflags)
663
self.assertContainsRe(out, "^dir0/file0.aa~.:line10$", flags=TestGrep._reflags)
664
self.assertContainsRe(out, "^dir1/file1.bb~.:line10$", flags=TestGrep._reflags)
665
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
666
# finds line1 and line10
667
self.assertEqual(len(out.splitlines()), 4)
669
out, err = self.run_bzr(['grep', '-r', 'last:1',
670
'--include', '*.aa', '--include', '*.bb', 'line1'])
671
self.assertContainsRe(out, "^dir0/file0.aa~.:line1$", flags=TestGrep._reflags)
672
self.assertContainsRe(out, "^dir1/file1.bb~.:line1$", flags=TestGrep._reflags)
673
self.assertContainsRe(out, "^dir0/file0.aa~.:line10$", flags=TestGrep._reflags)
674
self.assertContainsRe(out, "^dir1/file1.bb~.:line10$", flags=TestGrep._reflags)
675
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
676
# finds line1 and line10
677
self.assertEqual(len(out.splitlines()), 4)
679
def test_wtree_include_from_outside_dir(self):
680
"""(wtree) Ensure --include is respected during recursive search.
683
self.make_branch_and_tree(wd)
686
self._mk_versioned_dir('dir0')
687
self._mk_versioned_file('dir0/file0.aa')
689
self._mk_versioned_dir('dir1')
690
self._mk_versioned_file('dir1/file1.bb')
692
self._mk_versioned_dir('dir2')
693
self._mk_versioned_file('dir2/file2.cc')
695
out, err = self.run_bzr(['grep', '--include', '*.aa',
696
'--include', '*.bb', 'l.n.1'])
697
self.assertContainsRe(out, "^dir0/file0.aa:line1$", flags=TestGrep._reflags)
698
self.assertContainsRe(out, "^dir1/file1.bb:line1$", flags=TestGrep._reflags)
699
self.assertContainsRe(out, "^dir0/file0.aa:line10$", flags=TestGrep._reflags)
700
self.assertContainsRe(out, "^dir1/file1.bb:line10$", flags=TestGrep._reflags)
701
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
702
# finds line1 and line10
703
self.assertEqual(len(out.splitlines()), 4)
705
out, err = self.run_bzr(['grep', '--include', '*.aa',
706
'--include', '*.bb', 'line1'])
707
self.assertContainsRe(out, "^dir0/file0.aa:line1$", flags=TestGrep._reflags)
708
self.assertContainsRe(out, "^dir1/file1.bb:line1$", flags=TestGrep._reflags)
709
self.assertContainsRe(out, "^dir0/file0.aa:line10$", flags=TestGrep._reflags)
710
self.assertContainsRe(out, "^dir1/file1.bb:line10$", flags=TestGrep._reflags)
711
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
712
# finds line1 and line10
713
self.assertEqual(len(out.splitlines()), 4)
715
def test_versioned_exclude_from_outside_dir(self):
716
"""(versioned) Ensure --exclude is respected during recursive search.
719
self.make_branch_and_tree(wd)
722
self._mk_versioned_dir('dir0')
723
self._mk_versioned_file('dir0/file0.aa')
725
self._mk_versioned_dir('dir1')
726
self._mk_versioned_file('dir1/file1.bb')
728
self._mk_versioned_dir('dir2')
729
self._mk_versioned_file('dir2/file2.cc')
731
out, err = self.run_bzr(['grep', '-r', 'last:1',
732
'--exclude', '*.cc', 'l..e1'])
733
self.assertContainsRe(out, "^dir0/file0.aa~.:line1", flags=TestGrep._reflags)
734
self.assertContainsRe(out, "^dir1/file1.bb~.:line1", flags=TestGrep._reflags)
735
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
737
out, err = self.run_bzr(['grep', '-r', 'last:1',
738
'--exclude', '*.cc', 'line1'])
739
self.assertContainsRe(out, "^dir0/file0.aa~.:line1", flags=TestGrep._reflags)
740
self.assertContainsRe(out, "^dir1/file1.bb~.:line1", flags=TestGrep._reflags)
741
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
743
def test_wtree_exclude_from_outside_dir(self):
744
"""(wtree) Ensure --exclude is respected during recursive search.
747
self.make_branch_and_tree(wd)
750
self._mk_versioned_dir('dir0')
751
self._mk_versioned_file('dir0/file0.aa')
753
self._mk_versioned_dir('dir1')
754
self._mk_versioned_file('dir1/file1.bb')
756
self._mk_versioned_dir('dir2')
757
self._mk_versioned_file('dir2/file2.cc')
759
out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'l[hijk]ne1'])
760
self.assertContainsRe(out, "^dir0/file0.aa:line1", flags=TestGrep._reflags)
761
self.assertContainsRe(out, "^dir1/file1.bb:line1", flags=TestGrep._reflags)
762
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
764
out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'line1'])
765
self.assertContainsRe(out, "^dir0/file0.aa:line1", flags=TestGrep._reflags)
766
self.assertContainsRe(out, "^dir1/file1.bb:line1", flags=TestGrep._reflags)
767
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
769
def test_workingtree_files_from_outside_dir(self):
770
"""(wtree) Grep for pattern with dirs passed as argument.
773
self.make_branch_and_tree(wd)
776
self._mk_versioned_dir('dir0')
777
self._mk_versioned_file('dir0/file0.txt')
779
self._mk_versioned_dir('dir1')
780
self._mk_versioned_file('dir1/file1.txt')
782
out, err = self.run_bzr(['grep', 'l[aeiou]ne1', 'dir0', 'dir1'])
783
self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
784
self.assertContainsRe(out, "^dir1/file1.txt:line1", flags=TestGrep._reflags)
786
out, err = self.run_bzr(['grep', 'line1', 'dir0', 'dir1'])
787
self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
788
self.assertContainsRe(out, "^dir1/file1.txt:line1", flags=TestGrep._reflags)
790
def test_versioned_files_from_outside_dir(self):
791
"""(versioned) Grep for pattern with dirs passed as argument.
794
self.make_branch_and_tree(wd)
797
self._mk_versioned_dir('dir0')
798
self._mk_versioned_file('dir0/file0.txt')
800
self._mk_versioned_dir('dir1')
801
self._mk_versioned_file('dir1/file1.txt')
803
out, err = self.run_bzr(['grep', '-r', 'last:1', '.ine1', 'dir0', 'dir1'])
804
self.assertContainsRe(out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
805
self.assertContainsRe(out, "^dir1/file1.txt~.:line1", flags=TestGrep._reflags)
807
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1', 'dir0', 'dir1'])
808
self.assertContainsRe(out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
809
self.assertContainsRe(out, "^dir1/file1.txt~.:line1", flags=TestGrep._reflags)
811
def test_wtree_files_from_outside_dir(self):
812
"""(wtree) Grep for pattern with dirs passed as argument.
815
self.make_branch_and_tree(wd)
818
self._mk_versioned_dir('dir0')
819
self._mk_versioned_file('dir0/file0.txt')
821
self._mk_versioned_dir('dir1')
822
self._mk_versioned_file('dir1/file1.txt')
824
out, err = self.run_bzr(['grep', 'li.e1', 'dir0', 'dir1'])
825
self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
826
self.assertContainsRe(out, "^dir1/file1.txt:line1", flags=TestGrep._reflags)
828
out, err = self.run_bzr(['grep', 'line1', 'dir0', 'dir1'])
829
self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
830
self.assertContainsRe(out, "^dir1/file1.txt:line1", flags=TestGrep._reflags)
832
def test_versioned_files_from_outside_two_dirs(self):
833
"""(versioned) Grep for pattern with two levels of nested dir.
836
self.make_branch_and_tree(wd)
839
self._mk_versioned_dir('dir0')
840
self._mk_versioned_file('dir0/file0.txt')
842
self._mk_versioned_dir('dir1')
843
self._mk_versioned_file('dir1/file1.txt')
845
self._mk_versioned_dir('dir0/dir00')
846
self._mk_versioned_file('dir0/dir00/file0.txt')
848
out, err = self.run_bzr(['grep', '-r', 'last:1', 'l.ne1', 'dir0/dir00'])
849
self.assertContainsRe(out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
851
out, err = self.run_bzr(['grep', '-r', 'last:1', 'l.ne1'])
852
self.assertContainsRe(out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
854
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1', 'dir0/dir00'])
855
self.assertContainsRe(out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
857
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
858
self.assertContainsRe(out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
860
def test_wtree_files_from_outside_two_dirs(self):
861
"""(wtree) Grep for pattern with two levels of nested dir.
864
self.make_branch_and_tree(wd)
867
self._mk_versioned_dir('dir0')
868
self._mk_versioned_file('dir0/file0.txt')
870
self._mk_versioned_dir('dir1')
871
self._mk_versioned_file('dir1/file1.txt')
873
self._mk_versioned_dir('dir0/dir00')
874
self._mk_versioned_file('dir0/dir00/file0.txt')
876
out, err = self.run_bzr(['grep', 'lin.1', 'dir0/dir00'])
877
self.assertContainsRe(out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
879
out, err = self.run_bzr(['grep', 'li.e1'])
880
self.assertContainsRe(out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
882
out, err = self.run_bzr(['grep', 'line1', 'dir0/dir00'])
883
self.assertContainsRe(out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
885
out, err = self.run_bzr(['grep', 'line1'])
886
self.assertContainsRe(out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
888
def test_versioned_file_within_dir_two_levels(self):
889
"""(versioned) Search for pattern while in nested dir (two levels).
892
self.make_branch_and_tree(wd)
894
self._mk_versioned_dir('dir0')
895
self._mk_versioned_dir('dir0/dir1')
896
self._mk_versioned_file('dir0/dir1/file0.txt')
899
out, err = self.run_bzr(['grep', '-r', 'last:1', '.ine1'])
900
self.assertContainsRe(out, "^dir1/file0.txt~.:line1", flags=TestGrep._reflags)
902
out, err = self.run_bzr(['grep', '-r', 'last:1', '--from-root', 'l.ne1'])
903
self.assertContainsRe(out, "^dir0/dir1/file0.txt~.:line1", flags=TestGrep._reflags)
905
out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1'])
906
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
908
out, err = self.run_bzr(['grep', '-r', 'last:1', 'lin.1'])
909
self.assertContainsRe(out, "^dir1/file0.txt~.:line1", flags=TestGrep._reflags)
911
out, err = self.run_bzr(['grep', '-r', 'last:1', '--from-root', 'line1'])
912
self.assertContainsRe(out, "^dir0/dir1/file0.txt~.:line1", flags=TestGrep._reflags)
914
out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1'])
915
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
916
self.assertEqual(len(out.splitlines()), 0)
918
def test_wtree_file_within_dir_two_levels(self):
919
"""(wtree) Search for pattern while in nested dir (two levels).
922
self.make_branch_and_tree(wd)
924
self._mk_versioned_dir('dir0')
925
self._mk_versioned_dir('dir0/dir1')
926
self._mk_versioned_file('dir0/dir1/file0.txt')
929
out, err = self.run_bzr(['grep', 'l[hij]ne1'])
930
self.assertContainsRe(out, "^dir1/file0.txt:line1", flags=TestGrep._reflags)
932
out, err = self.run_bzr(['grep', '--from-root', 'l.ne1'])
933
self.assertContainsRe(out, "^dir0/dir1/file0.txt:line1", flags=TestGrep._reflags)
935
out, err = self.run_bzr(['grep', '--no-recursive', 'lin.1'])
936
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
938
out, err = self.run_bzr(['grep', 'line1'])
939
self.assertContainsRe(out, "^dir1/file0.txt:line1", flags=TestGrep._reflags)
941
out, err = self.run_bzr(['grep', '--from-root', 'line1'])
942
self.assertContainsRe(out, "^dir0/dir1/file0.txt:line1", flags=TestGrep._reflags)
944
out, err = self.run_bzr(['grep', '--no-recursive', 'line1'])
945
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
947
def test_versioned_ignore_case_no_match(self):
948
"""(versioned) Match fails without --ignore-case.
951
self.make_branch_and_tree(wd)
953
self._mk_versioned_file('file0.txt')
955
out, err = self.run_bzr(['grep', '-r', 'last:1', 'LinE1', 'file0.txt'])
956
self.assertNotContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
958
out, err = self.run_bzr(['grep', '-r', 'last:1', 'Li.E1', 'file0.txt'])
959
self.assertNotContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
961
def test_wtree_ignore_case_no_match(self):
962
"""(wtree) Match fails without --ignore-case.
965
self.make_branch_and_tree(wd)
967
self._mk_versioned_file('file0.txt')
969
out, err = self.run_bzr(['grep', 'LinE1', 'file0.txt'])
970
self.assertNotContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
972
out, err = self.run_bzr(['grep', '.inE1', 'file0.txt'])
973
self.assertNotContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
975
def test_versioned_ignore_case_match(self):
976
"""(versioned) Match fails without --ignore-case.
979
self.make_branch_and_tree(wd)
981
self._mk_versioned_file('file0.txt')
983
out, err = self.run_bzr(['grep', '-r', 'last:1',
984
'-i', 'Li.E1', 'file0.txt'])
985
self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
987
out, err = self.run_bzr(['grep', '-r', 'last:1',
988
'-i', 'LinE1', 'file0.txt'])
989
self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
991
out, err = self.run_bzr(['grep', '-r', 'last:1',
992
'--ignore-case', 'LinE1', 'file0.txt'])
993
self.assertContainsRe(out, "^file0.txt~.:line1", flags=TestGrep._reflags)
995
def test_wtree_ignore_case_match(self):
996
"""(wtree) Match fails without --ignore-case.
999
self.make_branch_and_tree(wd)
1001
self._mk_versioned_file('file0.txt')
1003
out, err = self.run_bzr(['grep', '-i', 'LinE1', 'file0.txt'])
1004
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
1006
out, err = self.run_bzr(['grep', '--ignore-case', 'LinE1', 'file0.txt'])
1007
self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
1009
out, err = self.run_bzr(['grep', '--ignore-case', 'Li.E1', 'file0.txt'])
1010
self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
1012
def test_versioned_from_root_fail(self):
1013
"""(versioned) Match should fail without --from-root.
1016
self.make_branch_and_tree(wd)
1018
self._mk_versioned_file('file0.txt')
1019
self._mk_versioned_dir('dir0')
1022
out, err = self.run_bzr(['grep', '-r', 'last:1', 'li.e1'])
1023
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1025
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
1026
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1028
def test_wtree_from_root_fail(self):
1029
"""(wtree) Match should fail without --from-root.
1032
self.make_branch_and_tree(wd)
1034
self._mk_versioned_file('file0.txt')
1035
self._mk_versioned_dir('dir0')
1038
out, err = self.run_bzr(['grep', 'line1'])
1039
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1041
out, err = self.run_bzr(['grep', 'li.e1'])
1042
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1044
def test_versioned_from_root_pass(self):
1045
"""(versioned) Match pass with --from-root.
1048
self.make_branch_and_tree(wd)
1050
self._mk_versioned_file('file0.txt')
1051
self._mk_versioned_dir('dir0')
1054
out, err = self.run_bzr(['grep', '-r', 'last:1',
1055
'--from-root', 'l.ne1'])
1056
self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
1058
out, err = self.run_bzr(['grep', '-r', 'last:1',
1059
'--from-root', 'line1'])
1060
self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
1062
def test_wtree_from_root_pass(self):
1063
"""(wtree) Match pass with --from-root.
1066
self.make_branch_and_tree(wd)
1068
self._mk_versioned_file('file0.txt')
1069
self._mk_versioned_dir('dir0')
1072
out, err = self.run_bzr(['grep', '--from-root', 'lin.1'])
1073
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
1075
out, err = self.run_bzr(['grep', '--from-root', 'line1'])
1076
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
1078
def test_versioned_with_line_number(self):
1079
"""(versioned) Search for pattern with --line-number.
1082
self.make_branch_and_tree(wd)
1084
self._mk_versioned_file('file0.txt')
1086
out, err = self.run_bzr(['grep', '-r', 'last:1',
1087
'--line-number', 'li.e3', 'file0.txt'])
1088
self.assertContainsRe(out, "file0.txt~.:3:line3", flags=TestGrep._reflags)
1090
out, err = self.run_bzr(['grep', '-r', 'last:1',
1091
'--line-number', 'line3', 'file0.txt'])
1092
self.assertContainsRe(out, "file0.txt~.:3:line3", flags=TestGrep._reflags)
1094
out, err = self.run_bzr(['grep', '-r', 'last:1',
1095
'-n', 'line1', 'file0.txt'])
1096
self.assertContainsRe(out, "file0.txt~.:1:line1", flags=TestGrep._reflags)
1098
out, err = self.run_bzr(['grep', '-n', 'line[0-9]', 'file0.txt'])
1099
self.assertContainsRe(out, "file0.txt:3:line3", flags=TestGrep._reflags)
1101
def test_wtree_with_line_number(self):
1102
"""(wtree) Search for pattern with --line-number.
1105
self.make_branch_and_tree(wd)
1107
self._mk_versioned_file('file0.txt')
1109
out, err = self.run_bzr(['grep', '--line-number', 'line3', 'file0.txt'])
1110
self.assertContainsRe(out, "file0.txt:3:line3", flags=TestGrep._reflags)
1112
out, err = self.run_bzr(['grep', '-n', 'line1', 'file0.txt'])
1113
self.assertContainsRe(out, "file0.txt:1:line1", flags=TestGrep._reflags)
1115
out, err = self.run_bzr(['grep', '-n', '[hjkl]ine1', 'file0.txt'])
1116
self.assertContainsRe(out, "file0.txt:1:line1", flags=TestGrep._reflags)
1118
out, err = self.run_bzr(['grep', '-n', 'line[0-9]', 'file0.txt'])
1119
self.assertContainsRe(out, "file0.txt:3:line3", flags=TestGrep._reflags)
1121
def test_revno_basic_history_grep_file(self):
1122
"""Search for pattern in specific revision number in a file.
1126
self.make_branch_and_tree(wd)
1128
self._mk_versioned_file(fname, total_lines=0)
1129
self._update_file(fname, text="v2 text\n")
1130
self._update_file(fname, text="v3 text\n")
1131
self._update_file(fname, text="v4 text\n")
1133
# rev 2 should not have text 'v3'
1134
out, err = self.run_bzr(['grep', '-r', '2', 'v3', fname])
1135
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1137
# rev 3 should not have text 'v3'
1138
out, err = self.run_bzr(['grep', '-r', '3', 'v3', fname])
1139
self.assertContainsRe(out, "file0.txt~3:v3.*", flags=TestGrep._reflags)
1141
# rev 3 should not have text 'v3' with line number
1142
out, err = self.run_bzr(['grep', '-r', '3', '-n', 'v3', fname])
1143
self.assertContainsRe(out, "file0.txt~3:2:v3.*", flags=TestGrep._reflags)
1145
# rev 2 should not have text 'v3'
1146
out, err = self.run_bzr(['grep', '-r', '2', '[tuv]3', fname])
1147
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1149
# rev 3 should not have text 'v3'
1150
out, err = self.run_bzr(['grep', '-r', '3', '[tuv]3', fname])
1151
self.assertContainsRe(out, "file0.txt~3:v3.*", flags=TestGrep._reflags)
1153
# rev 3 should not have text 'v3' with line number
1154
out, err = self.run_bzr(['grep', '-r', '3', '-n', '[tuv]3', fname])
1155
self.assertContainsRe(out, "file0.txt~3:2:v3.*", flags=TestGrep._reflags)
1157
def test_revno_basic_history_grep_full(self):
1158
"""Search for pattern in specific revision number in a file.
1162
self.make_branch_and_tree(wd)
1164
self._mk_versioned_file(fname, total_lines=0) # rev1
1165
self._mk_versioned_file('file1.txt') # rev2
1166
self._update_file(fname, text="v3 text\n") # rev3
1167
self._update_file(fname, text="v4 text\n") # rev4
1168
self._update_file(fname, text="v5 text\n") # rev5
1170
# rev 2 should not have text 'v3'
1171
out, err = self.run_bzr(['grep', '-r', '2', 'v3'])
1172
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1174
# rev 3 should not have text 'v3'
1175
out, err = self.run_bzr(['grep', '-r', '3', 'v3'])
1176
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1178
# rev 3 should not have text 'v3' with line number
1179
out, err = self.run_bzr(['grep', '-r', '3', '-n', 'v3'])
1180
self.assertContainsRe(out, "file0.txt~3:1:v3", flags=TestGrep._reflags)
1182
# rev 2 should not have text 'v3'
1183
out, err = self.run_bzr(['grep', '-r', '2', '[tuv]3'])
1184
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1186
# rev 3 should not have text 'v3'
1187
out, err = self.run_bzr(['grep', '-r', '3', '[tuv]3'])
1188
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1190
# rev 3 should not have text 'v3' with line number
1191
out, err = self.run_bzr(['grep', '-r', '3', '-n', '[tuv]3'])
1192
self.assertContainsRe(out, "file0.txt~3:1:v3", flags=TestGrep._reflags)
1194
def test_revno_versioned_file_in_dir(self):
1195
"""Grep specific version of file withing dir.
1198
self.make_branch_and_tree(wd)
1200
self._mk_versioned_dir('dir0') # rev1
1201
self._mk_versioned_file('dir0/file0.txt') # rev2
1202
self._update_file('dir0/file0.txt', "v3 text\n") # rev3
1203
self._update_file('dir0/file0.txt', "v4 text\n") # rev4
1204
self._update_file('dir0/file0.txt', "v5 text\n") # rev5
1206
# v4 should not be present in revno 3
1207
out, err = self.run_bzr(['grep', '-r', 'last:3', 'v4'])
1208
self.assertNotContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
1210
# v4 should be present in revno 4
1211
out, err = self.run_bzr(['grep', '-r', 'last:2', 'v4'])
1212
self.assertContainsRe(out, "^dir0/file0.txt~4:v4", flags=TestGrep._reflags)
1214
# v4 should not be present in revno 3
1215
out, err = self.run_bzr(['grep', '-r', 'last:3', '[tuv]4'])
1216
self.assertNotContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
1218
# v4 should be present in revno 4
1219
out, err = self.run_bzr(['grep', '-r', 'last:2', '[tuv]4'])
1220
self.assertContainsRe(out, "^dir0/file0.txt~4:v4", flags=TestGrep._reflags)
1222
def test_revno_range_basic_history_grep(self):
1223
"""Search for pattern in revision range for file.
1227
self.make_branch_and_tree(wd)
1229
self._mk_versioned_file(fname, total_lines=0) # rev1
1230
self._mk_versioned_file('file1.txt') # rev2
1231
self._update_file(fname, text="v3 text\n") # rev3
1232
self._update_file(fname, text="v4 text\n") # rev4
1233
self._update_file(fname, text="v5 text\n") # rev5
1234
self._update_file(fname, text="v6 text\n") # rev6
1236
out, err = self.run_bzr(['grep', '-r', '1..', 'v3'])
1237
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1238
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1239
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1240
self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1241
self.assertEqual(len(out.splitlines()), 4)
1243
out, err = self.run_bzr(['grep', '-r', '..1', 'v3'])
1244
# searching only rev1 gives nothing
1245
self.assertEqual(len(out.splitlines()), 0)
1247
out, err = self.run_bzr(['grep', '-r', '..6', 'v3'])
1248
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1249
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1250
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1251
self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1252
self.assertEqual(len(out.splitlines()), 4)
1254
out, err = self.run_bzr(['grep', '-r', '..', 'v3'])
1255
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1256
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1257
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1258
self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1259
self.assertEqual(len(out.splitlines()), 4)
1261
out, err = self.run_bzr(['grep', '-r', '1..5', 'v3'])
1262
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1263
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1264
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1265
self.assertNotContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1266
self.assertEqual(len(out.splitlines()), 3)
1268
out, err = self.run_bzr(['grep', '-r', '5..1', 'v3'])
1269
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1270
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1271
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1272
self.assertNotContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1273
self.assertEqual(len(out.splitlines()), 3)
1275
out, err = self.run_bzr(['grep', '-r', '1..', '[tuv]3'])
1276
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1277
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1278
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1279
self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1280
self.assertEqual(len(out.splitlines()), 4)
1282
out, err = self.run_bzr(['grep', '-r', '1..5', '[tuv]3'])
1283
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1284
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1285
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1286
self.assertNotContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1287
self.assertEqual(len(out.splitlines()), 3)
1289
out, err = self.run_bzr(['grep', '-r', '5..1', '[tuv]3'])
1290
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1291
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1292
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1293
self.assertNotContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1294
self.assertEqual(len(out.splitlines()), 3)
1296
def test_revno_range_versioned_file_in_dir(self):
1297
"""Grep rev-range for pattern for file withing a dir.
1300
self.make_branch_and_tree(wd)
1302
self._mk_versioned_dir('dir0') # rev1
1303
self._mk_versioned_file('dir0/file0.txt') # rev2
1304
self._update_file('dir0/file0.txt', "v3 text\n") # rev3
1305
self._update_file('dir0/file0.txt', "v4 text\n") # rev4
1306
self._update_file('dir0/file0.txt', "v5 text\n") # rev5
1307
self._update_file('dir0/file0.txt', "v6 text\n") # rev6
1309
out, err = self.run_bzr(['grep', '-r', '2..5', 'v3'])
1310
self.assertContainsRe(out, "^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
1311
self.assertContainsRe(out, "^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
1312
self.assertContainsRe(out, "^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
1313
self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1314
self.assertEqual(len(out.splitlines()), 3)
1316
out, err = self.run_bzr(['grep', '-r', '2..5', '[tuv]3'])
1317
self.assertContainsRe(out, "^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
1318
self.assertContainsRe(out, "^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
1319
self.assertContainsRe(out, "^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
1320
self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1321
self.assertEqual(len(out.splitlines()), 3)
1323
def test_revno_range_versioned_file_from_outside_dir(self):
1324
"""Grep rev-range for pattern from outside dir.
1327
self.make_branch_and_tree(wd)
1329
self._mk_versioned_dir('dir0') # rev1
1330
self._mk_versioned_file('dir0/file0.txt') # rev2
1331
self._update_file('dir0/file0.txt', "v3 text\n") # rev3
1332
self._update_file('dir0/file0.txt', "v4 text\n") # rev4
1333
self._update_file('dir0/file0.txt', "v5 text\n") # rev5
1334
self._update_file('dir0/file0.txt', "v6 text\n") # rev6
1336
out, err = self.run_bzr(['grep', '-r', '2..5', 'v3', 'dir0'])
1337
self.assertContainsRe(out, "^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
1338
self.assertContainsRe(out, "^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
1339
self.assertContainsRe(out, "^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
1340
self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1342
out, err = self.run_bzr(['grep', '-r', '2..5', '[tuv]3', 'dir0'])
1343
self.assertContainsRe(out, "^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
1344
self.assertContainsRe(out, "^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
1345
self.assertContainsRe(out, "^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
1346
self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1348
def test_levels(self):
1349
"""--levels=0 should show findings from merged revision.
1354
self.make_branch_and_tree(wd0)
1356
self._mk_versioned_file('file0.txt')
1359
out, err = self.run_bzr(['branch', wd0, wd1])
1361
self._mk_versioned_file('file1.txt')
1362
os.chdir(osutils.pathjoin('..', wd0))
1364
out, err = self.run_bzr(['merge', osutils.pathjoin('..', wd1)])
1365
out, err = self.run_bzr(['ci', '-m', 'merged'])
1367
out, err = self.run_bzr(['grep', 'line1'])
1368
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
1369
self.assertContainsRe(out, "file1.txt:line1", flags=TestGrep._reflags)
1371
# levels should be ignored by wtree grep
1372
out, err = self.run_bzr(['grep', '--levels=0', 'line1'])
1373
self.assertContainsRe(out, "^file0.txt:line1$", flags=TestGrep._reflags)
1374
self.assertContainsRe(out, "^file1.txt:line1$", flags=TestGrep._reflags)
1375
self.assertContainsRe(out, "^file0.txt:line10$", flags=TestGrep._reflags)
1376
self.assertContainsRe(out, "^file1.txt:line10$", flags=TestGrep._reflags)
1377
self.assertEqual(len(out.splitlines()), 4)
1379
out, err = self.run_bzr(['grep', '-r', 'last:1..', '--levels=0', 'line1'])
1380
self.assertContainsRe(out, "^file0.txt~2:line1$", flags=TestGrep._reflags)
1381
self.assertContainsRe(out, "^file1.txt~2:line1$", flags=TestGrep._reflags)
1382
self.assertContainsRe(out, "^file0.txt~1.1.1:line1$", flags=TestGrep._reflags)
1383
self.assertContainsRe(out, "^file1.txt~1.1.1:line1$", flags=TestGrep._reflags)
1384
self.assertContainsRe(out, "^file0.txt~2:line10$", flags=TestGrep._reflags)
1385
self.assertContainsRe(out, "^file1.txt~2:line10$", flags=TestGrep._reflags)
1386
self.assertContainsRe(out, "^file0.txt~1.1.1:line10$", flags=TestGrep._reflags)
1387
self.assertContainsRe(out, "^file1.txt~1.1.1:line10$", flags=TestGrep._reflags)
1388
self.assertEqual(len(out.splitlines()), 8)
1390
out, err = self.run_bzr(['grep', '-r', '-1..', '-n', '--levels=0', 'line1'])
1391
self.assertContainsRe(out, "^file0.txt~2:1:line1$", flags=TestGrep._reflags)
1392
self.assertContainsRe(out, "^file1.txt~2:1:line1$", flags=TestGrep._reflags)
1393
self.assertContainsRe(out, "^file0.txt~1.1.1:1:line1$", flags=TestGrep._reflags)
1394
self.assertContainsRe(out, "^file1.txt~1.1.1:1:line1$", flags=TestGrep._reflags)
1395
self.assertContainsRe(out, "^file0.txt~2:10:line10$", flags=TestGrep._reflags)
1396
self.assertContainsRe(out, "^file1.txt~2:10:line10$", flags=TestGrep._reflags)
1397
self.assertContainsRe(out, "^file0.txt~1.1.1:10:line10$", flags=TestGrep._reflags)
1398
self.assertContainsRe(out, "^file1.txt~1.1.1:10:line10$", flags=TestGrep._reflags)
1399
self.assertEqual(len(out.splitlines()), 8)
1401
# levels should be ignored by wtree grep
1402
out, err = self.run_bzr(['grep', '--levels=0', 'l.ne1'])
1403
self.assertContainsRe(out, "^file0.txt:line1$", flags=TestGrep._reflags)
1404
self.assertContainsRe(out, "^file1.txt:line1$", flags=TestGrep._reflags)
1405
self.assertContainsRe(out, "^file0.txt:line10$", flags=TestGrep._reflags)
1406
self.assertContainsRe(out, "^file1.txt:line10$", flags=TestGrep._reflags)
1407
self.assertEqual(len(out.splitlines()), 4)
1409
out, err = self.run_bzr(['grep', '-r', 'last:1..', '--levels=0', 'lin.1'])
1410
self.assertContainsRe(out, "^file0.txt~2:line1$", flags=TestGrep._reflags)
1411
self.assertContainsRe(out, "^file1.txt~2:line1$", flags=TestGrep._reflags)
1412
self.assertContainsRe(out, "^file0.txt~1.1.1:line1$", flags=TestGrep._reflags)
1413
self.assertContainsRe(out, "^file1.txt~1.1.1:line1$", flags=TestGrep._reflags)
1414
self.assertContainsRe(out, "^file0.txt~2:line10$", flags=TestGrep._reflags)
1415
self.assertContainsRe(out, "^file1.txt~2:line10$", flags=TestGrep._reflags)
1416
self.assertContainsRe(out, "^file0.txt~1.1.1:line10$", flags=TestGrep._reflags)
1417
self.assertContainsRe(out, "^file1.txt~1.1.1:line10$", flags=TestGrep._reflags)
1418
self.assertEqual(len(out.splitlines()), 8)
1420
out, err = self.run_bzr(['grep', '-r', '-1..', '-n', '--levels=0', '.ine1'])
1421
self.assertContainsRe(out, "file0.txt~2:1:line1", flags=TestGrep._reflags)
1422
self.assertContainsRe(out, "file1.txt~2:1:line1", flags=TestGrep._reflags)
1423
self.assertContainsRe(out, "file0.txt~1.1.1:1:line1", flags=TestGrep._reflags)
1424
self.assertContainsRe(out, "file1.txt~1.1.1:1:line1", flags=TestGrep._reflags)
1426
def test_dotted_rev_grep(self):
1427
"""Grep in dotted revs
1432
self.make_branch_and_tree(wd0)
1434
self._mk_versioned_file('file0.txt')
1437
out, err = self.run_bzr(['branch', wd0, wd1])
1439
self._mk_versioned_file('file1.txt') # revno 1.1.1
1440
self._update_file('file1.txt', "text 0\n") # revno 1.1.2
1441
self._update_file('file1.txt', "text 1\n") # revno 1.1.3
1442
self._update_file('file1.txt', "text 2\n") # revno 1.1.4
1443
os.chdir(osutils.pathjoin('..', wd0))
1445
out, err = self.run_bzr(['merge', osutils.pathjoin('..', wd1)])
1446
out, err = self.run_bzr(['ci', '-m', 'merged'])
1448
out, err = self.run_bzr(['grep', '-r', '1.1.1..1.1.4', 'text'])
1449
self.assertContainsRe(out, "file1.txt~1.1.2:text 0", flags=TestGrep._reflags)
1450
self.assertContainsRe(out, "file1.txt~1.1.3:text 1", flags=TestGrep._reflags)
1451
self.assertContainsRe(out, "file1.txt~1.1.3:text 1", flags=TestGrep._reflags)
1452
self.assertContainsRe(out, "file1.txt~1.1.4:text 0", flags=TestGrep._reflags)
1453
self.assertContainsRe(out, "file1.txt~1.1.4:text 1", flags=TestGrep._reflags)
1454
self.assertContainsRe(out, "file1.txt~1.1.4:text 2", flags=TestGrep._reflags)
1455
self.assertEqual(len(out.splitlines()), 6)
1457
def test_versioned_binary_file_grep(self):
1458
"""(versioned) Grep for pattern in binary file.
1461
self.make_branch_and_tree(wd)
1463
self._mk_versioned_file('file.txt')
1464
self._mk_versioned_file('file0.bin')
1465
self._update_file('file0.bin', "\x00lineNN\x00\n")
1467
# note: set --verbose/-v flag to get the skip message.
1468
out, err = self.run_bzr(['grep', '-v', '-r', 'last:1',
1469
'lineNN', 'file0.bin'])
1470
self.assertNotContainsRe(out, "file0.bin", flags=TestGrep._reflags)
1471
self.assertContainsRe(err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
1472
self.assertEqual(len(out.splitlines()), 0)
1473
self.assertEqual(len(err.splitlines()), 1)
1475
out, err = self.run_bzr(['grep', '-v', '-r', 'last:1',
1476
'line.N', 'file0.bin'])
1477
self.assertNotContainsRe(out, "file0.bin", flags=TestGrep._reflags)
1478
self.assertContainsRe(err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
1479
self.assertEqual(len(out.splitlines()), 0)
1480
self.assertEqual(len(err.splitlines()), 1)
1482
def test_wtree_binary_file_grep(self):
1483
"""(wtree) Grep for pattern in binary file.
1486
self.make_branch_and_tree(wd)
1488
self._mk_versioned_file('file0.bin')
1489
self._update_file('file0.bin', "\x00lineNN\x00\n")
1491
# note: set --verbose/-v flag to get the skip message.
1492
out, err = self.run_bzr(['grep', '-v', 'lineNN', 'file0.bin'])
1493
self.assertNotContainsRe(out, "file0.bin:line1", flags=TestGrep._reflags)
1494
self.assertContainsRe(err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
1496
# binary warning should not be shown without --verbose
1497
out, err = self.run_bzr(['grep', 'lineNN', 'file0.bin'])
1498
self.assertNotContainsRe(out, "file0.bin:line1", flags=TestGrep._reflags)
1499
self.assertNotContainsRe(err, "Binary file", flags=TestGrep._reflags)
1501
def test_revspec(self):
1502
"""Ensure various revspecs work
1505
self.make_branch_and_tree(wd)
1507
self._mk_versioned_dir('dir0') # rev1
1508
self._mk_versioned_file('dir0/file0.txt') # rev2
1509
self._update_file('dir0/file0.txt', "v3 text\n") # rev3
1510
self._update_file('dir0/file0.txt', "v4 text\n") # rev4
1511
self._update_file('dir0/file0.txt', "v5 text\n") # rev5
1513
out, err = self.run_bzr(['grep', '-r', 'revno:1..2', 'v3'])
1514
self.assertNotContainsRe(out, "file0", flags=TestGrep._reflags)
1515
self.assertEqual(len(out.splitlines()), 0)
1517
out, err = self.run_bzr(['grep', '-r', 'revno:4..', 'v4'])
1518
self.assertContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
1519
self.assertEqual(len(out.splitlines()), 2) # find v4 in rev4 and rev5
1521
out, err = self.run_bzr(['grep', '-r', '..revno:3', 'v4'])
1522
self.assertNotContainsRe(out, "file0", flags=TestGrep._reflags)
1523
self.assertEqual(len(out.splitlines()), 0)
1525
out, err = self.run_bzr(['grep', '-r', '..revno:3', 'v3'])
1526
self.assertContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
1527
self.assertEqual(len(out.splitlines()), 1)
1529
def test_wtree_files_with_matches(self):
1530
"""(wtree) Ensure --files-with-matches, -l works
1533
self.make_branch_and_tree(wd)
1536
self._mk_versioned_file('file0.txt', total_lines=2)
1537
self._mk_versioned_file('file1.txt', total_lines=2)
1538
self._mk_versioned_dir('dir0')
1539
self._mk_versioned_file('dir0/file00.txt', total_lines=2)
1540
self._mk_versioned_file('dir0/file01.txt', total_lines=2)
1542
self._update_file('file0.txt', 'HELLO\n', checkin=False)
1543
self._update_file('dir0/file00.txt', 'HELLO\n', checkin=False)
1546
out, err = self.run_bzr(['grep', '--files-with-matches', 'HELLO'])
1548
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1549
self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
1550
self.assertEqual(len(out.splitlines()), 2)
1553
out, err = self.run_bzr(['grep', '--files-with-matches', 'HE.LO'])
1555
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1556
self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
1557
self.assertEqual(len(out.splitlines()), 2)
1560
out, err = self.run_bzr(['grep', '-l', 'HELLO'])
1562
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1563
self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
1564
self.assertEqual(len(out.splitlines()), 2)
1567
out, err = self.run_bzr(['grep', '-l', 'HE.LO'])
1569
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1570
self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
1571
self.assertEqual(len(out.splitlines()), 2)
1574
out, err = self.run_bzr(['grep', '-l', 'HELLO', 'dir0', 'file1.txt'])
1576
self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
1577
self.assertEqual(len(out.splitlines()), 1)
1580
out, err = self.run_bzr(['grep', '-l', '.ELLO', 'dir0', 'file1.txt'])
1582
self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
1583
self.assertEqual(len(out.splitlines()), 1)
1586
out, err = self.run_bzr(['grep', '-l', 'HELLO', 'file0.txt'])
1588
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1589
self.assertEqual(len(out.splitlines()), 1)
1592
out, err = self.run_bzr(['grep', '-l', '.ELLO', 'file0.txt'])
1594
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1595
self.assertEqual(len(out.splitlines()), 1)
1598
out, err = self.run_bzr(['grep', '--no-recursive', '-l', 'HELLO'])
1600
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1601
self.assertEqual(len(out.splitlines()), 1)
1604
out, err = self.run_bzr(['grep', '--no-recursive', '-l', '.ELLO'])
1606
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1607
self.assertEqual(len(out.splitlines()), 1)
1609
def test_ver_files_with_matches(self):
1610
"""(ver) Ensure --files-with-matches, -l works
1613
self.make_branch_and_tree(wd)
1616
self._mk_versioned_file('file0.txt', total_lines=2) # rev 1
1617
self._mk_versioned_file('file1.txt', total_lines=2) # rev 2
1618
self._mk_versioned_dir('dir0') # rev 3
1619
self._mk_versioned_file('dir0/file00.txt', total_lines=2) # rev 4
1620
self._mk_versioned_file('dir0/file01.txt', total_lines=2) # rev 5
1622
self._update_file('file0.txt', 'HELLO\n') # rev 6
1623
self._update_file('dir0/file00.txt', 'HELLO\n') # rev 7
1626
out, err = self.run_bzr(['grep', '-r', '-1', '--files-with-matches',
1629
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1630
self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1631
self.assertEqual(len(out.splitlines()), 2)
1634
out, err = self.run_bzr(['grep', '-r', '-1', '--files-with-matches',
1637
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1638
self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1639
self.assertEqual(len(out.splitlines()), 2)
1642
out, err = self.run_bzr(['grep', '-r', '6..7', '--files-with-matches',
1645
self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1646
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1647
self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1648
self.assertEqual(len(out.splitlines()), 3)
1651
out, err = self.run_bzr(['grep', '-r', '6..7', '--files-with-matches',
1654
self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1655
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1656
self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1657
self.assertEqual(len(out.splitlines()), 3)
1660
out, err = self.run_bzr(['grep', '-r', '-1', '-l', 'HELLO'])
1662
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1663
self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1664
self.assertEqual(len(out.splitlines()), 2)
1667
out, err = self.run_bzr(['grep', '-r', '-1', '-l', 'H.LLO'])
1669
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1670
self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1671
self.assertEqual(len(out.splitlines()), 2)
1674
out, err = self.run_bzr(['grep', '-l', 'HELLO', '-r', '-1',
1675
'dir0', 'file1.txt'])
1677
self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1678
self.assertEqual(len(out.splitlines()), 1)
1681
out, err = self.run_bzr(['grep', '-l', 'H.LLO', '-r', '-1',
1682
'dir0', 'file1.txt'])
1684
self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1685
self.assertEqual(len(out.splitlines()), 1)
1688
out, err = self.run_bzr(['grep', '-l', 'HELLO',
1689
'-r', '-2', 'file0.txt'])
1691
self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1692
self.assertEqual(len(out.splitlines()), 1)
1695
out, err = self.run_bzr(['grep', '-l', 'HE.LO',
1696
'-r', '-2', 'file0.txt'])
1698
self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1699
self.assertEqual(len(out.splitlines()), 1)
1702
out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
1705
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1706
self.assertEqual(len(out.splitlines()), 1)
1709
out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
1712
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1713
self.assertEqual(len(out.splitlines()), 1)
1715
def test_wtree_files_without_matches(self):
1716
"""(wtree) Ensure --files-without-match, -L works
1719
self.make_branch_and_tree(wd)
1722
self._mk_versioned_file('file0.txt', total_lines=2)
1723
self._mk_versioned_file('file1.txt', total_lines=2)
1724
self._mk_versioned_dir('dir0')
1725
self._mk_versioned_file('dir0/file00.txt', total_lines=2)
1726
self._mk_versioned_file('dir0/file01.txt', total_lines=2)
1728
self._update_file('file0.txt', 'HELLO\n', checkin=False)
1729
self._update_file('dir0/file00.txt', 'HELLO\n', checkin=False)
1732
out, err = self.run_bzr(['grep', '--files-without-match', 'HELLO'])
1734
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1735
self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
1736
self.assertEqual(len(out.splitlines()), 2)
1739
out, err = self.run_bzr(['grep', '--files-without-match', 'HE.LO'])
1741
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1742
self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
1743
self.assertEqual(len(out.splitlines()), 2)
1746
out, err = self.run_bzr(['grep', '-L', 'HELLO'])
1748
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1749
self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
1750
self.assertEqual(len(out.splitlines()), 2)
1753
out, err = self.run_bzr(['grep', '-L', 'HE.LO'])
1755
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1756
self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
1757
self.assertEqual(len(out.splitlines()), 2)
1760
out, err = self.run_bzr(['grep', '-L', 'HELLO', 'dir0', 'file1.txt'])
1762
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1763
self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
1764
self.assertEqual(len(out.splitlines()), 2)
1767
out, err = self.run_bzr(['grep', '-L', '.ELLO', 'dir0', 'file1.txt'])
1769
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1770
self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
1771
self.assertEqual(len(out.splitlines()), 2)
1774
out, err = self.run_bzr(['grep', '-L', 'HELLO', 'file1.txt'])
1776
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1777
self.assertEqual(len(out.splitlines()), 1)
1780
out, err = self.run_bzr(['grep', '-L', '.ELLO', 'file1.txt'])
1782
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1783
self.assertEqual(len(out.splitlines()), 1)
1786
out, err = self.run_bzr(['grep', '--no-recursive', '-L', 'HELLO'])
1788
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1789
self.assertEqual(len(out.splitlines()), 1)
1792
out, err = self.run_bzr(['grep', '--no-recursive', '-L', '.ELLO'])
1794
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1795
self.assertEqual(len(out.splitlines()), 1)
1797
def test_ver_files_without_matches(self):
1798
"""(ver) Ensure --files-without-match, -L works
1801
self.make_branch_and_tree(wd)
1804
self._mk_versioned_file('file0.txt', total_lines=2) # rev 1
1805
self._mk_versioned_file('file1.txt', total_lines=2) # rev 2
1806
self._mk_versioned_dir('dir0') # rev 3
1807
self._mk_versioned_file('dir0/file00.txt', total_lines=2) # rev 4
1808
self._mk_versioned_file('dir0/file01.txt', total_lines=2) # rev 5
1810
self._update_file('file0.txt', 'HELLO\n') # rev 6
1811
self._update_file('dir0/file00.txt', 'HELLO\n') # rev 7
1814
out, err = self.run_bzr(['grep', '-r', '-1', '--files-without-match',
1817
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1818
self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
1819
self.assertEqual(len(out.splitlines()), 2)
1822
out, err = self.run_bzr(['grep', '-r', '-1', '--files-without-match',
1825
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1826
self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
1827
self.assertEqual(len(out.splitlines()), 2)
1830
out, err = self.run_bzr(['grep', '-r', '6..7', '--files-without-match',
1833
self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
1834
self.assertContainsRe(out, "^dir0/file00.txt~6$", flags=TestGrep._reflags)
1835
self.assertContainsRe(out, "^dir0/file01.txt~6$", flags=TestGrep._reflags)
1836
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1837
self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
1838
self.assertEqual(len(out.splitlines()), 5)
1841
out, err = self.run_bzr(['grep', '-r', '6..7', '--files-without-match',
1844
self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
1845
self.assertContainsRe(out, "^dir0/file00.txt~6$", flags=TestGrep._reflags)
1846
self.assertContainsRe(out, "^dir0/file01.txt~6$", flags=TestGrep._reflags)
1847
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1848
self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
1849
self.assertEqual(len(out.splitlines()), 5)
1852
out, err = self.run_bzr(['grep', '-r', '-1', '-L', 'HELLO'])
1854
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1855
self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
1856
self.assertEqual(len(out.splitlines()), 2)
1859
out, err = self.run_bzr(['grep', '-r', '-1', '-L', 'H.LLO'])
1861
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1862
self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
1863
self.assertEqual(len(out.splitlines()), 2)
1866
out, err = self.run_bzr(['grep', '-L', 'HELLO', '-r', '-1',
1867
'dir0', 'file1.txt'])
1869
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1870
self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
1871
self.assertEqual(len(out.splitlines()), 2)
1874
out, err = self.run_bzr(['grep', '-L', 'H.LLO', '-r', '-1',
1875
'dir0', 'file1.txt'])
1877
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1878
self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
1879
self.assertEqual(len(out.splitlines()), 2)
1882
out, err = self.run_bzr(['grep', '-L', 'HELLO',
1883
'-r', '-2', 'file1.txt'])
1885
self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
1886
self.assertEqual(len(out.splitlines()), 1)
1889
out, err = self.run_bzr(['grep', '-L', 'HE.LO',
1890
'-r', '-2', 'file1.txt'])
1892
self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
1893
self.assertEqual(len(out.splitlines()), 1)
1896
out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
1899
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1900
self.assertEqual(len(out.splitlines()), 1)
1903
out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
1906
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1907
self.assertEqual(len(out.splitlines()), 1)
1909
def test_no_tree(self):
1910
"""Ensure grep works without working tree.
1914
self.make_branch_and_tree(wd0)
1916
self._mk_versioned_file('file0.txt')
1918
out, err = self.run_bzr(['branch', '--no-tree', wd0, wd1])
1921
out, err = self.run_bzr(['grep', 'line1'], 3)
1922
self.assertContainsRe(err, "Cannot search working tree", flags=TestGrep._reflags)
1923
self.assertEqual(out, '')
1925
out, err = self.run_bzr(['grep', '-r', '1', 'line1'])
1926
self.assertContainsRe(out, "file0.txt~1:line1", flags=TestGrep._reflags)
1927
self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
1930
class TestNonAscii(GrepTestBase):
1931
"""Tests for non-ascii filenames and file contents"""
1933
_test_needs_features = [UnicodeFilenameFeature]
1935
def test_unicode_only_file(self):
1936
"""Test filename and contents that requires a unicode encoding"""
1937
tree = self.make_branch_and_tree(".")
1938
contents = [u"\u1234"]
1939
self.build_tree(contents)
1941
tree.commit("Initial commit")
1944
# GZ 2010-06-07: Note we can't actually grep for \u1234 as the pattern
1945
# is mangled according to the user encoding.
1946
streams = self.run_bzr_raw(["grep", "--files-with-matches",
1947
u"contents"], encoding="UTF-8")
1948
as_utf8 = as_utf8.encode("UTF-8")
1949
self.assertEqual(streams, (as_utf8 + b"\n", b""))
1951
streams = self.run_bzr_raw(["grep", "-r", "1", "--files-with-matches",
1952
u"contents"], encoding="UTF-8")
1953
self.assertEqual(streams, (as_utf8 + b"~1\n", b""))
1955
fileencoding = osutils.get_user_encoding()
1956
as_mangled = as_utf8.decode(fileencoding, "replace").encode("UTF-8")
1958
streams = self.run_bzr_raw(["grep", "-n",
1959
u"contents"], encoding="UTF-8")
1960
self.assertEqual(streams, (b"%s:1:contents of %s\n" %
1961
(as_utf8, as_mangled), b""))
1963
streams = self.run_bzr_raw(["grep", "-n", "-r", "1",
1964
u"contents"], encoding="UTF-8")
1965
self.assertEqual(streams, (b"%s~1:1:contents of %s\n" %
1966
(as_utf8, as_mangled), b""))
1969
class TestColorGrep(GrepTestBase):
1970
"""Tests for the --color option."""
1972
_rev_sep = color_string('~', fg=FG.BOLD_YELLOW)
1973
_sep = color_string(':', fg=FG.BOLD_CYAN)
1975
def test_color_option(self):
1976
"""Ensure options for color are valid.
1978
out, err = self.run_bzr(['grep', '--color', 'foo', 'bar'], 3)
1979
self.assertEqual(out, '')
1980
self.assertContainsRe(err, 'Valid values for --color are', flags=TestGrep._reflags)
1982
def test_ver_matching_files(self):
1983
"""(versioned) Search for matches or no matches only"""
1984
tree = self.make_branch_and_tree(".")
1985
contents = ["d/", "d/aaa", "bbb"]
1986
self.build_tree(contents)
1988
tree.commit("Initial commit")
1990
# GZ 2010-06-05: Maybe modify the working tree here
1992
streams = self.run_bzr(["grep", "--color", "always", "-r", "1",
1993
"--files-with-matches", "aaa"])
1994
self.assertEqual(streams, ("".join([
1995
FG.MAGENTA, "d/aaa", self._rev_sep, "1", "\n"
1998
streams = self.run_bzr(["grep", "--color", "always", "-r", "1",
1999
"--files-without-match", "aaa"])
2000
self.assertEqual(streams, ("".join([
2001
FG.MAGENTA, "bbb", self._rev_sep, "1", "\n"
2004
def test_wtree_matching_files(self):
2005
"""(wtree) Search for matches or no matches only"""
2006
tree = self.make_branch_and_tree(".")
2007
contents = ["d/", "d/aaa", "bbb"]
2008
self.build_tree(contents)
2010
tree.commit("Initial commit")
2012
# GZ 2010-06-05: Maybe modify the working tree here
2014
streams = self.run_bzr(["grep", "--color", "always",
2015
"--files-with-matches", "aaa"])
2016
self.assertEqual(streams, ("".join([
2017
FG.MAGENTA, "d/aaa", FG.NONE, "\n"
2020
streams = self.run_bzr(["grep", "--color", "always",
2021
"--files-without-match", "aaa"])
2022
self.assertEqual(streams, ("".join([
2023
FG.MAGENTA, "bbb", FG.NONE, "\n"
2026
def test_ver_basic_file(self):
2027
"""(versioned) Search for pattern in specfic file.
2030
self.make_branch_and_tree(wd)
2032
lp = 'foo is foobar'
2033
self._mk_versioned_file('file0.txt', line_prefix=lp, total_lines=1)
2035
# prepare colored result
2036
foo = color_string('foo', fg=FG.BOLD_RED)
2037
res = (FG.MAGENTA + 'file0.txt'
2038
+ self._rev_sep + '1' + self._sep
2039
+ foo + ' is ' + foo + 'bar1' + '\n')
2040
txt_res = 'file0.txt~1:foo is foobar1\n'
2042
nres = (FG.MAGENTA + 'file0.txt'
2043
+ self._rev_sep + '1' + self._sep + '1' + self._sep
2044
+ foo + ' is ' + foo + 'bar1' + '\n')
2046
out, err = self.run_bzr(['grep', '--color',
2047
'always', '-r', '1', 'foo'])
2048
self.assertEqual(out, res)
2049
self.assertEqual(len(out.splitlines()), 1)
2051
# auto should produce plain text result
2052
# as stdout is redireched here.
2053
out, err = self.run_bzr(['grep', '--color',
2054
'auto', '-r', '1', 'foo'])
2055
self.assertEqual(out, txt_res)
2056
self.assertEqual(len(out.splitlines()), 1)
2058
out, err = self.run_bzr(['grep', '-i', '--color',
2059
'always', '-r', '1', 'FOO'])
2060
self.assertEqual(out, res)
2061
self.assertEqual(len(out.splitlines()), 1)
2063
out, err = self.run_bzr(['grep', '--color',
2064
'always', '-r', '1', 'f.o'])
2065
self.assertEqual(out, res)
2066
self.assertEqual(len(out.splitlines()), 1)
2068
out, err = self.run_bzr(['grep', '-i', '--color',
2069
'always', '-r', '1', 'F.O'])
2070
self.assertEqual(out, res)
2071
self.assertEqual(len(out.splitlines()), 1)
2073
out, err = self.run_bzr(['grep', '-n', '--color',
2074
'always', '-r', '1', 'foo'])
2075
self.assertEqual(out, nres)
2076
self.assertEqual(len(out.splitlines()), 1)
2078
out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2079
'always', '-r', '1', 'FOO'])
2080
self.assertEqual(out, nres)
2081
self.assertEqual(len(out.splitlines()), 1)
2083
out, err = self.run_bzr(['grep', '-n', '--color',
2084
'always', '-r', '1', 'f.o'])
2085
self.assertEqual(out, nres)
2086
self.assertEqual(len(out.splitlines()), 1)
2088
out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2089
'always', '-r', '1', 'F.O'])
2090
self.assertEqual(out, nres)
2091
self.assertEqual(len(out.splitlines()), 1)
2093
def test_wtree_basic_file(self):
2094
"""(wtree) Search for pattern in specfic file.
2097
self.make_branch_and_tree(wd)
2099
lp = 'foo is foobar'
2100
self._mk_versioned_file('file0.txt', line_prefix=lp, total_lines=1)
2102
# prepare colored result
2103
foo = color_string('foo', fg=FG.BOLD_RED)
2104
res = (FG.MAGENTA + 'file0.txt'
2105
+ self._sep + foo + ' is ' + foo + 'bar1' + '\n')
2107
nres = (FG.MAGENTA + 'file0.txt'
2108
+ self._sep + '1' + self._sep
2109
+ foo + ' is ' + foo + 'bar1' + '\n')
2111
out, err = self.run_bzr(['grep', '--color',
2113
self.assertEqual(out, res)
2114
self.assertEqual(len(out.splitlines()), 1)
2116
out, err = self.run_bzr(['grep', '-i', '--color',
2118
self.assertEqual(out, res)
2119
self.assertEqual(len(out.splitlines()), 1)
2121
out, err = self.run_bzr(['grep', '--color',
2123
self.assertEqual(out, res)
2124
self.assertEqual(len(out.splitlines()), 1)
2126
out, err = self.run_bzr(['grep', '-i', '--color',
2128
self.assertEqual(out, res)
2129
self.assertEqual(len(out.splitlines()), 1)
2131
out, err = self.run_bzr(['grep', '-n', '--color',
2133
self.assertEqual(out, nres)
2134
self.assertEqual(len(out.splitlines()), 1)
2136
out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2138
self.assertEqual(out, nres)
2139
self.assertEqual(len(out.splitlines()), 1)
2141
out, err = self.run_bzr(['grep', '-n', '--color',
2143
self.assertEqual(out, nres)
2144
self.assertEqual(len(out.splitlines()), 1)
2146
out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2148
self.assertEqual(out, nres)
2149
self.assertEqual(len(out.splitlines()), 1)
2152
# copied from breezy.tests.blackbox.test_diff
2153
def subst_dates(string):
2154
"""Replace date strings with constant values."""
2155
return re.sub(r'\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} [-\+]\d{4}',
2156
'YYYY-MM-DD HH:MM:SS +ZZZZ', string)
2159
class TestGrepDiff(tests.TestCaseWithTransport):
2161
def make_example_branch(self):
2162
tree = self.make_branch_and_tree('.')
2163
self.build_tree_contents([
2164
('hello', b'foo\n'),
2165
('goodbye', b'baz\n')])
2167
tree.commit('setup')
2168
tree.add(['goodbye'])
2169
tree.commit('setup')
2172
def test_grep_diff_basic(self):
2173
"""grep -p basic test."""
2174
tree = self.make_example_branch()
2175
self.build_tree_contents([('hello', b'hello world!\n')])
2176
tree.commit('updated hello')
2177
out, err = self.run_bzr(['grep', '-p', 'hello'])
2178
self.assertEqual(err, '')
2179
self.assertEqualDiff(subst_dates(out), '''\
2181
=== modified file 'hello'
2182
--- hello YYYY-MM-DD HH:MM:SS +ZZZZ
2183
+++ hello YYYY-MM-DD HH:MM:SS +ZZZZ
2186
=== added file 'hello'
2187
--- hello YYYY-MM-DD HH:MM:SS +ZZZZ
2188
+++ hello YYYY-MM-DD HH:MM:SS +ZZZZ
2191
def test_grep_diff_revision(self):
2192
"""grep -p specific revision."""
2193
tree = self.make_example_branch()
2194
self.build_tree_contents([('hello', b'hello world!\n')])
2195
tree.commit('updated hello')
2196
out, err = self.run_bzr(['grep', '-p', '-r', '3', 'hello'])
2197
self.assertEqual(err, '')
2198
self.assertEqualDiff(subst_dates(out), '''\
2200
=== modified file 'hello'
2201
--- hello YYYY-MM-DD HH:MM:SS +ZZZZ
2202
+++ hello YYYY-MM-DD HH:MM:SS +ZZZZ
2206
def test_grep_diff_revision_range(self):
2207
"""grep -p revision range."""
2208
tree = self.make_example_branch()
2209
self.build_tree_contents([('hello', b'hello world!1\n')]) # rev 3
2211
self.build_tree_contents([('blah', b'hello world!2\n')]) # rev 4
2214
with open('hello', 'a') as f:
2215
f.write('hello world!3\n')
2216
#self.build_tree_contents([('hello', 'hello world!3\n')]) # rev 5
2218
out, err = self.run_bzr(['grep', '-p', '-r', '2..5', 'hello'])
2219
self.assertEqual(err, '')
2220
self.assertEqualDiff(subst_dates(out), '''\
2222
=== modified file 'hello'
2223
--- hello YYYY-MM-DD HH:MM:SS +ZZZZ
2224
+++ hello YYYY-MM-DD HH:MM:SS +ZZZZ
2227
=== added file 'blah'
2230
=== modified file 'hello'
2231
--- hello YYYY-MM-DD HH:MM:SS +ZZZZ
2232
+++ hello YYYY-MM-DD HH:MM:SS +ZZZZ
2236
def test_grep_diff_color(self):
2237
"""grep -p color test."""
2238
tree = self.make_example_branch()
2239
self.build_tree_contents([('hello', b'hello world!\n')])
2240
tree.commit('updated hello')
2241
out, err = self.run_bzr(['grep', '--diff', '-r', '3',
2242
'--color', 'always', 'hello'])
2243
self.assertEqual(err, '')
2244
revno = color_string('=== revno:3 ===', fg=FG.BOLD_BLUE) + '\n'
2245
filename = color_string(" === modified file 'hello'", fg=FG.BOLD_MAGENTA) + '\n'
2246
redhello = color_string('hello', fg=FG.BOLD_RED)
2248
--- hello YYYY-MM-DD HH:MM:SS +ZZZZ
2249
+++ hello YYYY-MM-DD HH:MM:SS +ZZZZ
2252
diffstr = diffstr.replace('hello', redhello)
2253
self.assertEqualDiff(subst_dates(out), revno + filename + diffstr)
2255
def test_grep_norevs(self):
2256
"""grep -p with zero revisions."""
2257
out, err = self.run_bzr(['init'])
2258
out, err = self.run_bzr(['grep', '--diff', 'foo'], 3)
2259
self.assertEqual(out, '')
2260
self.assertContainsRe(err, "ERROR:.*revision.* does not exist in branch")
added
removed
breezy/plugins/grep/test_grep.py
