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 ..._termcolor import color_string, FG
26
from ...tests.features import (
27
UnicodeFilenameFeature,
30
# NOTE: As bzr-grep optimizes PATTERN search to -F/--fixed-string
31
# for patterns that are not alphanumeric+whitespace, we test grep
32
# specfically with patterns that have special characters so that
33
# regex path is tested. alphanumeric patterns test the -F path.
35
class GrepTestBase(tests.TestCaseWithTransport):
36
"""Base class for testing grep.
38
Provides support methods for creating directory and file revisions.
40
_reflags = re.MULTILINE|re.DOTALL
42
def _mk_file(self, path, line_prefix, total_lines, versioned):
44
for i in range(total_lines):
45
text += line_prefix + str(i+1) + "\n"
47
with open(path, 'w') as f:
50
self.run_bzr(['add', path])
51
self.run_bzr(['ci', '-m', '"' + path + '"'])
53
def _update_file(self, path, text, checkin=True):
54
"""append text to file 'path' and check it in"""
55
with open(path, 'a') as f:
58
self.run_bzr(['ci', path, '-m', '"' + path + '"'])
60
def _mk_unknown_file(self, path, line_prefix='line', total_lines=10):
61
self._mk_file(path, line_prefix, total_lines, versioned=False)
63
def _mk_versioned_file(self, path, line_prefix='line', total_lines=10):
64
self._mk_file(path, line_prefix, total_lines, versioned=True)
66
def _mk_dir(self, path, versioned):
69
self.run_bzr(['add', path])
70
self.run_bzr(['ci', '-m', '"' + path + '"'])
72
def _mk_unknown_dir(self, path):
73
self._mk_dir(path, versioned=False)
75
def _mk_versioned_dir(self, path):
76
self._mk_dir(path, versioned=True)
79
class TestGrep(GrepTestBase):
80
"""Core functional tests for grep."""
82
def test_basic_unknown_file(self):
83
"""Search for pattern in specfic file.
85
If specified file is unknown, grep it anyway."""
87
self.make_branch_and_tree(wd)
89
self._mk_unknown_file('file0.txt')
91
out, err = self.run_bzr(['grep', 'line1', 'file0.txt'])
92
self.assertContainsRe(out, b"file0.txt:line1", flags=TestGrep._reflags)
93
self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
95
out, err = self.run_bzr(['grep', 'line\\d+', 'file0.txt'])
96
self.assertContainsRe(out, b"file0.txt:line1", flags=TestGrep._reflags)
97
self.assertEqual(len(out.splitlines()), 10)
99
# unknown file is not grepped unless explicitely specified
100
out, err = self.run_bzr(['grep', 'line1'])
101
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
102
self.assertEqual(len(out.splitlines()), 0)
104
# unknown file is not grepped unless explicitely specified
105
out, err = self.run_bzr(['grep', 'line1$'])
106
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
107
self.assertEqual(len(out.splitlines()), 0)
109
def test_ver_basic_file(self):
110
"""(versioned) Search for pattern in specfic file.
113
self.make_branch_and_tree(wd)
115
self._mk_versioned_file('file0.txt')
117
out, err = self.run_bzr(['grep', '-r', '1', 'line1', 'file0.txt'])
118
self.assertContainsRe(out, b"file0.txt~1:line1", flags=TestGrep._reflags)
119
self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
121
out, err = self.run_bzr(['grep', '-r', '1', 'line[0-9]$', 'file0.txt'])
122
self.assertContainsRe(out, b"file0.txt~1:line1", flags=TestGrep._reflags)
123
self.assertEqual(len(out.splitlines()), 9)
125
# finds all the lines
126
out, err = self.run_bzr(['grep', '-r', '1', 'line[0-9]', 'file0.txt'])
127
self.assertContainsRe(out, b"file0.txt~1:line1", flags=TestGrep._reflags)
128
self.assertEqual(len(out.splitlines()), 10)
130
def test_wtree_basic_file(self):
131
"""(wtree) Search for pattern in specfic file.
134
self.make_branch_and_tree(wd)
136
self._mk_versioned_file('file0.txt')
137
self._update_file('file0.txt', 'ABC\n', checkin=False)
139
out, err = self.run_bzr(['grep', 'ABC', 'file0.txt'])
140
self.assertContainsRe(out, b"file0.txt:ABC", flags=TestGrep._reflags)
141
self.assertEqual(len(out.splitlines()), 1)
143
out, err = self.run_bzr(['grep', '[A-Z]{3}', 'file0.txt'])
144
self.assertContainsRe(out, b"file0.txt:ABC", flags=TestGrep._reflags)
145
self.assertEqual(len(out.splitlines()), 1)
147
out, err = self.run_bzr(['grep', '-r', 'last:1', 'ABC', 'file0.txt'])
148
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
149
self.assertEqual(len(out.splitlines()), 0)
151
out, err = self.run_bzr(['grep', '-r', 'last:1', '[A-Z]{3}', 'file0.txt'])
152
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
153
self.assertEqual(len(out.splitlines()), 0)
155
def test_ver_basic_include(self):
156
"""(versioned) Ensure that -I flag is respected.
159
self.make_branch_and_tree(wd)
161
self._mk_versioned_file('file0.aa')
162
self._mk_versioned_file('file0.bb')
163
self._mk_versioned_file('file0.cc')
165
out, err = self.run_bzr(['grep', '-r', 'last:1',
166
'--include', '*.aa', '--include', '*.bb', 'line1'])
167
self.assertContainsRe(out, b"file0.aa~.:line1", flags=TestGrep._reflags)
168
self.assertContainsRe(out, b"file0.bb~.:line1", flags=TestGrep._reflags)
169
self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
170
# two lines each (line1, line10) from file0.aa and file0.bb
171
self.assertEqual(len(out.splitlines()), 4)
173
out, err = self.run_bzr(['grep', '-r', 'last:1',
174
'--include', '*.aa', '--include', '*.bb', 'line1$'])
175
self.assertContainsRe(out, b"file0.aa~.:line1", flags=TestGrep._reflags)
176
self.assertContainsRe(out, b"file0.bb~.:line1", flags=TestGrep._reflags)
177
self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
178
# one lines each (line1) from file0.aa and file0.bb
179
self.assertEqual(len(out.splitlines()), 2)
181
out, err = self.run_bzr(['grep', '-r', 'last:1',
182
'-I', '*.aa', '-I', '*.bb', 'line1'])
183
self.assertContainsRe(out, b"file0.aa~.:line1", flags=TestGrep._reflags)
184
self.assertContainsRe(out, b"file0.bb~.:line1", flags=TestGrep._reflags)
185
self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
186
# two lines each (line1, line10) from file0.aa and file0.bb
187
self.assertEqual(len(out.splitlines()), 4)
189
out, err = self.run_bzr(['grep', '-r', 'last:1',
190
'-I', '*.aa', '-I', '*.bb', 'line1$'])
191
self.assertContainsRe(out, b"file0.aa~.:line1", flags=TestGrep._reflags)
192
self.assertContainsRe(out, b"file0.bb~.:line1", flags=TestGrep._reflags)
193
self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
194
# one lines each (line1) from file0.aa and file0.bb
195
self.assertEqual(len(out.splitlines()), 2)
197
def test_wtree_basic_include(self):
198
"""(wtree) Ensure that --include flag is respected.
201
self.make_branch_and_tree(wd)
203
self._mk_versioned_file('file0.aa')
204
self._mk_versioned_file('file0.bb')
205
self._mk_versioned_file('file0.cc')
207
out, err = self.run_bzr(['grep', '--include', '*.aa',
208
'--include', '*.bb', 'line1'])
209
self.assertContainsRe(out, b"file0.aa:line1", flags=TestGrep._reflags)
210
self.assertContainsRe(out, b"file0.bb:line1", flags=TestGrep._reflags)
211
self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
212
# two lines each (line1, line10) from file0.aa and file0.bb
213
self.assertEqual(len(out.splitlines()), 4)
215
out, err = self.run_bzr(['grep', '--include', '*.aa',
216
'--include', '*.bb', 'line1$'])
217
self.assertContainsRe(out, b"file0.aa:line1", flags=TestGrep._reflags)
218
self.assertContainsRe(out, b"file0.bb:line1", flags=TestGrep._reflags)
219
self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
220
# one line each (line1) from file0.aa and file0.bb
221
self.assertEqual(len(out.splitlines()), 2)
223
def test_ver_basic_exclude(self):
224
"""(versioned) Ensure that --exclude flag is respected.
227
self.make_branch_and_tree(wd)
229
self._mk_versioned_file('file0.aa')
230
self._mk_versioned_file('file0.bb')
231
self._mk_versioned_file('file0.cc')
233
out, err = self.run_bzr(['grep', '-r', 'last:1',
234
'--exclude', '*.cc', 'line1'])
235
self.assertContainsRe(out, b"file0.aa~.:line1$", flags=TestGrep._reflags)
236
self.assertContainsRe(out, b"file0.bb~.:line1$", flags=TestGrep._reflags)
237
self.assertContainsRe(out, b"file0.aa~.:line10", flags=TestGrep._reflags)
238
self.assertContainsRe(out, b"file0.bb~.:line10", flags=TestGrep._reflags)
239
self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
240
# two lines each (line1, line10) from file0.aa and file0.bb
241
self.assertEqual(len(out.splitlines()), 4)
243
out, err = self.run_bzr(['grep', '-r', 'last:1',
244
'--exclude', '*.cc', 'line1$'])
245
self.assertContainsRe(out, b"file0.aa~.:line1", flags=TestGrep._reflags)
246
self.assertContainsRe(out, b"file0.bb~.:line1", flags=TestGrep._reflags)
247
self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
248
# one line each (line1) from file0.aa and file0.bb
249
self.assertEqual(len(out.splitlines()), 2)
251
out, err = self.run_bzr(['grep', '-r', 'last:1',
252
'-X', '*.cc', 'line1'])
253
self.assertContainsRe(out, b"file0.aa~.:line1", flags=TestGrep._reflags)
254
self.assertContainsRe(out, b"file0.bb~.:line1", flags=TestGrep._reflags)
255
self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
256
# two lines each (line1, line10) from file0.aa and file0.bb
257
self.assertEqual(len(out.splitlines()), 4)
259
def test_wtree_basic_exclude(self):
260
"""(wtree) Ensure that --exclude flag is respected.
263
self.make_branch_and_tree(wd)
265
self._mk_versioned_file('file0.aa')
266
self._mk_versioned_file('file0.bb')
267
self._mk_versioned_file('file0.cc')
269
out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'line1'])
270
self.assertContainsRe(out, b"file0.aa:line1", flags=TestGrep._reflags)
271
self.assertContainsRe(out, b"file0.bb:line1", flags=TestGrep._reflags)
272
self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
273
# two lines each (line1, line10) from file0.aa and file0.bb
274
self.assertEqual(len(out.splitlines()), 4)
276
out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'lin.1$'])
277
self.assertContainsRe(out, b"file0.aa:line1", flags=TestGrep._reflags)
278
self.assertContainsRe(out, b"file0.bb:line1", flags=TestGrep._reflags)
279
self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
280
# one line each (line1) from file0.aa and file0.bb
281
self.assertEqual(len(out.splitlines()), 2)
283
def test_ver_multiple_files(self):
284
"""(versioned) Search for pattern in multiple files.
287
self.make_branch_and_tree(wd)
289
self._mk_versioned_file('file0.txt', total_lines=2)
290
self._mk_versioned_file('file1.txt', total_lines=2)
291
self._mk_versioned_file('file2.txt', total_lines=2)
293
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line[1-2]$'])
294
self.assertContainsRe(out, b"file0.txt~.:line1", flags=TestGrep._reflags)
295
self.assertContainsRe(out, b"file0.txt~.:line2", flags=TestGrep._reflags)
296
self.assertContainsRe(out, b"file1.txt~.:line1", flags=TestGrep._reflags)
297
self.assertContainsRe(out, b"file1.txt~.:line2", flags=TestGrep._reflags)
298
self.assertContainsRe(out, b"file2.txt~.:line1", flags=TestGrep._reflags)
299
self.assertContainsRe(out, b"file2.txt~.:line2", flags=TestGrep._reflags)
300
self.assertEqual(len(out.splitlines()), 6)
302
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line'])
303
self.assertContainsRe(out, b"file0.txt~.:line1", flags=TestGrep._reflags)
304
self.assertContainsRe(out, b"file0.txt~.:line2", flags=TestGrep._reflags)
305
self.assertContainsRe(out, b"file1.txt~.:line1", flags=TestGrep._reflags)
306
self.assertContainsRe(out, b"file1.txt~.:line2", flags=TestGrep._reflags)
307
self.assertContainsRe(out, b"file2.txt~.:line1", flags=TestGrep._reflags)
308
self.assertContainsRe(out, b"file2.txt~.:line2", flags=TestGrep._reflags)
309
self.assertEqual(len(out.splitlines()), 6)
311
def test_multiple_wtree_files(self):
312
"""(wtree) Search for pattern in multiple files in working tree.
315
self.make_branch_and_tree(wd)
317
self._mk_versioned_file('file0.txt', total_lines=2)
318
self._mk_versioned_file('file1.txt', total_lines=2)
319
self._mk_versioned_file('file2.txt', total_lines=2)
320
self._update_file('file0.txt', 'HELLO\n', checkin=False)
321
self._update_file('file1.txt', 'HELLO\n', checkin=True)
322
self._update_file('file2.txt', 'HELLO\n', checkin=False)
324
out, err = self.run_bzr(['grep', 'HELLO',
325
'file0.txt', 'file1.txt', 'file2.txt'])
327
self.assertContainsRe(out, b"file0.txt:HELLO", flags=TestGrep._reflags)
328
self.assertContainsRe(out, b"file1.txt:HELLO", flags=TestGrep._reflags)
329
self.assertContainsRe(out, b"file2.txt:HELLO", flags=TestGrep._reflags)
330
self.assertEqual(len(out.splitlines()), 3)
332
out, err = self.run_bzr(['grep', 'HELLO', '-r', 'last:1',
333
'file0.txt', 'file1.txt', 'file2.txt'])
335
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
336
self.assertContainsRe(out, b"file1.txt~.:HELLO", flags=TestGrep._reflags)
337
self.assertNotContainsRe(out, b"file2.txt", flags=TestGrep._reflags)
338
self.assertEqual(len(out.splitlines()), 1)
340
out, err = self.run_bzr(['grep', 'HE..O',
341
'file0.txt', 'file1.txt', 'file2.txt'])
343
self.assertContainsRe(out, b"file0.txt:HELLO", flags=TestGrep._reflags)
344
self.assertContainsRe(out, b"file1.txt:HELLO", flags=TestGrep._reflags)
345
self.assertContainsRe(out, b"file2.txt:HELLO", flags=TestGrep._reflags)
346
self.assertEqual(len(out.splitlines()), 3)
348
out, err = self.run_bzr(['grep', 'HE..O', '-r', 'last:1',
349
'file0.txt', 'file1.txt', 'file2.txt'])
351
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
352
self.assertContainsRe(out, b"file1.txt~.:HELLO", flags=TestGrep._reflags)
353
self.assertNotContainsRe(out, b"file2.txt", flags=TestGrep._reflags)
354
self.assertEqual(len(out.splitlines()), 1)
356
def test_ver_null_option(self):
357
"""(versioned) --null option should use NUL instead of newline.
360
self.make_branch_and_tree(wd)
362
self._mk_versioned_file('file0.txt', total_lines=3)
364
nref = ud.normalize(u'NFC', u"file0.txt~1:line1\0file0.txt~1:line2\0file0.txt~1:line3\0")
366
out, err = self.run_bzr(['grep', '-r', 'last:1', '--null', 'line[1-3]'])
367
nout = ud.normalize(u'NFC', out.decode('utf-8', 'ignore'))
368
self.assertEqual(nout, nref)
369
self.assertEqual(len(out.splitlines()), 1)
371
out, err = self.run_bzr(['grep', '-r', 'last:1', '-Z', 'line[1-3]'])
372
nout = ud.normalize(u'NFC', out.decode('utf-8', 'ignore'))
373
self.assertEqual(nout, nref)
374
self.assertEqual(len(out.splitlines()), 1)
376
out, err = self.run_bzr(['grep', '-r', 'last:1', '--null', 'line'])
377
nout = ud.normalize(u'NFC', out.decode('utf-8', 'ignore'))
378
self.assertEqual(nout, nref)
379
self.assertEqual(len(out.splitlines()), 1)
381
def test_wtree_null_option(self):
382
"""(wtree) --null option should use NUL instead of newline.
385
self.make_branch_and_tree(wd)
387
self._mk_versioned_file('file0.txt', total_lines=3)
389
out, err = self.run_bzr(['grep', '--null', 'line[1-3]'])
390
self.assertEqual(out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
391
self.assertEqual(len(out.splitlines()), 1)
393
out, err = self.run_bzr(['grep', '-Z', 'line[1-3]'])
394
self.assertEqual(out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
395
self.assertEqual(len(out.splitlines()), 1)
397
out, err = self.run_bzr(['grep', '-Z', 'line'])
398
self.assertEqual(out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
399
self.assertEqual(len(out.splitlines()), 1)
401
def test_versioned_file_in_dir_no_recursive(self):
402
"""(versioned) Should not recurse with --no-recursive"""
404
self.make_branch_and_tree(wd)
406
self._mk_versioned_file('fileX.txt', line_prefix='lin')
407
self._mk_versioned_dir('dir0')
408
self._mk_versioned_file('dir0/file0.txt')
410
out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1'])
411
self.assertNotContainsRe(out, b"file0.txt~.:line1", flags=TestGrep._reflags)
412
self.assertEqual(len(out.splitlines()), 0)
414
out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1$'])
415
self.assertNotContainsRe(out, b"file0.txt~.:line1", flags=TestGrep._reflags)
416
self.assertEqual(len(out.splitlines()), 0)
418
def test_wtree_file_in_dir_no_recursive(self):
419
"""(wtree) Should not recurse with --no-recursive"""
421
self.make_branch_and_tree(wd)
423
self._mk_versioned_file('fileX.txt', line_prefix='lin')
424
self._mk_versioned_dir('dir0')
425
self._mk_versioned_file('dir0/file0.txt')
427
out, err = self.run_bzr(['grep', '--no-recursive', 'line1'])
428
self.assertNotContainsRe(out, b"file0.txt:line1", flags=TestGrep._reflags)
429
self.assertEqual(len(out.splitlines()), 0)
431
out, err = self.run_bzr(['grep', '--no-recursive', 'lin.1'])
432
self.assertNotContainsRe(out, b"file0.txt:line1", flags=TestGrep._reflags)
433
self.assertEqual(len(out.splitlines()), 0)
435
def test_versioned_file_in_dir_recurse(self):
436
"""(versioned) Should recurse by default.
439
self.make_branch_and_tree(wd)
441
self._mk_versioned_dir('dir0')
442
self._mk_versioned_file('dir0/file0.txt')
444
out, err = self.run_bzr(['grep', '-r', '-1', '.i.e1'])
445
self.assertContainsRe(out, b"^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
446
# find line1 and line10
447
self.assertEqual(len(out.splitlines()), 2)
449
out, err = self.run_bzr(['grep', '-r', '-1', 'line1'])
450
self.assertContainsRe(out, b"^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
451
# find line1 and line10
452
self.assertEqual(len(out.splitlines()), 2)
454
def test_wtree_file_in_dir_recurse(self):
455
"""(wtree) Should recurse by default.
458
self.make_branch_and_tree(wd)
460
self._mk_versioned_dir('dir0')
461
self._mk_versioned_file('dir0/file0.txt')
463
out, err = self.run_bzr(['grep', 'line1'])
464
self.assertContainsRe(out, b"^dir0/file0.txt:line1", flags=TestGrep._reflags)
465
# find line1 and line10
466
self.assertEqual(len(out.splitlines()), 2)
468
out, err = self.run_bzr(['grep', 'lin.1'])
469
self.assertContainsRe(out, b"^dir0/file0.txt:line1", flags=TestGrep._reflags)
470
# find line1 and line10
471
self.assertEqual(len(out.splitlines()), 2)
473
def test_versioned_file_within_dir(self):
474
"""(versioned) Search for pattern while in nested dir.
477
self.make_branch_and_tree(wd)
479
self._mk_versioned_dir('dir0')
480
self._mk_versioned_file('dir0/file0.txt')
483
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
484
self.assertContainsRe(out, b"^file0.txt~.:line1", flags=TestGrep._reflags)
485
# finds line1 and line10
486
self.assertEqual(len(out.splitlines()), 2)
488
out, err = self.run_bzr(['grep', '-r', 'last:1', '.i.e1'])
489
self.assertContainsRe(out, b"^file0.txt~.:line1", flags=TestGrep._reflags)
490
# finds line1 and line10
491
self.assertEqual(len(out.splitlines()), 2)
493
def test_versioned_include_file_within_dir(self):
494
"""(versioned) Ensure --include is respected with file within dir.
497
self.make_branch_and_tree(wd)
499
self._mk_versioned_dir('dir0') # revno 1
500
self._mk_versioned_file('dir0/file0.txt') # revno 2
501
self._mk_versioned_file('dir0/file1.aa') # revno 3
502
self._update_file('dir0/file1.aa', 'hello\n') # revno 4
503
self._update_file('dir0/file0.txt', 'hello\n') # revno 5
506
out, err = self.run_bzr(['grep', '-r', 'last:1',
507
'--include', '*.aa', 'line1'])
508
self.assertContainsRe(out, b"^file1.aa~5:line1$", flags=TestGrep._reflags)
509
self.assertContainsRe(out, b"^file1.aa~5:line10$", flags=TestGrep._reflags)
510
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
511
# finds line1 and line10
512
self.assertEqual(len(out.splitlines()), 2)
514
out, err = self.run_bzr(['grep', '-r', 'last:2..last:1',
515
'--include', '*.aa', 'line1'])
516
self.assertContainsRe(out, b"^file1.aa~4:line1$", flags=TestGrep._reflags)
517
self.assertContainsRe(out, b"^file1.aa~4:line10$", flags=TestGrep._reflags)
518
self.assertContainsRe(out, b"^file1.aa~5:line1$", flags=TestGrep._reflags)
519
self.assertContainsRe(out, b"^file1.aa~5:line10$", flags=TestGrep._reflags)
520
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
521
# finds line1 and line10 over two revisions
522
self.assertEqual(len(out.splitlines()), 4)
524
out, err = self.run_bzr(['grep', '-r', 'last:1',
525
'--include', '*.aa', 'lin.1'])
526
self.assertContainsRe(out, b"^file1.aa~5:line1$", flags=TestGrep._reflags)
527
self.assertContainsRe(out, b"^file1.aa~5:line10$", flags=TestGrep._reflags)
528
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
529
# finds line1 and line10
530
self.assertEqual(len(out.splitlines()), 2)
532
out, err = self.run_bzr(['grep', '-r', 'last:3..last:1',
533
'--include', '*.aa', 'lin.1'])
534
self.assertContainsRe(out, b"^file1.aa~3:line1$", flags=TestGrep._reflags)
535
self.assertContainsRe(out, b"^file1.aa~4:line1$", flags=TestGrep._reflags)
536
self.assertContainsRe(out, b"^file1.aa~5:line1$", flags=TestGrep._reflags)
537
self.assertContainsRe(out, b"^file1.aa~3:line10$", flags=TestGrep._reflags)
538
self.assertContainsRe(out, b"^file1.aa~4:line10$", flags=TestGrep._reflags)
539
self.assertContainsRe(out, b"^file1.aa~5:line10$", flags=TestGrep._reflags)
540
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
541
# finds line1 and line10 over 3 revisions
542
self.assertEqual(len(out.splitlines()), 6)
544
def test_versioned_exclude_file_within_dir(self):
545
"""(versioned) Ensure --exclude is respected with file within dir.
548
self.make_branch_and_tree(wd)
550
self._mk_versioned_dir('dir0')
551
self._mk_versioned_file('dir0/file0.txt')
552
self._mk_versioned_file('dir0/file1.aa')
555
out, err = self.run_bzr(['grep', '-r', 'last:1',
556
'--exclude', '*.txt', 'line1'])
557
self.assertContainsRe(out, b"^file1.aa~.:line1", flags=TestGrep._reflags)
558
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
559
# finds line1 and line10
560
self.assertEqual(len(out.splitlines()), 2)
562
out, err = self.run_bzr(['grep', '-r', 'last:1',
563
'--exclude', '*.txt', 'l[a-z]ne1'])
564
self.assertContainsRe(out, b"^file1.aa~.:line1", flags=TestGrep._reflags)
565
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
566
# finds line1 and line10
567
self.assertEqual(len(out.splitlines()), 2)
569
def test_wtree_file_within_dir(self):
570
"""(wtree) Search for pattern while in nested dir.
573
self.make_branch_and_tree(wd)
575
self._mk_versioned_dir('dir0')
576
self._mk_versioned_file('dir0/file0.txt')
579
out, err = self.run_bzr(['grep', 'line1'])
580
self.assertContainsRe(out, b"^file0.txt:line1", flags=TestGrep._reflags)
581
# finds line1 and line10
582
self.assertEqual(len(out.splitlines()), 2)
584
out, err = self.run_bzr(['grep', 'l[aeiou]ne1'])
585
self.assertContainsRe(out, b"^file0.txt:line1", flags=TestGrep._reflags)
586
# finds line1 and line10
587
self.assertEqual(len(out.splitlines()), 2)
589
def test_wtree_include_file_within_dir(self):
590
"""(wtree) Ensure --include is respected with file within dir.
593
self.make_branch_and_tree(wd)
595
self._mk_versioned_dir('dir0')
596
self._mk_versioned_file('dir0/file0.txt')
597
self._mk_versioned_file('dir0/file1.aa')
600
out, err = self.run_bzr(['grep', '--include', '*.aa', 'line1'])
601
self.assertContainsRe(out, b"^file1.aa:line1", flags=TestGrep._reflags)
602
# finds line1 and line10
603
self.assertEqual(len(out.splitlines()), 2)
605
out, err = self.run_bzr(['grep', '--include', '*.aa', 'l[ixn]ne1'])
606
self.assertContainsRe(out, b"^file1.aa:line1", flags=TestGrep._reflags)
607
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
608
# finds line1 and line10
609
self.assertEqual(len(out.splitlines()), 2)
611
def test_wtree_exclude_file_within_dir(self):
612
"""(wtree) Ensure --exclude is respected with file within dir.
615
self.make_branch_and_tree(wd)
617
self._mk_versioned_dir('dir0')
618
self._mk_versioned_file('dir0/file0.txt')
619
self._mk_versioned_file('dir0/file1.aa')
622
out, err = self.run_bzr(['grep', '--exclude', '*.txt', 'li.e1'])
623
self.assertContainsRe(out, b"^file1.aa:line1$", flags=TestGrep._reflags)
624
self.assertContainsRe(out, b"^file1.aa:line10$", flags=TestGrep._reflags)
625
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
626
# finds line1 and line10
627
self.assertEqual(len(out.splitlines()), 2)
629
out, err = self.run_bzr(['grep', '--exclude', '*.txt', 'line1'])
630
self.assertContainsRe(out, b"^file1.aa:line1$", flags=TestGrep._reflags)
631
self.assertContainsRe(out, b"^file1.aa:line10$", flags=TestGrep._reflags)
632
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
633
# finds line1 and line10
634
self.assertEqual(len(out.splitlines()), 2)
636
def test_versioned_include_from_outside_dir(self):
637
"""(versioned) Ensure --include is respected during recursive search.
640
self.make_branch_and_tree(wd)
643
self._mk_versioned_dir('dir0')
644
self._mk_versioned_file('dir0/file0.aa')
646
self._mk_versioned_dir('dir1')
647
self._mk_versioned_file('dir1/file1.bb')
649
self._mk_versioned_dir('dir2')
650
self._mk_versioned_file('dir2/file2.cc')
652
out, err = self.run_bzr(['grep', '-r', 'last:1',
653
'--include', '*.aa', '--include', '*.bb', 'l..e1'])
654
self.assertContainsRe(out, b"^dir0/file0.aa~.:line1$", flags=TestGrep._reflags)
655
self.assertContainsRe(out, b"^dir1/file1.bb~.:line1$", flags=TestGrep._reflags)
656
self.assertContainsRe(out, b"^dir0/file0.aa~.:line10$", flags=TestGrep._reflags)
657
self.assertContainsRe(out, b"^dir1/file1.bb~.:line10$", flags=TestGrep._reflags)
658
self.assertNotContainsRe(out, b"file1.cc", flags=TestGrep._reflags)
659
# finds line1 and line10
660
self.assertEqual(len(out.splitlines()), 4)
662
out, err = self.run_bzr(['grep', '-r', 'last:1',
663
'--include', '*.aa', '--include', '*.bb', 'line1'])
664
self.assertContainsRe(out, b"^dir0/file0.aa~.:line1$", flags=TestGrep._reflags)
665
self.assertContainsRe(out, b"^dir1/file1.bb~.:line1$", flags=TestGrep._reflags)
666
self.assertContainsRe(out, b"^dir0/file0.aa~.:line10$", flags=TestGrep._reflags)
667
self.assertContainsRe(out, b"^dir1/file1.bb~.:line10$", flags=TestGrep._reflags)
668
self.assertNotContainsRe(out, b"file1.cc", flags=TestGrep._reflags)
669
# finds line1 and line10
670
self.assertEqual(len(out.splitlines()), 4)
672
def test_wtree_include_from_outside_dir(self):
673
"""(wtree) Ensure --include is respected during recursive search.
676
self.make_branch_and_tree(wd)
679
self._mk_versioned_dir('dir0')
680
self._mk_versioned_file('dir0/file0.aa')
682
self._mk_versioned_dir('dir1')
683
self._mk_versioned_file('dir1/file1.bb')
685
self._mk_versioned_dir('dir2')
686
self._mk_versioned_file('dir2/file2.cc')
688
out, err = self.run_bzr(['grep', '--include', '*.aa',
689
'--include', '*.bb', 'l.n.1'])
690
self.assertContainsRe(out, b"^dir0/file0.aa:line1$", flags=TestGrep._reflags)
691
self.assertContainsRe(out, b"^dir1/file1.bb:line1$", flags=TestGrep._reflags)
692
self.assertContainsRe(out, b"^dir0/file0.aa:line10$", flags=TestGrep._reflags)
693
self.assertContainsRe(out, b"^dir1/file1.bb:line10$", flags=TestGrep._reflags)
694
self.assertNotContainsRe(out, b"file1.cc", flags=TestGrep._reflags)
695
# finds line1 and line10
696
self.assertEqual(len(out.splitlines()), 4)
698
out, err = self.run_bzr(['grep', '--include', '*.aa',
699
'--include', '*.bb', 'line1'])
700
self.assertContainsRe(out, b"^dir0/file0.aa:line1$", flags=TestGrep._reflags)
701
self.assertContainsRe(out, b"^dir1/file1.bb:line1$", flags=TestGrep._reflags)
702
self.assertContainsRe(out, b"^dir0/file0.aa:line10$", flags=TestGrep._reflags)
703
self.assertContainsRe(out, b"^dir1/file1.bb:line10$", flags=TestGrep._reflags)
704
self.assertNotContainsRe(out, b"file1.cc", flags=TestGrep._reflags)
705
# finds line1 and line10
706
self.assertEqual(len(out.splitlines()), 4)
708
def test_versioned_exclude_from_outside_dir(self):
709
"""(versioned) Ensure --exclude is respected during recursive search.
712
self.make_branch_and_tree(wd)
715
self._mk_versioned_dir('dir0')
716
self._mk_versioned_file('dir0/file0.aa')
718
self._mk_versioned_dir('dir1')
719
self._mk_versioned_file('dir1/file1.bb')
721
self._mk_versioned_dir('dir2')
722
self._mk_versioned_file('dir2/file2.cc')
724
out, err = self.run_bzr(['grep', '-r', 'last:1',
725
'--exclude', '*.cc', 'l..e1'])
726
self.assertContainsRe(out, b"^dir0/file0.aa~.:line1", flags=TestGrep._reflags)
727
self.assertContainsRe(out, b"^dir1/file1.bb~.:line1", flags=TestGrep._reflags)
728
self.assertNotContainsRe(out, b"file1.cc", flags=TestGrep._reflags)
730
out, err = self.run_bzr(['grep', '-r', 'last:1',
731
'--exclude', '*.cc', 'line1'])
732
self.assertContainsRe(out, b"^dir0/file0.aa~.:line1", flags=TestGrep._reflags)
733
self.assertContainsRe(out, b"^dir1/file1.bb~.:line1", flags=TestGrep._reflags)
734
self.assertNotContainsRe(out, b"file1.cc", flags=TestGrep._reflags)
736
def test_wtree_exclude_from_outside_dir(self):
737
"""(wtree) Ensure --exclude is respected during recursive search.
740
self.make_branch_and_tree(wd)
743
self._mk_versioned_dir('dir0')
744
self._mk_versioned_file('dir0/file0.aa')
746
self._mk_versioned_dir('dir1')
747
self._mk_versioned_file('dir1/file1.bb')
749
self._mk_versioned_dir('dir2')
750
self._mk_versioned_file('dir2/file2.cc')
752
out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'l[hijk]ne1'])
753
self.assertContainsRe(out, b"^dir0/file0.aa:line1", flags=TestGrep._reflags)
754
self.assertContainsRe(out, b"^dir1/file1.bb:line1", flags=TestGrep._reflags)
755
self.assertNotContainsRe(out, b"file1.cc", flags=TestGrep._reflags)
757
out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'line1'])
758
self.assertContainsRe(out, b"^dir0/file0.aa:line1", flags=TestGrep._reflags)
759
self.assertContainsRe(out, b"^dir1/file1.bb:line1", flags=TestGrep._reflags)
760
self.assertNotContainsRe(out, b"file1.cc", flags=TestGrep._reflags)
762
def test_workingtree_files_from_outside_dir(self):
763
"""(wtree) Grep for pattern with dirs passed as argument.
766
self.make_branch_and_tree(wd)
769
self._mk_versioned_dir('dir0')
770
self._mk_versioned_file('dir0/file0.txt')
772
self._mk_versioned_dir('dir1')
773
self._mk_versioned_file('dir1/file1.txt')
775
out, err = self.run_bzr(['grep', 'l[aeiou]ne1', 'dir0', 'dir1'])
776
self.assertContainsRe(out, b"^dir0/file0.txt:line1", flags=TestGrep._reflags)
777
self.assertContainsRe(out, b"^dir1/file1.txt:line1", flags=TestGrep._reflags)
779
out, err = self.run_bzr(['grep', 'line1', 'dir0', 'dir1'])
780
self.assertContainsRe(out, b"^dir0/file0.txt:line1", flags=TestGrep._reflags)
781
self.assertContainsRe(out, b"^dir1/file1.txt:line1", flags=TestGrep._reflags)
783
def test_versioned_files_from_outside_dir(self):
784
"""(versioned) Grep for pattern with dirs passed as argument.
787
self.make_branch_and_tree(wd)
790
self._mk_versioned_dir('dir0')
791
self._mk_versioned_file('dir0/file0.txt')
793
self._mk_versioned_dir('dir1')
794
self._mk_versioned_file('dir1/file1.txt')
796
out, err = self.run_bzr(['grep', '-r', 'last:1', '.ine1', 'dir0', 'dir1'])
797
self.assertContainsRe(out, b"^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
798
self.assertContainsRe(out, b"^dir1/file1.txt~.:line1", flags=TestGrep._reflags)
800
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1', 'dir0', 'dir1'])
801
self.assertContainsRe(out, b"^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
802
self.assertContainsRe(out, b"^dir1/file1.txt~.:line1", flags=TestGrep._reflags)
804
def test_wtree_files_from_outside_dir(self):
805
"""(wtree) Grep for pattern with dirs passed as argument.
808
self.make_branch_and_tree(wd)
811
self._mk_versioned_dir('dir0')
812
self._mk_versioned_file('dir0/file0.txt')
814
self._mk_versioned_dir('dir1')
815
self._mk_versioned_file('dir1/file1.txt')
817
out, err = self.run_bzr(['grep', 'li.e1', 'dir0', 'dir1'])
818
self.assertContainsRe(out, b"^dir0/file0.txt:line1", flags=TestGrep._reflags)
819
self.assertContainsRe(out, b"^dir1/file1.txt:line1", flags=TestGrep._reflags)
821
out, err = self.run_bzr(['grep', 'line1', 'dir0', 'dir1'])
822
self.assertContainsRe(out, b"^dir0/file0.txt:line1", flags=TestGrep._reflags)
823
self.assertContainsRe(out, b"^dir1/file1.txt:line1", flags=TestGrep._reflags)
825
def test_versioned_files_from_outside_two_dirs(self):
826
"""(versioned) Grep for pattern with two levels of nested dir.
829
self.make_branch_and_tree(wd)
832
self._mk_versioned_dir('dir0')
833
self._mk_versioned_file('dir0/file0.txt')
835
self._mk_versioned_dir('dir1')
836
self._mk_versioned_file('dir1/file1.txt')
838
self._mk_versioned_dir('dir0/dir00')
839
self._mk_versioned_file('dir0/dir00/file0.txt')
841
out, err = self.run_bzr(['grep', '-r', 'last:1', 'l.ne1', 'dir0/dir00'])
842
self.assertContainsRe(out, b"^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
844
out, err = self.run_bzr(['grep', '-r', 'last:1', 'l.ne1'])
845
self.assertContainsRe(out, b"^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
847
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1', 'dir0/dir00'])
848
self.assertContainsRe(out, b"^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
850
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
851
self.assertContainsRe(out, b"^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
853
def test_wtree_files_from_outside_two_dirs(self):
854
"""(wtree) Grep for pattern with two levels of nested dir.
857
self.make_branch_and_tree(wd)
860
self._mk_versioned_dir('dir0')
861
self._mk_versioned_file('dir0/file0.txt')
863
self._mk_versioned_dir('dir1')
864
self._mk_versioned_file('dir1/file1.txt')
866
self._mk_versioned_dir('dir0/dir00')
867
self._mk_versioned_file('dir0/dir00/file0.txt')
869
out, err = self.run_bzr(['grep', 'lin.1', 'dir0/dir00'])
870
self.assertContainsRe(out, b"^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
872
out, err = self.run_bzr(['grep', 'li.e1'])
873
self.assertContainsRe(out, b"^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
875
out, err = self.run_bzr(['grep', 'line1', 'dir0/dir00'])
876
self.assertContainsRe(out, b"^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
878
out, err = self.run_bzr(['grep', 'line1'])
879
self.assertContainsRe(out, b"^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
881
def test_versioned_file_within_dir_two_levels(self):
882
"""(versioned) Search for pattern while in nested dir (two levels).
885
self.make_branch_and_tree(wd)
887
self._mk_versioned_dir('dir0')
888
self._mk_versioned_dir('dir0/dir1')
889
self._mk_versioned_file('dir0/dir1/file0.txt')
892
out, err = self.run_bzr(['grep', '-r', 'last:1', '.ine1'])
893
self.assertContainsRe(out, b"^dir1/file0.txt~.:line1", flags=TestGrep._reflags)
895
out, err = self.run_bzr(['grep', '-r', 'last:1', '--from-root', 'l.ne1'])
896
self.assertContainsRe(out, b"^dir0/dir1/file0.txt~.:line1", flags=TestGrep._reflags)
898
out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1'])
899
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
901
out, err = self.run_bzr(['grep', '-r', 'last:1', 'lin.1'])
902
self.assertContainsRe(out, b"^dir1/file0.txt~.:line1", flags=TestGrep._reflags)
904
out, err = self.run_bzr(['grep', '-r', 'last:1', '--from-root', 'line1'])
905
self.assertContainsRe(out, b"^dir0/dir1/file0.txt~.:line1", flags=TestGrep._reflags)
907
out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1'])
908
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
909
self.assertEqual(len(out.splitlines()), 0)
911
def test_wtree_file_within_dir_two_levels(self):
912
"""(wtree) Search for pattern while in nested dir (two levels).
915
self.make_branch_and_tree(wd)
917
self._mk_versioned_dir('dir0')
918
self._mk_versioned_dir('dir0/dir1')
919
self._mk_versioned_file('dir0/dir1/file0.txt')
922
out, err = self.run_bzr(['grep', 'l[hij]ne1'])
923
self.assertContainsRe(out, b"^dir1/file0.txt:line1", flags=TestGrep._reflags)
925
out, err = self.run_bzr(['grep', '--from-root', 'l.ne1'])
926
self.assertContainsRe(out, b"^dir0/dir1/file0.txt:line1", flags=TestGrep._reflags)
928
out, err = self.run_bzr(['grep', '--no-recursive', 'lin.1'])
929
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
931
out, err = self.run_bzr(['grep', 'line1'])
932
self.assertContainsRe(out, b"^dir1/file0.txt:line1", flags=TestGrep._reflags)
934
out, err = self.run_bzr(['grep', '--from-root', 'line1'])
935
self.assertContainsRe(out, b"^dir0/dir1/file0.txt:line1", flags=TestGrep._reflags)
937
out, err = self.run_bzr(['grep', '--no-recursive', 'line1'])
938
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
940
def test_versioned_ignore_case_no_match(self):
941
"""(versioned) Match fails without --ignore-case.
944
self.make_branch_and_tree(wd)
946
self._mk_versioned_file('file0.txt')
948
out, err = self.run_bzr(['grep', '-r', 'last:1', 'LinE1', 'file0.txt'])
949
self.assertNotContainsRe(out, b"file0.txt~.:line1", flags=TestGrep._reflags)
951
out, err = self.run_bzr(['grep', '-r', 'last:1', 'Li.E1', 'file0.txt'])
952
self.assertNotContainsRe(out, b"file0.txt~.:line1", flags=TestGrep._reflags)
954
def test_wtree_ignore_case_no_match(self):
955
"""(wtree) Match fails without --ignore-case.
958
self.make_branch_and_tree(wd)
960
self._mk_versioned_file('file0.txt')
962
out, err = self.run_bzr(['grep', 'LinE1', 'file0.txt'])
963
self.assertNotContainsRe(out, b"file0.txt:line1", flags=TestGrep._reflags)
965
out, err = self.run_bzr(['grep', '.inE1', 'file0.txt'])
966
self.assertNotContainsRe(out, b"file0.txt:line1", flags=TestGrep._reflags)
968
def test_versioned_ignore_case_match(self):
969
"""(versioned) Match fails without --ignore-case.
972
self.make_branch_and_tree(wd)
974
self._mk_versioned_file('file0.txt')
976
out, err = self.run_bzr(['grep', '-r', 'last:1',
977
'-i', 'Li.E1', 'file0.txt'])
978
self.assertContainsRe(out, b"file0.txt~.:line1", flags=TestGrep._reflags)
980
out, err = self.run_bzr(['grep', '-r', 'last:1',
981
'-i', 'LinE1', 'file0.txt'])
982
self.assertContainsRe(out, b"file0.txt~.:line1", flags=TestGrep._reflags)
984
out, err = self.run_bzr(['grep', '-r', 'last:1',
985
'--ignore-case', 'LinE1', 'file0.txt'])
986
self.assertContainsRe(out, b"^file0.txt~.:line1", flags=TestGrep._reflags)
988
def test_wtree_ignore_case_match(self):
989
"""(wtree) Match fails without --ignore-case.
992
self.make_branch_and_tree(wd)
994
self._mk_versioned_file('file0.txt')
996
out, err = self.run_bzr(['grep', '-i', 'LinE1', 'file0.txt'])
997
self.assertContainsRe(out, b"file0.txt:line1", flags=TestGrep._reflags)
999
out, err = self.run_bzr(['grep', '--ignore-case', 'LinE1', 'file0.txt'])
1000
self.assertContainsRe(out, b"^file0.txt:line1", flags=TestGrep._reflags)
1002
out, err = self.run_bzr(['grep', '--ignore-case', 'Li.E1', 'file0.txt'])
1003
self.assertContainsRe(out, b"^file0.txt:line1", flags=TestGrep._reflags)
1005
def test_versioned_from_root_fail(self):
1006
"""(versioned) Match should fail without --from-root.
1009
self.make_branch_and_tree(wd)
1011
self._mk_versioned_file('file0.txt')
1012
self._mk_versioned_dir('dir0')
1015
out, err = self.run_bzr(['grep', '-r', 'last:1', 'li.e1'])
1016
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
1018
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
1019
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
1021
def test_wtree_from_root_fail(self):
1022
"""(wtree) Match should fail without --from-root.
1025
self.make_branch_and_tree(wd)
1027
self._mk_versioned_file('file0.txt')
1028
self._mk_versioned_dir('dir0')
1031
out, err = self.run_bzr(['grep', 'line1'])
1032
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
1034
out, err = self.run_bzr(['grep', 'li.e1'])
1035
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
1037
def test_versioned_from_root_pass(self):
1038
"""(versioned) Match pass with --from-root.
1041
self.make_branch_and_tree(wd)
1043
self._mk_versioned_file('file0.txt')
1044
self._mk_versioned_dir('dir0')
1047
out, err = self.run_bzr(['grep', '-r', 'last:1',
1048
'--from-root', 'l.ne1'])
1049
self.assertContainsRe(out, b"file0.txt~.:line1", flags=TestGrep._reflags)
1051
out, err = self.run_bzr(['grep', '-r', 'last:1',
1052
'--from-root', 'line1'])
1053
self.assertContainsRe(out, b"file0.txt~.:line1", flags=TestGrep._reflags)
1055
def test_wtree_from_root_pass(self):
1056
"""(wtree) Match pass with --from-root.
1059
self.make_branch_and_tree(wd)
1061
self._mk_versioned_file('file0.txt')
1062
self._mk_versioned_dir('dir0')
1065
out, err = self.run_bzr(['grep', '--from-root', 'lin.1'])
1066
self.assertContainsRe(out, b"file0.txt:line1", flags=TestGrep._reflags)
1068
out, err = self.run_bzr(['grep', '--from-root', 'line1'])
1069
self.assertContainsRe(out, b"file0.txt:line1", flags=TestGrep._reflags)
1071
def test_versioned_with_line_number(self):
1072
"""(versioned) Search for pattern with --line-number.
1075
self.make_branch_and_tree(wd)
1077
self._mk_versioned_file('file0.txt')
1079
out, err = self.run_bzr(['grep', '-r', 'last:1',
1080
'--line-number', 'li.e3', 'file0.txt'])
1081
self.assertContainsRe(out, b"file0.txt~.:3:line3", flags=TestGrep._reflags)
1083
out, err = self.run_bzr(['grep', '-r', 'last:1',
1084
'--line-number', 'line3', 'file0.txt'])
1085
self.assertContainsRe(out, b"file0.txt~.:3:line3", flags=TestGrep._reflags)
1087
out, err = self.run_bzr(['grep', '-r', 'last:1',
1088
'-n', 'line1', 'file0.txt'])
1089
self.assertContainsRe(out, b"file0.txt~.:1:line1", flags=TestGrep._reflags)
1091
out, err = self.run_bzr(['grep', '-n', 'line[0-9]', 'file0.txt'])
1092
self.assertContainsRe(out, b"file0.txt:3:line3", flags=TestGrep._reflags)
1094
def test_wtree_with_line_number(self):
1095
"""(wtree) Search for pattern with --line-number.
1098
self.make_branch_and_tree(wd)
1100
self._mk_versioned_file('file0.txt')
1102
out, err = self.run_bzr(['grep', '--line-number', 'line3', 'file0.txt'])
1103
self.assertContainsRe(out, b"file0.txt:3:line3", flags=TestGrep._reflags)
1105
out, err = self.run_bzr(['grep', '-n', 'line1', 'file0.txt'])
1106
self.assertContainsRe(out, b"file0.txt:1:line1", flags=TestGrep._reflags)
1108
out, err = self.run_bzr(['grep', '-n', '[hjkl]ine1', 'file0.txt'])
1109
self.assertContainsRe(out, b"file0.txt:1:line1", flags=TestGrep._reflags)
1111
out, err = self.run_bzr(['grep', '-n', 'line[0-9]', 'file0.txt'])
1112
self.assertContainsRe(out, b"file0.txt:3:line3", flags=TestGrep._reflags)
1114
def test_revno_basic_history_grep_file(self):
1115
"""Search for pattern in specific revision number in a file.
1119
self.make_branch_and_tree(wd)
1121
self._mk_versioned_file(fname, total_lines=0)
1122
self._update_file(fname, text="v2 text\n")
1123
self._update_file(fname, text="v3 text\n")
1124
self._update_file(fname, text="v4 text\n")
1126
# rev 2 should not have text 'v3'
1127
out, err = self.run_bzr(['grep', '-r', '2', 'v3', fname])
1128
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
1130
# rev 3 should not have text 'v3'
1131
out, err = self.run_bzr(['grep', '-r', '3', 'v3', fname])
1132
self.assertContainsRe(out, b"file0.txt~3:v3.*", flags=TestGrep._reflags)
1134
# rev 3 should not have text 'v3' with line number
1135
out, err = self.run_bzr(['grep', '-r', '3', '-n', 'v3', fname])
1136
self.assertContainsRe(out, b"file0.txt~3:2:v3.*", flags=TestGrep._reflags)
1138
# rev 2 should not have text 'v3'
1139
out, err = self.run_bzr(['grep', '-r', '2', '[tuv]3', fname])
1140
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
1142
# rev 3 should not have text 'v3'
1143
out, err = self.run_bzr(['grep', '-r', '3', '[tuv]3', fname])
1144
self.assertContainsRe(out, b"file0.txt~3:v3.*", flags=TestGrep._reflags)
1146
# rev 3 should not have text 'v3' with line number
1147
out, err = self.run_bzr(['grep', '-r', '3', '-n', '[tuv]3', fname])
1148
self.assertContainsRe(out, b"file0.txt~3:2:v3.*", flags=TestGrep._reflags)
1150
def test_revno_basic_history_grep_full(self):
1151
"""Search for pattern in specific revision number in a file.
1155
self.make_branch_and_tree(wd)
1157
self._mk_versioned_file(fname, total_lines=0) # rev1
1158
self._mk_versioned_file('file1.txt') # rev2
1159
self._update_file(fname, text="v3 text\n") # rev3
1160
self._update_file(fname, text="v4 text\n") # rev4
1161
self._update_file(fname, text="v5 text\n") # rev5
1163
# rev 2 should not have text 'v3'
1164
out, err = self.run_bzr(['grep', '-r', '2', 'v3'])
1165
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
1167
# rev 3 should not have text 'v3'
1168
out, err = self.run_bzr(['grep', '-r', '3', 'v3'])
1169
self.assertContainsRe(out, b"file0.txt~3:v3", flags=TestGrep._reflags)
1171
# rev 3 should not have text 'v3' with line number
1172
out, err = self.run_bzr(['grep', '-r', '3', '-n', 'v3'])
1173
self.assertContainsRe(out, b"file0.txt~3:1:v3", flags=TestGrep._reflags)
1175
# rev 2 should not have text 'v3'
1176
out, err = self.run_bzr(['grep', '-r', '2', '[tuv]3'])
1177
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
1179
# rev 3 should not have text 'v3'
1180
out, err = self.run_bzr(['grep', '-r', '3', '[tuv]3'])
1181
self.assertContainsRe(out, b"file0.txt~3:v3", flags=TestGrep._reflags)
1183
# rev 3 should not have text 'v3' with line number
1184
out, err = self.run_bzr(['grep', '-r', '3', '-n', '[tuv]3'])
1185
self.assertContainsRe(out, b"file0.txt~3:1:v3", flags=TestGrep._reflags)
1187
def test_revno_versioned_file_in_dir(self):
1188
"""Grep specific version of file withing dir.
1191
self.make_branch_and_tree(wd)
1193
self._mk_versioned_dir('dir0') # rev1
1194
self._mk_versioned_file('dir0/file0.txt') # rev2
1195
self._update_file('dir0/file0.txt', "v3 text\n") # rev3
1196
self._update_file('dir0/file0.txt', "v4 text\n") # rev4
1197
self._update_file('dir0/file0.txt', "v5 text\n") # rev5
1199
# v4 should not be present in revno 3
1200
out, err = self.run_bzr(['grep', '-r', 'last:3', 'v4'])
1201
self.assertNotContainsRe(out, b"^dir0/file0.txt", flags=TestGrep._reflags)
1203
# v4 should be present in revno 4
1204
out, err = self.run_bzr(['grep', '-r', 'last:2', 'v4'])
1205
self.assertContainsRe(out, b"^dir0/file0.txt~4:v4", flags=TestGrep._reflags)
1207
# v4 should not be present in revno 3
1208
out, err = self.run_bzr(['grep', '-r', 'last:3', '[tuv]4'])
1209
self.assertNotContainsRe(out, b"^dir0/file0.txt", flags=TestGrep._reflags)
1211
# v4 should be present in revno 4
1212
out, err = self.run_bzr(['grep', '-r', 'last:2', '[tuv]4'])
1213
self.assertContainsRe(out, b"^dir0/file0.txt~4:v4", flags=TestGrep._reflags)
1215
def test_revno_range_basic_history_grep(self):
1216
"""Search for pattern in revision range for file.
1220
self.make_branch_and_tree(wd)
1222
self._mk_versioned_file(fname, total_lines=0) # rev1
1223
self._mk_versioned_file('file1.txt') # rev2
1224
self._update_file(fname, text="v3 text\n") # rev3
1225
self._update_file(fname, text="v4 text\n") # rev4
1226
self._update_file(fname, text="v5 text\n") # rev5
1227
self._update_file(fname, text="v6 text\n") # rev6
1229
out, err = self.run_bzr(['grep', '-r', '1..', 'v3'])
1230
self.assertContainsRe(out, b"file0.txt~3:v3", flags=TestGrep._reflags)
1231
self.assertContainsRe(out, b"file0.txt~4:v3", flags=TestGrep._reflags)
1232
self.assertContainsRe(out, b"file0.txt~5:v3", flags=TestGrep._reflags)
1233
self.assertContainsRe(out, b"file0.txt~6:v3", flags=TestGrep._reflags)
1234
self.assertEqual(len(out.splitlines()), 4)
1236
out, err = self.run_bzr(['grep', '-r', '..1', 'v3'])
1237
# searching only rev1 gives nothing
1238
self.assertEqual(len(out.splitlines()), 0)
1240
out, err = self.run_bzr(['grep', '-r', '..6', 'v3'])
1241
self.assertContainsRe(out, b"file0.txt~3:v3", flags=TestGrep._reflags)
1242
self.assertContainsRe(out, b"file0.txt~4:v3", flags=TestGrep._reflags)
1243
self.assertContainsRe(out, b"file0.txt~5:v3", flags=TestGrep._reflags)
1244
self.assertContainsRe(out, b"file0.txt~6:v3", flags=TestGrep._reflags)
1245
self.assertEqual(len(out.splitlines()), 4)
1247
out, err = self.run_bzr(['grep', '-r', '..', 'v3'])
1248
self.assertContainsRe(out, b"file0.txt~3:v3", flags=TestGrep._reflags)
1249
self.assertContainsRe(out, b"file0.txt~4:v3", flags=TestGrep._reflags)
1250
self.assertContainsRe(out, b"file0.txt~5:v3", flags=TestGrep._reflags)
1251
self.assertContainsRe(out, b"file0.txt~6:v3", flags=TestGrep._reflags)
1252
self.assertEqual(len(out.splitlines()), 4)
1254
out, err = self.run_bzr(['grep', '-r', '1..5', 'v3'])
1255
self.assertContainsRe(out, b"file0.txt~3:v3", flags=TestGrep._reflags)
1256
self.assertContainsRe(out, b"file0.txt~4:v3", flags=TestGrep._reflags)
1257
self.assertContainsRe(out, b"file0.txt~5:v3", flags=TestGrep._reflags)
1258
self.assertNotContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1259
self.assertEqual(len(out.splitlines()), 3)
1261
out, err = self.run_bzr(['grep', '-r', '5..1', 'v3'])
1262
self.assertContainsRe(out, b"file0.txt~3:v3", flags=TestGrep._reflags)
1263
self.assertContainsRe(out, b"file0.txt~4:v3", flags=TestGrep._reflags)
1264
self.assertContainsRe(out, b"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', '1..', '[tuv]3'])
1269
self.assertContainsRe(out, b"file0.txt~3:v3", flags=TestGrep._reflags)
1270
self.assertContainsRe(out, b"file0.txt~4:v3", flags=TestGrep._reflags)
1271
self.assertContainsRe(out, b"file0.txt~5:v3", flags=TestGrep._reflags)
1272
self.assertContainsRe(out, b"file0.txt~6:v3", flags=TestGrep._reflags)
1273
self.assertEqual(len(out.splitlines()), 4)
1275
out, err = self.run_bzr(['grep', '-r', '1..5', '[tuv]3'])
1276
self.assertContainsRe(out, b"file0.txt~3:v3", flags=TestGrep._reflags)
1277
self.assertContainsRe(out, b"file0.txt~4:v3", flags=TestGrep._reflags)
1278
self.assertContainsRe(out, b"file0.txt~5:v3", flags=TestGrep._reflags)
1279
self.assertNotContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1280
self.assertEqual(len(out.splitlines()), 3)
1282
out, err = self.run_bzr(['grep', '-r', '5..1', '[tuv]3'])
1283
self.assertContainsRe(out, b"file0.txt~3:v3", flags=TestGrep._reflags)
1284
self.assertContainsRe(out, b"file0.txt~4:v3", flags=TestGrep._reflags)
1285
self.assertContainsRe(out, b"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
def test_revno_range_versioned_file_in_dir(self):
1290
"""Grep rev-range for pattern for file withing a dir.
1293
self.make_branch_and_tree(wd)
1295
self._mk_versioned_dir('dir0') # rev1
1296
self._mk_versioned_file('dir0/file0.txt') # rev2
1297
self._update_file('dir0/file0.txt', "v3 text\n") # rev3
1298
self._update_file('dir0/file0.txt', "v4 text\n") # rev4
1299
self._update_file('dir0/file0.txt', "v5 text\n") # rev5
1300
self._update_file('dir0/file0.txt', "v6 text\n") # rev6
1302
out, err = self.run_bzr(['grep', '-r', '2..5', 'v3'])
1303
self.assertContainsRe(out, b"^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
1304
self.assertContainsRe(out, b"^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
1305
self.assertContainsRe(out, b"^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
1306
self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1307
self.assertEqual(len(out.splitlines()), 3)
1309
out, err = self.run_bzr(['grep', '-r', '2..5', '[tuv]3'])
1310
self.assertContainsRe(out, b"^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
1311
self.assertContainsRe(out, b"^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
1312
self.assertContainsRe(out, b"^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
def test_revno_range_versioned_file_from_outside_dir(self):
1317
"""Grep rev-range for pattern from outside dir.
1320
self.make_branch_and_tree(wd)
1322
self._mk_versioned_dir('dir0') # rev1
1323
self._mk_versioned_file('dir0/file0.txt') # rev2
1324
self._update_file('dir0/file0.txt', "v3 text\n") # rev3
1325
self._update_file('dir0/file0.txt', "v4 text\n") # rev4
1326
self._update_file('dir0/file0.txt', "v5 text\n") # rev5
1327
self._update_file('dir0/file0.txt', "v6 text\n") # rev6
1329
out, err = self.run_bzr(['grep', '-r', '2..5', 'v3', 'dir0'])
1330
self.assertContainsRe(out, b"^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
1331
self.assertContainsRe(out, b"^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
1332
self.assertContainsRe(out, b"^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
1333
self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1335
out, err = self.run_bzr(['grep', '-r', '2..5', '[tuv]3', 'dir0'])
1336
self.assertContainsRe(out, b"^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
1337
self.assertContainsRe(out, b"^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
1338
self.assertContainsRe(out, b"^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
1339
self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1341
def test_levels(self):
1342
"""--levels=0 should show findings from merged revision.
1347
self.make_branch_and_tree(wd0)
1349
self._mk_versioned_file('file0.txt')
1352
out, err = self.run_bzr(['branch', wd0, wd1])
1354
self._mk_versioned_file('file1.txt')
1355
os.chdir(osutils.pathjoin('..', wd0))
1357
out, err = self.run_bzr(['merge', osutils.pathjoin('..', wd1)])
1358
out, err = self.run_bzr(['ci', '-m', 'merged'])
1360
out, err = self.run_bzr(['grep', 'line1'])
1361
self.assertContainsRe(out, b"file0.txt:line1", flags=TestGrep._reflags)
1362
self.assertContainsRe(out, b"file1.txt:line1", flags=TestGrep._reflags)
1364
# levels should be ignored by wtree grep
1365
out, err = self.run_bzr(['grep', '--levels=0', 'line1'])
1366
self.assertContainsRe(out, b"^file0.txt:line1$", flags=TestGrep._reflags)
1367
self.assertContainsRe(out, b"^file1.txt:line1$", flags=TestGrep._reflags)
1368
self.assertContainsRe(out, b"^file0.txt:line10$", flags=TestGrep._reflags)
1369
self.assertContainsRe(out, b"^file1.txt:line10$", flags=TestGrep._reflags)
1370
self.assertEqual(len(out.splitlines()), 4)
1372
out, err = self.run_bzr(['grep', '-r', 'last:1..', '--levels=0', 'line1'])
1373
self.assertContainsRe(out, b"^file0.txt~2:line1$", flags=TestGrep._reflags)
1374
self.assertContainsRe(out, b"^file1.txt~2:line1$", flags=TestGrep._reflags)
1375
self.assertContainsRe(out, b"^file0.txt~1.1.1:line1$", flags=TestGrep._reflags)
1376
self.assertContainsRe(out, b"^file1.txt~1.1.1:line1$", flags=TestGrep._reflags)
1377
self.assertContainsRe(out, b"^file0.txt~2:line10$", flags=TestGrep._reflags)
1378
self.assertContainsRe(out, b"^file1.txt~2:line10$", flags=TestGrep._reflags)
1379
self.assertContainsRe(out, b"^file0.txt~1.1.1:line10$", flags=TestGrep._reflags)
1380
self.assertContainsRe(out, b"^file1.txt~1.1.1:line10$", flags=TestGrep._reflags)
1381
self.assertEqual(len(out.splitlines()), 8)
1383
out, err = self.run_bzr(['grep', '-r', '-1..', '-n', '--levels=0', 'line1'])
1384
self.assertContainsRe(out, b"^file0.txt~2:1:line1$", flags=TestGrep._reflags)
1385
self.assertContainsRe(out, b"^file1.txt~2:1:line1$", flags=TestGrep._reflags)
1386
self.assertContainsRe(out, b"^file0.txt~1.1.1:1:line1$", flags=TestGrep._reflags)
1387
self.assertContainsRe(out, b"^file1.txt~1.1.1:1:line1$", flags=TestGrep._reflags)
1388
self.assertContainsRe(out, b"^file0.txt~2:10:line10$", flags=TestGrep._reflags)
1389
self.assertContainsRe(out, b"^file1.txt~2:10:line10$", flags=TestGrep._reflags)
1390
self.assertContainsRe(out, b"^file0.txt~1.1.1:10:line10$", flags=TestGrep._reflags)
1391
self.assertContainsRe(out, b"^file1.txt~1.1.1:10:line10$", flags=TestGrep._reflags)
1392
self.assertEqual(len(out.splitlines()), 8)
1394
# levels should be ignored by wtree grep
1395
out, err = self.run_bzr(['grep', '--levels=0', 'l.ne1'])
1396
self.assertContainsRe(out, b"^file0.txt:line1$", flags=TestGrep._reflags)
1397
self.assertContainsRe(out, b"^file1.txt:line1$", flags=TestGrep._reflags)
1398
self.assertContainsRe(out, b"^file0.txt:line10$", flags=TestGrep._reflags)
1399
self.assertContainsRe(out, b"^file1.txt:line10$", flags=TestGrep._reflags)
1400
self.assertEqual(len(out.splitlines()), 4)
1402
out, err = self.run_bzr(['grep', '-r', 'last:1..', '--levels=0', 'lin.1'])
1403
self.assertContainsRe(out, b"^file0.txt~2:line1$", flags=TestGrep._reflags)
1404
self.assertContainsRe(out, b"^file1.txt~2:line1$", flags=TestGrep._reflags)
1405
self.assertContainsRe(out, b"^file0.txt~1.1.1:line1$", flags=TestGrep._reflags)
1406
self.assertContainsRe(out, b"^file1.txt~1.1.1:line1$", flags=TestGrep._reflags)
1407
self.assertContainsRe(out, b"^file0.txt~2:line10$", flags=TestGrep._reflags)
1408
self.assertContainsRe(out, b"^file1.txt~2:line10$", flags=TestGrep._reflags)
1409
self.assertContainsRe(out, b"^file0.txt~1.1.1:line10$", flags=TestGrep._reflags)
1410
self.assertContainsRe(out, b"^file1.txt~1.1.1:line10$", flags=TestGrep._reflags)
1411
self.assertEqual(len(out.splitlines()), 8)
1413
out, err = self.run_bzr(['grep', '-r', '-1..', '-n', '--levels=0', '.ine1'])
1414
self.assertContainsRe(out, b"file0.txt~2:1:line1", flags=TestGrep._reflags)
1415
self.assertContainsRe(out, b"file1.txt~2:1:line1", flags=TestGrep._reflags)
1416
self.assertContainsRe(out, b"file0.txt~1.1.1:1:line1", flags=TestGrep._reflags)
1417
self.assertContainsRe(out, b"file1.txt~1.1.1:1:line1", flags=TestGrep._reflags)
1419
def test_dotted_rev_grep(self):
1420
"""Grep in dotted revs
1425
self.make_branch_and_tree(wd0)
1427
self._mk_versioned_file('file0.txt')
1430
out, err = self.run_bzr(['branch', wd0, wd1])
1432
self._mk_versioned_file('file1.txt') # revno 1.1.1
1433
self._update_file('file1.txt', "text 0\n") # revno 1.1.2
1434
self._update_file('file1.txt', "text 1\n") # revno 1.1.3
1435
self._update_file('file1.txt', "text 2\n") # revno 1.1.4
1436
os.chdir(osutils.pathjoin('..', wd0))
1438
out, err = self.run_bzr(['merge', osutils.pathjoin('..', wd1)])
1439
out, err = self.run_bzr(['ci', '-m', 'merged'])
1441
out, err = self.run_bzr(['grep', '-r', '1.1.1..1.1.4', 'text'])
1442
self.assertContainsRe(out, b"file1.txt~1.1.2:text 0", flags=TestGrep._reflags)
1443
self.assertContainsRe(out, b"file1.txt~1.1.3:text 1", flags=TestGrep._reflags)
1444
self.assertContainsRe(out, b"file1.txt~1.1.3:text 1", flags=TestGrep._reflags)
1445
self.assertContainsRe(out, b"file1.txt~1.1.4:text 0", flags=TestGrep._reflags)
1446
self.assertContainsRe(out, b"file1.txt~1.1.4:text 1", flags=TestGrep._reflags)
1447
self.assertContainsRe(out, b"file1.txt~1.1.4:text 2", flags=TestGrep._reflags)
1448
self.assertEqual(len(out.splitlines()), 6)
1450
def test_versioned_binary_file_grep(self):
1451
"""(versioned) Grep for pattern in binary file.
1454
self.make_branch_and_tree(wd)
1456
self._mk_versioned_file('file.txt')
1457
self._mk_versioned_file('file0.bin')
1458
self._update_file('file0.bin', "\x00lineNN\x00\n")
1460
# note: set --verbose/-v flag to get the skip message.
1461
out, err = self.run_bzr(['grep', '-v', '-r', 'last:1',
1462
'lineNN', 'file0.bin'])
1463
self.assertNotContainsRe(out, b"file0.bin", flags=TestGrep._reflags)
1464
self.assertContainsRe(err, b"Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
1465
self.assertEqual(len(out.splitlines()), 0)
1466
self.assertEqual(len(err.splitlines()), 1)
1468
out, err = self.run_bzr(['grep', '-v', '-r', 'last:1',
1469
'line.N', 'file0.bin'])
1470
self.assertNotContainsRe(out, b"file0.bin", flags=TestGrep._reflags)
1471
self.assertContainsRe(err, b"Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
1472
self.assertEqual(len(out.splitlines()), 0)
1473
self.assertEqual(len(err.splitlines()), 1)
1475
def test_wtree_binary_file_grep(self):
1476
"""(wtree) Grep for pattern in binary file.
1479
self.make_branch_and_tree(wd)
1481
self._mk_versioned_file('file0.bin')
1482
self._update_file('file0.bin', "\x00lineNN\x00\n")
1484
# note: set --verbose/-v flag to get the skip message.
1485
out, err = self.run_bzr(['grep', '-v', 'lineNN', 'file0.bin'])
1486
self.assertNotContainsRe(out, b"file0.bin:line1", flags=TestGrep._reflags)
1487
self.assertContainsRe(err, b"Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
1489
# binary warning should not be shown without --verbose
1490
out, err = self.run_bzr(['grep', 'lineNN', 'file0.bin'])
1491
self.assertNotContainsRe(out, b"file0.bin:line1", flags=TestGrep._reflags)
1492
self.assertNotContainsRe(err, b"Binary file", flags=TestGrep._reflags)
1494
def test_revspec(self):
1495
"""Ensure various revspecs work
1498
self.make_branch_and_tree(wd)
1500
self._mk_versioned_dir('dir0') # rev1
1501
self._mk_versioned_file('dir0/file0.txt') # rev2
1502
self._update_file('dir0/file0.txt', "v3 text\n") # rev3
1503
self._update_file('dir0/file0.txt', "v4 text\n") # rev4
1504
self._update_file('dir0/file0.txt', "v5 text\n") # rev5
1506
out, err = self.run_bzr(['grep', '-r', 'revno:1..2', 'v3'])
1507
self.assertNotContainsRe(out, "file0", flags=TestGrep._reflags)
1508
self.assertEqual(len(out.splitlines()), 0)
1510
out, err = self.run_bzr(['grep', '-r', 'revno:4..', 'v4'])
1511
self.assertContainsRe(out, b"^dir0/file0.txt", flags=TestGrep._reflags)
1512
self.assertEqual(len(out.splitlines()), 2) # find v4 in rev4 and rev5
1514
out, err = self.run_bzr(['grep', '-r', '..revno:3', 'v4'])
1515
self.assertNotContainsRe(out, "file0", flags=TestGrep._reflags)
1516
self.assertEqual(len(out.splitlines()), 0)
1518
out, err = self.run_bzr(['grep', '-r', '..revno:3', 'v3'])
1519
self.assertContainsRe(out, b"^dir0/file0.txt", flags=TestGrep._reflags)
1520
self.assertEqual(len(out.splitlines()), 1)
1522
def test_wtree_files_with_matches(self):
1523
"""(wtree) Ensure --files-with-matches, -l works
1526
self.make_branch_and_tree(wd)
1529
self._mk_versioned_file('file0.txt', total_lines=2)
1530
self._mk_versioned_file('file1.txt', total_lines=2)
1531
self._mk_versioned_dir('dir0')
1532
self._mk_versioned_file('dir0/file00.txt', total_lines=2)
1533
self._mk_versioned_file('dir0/file01.txt', total_lines=2)
1535
self._update_file('file0.txt', 'HELLO\n', checkin=False)
1536
self._update_file('dir0/file00.txt', 'HELLO\n', checkin=False)
1539
out, err = self.run_bzr(['grep', '--files-with-matches', 'HELLO'])
1541
self.assertContainsRe(out, b"^file0.txt$", flags=TestGrep._reflags)
1542
self.assertContainsRe(out, b"^dir0/file00.txt$", flags=TestGrep._reflags)
1543
self.assertEqual(len(out.splitlines()), 2)
1546
out, err = self.run_bzr(['grep', '--files-with-matches', 'HE.LO'])
1548
self.assertContainsRe(out, b"^file0.txt$", flags=TestGrep._reflags)
1549
self.assertContainsRe(out, b"^dir0/file00.txt$", flags=TestGrep._reflags)
1550
self.assertEqual(len(out.splitlines()), 2)
1553
out, err = self.run_bzr(['grep', '-l', 'HELLO'])
1555
self.assertContainsRe(out, b"^file0.txt$", flags=TestGrep._reflags)
1556
self.assertContainsRe(out, b"^dir0/file00.txt$", flags=TestGrep._reflags)
1557
self.assertEqual(len(out.splitlines()), 2)
1560
out, err = self.run_bzr(['grep', '-l', 'HE.LO'])
1562
self.assertContainsRe(out, b"^file0.txt$", flags=TestGrep._reflags)
1563
self.assertContainsRe(out, b"^dir0/file00.txt$", flags=TestGrep._reflags)
1564
self.assertEqual(len(out.splitlines()), 2)
1567
out, err = self.run_bzr(['grep', '-l', 'HELLO', 'dir0', 'file1.txt'])
1569
self.assertContainsRe(out, b"^dir0/file00.txt$", flags=TestGrep._reflags)
1570
self.assertEqual(len(out.splitlines()), 1)
1573
out, err = self.run_bzr(['grep', '-l', '.ELLO', 'dir0', 'file1.txt'])
1575
self.assertContainsRe(out, b"^dir0/file00.txt$", flags=TestGrep._reflags)
1576
self.assertEqual(len(out.splitlines()), 1)
1579
out, err = self.run_bzr(['grep', '-l', 'HELLO', 'file0.txt'])
1581
self.assertContainsRe(out, b"^file0.txt$", flags=TestGrep._reflags)
1582
self.assertEqual(len(out.splitlines()), 1)
1585
out, err = self.run_bzr(['grep', '-l', '.ELLO', 'file0.txt'])
1587
self.assertContainsRe(out, b"^file0.txt$", flags=TestGrep._reflags)
1588
self.assertEqual(len(out.splitlines()), 1)
1591
out, err = self.run_bzr(['grep', '--no-recursive', '-l', 'HELLO'])
1593
self.assertContainsRe(out, b"^file0.txt$", flags=TestGrep._reflags)
1594
self.assertEqual(len(out.splitlines()), 1)
1597
out, err = self.run_bzr(['grep', '--no-recursive', '-l', '.ELLO'])
1599
self.assertContainsRe(out, b"^file0.txt$", flags=TestGrep._reflags)
1600
self.assertEqual(len(out.splitlines()), 1)
1602
def test_ver_files_with_matches(self):
1603
"""(ver) Ensure --files-with-matches, -l works
1606
self.make_branch_and_tree(wd)
1609
self._mk_versioned_file('file0.txt', total_lines=2) # rev 1
1610
self._mk_versioned_file('file1.txt', total_lines=2) # rev 2
1611
self._mk_versioned_dir('dir0') # rev 3
1612
self._mk_versioned_file('dir0/file00.txt', total_lines=2) # rev 4
1613
self._mk_versioned_file('dir0/file01.txt', total_lines=2) # rev 5
1615
self._update_file('file0.txt', 'HELLO\n') # rev 6
1616
self._update_file('dir0/file00.txt', 'HELLO\n') # rev 7
1619
out, err = self.run_bzr(['grep', '-r', '-1', '--files-with-matches',
1622
self.assertContainsRe(out, b"^file0.txt~7$", flags=TestGrep._reflags)
1623
self.assertContainsRe(out, b"^dir0/file00.txt~7$", flags=TestGrep._reflags)
1624
self.assertEqual(len(out.splitlines()), 2)
1627
out, err = self.run_bzr(['grep', '-r', '-1', '--files-with-matches',
1630
self.assertContainsRe(out, b"^file0.txt~7$", flags=TestGrep._reflags)
1631
self.assertContainsRe(out, b"^dir0/file00.txt~7$", flags=TestGrep._reflags)
1632
self.assertEqual(len(out.splitlines()), 2)
1635
out, err = self.run_bzr(['grep', '-r', '6..7', '--files-with-matches',
1638
self.assertContainsRe(out, b"^file0.txt~6$", flags=TestGrep._reflags)
1639
self.assertContainsRe(out, b"^file0.txt~7$", flags=TestGrep._reflags)
1640
self.assertContainsRe(out, b"^dir0/file00.txt~7$", flags=TestGrep._reflags)
1641
self.assertEqual(len(out.splitlines()), 3)
1644
out, err = self.run_bzr(['grep', '-r', '6..7', '--files-with-matches',
1647
self.assertContainsRe(out, b"^file0.txt~6$", flags=TestGrep._reflags)
1648
self.assertContainsRe(out, b"^file0.txt~7$", flags=TestGrep._reflags)
1649
self.assertContainsRe(out, b"^dir0/file00.txt~7$", flags=TestGrep._reflags)
1650
self.assertEqual(len(out.splitlines()), 3)
1653
out, err = self.run_bzr(['grep', '-r', '-1', '-l', 'HELLO'])
1655
self.assertContainsRe(out, b"^file0.txt~7$", flags=TestGrep._reflags)
1656
self.assertContainsRe(out, b"^dir0/file00.txt~7$", flags=TestGrep._reflags)
1657
self.assertEqual(len(out.splitlines()), 2)
1660
out, err = self.run_bzr(['grep', '-r', '-1', '-l', 'H.LLO'])
1662
self.assertContainsRe(out, b"^file0.txt~7$", flags=TestGrep._reflags)
1663
self.assertContainsRe(out, b"^dir0/file00.txt~7$", flags=TestGrep._reflags)
1664
self.assertEqual(len(out.splitlines()), 2)
1667
out, err = self.run_bzr(['grep', '-l', 'HELLO', '-r', '-1',
1668
'dir0', 'file1.txt'])
1670
self.assertContainsRe(out, b"^dir0/file00.txt~7$", flags=TestGrep._reflags)
1671
self.assertEqual(len(out.splitlines()), 1)
1674
out, err = self.run_bzr(['grep', '-l', 'H.LLO', '-r', '-1',
1675
'dir0', 'file1.txt'])
1677
self.assertContainsRe(out, b"^dir0/file00.txt~7$", flags=TestGrep._reflags)
1678
self.assertEqual(len(out.splitlines()), 1)
1681
out, err = self.run_bzr(['grep', '-l', 'HELLO',
1682
'-r', '-2', 'file0.txt'])
1684
self.assertContainsRe(out, b"^file0.txt~6$", flags=TestGrep._reflags)
1685
self.assertEqual(len(out.splitlines()), 1)
1688
out, err = self.run_bzr(['grep', '-l', 'HE.LO',
1689
'-r', '-2', 'file0.txt'])
1691
self.assertContainsRe(out, b"^file0.txt~6$", flags=TestGrep._reflags)
1692
self.assertEqual(len(out.splitlines()), 1)
1695
out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
1698
self.assertContainsRe(out, b"^file0.txt~7$", 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, b"^file0.txt~7$", flags=TestGrep._reflags)
1706
self.assertEqual(len(out.splitlines()), 1)
1708
def test_wtree_files_without_matches(self):
1709
"""(wtree) Ensure --files-without-match, -L works
1712
self.make_branch_and_tree(wd)
1715
self._mk_versioned_file('file0.txt', total_lines=2)
1716
self._mk_versioned_file('file1.txt', total_lines=2)
1717
self._mk_versioned_dir('dir0')
1718
self._mk_versioned_file('dir0/file00.txt', total_lines=2)
1719
self._mk_versioned_file('dir0/file01.txt', total_lines=2)
1721
self._update_file('file0.txt', 'HELLO\n', checkin=False)
1722
self._update_file('dir0/file00.txt', 'HELLO\n', checkin=False)
1725
out, err = self.run_bzr(['grep', '--files-without-match', 'HELLO'])
1727
self.assertContainsRe(out, b"^file1.txt$", flags=TestGrep._reflags)
1728
self.assertContainsRe(out, b"^dir0/file01.txt$", flags=TestGrep._reflags)
1729
self.assertEqual(len(out.splitlines()), 2)
1732
out, err = self.run_bzr(['grep', '--files-without-match', 'HE.LO'])
1734
self.assertContainsRe(out, b"^file1.txt$", flags=TestGrep._reflags)
1735
self.assertContainsRe(out, b"^dir0/file01.txt$", flags=TestGrep._reflags)
1736
self.assertEqual(len(out.splitlines()), 2)
1739
out, err = self.run_bzr(['grep', '-L', 'HELLO'])
1741
self.assertContainsRe(out, b"^file1.txt$", flags=TestGrep._reflags)
1742
self.assertContainsRe(out, b"^dir0/file01.txt$", flags=TestGrep._reflags)
1743
self.assertEqual(len(out.splitlines()), 2)
1746
out, err = self.run_bzr(['grep', '-L', 'HE.LO'])
1748
self.assertContainsRe(out, b"^file1.txt$", flags=TestGrep._reflags)
1749
self.assertContainsRe(out, b"^dir0/file01.txt$", flags=TestGrep._reflags)
1750
self.assertEqual(len(out.splitlines()), 2)
1753
out, err = self.run_bzr(['grep', '-L', 'HELLO', 'dir0', 'file1.txt'])
1755
self.assertContainsRe(out, b"^file1.txt$", flags=TestGrep._reflags)
1756
self.assertContainsRe(out, b"^dir0/file01.txt$", flags=TestGrep._reflags)
1757
self.assertEqual(len(out.splitlines()), 2)
1760
out, err = self.run_bzr(['grep', '-L', '.ELLO', 'dir0', 'file1.txt'])
1762
self.assertContainsRe(out, b"^file1.txt$", flags=TestGrep._reflags)
1763
self.assertContainsRe(out, b"^dir0/file01.txt$", flags=TestGrep._reflags)
1764
self.assertEqual(len(out.splitlines()), 2)
1767
out, err = self.run_bzr(['grep', '-L', 'HELLO', 'file1.txt'])
1769
self.assertContainsRe(out, b"^file1.txt$", flags=TestGrep._reflags)
1770
self.assertEqual(len(out.splitlines()), 1)
1773
out, err = self.run_bzr(['grep', '-L', '.ELLO', 'file1.txt'])
1775
self.assertContainsRe(out, b"^file1.txt$", flags=TestGrep._reflags)
1776
self.assertEqual(len(out.splitlines()), 1)
1779
out, err = self.run_bzr(['grep', '--no-recursive', '-L', 'HELLO'])
1781
self.assertContainsRe(out, b"^file1.txt$", flags=TestGrep._reflags)
1782
self.assertEqual(len(out.splitlines()), 1)
1785
out, err = self.run_bzr(['grep', '--no-recursive', '-L', '.ELLO'])
1787
self.assertContainsRe(out, b"^file1.txt$", flags=TestGrep._reflags)
1788
self.assertEqual(len(out.splitlines()), 1)
1790
def test_ver_files_without_matches(self):
1791
"""(ver) Ensure --files-without-match, -L works
1794
self.make_branch_and_tree(wd)
1797
self._mk_versioned_file('file0.txt', total_lines=2) # rev 1
1798
self._mk_versioned_file('file1.txt', total_lines=2) # rev 2
1799
self._mk_versioned_dir('dir0') # rev 3
1800
self._mk_versioned_file('dir0/file00.txt', total_lines=2) # rev 4
1801
self._mk_versioned_file('dir0/file01.txt', total_lines=2) # rev 5
1803
self._update_file('file0.txt', 'HELLO\n') # rev 6
1804
self._update_file('dir0/file00.txt', 'HELLO\n') # rev 7
1807
out, err = self.run_bzr(['grep', '-r', '-1', '--files-without-match',
1810
self.assertContainsRe(out, b"^file1.txt~7$", flags=TestGrep._reflags)
1811
self.assertContainsRe(out, b"^dir0/file01.txt~7$", flags=TestGrep._reflags)
1812
self.assertEqual(len(out.splitlines()), 2)
1815
out, err = self.run_bzr(['grep', '-r', '-1', '--files-without-match',
1818
self.assertContainsRe(out, b"^file1.txt~7$", flags=TestGrep._reflags)
1819
self.assertContainsRe(out, b"^dir0/file01.txt~7$", flags=TestGrep._reflags)
1820
self.assertEqual(len(out.splitlines()), 2)
1823
out, err = self.run_bzr(['grep', '-r', '6..7', '--files-without-match',
1826
self.assertContainsRe(out, b"^file1.txt~6$", flags=TestGrep._reflags)
1827
self.assertContainsRe(out, b"^dir0/file00.txt~6$", flags=TestGrep._reflags)
1828
self.assertContainsRe(out, b"^dir0/file01.txt~6$", flags=TestGrep._reflags)
1829
self.assertContainsRe(out, b"^file1.txt~7$", flags=TestGrep._reflags)
1830
self.assertContainsRe(out, b"^dir0/file01.txt~7$", flags=TestGrep._reflags)
1831
self.assertEqual(len(out.splitlines()), 5)
1834
out, err = self.run_bzr(['grep', '-r', '6..7', '--files-without-match',
1837
self.assertContainsRe(out, b"^file1.txt~6$", flags=TestGrep._reflags)
1838
self.assertContainsRe(out, b"^dir0/file00.txt~6$", flags=TestGrep._reflags)
1839
self.assertContainsRe(out, b"^dir0/file01.txt~6$", flags=TestGrep._reflags)
1840
self.assertContainsRe(out, b"^file1.txt~7$", flags=TestGrep._reflags)
1841
self.assertContainsRe(out, b"^dir0/file01.txt~7$", flags=TestGrep._reflags)
1842
self.assertEqual(len(out.splitlines()), 5)
1845
out, err = self.run_bzr(['grep', '-r', '-1', '-L', 'HELLO'])
1847
self.assertContainsRe(out, b"^file1.txt~7$", flags=TestGrep._reflags)
1848
self.assertContainsRe(out, b"^dir0/file01.txt~7$", flags=TestGrep._reflags)
1849
self.assertEqual(len(out.splitlines()), 2)
1852
out, err = self.run_bzr(['grep', '-r', '-1', '-L', 'H.LLO'])
1854
self.assertContainsRe(out, b"^file1.txt~7$", flags=TestGrep._reflags)
1855
self.assertContainsRe(out, b"^dir0/file01.txt~7$", flags=TestGrep._reflags)
1856
self.assertEqual(len(out.splitlines()), 2)
1859
out, err = self.run_bzr(['grep', '-L', 'HELLO', '-r', '-1',
1860
'dir0', 'file1.txt'])
1862
self.assertContainsRe(out, b"^file1.txt~7$", flags=TestGrep._reflags)
1863
self.assertContainsRe(out, b"^dir0/file01.txt~7$", flags=TestGrep._reflags)
1864
self.assertEqual(len(out.splitlines()), 2)
1867
out, err = self.run_bzr(['grep', '-L', 'H.LLO', '-r', '-1',
1868
'dir0', 'file1.txt'])
1870
self.assertContainsRe(out, b"^file1.txt~7$", flags=TestGrep._reflags)
1871
self.assertContainsRe(out, b"^dir0/file01.txt~7$", flags=TestGrep._reflags)
1872
self.assertEqual(len(out.splitlines()), 2)
1875
out, err = self.run_bzr(['grep', '-L', 'HELLO',
1876
'-r', '-2', 'file1.txt'])
1878
self.assertContainsRe(out, b"^file1.txt~6$", flags=TestGrep._reflags)
1879
self.assertEqual(len(out.splitlines()), 1)
1882
out, err = self.run_bzr(['grep', '-L', 'HE.LO',
1883
'-r', '-2', 'file1.txt'])
1885
self.assertContainsRe(out, b"^file1.txt~6$", flags=TestGrep._reflags)
1886
self.assertEqual(len(out.splitlines()), 1)
1889
out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
1892
self.assertContainsRe(out, b"^file1.txt~7$", 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, b"^file1.txt~7$", flags=TestGrep._reflags)
1900
self.assertEqual(len(out.splitlines()), 1)
1902
def test_no_tree(self):
1903
"""Ensure grep works without working tree.
1907
self.make_branch_and_tree(wd0)
1909
self._mk_versioned_file('file0.txt')
1911
out, err = self.run_bzr(['branch', '--no-tree', wd0, wd1])
1914
out, err = self.run_bzr(['grep', 'line1'], 3)
1915
self.assertContainsRe(err, b"Cannot search working tree", flags=TestGrep._reflags)
1916
self.assertEqual(out, '')
1918
out, err = self.run_bzr(['grep', '-r', '1', 'line1'])
1919
self.assertContainsRe(out, b"file0.txt~1:line1", flags=TestGrep._reflags)
1920
self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
1923
class TestNonAscii(GrepTestBase):
1924
"""Tests for non-ascii filenames and file contents"""
1926
_test_needs_features = [UnicodeFilenameFeature]
1928
def test_unicode_only_file(self):
1929
"""Test filename and contents that requires a unicode encoding"""
1930
tree = self.make_branch_and_tree(".")
1931
contents = [u"\u1234"]
1932
self.build_tree(contents)
1934
tree.commit("Initial commit")
1935
as_utf8 = u"\u1234".encode("UTF-8")
1937
# GZ 2010-06-07: Note we can't actually grep for \u1234 as the pattern
1938
# is mangled according to the user encoding.
1939
streams = self.run_bzr(["grep", "--files-with-matches",
1940
u"contents"], encoding="UTF-8")
1941
self.assertEqual(streams, (as_utf8 + "\n", ""))
1943
streams = self.run_bzr(["grep", "-r", "1", "--files-with-matches",
1944
u"contents"], encoding="UTF-8")
1945
self.assertEqual(streams, (as_utf8 + "~1\n", ""))
1947
fileencoding = osutils.get_user_encoding()
1948
as_mangled = as_utf8.decode(fileencoding, "replace").encode("UTF-8")
1950
streams = self.run_bzr(["grep", "-n",
1951
u"contents"], encoding="UTF-8")
1952
self.assertEqual(streams, ("%s:1:contents of %s\n" %
1953
(as_utf8, as_mangled), ""))
1955
streams = self.run_bzr(["grep", "-n", "-r", "1",
1956
u"contents"], encoding="UTF-8")
1957
self.assertEqual(streams, ("%s~1:1:contents of %s\n" %
1958
(as_utf8, as_mangled), ""))
1961
class TestColorGrep(GrepTestBase):
1962
"""Tests for the --color option."""
1964
_rev_sep = color_string('~', fg=FG.BOLD_YELLOW)
1965
_sep = color_string(':', fg=FG.BOLD_CYAN)
1967
def test_color_option(self):
1968
"""Ensure options for color are valid.
1970
out, err = self.run_bzr(['grep', '--color', 'foo', 'bar'], 3)
1971
self.assertEqual(out, '')
1972
self.assertContainsRe(err, b'Valid values for --color are', flags=TestGrep._reflags)
1974
def test_ver_matching_files(self):
1975
"""(versioned) Search for matches or no matches only"""
1976
tree = self.make_branch_and_tree(".")
1977
contents = ["d/", "d/aaa", "bbb"]
1978
self.build_tree(contents)
1980
tree.commit("Initial commit")
1982
# GZ 2010-06-05: Maybe modify the working tree here
1984
streams = self.run_bzr(["grep", "--color", "always", "-r", "1",
1985
"--files-with-matches", "aaa"])
1986
self.assertEqual(streams, ("".join([
1987
FG.MAGENTA, "d/aaa", self._rev_sep, "1", "\n"
1990
streams = self.run_bzr(["grep", "--color", "always", "-r", "1",
1991
"--files-without-match", "aaa"])
1992
self.assertEqual(streams, ("".join([
1993
FG.MAGENTA, "bbb", self._rev_sep, "1", "\n"
1996
def test_wtree_matching_files(self):
1997
"""(wtree) Search for matches or no matches only"""
1998
tree = self.make_branch_and_tree(".")
1999
contents = ["d/", "d/aaa", "bbb"]
2000
self.build_tree(contents)
2002
tree.commit("Initial commit")
2004
# GZ 2010-06-05: Maybe modify the working tree here
2006
streams = self.run_bzr(["grep", "--color", "always",
2007
"--files-with-matches", "aaa"])
2008
self.assertEqual(streams, ("".join([
2009
FG.MAGENTA, "d/aaa", FG.NONE, "\n"
2012
streams = self.run_bzr(["grep", "--color", "always",
2013
"--files-without-match", "aaa"])
2014
self.assertEqual(streams, ("".join([
2015
FG.MAGENTA, "bbb", FG.NONE, "\n"
2018
def test_ver_basic_file(self):
2019
"""(versioned) Search for pattern in specfic file.
2022
self.make_branch_and_tree(wd)
2024
lp = 'foo is foobar'
2025
self._mk_versioned_file('file0.txt', line_prefix=lp, total_lines=1)
2027
# prepare colored result
2028
foo = color_string('foo', fg=FG.BOLD_RED)
2029
res = (FG.MAGENTA + 'file0.txt'
2030
+ self._rev_sep + '1' + self._sep
2031
+ foo + ' is ' + foo + 'bar1' + '\n')
2032
txt_res = 'file0.txt~1:foo is foobar1\n'
2034
nres = (FG.MAGENTA + 'file0.txt'
2035
+ self._rev_sep + '1' + self._sep + '1' + self._sep
2036
+ foo + ' is ' + foo + 'bar1' + '\n')
2038
out, err = self.run_bzr(['grep', '--color',
2039
'always', '-r', '1', 'foo'])
2040
self.assertEqual(out, res)
2041
self.assertEqual(len(out.splitlines()), 1)
2043
# auto should produce plain text result
2044
# as stdout is redireched here.
2045
out, err = self.run_bzr(['grep', '--color',
2046
'auto', '-r', '1', 'foo'])
2047
self.assertEqual(out, txt_res)
2048
self.assertEqual(len(out.splitlines()), 1)
2050
out, err = self.run_bzr(['grep', '-i', '--color',
2051
'always', '-r', '1', 'FOO'])
2052
self.assertEqual(out, res)
2053
self.assertEqual(len(out.splitlines()), 1)
2055
out, err = self.run_bzr(['grep', '--color',
2056
'always', '-r', '1', 'f.o'])
2057
self.assertEqual(out, res)
2058
self.assertEqual(len(out.splitlines()), 1)
2060
out, err = self.run_bzr(['grep', '-i', '--color',
2061
'always', '-r', '1', 'F.O'])
2062
self.assertEqual(out, res)
2063
self.assertEqual(len(out.splitlines()), 1)
2065
out, err = self.run_bzr(['grep', '-n', '--color',
2066
'always', '-r', '1', 'foo'])
2067
self.assertEqual(out, nres)
2068
self.assertEqual(len(out.splitlines()), 1)
2070
out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2071
'always', '-r', '1', 'FOO'])
2072
self.assertEqual(out, nres)
2073
self.assertEqual(len(out.splitlines()), 1)
2075
out, err = self.run_bzr(['grep', '-n', '--color',
2076
'always', '-r', '1', 'f.o'])
2077
self.assertEqual(out, nres)
2078
self.assertEqual(len(out.splitlines()), 1)
2080
out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2081
'always', '-r', '1', 'F.O'])
2082
self.assertEqual(out, nres)
2083
self.assertEqual(len(out.splitlines()), 1)
2085
def test_wtree_basic_file(self):
2086
"""(wtree) Search for pattern in specfic file.
2089
self.make_branch_and_tree(wd)
2091
lp = 'foo is foobar'
2092
self._mk_versioned_file('file0.txt', line_prefix=lp, total_lines=1)
2094
# prepare colored result
2095
foo = color_string('foo', fg=FG.BOLD_RED)
2096
res = (FG.MAGENTA + 'file0.txt'
2097
+ self._sep + foo + ' is ' + foo + 'bar1' + '\n')
2099
nres = (FG.MAGENTA + 'file0.txt'
2100
+ self._sep + '1' + self._sep
2101
+ foo + ' is ' + foo + 'bar1' + '\n')
2103
out, err = self.run_bzr(['grep', '--color',
2105
self.assertEqual(out, res)
2106
self.assertEqual(len(out.splitlines()), 1)
2108
out, err = self.run_bzr(['grep', '-i', '--color',
2110
self.assertEqual(out, res)
2111
self.assertEqual(len(out.splitlines()), 1)
2113
out, err = self.run_bzr(['grep', '--color',
2115
self.assertEqual(out, res)
2116
self.assertEqual(len(out.splitlines()), 1)
2118
out, err = self.run_bzr(['grep', '-i', '--color',
2120
self.assertEqual(out, res)
2121
self.assertEqual(len(out.splitlines()), 1)
2123
out, err = self.run_bzr(['grep', '-n', '--color',
2125
self.assertEqual(out, nres)
2126
self.assertEqual(len(out.splitlines()), 1)
2128
out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2130
self.assertEqual(out, nres)
2131
self.assertEqual(len(out.splitlines()), 1)
2133
out, err = self.run_bzr(['grep', '-n', '--color',
2135
self.assertEqual(out, nres)
2136
self.assertEqual(len(out.splitlines()), 1)
2138
out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2140
self.assertEqual(out, nres)
2141
self.assertEqual(len(out.splitlines()), 1)
2144
# copied from breezy.tests.blackbox.test_diff
2145
def subst_dates(string):
2146
"""Replace date strings with constant values."""
2147
return re.sub(r'\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} [-\+]\d{4}',
2148
'YYYY-MM-DD HH:MM:SS +ZZZZ', string)
2151
class TestGrepDiff(tests.TestCaseWithTransport):
2153
def make_example_branch(self):
2154
tree = self.make_branch_and_tree('.')
2155
self.build_tree_contents([
2156
('hello', b'foo\n'),
2157
('goodbye', b'baz\n')])
2159
tree.commit('setup')
2160
tree.add(['goodbye'])
2161
tree.commit('setup')
2164
def test_grep_diff_basic(self):
2165
"""grep -p basic test."""
2166
tree = self.make_example_branch()
2167
self.build_tree_contents([('hello', b'hello world!\n')])
2168
tree.commit('updated hello')
2169
out, err = self.run_bzr(['grep', '-p', 'hello'])
2170
self.assertEqual(err, '')
2171
self.assertEqualDiff(subst_dates(out), '''\
2173
=== modified file 'hello'
2174
--- hello YYYY-MM-DD HH:MM:SS +ZZZZ
2175
+++ hello YYYY-MM-DD HH:MM:SS +ZZZZ
2178
=== added file 'hello'
2179
--- hello YYYY-MM-DD HH:MM:SS +ZZZZ
2180
+++ hello YYYY-MM-DD HH:MM:SS +ZZZZ
2183
def test_grep_diff_revision(self):
2184
"""grep -p specific revision."""
2185
tree = self.make_example_branch()
2186
self.build_tree_contents([('hello', b'hello world!\n')])
2187
tree.commit('updated hello')
2188
out, err = self.run_bzr(['grep', '-p', '-r', '3', 'hello'])
2189
self.assertEqual(err, '')
2190
self.assertEqualDiff(subst_dates(out), '''\
2192
=== modified file 'hello'
2193
--- hello YYYY-MM-DD HH:MM:SS +ZZZZ
2194
+++ hello YYYY-MM-DD HH:MM:SS +ZZZZ
2198
def test_grep_diff_revision_range(self):
2199
"""grep -p revision range."""
2200
tree = self.make_example_branch()
2201
self.build_tree_contents([('hello', b'hello world!1\n')]) # rev 3
2203
self.build_tree_contents([('blah', b'hello world!2\n')]) # rev 4
2206
with open('hello', 'a') as f:
2207
f.write('hello world!3\n')
2208
#self.build_tree_contents([('hello', 'hello world!3\n')]) # rev 5
2210
out, err = self.run_bzr(['grep', '-p', '-r', '2..5', 'hello'])
2211
self.assertEqual(err, '')
2212
self.assertEqualDiff(subst_dates(out), '''\
2214
=== modified file 'hello'
2215
--- hello YYYY-MM-DD HH:MM:SS +ZZZZ
2216
+++ hello YYYY-MM-DD HH:MM:SS +ZZZZ
2219
=== added file 'blah'
2222
=== modified file 'hello'
2223
--- hello YYYY-MM-DD HH:MM:SS +ZZZZ
2224
+++ hello YYYY-MM-DD HH:MM:SS +ZZZZ
2228
def test_grep_diff_color(self):
2229
"""grep -p color test."""
2230
tree = self.make_example_branch()
2231
self.build_tree_contents([('hello', b'hello world!\n')])
2232
tree.commit('updated hello')
2233
out, err = self.run_bzr(['grep', '--diff', '-r', '3',
2234
'--color', 'always', 'hello'])
2235
self.assertEqual(err, '')
2236
revno = color_string('=== revno:3 ===', fg=FG.BOLD_BLUE) + '\n'
2237
filename = color_string(" === modified file 'hello'", fg=FG.BOLD_MAGENTA) + '\n'
2238
redhello = color_string('hello', fg=FG.BOLD_RED)
2240
--- hello YYYY-MM-DD HH:MM:SS +ZZZZ
2241
+++ hello YYYY-MM-DD HH:MM:SS +ZZZZ
2244
diffstr = diffstr.replace('hello', redhello)
2245
self.assertEqualDiff(subst_dates(out), revno + filename + diffstr)
2247
def test_grep_norevs(self):
2248
"""grep -p with zero revisions."""
2249
out, err = self.run_bzr(['init'])
2250
out, err = self.run_bzr(['grep', '--diff', 'foo'], 3)
2251
self.assertEqual(out, b'')
2252
self.assertContainsRe(err, b"ERROR:.*revision.* does not exist in branch")
added
removed
breezy/plugins/grep/test_grep.py
