1
# Copyright (C) 2010, 2011, 2012, 2016 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
from __future__ import absolute_import
21
import unicodedata as ud
23
from .. import tests, osutils
24
from .._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.
36
class GrepTestBase(tests.TestCaseWithTransport):
37
"""Base class for testing grep.
39
Provides support methods for creating directory and file revisions.
41
_reflags = re.MULTILINE | re.DOTALL
43
def _mk_file(self, path, line_prefix, total_lines, versioned):
45
for i in range(total_lines):
46
text += line_prefix + str(i + 1) + "\n"
48
with open(path, 'w') as f:
51
self.run_bzr(['add', path])
52
self.run_bzr(['ci', '-m', '"' + path + '"'])
54
def _update_file(self, path, text, checkin=True):
55
"""append text to file 'path' and check it in"""
56
with open(path, 'a') as f:
59
self.run_bzr(['ci', path, '-m', '"' + path + '"'])
61
def _mk_unknown_file(self, path, line_prefix='line', total_lines=10):
62
self._mk_file(path, line_prefix, total_lines, versioned=False)
64
def _mk_versioned_file(self, path, line_prefix='line', total_lines=10):
65
self._mk_file(path, line_prefix, total_lines, versioned=True)
67
def _mk_dir(self, path, versioned):
70
self.run_bzr(['add', path])
71
self.run_bzr(['ci', '-m', '"' + path + '"'])
73
def _mk_unknown_dir(self, path):
74
self._mk_dir(path, versioned=False)
76
def _mk_versioned_dir(self, path):
77
self._mk_dir(path, versioned=True)
80
class TestGrep(GrepTestBase):
81
"""Core functional tests for grep."""
83
def test_basic_unknown_file(self):
84
"""Search for pattern in specfic file.
86
If specified file is unknown, grep it anyway."""
88
self.make_branch_and_tree(wd)
90
self._mk_unknown_file('file0.txt')
92
out, err = self.run_bzr(['grep', 'line1', 'file0.txt'])
93
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
94
self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
96
out, err = self.run_bzr(['grep', 'line\\d+', 'file0.txt'])
97
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
98
self.assertEqual(len(out.splitlines()), 10)
100
# unknown file is not grepped unless explicitely specified
101
out, err = self.run_bzr(['grep', 'line1'])
102
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
103
self.assertEqual(len(out.splitlines()), 0)
105
# unknown file is not grepped unless explicitely specified
106
out, err = self.run_bzr(['grep', 'line1$'])
107
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
108
self.assertEqual(len(out.splitlines()), 0)
110
def test_ver_basic_file(self):
111
"""(versioned) Search for pattern in specfic file.
114
self.make_branch_and_tree(wd)
116
self._mk_versioned_file('file0.txt')
118
out, err = self.run_bzr(['grep', '-r', '1', 'line1', 'file0.txt'])
119
self.assertContainsRe(out, "file0.txt~1:line1",
120
flags=TestGrep._reflags)
121
self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
123
out, err = self.run_bzr(['grep', '-r', '1', 'line[0-9]$', 'file0.txt'])
124
self.assertContainsRe(out, "file0.txt~1:line1",
125
flags=TestGrep._reflags)
126
self.assertEqual(len(out.splitlines()), 9)
128
# finds all the lines
129
out, err = self.run_bzr(['grep', '-r', '1', 'line[0-9]', 'file0.txt'])
130
self.assertContainsRe(out, "file0.txt~1:line1",
131
flags=TestGrep._reflags)
132
self.assertEqual(len(out.splitlines()), 10)
134
def test_wtree_basic_file(self):
135
"""(wtree) Search for pattern in specfic file.
138
self.make_branch_and_tree(wd)
140
self._mk_versioned_file('file0.txt')
141
self._update_file('file0.txt', 'ABC\n', checkin=False)
143
out, err = self.run_bzr(['grep', 'ABC', 'file0.txt'])
144
self.assertContainsRe(out, "file0.txt:ABC", flags=TestGrep._reflags)
145
self.assertEqual(len(out.splitlines()), 1)
147
out, err = self.run_bzr(['grep', '[A-Z]{3}', 'file0.txt'])
148
self.assertContainsRe(out, "file0.txt:ABC", flags=TestGrep._reflags)
149
self.assertEqual(len(out.splitlines()), 1)
151
out, err = self.run_bzr(['grep', '-r', 'last:1', 'ABC', 'file0.txt'])
152
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
153
self.assertEqual(len(out.splitlines()), 0)
155
out, err = self.run_bzr(
156
['grep', '-r', 'last:1', '[A-Z]{3}', 'file0.txt'])
157
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
158
self.assertEqual(len(out.splitlines()), 0)
160
def test_ver_basic_include(self):
161
"""(versioned) Ensure that -I flag is respected.
164
self.make_branch_and_tree(wd)
166
self._mk_versioned_file('file0.aa')
167
self._mk_versioned_file('file0.bb')
168
self._mk_versioned_file('file0.cc')
170
out, err = self.run_bzr(['grep', '-r', 'last:1',
171
'--include', '*.aa', '--include', '*.bb', 'line1'])
172
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
173
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
174
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
175
# two lines each (line1, line10) from file0.aa and file0.bb
176
self.assertEqual(len(out.splitlines()), 4)
178
out, err = self.run_bzr(['grep', '-r', 'last:1',
179
'--include', '*.aa', '--include', '*.bb', 'line1$'])
180
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
181
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
182
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
183
# one lines each (line1) from file0.aa and file0.bb
184
self.assertEqual(len(out.splitlines()), 2)
186
out, err = self.run_bzr(['grep', '-r', 'last:1',
187
'-I', '*.aa', '-I', '*.bb', 'line1'])
188
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
189
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
190
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
191
# two lines each (line1, line10) from file0.aa and file0.bb
192
self.assertEqual(len(out.splitlines()), 4)
194
out, err = self.run_bzr(['grep', '-r', 'last:1',
195
'-I', '*.aa', '-I', '*.bb', 'line1$'])
196
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
197
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
198
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
199
# one lines each (line1) from file0.aa and file0.bb
200
self.assertEqual(len(out.splitlines()), 2)
202
def test_wtree_basic_include(self):
203
"""(wtree) Ensure that --include flag is respected.
206
self.make_branch_and_tree(wd)
208
self._mk_versioned_file('file0.aa')
209
self._mk_versioned_file('file0.bb')
210
self._mk_versioned_file('file0.cc')
212
out, err = self.run_bzr(['grep', '--include', '*.aa',
213
'--include', '*.bb', 'line1'])
214
self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
215
self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
216
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
217
# two lines each (line1, line10) from file0.aa and file0.bb
218
self.assertEqual(len(out.splitlines()), 4)
220
out, err = self.run_bzr(['grep', '--include', '*.aa',
221
'--include', '*.bb', 'line1$'])
222
self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
223
self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
224
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
225
# one line each (line1) from file0.aa and file0.bb
226
self.assertEqual(len(out.splitlines()), 2)
228
def test_ver_basic_exclude(self):
229
"""(versioned) Ensure that --exclude flag is respected.
232
self.make_branch_and_tree(wd)
234
self._mk_versioned_file('file0.aa')
235
self._mk_versioned_file('file0.bb')
236
self._mk_versioned_file('file0.cc')
238
out, err = self.run_bzr(['grep', '-r', 'last:1',
239
'--exclude', '*.cc', 'line1'])
240
self.assertContainsRe(out, "file0.aa~.:line1$",
241
flags=TestGrep._reflags)
242
self.assertContainsRe(out, "file0.bb~.:line1$",
243
flags=TestGrep._reflags)
244
self.assertContainsRe(out, "file0.aa~.:line10",
245
flags=TestGrep._reflags)
246
self.assertContainsRe(out, "file0.bb~.:line10",
247
flags=TestGrep._reflags)
248
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
249
# two lines each (line1, line10) from file0.aa and file0.bb
250
self.assertEqual(len(out.splitlines()), 4)
252
out, err = self.run_bzr(['grep', '-r', 'last:1',
253
'--exclude', '*.cc', 'line1$'])
254
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
255
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
256
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
257
# one line each (line1) from file0.aa and file0.bb
258
self.assertEqual(len(out.splitlines()), 2)
260
out, err = self.run_bzr(['grep', '-r', 'last:1',
261
'-X', '*.cc', 'line1'])
262
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
263
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
264
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
265
# two lines each (line1, line10) from file0.aa and file0.bb
266
self.assertEqual(len(out.splitlines()), 4)
268
def test_wtree_basic_exclude(self):
269
"""(wtree) Ensure that --exclude flag is respected.
272
self.make_branch_and_tree(wd)
274
self._mk_versioned_file('file0.aa')
275
self._mk_versioned_file('file0.bb')
276
self._mk_versioned_file('file0.cc')
278
out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'line1'])
279
self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
280
self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
281
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
282
# two lines each (line1, line10) from file0.aa and file0.bb
283
self.assertEqual(len(out.splitlines()), 4)
285
out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'lin.1$'])
286
self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
287
self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
288
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
289
# one line each (line1) from file0.aa and file0.bb
290
self.assertEqual(len(out.splitlines()), 2)
292
def test_ver_multiple_files(self):
293
"""(versioned) Search for pattern in multiple files.
296
self.make_branch_and_tree(wd)
298
self._mk_versioned_file('file0.txt', total_lines=2)
299
self._mk_versioned_file('file1.txt', total_lines=2)
300
self._mk_versioned_file('file2.txt', total_lines=2)
302
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line[1-2]$'])
303
self.assertContainsRe(out, "file0.txt~.:line1",
304
flags=TestGrep._reflags)
305
self.assertContainsRe(out, "file0.txt~.:line2",
306
flags=TestGrep._reflags)
307
self.assertContainsRe(out, "file1.txt~.:line1",
308
flags=TestGrep._reflags)
309
self.assertContainsRe(out, "file1.txt~.:line2",
310
flags=TestGrep._reflags)
311
self.assertContainsRe(out, "file2.txt~.:line1",
312
flags=TestGrep._reflags)
313
self.assertContainsRe(out, "file2.txt~.:line2",
314
flags=TestGrep._reflags)
315
self.assertEqual(len(out.splitlines()), 6)
317
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line'])
318
self.assertContainsRe(out, "file0.txt~.:line1",
319
flags=TestGrep._reflags)
320
self.assertContainsRe(out, "file0.txt~.:line2",
321
flags=TestGrep._reflags)
322
self.assertContainsRe(out, "file1.txt~.:line1",
323
flags=TestGrep._reflags)
324
self.assertContainsRe(out, "file1.txt~.:line2",
325
flags=TestGrep._reflags)
326
self.assertContainsRe(out, "file2.txt~.:line1",
327
flags=TestGrep._reflags)
328
self.assertContainsRe(out, "file2.txt~.:line2",
329
flags=TestGrep._reflags)
330
self.assertEqual(len(out.splitlines()), 6)
332
def test_multiple_wtree_files(self):
333
"""(wtree) Search for pattern in multiple files in working tree.
336
self.make_branch_and_tree(wd)
338
self._mk_versioned_file('file0.txt', total_lines=2)
339
self._mk_versioned_file('file1.txt', total_lines=2)
340
self._mk_versioned_file('file2.txt', total_lines=2)
341
self._update_file('file0.txt', 'HELLO\n', checkin=False)
342
self._update_file('file1.txt', 'HELLO\n', checkin=True)
343
self._update_file('file2.txt', 'HELLO\n', checkin=False)
345
out, err = self.run_bzr(['grep', 'HELLO',
346
'file0.txt', 'file1.txt', 'file2.txt'])
348
self.assertContainsRe(out, "file0.txt:HELLO", flags=TestGrep._reflags)
349
self.assertContainsRe(out, "file1.txt:HELLO", flags=TestGrep._reflags)
350
self.assertContainsRe(out, "file2.txt:HELLO", flags=TestGrep._reflags)
351
self.assertEqual(len(out.splitlines()), 3)
353
out, err = self.run_bzr(['grep', 'HELLO', '-r', 'last:1',
354
'file0.txt', 'file1.txt', 'file2.txt'])
356
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
357
self.assertContainsRe(out, "file1.txt~.:HELLO",
358
flags=TestGrep._reflags)
359
self.assertNotContainsRe(out, "file2.txt", flags=TestGrep._reflags)
360
self.assertEqual(len(out.splitlines()), 1)
362
out, err = self.run_bzr(['grep', 'HE..O',
363
'file0.txt', 'file1.txt', 'file2.txt'])
365
self.assertContainsRe(out, "file0.txt:HELLO", flags=TestGrep._reflags)
366
self.assertContainsRe(out, "file1.txt:HELLO", flags=TestGrep._reflags)
367
self.assertContainsRe(out, "file2.txt:HELLO", flags=TestGrep._reflags)
368
self.assertEqual(len(out.splitlines()), 3)
370
out, err = self.run_bzr(['grep', 'HE..O', '-r', 'last:1',
371
'file0.txt', 'file1.txt', 'file2.txt'])
373
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
374
self.assertContainsRe(out, "file1.txt~.:HELLO",
375
flags=TestGrep._reflags)
376
self.assertNotContainsRe(out, "file2.txt", flags=TestGrep._reflags)
377
self.assertEqual(len(out.splitlines()), 1)
379
def test_ver_null_option(self):
380
"""(versioned) --null option should use NUL instead of newline.
383
self.make_branch_and_tree(wd)
385
self._mk_versioned_file('file0.txt', total_lines=3)
388
u'NFC', u"file0.txt~1:line1\0file0.txt~1:line2\0file0.txt~1:line3\0")
390
out, err = self.run_bzr(
391
['grep', '-r', 'last:1', '--null', 'line[1-3]'])
392
nout = ud.normalize(u'NFC', out)
393
self.assertEqual(nout, nref)
394
self.assertEqual(len(out.splitlines()), 1)
396
out, err = self.run_bzr(['grep', '-r', 'last:1', '-Z', 'line[1-3]'])
397
nout = ud.normalize(u'NFC', out)
398
self.assertEqual(nout, nref)
399
self.assertEqual(len(out.splitlines()), 1)
401
out, err = self.run_bzr(['grep', '-r', 'last:1', '--null', 'line'])
402
nout = ud.normalize(u'NFC', out)
403
self.assertEqual(nout, nref)
404
self.assertEqual(len(out.splitlines()), 1)
406
def test_wtree_null_option(self):
407
"""(wtree) --null option should use NUL instead of newline.
410
self.make_branch_and_tree(wd)
412
self._mk_versioned_file('file0.txt', total_lines=3)
414
out, err = self.run_bzr(['grep', '--null', 'line[1-3]'])
416
out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
417
self.assertEqual(len(out.splitlines()), 1)
419
out, err = self.run_bzr(['grep', '-Z', 'line[1-3]'])
421
out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
422
self.assertEqual(len(out.splitlines()), 1)
424
out, err = self.run_bzr(['grep', '-Z', 'line'])
426
out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
427
self.assertEqual(len(out.splitlines()), 1)
429
def test_versioned_file_in_dir_no_recursive(self):
430
"""(versioned) Should not recurse with --no-recursive"""
432
self.make_branch_and_tree(wd)
434
self._mk_versioned_file('fileX.txt', line_prefix='lin')
435
self._mk_versioned_dir('dir0')
436
self._mk_versioned_file('dir0/file0.txt')
438
out, err = self.run_bzr(
439
['grep', '-r', 'last:1', '--no-recursive', 'line1'])
440
self.assertNotContainsRe(
441
out, "file0.txt~.:line1", flags=TestGrep._reflags)
442
self.assertEqual(len(out.splitlines()), 0)
444
out, err = self.run_bzr(
445
['grep', '-r', 'last:1', '--no-recursive', 'line1$'])
446
self.assertNotContainsRe(
447
out, "file0.txt~.:line1", flags=TestGrep._reflags)
448
self.assertEqual(len(out.splitlines()), 0)
450
def test_wtree_file_in_dir_no_recursive(self):
451
"""(wtree) Should not recurse with --no-recursive"""
453
self.make_branch_and_tree(wd)
455
self._mk_versioned_file('fileX.txt', line_prefix='lin')
456
self._mk_versioned_dir('dir0')
457
self._mk_versioned_file('dir0/file0.txt')
459
out, err = self.run_bzr(['grep', '--no-recursive', 'line1'])
460
self.assertNotContainsRe(
461
out, "file0.txt:line1", flags=TestGrep._reflags)
462
self.assertEqual(len(out.splitlines()), 0)
464
out, err = self.run_bzr(['grep', '--no-recursive', 'lin.1'])
465
self.assertNotContainsRe(
466
out, "file0.txt:line1", flags=TestGrep._reflags)
467
self.assertEqual(len(out.splitlines()), 0)
469
def test_versioned_file_in_dir_recurse(self):
470
"""(versioned) Should recurse by default.
473
self.make_branch_and_tree(wd)
475
self._mk_versioned_dir('dir0')
476
self._mk_versioned_file('dir0/file0.txt')
478
out, err = self.run_bzr(['grep', '-r', '-1', '.i.e1'])
479
self.assertContainsRe(
480
out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
481
# find line1 and line10
482
self.assertEqual(len(out.splitlines()), 2)
484
out, err = self.run_bzr(['grep', '-r', '-1', 'line1'])
485
self.assertContainsRe(
486
out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
487
# find line1 and line10
488
self.assertEqual(len(out.splitlines()), 2)
490
def test_wtree_file_in_dir_recurse(self):
491
"""(wtree) Should recurse by default.
494
self.make_branch_and_tree(wd)
496
self._mk_versioned_dir('dir0')
497
self._mk_versioned_file('dir0/file0.txt')
499
out, err = self.run_bzr(['grep', 'line1'])
500
self.assertContainsRe(out, "^dir0/file0.txt:line1",
501
flags=TestGrep._reflags)
502
# find line1 and line10
503
self.assertEqual(len(out.splitlines()), 2)
505
out, err = self.run_bzr(['grep', 'lin.1'])
506
self.assertContainsRe(out, "^dir0/file0.txt:line1",
507
flags=TestGrep._reflags)
508
# find line1 and line10
509
self.assertEqual(len(out.splitlines()), 2)
511
def test_versioned_file_within_dir(self):
512
"""(versioned) Search for pattern while in nested dir.
515
self.make_branch_and_tree(wd)
517
self._mk_versioned_dir('dir0')
518
self._mk_versioned_file('dir0/file0.txt')
521
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
522
self.assertContainsRe(out, "^file0.txt~.:line1",
523
flags=TestGrep._reflags)
524
# finds line1 and line10
525
self.assertEqual(len(out.splitlines()), 2)
527
out, err = self.run_bzr(['grep', '-r', 'last:1', '.i.e1'])
528
self.assertContainsRe(out, "^file0.txt~.:line1",
529
flags=TestGrep._reflags)
530
# finds line1 and line10
531
self.assertEqual(len(out.splitlines()), 2)
533
def test_versioned_include_file_within_dir(self):
534
"""(versioned) Ensure --include is respected with file within dir.
537
self.make_branch_and_tree(wd)
539
self._mk_versioned_dir('dir0') # revno 1
540
self._mk_versioned_file('dir0/file0.txt') # revno 2
541
self._mk_versioned_file('dir0/file1.aa') # revno 3
542
self._update_file('dir0/file1.aa', 'hello\n') # revno 4
543
self._update_file('dir0/file0.txt', 'hello\n') # revno 5
546
out, err = self.run_bzr(['grep', '-r', 'last:1',
547
'--include', '*.aa', 'line1'])
548
self.assertContainsRe(out, "^file1.aa~5:line1$",
549
flags=TestGrep._reflags)
550
self.assertContainsRe(out, "^file1.aa~5:line10$",
551
flags=TestGrep._reflags)
552
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
553
# finds line1 and line10
554
self.assertEqual(len(out.splitlines()), 2)
556
out, err = self.run_bzr(['grep', '-r', 'last:2..last:1',
557
'--include', '*.aa', 'line1'])
558
self.assertContainsRe(out, "^file1.aa~4:line1$",
559
flags=TestGrep._reflags)
560
self.assertContainsRe(out, "^file1.aa~4:line10$",
561
flags=TestGrep._reflags)
562
self.assertContainsRe(out, "^file1.aa~5:line1$",
563
flags=TestGrep._reflags)
564
self.assertContainsRe(out, "^file1.aa~5:line10$",
565
flags=TestGrep._reflags)
566
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
567
# finds line1 and line10 over two revisions
568
self.assertEqual(len(out.splitlines()), 4)
570
out, err = self.run_bzr(['grep', '-r', 'last:1',
571
'--include', '*.aa', 'lin.1'])
572
self.assertContainsRe(out, "^file1.aa~5:line1$",
573
flags=TestGrep._reflags)
574
self.assertContainsRe(out, "^file1.aa~5:line10$",
575
flags=TestGrep._reflags)
576
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
577
# finds line1 and line10
578
self.assertEqual(len(out.splitlines()), 2)
580
out, err = self.run_bzr(['grep', '-r', 'last:3..last:1',
581
'--include', '*.aa', 'lin.1'])
582
self.assertContainsRe(out, "^file1.aa~3:line1$",
583
flags=TestGrep._reflags)
584
self.assertContainsRe(out, "^file1.aa~4:line1$",
585
flags=TestGrep._reflags)
586
self.assertContainsRe(out, "^file1.aa~5:line1$",
587
flags=TestGrep._reflags)
588
self.assertContainsRe(out, "^file1.aa~3:line10$",
589
flags=TestGrep._reflags)
590
self.assertContainsRe(out, "^file1.aa~4:line10$",
591
flags=TestGrep._reflags)
592
self.assertContainsRe(out, "^file1.aa~5:line10$",
593
flags=TestGrep._reflags)
594
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
595
# finds line1 and line10 over 3 revisions
596
self.assertEqual(len(out.splitlines()), 6)
598
def test_versioned_exclude_file_within_dir(self):
599
"""(versioned) Ensure --exclude is respected with file within dir.
602
self.make_branch_and_tree(wd)
604
self._mk_versioned_dir('dir0')
605
self._mk_versioned_file('dir0/file0.txt')
606
self._mk_versioned_file('dir0/file1.aa')
609
out, err = self.run_bzr(['grep', '-r', 'last:1',
610
'--exclude', '*.txt', 'line1'])
611
self.assertContainsRe(out, "^file1.aa~.:line1",
612
flags=TestGrep._reflags)
613
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
614
# finds line1 and line10
615
self.assertEqual(len(out.splitlines()), 2)
617
out, err = self.run_bzr(['grep', '-r', 'last:1',
618
'--exclude', '*.txt', 'l[a-z]ne1'])
619
self.assertContainsRe(out, "^file1.aa~.:line1",
620
flags=TestGrep._reflags)
621
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
622
# finds line1 and line10
623
self.assertEqual(len(out.splitlines()), 2)
625
def test_wtree_file_within_dir(self):
626
"""(wtree) Search for pattern while in nested dir.
629
self.make_branch_and_tree(wd)
631
self._mk_versioned_dir('dir0')
632
self._mk_versioned_file('dir0/file0.txt')
635
out, err = self.run_bzr(['grep', 'line1'])
636
self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
637
# finds line1 and line10
638
self.assertEqual(len(out.splitlines()), 2)
640
out, err = self.run_bzr(['grep', 'l[aeiou]ne1'])
641
self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
642
# finds line1 and line10
643
self.assertEqual(len(out.splitlines()), 2)
645
def test_wtree_include_file_within_dir(self):
646
"""(wtree) Ensure --include is respected with file within dir.
649
self.make_branch_and_tree(wd)
651
self._mk_versioned_dir('dir0')
652
self._mk_versioned_file('dir0/file0.txt')
653
self._mk_versioned_file('dir0/file1.aa')
656
out, err = self.run_bzr(['grep', '--include', '*.aa', 'line1'])
657
self.assertContainsRe(out, "^file1.aa:line1", flags=TestGrep._reflags)
658
# finds line1 and line10
659
self.assertEqual(len(out.splitlines()), 2)
661
out, err = self.run_bzr(['grep', '--include', '*.aa', 'l[ixn]ne1'])
662
self.assertContainsRe(out, "^file1.aa:line1", flags=TestGrep._reflags)
663
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
664
# finds line1 and line10
665
self.assertEqual(len(out.splitlines()), 2)
667
def test_wtree_exclude_file_within_dir(self):
668
"""(wtree) Ensure --exclude is respected with file within dir.
671
self.make_branch_and_tree(wd)
673
self._mk_versioned_dir('dir0')
674
self._mk_versioned_file('dir0/file0.txt')
675
self._mk_versioned_file('dir0/file1.aa')
678
out, err = self.run_bzr(['grep', '--exclude', '*.txt', 'li.e1'])
679
self.assertContainsRe(out, "^file1.aa:line1$", flags=TestGrep._reflags)
680
self.assertContainsRe(out, "^file1.aa:line10$",
681
flags=TestGrep._reflags)
682
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
683
# finds line1 and line10
684
self.assertEqual(len(out.splitlines()), 2)
686
out, err = self.run_bzr(['grep', '--exclude', '*.txt', 'line1'])
687
self.assertContainsRe(out, "^file1.aa:line1$", flags=TestGrep._reflags)
688
self.assertContainsRe(out, "^file1.aa:line10$",
689
flags=TestGrep._reflags)
690
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
691
# finds line1 and line10
692
self.assertEqual(len(out.splitlines()), 2)
694
def test_versioned_include_from_outside_dir(self):
695
"""(versioned) Ensure --include is respected during recursive search.
698
self.make_branch_and_tree(wd)
701
self._mk_versioned_dir('dir0')
702
self._mk_versioned_file('dir0/file0.aa')
704
self._mk_versioned_dir('dir1')
705
self._mk_versioned_file('dir1/file1.bb')
707
self._mk_versioned_dir('dir2')
708
self._mk_versioned_file('dir2/file2.cc')
710
out, err = self.run_bzr(['grep', '-r', 'last:1',
711
'--include', '*.aa', '--include', '*.bb', 'l..e1'])
712
self.assertContainsRe(
713
out, "^dir0/file0.aa~.:line1$", flags=TestGrep._reflags)
714
self.assertContainsRe(
715
out, "^dir1/file1.bb~.:line1$", flags=TestGrep._reflags)
716
self.assertContainsRe(
717
out, "^dir0/file0.aa~.:line10$", flags=TestGrep._reflags)
718
self.assertContainsRe(
719
out, "^dir1/file1.bb~.:line10$", flags=TestGrep._reflags)
720
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
721
# finds line1 and line10
722
self.assertEqual(len(out.splitlines()), 4)
724
out, err = self.run_bzr(['grep', '-r', 'last:1',
725
'--include', '*.aa', '--include', '*.bb', 'line1'])
726
self.assertContainsRe(
727
out, "^dir0/file0.aa~.:line1$", flags=TestGrep._reflags)
728
self.assertContainsRe(
729
out, "^dir1/file1.bb~.:line1$", flags=TestGrep._reflags)
730
self.assertContainsRe(
731
out, "^dir0/file0.aa~.:line10$", flags=TestGrep._reflags)
732
self.assertContainsRe(
733
out, "^dir1/file1.bb~.:line10$", flags=TestGrep._reflags)
734
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
735
# finds line1 and line10
736
self.assertEqual(len(out.splitlines()), 4)
738
def test_wtree_include_from_outside_dir(self):
739
"""(wtree) Ensure --include is respected during recursive search.
742
self.make_branch_and_tree(wd)
745
self._mk_versioned_dir('dir0')
746
self._mk_versioned_file('dir0/file0.aa')
748
self._mk_versioned_dir('dir1')
749
self._mk_versioned_file('dir1/file1.bb')
751
self._mk_versioned_dir('dir2')
752
self._mk_versioned_file('dir2/file2.cc')
754
out, err = self.run_bzr(['grep', '--include', '*.aa',
755
'--include', '*.bb', 'l.n.1'])
756
self.assertContainsRe(out, "^dir0/file0.aa:line1$",
757
flags=TestGrep._reflags)
758
self.assertContainsRe(out, "^dir1/file1.bb:line1$",
759
flags=TestGrep._reflags)
760
self.assertContainsRe(
761
out, "^dir0/file0.aa:line10$", flags=TestGrep._reflags)
762
self.assertContainsRe(
763
out, "^dir1/file1.bb:line10$", flags=TestGrep._reflags)
764
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
765
# finds line1 and line10
766
self.assertEqual(len(out.splitlines()), 4)
768
out, err = self.run_bzr(['grep', '--include', '*.aa',
769
'--include', '*.bb', 'line1'])
770
self.assertContainsRe(out, "^dir0/file0.aa:line1$",
771
flags=TestGrep._reflags)
772
self.assertContainsRe(out, "^dir1/file1.bb:line1$",
773
flags=TestGrep._reflags)
774
self.assertContainsRe(
775
out, "^dir0/file0.aa:line10$", flags=TestGrep._reflags)
776
self.assertContainsRe(
777
out, "^dir1/file1.bb:line10$", flags=TestGrep._reflags)
778
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
779
# finds line1 and line10
780
self.assertEqual(len(out.splitlines()), 4)
782
def test_versioned_exclude_from_outside_dir(self):
783
"""(versioned) Ensure --exclude is respected during recursive search.
786
self.make_branch_and_tree(wd)
789
self._mk_versioned_dir('dir0')
790
self._mk_versioned_file('dir0/file0.aa')
792
self._mk_versioned_dir('dir1')
793
self._mk_versioned_file('dir1/file1.bb')
795
self._mk_versioned_dir('dir2')
796
self._mk_versioned_file('dir2/file2.cc')
798
out, err = self.run_bzr(['grep', '-r', 'last:1',
799
'--exclude', '*.cc', 'l..e1'])
800
self.assertContainsRe(
801
out, "^dir0/file0.aa~.:line1", flags=TestGrep._reflags)
802
self.assertContainsRe(
803
out, "^dir1/file1.bb~.:line1", flags=TestGrep._reflags)
804
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
806
out, err = self.run_bzr(['grep', '-r', 'last:1',
807
'--exclude', '*.cc', 'line1'])
808
self.assertContainsRe(
809
out, "^dir0/file0.aa~.:line1", flags=TestGrep._reflags)
810
self.assertContainsRe(
811
out, "^dir1/file1.bb~.:line1", flags=TestGrep._reflags)
812
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
814
def test_wtree_exclude_from_outside_dir(self):
815
"""(wtree) Ensure --exclude is respected during recursive search.
818
self.make_branch_and_tree(wd)
821
self._mk_versioned_dir('dir0')
822
self._mk_versioned_file('dir0/file0.aa')
824
self._mk_versioned_dir('dir1')
825
self._mk_versioned_file('dir1/file1.bb')
827
self._mk_versioned_dir('dir2')
828
self._mk_versioned_file('dir2/file2.cc')
830
out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'l[hijk]ne1'])
831
self.assertContainsRe(out, "^dir0/file0.aa:line1",
832
flags=TestGrep._reflags)
833
self.assertContainsRe(out, "^dir1/file1.bb:line1",
834
flags=TestGrep._reflags)
835
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
837
out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'line1'])
838
self.assertContainsRe(out, "^dir0/file0.aa:line1",
839
flags=TestGrep._reflags)
840
self.assertContainsRe(out, "^dir1/file1.bb:line1",
841
flags=TestGrep._reflags)
842
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
844
def test_workingtree_files_from_outside_dir(self):
845
"""(wtree) Grep for pattern with dirs passed as argument.
848
self.make_branch_and_tree(wd)
851
self._mk_versioned_dir('dir0')
852
self._mk_versioned_file('dir0/file0.txt')
854
self._mk_versioned_dir('dir1')
855
self._mk_versioned_file('dir1/file1.txt')
857
out, err = self.run_bzr(['grep', 'l[aeiou]ne1', 'dir0', 'dir1'])
858
self.assertContainsRe(out, "^dir0/file0.txt:line1",
859
flags=TestGrep._reflags)
860
self.assertContainsRe(out, "^dir1/file1.txt:line1",
861
flags=TestGrep._reflags)
863
out, err = self.run_bzr(['grep', 'line1', 'dir0', 'dir1'])
864
self.assertContainsRe(out, "^dir0/file0.txt:line1",
865
flags=TestGrep._reflags)
866
self.assertContainsRe(out, "^dir1/file1.txt:line1",
867
flags=TestGrep._reflags)
869
def test_versioned_files_from_outside_dir(self):
870
"""(versioned) Grep for pattern with dirs passed as argument.
873
self.make_branch_and_tree(wd)
876
self._mk_versioned_dir('dir0')
877
self._mk_versioned_file('dir0/file0.txt')
879
self._mk_versioned_dir('dir1')
880
self._mk_versioned_file('dir1/file1.txt')
882
out, err = self.run_bzr(
883
['grep', '-r', 'last:1', '.ine1', 'dir0', 'dir1'])
884
self.assertContainsRe(
885
out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
886
self.assertContainsRe(
887
out, "^dir1/file1.txt~.:line1", flags=TestGrep._reflags)
889
out, err = self.run_bzr(
890
['grep', '-r', 'last:1', 'line1', 'dir0', 'dir1'])
891
self.assertContainsRe(
892
out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
893
self.assertContainsRe(
894
out, "^dir1/file1.txt~.:line1", flags=TestGrep._reflags)
896
def test_wtree_files_from_outside_dir(self):
897
"""(wtree) Grep for pattern with dirs passed as argument.
900
self.make_branch_and_tree(wd)
903
self._mk_versioned_dir('dir0')
904
self._mk_versioned_file('dir0/file0.txt')
906
self._mk_versioned_dir('dir1')
907
self._mk_versioned_file('dir1/file1.txt')
909
out, err = self.run_bzr(['grep', 'li.e1', 'dir0', 'dir1'])
910
self.assertContainsRe(out, "^dir0/file0.txt:line1",
911
flags=TestGrep._reflags)
912
self.assertContainsRe(out, "^dir1/file1.txt:line1",
913
flags=TestGrep._reflags)
915
out, err = self.run_bzr(['grep', 'line1', 'dir0', 'dir1'])
916
self.assertContainsRe(out, "^dir0/file0.txt:line1",
917
flags=TestGrep._reflags)
918
self.assertContainsRe(out, "^dir1/file1.txt:line1",
919
flags=TestGrep._reflags)
921
def test_versioned_files_from_outside_two_dirs(self):
922
"""(versioned) Grep for pattern with two levels of nested dir.
925
self.make_branch_and_tree(wd)
928
self._mk_versioned_dir('dir0')
929
self._mk_versioned_file('dir0/file0.txt')
931
self._mk_versioned_dir('dir1')
932
self._mk_versioned_file('dir1/file1.txt')
934
self._mk_versioned_dir('dir0/dir00')
935
self._mk_versioned_file('dir0/dir00/file0.txt')
937
out, err = self.run_bzr(
938
['grep', '-r', 'last:1', 'l.ne1', 'dir0/dir00'])
939
self.assertContainsRe(
940
out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
942
out, err = self.run_bzr(['grep', '-r', 'last:1', 'l.ne1'])
943
self.assertContainsRe(
944
out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
946
out, err = self.run_bzr(
947
['grep', '-r', 'last:1', 'line1', 'dir0/dir00'])
948
self.assertContainsRe(
949
out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
951
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
952
self.assertContainsRe(
953
out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
955
def test_wtree_files_from_outside_two_dirs(self):
956
"""(wtree) Grep for pattern with two levels of nested dir.
959
self.make_branch_and_tree(wd)
962
self._mk_versioned_dir('dir0')
963
self._mk_versioned_file('dir0/file0.txt')
965
self._mk_versioned_dir('dir1')
966
self._mk_versioned_file('dir1/file1.txt')
968
self._mk_versioned_dir('dir0/dir00')
969
self._mk_versioned_file('dir0/dir00/file0.txt')
971
out, err = self.run_bzr(['grep', 'lin.1', 'dir0/dir00'])
972
self.assertContainsRe(
973
out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
975
out, err = self.run_bzr(['grep', 'li.e1'])
976
self.assertContainsRe(
977
out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
979
out, err = self.run_bzr(['grep', 'line1', 'dir0/dir00'])
980
self.assertContainsRe(
981
out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
983
out, err = self.run_bzr(['grep', 'line1'])
984
self.assertContainsRe(
985
out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
987
def test_versioned_file_within_dir_two_levels(self):
988
"""(versioned) Search for pattern while in nested dir (two levels).
991
self.make_branch_and_tree(wd)
993
self._mk_versioned_dir('dir0')
994
self._mk_versioned_dir('dir0/dir1')
995
self._mk_versioned_file('dir0/dir1/file0.txt')
998
out, err = self.run_bzr(['grep', '-r', 'last:1', '.ine1'])
999
self.assertContainsRe(
1000
out, "^dir1/file0.txt~.:line1", flags=TestGrep._reflags)
1002
out, err = self.run_bzr(
1003
['grep', '-r', 'last:1', '--from-root', 'l.ne1'])
1004
self.assertContainsRe(
1005
out, "^dir0/dir1/file0.txt~.:line1", flags=TestGrep._reflags)
1007
out, err = self.run_bzr(
1008
['grep', '-r', 'last:1', '--no-recursive', 'line1'])
1009
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1011
out, err = self.run_bzr(['grep', '-r', 'last:1', 'lin.1'])
1012
self.assertContainsRe(
1013
out, "^dir1/file0.txt~.:line1", flags=TestGrep._reflags)
1015
out, err = self.run_bzr(
1016
['grep', '-r', 'last:1', '--from-root', 'line1'])
1017
self.assertContainsRe(
1018
out, "^dir0/dir1/file0.txt~.:line1", flags=TestGrep._reflags)
1020
out, err = self.run_bzr(
1021
['grep', '-r', 'last:1', '--no-recursive', 'line1'])
1022
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1023
self.assertEqual(len(out.splitlines()), 0)
1025
def test_wtree_file_within_dir_two_levels(self):
1026
"""(wtree) Search for pattern while in nested dir (two levels).
1029
self.make_branch_and_tree(wd)
1031
self._mk_versioned_dir('dir0')
1032
self._mk_versioned_dir('dir0/dir1')
1033
self._mk_versioned_file('dir0/dir1/file0.txt')
1036
out, err = self.run_bzr(['grep', 'l[hij]ne1'])
1037
self.assertContainsRe(out, "^dir1/file0.txt:line1",
1038
flags=TestGrep._reflags)
1040
out, err = self.run_bzr(['grep', '--from-root', 'l.ne1'])
1041
self.assertContainsRe(
1042
out, "^dir0/dir1/file0.txt:line1", flags=TestGrep._reflags)
1044
out, err = self.run_bzr(['grep', '--no-recursive', 'lin.1'])
1045
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1047
out, err = self.run_bzr(['grep', 'line1'])
1048
self.assertContainsRe(out, "^dir1/file0.txt:line1",
1049
flags=TestGrep._reflags)
1051
out, err = self.run_bzr(['grep', '--from-root', 'line1'])
1052
self.assertContainsRe(
1053
out, "^dir0/dir1/file0.txt:line1", flags=TestGrep._reflags)
1055
out, err = self.run_bzr(['grep', '--no-recursive', 'line1'])
1056
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1058
def test_versioned_ignore_case_no_match(self):
1059
"""(versioned) Match fails without --ignore-case.
1062
self.make_branch_and_tree(wd)
1064
self._mk_versioned_file('file0.txt')
1066
out, err = self.run_bzr(['grep', '-r', 'last:1', 'LinE1', 'file0.txt'])
1067
self.assertNotContainsRe(
1068
out, "file0.txt~.:line1", flags=TestGrep._reflags)
1070
out, err = self.run_bzr(['grep', '-r', 'last:1', 'Li.E1', 'file0.txt'])
1071
self.assertNotContainsRe(
1072
out, "file0.txt~.:line1", flags=TestGrep._reflags)
1074
def test_wtree_ignore_case_no_match(self):
1075
"""(wtree) Match fails without --ignore-case.
1078
self.make_branch_and_tree(wd)
1080
self._mk_versioned_file('file0.txt')
1082
out, err = self.run_bzr(['grep', 'LinE1', 'file0.txt'])
1083
self.assertNotContainsRe(
1084
out, "file0.txt:line1", flags=TestGrep._reflags)
1086
out, err = self.run_bzr(['grep', '.inE1', 'file0.txt'])
1087
self.assertNotContainsRe(
1088
out, "file0.txt:line1", flags=TestGrep._reflags)
1090
def test_versioned_ignore_case_match(self):
1091
"""(versioned) Match fails without --ignore-case.
1094
self.make_branch_and_tree(wd)
1096
self._mk_versioned_file('file0.txt')
1098
out, err = self.run_bzr(['grep', '-r', 'last:1',
1099
'-i', 'Li.E1', 'file0.txt'])
1100
self.assertContainsRe(out, "file0.txt~.:line1",
1101
flags=TestGrep._reflags)
1103
out, err = self.run_bzr(['grep', '-r', 'last:1',
1104
'-i', 'LinE1', 'file0.txt'])
1105
self.assertContainsRe(out, "file0.txt~.:line1",
1106
flags=TestGrep._reflags)
1108
out, err = self.run_bzr(['grep', '-r', 'last:1',
1109
'--ignore-case', 'LinE1', 'file0.txt'])
1110
self.assertContainsRe(out, "^file0.txt~.:line1",
1111
flags=TestGrep._reflags)
1113
def test_wtree_ignore_case_match(self):
1114
"""(wtree) Match fails without --ignore-case.
1117
self.make_branch_and_tree(wd)
1119
self._mk_versioned_file('file0.txt')
1121
out, err = self.run_bzr(['grep', '-i', 'LinE1', 'file0.txt'])
1122
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
1124
out, err = self.run_bzr(
1125
['grep', '--ignore-case', 'LinE1', 'file0.txt'])
1126
self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
1128
out, err = self.run_bzr(
1129
['grep', '--ignore-case', 'Li.E1', 'file0.txt'])
1130
self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
1132
def test_versioned_from_root_fail(self):
1133
"""(versioned) Match should fail without --from-root.
1136
self.make_branch_and_tree(wd)
1138
self._mk_versioned_file('file0.txt')
1139
self._mk_versioned_dir('dir0')
1142
out, err = self.run_bzr(['grep', '-r', 'last:1', 'li.e1'])
1143
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1145
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
1146
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1148
def test_wtree_from_root_fail(self):
1149
"""(wtree) Match should fail without --from-root.
1152
self.make_branch_and_tree(wd)
1154
self._mk_versioned_file('file0.txt')
1155
self._mk_versioned_dir('dir0')
1158
out, err = self.run_bzr(['grep', 'line1'])
1159
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1161
out, err = self.run_bzr(['grep', 'li.e1'])
1162
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1164
def test_versioned_from_root_pass(self):
1165
"""(versioned) Match pass with --from-root.
1168
self.make_branch_and_tree(wd)
1170
self._mk_versioned_file('file0.txt')
1171
self._mk_versioned_dir('dir0')
1174
out, err = self.run_bzr(['grep', '-r', 'last:1',
1175
'--from-root', 'l.ne1'])
1176
self.assertContainsRe(out, "file0.txt~.:line1",
1177
flags=TestGrep._reflags)
1179
out, err = self.run_bzr(['grep', '-r', 'last:1',
1180
'--from-root', 'line1'])
1181
self.assertContainsRe(out, "file0.txt~.:line1",
1182
flags=TestGrep._reflags)
1184
def test_wtree_from_root_pass(self):
1185
"""(wtree) Match pass with --from-root.
1188
self.make_branch_and_tree(wd)
1190
self._mk_versioned_file('file0.txt')
1191
self._mk_versioned_dir('dir0')
1194
out, err = self.run_bzr(['grep', '--from-root', 'lin.1'])
1195
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
1197
out, err = self.run_bzr(['grep', '--from-root', 'line1'])
1198
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
1200
def test_versioned_with_line_number(self):
1201
"""(versioned) Search for pattern with --line-number.
1204
self.make_branch_and_tree(wd)
1206
self._mk_versioned_file('file0.txt')
1208
out, err = self.run_bzr(['grep', '-r', 'last:1',
1209
'--line-number', 'li.e3', 'file0.txt'])
1210
self.assertContainsRe(out, "file0.txt~.:3:line3",
1211
flags=TestGrep._reflags)
1213
out, err = self.run_bzr(['grep', '-r', 'last:1',
1214
'--line-number', 'line3', 'file0.txt'])
1215
self.assertContainsRe(out, "file0.txt~.:3:line3",
1216
flags=TestGrep._reflags)
1218
out, err = self.run_bzr(['grep', '-r', 'last:1',
1219
'-n', 'line1', 'file0.txt'])
1220
self.assertContainsRe(out, "file0.txt~.:1:line1",
1221
flags=TestGrep._reflags)
1223
out, err = self.run_bzr(['grep', '-n', 'line[0-9]', 'file0.txt'])
1224
self.assertContainsRe(out, "file0.txt:3:line3",
1225
flags=TestGrep._reflags)
1227
def test_wtree_with_line_number(self):
1228
"""(wtree) Search for pattern with --line-number.
1231
self.make_branch_and_tree(wd)
1233
self._mk_versioned_file('file0.txt')
1235
out, err = self.run_bzr(
1236
['grep', '--line-number', 'line3', 'file0.txt'])
1237
self.assertContainsRe(out, "file0.txt:3:line3",
1238
flags=TestGrep._reflags)
1240
out, err = self.run_bzr(['grep', '-n', 'line1', 'file0.txt'])
1241
self.assertContainsRe(out, "file0.txt:1:line1",
1242
flags=TestGrep._reflags)
1244
out, err = self.run_bzr(['grep', '-n', '[hjkl]ine1', 'file0.txt'])
1245
self.assertContainsRe(out, "file0.txt:1:line1",
1246
flags=TestGrep._reflags)
1248
out, err = self.run_bzr(['grep', '-n', 'line[0-9]', 'file0.txt'])
1249
self.assertContainsRe(out, "file0.txt:3:line3",
1250
flags=TestGrep._reflags)
1252
def test_revno_basic_history_grep_file(self):
1253
"""Search for pattern in specific revision number in a file.
1257
self.make_branch_and_tree(wd)
1259
self._mk_versioned_file(fname, total_lines=0)
1260
self._update_file(fname, text="v2 text\n")
1261
self._update_file(fname, text="v3 text\n")
1262
self._update_file(fname, text="v4 text\n")
1264
# rev 2 should not have text 'v3'
1265
out, err = self.run_bzr(['grep', '-r', '2', 'v3', fname])
1266
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1268
# rev 3 should not have text 'v3'
1269
out, err = self.run_bzr(['grep', '-r', '3', 'v3', fname])
1270
self.assertContainsRe(out, "file0.txt~3:v3.*", flags=TestGrep._reflags)
1272
# rev 3 should not have text 'v3' with line number
1273
out, err = self.run_bzr(['grep', '-r', '3', '-n', 'v3', fname])
1274
self.assertContainsRe(out, "file0.txt~3:2:v3.*",
1275
flags=TestGrep._reflags)
1277
# rev 2 should not have text 'v3'
1278
out, err = self.run_bzr(['grep', '-r', '2', '[tuv]3', fname])
1279
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1281
# rev 3 should not have text 'v3'
1282
out, err = self.run_bzr(['grep', '-r', '3', '[tuv]3', fname])
1283
self.assertContainsRe(out, "file0.txt~3:v3.*", flags=TestGrep._reflags)
1285
# rev 3 should not have text 'v3' with line number
1286
out, err = self.run_bzr(['grep', '-r', '3', '-n', '[tuv]3', fname])
1287
self.assertContainsRe(out, "file0.txt~3:2:v3.*",
1288
flags=TestGrep._reflags)
1290
def test_revno_basic_history_grep_full(self):
1291
"""Search for pattern in specific revision number in a file.
1295
self.make_branch_and_tree(wd)
1297
self._mk_versioned_file(fname, total_lines=0) # rev1
1298
self._mk_versioned_file('file1.txt') # rev2
1299
self._update_file(fname, text="v3 text\n") # rev3
1300
self._update_file(fname, text="v4 text\n") # rev4
1301
self._update_file(fname, text="v5 text\n") # rev5
1303
# rev 2 should not have text 'v3'
1304
out, err = self.run_bzr(['grep', '-r', '2', 'v3'])
1305
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1307
# rev 3 should not have text 'v3'
1308
out, err = self.run_bzr(['grep', '-r', '3', 'v3'])
1309
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1311
# rev 3 should not have text 'v3' with line number
1312
out, err = self.run_bzr(['grep', '-r', '3', '-n', 'v3'])
1313
self.assertContainsRe(out, "file0.txt~3:1:v3", flags=TestGrep._reflags)
1315
# rev 2 should not have text 'v3'
1316
out, err = self.run_bzr(['grep', '-r', '2', '[tuv]3'])
1317
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1319
# rev 3 should not have text 'v3'
1320
out, err = self.run_bzr(['grep', '-r', '3', '[tuv]3'])
1321
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1323
# rev 3 should not have text 'v3' with line number
1324
out, err = self.run_bzr(['grep', '-r', '3', '-n', '[tuv]3'])
1325
self.assertContainsRe(out, "file0.txt~3:1:v3", flags=TestGrep._reflags)
1327
def test_revno_versioned_file_in_dir(self):
1328
"""Grep specific version of file withing dir.
1331
self.make_branch_and_tree(wd)
1333
self._mk_versioned_dir('dir0') # rev1
1334
self._mk_versioned_file('dir0/file0.txt') # rev2
1335
self._update_file('dir0/file0.txt', "v3 text\n") # rev3
1336
self._update_file('dir0/file0.txt', "v4 text\n") # rev4
1337
self._update_file('dir0/file0.txt', "v5 text\n") # rev5
1339
# v4 should not be present in revno 3
1340
out, err = self.run_bzr(['grep', '-r', 'last:3', 'v4'])
1341
self.assertNotContainsRe(
1342
out, "^dir0/file0.txt", flags=TestGrep._reflags)
1344
# v4 should be present in revno 4
1345
out, err = self.run_bzr(['grep', '-r', 'last:2', 'v4'])
1346
self.assertContainsRe(out, "^dir0/file0.txt~4:v4",
1347
flags=TestGrep._reflags)
1349
# v4 should not be present in revno 3
1350
out, err = self.run_bzr(['grep', '-r', 'last:3', '[tuv]4'])
1351
self.assertNotContainsRe(
1352
out, "^dir0/file0.txt", flags=TestGrep._reflags)
1354
# v4 should be present in revno 4
1355
out, err = self.run_bzr(['grep', '-r', 'last:2', '[tuv]4'])
1356
self.assertContainsRe(out, "^dir0/file0.txt~4:v4",
1357
flags=TestGrep._reflags)
1359
def test_revno_range_basic_history_grep(self):
1360
"""Search for pattern in revision range for file.
1364
self.make_branch_and_tree(wd)
1366
self._mk_versioned_file(fname, total_lines=0) # rev1
1367
self._mk_versioned_file('file1.txt') # rev2
1368
self._update_file(fname, text="v3 text\n") # rev3
1369
self._update_file(fname, text="v4 text\n") # rev4
1370
self._update_file(fname, text="v5 text\n") # rev5
1371
self._update_file(fname, text="v6 text\n") # rev6
1373
out, err = self.run_bzr(['grep', '-r', '1..', 'v3'])
1374
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1375
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1376
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1377
self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1378
self.assertEqual(len(out.splitlines()), 4)
1380
out, err = self.run_bzr(['grep', '-r', '..1', 'v3'])
1381
# searching only rev1 gives nothing
1382
self.assertEqual(len(out.splitlines()), 0)
1384
out, err = self.run_bzr(['grep', '-r', '..6', 'v3'])
1385
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1386
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1387
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1388
self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1389
self.assertEqual(len(out.splitlines()), 4)
1391
out, err = self.run_bzr(['grep', '-r', '..', 'v3'])
1392
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1393
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1394
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1395
self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1396
self.assertEqual(len(out.splitlines()), 4)
1398
out, err = self.run_bzr(['grep', '-r', '1..5', 'v3'])
1399
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1400
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1401
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1402
self.assertNotContainsRe(
1403
out, "file0.txt~6:v3", flags=TestGrep._reflags)
1404
self.assertEqual(len(out.splitlines()), 3)
1406
out, err = self.run_bzr(['grep', '-r', '5..1', 'v3'])
1407
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1408
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1409
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1410
self.assertNotContainsRe(
1411
out, "file0.txt~6:v3", flags=TestGrep._reflags)
1412
self.assertEqual(len(out.splitlines()), 3)
1414
out, err = self.run_bzr(['grep', '-r', '1..', '[tuv]3'])
1415
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1416
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1417
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1418
self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1419
self.assertEqual(len(out.splitlines()), 4)
1421
out, err = self.run_bzr(['grep', '-r', '1..5', '[tuv]3'])
1422
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1423
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1424
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1425
self.assertNotContainsRe(
1426
out, "file0.txt~6:v3", flags=TestGrep._reflags)
1427
self.assertEqual(len(out.splitlines()), 3)
1429
out, err = self.run_bzr(['grep', '-r', '5..1', '[tuv]3'])
1430
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1431
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1432
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1433
self.assertNotContainsRe(
1434
out, "file0.txt~6:v3", flags=TestGrep._reflags)
1435
self.assertEqual(len(out.splitlines()), 3)
1437
def test_revno_range_versioned_file_in_dir(self):
1438
"""Grep rev-range for pattern for file withing a dir.
1441
self.make_branch_and_tree(wd)
1443
self._mk_versioned_dir('dir0') # rev1
1444
self._mk_versioned_file('dir0/file0.txt') # rev2
1445
self._update_file('dir0/file0.txt', "v3 text\n") # rev3
1446
self._update_file('dir0/file0.txt', "v4 text\n") # rev4
1447
self._update_file('dir0/file0.txt', "v5 text\n") # rev5
1448
self._update_file('dir0/file0.txt', "v6 text\n") # rev6
1450
out, err = self.run_bzr(['grep', '-r', '2..5', 'v3'])
1451
self.assertContainsRe(out, "^dir0/file0.txt~3:v3",
1452
flags=TestGrep._reflags)
1453
self.assertContainsRe(out, "^dir0/file0.txt~4:v3",
1454
flags=TestGrep._reflags)
1455
self.assertContainsRe(out, "^dir0/file0.txt~5:v3",
1456
flags=TestGrep._reflags)
1457
self.assertNotContainsRe(
1458
out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1459
self.assertEqual(len(out.splitlines()), 3)
1461
out, err = self.run_bzr(['grep', '-r', '2..5', '[tuv]3'])
1462
self.assertContainsRe(out, "^dir0/file0.txt~3:v3",
1463
flags=TestGrep._reflags)
1464
self.assertContainsRe(out, "^dir0/file0.txt~4:v3",
1465
flags=TestGrep._reflags)
1466
self.assertContainsRe(out, "^dir0/file0.txt~5:v3",
1467
flags=TestGrep._reflags)
1468
self.assertNotContainsRe(
1469
out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1470
self.assertEqual(len(out.splitlines()), 3)
1472
def test_revno_range_versioned_file_from_outside_dir(self):
1473
"""Grep rev-range for pattern from outside dir.
1476
self.make_branch_and_tree(wd)
1478
self._mk_versioned_dir('dir0') # rev1
1479
self._mk_versioned_file('dir0/file0.txt') # rev2
1480
self._update_file('dir0/file0.txt', "v3 text\n") # rev3
1481
self._update_file('dir0/file0.txt', "v4 text\n") # rev4
1482
self._update_file('dir0/file0.txt', "v5 text\n") # rev5
1483
self._update_file('dir0/file0.txt', "v6 text\n") # rev6
1485
out, err = self.run_bzr(['grep', '-r', '2..5', 'v3', 'dir0'])
1486
self.assertContainsRe(out, "^dir0/file0.txt~3:v3",
1487
flags=TestGrep._reflags)
1488
self.assertContainsRe(out, "^dir0/file0.txt~4:v3",
1489
flags=TestGrep._reflags)
1490
self.assertContainsRe(out, "^dir0/file0.txt~5:v3",
1491
flags=TestGrep._reflags)
1492
self.assertNotContainsRe(
1493
out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1495
out, err = self.run_bzr(['grep', '-r', '2..5', '[tuv]3', 'dir0'])
1496
self.assertContainsRe(out, "^dir0/file0.txt~3:v3",
1497
flags=TestGrep._reflags)
1498
self.assertContainsRe(out, "^dir0/file0.txt~4:v3",
1499
flags=TestGrep._reflags)
1500
self.assertContainsRe(out, "^dir0/file0.txt~5:v3",
1501
flags=TestGrep._reflags)
1502
self.assertNotContainsRe(
1503
out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1505
def test_levels(self):
1506
"""--levels=0 should show findings from merged revision.
1511
self.make_branch_and_tree(wd0)
1513
self._mk_versioned_file('file0.txt')
1516
out, err = self.run_bzr(['branch', wd0, wd1])
1518
self._mk_versioned_file('file1.txt')
1519
os.chdir(osutils.pathjoin('..', wd0))
1521
out, err = self.run_bzr(['merge', osutils.pathjoin('..', wd1)])
1522
out, err = self.run_bzr(['ci', '-m', 'merged'])
1524
out, err = self.run_bzr(['grep', 'line1'])
1525
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
1526
self.assertContainsRe(out, "file1.txt:line1", flags=TestGrep._reflags)
1528
# levels should be ignored by wtree grep
1529
out, err = self.run_bzr(['grep', '--levels=0', 'line1'])
1530
self.assertContainsRe(out, "^file0.txt:line1$",
1531
flags=TestGrep._reflags)
1532
self.assertContainsRe(out, "^file1.txt:line1$",
1533
flags=TestGrep._reflags)
1534
self.assertContainsRe(out, "^file0.txt:line10$",
1535
flags=TestGrep._reflags)
1536
self.assertContainsRe(out, "^file1.txt:line10$",
1537
flags=TestGrep._reflags)
1538
self.assertEqual(len(out.splitlines()), 4)
1540
out, err = self.run_bzr(
1541
['grep', '-r', 'last:1..', '--levels=0', 'line1'])
1542
self.assertContainsRe(out, "^file0.txt~2:line1$",
1543
flags=TestGrep._reflags)
1544
self.assertContainsRe(out, "^file1.txt~2:line1$",
1545
flags=TestGrep._reflags)
1546
self.assertContainsRe(
1547
out, "^file0.txt~1.1.1:line1$", flags=TestGrep._reflags)
1548
self.assertContainsRe(
1549
out, "^file1.txt~1.1.1:line1$", flags=TestGrep._reflags)
1550
self.assertContainsRe(out, "^file0.txt~2:line10$",
1551
flags=TestGrep._reflags)
1552
self.assertContainsRe(out, "^file1.txt~2:line10$",
1553
flags=TestGrep._reflags)
1554
self.assertContainsRe(
1555
out, "^file0.txt~1.1.1:line10$", flags=TestGrep._reflags)
1556
self.assertContainsRe(
1557
out, "^file1.txt~1.1.1:line10$", flags=TestGrep._reflags)
1558
self.assertEqual(len(out.splitlines()), 8)
1560
out, err = self.run_bzr(
1561
['grep', '-r', '-1..', '-n', '--levels=0', 'line1'])
1562
self.assertContainsRe(out, "^file0.txt~2:1:line1$",
1563
flags=TestGrep._reflags)
1564
self.assertContainsRe(out, "^file1.txt~2:1:line1$",
1565
flags=TestGrep._reflags)
1566
self.assertContainsRe(
1567
out, "^file0.txt~1.1.1:1:line1$", flags=TestGrep._reflags)
1568
self.assertContainsRe(
1569
out, "^file1.txt~1.1.1:1:line1$", flags=TestGrep._reflags)
1570
self.assertContainsRe(
1571
out, "^file0.txt~2:10:line10$", flags=TestGrep._reflags)
1572
self.assertContainsRe(
1573
out, "^file1.txt~2:10:line10$", flags=TestGrep._reflags)
1574
self.assertContainsRe(
1575
out, "^file0.txt~1.1.1:10:line10$", flags=TestGrep._reflags)
1576
self.assertContainsRe(
1577
out, "^file1.txt~1.1.1:10:line10$", flags=TestGrep._reflags)
1578
self.assertEqual(len(out.splitlines()), 8)
1580
# levels should be ignored by wtree grep
1581
out, err = self.run_bzr(['grep', '--levels=0', 'l.ne1'])
1582
self.assertContainsRe(out, "^file0.txt:line1$",
1583
flags=TestGrep._reflags)
1584
self.assertContainsRe(out, "^file1.txt:line1$",
1585
flags=TestGrep._reflags)
1586
self.assertContainsRe(out, "^file0.txt:line10$",
1587
flags=TestGrep._reflags)
1588
self.assertContainsRe(out, "^file1.txt:line10$",
1589
flags=TestGrep._reflags)
1590
self.assertEqual(len(out.splitlines()), 4)
1592
out, err = self.run_bzr(
1593
['grep', '-r', 'last:1..', '--levels=0', 'lin.1'])
1594
self.assertContainsRe(out, "^file0.txt~2:line1$",
1595
flags=TestGrep._reflags)
1596
self.assertContainsRe(out, "^file1.txt~2:line1$",
1597
flags=TestGrep._reflags)
1598
self.assertContainsRe(
1599
out, "^file0.txt~1.1.1:line1$", flags=TestGrep._reflags)
1600
self.assertContainsRe(
1601
out, "^file1.txt~1.1.1:line1$", flags=TestGrep._reflags)
1602
self.assertContainsRe(out, "^file0.txt~2:line10$",
1603
flags=TestGrep._reflags)
1604
self.assertContainsRe(out, "^file1.txt~2:line10$",
1605
flags=TestGrep._reflags)
1606
self.assertContainsRe(
1607
out, "^file0.txt~1.1.1:line10$", flags=TestGrep._reflags)
1608
self.assertContainsRe(
1609
out, "^file1.txt~1.1.1:line10$", flags=TestGrep._reflags)
1610
self.assertEqual(len(out.splitlines()), 8)
1612
out, err = self.run_bzr(
1613
['grep', '-r', '-1..', '-n', '--levels=0', '.ine1'])
1614
self.assertContainsRe(out, "file0.txt~2:1:line1",
1615
flags=TestGrep._reflags)
1616
self.assertContainsRe(out, "file1.txt~2:1:line1",
1617
flags=TestGrep._reflags)
1618
self.assertContainsRe(
1619
out, "file0.txt~1.1.1:1:line1", flags=TestGrep._reflags)
1620
self.assertContainsRe(
1621
out, "file1.txt~1.1.1:1:line1", flags=TestGrep._reflags)
1623
def test_dotted_rev_grep(self):
1624
"""Grep in dotted revs
1629
self.make_branch_and_tree(wd0)
1631
self._mk_versioned_file('file0.txt')
1634
out, err = self.run_bzr(['branch', wd0, wd1])
1636
self._mk_versioned_file('file1.txt') # revno 1.1.1
1637
self._update_file('file1.txt', "text 0\n") # revno 1.1.2
1638
self._update_file('file1.txt', "text 1\n") # revno 1.1.3
1639
self._update_file('file1.txt', "text 2\n") # revno 1.1.4
1640
os.chdir(osutils.pathjoin('..', wd0))
1642
out, err = self.run_bzr(['merge', osutils.pathjoin('..', wd1)])
1643
out, err = self.run_bzr(['ci', '-m', 'merged'])
1645
out, err = self.run_bzr(['grep', '-r', '1.1.1..1.1.4', 'text'])
1646
self.assertContainsRe(
1647
out, "file1.txt~1.1.2:text 0", 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.3:text 1", flags=TestGrep._reflags)
1652
self.assertContainsRe(
1653
out, "file1.txt~1.1.4:text 0", flags=TestGrep._reflags)
1654
self.assertContainsRe(
1655
out, "file1.txt~1.1.4:text 1", flags=TestGrep._reflags)
1656
self.assertContainsRe(
1657
out, "file1.txt~1.1.4:text 2", flags=TestGrep._reflags)
1658
self.assertEqual(len(out.splitlines()), 6)
1660
def test_versioned_binary_file_grep(self):
1661
"""(versioned) Grep for pattern in binary file.
1664
self.make_branch_and_tree(wd)
1666
self._mk_versioned_file('file.txt')
1667
self._mk_versioned_file('file0.bin')
1668
self._update_file('file0.bin', "\x00lineNN\x00\n")
1670
# note: set --verbose/-v flag to get the skip message.
1671
out, err = self.run_bzr(['grep', '-v', '-r', 'last:1',
1672
'lineNN', 'file0.bin'])
1673
self.assertNotContainsRe(out, "file0.bin", flags=TestGrep._reflags)
1674
self.assertContainsRe(
1675
err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
1676
self.assertEqual(len(out.splitlines()), 0)
1677
self.assertEqual(len(err.splitlines()), 1)
1679
out, err = self.run_bzr(['grep', '-v', '-r', 'last:1',
1680
'line.N', 'file0.bin'])
1681
self.assertNotContainsRe(out, "file0.bin", flags=TestGrep._reflags)
1682
self.assertContainsRe(
1683
err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
1684
self.assertEqual(len(out.splitlines()), 0)
1685
self.assertEqual(len(err.splitlines()), 1)
1687
def test_wtree_binary_file_grep(self):
1688
"""(wtree) Grep for pattern in binary file.
1691
self.make_branch_and_tree(wd)
1693
self._mk_versioned_file('file0.bin')
1694
self._update_file('file0.bin', "\x00lineNN\x00\n")
1696
# note: set --verbose/-v flag to get the skip message.
1697
out, err = self.run_bzr(['grep', '-v', 'lineNN', 'file0.bin'])
1698
self.assertNotContainsRe(
1699
out, "file0.bin:line1", flags=TestGrep._reflags)
1700
self.assertContainsRe(
1701
err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
1703
# binary warning should not be shown without --verbose
1704
out, err = self.run_bzr(['grep', 'lineNN', 'file0.bin'])
1705
self.assertNotContainsRe(
1706
out, "file0.bin:line1", flags=TestGrep._reflags)
1707
self.assertNotContainsRe(err, "Binary file", flags=TestGrep._reflags)
1709
def test_revspec(self):
1710
"""Ensure various revspecs work
1713
self.make_branch_and_tree(wd)
1715
self._mk_versioned_dir('dir0') # rev1
1716
self._mk_versioned_file('dir0/file0.txt') # rev2
1717
self._update_file('dir0/file0.txt', "v3 text\n") # rev3
1718
self._update_file('dir0/file0.txt', "v4 text\n") # rev4
1719
self._update_file('dir0/file0.txt', "v5 text\n") # rev5
1721
out, err = self.run_bzr(['grep', '-r', 'revno:1..2', 'v3'])
1722
self.assertNotContainsRe(out, "file0", flags=TestGrep._reflags)
1723
self.assertEqual(len(out.splitlines()), 0)
1725
out, err = self.run_bzr(['grep', '-r', 'revno:4..', 'v4'])
1726
self.assertContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
1727
self.assertEqual(len(out.splitlines()), 2) # find v4 in rev4 and rev5
1729
out, err = self.run_bzr(['grep', '-r', '..revno:3', 'v4'])
1730
self.assertNotContainsRe(out, "file0", flags=TestGrep._reflags)
1731
self.assertEqual(len(out.splitlines()), 0)
1733
out, err = self.run_bzr(['grep', '-r', '..revno:3', 'v3'])
1734
self.assertContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
1735
self.assertEqual(len(out.splitlines()), 1)
1737
def test_wtree_files_with_matches(self):
1738
"""(wtree) Ensure --files-with-matches, -l works
1741
self.make_branch_and_tree(wd)
1744
self._mk_versioned_file('file0.txt', total_lines=2)
1745
self._mk_versioned_file('file1.txt', total_lines=2)
1746
self._mk_versioned_dir('dir0')
1747
self._mk_versioned_file('dir0/file00.txt', total_lines=2)
1748
self._mk_versioned_file('dir0/file01.txt', total_lines=2)
1750
self._update_file('file0.txt', 'HELLO\n', checkin=False)
1751
self._update_file('dir0/file00.txt', 'HELLO\n', checkin=False)
1754
out, err = self.run_bzr(['grep', '--files-with-matches', 'HELLO'])
1756
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1757
self.assertContainsRe(out, "^dir0/file00.txt$",
1758
flags=TestGrep._reflags)
1759
self.assertEqual(len(out.splitlines()), 2)
1762
out, err = self.run_bzr(['grep', '--files-with-matches', 'HE.LO'])
1764
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1765
self.assertContainsRe(out, "^dir0/file00.txt$",
1766
flags=TestGrep._reflags)
1767
self.assertEqual(len(out.splitlines()), 2)
1770
out, err = self.run_bzr(['grep', '-l', 'HELLO'])
1772
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1773
self.assertContainsRe(out, "^dir0/file00.txt$",
1774
flags=TestGrep._reflags)
1775
self.assertEqual(len(out.splitlines()), 2)
1778
out, err = self.run_bzr(['grep', '-l', 'HE.LO'])
1780
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1781
self.assertContainsRe(out, "^dir0/file00.txt$",
1782
flags=TestGrep._reflags)
1783
self.assertEqual(len(out.splitlines()), 2)
1786
out, err = self.run_bzr(['grep', '-l', 'HELLO', 'dir0', 'file1.txt'])
1788
self.assertContainsRe(out, "^dir0/file00.txt$",
1789
flags=TestGrep._reflags)
1790
self.assertEqual(len(out.splitlines()), 1)
1793
out, err = self.run_bzr(['grep', '-l', '.ELLO', 'dir0', 'file1.txt'])
1795
self.assertContainsRe(out, "^dir0/file00.txt$",
1796
flags=TestGrep._reflags)
1797
self.assertEqual(len(out.splitlines()), 1)
1800
out, err = self.run_bzr(['grep', '-l', 'HELLO', 'file0.txt'])
1802
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1803
self.assertEqual(len(out.splitlines()), 1)
1806
out, err = self.run_bzr(['grep', '-l', '.ELLO', 'file0.txt'])
1808
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1809
self.assertEqual(len(out.splitlines()), 1)
1812
out, err = self.run_bzr(['grep', '--no-recursive', '-l', 'HELLO'])
1814
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1815
self.assertEqual(len(out.splitlines()), 1)
1818
out, err = self.run_bzr(['grep', '--no-recursive', '-l', '.ELLO'])
1820
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1821
self.assertEqual(len(out.splitlines()), 1)
1823
def test_ver_files_with_matches(self):
1824
"""(ver) Ensure --files-with-matches, -l works
1827
self.make_branch_and_tree(wd)
1830
self._mk_versioned_file('file0.txt', total_lines=2) # rev 1
1831
self._mk_versioned_file('file1.txt', total_lines=2) # rev 2
1832
self._mk_versioned_dir('dir0') # rev 3
1833
self._mk_versioned_file('dir0/file00.txt', total_lines=2) # rev 4
1834
self._mk_versioned_file('dir0/file01.txt', total_lines=2) # rev 5
1836
self._update_file('file0.txt', 'HELLO\n') # rev 6
1837
self._update_file('dir0/file00.txt', 'HELLO\n') # rev 7
1840
out, err = self.run_bzr(['grep', '-r', '-1', '--files-with-matches',
1843
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1844
self.assertContainsRe(out, "^dir0/file00.txt~7$",
1845
flags=TestGrep._reflags)
1846
self.assertEqual(len(out.splitlines()), 2)
1849
out, err = self.run_bzr(['grep', '-r', '-1', '--files-with-matches',
1852
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1853
self.assertContainsRe(out, "^dir0/file00.txt~7$",
1854
flags=TestGrep._reflags)
1855
self.assertEqual(len(out.splitlines()), 2)
1858
out, err = self.run_bzr(['grep', '-r', '6..7', '--files-with-matches',
1861
self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1862
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1863
self.assertContainsRe(out, "^dir0/file00.txt~7$",
1864
flags=TestGrep._reflags)
1865
self.assertEqual(len(out.splitlines()), 3)
1868
out, err = self.run_bzr(['grep', '-r', '6..7', '--files-with-matches',
1871
self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1872
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1873
self.assertContainsRe(out, "^dir0/file00.txt~7$",
1874
flags=TestGrep._reflags)
1875
self.assertEqual(len(out.splitlines()), 3)
1878
out, err = self.run_bzr(['grep', '-r', '-1', '-l', 'HELLO'])
1880
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1881
self.assertContainsRe(out, "^dir0/file00.txt~7$",
1882
flags=TestGrep._reflags)
1883
self.assertEqual(len(out.splitlines()), 2)
1886
out, err = self.run_bzr(['grep', '-r', '-1', '-l', 'H.LLO'])
1888
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1889
self.assertContainsRe(out, "^dir0/file00.txt~7$",
1890
flags=TestGrep._reflags)
1891
self.assertEqual(len(out.splitlines()), 2)
1894
out, err = self.run_bzr(['grep', '-l', 'HELLO', '-r', '-1',
1895
'dir0', 'file1.txt'])
1897
self.assertContainsRe(out, "^dir0/file00.txt~7$",
1898
flags=TestGrep._reflags)
1899
self.assertEqual(len(out.splitlines()), 1)
1902
out, err = self.run_bzr(['grep', '-l', 'H.LLO', '-r', '-1',
1903
'dir0', 'file1.txt'])
1905
self.assertContainsRe(out, "^dir0/file00.txt~7$",
1906
flags=TestGrep._reflags)
1907
self.assertEqual(len(out.splitlines()), 1)
1910
out, err = self.run_bzr(['grep', '-l', 'HELLO',
1911
'-r', '-2', 'file0.txt'])
1913
self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1914
self.assertEqual(len(out.splitlines()), 1)
1917
out, err = self.run_bzr(['grep', '-l', 'HE.LO',
1918
'-r', '-2', 'file0.txt'])
1920
self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1921
self.assertEqual(len(out.splitlines()), 1)
1924
out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
1927
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1928
self.assertEqual(len(out.splitlines()), 1)
1931
out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
1934
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1935
self.assertEqual(len(out.splitlines()), 1)
1937
def test_wtree_files_without_matches(self):
1938
"""(wtree) Ensure --files-without-match, -L works
1941
self.make_branch_and_tree(wd)
1944
self._mk_versioned_file('file0.txt', total_lines=2)
1945
self._mk_versioned_file('file1.txt', total_lines=2)
1946
self._mk_versioned_dir('dir0')
1947
self._mk_versioned_file('dir0/file00.txt', total_lines=2)
1948
self._mk_versioned_file('dir0/file01.txt', total_lines=2)
1950
self._update_file('file0.txt', 'HELLO\n', checkin=False)
1951
self._update_file('dir0/file00.txt', 'HELLO\n', checkin=False)
1954
out, err = self.run_bzr(['grep', '--files-without-match', 'HELLO'])
1956
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1957
self.assertContainsRe(out, "^dir0/file01.txt$",
1958
flags=TestGrep._reflags)
1959
self.assertEqual(len(out.splitlines()), 2)
1962
out, err = self.run_bzr(['grep', '--files-without-match', 'HE.LO'])
1964
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1965
self.assertContainsRe(out, "^dir0/file01.txt$",
1966
flags=TestGrep._reflags)
1967
self.assertEqual(len(out.splitlines()), 2)
1970
out, err = self.run_bzr(['grep', '-L', 'HELLO'])
1972
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1973
self.assertContainsRe(out, "^dir0/file01.txt$",
1974
flags=TestGrep._reflags)
1975
self.assertEqual(len(out.splitlines()), 2)
1978
out, err = self.run_bzr(['grep', '-L', 'HE.LO'])
1980
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1981
self.assertContainsRe(out, "^dir0/file01.txt$",
1982
flags=TestGrep._reflags)
1983
self.assertEqual(len(out.splitlines()), 2)
1986
out, err = self.run_bzr(['grep', '-L', 'HELLO', 'dir0', 'file1.txt'])
1988
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1989
self.assertContainsRe(out, "^dir0/file01.txt$",
1990
flags=TestGrep._reflags)
1991
self.assertEqual(len(out.splitlines()), 2)
1994
out, err = self.run_bzr(['grep', '-L', '.ELLO', 'dir0', 'file1.txt'])
1996
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1997
self.assertContainsRe(out, "^dir0/file01.txt$",
1998
flags=TestGrep._reflags)
1999
self.assertEqual(len(out.splitlines()), 2)
2002
out, err = self.run_bzr(['grep', '-L', 'HELLO', 'file1.txt'])
2004
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
2005
self.assertEqual(len(out.splitlines()), 1)
2008
out, err = self.run_bzr(['grep', '-L', '.ELLO', 'file1.txt'])
2010
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
2011
self.assertEqual(len(out.splitlines()), 1)
2014
out, err = self.run_bzr(['grep', '--no-recursive', '-L', 'HELLO'])
2016
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
2017
self.assertEqual(len(out.splitlines()), 1)
2020
out, err = self.run_bzr(['grep', '--no-recursive', '-L', '.ELLO'])
2022
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
2023
self.assertEqual(len(out.splitlines()), 1)
2025
def test_ver_files_without_matches(self):
2026
"""(ver) Ensure --files-without-match, -L works
2029
self.make_branch_and_tree(wd)
2032
self._mk_versioned_file('file0.txt', total_lines=2) # rev 1
2033
self._mk_versioned_file('file1.txt', total_lines=2) # rev 2
2034
self._mk_versioned_dir('dir0') # rev 3
2035
self._mk_versioned_file('dir0/file00.txt', total_lines=2) # rev 4
2036
self._mk_versioned_file('dir0/file01.txt', total_lines=2) # rev 5
2038
self._update_file('file0.txt', 'HELLO\n') # rev 6
2039
self._update_file('dir0/file00.txt', 'HELLO\n') # rev 7
2042
out, err = self.run_bzr(['grep', '-r', '-1', '--files-without-match',
2045
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2046
self.assertContainsRe(out, "^dir0/file01.txt~7$",
2047
flags=TestGrep._reflags)
2048
self.assertEqual(len(out.splitlines()), 2)
2051
out, err = self.run_bzr(['grep', '-r', '-1', '--files-without-match',
2054
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2055
self.assertContainsRe(out, "^dir0/file01.txt~7$",
2056
flags=TestGrep._reflags)
2057
self.assertEqual(len(out.splitlines()), 2)
2060
out, err = self.run_bzr(['grep', '-r', '6..7', '--files-without-match',
2063
self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
2064
self.assertContainsRe(out, "^dir0/file00.txt~6$",
2065
flags=TestGrep._reflags)
2066
self.assertContainsRe(out, "^dir0/file01.txt~6$",
2067
flags=TestGrep._reflags)
2068
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2069
self.assertContainsRe(out, "^dir0/file01.txt~7$",
2070
flags=TestGrep._reflags)
2071
self.assertEqual(len(out.splitlines()), 5)
2074
out, err = self.run_bzr(['grep', '-r', '6..7', '--files-without-match',
2077
self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
2078
self.assertContainsRe(out, "^dir0/file00.txt~6$",
2079
flags=TestGrep._reflags)
2080
self.assertContainsRe(out, "^dir0/file01.txt~6$",
2081
flags=TestGrep._reflags)
2082
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2083
self.assertContainsRe(out, "^dir0/file01.txt~7$",
2084
flags=TestGrep._reflags)
2085
self.assertEqual(len(out.splitlines()), 5)
2088
out, err = self.run_bzr(['grep', '-r', '-1', '-L', 'HELLO'])
2090
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2091
self.assertContainsRe(out, "^dir0/file01.txt~7$",
2092
flags=TestGrep._reflags)
2093
self.assertEqual(len(out.splitlines()), 2)
2096
out, err = self.run_bzr(['grep', '-r', '-1', '-L', 'H.LLO'])
2098
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2099
self.assertContainsRe(out, "^dir0/file01.txt~7$",
2100
flags=TestGrep._reflags)
2101
self.assertEqual(len(out.splitlines()), 2)
2104
out, err = self.run_bzr(['grep', '-L', 'HELLO', '-r', '-1',
2105
'dir0', 'file1.txt'])
2107
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2108
self.assertContainsRe(out, "^dir0/file01.txt~7$",
2109
flags=TestGrep._reflags)
2110
self.assertEqual(len(out.splitlines()), 2)
2113
out, err = self.run_bzr(['grep', '-L', 'H.LLO', '-r', '-1',
2114
'dir0', 'file1.txt'])
2116
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2117
self.assertContainsRe(out, "^dir0/file01.txt~7$",
2118
flags=TestGrep._reflags)
2119
self.assertEqual(len(out.splitlines()), 2)
2122
out, err = self.run_bzr(['grep', '-L', 'HELLO',
2123
'-r', '-2', 'file1.txt'])
2125
self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
2126
self.assertEqual(len(out.splitlines()), 1)
2129
out, err = self.run_bzr(['grep', '-L', 'HE.LO',
2130
'-r', '-2', 'file1.txt'])
2132
self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
2133
self.assertEqual(len(out.splitlines()), 1)
2136
out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
2139
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2140
self.assertEqual(len(out.splitlines()), 1)
2143
out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
2146
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2147
self.assertEqual(len(out.splitlines()), 1)
2149
def test_no_tree(self):
2150
"""Ensure grep works without working tree.
2154
self.make_branch_and_tree(wd0)
2156
self._mk_versioned_file('file0.txt')
2158
out, err = self.run_bzr(['branch', '--no-tree', wd0, wd1])
2161
out, err = self.run_bzr(['grep', 'line1'], 3)
2162
self.assertContainsRe(
2163
err, "Cannot search working tree", flags=TestGrep._reflags)
2164
self.assertEqual(out, '')
2166
out, err = self.run_bzr(['grep', '-r', '1', 'line1'])
2167
self.assertContainsRe(out, "file0.txt~1:line1",
2168
flags=TestGrep._reflags)
2169
self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
2172
class TestNonAscii(GrepTestBase):
2173
"""Tests for non-ascii filenames and file contents"""
2175
_test_needs_features = [UnicodeFilenameFeature]
2177
def test_unicode_only_file(self):
2178
"""Test filename and contents that requires a unicode encoding"""
2179
tree = self.make_branch_and_tree(".")
2180
contents = [u"\u1234"]
2181
self.build_tree(contents)
2183
tree.commit("Initial commit")
2186
# GZ 2010-06-07: Note we can't actually grep for \u1234 as the pattern
2187
# is mangled according to the user encoding.
2188
streams = self.run_bzr_raw(["grep", "--files-with-matches",
2189
u"contents"], encoding="UTF-8")
2190
as_utf8 = as_utf8.encode("UTF-8")
2191
self.assertEqual(streams, (as_utf8 + b"\n", b""))
2193
streams = self.run_bzr_raw(["grep", "-r", "1", "--files-with-matches",
2194
u"contents"], encoding="UTF-8")
2195
self.assertEqual(streams, (as_utf8 + b"~1\n", b""))
2197
fileencoding = osutils.get_user_encoding()
2198
as_mangled = as_utf8.decode(fileencoding, "replace").encode("UTF-8")
2200
streams = self.run_bzr_raw(["grep", "-n",
2201
u"contents"], encoding="UTF-8")
2202
self.assertEqual(streams, (b"%s:1:contents of %s\n" %
2203
(as_utf8, as_mangled), b""))
2205
streams = self.run_bzr_raw(["grep", "-n", "-r", "1",
2206
u"contents"], encoding="UTF-8")
2207
self.assertEqual(streams, (b"%s~1:1:contents of %s\n" %
2208
(as_utf8, as_mangled), b""))
2211
class TestColorGrep(GrepTestBase):
2212
"""Tests for the --color option."""
2214
_rev_sep = color_string('~', fg=FG.BOLD_YELLOW)
2215
_sep = color_string(':', fg=FG.BOLD_CYAN)
2217
def test_color_option(self):
2218
"""Ensure options for color are valid.
2220
out, err = self.run_bzr(['grep', '--color', 'foo', 'bar'], 3)
2221
self.assertEqual(out, '')
2222
self.assertContainsRe(
2223
err, 'Valid values for --color are', flags=TestGrep._reflags)
2225
def test_ver_matching_files(self):
2226
"""(versioned) Search for matches or no matches only"""
2227
tree = self.make_branch_and_tree(".")
2228
contents = ["d/", "d/aaa", "bbb"]
2229
self.build_tree(contents)
2231
tree.commit("Initial commit")
2233
# GZ 2010-06-05: Maybe modify the working tree here
2235
streams = self.run_bzr(["grep", "--color", "always", "-r", "1",
2236
"--files-with-matches", "aaa"])
2237
self.assertEqual(streams, ("".join([
2238
FG.MAGENTA, "d/aaa", self._rev_sep, "1", "\n"
2241
streams = self.run_bzr(["grep", "--color", "always", "-r", "1",
2242
"--files-without-match", "aaa"])
2243
self.assertEqual(streams, ("".join([
2244
FG.MAGENTA, "bbb", self._rev_sep, "1", "\n"
2247
def test_wtree_matching_files(self):
2248
"""(wtree) Search for matches or no matches only"""
2249
tree = self.make_branch_and_tree(".")
2250
contents = ["d/", "d/aaa", "bbb"]
2251
self.build_tree(contents)
2253
tree.commit("Initial commit")
2255
# GZ 2010-06-05: Maybe modify the working tree here
2257
streams = self.run_bzr(["grep", "--color", "always",
2258
"--files-with-matches", "aaa"])
2259
self.assertEqual(streams, ("".join([
2260
FG.MAGENTA, "d/aaa", FG.NONE, "\n"
2263
streams = self.run_bzr(["grep", "--color", "always",
2264
"--files-without-match", "aaa"])
2265
self.assertEqual(streams, ("".join([
2266
FG.MAGENTA, "bbb", FG.NONE, "\n"
2269
def test_ver_basic_file(self):
2270
"""(versioned) Search for pattern in specfic file.
2273
self.make_branch_and_tree(wd)
2275
lp = 'foo is foobar'
2276
self._mk_versioned_file('file0.txt', line_prefix=lp, total_lines=1)
2278
# prepare colored result
2279
foo = color_string('foo', fg=FG.BOLD_RED)
2280
res = (FG.MAGENTA + 'file0.txt'
2281
+ self._rev_sep + '1' + self._sep
2282
+ foo + ' is ' + foo + 'bar1' + '\n')
2283
txt_res = 'file0.txt~1:foo is foobar1\n'
2285
nres = (FG.MAGENTA + 'file0.txt'
2286
+ self._rev_sep + '1' + self._sep + '1' + self._sep
2287
+ foo + ' is ' + foo + 'bar1' + '\n')
2289
out, err = self.run_bzr(['grep', '--color',
2290
'always', '-r', '1', 'foo'])
2291
self.assertEqual(out, res)
2292
self.assertEqual(len(out.splitlines()), 1)
2294
# auto should produce plain text result
2295
# as stdout is redireched here.
2296
out, err = self.run_bzr(['grep', '--color',
2297
'auto', '-r', '1', 'foo'])
2298
self.assertEqual(out, txt_res)
2299
self.assertEqual(len(out.splitlines()), 1)
2301
out, err = self.run_bzr(['grep', '-i', '--color',
2302
'always', '-r', '1', 'FOO'])
2303
self.assertEqual(out, res)
2304
self.assertEqual(len(out.splitlines()), 1)
2306
out, err = self.run_bzr(['grep', '--color',
2307
'always', '-r', '1', 'f.o'])
2308
self.assertEqual(out, res)
2309
self.assertEqual(len(out.splitlines()), 1)
2311
out, err = self.run_bzr(['grep', '-i', '--color',
2312
'always', '-r', '1', 'F.O'])
2313
self.assertEqual(out, res)
2314
self.assertEqual(len(out.splitlines()), 1)
2316
out, err = self.run_bzr(['grep', '-n', '--color',
2317
'always', '-r', '1', 'foo'])
2318
self.assertEqual(out, nres)
2319
self.assertEqual(len(out.splitlines()), 1)
2321
out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2322
'always', '-r', '1', 'FOO'])
2323
self.assertEqual(out, nres)
2324
self.assertEqual(len(out.splitlines()), 1)
2326
out, err = self.run_bzr(['grep', '-n', '--color',
2327
'always', '-r', '1', 'f.o'])
2328
self.assertEqual(out, nres)
2329
self.assertEqual(len(out.splitlines()), 1)
2331
out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2332
'always', '-r', '1', 'F.O'])
2333
self.assertEqual(out, nres)
2334
self.assertEqual(len(out.splitlines()), 1)
2336
def test_wtree_basic_file(self):
2337
"""(wtree) Search for pattern in specfic file.
2340
self.make_branch_and_tree(wd)
2342
lp = 'foo is foobar'
2343
self._mk_versioned_file('file0.txt', line_prefix=lp, total_lines=1)
2345
# prepare colored result
2346
foo = color_string('foo', fg=FG.BOLD_RED)
2347
res = (FG.MAGENTA + 'file0.txt'
2348
+ self._sep + foo + ' is ' + foo + 'bar1' + '\n')
2350
nres = (FG.MAGENTA + 'file0.txt'
2351
+ self._sep + '1' + self._sep
2352
+ foo + ' is ' + foo + 'bar1' + '\n')
2354
out, err = self.run_bzr(['grep', '--color',
2356
self.assertEqual(out, res)
2357
self.assertEqual(len(out.splitlines()), 1)
2359
out, err = self.run_bzr(['grep', '-i', '--color',
2361
self.assertEqual(out, res)
2362
self.assertEqual(len(out.splitlines()), 1)
2364
out, err = self.run_bzr(['grep', '--color',
2366
self.assertEqual(out, res)
2367
self.assertEqual(len(out.splitlines()), 1)
2369
out, err = self.run_bzr(['grep', '-i', '--color',
2371
self.assertEqual(out, res)
2372
self.assertEqual(len(out.splitlines()), 1)
2374
out, err = self.run_bzr(['grep', '-n', '--color',
2376
self.assertEqual(out, nres)
2377
self.assertEqual(len(out.splitlines()), 1)
2379
out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2381
self.assertEqual(out, nres)
2382
self.assertEqual(len(out.splitlines()), 1)
2384
out, err = self.run_bzr(['grep', '-n', '--color',
2386
self.assertEqual(out, nres)
2387
self.assertEqual(len(out.splitlines()), 1)
2389
out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2391
self.assertEqual(out, nres)
2392
self.assertEqual(len(out.splitlines()), 1)
2395
# copied from breezy.tests.blackbox.test_diff
2396
def subst_dates(string):
2397
"""Replace date strings with constant values."""
2398
return re.sub(r'\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} [-\+]\d{4}',
2399
'YYYY-MM-DD HH:MM:SS +ZZZZ', string)
2402
class TestGrepDiff(tests.TestCaseWithTransport):
2404
def make_example_branch(self):
2405
tree = self.make_branch_and_tree('.')
2406
self.build_tree_contents([
2407
('hello', b'foo\n'),
2408
('goodbye', b'baz\n')])
2410
tree.commit('setup')
2411
tree.add(['goodbye'])
2412
tree.commit('setup')
2415
def test_grep_diff_basic(self):
2416
"""grep -p basic test."""
2417
tree = self.make_example_branch()
2418
self.build_tree_contents([('hello', b'hello world!\n')])
2419
tree.commit('updated hello')
2420
out, err = self.run_bzr(['grep', '-p', 'hello'])
2421
self.assertEqual(err, '')
2422
self.assertEqualDiff(subst_dates(out), '''\
2424
=== modified file 'hello'
2425
--- hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2426
+++ hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2429
=== added file 'hello'
2430
--- hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2431
+++ hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2434
def test_grep_diff_revision(self):
2435
"""grep -p specific revision."""
2436
tree = self.make_example_branch()
2437
self.build_tree_contents([('hello', b'hello world!\n')])
2438
tree.commit('updated hello')
2439
out, err = self.run_bzr(['grep', '-p', '-r', '3', 'hello'])
2440
self.assertEqual(err, '')
2441
self.assertEqualDiff(subst_dates(out), '''\
2443
=== modified file 'hello'
2444
--- hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2445
+++ hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2449
def test_grep_diff_revision_range(self):
2450
"""grep -p revision range."""
2451
tree = self.make_example_branch()
2452
self.build_tree_contents([('hello', b'hello world!1\n')]) # rev 3
2454
self.build_tree_contents([('blah', b'hello world!2\n')]) # rev 4
2457
with open('hello', 'a') as f:
2458
f.write('hello world!3\n')
2459
# self.build_tree_contents([('hello', 'hello world!3\n')]) # rev 5
2461
out, err = self.run_bzr(['grep', '-p', '-r', '2..5', 'hello'])
2462
self.assertEqual(err, '')
2463
self.assertEqualDiff(subst_dates(out), '''\
2465
=== modified file 'hello'
2466
--- hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2467
+++ hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2470
=== added file 'blah'
2473
=== modified file 'hello'
2474
--- hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2475
+++ hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2479
def test_grep_diff_color(self):
2480
"""grep -p color test."""
2481
tree = self.make_example_branch()
2482
self.build_tree_contents([('hello', b'hello world!\n')])
2483
tree.commit('updated hello')
2484
out, err = self.run_bzr(['grep', '--diff', '-r', '3',
2485
'--color', 'always', 'hello'])
2486
self.assertEqual(err, '')
2487
revno = color_string('=== revno:3 ===', fg=FG.BOLD_BLUE) + '\n'
2488
filename = color_string(
2489
" === modified file 'hello'", fg=FG.BOLD_MAGENTA) + '\n'
2490
redhello = color_string('hello', fg=FG.BOLD_RED)
2492
--- hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2493
+++ hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2496
diffstr = diffstr.replace('hello', redhello)
2497
self.assertEqualDiff(subst_dates(out), revno + filename + diffstr)
2499
def test_grep_norevs(self):
2500
"""grep -p with zero revisions."""
2501
out, err = self.run_bzr(['init'])
2502
out, err = self.run_bzr(['grep', '--diff', 'foo'], 3)
2503
self.assertEqual(out, '')
2504
self.assertContainsRe(
2505
err, "ERROR:.*revision.* does not exist in branch")
added
removed
breezy/tests/test_grep.py
