1
# Copyright (C) 2010, 2011, 2012, 2016 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
import unicodedata as ud
21
from .. import tests, osutils
22
from .._termcolor import color_string, FG
24
from ..tests.features import (
25
UnicodeFilenameFeature,
28
# NOTE: As bzr-grep optimizes PATTERN search to -F/--fixed-string
29
# for patterns that are not alphanumeric+whitespace, we test grep
30
# specfically with patterns that have special characters so that
31
# regex path is tested. alphanumeric patterns test the -F path.
34
class GrepTestBase(tests.TestCaseWithTransport):
35
"""Base class for testing grep.
37
Provides support methods for creating directory and file revisions.
39
_reflags = re.MULTILINE | re.DOTALL
41
def _mk_file(self, path, line_prefix, total_lines, versioned):
43
for i in range(total_lines):
44
text += line_prefix + str(i + 1) + "\n"
46
with open(path, 'w') as f:
49
self.run_bzr(['add', path])
50
self.run_bzr(['ci', '-m', '"' + path + '"'])
52
def _update_file(self, path, text, checkin=True):
53
"""append text to file 'path' and check it in"""
54
with open(path, 'a') as f:
57
self.run_bzr(['ci', path, '-m', '"' + path + '"'])
59
def _mk_unknown_file(self, path, line_prefix='line', total_lines=10):
60
self._mk_file(path, line_prefix, total_lines, versioned=False)
62
def _mk_versioned_file(self, path, line_prefix='line', total_lines=10):
63
self._mk_file(path, line_prefix, total_lines, versioned=True)
65
def _mk_dir(self, path, versioned):
68
self.run_bzr(['add', path])
69
self.run_bzr(['ci', '-m', '"' + path + '"'])
71
def _mk_unknown_dir(self, path):
72
self._mk_dir(path, versioned=False)
74
def _mk_versioned_dir(self, path):
75
self._mk_dir(path, versioned=True)
78
class TestGrep(GrepTestBase):
79
"""Core functional tests for grep."""
81
def test_basic_unknown_file(self):
82
"""Search for pattern in specfic file.
84
If specified file is unknown, grep it anyway."""
86
self.make_branch_and_tree(wd)
88
self._mk_unknown_file('file0.txt')
90
out, err = self.run_bzr(['grep', 'line1', 'file0.txt'])
91
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
92
self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
94
out, err = self.run_bzr(['grep', 'line\\d+', 'file0.txt'])
95
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
96
self.assertEqual(len(out.splitlines()), 10)
98
# unknown file is not grepped unless explicitely specified
99
out, err = self.run_bzr(['grep', 'line1'])
100
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
101
self.assertEqual(len(out.splitlines()), 0)
103
# unknown file is not grepped unless explicitely specified
104
out, err = self.run_bzr(['grep', 'line1$'])
105
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
106
self.assertEqual(len(out.splitlines()), 0)
108
def test_ver_basic_file(self):
109
"""(versioned) Search for pattern in specfic file.
112
self.make_branch_and_tree(wd)
114
self._mk_versioned_file('file0.txt')
116
out, err = self.run_bzr(['grep', '-r', '1', 'line1', 'file0.txt'])
117
self.assertContainsRe(out, "file0.txt~1:line1",
118
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, "file0.txt~1:line1",
123
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",
129
flags=TestGrep._reflags)
130
self.assertEqual(len(out.splitlines()), 10)
132
def test_wtree_basic_file(self):
133
"""(wtree) Search for pattern in specfic file.
136
self.make_branch_and_tree(wd)
138
self._mk_versioned_file('file0.txt')
139
self._update_file('file0.txt', 'ABC\n', checkin=False)
141
out, err = self.run_bzr(['grep', 'ABC', 'file0.txt'])
142
self.assertContainsRe(out, "file0.txt:ABC", flags=TestGrep._reflags)
143
self.assertEqual(len(out.splitlines()), 1)
145
out, err = self.run_bzr(['grep', '[A-Z]{3}', 'file0.txt'])
146
self.assertContainsRe(out, "file0.txt:ABC", flags=TestGrep._reflags)
147
self.assertEqual(len(out.splitlines()), 1)
149
out, err = self.run_bzr(['grep', '-r', 'last:1', 'ABC', 'file0.txt'])
150
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
151
self.assertEqual(len(out.splitlines()), 0)
153
out, err = self.run_bzr(
154
['grep', '-r', 'last:1', '[A-Z]{3}', 'file0.txt'])
155
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
156
self.assertEqual(len(out.splitlines()), 0)
158
def test_ver_basic_include(self):
159
"""(versioned) Ensure that -I flag is respected.
162
self.make_branch_and_tree(wd)
164
self._mk_versioned_file('file0.aa')
165
self._mk_versioned_file('file0.bb')
166
self._mk_versioned_file('file0.cc')
168
out, err = self.run_bzr(['grep', '-r', 'last:1',
169
'--include', '*.aa', '--include', '*.bb', 'line1'])
170
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
171
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
172
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
173
# two lines each (line1, line10) from file0.aa and file0.bb
174
self.assertEqual(len(out.splitlines()), 4)
176
out, err = self.run_bzr(['grep', '-r', 'last:1',
177
'--include', '*.aa', '--include', '*.bb', 'line1$'])
178
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
179
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
180
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
181
# one lines each (line1) from file0.aa and file0.bb
182
self.assertEqual(len(out.splitlines()), 2)
184
out, err = self.run_bzr(['grep', '-r', 'last:1',
185
'-I', '*.aa', '-I', '*.bb', 'line1'])
186
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
187
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
188
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
189
# two lines each (line1, line10) from file0.aa and file0.bb
190
self.assertEqual(len(out.splitlines()), 4)
192
out, err = self.run_bzr(['grep', '-r', 'last:1',
193
'-I', '*.aa', '-I', '*.bb', 'line1$'])
194
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
195
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
196
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
197
# one lines each (line1) from file0.aa and file0.bb
198
self.assertEqual(len(out.splitlines()), 2)
200
def test_wtree_basic_include(self):
201
"""(wtree) Ensure that --include flag is respected.
204
self.make_branch_and_tree(wd)
206
self._mk_versioned_file('file0.aa')
207
self._mk_versioned_file('file0.bb')
208
self._mk_versioned_file('file0.cc')
210
out, err = self.run_bzr(['grep', '--include', '*.aa',
211
'--include', '*.bb', 'line1'])
212
self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
213
self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
214
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
215
# two lines each (line1, line10) from file0.aa and file0.bb
216
self.assertEqual(len(out.splitlines()), 4)
218
out, err = self.run_bzr(['grep', '--include', '*.aa',
219
'--include', '*.bb', 'line1$'])
220
self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
221
self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
222
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
223
# one line each (line1) from file0.aa and file0.bb
224
self.assertEqual(len(out.splitlines()), 2)
226
def test_ver_basic_exclude(self):
227
"""(versioned) Ensure that --exclude flag is respected.
230
self.make_branch_and_tree(wd)
232
self._mk_versioned_file('file0.aa')
233
self._mk_versioned_file('file0.bb')
234
self._mk_versioned_file('file0.cc')
236
out, err = self.run_bzr(['grep', '-r', 'last:1',
237
'--exclude', '*.cc', 'line1'])
238
self.assertContainsRe(out, "file0.aa~.:line1$",
239
flags=TestGrep._reflags)
240
self.assertContainsRe(out, "file0.bb~.:line1$",
241
flags=TestGrep._reflags)
242
self.assertContainsRe(out, "file0.aa~.:line10",
243
flags=TestGrep._reflags)
244
self.assertContainsRe(out, "file0.bb~.:line10",
245
flags=TestGrep._reflags)
246
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
247
# two lines each (line1, line10) from file0.aa and file0.bb
248
self.assertEqual(len(out.splitlines()), 4)
250
out, err = self.run_bzr(['grep', '-r', 'last:1',
251
'--exclude', '*.cc', 'line1$'])
252
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
253
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
254
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
255
# one line each (line1) from file0.aa and file0.bb
256
self.assertEqual(len(out.splitlines()), 2)
258
out, err = self.run_bzr(['grep', '-r', 'last:1',
259
'-X', '*.cc', 'line1'])
260
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
261
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
262
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
263
# two lines each (line1, line10) from file0.aa and file0.bb
264
self.assertEqual(len(out.splitlines()), 4)
266
def test_wtree_basic_exclude(self):
267
"""(wtree) Ensure that --exclude flag is respected.
270
self.make_branch_and_tree(wd)
272
self._mk_versioned_file('file0.aa')
273
self._mk_versioned_file('file0.bb')
274
self._mk_versioned_file('file0.cc')
276
out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'line1'])
277
self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
278
self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
279
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
280
# two lines each (line1, line10) from file0.aa and file0.bb
281
self.assertEqual(len(out.splitlines()), 4)
283
out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'lin.1$'])
284
self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
285
self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
286
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
287
# one line each (line1) from file0.aa and file0.bb
288
self.assertEqual(len(out.splitlines()), 2)
290
def test_ver_multiple_files(self):
291
"""(versioned) Search for pattern in multiple files.
294
self.make_branch_and_tree(wd)
296
self._mk_versioned_file('file0.txt', total_lines=2)
297
self._mk_versioned_file('file1.txt', total_lines=2)
298
self._mk_versioned_file('file2.txt', total_lines=2)
300
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line[1-2]$'])
301
self.assertContainsRe(out, "file0.txt~.:line1",
302
flags=TestGrep._reflags)
303
self.assertContainsRe(out, "file0.txt~.:line2",
304
flags=TestGrep._reflags)
305
self.assertContainsRe(out, "file1.txt~.:line1",
306
flags=TestGrep._reflags)
307
self.assertContainsRe(out, "file1.txt~.:line2",
308
flags=TestGrep._reflags)
309
self.assertContainsRe(out, "file2.txt~.:line1",
310
flags=TestGrep._reflags)
311
self.assertContainsRe(out, "file2.txt~.:line2",
312
flags=TestGrep._reflags)
313
self.assertEqual(len(out.splitlines()), 6)
315
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line'])
316
self.assertContainsRe(out, "file0.txt~.:line1",
317
flags=TestGrep._reflags)
318
self.assertContainsRe(out, "file0.txt~.:line2",
319
flags=TestGrep._reflags)
320
self.assertContainsRe(out, "file1.txt~.:line1",
321
flags=TestGrep._reflags)
322
self.assertContainsRe(out, "file1.txt~.:line2",
323
flags=TestGrep._reflags)
324
self.assertContainsRe(out, "file2.txt~.:line1",
325
flags=TestGrep._reflags)
326
self.assertContainsRe(out, "file2.txt~.:line2",
327
flags=TestGrep._reflags)
328
self.assertEqual(len(out.splitlines()), 6)
330
def test_multiple_wtree_files(self):
331
"""(wtree) Search for pattern in multiple files in working tree.
334
self.make_branch_and_tree(wd)
336
self._mk_versioned_file('file0.txt', total_lines=2)
337
self._mk_versioned_file('file1.txt', total_lines=2)
338
self._mk_versioned_file('file2.txt', total_lines=2)
339
self._update_file('file0.txt', 'HELLO\n', checkin=False)
340
self._update_file('file1.txt', 'HELLO\n', checkin=True)
341
self._update_file('file2.txt', 'HELLO\n', checkin=False)
343
out, err = self.run_bzr(['grep', 'HELLO',
344
'file0.txt', 'file1.txt', 'file2.txt'])
346
self.assertContainsRe(out, "file0.txt:HELLO", flags=TestGrep._reflags)
347
self.assertContainsRe(out, "file1.txt:HELLO", flags=TestGrep._reflags)
348
self.assertContainsRe(out, "file2.txt:HELLO", flags=TestGrep._reflags)
349
self.assertEqual(len(out.splitlines()), 3)
351
out, err = self.run_bzr(['grep', 'HELLO', '-r', 'last:1',
352
'file0.txt', 'file1.txt', 'file2.txt'])
354
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
355
self.assertContainsRe(out, "file1.txt~.:HELLO",
356
flags=TestGrep._reflags)
357
self.assertNotContainsRe(out, "file2.txt", flags=TestGrep._reflags)
358
self.assertEqual(len(out.splitlines()), 1)
360
out, err = self.run_bzr(['grep', 'HE..O',
361
'file0.txt', 'file1.txt', 'file2.txt'])
363
self.assertContainsRe(out, "file0.txt:HELLO", flags=TestGrep._reflags)
364
self.assertContainsRe(out, "file1.txt:HELLO", flags=TestGrep._reflags)
365
self.assertContainsRe(out, "file2.txt:HELLO", flags=TestGrep._reflags)
366
self.assertEqual(len(out.splitlines()), 3)
368
out, err = self.run_bzr(['grep', 'HE..O', '-r', 'last:1',
369
'file0.txt', 'file1.txt', 'file2.txt'])
371
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
372
self.assertContainsRe(out, "file1.txt~.:HELLO",
373
flags=TestGrep._reflags)
374
self.assertNotContainsRe(out, "file2.txt", flags=TestGrep._reflags)
375
self.assertEqual(len(out.splitlines()), 1)
377
def test_ver_null_option(self):
378
"""(versioned) --null option should use NUL instead of newline.
381
self.make_branch_and_tree(wd)
383
self._mk_versioned_file('file0.txt', total_lines=3)
386
u'NFC', u"file0.txt~1:line1\0file0.txt~1:line2\0file0.txt~1:line3\0")
388
out, err = self.run_bzr(
389
['grep', '-r', 'last:1', '--null', 'line[1-3]'])
390
nout = ud.normalize(u'NFC', out)
391
self.assertEqual(nout, nref)
392
self.assertEqual(len(out.splitlines()), 1)
394
out, err = self.run_bzr(['grep', '-r', 'last:1', '-Z', 'line[1-3]'])
395
nout = ud.normalize(u'NFC', out)
396
self.assertEqual(nout, nref)
397
self.assertEqual(len(out.splitlines()), 1)
399
out, err = self.run_bzr(['grep', '-r', 'last:1', '--null', 'line'])
400
nout = ud.normalize(u'NFC', out)
401
self.assertEqual(nout, nref)
402
self.assertEqual(len(out.splitlines()), 1)
404
def test_wtree_null_option(self):
405
"""(wtree) --null option should use NUL instead of newline.
408
self.make_branch_and_tree(wd)
410
self._mk_versioned_file('file0.txt', total_lines=3)
412
out, err = self.run_bzr(['grep', '--null', 'line[1-3]'])
414
out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
415
self.assertEqual(len(out.splitlines()), 1)
417
out, err = self.run_bzr(['grep', '-Z', 'line[1-3]'])
419
out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
420
self.assertEqual(len(out.splitlines()), 1)
422
out, err = self.run_bzr(['grep', '-Z', 'line'])
424
out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
425
self.assertEqual(len(out.splitlines()), 1)
427
def test_versioned_file_in_dir_no_recursive(self):
428
"""(versioned) Should not recurse with --no-recursive"""
430
self.make_branch_and_tree(wd)
432
self._mk_versioned_file('fileX.txt', line_prefix='lin')
433
self._mk_versioned_dir('dir0')
434
self._mk_versioned_file('dir0/file0.txt')
436
out, err = self.run_bzr(
437
['grep', '-r', 'last:1', '--no-recursive', 'line1'])
438
self.assertNotContainsRe(
439
out, "file0.txt~.:line1", flags=TestGrep._reflags)
440
self.assertEqual(len(out.splitlines()), 0)
442
out, err = self.run_bzr(
443
['grep', '-r', 'last:1', '--no-recursive', 'line1$'])
444
self.assertNotContainsRe(
445
out, "file0.txt~.:line1", flags=TestGrep._reflags)
446
self.assertEqual(len(out.splitlines()), 0)
448
def test_wtree_file_in_dir_no_recursive(self):
449
"""(wtree) Should not recurse with --no-recursive"""
451
self.make_branch_and_tree(wd)
453
self._mk_versioned_file('fileX.txt', line_prefix='lin')
454
self._mk_versioned_dir('dir0')
455
self._mk_versioned_file('dir0/file0.txt')
457
out, err = self.run_bzr(['grep', '--no-recursive', 'line1'])
458
self.assertNotContainsRe(
459
out, "file0.txt:line1", flags=TestGrep._reflags)
460
self.assertEqual(len(out.splitlines()), 0)
462
out, err = self.run_bzr(['grep', '--no-recursive', 'lin.1'])
463
self.assertNotContainsRe(
464
out, "file0.txt:line1", flags=TestGrep._reflags)
465
self.assertEqual(len(out.splitlines()), 0)
467
def test_versioned_file_in_dir_recurse(self):
468
"""(versioned) Should recurse by default.
471
self.make_branch_and_tree(wd)
473
self._mk_versioned_dir('dir0')
474
self._mk_versioned_file('dir0/file0.txt')
476
out, err = self.run_bzr(['grep', '-r', '-1', '.i.e1'])
477
self.assertContainsRe(
478
out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
479
# find line1 and line10
480
self.assertEqual(len(out.splitlines()), 2)
482
out, err = self.run_bzr(['grep', '-r', '-1', 'line1'])
483
self.assertContainsRe(
484
out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
485
# find line1 and line10
486
self.assertEqual(len(out.splitlines()), 2)
488
def test_wtree_file_in_dir_recurse(self):
489
"""(wtree) Should recurse by default.
492
self.make_branch_and_tree(wd)
494
self._mk_versioned_dir('dir0')
495
self._mk_versioned_file('dir0/file0.txt')
497
out, err = self.run_bzr(['grep', 'line1'])
498
self.assertContainsRe(out, "^dir0/file0.txt:line1",
499
flags=TestGrep._reflags)
500
# find line1 and line10
501
self.assertEqual(len(out.splitlines()), 2)
503
out, err = self.run_bzr(['grep', 'lin.1'])
504
self.assertContainsRe(out, "^dir0/file0.txt:line1",
505
flags=TestGrep._reflags)
506
# find line1 and line10
507
self.assertEqual(len(out.splitlines()), 2)
509
def test_versioned_file_within_dir(self):
510
"""(versioned) Search for pattern while in nested dir.
513
self.make_branch_and_tree(wd)
515
self._mk_versioned_dir('dir0')
516
self._mk_versioned_file('dir0/file0.txt')
519
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
520
self.assertContainsRe(out, "^file0.txt~.:line1",
521
flags=TestGrep._reflags)
522
# finds line1 and line10
523
self.assertEqual(len(out.splitlines()), 2)
525
out, err = self.run_bzr(['grep', '-r', 'last:1', '.i.e1'])
526
self.assertContainsRe(out, "^file0.txt~.:line1",
527
flags=TestGrep._reflags)
528
# finds line1 and line10
529
self.assertEqual(len(out.splitlines()), 2)
531
def test_versioned_include_file_within_dir(self):
532
"""(versioned) Ensure --include is respected with file within dir.
535
self.make_branch_and_tree(wd)
537
self._mk_versioned_dir('dir0') # revno 1
538
self._mk_versioned_file('dir0/file0.txt') # revno 2
539
self._mk_versioned_file('dir0/file1.aa') # revno 3
540
self._update_file('dir0/file1.aa', 'hello\n') # revno 4
541
self._update_file('dir0/file0.txt', 'hello\n') # revno 5
544
out, err = self.run_bzr(['grep', '-r', 'last:1',
545
'--include', '*.aa', 'line1'])
546
self.assertContainsRe(out, "^file1.aa~5:line1$",
547
flags=TestGrep._reflags)
548
self.assertContainsRe(out, "^file1.aa~5:line10$",
549
flags=TestGrep._reflags)
550
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
551
# finds line1 and line10
552
self.assertEqual(len(out.splitlines()), 2)
554
out, err = self.run_bzr(['grep', '-r', 'last:2..last:1',
555
'--include', '*.aa', 'line1'])
556
self.assertContainsRe(out, "^file1.aa~4:line1$",
557
flags=TestGrep._reflags)
558
self.assertContainsRe(out, "^file1.aa~4:line10$",
559
flags=TestGrep._reflags)
560
self.assertContainsRe(out, "^file1.aa~5:line1$",
561
flags=TestGrep._reflags)
562
self.assertContainsRe(out, "^file1.aa~5:line10$",
563
flags=TestGrep._reflags)
564
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
565
# finds line1 and line10 over two revisions
566
self.assertEqual(len(out.splitlines()), 4)
568
out, err = self.run_bzr(['grep', '-r', 'last:1',
569
'--include', '*.aa', 'lin.1'])
570
self.assertContainsRe(out, "^file1.aa~5:line1$",
571
flags=TestGrep._reflags)
572
self.assertContainsRe(out, "^file1.aa~5:line10$",
573
flags=TestGrep._reflags)
574
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
575
# finds line1 and line10
576
self.assertEqual(len(out.splitlines()), 2)
578
out, err = self.run_bzr(['grep', '-r', 'last:3..last:1',
579
'--include', '*.aa', 'lin.1'])
580
self.assertContainsRe(out, "^file1.aa~3:line1$",
581
flags=TestGrep._reflags)
582
self.assertContainsRe(out, "^file1.aa~4:line1$",
583
flags=TestGrep._reflags)
584
self.assertContainsRe(out, "^file1.aa~5:line1$",
585
flags=TestGrep._reflags)
586
self.assertContainsRe(out, "^file1.aa~3:line10$",
587
flags=TestGrep._reflags)
588
self.assertContainsRe(out, "^file1.aa~4:line10$",
589
flags=TestGrep._reflags)
590
self.assertContainsRe(out, "^file1.aa~5:line10$",
591
flags=TestGrep._reflags)
592
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
593
# finds line1 and line10 over 3 revisions
594
self.assertEqual(len(out.splitlines()), 6)
596
def test_versioned_exclude_file_within_dir(self):
597
"""(versioned) Ensure --exclude 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', '-r', 'last:1',
608
'--exclude', '*.txt', 'line1'])
609
self.assertContainsRe(out, "^file1.aa~.:line1",
610
flags=TestGrep._reflags)
611
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
612
# finds line1 and line10
613
self.assertEqual(len(out.splitlines()), 2)
615
out, err = self.run_bzr(['grep', '-r', 'last:1',
616
'--exclude', '*.txt', 'l[a-z]ne1'])
617
self.assertContainsRe(out, "^file1.aa~.:line1",
618
flags=TestGrep._reflags)
619
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
620
# finds line1 and line10
621
self.assertEqual(len(out.splitlines()), 2)
623
def test_wtree_file_within_dir(self):
624
"""(wtree) Search for pattern while in nested dir.
627
self.make_branch_and_tree(wd)
629
self._mk_versioned_dir('dir0')
630
self._mk_versioned_file('dir0/file0.txt')
633
out, err = self.run_bzr(['grep', 'line1'])
634
self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
635
# finds line1 and line10
636
self.assertEqual(len(out.splitlines()), 2)
638
out, err = self.run_bzr(['grep', 'l[aeiou]ne1'])
639
self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
640
# finds line1 and line10
641
self.assertEqual(len(out.splitlines()), 2)
643
def test_wtree_include_file_within_dir(self):
644
"""(wtree) Ensure --include is respected with file within dir.
647
self.make_branch_and_tree(wd)
649
self._mk_versioned_dir('dir0')
650
self._mk_versioned_file('dir0/file0.txt')
651
self._mk_versioned_file('dir0/file1.aa')
654
out, err = self.run_bzr(['grep', '--include', '*.aa', 'line1'])
655
self.assertContainsRe(out, "^file1.aa:line1", flags=TestGrep._reflags)
656
# finds line1 and line10
657
self.assertEqual(len(out.splitlines()), 2)
659
out, err = self.run_bzr(['grep', '--include', '*.aa', 'l[ixn]ne1'])
660
self.assertContainsRe(out, "^file1.aa:line1", flags=TestGrep._reflags)
661
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
662
# finds line1 and line10
663
self.assertEqual(len(out.splitlines()), 2)
665
def test_wtree_exclude_file_within_dir(self):
666
"""(wtree) Ensure --exclude is respected with file within dir.
669
self.make_branch_and_tree(wd)
671
self._mk_versioned_dir('dir0')
672
self._mk_versioned_file('dir0/file0.txt')
673
self._mk_versioned_file('dir0/file1.aa')
676
out, err = self.run_bzr(['grep', '--exclude', '*.txt', 'li.e1'])
677
self.assertContainsRe(out, "^file1.aa:line1$", flags=TestGrep._reflags)
678
self.assertContainsRe(out, "^file1.aa:line10$",
679
flags=TestGrep._reflags)
680
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
681
# finds line1 and line10
682
self.assertEqual(len(out.splitlines()), 2)
684
out, err = self.run_bzr(['grep', '--exclude', '*.txt', 'line1'])
685
self.assertContainsRe(out, "^file1.aa:line1$", flags=TestGrep._reflags)
686
self.assertContainsRe(out, "^file1.aa:line10$",
687
flags=TestGrep._reflags)
688
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
689
# finds line1 and line10
690
self.assertEqual(len(out.splitlines()), 2)
692
def test_versioned_include_from_outside_dir(self):
693
"""(versioned) Ensure --include is respected during recursive search.
696
self.make_branch_and_tree(wd)
699
self._mk_versioned_dir('dir0')
700
self._mk_versioned_file('dir0/file0.aa')
702
self._mk_versioned_dir('dir1')
703
self._mk_versioned_file('dir1/file1.bb')
705
self._mk_versioned_dir('dir2')
706
self._mk_versioned_file('dir2/file2.cc')
708
out, err = self.run_bzr(['grep', '-r', 'last:1',
709
'--include', '*.aa', '--include', '*.bb', 'l..e1'])
710
self.assertContainsRe(
711
out, "^dir0/file0.aa~.:line1$", flags=TestGrep._reflags)
712
self.assertContainsRe(
713
out, "^dir1/file1.bb~.:line1$", flags=TestGrep._reflags)
714
self.assertContainsRe(
715
out, "^dir0/file0.aa~.:line10$", flags=TestGrep._reflags)
716
self.assertContainsRe(
717
out, "^dir1/file1.bb~.:line10$", flags=TestGrep._reflags)
718
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
719
# finds line1 and line10
720
self.assertEqual(len(out.splitlines()), 4)
722
out, err = self.run_bzr(['grep', '-r', 'last:1',
723
'--include', '*.aa', '--include', '*.bb', 'line1'])
724
self.assertContainsRe(
725
out, "^dir0/file0.aa~.:line1$", flags=TestGrep._reflags)
726
self.assertContainsRe(
727
out, "^dir1/file1.bb~.:line1$", flags=TestGrep._reflags)
728
self.assertContainsRe(
729
out, "^dir0/file0.aa~.:line10$", flags=TestGrep._reflags)
730
self.assertContainsRe(
731
out, "^dir1/file1.bb~.:line10$", flags=TestGrep._reflags)
732
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
733
# finds line1 and line10
734
self.assertEqual(len(out.splitlines()), 4)
736
def test_wtree_include_from_outside_dir(self):
737
"""(wtree) Ensure --include 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', '--include', '*.aa',
753
'--include', '*.bb', 'l.n.1'])
754
self.assertContainsRe(out, "^dir0/file0.aa:line1$",
755
flags=TestGrep._reflags)
756
self.assertContainsRe(out, "^dir1/file1.bb:line1$",
757
flags=TestGrep._reflags)
758
self.assertContainsRe(
759
out, "^dir0/file0.aa:line10$", flags=TestGrep._reflags)
760
self.assertContainsRe(
761
out, "^dir1/file1.bb:line10$", flags=TestGrep._reflags)
762
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
763
# finds line1 and line10
764
self.assertEqual(len(out.splitlines()), 4)
766
out, err = self.run_bzr(['grep', '--include', '*.aa',
767
'--include', '*.bb', 'line1'])
768
self.assertContainsRe(out, "^dir0/file0.aa:line1$",
769
flags=TestGrep._reflags)
770
self.assertContainsRe(out, "^dir1/file1.bb:line1$",
771
flags=TestGrep._reflags)
772
self.assertContainsRe(
773
out, "^dir0/file0.aa:line10$", flags=TestGrep._reflags)
774
self.assertContainsRe(
775
out, "^dir1/file1.bb:line10$", flags=TestGrep._reflags)
776
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
777
# finds line1 and line10
778
self.assertEqual(len(out.splitlines()), 4)
780
def test_versioned_exclude_from_outside_dir(self):
781
"""(versioned) Ensure --exclude is respected during recursive search.
784
self.make_branch_and_tree(wd)
787
self._mk_versioned_dir('dir0')
788
self._mk_versioned_file('dir0/file0.aa')
790
self._mk_versioned_dir('dir1')
791
self._mk_versioned_file('dir1/file1.bb')
793
self._mk_versioned_dir('dir2')
794
self._mk_versioned_file('dir2/file2.cc')
796
out, err = self.run_bzr(['grep', '-r', 'last:1',
797
'--exclude', '*.cc', 'l..e1'])
798
self.assertContainsRe(
799
out, "^dir0/file0.aa~.:line1", flags=TestGrep._reflags)
800
self.assertContainsRe(
801
out, "^dir1/file1.bb~.:line1", flags=TestGrep._reflags)
802
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
804
out, err = self.run_bzr(['grep', '-r', 'last:1',
805
'--exclude', '*.cc', 'line1'])
806
self.assertContainsRe(
807
out, "^dir0/file0.aa~.:line1", flags=TestGrep._reflags)
808
self.assertContainsRe(
809
out, "^dir1/file1.bb~.:line1", flags=TestGrep._reflags)
810
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
812
def test_wtree_exclude_from_outside_dir(self):
813
"""(wtree) Ensure --exclude is respected during recursive search.
816
self.make_branch_and_tree(wd)
819
self._mk_versioned_dir('dir0')
820
self._mk_versioned_file('dir0/file0.aa')
822
self._mk_versioned_dir('dir1')
823
self._mk_versioned_file('dir1/file1.bb')
825
self._mk_versioned_dir('dir2')
826
self._mk_versioned_file('dir2/file2.cc')
828
out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'l[hijk]ne1'])
829
self.assertContainsRe(out, "^dir0/file0.aa:line1",
830
flags=TestGrep._reflags)
831
self.assertContainsRe(out, "^dir1/file1.bb:line1",
832
flags=TestGrep._reflags)
833
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
835
out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'line1'])
836
self.assertContainsRe(out, "^dir0/file0.aa:line1",
837
flags=TestGrep._reflags)
838
self.assertContainsRe(out, "^dir1/file1.bb:line1",
839
flags=TestGrep._reflags)
840
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
842
def test_workingtree_files_from_outside_dir(self):
843
"""(wtree) Grep for pattern with dirs passed as argument.
846
self.make_branch_and_tree(wd)
849
self._mk_versioned_dir('dir0')
850
self._mk_versioned_file('dir0/file0.txt')
852
self._mk_versioned_dir('dir1')
853
self._mk_versioned_file('dir1/file1.txt')
855
out, err = self.run_bzr(['grep', 'l[aeiou]ne1', 'dir0', 'dir1'])
856
self.assertContainsRe(out, "^dir0/file0.txt:line1",
857
flags=TestGrep._reflags)
858
self.assertContainsRe(out, "^dir1/file1.txt:line1",
859
flags=TestGrep._reflags)
861
out, err = self.run_bzr(['grep', 'line1', 'dir0', 'dir1'])
862
self.assertContainsRe(out, "^dir0/file0.txt:line1",
863
flags=TestGrep._reflags)
864
self.assertContainsRe(out, "^dir1/file1.txt:line1",
865
flags=TestGrep._reflags)
867
def test_versioned_files_from_outside_dir(self):
868
"""(versioned) Grep for pattern with dirs passed as argument.
871
self.make_branch_and_tree(wd)
874
self._mk_versioned_dir('dir0')
875
self._mk_versioned_file('dir0/file0.txt')
877
self._mk_versioned_dir('dir1')
878
self._mk_versioned_file('dir1/file1.txt')
880
out, err = self.run_bzr(
881
['grep', '-r', 'last:1', '.ine1', 'dir0', 'dir1'])
882
self.assertContainsRe(
883
out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
884
self.assertContainsRe(
885
out, "^dir1/file1.txt~.:line1", flags=TestGrep._reflags)
887
out, err = self.run_bzr(
888
['grep', '-r', 'last:1', 'line1', 'dir0', 'dir1'])
889
self.assertContainsRe(
890
out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
891
self.assertContainsRe(
892
out, "^dir1/file1.txt~.:line1", flags=TestGrep._reflags)
894
def test_wtree_files_from_outside_dir(self):
895
"""(wtree) Grep for pattern with dirs passed as argument.
898
self.make_branch_and_tree(wd)
901
self._mk_versioned_dir('dir0')
902
self._mk_versioned_file('dir0/file0.txt')
904
self._mk_versioned_dir('dir1')
905
self._mk_versioned_file('dir1/file1.txt')
907
out, err = self.run_bzr(['grep', 'li.e1', 'dir0', 'dir1'])
908
self.assertContainsRe(out, "^dir0/file0.txt:line1",
909
flags=TestGrep._reflags)
910
self.assertContainsRe(out, "^dir1/file1.txt:line1",
911
flags=TestGrep._reflags)
913
out, err = self.run_bzr(['grep', 'line1', 'dir0', 'dir1'])
914
self.assertContainsRe(out, "^dir0/file0.txt:line1",
915
flags=TestGrep._reflags)
916
self.assertContainsRe(out, "^dir1/file1.txt:line1",
917
flags=TestGrep._reflags)
919
def test_versioned_files_from_outside_two_dirs(self):
920
"""(versioned) Grep for pattern with two levels of nested dir.
923
self.make_branch_and_tree(wd)
926
self._mk_versioned_dir('dir0')
927
self._mk_versioned_file('dir0/file0.txt')
929
self._mk_versioned_dir('dir1')
930
self._mk_versioned_file('dir1/file1.txt')
932
self._mk_versioned_dir('dir0/dir00')
933
self._mk_versioned_file('dir0/dir00/file0.txt')
935
out, err = self.run_bzr(
936
['grep', '-r', 'last:1', 'l.ne1', 'dir0/dir00'])
937
self.assertContainsRe(
938
out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
940
out, err = self.run_bzr(['grep', '-r', 'last:1', 'l.ne1'])
941
self.assertContainsRe(
942
out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
944
out, err = self.run_bzr(
945
['grep', '-r', 'last:1', 'line1', 'dir0/dir00'])
946
self.assertContainsRe(
947
out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
949
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
950
self.assertContainsRe(
951
out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
953
def test_wtree_files_from_outside_two_dirs(self):
954
"""(wtree) Grep for pattern with two levels of nested dir.
957
self.make_branch_and_tree(wd)
960
self._mk_versioned_dir('dir0')
961
self._mk_versioned_file('dir0/file0.txt')
963
self._mk_versioned_dir('dir1')
964
self._mk_versioned_file('dir1/file1.txt')
966
self._mk_versioned_dir('dir0/dir00')
967
self._mk_versioned_file('dir0/dir00/file0.txt')
969
out, err = self.run_bzr(['grep', 'lin.1', 'dir0/dir00'])
970
self.assertContainsRe(
971
out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
973
out, err = self.run_bzr(['grep', 'li.e1'])
974
self.assertContainsRe(
975
out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
977
out, err = self.run_bzr(['grep', 'line1', 'dir0/dir00'])
978
self.assertContainsRe(
979
out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
981
out, err = self.run_bzr(['grep', 'line1'])
982
self.assertContainsRe(
983
out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
985
def test_versioned_file_within_dir_two_levels(self):
986
"""(versioned) Search for pattern while in nested dir (two levels).
989
self.make_branch_and_tree(wd)
991
self._mk_versioned_dir('dir0')
992
self._mk_versioned_dir('dir0/dir1')
993
self._mk_versioned_file('dir0/dir1/file0.txt')
996
out, err = self.run_bzr(['grep', '-r', 'last:1', '.ine1'])
997
self.assertContainsRe(
998
out, "^dir1/file0.txt~.:line1", flags=TestGrep._reflags)
1000
out, err = self.run_bzr(
1001
['grep', '-r', 'last:1', '--from-root', 'l.ne1'])
1002
self.assertContainsRe(
1003
out, "^dir0/dir1/file0.txt~.:line1", flags=TestGrep._reflags)
1005
out, err = self.run_bzr(
1006
['grep', '-r', 'last:1', '--no-recursive', 'line1'])
1007
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1009
out, err = self.run_bzr(['grep', '-r', 'last:1', 'lin.1'])
1010
self.assertContainsRe(
1011
out, "^dir1/file0.txt~.:line1", flags=TestGrep._reflags)
1013
out, err = self.run_bzr(
1014
['grep', '-r', 'last:1', '--from-root', 'line1'])
1015
self.assertContainsRe(
1016
out, "^dir0/dir1/file0.txt~.:line1", flags=TestGrep._reflags)
1018
out, err = self.run_bzr(
1019
['grep', '-r', 'last:1', '--no-recursive', 'line1'])
1020
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1021
self.assertEqual(len(out.splitlines()), 0)
1023
def test_wtree_file_within_dir_two_levels(self):
1024
"""(wtree) Search for pattern while in nested dir (two levels).
1027
self.make_branch_and_tree(wd)
1029
self._mk_versioned_dir('dir0')
1030
self._mk_versioned_dir('dir0/dir1')
1031
self._mk_versioned_file('dir0/dir1/file0.txt')
1034
out, err = self.run_bzr(['grep', 'l[hij]ne1'])
1035
self.assertContainsRe(out, "^dir1/file0.txt:line1",
1036
flags=TestGrep._reflags)
1038
out, err = self.run_bzr(['grep', '--from-root', 'l.ne1'])
1039
self.assertContainsRe(
1040
out, "^dir0/dir1/file0.txt:line1", flags=TestGrep._reflags)
1042
out, err = self.run_bzr(['grep', '--no-recursive', 'lin.1'])
1043
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1045
out, err = self.run_bzr(['grep', 'line1'])
1046
self.assertContainsRe(out, "^dir1/file0.txt:line1",
1047
flags=TestGrep._reflags)
1049
out, err = self.run_bzr(['grep', '--from-root', 'line1'])
1050
self.assertContainsRe(
1051
out, "^dir0/dir1/file0.txt:line1", flags=TestGrep._reflags)
1053
out, err = self.run_bzr(['grep', '--no-recursive', 'line1'])
1054
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1056
def test_versioned_ignore_case_no_match(self):
1057
"""(versioned) Match fails without --ignore-case.
1060
self.make_branch_and_tree(wd)
1062
self._mk_versioned_file('file0.txt')
1064
out, err = self.run_bzr(['grep', '-r', 'last:1', 'LinE1', 'file0.txt'])
1065
self.assertNotContainsRe(
1066
out, "file0.txt~.:line1", flags=TestGrep._reflags)
1068
out, err = self.run_bzr(['grep', '-r', 'last:1', 'Li.E1', 'file0.txt'])
1069
self.assertNotContainsRe(
1070
out, "file0.txt~.:line1", flags=TestGrep._reflags)
1072
def test_wtree_ignore_case_no_match(self):
1073
"""(wtree) Match fails without --ignore-case.
1076
self.make_branch_and_tree(wd)
1078
self._mk_versioned_file('file0.txt')
1080
out, err = self.run_bzr(['grep', 'LinE1', 'file0.txt'])
1081
self.assertNotContainsRe(
1082
out, "file0.txt:line1", flags=TestGrep._reflags)
1084
out, err = self.run_bzr(['grep', '.inE1', 'file0.txt'])
1085
self.assertNotContainsRe(
1086
out, "file0.txt:line1", flags=TestGrep._reflags)
1088
def test_versioned_ignore_case_match(self):
1089
"""(versioned) Match fails without --ignore-case.
1092
self.make_branch_and_tree(wd)
1094
self._mk_versioned_file('file0.txt')
1096
out, err = self.run_bzr(['grep', '-r', 'last:1',
1097
'-i', 'Li.E1', 'file0.txt'])
1098
self.assertContainsRe(out, "file0.txt~.:line1",
1099
flags=TestGrep._reflags)
1101
out, err = self.run_bzr(['grep', '-r', 'last:1',
1102
'-i', 'LinE1', 'file0.txt'])
1103
self.assertContainsRe(out, "file0.txt~.:line1",
1104
flags=TestGrep._reflags)
1106
out, err = self.run_bzr(['grep', '-r', 'last:1',
1107
'--ignore-case', 'LinE1', 'file0.txt'])
1108
self.assertContainsRe(out, "^file0.txt~.:line1",
1109
flags=TestGrep._reflags)
1111
def test_wtree_ignore_case_match(self):
1112
"""(wtree) Match fails without --ignore-case.
1115
self.make_branch_and_tree(wd)
1117
self._mk_versioned_file('file0.txt')
1119
out, err = self.run_bzr(['grep', '-i', 'LinE1', 'file0.txt'])
1120
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
1122
out, err = self.run_bzr(
1123
['grep', '--ignore-case', 'LinE1', 'file0.txt'])
1124
self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
1126
out, err = self.run_bzr(
1127
['grep', '--ignore-case', 'Li.E1', 'file0.txt'])
1128
self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
1130
def test_versioned_from_root_fail(self):
1131
"""(versioned) Match should fail without --from-root.
1134
self.make_branch_and_tree(wd)
1136
self._mk_versioned_file('file0.txt')
1137
self._mk_versioned_dir('dir0')
1140
out, err = self.run_bzr(['grep', '-r', 'last:1', 'li.e1'])
1141
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1143
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
1144
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1146
def test_wtree_from_root_fail(self):
1147
"""(wtree) Match should fail without --from-root.
1150
self.make_branch_and_tree(wd)
1152
self._mk_versioned_file('file0.txt')
1153
self._mk_versioned_dir('dir0')
1156
out, err = self.run_bzr(['grep', 'line1'])
1157
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1159
out, err = self.run_bzr(['grep', 'li.e1'])
1160
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1162
def test_versioned_from_root_pass(self):
1163
"""(versioned) Match pass with --from-root.
1166
self.make_branch_and_tree(wd)
1168
self._mk_versioned_file('file0.txt')
1169
self._mk_versioned_dir('dir0')
1172
out, err = self.run_bzr(['grep', '-r', 'last:1',
1173
'--from-root', 'l.ne1'])
1174
self.assertContainsRe(out, "file0.txt~.:line1",
1175
flags=TestGrep._reflags)
1177
out, err = self.run_bzr(['grep', '-r', 'last:1',
1178
'--from-root', 'line1'])
1179
self.assertContainsRe(out, "file0.txt~.:line1",
1180
flags=TestGrep._reflags)
1182
def test_wtree_from_root_pass(self):
1183
"""(wtree) Match pass with --from-root.
1186
self.make_branch_and_tree(wd)
1188
self._mk_versioned_file('file0.txt')
1189
self._mk_versioned_dir('dir0')
1192
out, err = self.run_bzr(['grep', '--from-root', 'lin.1'])
1193
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
1195
out, err = self.run_bzr(['grep', '--from-root', 'line1'])
1196
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
1198
def test_versioned_with_line_number(self):
1199
"""(versioned) Search for pattern with --line-number.
1202
self.make_branch_and_tree(wd)
1204
self._mk_versioned_file('file0.txt')
1206
out, err = self.run_bzr(['grep', '-r', 'last:1',
1207
'--line-number', 'li.e3', 'file0.txt'])
1208
self.assertContainsRe(out, "file0.txt~.:3:line3",
1209
flags=TestGrep._reflags)
1211
out, err = self.run_bzr(['grep', '-r', 'last:1',
1212
'--line-number', 'line3', 'file0.txt'])
1213
self.assertContainsRe(out, "file0.txt~.:3:line3",
1214
flags=TestGrep._reflags)
1216
out, err = self.run_bzr(['grep', '-r', 'last:1',
1217
'-n', 'line1', 'file0.txt'])
1218
self.assertContainsRe(out, "file0.txt~.:1:line1",
1219
flags=TestGrep._reflags)
1221
out, err = self.run_bzr(['grep', '-n', 'line[0-9]', 'file0.txt'])
1222
self.assertContainsRe(out, "file0.txt:3:line3",
1223
flags=TestGrep._reflags)
1225
def test_wtree_with_line_number(self):
1226
"""(wtree) Search for pattern with --line-number.
1229
self.make_branch_and_tree(wd)
1231
self._mk_versioned_file('file0.txt')
1233
out, err = self.run_bzr(
1234
['grep', '--line-number', 'line3', 'file0.txt'])
1235
self.assertContainsRe(out, "file0.txt:3:line3",
1236
flags=TestGrep._reflags)
1238
out, err = self.run_bzr(['grep', '-n', 'line1', 'file0.txt'])
1239
self.assertContainsRe(out, "file0.txt:1:line1",
1240
flags=TestGrep._reflags)
1242
out, err = self.run_bzr(['grep', '-n', '[hjkl]ine1', 'file0.txt'])
1243
self.assertContainsRe(out, "file0.txt:1:line1",
1244
flags=TestGrep._reflags)
1246
out, err = self.run_bzr(['grep', '-n', 'line[0-9]', 'file0.txt'])
1247
self.assertContainsRe(out, "file0.txt:3:line3",
1248
flags=TestGrep._reflags)
1250
def test_revno_basic_history_grep_file(self):
1251
"""Search for pattern in specific revision number in a file.
1255
self.make_branch_and_tree(wd)
1257
self._mk_versioned_file(fname, total_lines=0)
1258
self._update_file(fname, text="v2 text\n")
1259
self._update_file(fname, text="v3 text\n")
1260
self._update_file(fname, text="v4 text\n")
1262
# rev 2 should not have text 'v3'
1263
out, err = self.run_bzr(['grep', '-r', '2', 'v3', fname])
1264
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1266
# rev 3 should not have text 'v3'
1267
out, err = self.run_bzr(['grep', '-r', '3', 'v3', fname])
1268
self.assertContainsRe(out, "file0.txt~3:v3.*", flags=TestGrep._reflags)
1270
# rev 3 should not have text 'v3' with line number
1271
out, err = self.run_bzr(['grep', '-r', '3', '-n', 'v3', fname])
1272
self.assertContainsRe(out, "file0.txt~3:2:v3.*",
1273
flags=TestGrep._reflags)
1275
# rev 2 should not have text 'v3'
1276
out, err = self.run_bzr(['grep', '-r', '2', '[tuv]3', fname])
1277
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1279
# rev 3 should not have text 'v3'
1280
out, err = self.run_bzr(['grep', '-r', '3', '[tuv]3', fname])
1281
self.assertContainsRe(out, "file0.txt~3:v3.*", flags=TestGrep._reflags)
1283
# rev 3 should not have text 'v3' with line number
1284
out, err = self.run_bzr(['grep', '-r', '3', '-n', '[tuv]3', fname])
1285
self.assertContainsRe(out, "file0.txt~3:2:v3.*",
1286
flags=TestGrep._reflags)
1288
def test_revno_basic_history_grep_full(self):
1289
"""Search for pattern in specific revision number in a file.
1293
self.make_branch_and_tree(wd)
1295
self._mk_versioned_file(fname, total_lines=0) # rev1
1296
self._mk_versioned_file('file1.txt') # rev2
1297
self._update_file(fname, text="v3 text\n") # rev3
1298
self._update_file(fname, text="v4 text\n") # rev4
1299
self._update_file(fname, text="v5 text\n") # rev5
1301
# rev 2 should not have text 'v3'
1302
out, err = self.run_bzr(['grep', '-r', '2', 'v3'])
1303
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1305
# rev 3 should not have text 'v3'
1306
out, err = self.run_bzr(['grep', '-r', '3', 'v3'])
1307
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1309
# rev 3 should not have text 'v3' with line number
1310
out, err = self.run_bzr(['grep', '-r', '3', '-n', 'v3'])
1311
self.assertContainsRe(out, "file0.txt~3:1:v3", flags=TestGrep._reflags)
1313
# rev 2 should not have text 'v3'
1314
out, err = self.run_bzr(['grep', '-r', '2', '[tuv]3'])
1315
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1317
# rev 3 should not have text 'v3'
1318
out, err = self.run_bzr(['grep', '-r', '3', '[tuv]3'])
1319
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1321
# rev 3 should not have text 'v3' with line number
1322
out, err = self.run_bzr(['grep', '-r', '3', '-n', '[tuv]3'])
1323
self.assertContainsRe(out, "file0.txt~3:1:v3", flags=TestGrep._reflags)
1325
def test_revno_versioned_file_in_dir(self):
1326
"""Grep specific version of file withing dir.
1329
self.make_branch_and_tree(wd)
1331
self._mk_versioned_dir('dir0') # rev1
1332
self._mk_versioned_file('dir0/file0.txt') # rev2
1333
self._update_file('dir0/file0.txt', "v3 text\n") # rev3
1334
self._update_file('dir0/file0.txt', "v4 text\n") # rev4
1335
self._update_file('dir0/file0.txt', "v5 text\n") # rev5
1337
# v4 should not be present in revno 3
1338
out, err = self.run_bzr(['grep', '-r', 'last:3', 'v4'])
1339
self.assertNotContainsRe(
1340
out, "^dir0/file0.txt", flags=TestGrep._reflags)
1342
# v4 should be present in revno 4
1343
out, err = self.run_bzr(['grep', '-r', 'last:2', 'v4'])
1344
self.assertContainsRe(out, "^dir0/file0.txt~4:v4",
1345
flags=TestGrep._reflags)
1347
# v4 should not be present in revno 3
1348
out, err = self.run_bzr(['grep', '-r', 'last:3', '[tuv]4'])
1349
self.assertNotContainsRe(
1350
out, "^dir0/file0.txt", flags=TestGrep._reflags)
1352
# v4 should be present in revno 4
1353
out, err = self.run_bzr(['grep', '-r', 'last:2', '[tuv]4'])
1354
self.assertContainsRe(out, "^dir0/file0.txt~4:v4",
1355
flags=TestGrep._reflags)
1357
def test_revno_range_basic_history_grep(self):
1358
"""Search for pattern in revision range for file.
1362
self.make_branch_and_tree(wd)
1364
self._mk_versioned_file(fname, total_lines=0) # rev1
1365
self._mk_versioned_file('file1.txt') # rev2
1366
self._update_file(fname, text="v3 text\n") # rev3
1367
self._update_file(fname, text="v4 text\n") # rev4
1368
self._update_file(fname, text="v5 text\n") # rev5
1369
self._update_file(fname, text="v6 text\n") # rev6
1371
out, err = self.run_bzr(['grep', '-r', '1..', 'v3'])
1372
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1373
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1374
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1375
self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1376
self.assertEqual(len(out.splitlines()), 4)
1378
out, err = self.run_bzr(['grep', '-r', '..1', 'v3'])
1379
# searching only rev1 gives nothing
1380
self.assertEqual(len(out.splitlines()), 0)
1382
out, err = self.run_bzr(['grep', '-r', '..6', 'v3'])
1383
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1384
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1385
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1386
self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1387
self.assertEqual(len(out.splitlines()), 4)
1389
out, err = self.run_bzr(['grep', '-r', '..', 'v3'])
1390
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1391
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1392
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1393
self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1394
self.assertEqual(len(out.splitlines()), 4)
1396
out, err = self.run_bzr(['grep', '-r', '1..5', 'v3'])
1397
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1398
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1399
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1400
self.assertNotContainsRe(
1401
out, "file0.txt~6:v3", flags=TestGrep._reflags)
1402
self.assertEqual(len(out.splitlines()), 3)
1404
out, err = self.run_bzr(['grep', '-r', '5..1', 'v3'])
1405
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1406
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1407
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1408
self.assertNotContainsRe(
1409
out, "file0.txt~6:v3", flags=TestGrep._reflags)
1410
self.assertEqual(len(out.splitlines()), 3)
1412
out, err = self.run_bzr(['grep', '-r', '1..', '[tuv]3'])
1413
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1414
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1415
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1416
self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1417
self.assertEqual(len(out.splitlines()), 4)
1419
out, err = self.run_bzr(['grep', '-r', '1..5', '[tuv]3'])
1420
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1421
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1422
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1423
self.assertNotContainsRe(
1424
out, "file0.txt~6:v3", flags=TestGrep._reflags)
1425
self.assertEqual(len(out.splitlines()), 3)
1427
out, err = self.run_bzr(['grep', '-r', '5..1', '[tuv]3'])
1428
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1429
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1430
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1431
self.assertNotContainsRe(
1432
out, "file0.txt~6:v3", flags=TestGrep._reflags)
1433
self.assertEqual(len(out.splitlines()), 3)
1435
def test_revno_range_versioned_file_in_dir(self):
1436
"""Grep rev-range for pattern for file withing a dir.
1439
self.make_branch_and_tree(wd)
1441
self._mk_versioned_dir('dir0') # rev1
1442
self._mk_versioned_file('dir0/file0.txt') # rev2
1443
self._update_file('dir0/file0.txt', "v3 text\n") # rev3
1444
self._update_file('dir0/file0.txt', "v4 text\n") # rev4
1445
self._update_file('dir0/file0.txt', "v5 text\n") # rev5
1446
self._update_file('dir0/file0.txt', "v6 text\n") # rev6
1448
out, err = self.run_bzr(['grep', '-r', '2..5', 'v3'])
1449
self.assertContainsRe(out, "^dir0/file0.txt~3:v3",
1450
flags=TestGrep._reflags)
1451
self.assertContainsRe(out, "^dir0/file0.txt~4:v3",
1452
flags=TestGrep._reflags)
1453
self.assertContainsRe(out, "^dir0/file0.txt~5:v3",
1454
flags=TestGrep._reflags)
1455
self.assertNotContainsRe(
1456
out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1457
self.assertEqual(len(out.splitlines()), 3)
1459
out, err = self.run_bzr(['grep', '-r', '2..5', '[tuv]3'])
1460
self.assertContainsRe(out, "^dir0/file0.txt~3:v3",
1461
flags=TestGrep._reflags)
1462
self.assertContainsRe(out, "^dir0/file0.txt~4:v3",
1463
flags=TestGrep._reflags)
1464
self.assertContainsRe(out, "^dir0/file0.txt~5:v3",
1465
flags=TestGrep._reflags)
1466
self.assertNotContainsRe(
1467
out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1468
self.assertEqual(len(out.splitlines()), 3)
1470
def test_revno_range_versioned_file_from_outside_dir(self):
1471
"""Grep rev-range for pattern from outside dir.
1474
self.make_branch_and_tree(wd)
1476
self._mk_versioned_dir('dir0') # rev1
1477
self._mk_versioned_file('dir0/file0.txt') # rev2
1478
self._update_file('dir0/file0.txt', "v3 text\n") # rev3
1479
self._update_file('dir0/file0.txt', "v4 text\n") # rev4
1480
self._update_file('dir0/file0.txt', "v5 text\n") # rev5
1481
self._update_file('dir0/file0.txt', "v6 text\n") # rev6
1483
out, err = self.run_bzr(['grep', '-r', '2..5', 'v3', 'dir0'])
1484
self.assertContainsRe(out, "^dir0/file0.txt~3:v3",
1485
flags=TestGrep._reflags)
1486
self.assertContainsRe(out, "^dir0/file0.txt~4:v3",
1487
flags=TestGrep._reflags)
1488
self.assertContainsRe(out, "^dir0/file0.txt~5:v3",
1489
flags=TestGrep._reflags)
1490
self.assertNotContainsRe(
1491
out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1493
out, err = self.run_bzr(['grep', '-r', '2..5', '[tuv]3', 'dir0'])
1494
self.assertContainsRe(out, "^dir0/file0.txt~3:v3",
1495
flags=TestGrep._reflags)
1496
self.assertContainsRe(out, "^dir0/file0.txt~4:v3",
1497
flags=TestGrep._reflags)
1498
self.assertContainsRe(out, "^dir0/file0.txt~5:v3",
1499
flags=TestGrep._reflags)
1500
self.assertNotContainsRe(
1501
out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1503
def test_levels(self):
1504
"""--levels=0 should show findings from merged revision.
1509
self.make_branch_and_tree(wd0)
1511
self._mk_versioned_file('file0.txt')
1514
out, err = self.run_bzr(['branch', wd0, wd1])
1516
self._mk_versioned_file('file1.txt')
1517
os.chdir(osutils.pathjoin('..', wd0))
1519
out, err = self.run_bzr(['merge', osutils.pathjoin('..', wd1)])
1520
out, err = self.run_bzr(['ci', '-m', 'merged'])
1522
out, err = self.run_bzr(['grep', 'line1'])
1523
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
1524
self.assertContainsRe(out, "file1.txt:line1", flags=TestGrep._reflags)
1526
# levels should be ignored by wtree grep
1527
out, err = self.run_bzr(['grep', '--levels=0', 'line1'])
1528
self.assertContainsRe(out, "^file0.txt:line1$",
1529
flags=TestGrep._reflags)
1530
self.assertContainsRe(out, "^file1.txt:line1$",
1531
flags=TestGrep._reflags)
1532
self.assertContainsRe(out, "^file0.txt:line10$",
1533
flags=TestGrep._reflags)
1534
self.assertContainsRe(out, "^file1.txt:line10$",
1535
flags=TestGrep._reflags)
1536
self.assertEqual(len(out.splitlines()), 4)
1538
out, err = self.run_bzr(
1539
['grep', '-r', 'last:1..', '--levels=0', 'line1'])
1540
self.assertContainsRe(out, "^file0.txt~2:line1$",
1541
flags=TestGrep._reflags)
1542
self.assertContainsRe(out, "^file1.txt~2:line1$",
1543
flags=TestGrep._reflags)
1544
self.assertContainsRe(
1545
out, "^file0.txt~1.1.1:line1$", flags=TestGrep._reflags)
1546
self.assertContainsRe(
1547
out, "^file1.txt~1.1.1:line1$", flags=TestGrep._reflags)
1548
self.assertContainsRe(out, "^file0.txt~2:line10$",
1549
flags=TestGrep._reflags)
1550
self.assertContainsRe(out, "^file1.txt~2:line10$",
1551
flags=TestGrep._reflags)
1552
self.assertContainsRe(
1553
out, "^file0.txt~1.1.1:line10$", flags=TestGrep._reflags)
1554
self.assertContainsRe(
1555
out, "^file1.txt~1.1.1:line10$", flags=TestGrep._reflags)
1556
self.assertEqual(len(out.splitlines()), 8)
1558
out, err = self.run_bzr(
1559
['grep', '-r', '-1..', '-n', '--levels=0', 'line1'])
1560
self.assertContainsRe(out, "^file0.txt~2:1:line1$",
1561
flags=TestGrep._reflags)
1562
self.assertContainsRe(out, "^file1.txt~2:1:line1$",
1563
flags=TestGrep._reflags)
1564
self.assertContainsRe(
1565
out, "^file0.txt~1.1.1:1:line1$", flags=TestGrep._reflags)
1566
self.assertContainsRe(
1567
out, "^file1.txt~1.1.1:1:line1$", flags=TestGrep._reflags)
1568
self.assertContainsRe(
1569
out, "^file0.txt~2:10:line10$", flags=TestGrep._reflags)
1570
self.assertContainsRe(
1571
out, "^file1.txt~2:10:line10$", flags=TestGrep._reflags)
1572
self.assertContainsRe(
1573
out, "^file0.txt~1.1.1:10:line10$", flags=TestGrep._reflags)
1574
self.assertContainsRe(
1575
out, "^file1.txt~1.1.1:10:line10$", flags=TestGrep._reflags)
1576
self.assertEqual(len(out.splitlines()), 8)
1578
# levels should be ignored by wtree grep
1579
out, err = self.run_bzr(['grep', '--levels=0', 'l.ne1'])
1580
self.assertContainsRe(out, "^file0.txt:line1$",
1581
flags=TestGrep._reflags)
1582
self.assertContainsRe(out, "^file1.txt:line1$",
1583
flags=TestGrep._reflags)
1584
self.assertContainsRe(out, "^file0.txt:line10$",
1585
flags=TestGrep._reflags)
1586
self.assertContainsRe(out, "^file1.txt:line10$",
1587
flags=TestGrep._reflags)
1588
self.assertEqual(len(out.splitlines()), 4)
1590
out, err = self.run_bzr(
1591
['grep', '-r', 'last:1..', '--levels=0', 'lin.1'])
1592
self.assertContainsRe(out, "^file0.txt~2:line1$",
1593
flags=TestGrep._reflags)
1594
self.assertContainsRe(out, "^file1.txt~2:line1$",
1595
flags=TestGrep._reflags)
1596
self.assertContainsRe(
1597
out, "^file0.txt~1.1.1:line1$", flags=TestGrep._reflags)
1598
self.assertContainsRe(
1599
out, "^file1.txt~1.1.1:line1$", flags=TestGrep._reflags)
1600
self.assertContainsRe(out, "^file0.txt~2:line10$",
1601
flags=TestGrep._reflags)
1602
self.assertContainsRe(out, "^file1.txt~2:line10$",
1603
flags=TestGrep._reflags)
1604
self.assertContainsRe(
1605
out, "^file0.txt~1.1.1:line10$", flags=TestGrep._reflags)
1606
self.assertContainsRe(
1607
out, "^file1.txt~1.1.1:line10$", flags=TestGrep._reflags)
1608
self.assertEqual(len(out.splitlines()), 8)
1610
out, err = self.run_bzr(
1611
['grep', '-r', '-1..', '-n', '--levels=0', '.ine1'])
1612
self.assertContainsRe(out, "file0.txt~2:1:line1",
1613
flags=TestGrep._reflags)
1614
self.assertContainsRe(out, "file1.txt~2:1:line1",
1615
flags=TestGrep._reflags)
1616
self.assertContainsRe(
1617
out, "file0.txt~1.1.1:1:line1", flags=TestGrep._reflags)
1618
self.assertContainsRe(
1619
out, "file1.txt~1.1.1:1:line1", flags=TestGrep._reflags)
1621
def test_dotted_rev_grep(self):
1622
"""Grep in dotted revs
1627
self.make_branch_and_tree(wd0)
1629
self._mk_versioned_file('file0.txt')
1632
out, err = self.run_bzr(['branch', wd0, wd1])
1634
self._mk_versioned_file('file1.txt') # revno 1.1.1
1635
self._update_file('file1.txt', "text 0\n") # revno 1.1.2
1636
self._update_file('file1.txt', "text 1\n") # revno 1.1.3
1637
self._update_file('file1.txt', "text 2\n") # revno 1.1.4
1638
os.chdir(osutils.pathjoin('..', wd0))
1640
out, err = self.run_bzr(['merge', osutils.pathjoin('..', wd1)])
1641
out, err = self.run_bzr(['ci', '-m', 'merged'])
1643
out, err = self.run_bzr(['grep', '-r', '1.1.1..1.1.4', 'text'])
1644
self.assertContainsRe(
1645
out, "file1.txt~1.1.2:text 0", flags=TestGrep._reflags)
1646
self.assertContainsRe(
1647
out, "file1.txt~1.1.3:text 1", flags=TestGrep._reflags)
1648
self.assertContainsRe(
1649
out, "file1.txt~1.1.3:text 1", flags=TestGrep._reflags)
1650
self.assertContainsRe(
1651
out, "file1.txt~1.1.4:text 0", flags=TestGrep._reflags)
1652
self.assertContainsRe(
1653
out, "file1.txt~1.1.4:text 1", flags=TestGrep._reflags)
1654
self.assertContainsRe(
1655
out, "file1.txt~1.1.4:text 2", flags=TestGrep._reflags)
1656
self.assertEqual(len(out.splitlines()), 6)
1658
def test_versioned_binary_file_grep(self):
1659
"""(versioned) Grep for pattern in binary file.
1662
self.make_branch_and_tree(wd)
1664
self._mk_versioned_file('file.txt')
1665
self._mk_versioned_file('file0.bin')
1666
self._update_file('file0.bin', "\x00lineNN\x00\n")
1668
# note: set --verbose/-v flag to get the skip message.
1669
out, err = self.run_bzr(['grep', '-v', '-r', 'last:1',
1670
'lineNN', 'file0.bin'])
1671
self.assertNotContainsRe(out, "file0.bin", flags=TestGrep._reflags)
1672
self.assertContainsRe(
1673
err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
1674
self.assertEqual(len(out.splitlines()), 0)
1675
self.assertEqual(len(err.splitlines()), 1)
1677
out, err = self.run_bzr(['grep', '-v', '-r', 'last:1',
1678
'line.N', 'file0.bin'])
1679
self.assertNotContainsRe(out, "file0.bin", flags=TestGrep._reflags)
1680
self.assertContainsRe(
1681
err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
1682
self.assertEqual(len(out.splitlines()), 0)
1683
self.assertEqual(len(err.splitlines()), 1)
1685
def test_wtree_binary_file_grep(self):
1686
"""(wtree) Grep for pattern in binary file.
1689
self.make_branch_and_tree(wd)
1691
self._mk_versioned_file('file0.bin')
1692
self._update_file('file0.bin', "\x00lineNN\x00\n")
1694
# note: set --verbose/-v flag to get the skip message.
1695
out, err = self.run_bzr(['grep', '-v', 'lineNN', 'file0.bin'])
1696
self.assertNotContainsRe(
1697
out, "file0.bin:line1", flags=TestGrep._reflags)
1698
self.assertContainsRe(
1699
err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
1701
# binary warning should not be shown without --verbose
1702
out, err = self.run_bzr(['grep', 'lineNN', 'file0.bin'])
1703
self.assertNotContainsRe(
1704
out, "file0.bin:line1", flags=TestGrep._reflags)
1705
self.assertNotContainsRe(err, "Binary file", flags=TestGrep._reflags)
1707
def test_revspec(self):
1708
"""Ensure various revspecs work
1711
self.make_branch_and_tree(wd)
1713
self._mk_versioned_dir('dir0') # rev1
1714
self._mk_versioned_file('dir0/file0.txt') # rev2
1715
self._update_file('dir0/file0.txt', "v3 text\n") # rev3
1716
self._update_file('dir0/file0.txt', "v4 text\n") # rev4
1717
self._update_file('dir0/file0.txt', "v5 text\n") # rev5
1719
out, err = self.run_bzr(['grep', '-r', 'revno:1..2', 'v3'])
1720
self.assertNotContainsRe(out, "file0", flags=TestGrep._reflags)
1721
self.assertEqual(len(out.splitlines()), 0)
1723
out, err = self.run_bzr(['grep', '-r', 'revno:4..', 'v4'])
1724
self.assertContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
1725
self.assertEqual(len(out.splitlines()), 2) # find v4 in rev4 and rev5
1727
out, err = self.run_bzr(['grep', '-r', '..revno:3', 'v4'])
1728
self.assertNotContainsRe(out, "file0", flags=TestGrep._reflags)
1729
self.assertEqual(len(out.splitlines()), 0)
1731
out, err = self.run_bzr(['grep', '-r', '..revno:3', 'v3'])
1732
self.assertContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
1733
self.assertEqual(len(out.splitlines()), 1)
1735
def test_wtree_files_with_matches(self):
1736
"""(wtree) Ensure --files-with-matches, -l works
1739
self.make_branch_and_tree(wd)
1742
self._mk_versioned_file('file0.txt', total_lines=2)
1743
self._mk_versioned_file('file1.txt', total_lines=2)
1744
self._mk_versioned_dir('dir0')
1745
self._mk_versioned_file('dir0/file00.txt', total_lines=2)
1746
self._mk_versioned_file('dir0/file01.txt', total_lines=2)
1748
self._update_file('file0.txt', 'HELLO\n', checkin=False)
1749
self._update_file('dir0/file00.txt', 'HELLO\n', checkin=False)
1752
out, err = self.run_bzr(['grep', '--files-with-matches', 'HELLO'])
1754
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1755
self.assertContainsRe(out, "^dir0/file00.txt$",
1756
flags=TestGrep._reflags)
1757
self.assertEqual(len(out.splitlines()), 2)
1760
out, err = self.run_bzr(['grep', '--files-with-matches', 'HE.LO'])
1762
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1763
self.assertContainsRe(out, "^dir0/file00.txt$",
1764
flags=TestGrep._reflags)
1765
self.assertEqual(len(out.splitlines()), 2)
1768
out, err = self.run_bzr(['grep', '-l', 'HELLO'])
1770
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1771
self.assertContainsRe(out, "^dir0/file00.txt$",
1772
flags=TestGrep._reflags)
1773
self.assertEqual(len(out.splitlines()), 2)
1776
out, err = self.run_bzr(['grep', '-l', 'HE.LO'])
1778
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1779
self.assertContainsRe(out, "^dir0/file00.txt$",
1780
flags=TestGrep._reflags)
1781
self.assertEqual(len(out.splitlines()), 2)
1784
out, err = self.run_bzr(['grep', '-l', 'HELLO', 'dir0', 'file1.txt'])
1786
self.assertContainsRe(out, "^dir0/file00.txt$",
1787
flags=TestGrep._reflags)
1788
self.assertEqual(len(out.splitlines()), 1)
1791
out, err = self.run_bzr(['grep', '-l', '.ELLO', 'dir0', 'file1.txt'])
1793
self.assertContainsRe(out, "^dir0/file00.txt$",
1794
flags=TestGrep._reflags)
1795
self.assertEqual(len(out.splitlines()), 1)
1798
out, err = self.run_bzr(['grep', '-l', 'HELLO', 'file0.txt'])
1800
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1801
self.assertEqual(len(out.splitlines()), 1)
1804
out, err = self.run_bzr(['grep', '-l', '.ELLO', 'file0.txt'])
1806
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1807
self.assertEqual(len(out.splitlines()), 1)
1810
out, err = self.run_bzr(['grep', '--no-recursive', '-l', 'HELLO'])
1812
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1813
self.assertEqual(len(out.splitlines()), 1)
1816
out, err = self.run_bzr(['grep', '--no-recursive', '-l', '.ELLO'])
1818
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1819
self.assertEqual(len(out.splitlines()), 1)
1821
def test_ver_files_with_matches(self):
1822
"""(ver) Ensure --files-with-matches, -l works
1825
self.make_branch_and_tree(wd)
1828
self._mk_versioned_file('file0.txt', total_lines=2) # rev 1
1829
self._mk_versioned_file('file1.txt', total_lines=2) # rev 2
1830
self._mk_versioned_dir('dir0') # rev 3
1831
self._mk_versioned_file('dir0/file00.txt', total_lines=2) # rev 4
1832
self._mk_versioned_file('dir0/file01.txt', total_lines=2) # rev 5
1834
self._update_file('file0.txt', 'HELLO\n') # rev 6
1835
self._update_file('dir0/file00.txt', 'HELLO\n') # rev 7
1838
out, err = self.run_bzr(['grep', '-r', '-1', '--files-with-matches',
1841
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1842
self.assertContainsRe(out, "^dir0/file00.txt~7$",
1843
flags=TestGrep._reflags)
1844
self.assertEqual(len(out.splitlines()), 2)
1847
out, err = self.run_bzr(['grep', '-r', '-1', '--files-with-matches',
1850
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1851
self.assertContainsRe(out, "^dir0/file00.txt~7$",
1852
flags=TestGrep._reflags)
1853
self.assertEqual(len(out.splitlines()), 2)
1856
out, err = self.run_bzr(['grep', '-r', '6..7', '--files-with-matches',
1859
self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1860
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1861
self.assertContainsRe(out, "^dir0/file00.txt~7$",
1862
flags=TestGrep._reflags)
1863
self.assertEqual(len(out.splitlines()), 3)
1866
out, err = self.run_bzr(['grep', '-r', '6..7', '--files-with-matches',
1869
self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1870
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1871
self.assertContainsRe(out, "^dir0/file00.txt~7$",
1872
flags=TestGrep._reflags)
1873
self.assertEqual(len(out.splitlines()), 3)
1876
out, err = self.run_bzr(['grep', '-r', '-1', '-l', 'HELLO'])
1878
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1879
self.assertContainsRe(out, "^dir0/file00.txt~7$",
1880
flags=TestGrep._reflags)
1881
self.assertEqual(len(out.splitlines()), 2)
1884
out, err = self.run_bzr(['grep', '-r', '-1', '-l', 'H.LLO'])
1886
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1887
self.assertContainsRe(out, "^dir0/file00.txt~7$",
1888
flags=TestGrep._reflags)
1889
self.assertEqual(len(out.splitlines()), 2)
1892
out, err = self.run_bzr(['grep', '-l', 'HELLO', '-r', '-1',
1893
'dir0', 'file1.txt'])
1895
self.assertContainsRe(out, "^dir0/file00.txt~7$",
1896
flags=TestGrep._reflags)
1897
self.assertEqual(len(out.splitlines()), 1)
1900
out, err = self.run_bzr(['grep', '-l', 'H.LLO', '-r', '-1',
1901
'dir0', 'file1.txt'])
1903
self.assertContainsRe(out, "^dir0/file00.txt~7$",
1904
flags=TestGrep._reflags)
1905
self.assertEqual(len(out.splitlines()), 1)
1908
out, err = self.run_bzr(['grep', '-l', 'HELLO',
1909
'-r', '-2', 'file0.txt'])
1911
self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1912
self.assertEqual(len(out.splitlines()), 1)
1915
out, err = self.run_bzr(['grep', '-l', 'HE.LO',
1916
'-r', '-2', 'file0.txt'])
1918
self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1919
self.assertEqual(len(out.splitlines()), 1)
1922
out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
1925
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1926
self.assertEqual(len(out.splitlines()), 1)
1929
out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
1932
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1933
self.assertEqual(len(out.splitlines()), 1)
1935
def test_wtree_files_without_matches(self):
1936
"""(wtree) Ensure --files-without-match, -L works
1939
self.make_branch_and_tree(wd)
1942
self._mk_versioned_file('file0.txt', total_lines=2)
1943
self._mk_versioned_file('file1.txt', total_lines=2)
1944
self._mk_versioned_dir('dir0')
1945
self._mk_versioned_file('dir0/file00.txt', total_lines=2)
1946
self._mk_versioned_file('dir0/file01.txt', total_lines=2)
1948
self._update_file('file0.txt', 'HELLO\n', checkin=False)
1949
self._update_file('dir0/file00.txt', 'HELLO\n', checkin=False)
1952
out, err = self.run_bzr(['grep', '--files-without-match', 'HELLO'])
1954
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1955
self.assertContainsRe(out, "^dir0/file01.txt$",
1956
flags=TestGrep._reflags)
1957
self.assertEqual(len(out.splitlines()), 2)
1960
out, err = self.run_bzr(['grep', '--files-without-match', 'HE.LO'])
1962
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1963
self.assertContainsRe(out, "^dir0/file01.txt$",
1964
flags=TestGrep._reflags)
1965
self.assertEqual(len(out.splitlines()), 2)
1968
out, err = self.run_bzr(['grep', '-L', 'HELLO'])
1970
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1971
self.assertContainsRe(out, "^dir0/file01.txt$",
1972
flags=TestGrep._reflags)
1973
self.assertEqual(len(out.splitlines()), 2)
1976
out, err = self.run_bzr(['grep', '-L', 'HE.LO'])
1978
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1979
self.assertContainsRe(out, "^dir0/file01.txt$",
1980
flags=TestGrep._reflags)
1981
self.assertEqual(len(out.splitlines()), 2)
1984
out, err = self.run_bzr(['grep', '-L', 'HELLO', 'dir0', 'file1.txt'])
1986
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1987
self.assertContainsRe(out, "^dir0/file01.txt$",
1988
flags=TestGrep._reflags)
1989
self.assertEqual(len(out.splitlines()), 2)
1992
out, err = self.run_bzr(['grep', '-L', '.ELLO', 'dir0', 'file1.txt'])
1994
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1995
self.assertContainsRe(out, "^dir0/file01.txt$",
1996
flags=TestGrep._reflags)
1997
self.assertEqual(len(out.splitlines()), 2)
2000
out, err = self.run_bzr(['grep', '-L', 'HELLO', 'file1.txt'])
2002
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
2003
self.assertEqual(len(out.splitlines()), 1)
2006
out, err = self.run_bzr(['grep', '-L', '.ELLO', 'file1.txt'])
2008
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
2009
self.assertEqual(len(out.splitlines()), 1)
2012
out, err = self.run_bzr(['grep', '--no-recursive', '-L', 'HELLO'])
2014
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
2015
self.assertEqual(len(out.splitlines()), 1)
2018
out, err = self.run_bzr(['grep', '--no-recursive', '-L', '.ELLO'])
2020
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
2021
self.assertEqual(len(out.splitlines()), 1)
2023
def test_ver_files_without_matches(self):
2024
"""(ver) Ensure --files-without-match, -L works
2027
self.make_branch_and_tree(wd)
2030
self._mk_versioned_file('file0.txt', total_lines=2) # rev 1
2031
self._mk_versioned_file('file1.txt', total_lines=2) # rev 2
2032
self._mk_versioned_dir('dir0') # rev 3
2033
self._mk_versioned_file('dir0/file00.txt', total_lines=2) # rev 4
2034
self._mk_versioned_file('dir0/file01.txt', total_lines=2) # rev 5
2036
self._update_file('file0.txt', 'HELLO\n') # rev 6
2037
self._update_file('dir0/file00.txt', 'HELLO\n') # rev 7
2040
out, err = self.run_bzr(['grep', '-r', '-1', '--files-without-match',
2043
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2044
self.assertContainsRe(out, "^dir0/file01.txt~7$",
2045
flags=TestGrep._reflags)
2046
self.assertEqual(len(out.splitlines()), 2)
2049
out, err = self.run_bzr(['grep', '-r', '-1', '--files-without-match',
2052
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2053
self.assertContainsRe(out, "^dir0/file01.txt~7$",
2054
flags=TestGrep._reflags)
2055
self.assertEqual(len(out.splitlines()), 2)
2058
out, err = self.run_bzr(['grep', '-r', '6..7', '--files-without-match',
2061
self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
2062
self.assertContainsRe(out, "^dir0/file00.txt~6$",
2063
flags=TestGrep._reflags)
2064
self.assertContainsRe(out, "^dir0/file01.txt~6$",
2065
flags=TestGrep._reflags)
2066
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2067
self.assertContainsRe(out, "^dir0/file01.txt~7$",
2068
flags=TestGrep._reflags)
2069
self.assertEqual(len(out.splitlines()), 5)
2072
out, err = self.run_bzr(['grep', '-r', '6..7', '--files-without-match',
2075
self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
2076
self.assertContainsRe(out, "^dir0/file00.txt~6$",
2077
flags=TestGrep._reflags)
2078
self.assertContainsRe(out, "^dir0/file01.txt~6$",
2079
flags=TestGrep._reflags)
2080
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2081
self.assertContainsRe(out, "^dir0/file01.txt~7$",
2082
flags=TestGrep._reflags)
2083
self.assertEqual(len(out.splitlines()), 5)
2086
out, err = self.run_bzr(['grep', '-r', '-1', '-L', 'HELLO'])
2088
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2089
self.assertContainsRe(out, "^dir0/file01.txt~7$",
2090
flags=TestGrep._reflags)
2091
self.assertEqual(len(out.splitlines()), 2)
2094
out, err = self.run_bzr(['grep', '-r', '-1', '-L', 'H.LLO'])
2096
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2097
self.assertContainsRe(out, "^dir0/file01.txt~7$",
2098
flags=TestGrep._reflags)
2099
self.assertEqual(len(out.splitlines()), 2)
2102
out, err = self.run_bzr(['grep', '-L', 'HELLO', '-r', '-1',
2103
'dir0', 'file1.txt'])
2105
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2106
self.assertContainsRe(out, "^dir0/file01.txt~7$",
2107
flags=TestGrep._reflags)
2108
self.assertEqual(len(out.splitlines()), 2)
2111
out, err = self.run_bzr(['grep', '-L', 'H.LLO', '-r', '-1',
2112
'dir0', 'file1.txt'])
2114
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2115
self.assertContainsRe(out, "^dir0/file01.txt~7$",
2116
flags=TestGrep._reflags)
2117
self.assertEqual(len(out.splitlines()), 2)
2120
out, err = self.run_bzr(['grep', '-L', 'HELLO',
2121
'-r', '-2', 'file1.txt'])
2123
self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
2124
self.assertEqual(len(out.splitlines()), 1)
2127
out, err = self.run_bzr(['grep', '-L', 'HE.LO',
2128
'-r', '-2', 'file1.txt'])
2130
self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
2131
self.assertEqual(len(out.splitlines()), 1)
2134
out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
2137
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2138
self.assertEqual(len(out.splitlines()), 1)
2141
out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
2144
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2145
self.assertEqual(len(out.splitlines()), 1)
2147
def test_no_tree(self):
2148
"""Ensure grep works without working tree.
2152
self.make_branch_and_tree(wd0)
2154
self._mk_versioned_file('file0.txt')
2156
out, err = self.run_bzr(['branch', '--no-tree', wd0, wd1])
2159
out, err = self.run_bzr(['grep', 'line1'], 3)
2160
self.assertContainsRe(
2161
err, "Cannot search working tree", flags=TestGrep._reflags)
2162
self.assertEqual(out, '')
2164
out, err = self.run_bzr(['grep', '-r', '1', 'line1'])
2165
self.assertContainsRe(out, "file0.txt~1:line1",
2166
flags=TestGrep._reflags)
2167
self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
2170
class TestNonAscii(GrepTestBase):
2171
"""Tests for non-ascii filenames and file contents"""
2173
_test_needs_features = [UnicodeFilenameFeature]
2175
def test_unicode_only_file(self):
2176
"""Test filename and contents that requires a unicode encoding"""
2177
tree = self.make_branch_and_tree(".")
2178
contents = [u"\u1234"]
2179
self.build_tree(contents)
2181
tree.commit("Initial commit")
2184
# GZ 2010-06-07: Note we can't actually grep for \u1234 as the pattern
2185
# is mangled according to the user encoding.
2186
streams = self.run_bzr_raw(["grep", "--files-with-matches",
2187
u"contents"], encoding="UTF-8")
2188
as_utf8 = as_utf8.encode("UTF-8")
2189
self.assertEqual(streams, (as_utf8 + b"\n", b""))
2191
streams = self.run_bzr_raw(["grep", "-r", "1", "--files-with-matches",
2192
u"contents"], encoding="UTF-8")
2193
self.assertEqual(streams, (as_utf8 + b"~1\n", b""))
2195
fileencoding = osutils.get_user_encoding()
2196
as_mangled = as_utf8.decode(fileencoding, "replace").encode("UTF-8")
2198
streams = self.run_bzr_raw(["grep", "-n",
2199
u"contents"], encoding="UTF-8")
2200
self.assertEqual(streams, (b"%s:1:contents of %s\n" %
2201
(as_utf8, as_mangled), b""))
2203
streams = self.run_bzr_raw(["grep", "-n", "-r", "1",
2204
u"contents"], encoding="UTF-8")
2205
self.assertEqual(streams, (b"%s~1:1:contents of %s\n" %
2206
(as_utf8, as_mangled), b""))
2209
class TestColorGrep(GrepTestBase):
2210
"""Tests for the --color option."""
2212
_rev_sep = color_string('~', fg=FG.BOLD_YELLOW)
2213
_sep = color_string(':', fg=FG.BOLD_CYAN)
2215
def test_color_option(self):
2216
"""Ensure options for color are valid.
2218
out, err = self.run_bzr(['grep', '--color', 'foo', 'bar'], 3)
2219
self.assertEqual(out, '')
2220
self.assertContainsRe(
2221
err, 'Valid values for --color are', flags=TestGrep._reflags)
2223
def test_ver_matching_files(self):
2224
"""(versioned) Search for matches or no matches only"""
2225
tree = self.make_branch_and_tree(".")
2226
contents = ["d/", "d/aaa", "bbb"]
2227
self.build_tree(contents)
2229
tree.commit("Initial commit")
2231
# GZ 2010-06-05: Maybe modify the working tree here
2233
streams = self.run_bzr(["grep", "--color", "always", "-r", "1",
2234
"--files-with-matches", "aaa"])
2235
self.assertEqual(streams, ("".join([
2236
FG.MAGENTA, "d/aaa", self._rev_sep, "1", "\n"
2239
streams = self.run_bzr(["grep", "--color", "always", "-r", "1",
2240
"--files-without-match", "aaa"])
2241
self.assertEqual(streams, ("".join([
2242
FG.MAGENTA, "bbb", self._rev_sep, "1", "\n"
2245
def test_wtree_matching_files(self):
2246
"""(wtree) Search for matches or no matches only"""
2247
tree = self.make_branch_and_tree(".")
2248
contents = ["d/", "d/aaa", "bbb"]
2249
self.build_tree(contents)
2251
tree.commit("Initial commit")
2253
# GZ 2010-06-05: Maybe modify the working tree here
2255
streams = self.run_bzr(["grep", "--color", "always",
2256
"--files-with-matches", "aaa"])
2257
self.assertEqual(streams, ("".join([
2258
FG.MAGENTA, "d/aaa", FG.NONE, "\n"
2261
streams = self.run_bzr(["grep", "--color", "always",
2262
"--files-without-match", "aaa"])
2263
self.assertEqual(streams, ("".join([
2264
FG.MAGENTA, "bbb", FG.NONE, "\n"
2267
def test_ver_basic_file(self):
2268
"""(versioned) Search for pattern in specfic file.
2271
self.make_branch_and_tree(wd)
2273
lp = 'foo is foobar'
2274
self._mk_versioned_file('file0.txt', line_prefix=lp, total_lines=1)
2276
# prepare colored result
2277
foo = color_string('foo', fg=FG.BOLD_RED)
2278
res = (FG.MAGENTA + 'file0.txt'
2279
+ self._rev_sep + '1' + self._sep
2280
+ foo + ' is ' + foo + 'bar1' + '\n')
2281
txt_res = 'file0.txt~1:foo is foobar1\n'
2283
nres = (FG.MAGENTA + 'file0.txt'
2284
+ self._rev_sep + '1' + self._sep + '1' + self._sep
2285
+ foo + ' is ' + foo + 'bar1' + '\n')
2287
out, err = self.run_bzr(['grep', '--color',
2288
'always', '-r', '1', 'foo'])
2289
self.assertEqual(out, res)
2290
self.assertEqual(len(out.splitlines()), 1)
2292
# auto should produce plain text result
2293
# as stdout is redireched here.
2294
out, err = self.run_bzr(['grep', '--color',
2295
'auto', '-r', '1', 'foo'])
2296
self.assertEqual(out, txt_res)
2297
self.assertEqual(len(out.splitlines()), 1)
2299
out, err = self.run_bzr(['grep', '-i', '--color',
2300
'always', '-r', '1', 'FOO'])
2301
self.assertEqual(out, res)
2302
self.assertEqual(len(out.splitlines()), 1)
2304
out, err = self.run_bzr(['grep', '--color',
2305
'always', '-r', '1', 'f.o'])
2306
self.assertEqual(out, res)
2307
self.assertEqual(len(out.splitlines()), 1)
2309
out, err = self.run_bzr(['grep', '-i', '--color',
2310
'always', '-r', '1', 'F.O'])
2311
self.assertEqual(out, res)
2312
self.assertEqual(len(out.splitlines()), 1)
2314
out, err = self.run_bzr(['grep', '-n', '--color',
2315
'always', '-r', '1', 'foo'])
2316
self.assertEqual(out, nres)
2317
self.assertEqual(len(out.splitlines()), 1)
2319
out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2320
'always', '-r', '1', 'FOO'])
2321
self.assertEqual(out, nres)
2322
self.assertEqual(len(out.splitlines()), 1)
2324
out, err = self.run_bzr(['grep', '-n', '--color',
2325
'always', '-r', '1', 'f.o'])
2326
self.assertEqual(out, nres)
2327
self.assertEqual(len(out.splitlines()), 1)
2329
out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2330
'always', '-r', '1', 'F.O'])
2331
self.assertEqual(out, nres)
2332
self.assertEqual(len(out.splitlines()), 1)
2334
def test_wtree_basic_file(self):
2335
"""(wtree) Search for pattern in specfic file.
2338
self.make_branch_and_tree(wd)
2340
lp = 'foo is foobar'
2341
self._mk_versioned_file('file0.txt', line_prefix=lp, total_lines=1)
2343
# prepare colored result
2344
foo = color_string('foo', fg=FG.BOLD_RED)
2345
res = (FG.MAGENTA + 'file0.txt'
2346
+ self._sep + foo + ' is ' + foo + 'bar1' + '\n')
2348
nres = (FG.MAGENTA + 'file0.txt'
2349
+ self._sep + '1' + self._sep
2350
+ foo + ' is ' + foo + 'bar1' + '\n')
2352
out, err = self.run_bzr(['grep', '--color',
2354
self.assertEqual(out, res)
2355
self.assertEqual(len(out.splitlines()), 1)
2357
out, err = self.run_bzr(['grep', '-i', '--color',
2359
self.assertEqual(out, res)
2360
self.assertEqual(len(out.splitlines()), 1)
2362
out, err = self.run_bzr(['grep', '--color',
2364
self.assertEqual(out, res)
2365
self.assertEqual(len(out.splitlines()), 1)
2367
out, err = self.run_bzr(['grep', '-i', '--color',
2369
self.assertEqual(out, res)
2370
self.assertEqual(len(out.splitlines()), 1)
2372
out, err = self.run_bzr(['grep', '-n', '--color',
2374
self.assertEqual(out, nres)
2375
self.assertEqual(len(out.splitlines()), 1)
2377
out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2379
self.assertEqual(out, nres)
2380
self.assertEqual(len(out.splitlines()), 1)
2382
out, err = self.run_bzr(['grep', '-n', '--color',
2384
self.assertEqual(out, nres)
2385
self.assertEqual(len(out.splitlines()), 1)
2387
out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2389
self.assertEqual(out, nres)
2390
self.assertEqual(len(out.splitlines()), 1)
2393
# copied from breezy.tests.blackbox.test_diff
2394
def subst_dates(string):
2395
"""Replace date strings with constant values."""
2396
return re.sub(r'\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} [-\+]\d{4}',
2397
'YYYY-MM-DD HH:MM:SS +ZZZZ', string)
2400
class TestGrepDiff(tests.TestCaseWithTransport):
2402
def make_example_branch(self):
2403
tree = self.make_branch_and_tree('.')
2404
self.build_tree_contents([
2405
('hello', b'foo\n'),
2406
('goodbye', b'baz\n')])
2408
tree.commit('setup')
2409
tree.add(['goodbye'])
2410
tree.commit('setup')
2413
def test_grep_diff_basic(self):
2414
"""grep -p basic test."""
2415
tree = self.make_example_branch()
2416
self.build_tree_contents([('hello', b'hello world!\n')])
2417
tree.commit('updated hello')
2418
out, err = self.run_bzr(['grep', '-p', 'hello'])
2419
self.assertEqual(err, '')
2420
self.assertEqualDiff(subst_dates(out), '''\
2422
=== modified file 'hello'
2423
--- hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2424
+++ hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2427
=== added file 'hello'
2428
--- hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2429
+++ hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2432
def test_grep_diff_revision(self):
2433
"""grep -p specific revision."""
2434
tree = self.make_example_branch()
2435
self.build_tree_contents([('hello', b'hello world!\n')])
2436
tree.commit('updated hello')
2437
out, err = self.run_bzr(['grep', '-p', '-r', '3', 'hello'])
2438
self.assertEqual(err, '')
2439
self.assertEqualDiff(subst_dates(out), '''\
2441
=== modified file 'hello'
2442
--- hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2443
+++ hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2447
def test_grep_diff_revision_range(self):
2448
"""grep -p revision range."""
2449
tree = self.make_example_branch()
2450
self.build_tree_contents([('hello', b'hello world!1\n')]) # rev 3
2452
self.build_tree_contents([('blah', b'hello world!2\n')]) # rev 4
2455
with open('hello', 'a') as f:
2456
f.write('hello world!3\n')
2457
# self.build_tree_contents([('hello', 'hello world!3\n')]) # rev 5
2459
out, err = self.run_bzr(['grep', '-p', '-r', '2..5', 'hello'])
2460
self.assertEqual(err, '')
2461
self.assertEqualDiff(subst_dates(out), '''\
2463
=== modified file 'hello'
2464
--- hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2465
+++ hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2468
=== added file 'blah'
2471
=== modified file 'hello'
2472
--- hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2473
+++ hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2477
def test_grep_diff_color(self):
2478
"""grep -p color test."""
2479
tree = self.make_example_branch()
2480
self.build_tree_contents([('hello', b'hello world!\n')])
2481
tree.commit('updated hello')
2482
out, err = self.run_bzr(['grep', '--diff', '-r', '3',
2483
'--color', 'always', 'hello'])
2484
self.assertEqual(err, '')
2485
revno = color_string('=== revno:3 ===', fg=FG.BOLD_BLUE) + '\n'
2486
filename = color_string(
2487
" === modified file 'hello'", fg=FG.BOLD_MAGENTA) + '\n'
2488
redhello = color_string('hello', fg=FG.BOLD_RED)
2490
--- hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2491
+++ hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2494
diffstr = diffstr.replace('hello', redhello)
2495
self.assertEqualDiff(subst_dates(out), revno + filename + diffstr)
2497
def test_grep_norevs(self):
2498
"""grep -p with zero revisions."""
2499
out, err = self.run_bzr(['init'])
2500
out, err = self.run_bzr(['grep', '--diff', 'foo'], 3)
2501
self.assertEqual(out, '')
2502
self.assertContainsRe(
2503
err, "ERROR:.*revision.* does not exist in branch")
added
removed
breezy/tests/test_grep.py
