/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/plugins/grep/test_grep.py

Merge test-run support.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/plugins/grep/test_grep.py
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
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
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
from __future__ import absolute_import
18
18
 
20
20
import re
21
21
import unicodedata as ud
22
22
 
23
 
from .. import tests, osutils
24
 
from ..sixish import PY3
25
 
from .._termcolor import color_string, FG
 
23
from ... import tests, osutils
 
24
from ..._termcolor import color_string, FG
26
25
 
27
 
from ..tests.features import (
 
26
from ...tests.features import (
 
27
    ColorFeature,
28
28
    UnicodeFilenameFeature,
29
29
    )
30
30
 
33
33
# specfically with patterns that have special characters so that
34
34
# regex path is tested. alphanumeric patterns test the -F path.
35
35
 
36
 
 
37
36
class GrepTestBase(tests.TestCaseWithTransport):
38
37
    """Base class for testing grep.
39
38
 
40
39
    Provides support methods for creating directory and file revisions.
41
40
    """
42
 
    _reflags = re.MULTILINE | re.DOTALL
 
41
    _reflags = re.MULTILINE|re.DOTALL
43
42
 
44
43
    def _mk_file(self, path, line_prefix, total_lines, versioned):
45
 
        text = ''
 
44
        text=''
46
45
        for i in range(total_lines):
47
 
            text += line_prefix + str(i + 1) + "\n"
 
46
            text += line_prefix + str(i+1) + "\n"
48
47
 
49
 
        with open(path, 'w') as f:
50
 
            f.write(text)
 
48
        open(path, 'w').write(text)
51
49
        if versioned:
52
50
            self.run_bzr(['add', path])
53
51
            self.run_bzr(['ci', '-m', '"' + path + '"'])
54
52
 
55
53
    def _update_file(self, path, text, checkin=True):
56
54
        """append text to file 'path' and check it in"""
57
 
        with open(path, 'a') as f:
58
 
            f.write(text)
 
55
        open(path, 'a').write(text)
59
56
        if checkin:
60
57
            self.run_bzr(['ci', path, '-m', '"' + path + '"'])
61
58
 
92
89
 
93
90
        out, err = self.run_bzr(['grep', 'line1', 'file0.txt'])
94
91
        self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
95
 
        self.assertEqual(len(out.splitlines()), 2)  # finds line1 and line10
 
92
        self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
96
93
 
97
94
        out, err = self.run_bzr(['grep', 'line\\d+', 'file0.txt'])
98
95
        self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
117
114
        self._mk_versioned_file('file0.txt')
118
115
 
119
116
        out, err = self.run_bzr(['grep', '-r', '1', 'line1', 'file0.txt'])
120
 
        self.assertContainsRe(out, "file0.txt~1:line1",
121
 
                              flags=TestGrep._reflags)
122
 
        self.assertEqual(len(out.splitlines()), 2)  # finds line1 and line10
 
117
        self.assertContainsRe(out, "file0.txt~1:line1", flags=TestGrep._reflags)
 
118
        self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
123
119
 
124
120
        out, err = self.run_bzr(['grep', '-r', '1', 'line[0-9]$', 'file0.txt'])
125
 
        self.assertContainsRe(out, "file0.txt~1:line1",
126
 
                              flags=TestGrep._reflags)
 
121
        self.assertContainsRe(out, "file0.txt~1:line1", flags=TestGrep._reflags)
127
122
        self.assertEqual(len(out.splitlines()), 9)
128
123
 
129
124
        # finds all the lines
130
125
        out, err = self.run_bzr(['grep', '-r', '1', 'line[0-9]', 'file0.txt'])
131
 
        self.assertContainsRe(out, "file0.txt~1:line1",
132
 
                              flags=TestGrep._reflags)
 
126
        self.assertContainsRe(out, "file0.txt~1:line1", flags=TestGrep._reflags)
133
127
        self.assertEqual(len(out.splitlines()), 10)
134
128
 
135
129
    def test_wtree_basic_file(self):
153
147
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
154
148
        self.assertEqual(len(out.splitlines()), 0)
155
149
 
156
 
        out, err = self.run_bzr(
157
 
            ['grep', '-r', 'last:1', '[A-Z]{3}', 'file0.txt'])
 
150
        out, err = self.run_bzr(['grep', '-r', 'last:1', '[A-Z]{3}', 'file0.txt'])
158
151
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
159
152
        self.assertEqual(len(out.splitlines()), 0)
160
153
 
169
162
        self._mk_versioned_file('file0.cc')
170
163
 
171
164
        out, err = self.run_bzr(['grep', '-r', 'last:1',
172
 
                                 '--include', '*.aa', '--include', '*.bb', 'line1'])
 
165
            '--include', '*.aa', '--include', '*.bb', 'line1'])
173
166
        self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
174
167
        self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
175
168
        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
177
170
        self.assertEqual(len(out.splitlines()), 4)
178
171
 
179
172
        out, err = self.run_bzr(['grep', '-r', 'last:1',
180
 
                                 '--include', '*.aa', '--include', '*.bb', 'line1$'])
 
173
            '--include', '*.aa', '--include', '*.bb', 'line1$'])
181
174
        self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
182
175
        self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
183
176
        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
185
178
        self.assertEqual(len(out.splitlines()), 2)
186
179
 
187
180
        out, err = self.run_bzr(['grep', '-r', 'last:1',
188
 
                                 '-I', '*.aa', '-I', '*.bb', 'line1'])
 
181
            '-I', '*.aa', '-I', '*.bb', 'line1'])
189
182
        self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
190
183
        self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
191
184
        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
193
186
        self.assertEqual(len(out.splitlines()), 4)
194
187
 
195
188
        out, err = self.run_bzr(['grep', '-r', 'last:1',
196
 
                                 '-I', '*.aa', '-I', '*.bb', 'line1$'])
 
189
            '-I', '*.aa', '-I', '*.bb', 'line1$'])
197
190
        self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
198
191
        self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
199
192
        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
211
204
        self._mk_versioned_file('file0.cc')
212
205
 
213
206
        out, err = self.run_bzr(['grep', '--include', '*.aa',
214
 
                                 '--include', '*.bb', 'line1'])
 
207
            '--include', '*.bb', 'line1'])
215
208
        self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
216
209
        self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
217
210
        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
219
212
        self.assertEqual(len(out.splitlines()), 4)
220
213
 
221
214
        out, err = self.run_bzr(['grep', '--include', '*.aa',
222
 
                                 '--include', '*.bb', 'line1$'])
 
215
            '--include', '*.bb', 'line1$'])
223
216
        self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
224
217
        self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
225
218
        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
237
230
        self._mk_versioned_file('file0.cc')
238
231
 
239
232
        out, err = self.run_bzr(['grep', '-r', 'last:1',
240
 
                                 '--exclude', '*.cc', 'line1'])
241
 
        self.assertContainsRe(out, "file0.aa~.:line1$",
242
 
                              flags=TestGrep._reflags)
243
 
        self.assertContainsRe(out, "file0.bb~.:line1$",
244
 
                              flags=TestGrep._reflags)
245
 
        self.assertContainsRe(out, "file0.aa~.:line10",
246
 
                              flags=TestGrep._reflags)
247
 
        self.assertContainsRe(out, "file0.bb~.:line10",
248
 
                              flags=TestGrep._reflags)
 
233
            '--exclude', '*.cc', 'line1'])
 
234
        self.assertContainsRe(out, "file0.aa~.:line1$", flags=TestGrep._reflags)
 
235
        self.assertContainsRe(out, "file0.bb~.:line1$", flags=TestGrep._reflags)
 
236
        self.assertContainsRe(out, "file0.aa~.:line10", flags=TestGrep._reflags)
 
237
        self.assertContainsRe(out, "file0.bb~.:line10", flags=TestGrep._reflags)
249
238
        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
250
239
        # two lines each (line1, line10) from file0.aa and file0.bb
251
240
        self.assertEqual(len(out.splitlines()), 4)
252
241
 
253
242
        out, err = self.run_bzr(['grep', '-r', 'last:1',
254
 
                                 '--exclude', '*.cc', 'line1$'])
 
243
            '--exclude', '*.cc', 'line1$'])
255
244
        self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
256
245
        self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
257
246
        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
259
248
        self.assertEqual(len(out.splitlines()), 2)
260
249
 
261
250
        out, err = self.run_bzr(['grep', '-r', 'last:1',
262
 
                                 '-X', '*.cc', 'line1'])
 
251
            '-X', '*.cc', 'line1'])
263
252
        self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
264
253
        self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
265
254
        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
301
290
        self._mk_versioned_file('file2.txt', total_lines=2)
302
291
 
303
292
        out, err = self.run_bzr(['grep', '-r', 'last:1', 'line[1-2]$'])
304
 
        self.assertContainsRe(out, "file0.txt~.:line1",
305
 
                              flags=TestGrep._reflags)
306
 
        self.assertContainsRe(out, "file0.txt~.:line2",
307
 
                              flags=TestGrep._reflags)
308
 
        self.assertContainsRe(out, "file1.txt~.:line1",
309
 
                              flags=TestGrep._reflags)
310
 
        self.assertContainsRe(out, "file1.txt~.:line2",
311
 
                              flags=TestGrep._reflags)
312
 
        self.assertContainsRe(out, "file2.txt~.:line1",
313
 
                              flags=TestGrep._reflags)
314
 
        self.assertContainsRe(out, "file2.txt~.:line2",
315
 
                              flags=TestGrep._reflags)
 
293
        self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
 
294
        self.assertContainsRe(out, "file0.txt~.:line2", flags=TestGrep._reflags)
 
295
        self.assertContainsRe(out, "file1.txt~.:line1", flags=TestGrep._reflags)
 
296
        self.assertContainsRe(out, "file1.txt~.:line2", flags=TestGrep._reflags)
 
297
        self.assertContainsRe(out, "file2.txt~.:line1", flags=TestGrep._reflags)
 
298
        self.assertContainsRe(out, "file2.txt~.:line2", flags=TestGrep._reflags)
316
299
        self.assertEqual(len(out.splitlines()), 6)
317
300
 
318
301
        out, err = self.run_bzr(['grep', '-r', 'last:1', 'line'])
319
 
        self.assertContainsRe(out, "file0.txt~.:line1",
320
 
                              flags=TestGrep._reflags)
321
 
        self.assertContainsRe(out, "file0.txt~.:line2",
322
 
                              flags=TestGrep._reflags)
323
 
        self.assertContainsRe(out, "file1.txt~.:line1",
324
 
                              flags=TestGrep._reflags)
325
 
        self.assertContainsRe(out, "file1.txt~.:line2",
326
 
                              flags=TestGrep._reflags)
327
 
        self.assertContainsRe(out, "file2.txt~.:line1",
328
 
                              flags=TestGrep._reflags)
329
 
        self.assertContainsRe(out, "file2.txt~.:line2",
330
 
                              flags=TestGrep._reflags)
 
302
        self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
 
303
        self.assertContainsRe(out, "file0.txt~.:line2", flags=TestGrep._reflags)
 
304
        self.assertContainsRe(out, "file1.txt~.:line1", flags=TestGrep._reflags)
 
305
        self.assertContainsRe(out, "file1.txt~.:line2", flags=TestGrep._reflags)
 
306
        self.assertContainsRe(out, "file2.txt~.:line1", flags=TestGrep._reflags)
 
307
        self.assertContainsRe(out, "file2.txt~.:line2", flags=TestGrep._reflags)
331
308
        self.assertEqual(len(out.splitlines()), 6)
332
309
 
333
310
    def test_multiple_wtree_files(self):
344
321
        self._update_file('file2.txt', 'HELLO\n', checkin=False)
345
322
 
346
323
        out, err = self.run_bzr(['grep', 'HELLO',
347
 
                                 'file0.txt', 'file1.txt', 'file2.txt'])
 
324
            'file0.txt', 'file1.txt', 'file2.txt'])
348
325
 
349
326
        self.assertContainsRe(out, "file0.txt:HELLO", flags=TestGrep._reflags)
350
327
        self.assertContainsRe(out, "file1.txt:HELLO", flags=TestGrep._reflags)
352
329
        self.assertEqual(len(out.splitlines()), 3)
353
330
 
354
331
        out, err = self.run_bzr(['grep', 'HELLO', '-r', 'last:1',
355
 
                                 'file0.txt', 'file1.txt', 'file2.txt'])
 
332
            'file0.txt', 'file1.txt', 'file2.txt'])
356
333
 
357
334
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
358
 
        self.assertContainsRe(out, "file1.txt~.:HELLO",
359
 
                              flags=TestGrep._reflags)
 
335
        self.assertContainsRe(out, "file1.txt~.:HELLO", flags=TestGrep._reflags)
360
336
        self.assertNotContainsRe(out, "file2.txt", flags=TestGrep._reflags)
361
337
        self.assertEqual(len(out.splitlines()), 1)
362
338
 
363
339
        out, err = self.run_bzr(['grep', 'HE..O',
364
 
                                 'file0.txt', 'file1.txt', 'file2.txt'])
 
340
            'file0.txt', 'file1.txt', 'file2.txt'])
365
341
 
366
342
        self.assertContainsRe(out, "file0.txt:HELLO", flags=TestGrep._reflags)
367
343
        self.assertContainsRe(out, "file1.txt:HELLO", flags=TestGrep._reflags)
369
345
        self.assertEqual(len(out.splitlines()), 3)
370
346
 
371
347
        out, err = self.run_bzr(['grep', 'HE..O', '-r', 'last:1',
372
 
                                 'file0.txt', 'file1.txt', 'file2.txt'])
 
348
            'file0.txt', 'file1.txt', 'file2.txt'])
373
349
 
374
350
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
375
 
        self.assertContainsRe(out, "file1.txt~.:HELLO",
376
 
                              flags=TestGrep._reflags)
 
351
        self.assertContainsRe(out, "file1.txt~.:HELLO", flags=TestGrep._reflags)
377
352
        self.assertNotContainsRe(out, "file2.txt", flags=TestGrep._reflags)
378
353
        self.assertEqual(len(out.splitlines()), 1)
379
354
 
385
360
        os.chdir(wd)
386
361
        self._mk_versioned_file('file0.txt', total_lines=3)
387
362
 
388
 
        nref = ud.normalize(
389
 
            u'NFC', u"file0.txt~1:line1\0file0.txt~1:line2\0file0.txt~1:line3\0")
 
363
        nref = ud.normalize(u'NFC', u"file0.txt~1:line1\0file0.txt~1:line2\0file0.txt~1:line3\0")
390
364
 
391
 
        out, err = self.run_bzr(
392
 
            ['grep', '-r', 'last:1', '--null', 'line[1-3]'])
393
 
        if not PY3:
394
 
            out = out.decode('utf-8', 'ignore')
395
 
        nout = ud.normalize(u'NFC', out)
 
365
        out, err = self.run_bzr(['grep', '-r', 'last:1', '--null', 'line[1-3]'])
 
366
        nout = ud.normalize(u'NFC', out.decode('utf-8', 'ignore'))
396
367
        self.assertEqual(nout, nref)
397
368
        self.assertEqual(len(out.splitlines()), 1)
398
369
 
399
370
        out, err = self.run_bzr(['grep', '-r', 'last:1', '-Z', 'line[1-3]'])
400
 
        if not PY3:
401
 
            out = out.decode('utf-8', 'ignore')
402
 
        nout = ud.normalize(u'NFC', out)
 
371
        nout = ud.normalize(u'NFC', out.decode('utf-8', 'ignore'))
403
372
        self.assertEqual(nout, nref)
404
373
        self.assertEqual(len(out.splitlines()), 1)
405
374
 
406
375
        out, err = self.run_bzr(['grep', '-r', 'last:1', '--null', 'line'])
407
 
        if not PY3:
408
 
            out = out.decode('utf-8', 'ignore')
409
 
        nout = ud.normalize(u'NFC', out)
 
376
        nout = ud.normalize(u'NFC', out.decode('utf-8', 'ignore'))
410
377
        self.assertEqual(nout, nref)
411
378
        self.assertEqual(len(out.splitlines()), 1)
412
379
 
419
386
        self._mk_versioned_file('file0.txt', total_lines=3)
420
387
 
421
388
        out, err = self.run_bzr(['grep', '--null', 'line[1-3]'])
422
 
        self.assertEqual(
423
 
            out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
 
389
        self.assertEqual(out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
424
390
        self.assertEqual(len(out.splitlines()), 1)
425
391
 
426
392
        out, err = self.run_bzr(['grep', '-Z', 'line[1-3]'])
427
 
        self.assertEqual(
428
 
            out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
 
393
        self.assertEqual(out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
429
394
        self.assertEqual(len(out.splitlines()), 1)
430
395
 
431
396
        out, err = self.run_bzr(['grep', '-Z', 'line'])
432
 
        self.assertEqual(
433
 
            out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
 
397
        self.assertEqual(out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
434
398
        self.assertEqual(len(out.splitlines()), 1)
435
399
 
436
400
    def test_versioned_file_in_dir_no_recursive(self):
442
406
        self._mk_versioned_dir('dir0')
443
407
        self._mk_versioned_file('dir0/file0.txt')
444
408
 
445
 
        out, err = self.run_bzr(
446
 
            ['grep', '-r', 'last:1', '--no-recursive', 'line1'])
447
 
        self.assertNotContainsRe(
448
 
            out, "file0.txt~.:line1", flags=TestGrep._reflags)
 
409
        out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1'])
 
410
        self.assertNotContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
449
411
        self.assertEqual(len(out.splitlines()), 0)
450
412
 
451
 
        out, err = self.run_bzr(
452
 
            ['grep', '-r', 'last:1', '--no-recursive', 'line1$'])
453
 
        self.assertNotContainsRe(
454
 
            out, "file0.txt~.:line1", flags=TestGrep._reflags)
 
413
        out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1$'])
 
414
        self.assertNotContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
455
415
        self.assertEqual(len(out.splitlines()), 0)
456
416
 
457
417
    def test_wtree_file_in_dir_no_recursive(self):
464
424
        self._mk_versioned_file('dir0/file0.txt')
465
425
 
466
426
        out, err = self.run_bzr(['grep', '--no-recursive', 'line1'])
467
 
        self.assertNotContainsRe(
468
 
            out, "file0.txt:line1", flags=TestGrep._reflags)
 
427
        self.assertNotContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
469
428
        self.assertEqual(len(out.splitlines()), 0)
470
429
 
471
430
        out, err = self.run_bzr(['grep', '--no-recursive', 'lin.1'])
472
 
        self.assertNotContainsRe(
473
 
            out, "file0.txt:line1", flags=TestGrep._reflags)
 
431
        self.assertNotContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
474
432
        self.assertEqual(len(out.splitlines()), 0)
475
433
 
476
434
    def test_versioned_file_in_dir_recurse(self):
483
441
        self._mk_versioned_file('dir0/file0.txt')
484
442
 
485
443
        out, err = self.run_bzr(['grep', '-r', '-1', '.i.e1'])
486
 
        self.assertContainsRe(
487
 
            out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
 
444
        self.assertContainsRe(out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
488
445
        # find line1 and line10
489
446
        self.assertEqual(len(out.splitlines()), 2)
490
447
 
491
448
        out, err = self.run_bzr(['grep', '-r', '-1', 'line1'])
492
 
        self.assertContainsRe(
493
 
            out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
 
449
        self.assertContainsRe(out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
494
450
        # find line1 and line10
495
451
        self.assertEqual(len(out.splitlines()), 2)
496
452
 
504
460
        self._mk_versioned_file('dir0/file0.txt')
505
461
 
506
462
        out, err = self.run_bzr(['grep', 'line1'])
507
 
        self.assertContainsRe(out, "^dir0/file0.txt:line1",
508
 
                              flags=TestGrep._reflags)
 
463
        self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
509
464
        # find line1 and line10
510
465
        self.assertEqual(len(out.splitlines()), 2)
511
466
 
512
467
        out, err = self.run_bzr(['grep', 'lin.1'])
513
 
        self.assertContainsRe(out, "^dir0/file0.txt:line1",
514
 
                              flags=TestGrep._reflags)
 
468
        self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
515
469
        # find line1 and line10
516
470
        self.assertEqual(len(out.splitlines()), 2)
517
471
 
526
480
        os.chdir('dir0')
527
481
 
528
482
        out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
529
 
        self.assertContainsRe(out, "^file0.txt~.:line1",
530
 
                              flags=TestGrep._reflags)
 
483
        self.assertContainsRe(out, "^file0.txt~.:line1", flags=TestGrep._reflags)
531
484
        # finds line1 and line10
532
485
        self.assertEqual(len(out.splitlines()), 2)
533
486
 
534
487
        out, err = self.run_bzr(['grep', '-r', 'last:1', '.i.e1'])
535
 
        self.assertContainsRe(out, "^file0.txt~.:line1",
536
 
                              flags=TestGrep._reflags)
 
488
        self.assertContainsRe(out, "^file0.txt~.:line1", flags=TestGrep._reflags)
537
489
        # finds line1 and line10
538
490
        self.assertEqual(len(out.splitlines()), 2)
539
491
 
551
503
        os.chdir('dir0')
552
504
 
553
505
        out, err = self.run_bzr(['grep', '-r', 'last:1',
554
 
                                 '--include', '*.aa', 'line1'])
555
 
        self.assertContainsRe(out, "^file1.aa~5:line1$",
556
 
                              flags=TestGrep._reflags)
557
 
        self.assertContainsRe(out, "^file1.aa~5:line10$",
558
 
                              flags=TestGrep._reflags)
 
506
            '--include', '*.aa', 'line1'])
 
507
        self.assertContainsRe(out, "^file1.aa~5:line1$", flags=TestGrep._reflags)
 
508
        self.assertContainsRe(out, "^file1.aa~5:line10$", flags=TestGrep._reflags)
559
509
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
560
510
        # finds line1 and line10
561
511
        self.assertEqual(len(out.splitlines()), 2)
562
512
 
563
513
        out, err = self.run_bzr(['grep', '-r', 'last:2..last:1',
564
 
                                 '--include', '*.aa', 'line1'])
565
 
        self.assertContainsRe(out, "^file1.aa~4:line1$",
566
 
                              flags=TestGrep._reflags)
567
 
        self.assertContainsRe(out, "^file1.aa~4:line10$",
568
 
                              flags=TestGrep._reflags)
569
 
        self.assertContainsRe(out, "^file1.aa~5:line1$",
570
 
                              flags=TestGrep._reflags)
571
 
        self.assertContainsRe(out, "^file1.aa~5:line10$",
572
 
                              flags=TestGrep._reflags)
 
514
            '--include', '*.aa', 'line1'])
 
515
        self.assertContainsRe(out, "^file1.aa~4:line1$", flags=TestGrep._reflags)
 
516
        self.assertContainsRe(out, "^file1.aa~4:line10$", flags=TestGrep._reflags)
 
517
        self.assertContainsRe(out, "^file1.aa~5:line1$", flags=TestGrep._reflags)
 
518
        self.assertContainsRe(out, "^file1.aa~5:line10$", flags=TestGrep._reflags)
573
519
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
574
520
        # finds line1 and line10 over two revisions
575
521
        self.assertEqual(len(out.splitlines()), 4)
576
522
 
577
523
        out, err = self.run_bzr(['grep', '-r', 'last:1',
578
 
                                 '--include', '*.aa', 'lin.1'])
579
 
        self.assertContainsRe(out, "^file1.aa~5:line1$",
580
 
                              flags=TestGrep._reflags)
581
 
        self.assertContainsRe(out, "^file1.aa~5:line10$",
582
 
                              flags=TestGrep._reflags)
 
524
            '--include', '*.aa', 'lin.1'])
 
525
        self.assertContainsRe(out, "^file1.aa~5:line1$", flags=TestGrep._reflags)
 
526
        self.assertContainsRe(out, "^file1.aa~5:line10$", flags=TestGrep._reflags)
583
527
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
584
528
        # finds line1 and line10
585
529
        self.assertEqual(len(out.splitlines()), 2)
586
530
 
587
531
        out, err = self.run_bzr(['grep', '-r', 'last:3..last:1',
588
 
                                 '--include', '*.aa', 'lin.1'])
589
 
        self.assertContainsRe(out, "^file1.aa~3:line1$",
590
 
                              flags=TestGrep._reflags)
591
 
        self.assertContainsRe(out, "^file1.aa~4:line1$",
592
 
                              flags=TestGrep._reflags)
593
 
        self.assertContainsRe(out, "^file1.aa~5:line1$",
594
 
                              flags=TestGrep._reflags)
595
 
        self.assertContainsRe(out, "^file1.aa~3:line10$",
596
 
                              flags=TestGrep._reflags)
597
 
        self.assertContainsRe(out, "^file1.aa~4:line10$",
598
 
                              flags=TestGrep._reflags)
599
 
        self.assertContainsRe(out, "^file1.aa~5:line10$",
600
 
                              flags=TestGrep._reflags)
 
532
            '--include', '*.aa', 'lin.1'])
 
533
        self.assertContainsRe(out, "^file1.aa~3:line1$", flags=TestGrep._reflags)
 
534
        self.assertContainsRe(out, "^file1.aa~4:line1$", flags=TestGrep._reflags)
 
535
        self.assertContainsRe(out, "^file1.aa~5:line1$", flags=TestGrep._reflags)
 
536
        self.assertContainsRe(out, "^file1.aa~3:line10$", flags=TestGrep._reflags)
 
537
        self.assertContainsRe(out, "^file1.aa~4:line10$", flags=TestGrep._reflags)
 
538
        self.assertContainsRe(out, "^file1.aa~5:line10$", flags=TestGrep._reflags)
601
539
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
602
540
        # finds line1 and line10 over 3 revisions
603
541
        self.assertEqual(len(out.splitlines()), 6)
614
552
        os.chdir('dir0')
615
553
 
616
554
        out, err = self.run_bzr(['grep', '-r', 'last:1',
617
 
                                 '--exclude', '*.txt', 'line1'])
618
 
        self.assertContainsRe(out, "^file1.aa~.:line1",
619
 
                              flags=TestGrep._reflags)
 
555
            '--exclude', '*.txt', 'line1'])
 
556
        self.assertContainsRe(out, "^file1.aa~.:line1", flags=TestGrep._reflags)
620
557
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
621
558
        # finds line1 and line10
622
559
        self.assertEqual(len(out.splitlines()), 2)
623
560
 
624
561
        out, err = self.run_bzr(['grep', '-r', 'last:1',
625
 
                                 '--exclude', '*.txt', 'l[a-z]ne1'])
626
 
        self.assertContainsRe(out, "^file1.aa~.:line1",
627
 
                              flags=TestGrep._reflags)
 
562
            '--exclude', '*.txt', 'l[a-z]ne1'])
 
563
        self.assertContainsRe(out, "^file1.aa~.:line1", flags=TestGrep._reflags)
628
564
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
629
565
        # finds line1 and line10
630
566
        self.assertEqual(len(out.splitlines()), 2)
684
620
 
685
621
        out, err = self.run_bzr(['grep', '--exclude', '*.txt', 'li.e1'])
686
622
        self.assertContainsRe(out, "^file1.aa:line1$", flags=TestGrep._reflags)
687
 
        self.assertContainsRe(out, "^file1.aa:line10$",
688
 
                              flags=TestGrep._reflags)
 
623
        self.assertContainsRe(out, "^file1.aa:line10$", flags=TestGrep._reflags)
689
624
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
690
625
        # finds line1 and line10
691
626
        self.assertEqual(len(out.splitlines()), 2)
692
627
 
693
628
        out, err = self.run_bzr(['grep', '--exclude', '*.txt', 'line1'])
694
629
        self.assertContainsRe(out, "^file1.aa:line1$", flags=TestGrep._reflags)
695
 
        self.assertContainsRe(out, "^file1.aa:line10$",
696
 
                              flags=TestGrep._reflags)
 
630
        self.assertContainsRe(out, "^file1.aa:line10$", flags=TestGrep._reflags)
697
631
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
698
632
        # finds line1 and line10
699
633
        self.assertEqual(len(out.splitlines()), 2)
715
649
        self._mk_versioned_file('dir2/file2.cc')
716
650
 
717
651
        out, err = self.run_bzr(['grep', '-r', 'last:1',
718
 
                                 '--include', '*.aa', '--include', '*.bb', 'l..e1'])
719
 
        self.assertContainsRe(
720
 
            out, "^dir0/file0.aa~.:line1$", flags=TestGrep._reflags)
721
 
        self.assertContainsRe(
722
 
            out, "^dir1/file1.bb~.:line1$", flags=TestGrep._reflags)
723
 
        self.assertContainsRe(
724
 
            out, "^dir0/file0.aa~.:line10$", flags=TestGrep._reflags)
725
 
        self.assertContainsRe(
726
 
            out, "^dir1/file1.bb~.:line10$", flags=TestGrep._reflags)
 
652
            '--include', '*.aa', '--include', '*.bb', 'l..e1'])
 
653
        self.assertContainsRe(out, "^dir0/file0.aa~.:line1$", flags=TestGrep._reflags)
 
654
        self.assertContainsRe(out, "^dir1/file1.bb~.:line1$", flags=TestGrep._reflags)
 
655
        self.assertContainsRe(out, "^dir0/file0.aa~.:line10$", flags=TestGrep._reflags)
 
656
        self.assertContainsRe(out, "^dir1/file1.bb~.:line10$", flags=TestGrep._reflags)
727
657
        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
728
658
        # finds line1 and line10
729
659
        self.assertEqual(len(out.splitlines()), 4)
730
660
 
731
661
        out, err = self.run_bzr(['grep', '-r', 'last:1',
732
 
                                 '--include', '*.aa', '--include', '*.bb', 'line1'])
733
 
        self.assertContainsRe(
734
 
            out, "^dir0/file0.aa~.:line1$", flags=TestGrep._reflags)
735
 
        self.assertContainsRe(
736
 
            out, "^dir1/file1.bb~.:line1$", flags=TestGrep._reflags)
737
 
        self.assertContainsRe(
738
 
            out, "^dir0/file0.aa~.:line10$", flags=TestGrep._reflags)
739
 
        self.assertContainsRe(
740
 
            out, "^dir1/file1.bb~.:line10$", flags=TestGrep._reflags)
 
662
            '--include', '*.aa', '--include', '*.bb', 'line1'])
 
663
        self.assertContainsRe(out, "^dir0/file0.aa~.:line1$", flags=TestGrep._reflags)
 
664
        self.assertContainsRe(out, "^dir1/file1.bb~.:line1$", flags=TestGrep._reflags)
 
665
        self.assertContainsRe(out, "^dir0/file0.aa~.:line10$", flags=TestGrep._reflags)
 
666
        self.assertContainsRe(out, "^dir1/file1.bb~.:line10$", flags=TestGrep._reflags)
741
667
        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
742
668
        # finds line1 and line10
743
669
        self.assertEqual(len(out.splitlines()), 4)
759
685
        self._mk_versioned_file('dir2/file2.cc')
760
686
 
761
687
        out, err = self.run_bzr(['grep', '--include', '*.aa',
762
 
                                 '--include', '*.bb', 'l.n.1'])
763
 
        self.assertContainsRe(out, "^dir0/file0.aa:line1$",
764
 
                              flags=TestGrep._reflags)
765
 
        self.assertContainsRe(out, "^dir1/file1.bb:line1$",
766
 
                              flags=TestGrep._reflags)
767
 
        self.assertContainsRe(
768
 
            out, "^dir0/file0.aa:line10$", flags=TestGrep._reflags)
769
 
        self.assertContainsRe(
770
 
            out, "^dir1/file1.bb:line10$", flags=TestGrep._reflags)
 
688
            '--include', '*.bb', 'l.n.1'])
 
689
        self.assertContainsRe(out, "^dir0/file0.aa:line1$", flags=TestGrep._reflags)
 
690
        self.assertContainsRe(out, "^dir1/file1.bb:line1$", flags=TestGrep._reflags)
 
691
        self.assertContainsRe(out, "^dir0/file0.aa:line10$", flags=TestGrep._reflags)
 
692
        self.assertContainsRe(out, "^dir1/file1.bb:line10$", flags=TestGrep._reflags)
771
693
        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
772
694
        # finds line1 and line10
773
695
        self.assertEqual(len(out.splitlines()), 4)
774
696
 
775
697
        out, err = self.run_bzr(['grep', '--include', '*.aa',
776
 
                                 '--include', '*.bb', 'line1'])
777
 
        self.assertContainsRe(out, "^dir0/file0.aa:line1$",
778
 
                              flags=TestGrep._reflags)
779
 
        self.assertContainsRe(out, "^dir1/file1.bb:line1$",
780
 
                              flags=TestGrep._reflags)
781
 
        self.assertContainsRe(
782
 
            out, "^dir0/file0.aa:line10$", flags=TestGrep._reflags)
783
 
        self.assertContainsRe(
784
 
            out, "^dir1/file1.bb:line10$", flags=TestGrep._reflags)
 
698
            '--include', '*.bb', 'line1'])
 
699
        self.assertContainsRe(out, "^dir0/file0.aa:line1$", flags=TestGrep._reflags)
 
700
        self.assertContainsRe(out, "^dir1/file1.bb:line1$", flags=TestGrep._reflags)
 
701
        self.assertContainsRe(out, "^dir0/file0.aa:line10$", flags=TestGrep._reflags)
 
702
        self.assertContainsRe(out, "^dir1/file1.bb:line10$", flags=TestGrep._reflags)
785
703
        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
786
704
        # finds line1 and line10
787
705
        self.assertEqual(len(out.splitlines()), 4)
803
721
        self._mk_versioned_file('dir2/file2.cc')
804
722
 
805
723
        out, err = self.run_bzr(['grep', '-r', 'last:1',
806
 
                                 '--exclude', '*.cc', 'l..e1'])
807
 
        self.assertContainsRe(
808
 
            out, "^dir0/file0.aa~.:line1", flags=TestGrep._reflags)
809
 
        self.assertContainsRe(
810
 
            out, "^dir1/file1.bb~.:line1", flags=TestGrep._reflags)
 
724
            '--exclude', '*.cc', 'l..e1'])
 
725
        self.assertContainsRe(out, "^dir0/file0.aa~.:line1", flags=TestGrep._reflags)
 
726
        self.assertContainsRe(out, "^dir1/file1.bb~.:line1", flags=TestGrep._reflags)
811
727
        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
812
728
 
813
729
        out, err = self.run_bzr(['grep', '-r', 'last:1',
814
 
                                 '--exclude', '*.cc', 'line1'])
815
 
        self.assertContainsRe(
816
 
            out, "^dir0/file0.aa~.:line1", flags=TestGrep._reflags)
817
 
        self.assertContainsRe(
818
 
            out, "^dir1/file1.bb~.:line1", flags=TestGrep._reflags)
 
730
            '--exclude', '*.cc', 'line1'])
 
731
        self.assertContainsRe(out, "^dir0/file0.aa~.:line1", flags=TestGrep._reflags)
 
732
        self.assertContainsRe(out, "^dir1/file1.bb~.:line1", flags=TestGrep._reflags)
819
733
        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
820
734
 
821
735
    def test_wtree_exclude_from_outside_dir(self):
835
749
        self._mk_versioned_file('dir2/file2.cc')
836
750
 
837
751
        out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'l[hijk]ne1'])
838
 
        self.assertContainsRe(out, "^dir0/file0.aa:line1",
839
 
                              flags=TestGrep._reflags)
840
 
        self.assertContainsRe(out, "^dir1/file1.bb:line1",
841
 
                              flags=TestGrep._reflags)
 
752
        self.assertContainsRe(out, "^dir0/file0.aa:line1", flags=TestGrep._reflags)
 
753
        self.assertContainsRe(out, "^dir1/file1.bb:line1", flags=TestGrep._reflags)
842
754
        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
843
755
 
844
756
        out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'line1'])
845
 
        self.assertContainsRe(out, "^dir0/file0.aa:line1",
846
 
                              flags=TestGrep._reflags)
847
 
        self.assertContainsRe(out, "^dir1/file1.bb:line1",
848
 
                              flags=TestGrep._reflags)
 
757
        self.assertContainsRe(out, "^dir0/file0.aa:line1", flags=TestGrep._reflags)
 
758
        self.assertContainsRe(out, "^dir1/file1.bb:line1", flags=TestGrep._reflags)
849
759
        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
850
760
 
851
761
    def test_workingtree_files_from_outside_dir(self):
862
772
        self._mk_versioned_file('dir1/file1.txt')
863
773
 
864
774
        out, err = self.run_bzr(['grep', 'l[aeiou]ne1', 'dir0', 'dir1'])
865
 
        self.assertContainsRe(out, "^dir0/file0.txt:line1",
866
 
                              flags=TestGrep._reflags)
867
 
        self.assertContainsRe(out, "^dir1/file1.txt:line1",
868
 
                              flags=TestGrep._reflags)
 
775
        self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
 
776
        self.assertContainsRe(out, "^dir1/file1.txt:line1", flags=TestGrep._reflags)
869
777
 
870
778
        out, err = self.run_bzr(['grep', 'line1', 'dir0', 'dir1'])
871
 
        self.assertContainsRe(out, "^dir0/file0.txt:line1",
872
 
                              flags=TestGrep._reflags)
873
 
        self.assertContainsRe(out, "^dir1/file1.txt:line1",
874
 
                              flags=TestGrep._reflags)
 
779
        self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
 
780
        self.assertContainsRe(out, "^dir1/file1.txt:line1", flags=TestGrep._reflags)
875
781
 
876
782
    def test_versioned_files_from_outside_dir(self):
877
783
        """(versioned) Grep for pattern with dirs passed as argument.
886
792
        self._mk_versioned_dir('dir1')
887
793
        self._mk_versioned_file('dir1/file1.txt')
888
794
 
889
 
        out, err = self.run_bzr(
890
 
            ['grep', '-r', 'last:1', '.ine1', 'dir0', 'dir1'])
891
 
        self.assertContainsRe(
892
 
            out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
893
 
        self.assertContainsRe(
894
 
            out, "^dir1/file1.txt~.:line1", flags=TestGrep._reflags)
 
795
        out, err = self.run_bzr(['grep', '-r', 'last:1', '.ine1', 'dir0', 'dir1'])
 
796
        self.assertContainsRe(out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
 
797
        self.assertContainsRe(out, "^dir1/file1.txt~.:line1", flags=TestGrep._reflags)
895
798
 
896
 
        out, err = self.run_bzr(
897
 
            ['grep', '-r', 'last:1', 'line1', 'dir0', 'dir1'])
898
 
        self.assertContainsRe(
899
 
            out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
900
 
        self.assertContainsRe(
901
 
            out, "^dir1/file1.txt~.:line1", flags=TestGrep._reflags)
 
799
        out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1', 'dir0', 'dir1'])
 
800
        self.assertContainsRe(out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
 
801
        self.assertContainsRe(out, "^dir1/file1.txt~.:line1", flags=TestGrep._reflags)
902
802
 
903
803
    def test_wtree_files_from_outside_dir(self):
904
804
        """(wtree) Grep for pattern with dirs passed as argument.
914
814
        self._mk_versioned_file('dir1/file1.txt')
915
815
 
916
816
        out, err = self.run_bzr(['grep', 'li.e1', 'dir0', 'dir1'])
917
 
        self.assertContainsRe(out, "^dir0/file0.txt:line1",
918
 
                              flags=TestGrep._reflags)
919
 
        self.assertContainsRe(out, "^dir1/file1.txt:line1",
920
 
                              flags=TestGrep._reflags)
 
817
        self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
 
818
        self.assertContainsRe(out, "^dir1/file1.txt:line1", flags=TestGrep._reflags)
921
819
 
922
820
        out, err = self.run_bzr(['grep', 'line1', 'dir0', 'dir1'])
923
 
        self.assertContainsRe(out, "^dir0/file0.txt:line1",
924
 
                              flags=TestGrep._reflags)
925
 
        self.assertContainsRe(out, "^dir1/file1.txt:line1",
926
 
                              flags=TestGrep._reflags)
 
821
        self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
 
822
        self.assertContainsRe(out, "^dir1/file1.txt:line1", flags=TestGrep._reflags)
927
823
 
928
824
    def test_versioned_files_from_outside_two_dirs(self):
929
825
        """(versioned) Grep for pattern with two levels of nested dir.
941
837
        self._mk_versioned_dir('dir0/dir00')
942
838
        self._mk_versioned_file('dir0/dir00/file0.txt')
943
839
 
944
 
        out, err = self.run_bzr(
945
 
            ['grep', '-r', 'last:1', 'l.ne1', 'dir0/dir00'])
946
 
        self.assertContainsRe(
947
 
            out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
 
840
        out, err = self.run_bzr(['grep', '-r', 'last:1', 'l.ne1', 'dir0/dir00'])
 
841
        self.assertContainsRe(out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
948
842
 
949
843
        out, err = self.run_bzr(['grep', '-r', 'last:1', 'l.ne1'])
950
 
        self.assertContainsRe(
951
 
            out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
 
844
        self.assertContainsRe(out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
952
845
 
953
 
        out, err = self.run_bzr(
954
 
            ['grep', '-r', 'last:1', 'line1', 'dir0/dir00'])
955
 
        self.assertContainsRe(
956
 
            out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
 
846
        out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1', 'dir0/dir00'])
 
847
        self.assertContainsRe(out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
957
848
 
958
849
        out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
959
 
        self.assertContainsRe(
960
 
            out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
 
850
        self.assertContainsRe(out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
961
851
 
962
852
    def test_wtree_files_from_outside_two_dirs(self):
963
853
        """(wtree) Grep for pattern with two levels of nested dir.
976
866
        self._mk_versioned_file('dir0/dir00/file0.txt')
977
867
 
978
868
        out, err = self.run_bzr(['grep', 'lin.1', 'dir0/dir00'])
979
 
        self.assertContainsRe(
980
 
            out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
 
869
        self.assertContainsRe(out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
981
870
 
982
871
        out, err = self.run_bzr(['grep', 'li.e1'])
983
 
        self.assertContainsRe(
984
 
            out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
 
872
        self.assertContainsRe(out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
985
873
 
986
874
        out, err = self.run_bzr(['grep', 'line1', 'dir0/dir00'])
987
 
        self.assertContainsRe(
988
 
            out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
 
875
        self.assertContainsRe(out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
989
876
 
990
877
        out, err = self.run_bzr(['grep', 'line1'])
991
 
        self.assertContainsRe(
992
 
            out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
 
878
        self.assertContainsRe(out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
993
879
 
994
880
    def test_versioned_file_within_dir_two_levels(self):
995
881
        """(versioned) Search for pattern while in nested dir (two levels).
1003
889
        os.chdir('dir0')
1004
890
 
1005
891
        out, err = self.run_bzr(['grep', '-r', 'last:1', '.ine1'])
1006
 
        self.assertContainsRe(
1007
 
            out, "^dir1/file0.txt~.:line1", flags=TestGrep._reflags)
1008
 
 
1009
 
        out, err = self.run_bzr(
1010
 
            ['grep', '-r', 'last:1', '--from-root', 'l.ne1'])
1011
 
        self.assertContainsRe(
1012
 
            out, "^dir0/dir1/file0.txt~.:line1", flags=TestGrep._reflags)
1013
 
 
1014
 
        out, err = self.run_bzr(
1015
 
            ['grep', '-r', 'last:1', '--no-recursive', 'line1'])
 
892
        self.assertContainsRe(out, "^dir1/file0.txt~.:line1", flags=TestGrep._reflags)
 
893
 
 
894
        out, err = self.run_bzr(['grep', '-r', 'last:1', '--from-root', 'l.ne1'])
 
895
        self.assertContainsRe(out, "^dir0/dir1/file0.txt~.:line1", flags=TestGrep._reflags)
 
896
 
 
897
        out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1'])
1016
898
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1017
899
 
1018
900
        out, err = self.run_bzr(['grep', '-r', 'last:1', 'lin.1'])
1019
 
        self.assertContainsRe(
1020
 
            out, "^dir1/file0.txt~.:line1", flags=TestGrep._reflags)
1021
 
 
1022
 
        out, err = self.run_bzr(
1023
 
            ['grep', '-r', 'last:1', '--from-root', 'line1'])
1024
 
        self.assertContainsRe(
1025
 
            out, "^dir0/dir1/file0.txt~.:line1", flags=TestGrep._reflags)
1026
 
 
1027
 
        out, err = self.run_bzr(
1028
 
            ['grep', '-r', 'last:1', '--no-recursive', 'line1'])
 
901
        self.assertContainsRe(out, "^dir1/file0.txt~.:line1", flags=TestGrep._reflags)
 
902
 
 
903
        out, err = self.run_bzr(['grep', '-r', 'last:1', '--from-root', 'line1'])
 
904
        self.assertContainsRe(out, "^dir0/dir1/file0.txt~.:line1", flags=TestGrep._reflags)
 
905
 
 
906
        out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1'])
1029
907
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1030
908
        self.assertEqual(len(out.splitlines()), 0)
1031
909
 
1041
919
        os.chdir('dir0')
1042
920
 
1043
921
        out, err = self.run_bzr(['grep', 'l[hij]ne1'])
1044
 
        self.assertContainsRe(out, "^dir1/file0.txt:line1",
1045
 
                              flags=TestGrep._reflags)
 
922
        self.assertContainsRe(out, "^dir1/file0.txt:line1", flags=TestGrep._reflags)
1046
923
 
1047
924
        out, err = self.run_bzr(['grep', '--from-root', 'l.ne1'])
1048
 
        self.assertContainsRe(
1049
 
            out, "^dir0/dir1/file0.txt:line1", flags=TestGrep._reflags)
 
925
        self.assertContainsRe(out, "^dir0/dir1/file0.txt:line1", flags=TestGrep._reflags)
1050
926
 
1051
927
        out, err = self.run_bzr(['grep', '--no-recursive', 'lin.1'])
1052
928
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1053
929
 
1054
930
        out, err = self.run_bzr(['grep', 'line1'])
1055
 
        self.assertContainsRe(out, "^dir1/file0.txt:line1",
1056
 
                              flags=TestGrep._reflags)
 
931
        self.assertContainsRe(out, "^dir1/file0.txt:line1", flags=TestGrep._reflags)
1057
932
 
1058
933
        out, err = self.run_bzr(['grep', '--from-root', 'line1'])
1059
 
        self.assertContainsRe(
1060
 
            out, "^dir0/dir1/file0.txt:line1", flags=TestGrep._reflags)
 
934
        self.assertContainsRe(out, "^dir0/dir1/file0.txt:line1", flags=TestGrep._reflags)
1061
935
 
1062
936
        out, err = self.run_bzr(['grep', '--no-recursive', 'line1'])
1063
937
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1071
945
        self._mk_versioned_file('file0.txt')
1072
946
 
1073
947
        out, err = self.run_bzr(['grep', '-r', 'last:1', 'LinE1', 'file0.txt'])
1074
 
        self.assertNotContainsRe(
1075
 
            out, "file0.txt~.:line1", flags=TestGrep._reflags)
 
948
        self.assertNotContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
1076
949
 
1077
950
        out, err = self.run_bzr(['grep', '-r', 'last:1', 'Li.E1', 'file0.txt'])
1078
 
        self.assertNotContainsRe(
1079
 
            out, "file0.txt~.:line1", flags=TestGrep._reflags)
 
951
        self.assertNotContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
1080
952
 
1081
953
    def test_wtree_ignore_case_no_match(self):
1082
954
        """(wtree) Match fails without --ignore-case.
1087
959
        self._mk_versioned_file('file0.txt')
1088
960
 
1089
961
        out, err = self.run_bzr(['grep', 'LinE1', 'file0.txt'])
1090
 
        self.assertNotContainsRe(
1091
 
            out, "file0.txt:line1", flags=TestGrep._reflags)
 
962
        self.assertNotContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
1092
963
 
1093
964
        out, err = self.run_bzr(['grep', '.inE1', 'file0.txt'])
1094
 
        self.assertNotContainsRe(
1095
 
            out, "file0.txt:line1", flags=TestGrep._reflags)
 
965
        self.assertNotContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
1096
966
 
1097
967
    def test_versioned_ignore_case_match(self):
1098
968
        """(versioned) Match fails without --ignore-case.
1103
973
        self._mk_versioned_file('file0.txt')
1104
974
 
1105
975
        out, err = self.run_bzr(['grep', '-r', 'last:1',
1106
 
                                 '-i', 'Li.E1', 'file0.txt'])
1107
 
        self.assertContainsRe(out, "file0.txt~.:line1",
1108
 
                              flags=TestGrep._reflags)
1109
 
 
1110
 
        out, err = self.run_bzr(['grep', '-r', 'last:1',
1111
 
                                 '-i', 'LinE1', 'file0.txt'])
1112
 
        self.assertContainsRe(out, "file0.txt~.:line1",
1113
 
                              flags=TestGrep._reflags)
1114
 
 
1115
 
        out, err = self.run_bzr(['grep', '-r', 'last:1',
1116
 
                                 '--ignore-case', 'LinE1', 'file0.txt'])
1117
 
        self.assertContainsRe(out, "^file0.txt~.:line1",
1118
 
                              flags=TestGrep._reflags)
 
976
            '-i', 'Li.E1', 'file0.txt'])
 
977
        self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
 
978
 
 
979
        out, err = self.run_bzr(['grep', '-r', 'last:1',
 
980
            '-i', 'LinE1', 'file0.txt'])
 
981
        self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
 
982
 
 
983
        out, err = self.run_bzr(['grep', '-r', 'last:1',
 
984
            '--ignore-case', 'LinE1', 'file0.txt'])
 
985
        self.assertContainsRe(out, "^file0.txt~.:line1", flags=TestGrep._reflags)
1119
986
 
1120
987
    def test_wtree_ignore_case_match(self):
1121
988
        """(wtree) Match fails without --ignore-case.
1128
995
        out, err = self.run_bzr(['grep', '-i', 'LinE1', 'file0.txt'])
1129
996
        self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
1130
997
 
1131
 
        out, err = self.run_bzr(
1132
 
            ['grep', '--ignore-case', 'LinE1', 'file0.txt'])
 
998
        out, err = self.run_bzr(['grep', '--ignore-case', 'LinE1', 'file0.txt'])
1133
999
        self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
1134
1000
 
1135
 
        out, err = self.run_bzr(
1136
 
            ['grep', '--ignore-case', 'Li.E1', 'file0.txt'])
 
1001
        out, err = self.run_bzr(['grep', '--ignore-case', 'Li.E1', 'file0.txt'])
1137
1002
        self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
1138
1003
 
1139
1004
    def test_versioned_from_root_fail(self):
1179
1044
        os.chdir('dir0')
1180
1045
 
1181
1046
        out, err = self.run_bzr(['grep', '-r', 'last:1',
1182
 
                                 '--from-root', 'l.ne1'])
1183
 
        self.assertContainsRe(out, "file0.txt~.:line1",
1184
 
                              flags=TestGrep._reflags)
 
1047
            '--from-root', 'l.ne1'])
 
1048
        self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
1185
1049
 
1186
1050
        out, err = self.run_bzr(['grep', '-r', 'last:1',
1187
 
                                 '--from-root', 'line1'])
1188
 
        self.assertContainsRe(out, "file0.txt~.:line1",
1189
 
                              flags=TestGrep._reflags)
 
1051
            '--from-root', 'line1'])
 
1052
        self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
1190
1053
 
1191
1054
    def test_wtree_from_root_pass(self):
1192
1055
        """(wtree) Match pass with --from-root.
1213
1076
        self._mk_versioned_file('file0.txt')
1214
1077
 
1215
1078
        out, err = self.run_bzr(['grep', '-r', 'last:1',
1216
 
                                 '--line-number', 'li.e3', 'file0.txt'])
1217
 
        self.assertContainsRe(out, "file0.txt~.:3:line3",
1218
 
                              flags=TestGrep._reflags)
1219
 
 
1220
 
        out, err = self.run_bzr(['grep', '-r', 'last:1',
1221
 
                                 '--line-number', 'line3', 'file0.txt'])
1222
 
        self.assertContainsRe(out, "file0.txt~.:3:line3",
1223
 
                              flags=TestGrep._reflags)
1224
 
 
1225
 
        out, err = self.run_bzr(['grep', '-r', 'last:1',
1226
 
                                 '-n', 'line1', 'file0.txt'])
1227
 
        self.assertContainsRe(out, "file0.txt~.:1:line1",
1228
 
                              flags=TestGrep._reflags)
 
1079
            '--line-number', 'li.e3', 'file0.txt'])
 
1080
        self.assertContainsRe(out, "file0.txt~.:3:line3", flags=TestGrep._reflags)
 
1081
 
 
1082
        out, err = self.run_bzr(['grep', '-r', 'last:1',
 
1083
            '--line-number', 'line3', 'file0.txt'])
 
1084
        self.assertContainsRe(out, "file0.txt~.:3:line3", flags=TestGrep._reflags)
 
1085
 
 
1086
        out, err = self.run_bzr(['grep', '-r', 'last:1',
 
1087
            '-n', 'line1', 'file0.txt'])
 
1088
        self.assertContainsRe(out, "file0.txt~.:1:line1", flags=TestGrep._reflags)
1229
1089
 
1230
1090
        out, err = self.run_bzr(['grep', '-n', 'line[0-9]', 'file0.txt'])
1231
 
        self.assertContainsRe(out, "file0.txt:3:line3",
1232
 
                              flags=TestGrep._reflags)
 
1091
        self.assertContainsRe(out, "file0.txt:3:line3", flags=TestGrep._reflags)
1233
1092
 
1234
1093
    def test_wtree_with_line_number(self):
1235
1094
        """(wtree) Search for pattern with --line-number.
1239
1098
        os.chdir(wd)
1240
1099
        self._mk_versioned_file('file0.txt')
1241
1100
 
1242
 
        out, err = self.run_bzr(
1243
 
            ['grep', '--line-number', 'line3', 'file0.txt'])
1244
 
        self.assertContainsRe(out, "file0.txt:3:line3",
1245
 
                              flags=TestGrep._reflags)
 
1101
        out, err = self.run_bzr(['grep', '--line-number', 'line3', 'file0.txt'])
 
1102
        self.assertContainsRe(out, "file0.txt:3:line3", flags=TestGrep._reflags)
1246
1103
 
1247
1104
        out, err = self.run_bzr(['grep', '-n', 'line1', 'file0.txt'])
1248
 
        self.assertContainsRe(out, "file0.txt:1:line1",
1249
 
                              flags=TestGrep._reflags)
 
1105
        self.assertContainsRe(out, "file0.txt:1:line1", flags=TestGrep._reflags)
1250
1106
 
1251
1107
        out, err = self.run_bzr(['grep', '-n', '[hjkl]ine1', 'file0.txt'])
1252
 
        self.assertContainsRe(out, "file0.txt:1:line1",
1253
 
                              flags=TestGrep._reflags)
 
1108
        self.assertContainsRe(out, "file0.txt:1:line1", flags=TestGrep._reflags)
1254
1109
 
1255
1110
        out, err = self.run_bzr(['grep', '-n', 'line[0-9]', 'file0.txt'])
1256
 
        self.assertContainsRe(out, "file0.txt:3:line3",
1257
 
                              flags=TestGrep._reflags)
 
1111
        self.assertContainsRe(out, "file0.txt:3:line3", flags=TestGrep._reflags)
1258
1112
 
1259
1113
    def test_revno_basic_history_grep_file(self):
1260
1114
        """Search for pattern in specific revision number in a file.
1278
1132
 
1279
1133
        # rev 3 should not have text 'v3' with line number
1280
1134
        out, err = self.run_bzr(['grep', '-r', '3', '-n', 'v3', fname])
1281
 
        self.assertContainsRe(out, "file0.txt~3:2:v3.*",
1282
 
                              flags=TestGrep._reflags)
 
1135
        self.assertContainsRe(out, "file0.txt~3:2:v3.*", flags=TestGrep._reflags)
1283
1136
 
1284
1137
        # rev 2 should not have text 'v3'
1285
1138
        out, err = self.run_bzr(['grep', '-r', '2', '[tuv]3', fname])
1291
1144
 
1292
1145
        # rev 3 should not have text 'v3' with line number
1293
1146
        out, err = self.run_bzr(['grep', '-r', '3', '-n', '[tuv]3', fname])
1294
 
        self.assertContainsRe(out, "file0.txt~3:2:v3.*",
1295
 
                              flags=TestGrep._reflags)
 
1147
        self.assertContainsRe(out, "file0.txt~3:2:v3.*", flags=TestGrep._reflags)
1296
1148
 
1297
1149
    def test_revno_basic_history_grep_full(self):
1298
1150
        """Search for pattern in specific revision number in a file.
1301
1153
        fname = 'file0.txt'
1302
1154
        self.make_branch_and_tree(wd)
1303
1155
        os.chdir(wd)
1304
 
        self._mk_versioned_file(fname, total_lines=0)  # rev1
 
1156
        self._mk_versioned_file(fname, total_lines=0) # rev1
1305
1157
        self._mk_versioned_file('file1.txt')          # rev2
1306
1158
        self._update_file(fname, text="v3 text\n")    # rev3
1307
1159
        self._update_file(fname, text="v4 text\n")    # rev4
1345
1197
 
1346
1198
        # v4 should not be present in revno 3
1347
1199
        out, err = self.run_bzr(['grep', '-r', 'last:3', 'v4'])
1348
 
        self.assertNotContainsRe(
1349
 
            out, "^dir0/file0.txt", flags=TestGrep._reflags)
 
1200
        self.assertNotContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
1350
1201
 
1351
1202
        # v4 should be present in revno 4
1352
1203
        out, err = self.run_bzr(['grep', '-r', 'last:2', 'v4'])
1353
 
        self.assertContainsRe(out, "^dir0/file0.txt~4:v4",
1354
 
                              flags=TestGrep._reflags)
 
1204
        self.assertContainsRe(out, "^dir0/file0.txt~4:v4", flags=TestGrep._reflags)
1355
1205
 
1356
1206
        # v4 should not be present in revno 3
1357
1207
        out, err = self.run_bzr(['grep', '-r', 'last:3', '[tuv]4'])
1358
 
        self.assertNotContainsRe(
1359
 
            out, "^dir0/file0.txt", flags=TestGrep._reflags)
 
1208
        self.assertNotContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
1360
1209
 
1361
1210
        # v4 should be present in revno 4
1362
1211
        out, err = self.run_bzr(['grep', '-r', 'last:2', '[tuv]4'])
1363
 
        self.assertContainsRe(out, "^dir0/file0.txt~4:v4",
1364
 
                              flags=TestGrep._reflags)
 
1212
        self.assertContainsRe(out, "^dir0/file0.txt~4:v4", flags=TestGrep._reflags)
1365
1213
 
1366
1214
    def test_revno_range_basic_history_grep(self):
1367
1215
        """Search for pattern in revision range for file.
1370
1218
        fname = 'file0.txt'
1371
1219
        self.make_branch_and_tree(wd)
1372
1220
        os.chdir(wd)
1373
 
        self._mk_versioned_file(fname, total_lines=0)  # rev1
 
1221
        self._mk_versioned_file(fname, total_lines=0) # rev1
1374
1222
        self._mk_versioned_file('file1.txt')          # rev2
1375
1223
        self._update_file(fname, text="v3 text\n")    # rev3
1376
1224
        self._update_file(fname, text="v4 text\n")    # rev4
1406
1254
        self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1407
1255
        self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1408
1256
        self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1409
 
        self.assertNotContainsRe(
1410
 
            out, "file0.txt~6:v3", flags=TestGrep._reflags)
 
1257
        self.assertNotContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1411
1258
        self.assertEqual(len(out.splitlines()), 3)
1412
1259
 
1413
1260
        out, err = self.run_bzr(['grep', '-r', '5..1', 'v3'])
1414
1261
        self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1415
1262
        self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1416
1263
        self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1417
 
        self.assertNotContainsRe(
1418
 
            out, "file0.txt~6:v3", flags=TestGrep._reflags)
 
1264
        self.assertNotContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1419
1265
        self.assertEqual(len(out.splitlines()), 3)
1420
1266
 
1421
1267
        out, err = self.run_bzr(['grep', '-r', '1..', '[tuv]3'])
1429
1275
        self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1430
1276
        self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1431
1277
        self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1432
 
        self.assertNotContainsRe(
1433
 
            out, "file0.txt~6:v3", flags=TestGrep._reflags)
 
1278
        self.assertNotContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1434
1279
        self.assertEqual(len(out.splitlines()), 3)
1435
1280
 
1436
1281
        out, err = self.run_bzr(['grep', '-r', '5..1', '[tuv]3'])
1437
1282
        self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1438
1283
        self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1439
1284
        self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1440
 
        self.assertNotContainsRe(
1441
 
            out, "file0.txt~6:v3", flags=TestGrep._reflags)
 
1285
        self.assertNotContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1442
1286
        self.assertEqual(len(out.splitlines()), 3)
1443
1287
 
1444
1288
    def test_revno_range_versioned_file_in_dir(self):
1455
1299
        self._update_file('dir0/file0.txt', "v6 text\n")    # rev6
1456
1300
 
1457
1301
        out, err = self.run_bzr(['grep', '-r', '2..5', 'v3'])
1458
 
        self.assertContainsRe(out, "^dir0/file0.txt~3:v3",
1459
 
                              flags=TestGrep._reflags)
1460
 
        self.assertContainsRe(out, "^dir0/file0.txt~4:v3",
1461
 
                              flags=TestGrep._reflags)
1462
 
        self.assertContainsRe(out, "^dir0/file0.txt~5:v3",
1463
 
                              flags=TestGrep._reflags)
1464
 
        self.assertNotContainsRe(
1465
 
            out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
 
1302
        self.assertContainsRe(out, "^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
 
1303
        self.assertContainsRe(out, "^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
 
1304
        self.assertContainsRe(out, "^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
 
1305
        self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1466
1306
        self.assertEqual(len(out.splitlines()), 3)
1467
1307
 
1468
1308
        out, err = self.run_bzr(['grep', '-r', '2..5', '[tuv]3'])
1469
 
        self.assertContainsRe(out, "^dir0/file0.txt~3:v3",
1470
 
                              flags=TestGrep._reflags)
1471
 
        self.assertContainsRe(out, "^dir0/file0.txt~4:v3",
1472
 
                              flags=TestGrep._reflags)
1473
 
        self.assertContainsRe(out, "^dir0/file0.txt~5:v3",
1474
 
                              flags=TestGrep._reflags)
1475
 
        self.assertNotContainsRe(
1476
 
            out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
 
1309
        self.assertContainsRe(out, "^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
 
1310
        self.assertContainsRe(out, "^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
 
1311
        self.assertContainsRe(out, "^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
 
1312
        self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1477
1313
        self.assertEqual(len(out.splitlines()), 3)
1478
1314
 
1479
1315
    def test_revno_range_versioned_file_from_outside_dir(self):
1490
1326
        self._update_file('dir0/file0.txt', "v6 text\n")    # rev6
1491
1327
 
1492
1328
        out, err = self.run_bzr(['grep', '-r', '2..5', 'v3', 'dir0'])
1493
 
        self.assertContainsRe(out, "^dir0/file0.txt~3:v3",
1494
 
                              flags=TestGrep._reflags)
1495
 
        self.assertContainsRe(out, "^dir0/file0.txt~4:v3",
1496
 
                              flags=TestGrep._reflags)
1497
 
        self.assertContainsRe(out, "^dir0/file0.txt~5:v3",
1498
 
                              flags=TestGrep._reflags)
1499
 
        self.assertNotContainsRe(
1500
 
            out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
 
1329
        self.assertContainsRe(out, "^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
 
1330
        self.assertContainsRe(out, "^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
 
1331
        self.assertContainsRe(out, "^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
 
1332
        self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1501
1333
 
1502
1334
        out, err = self.run_bzr(['grep', '-r', '2..5', '[tuv]3', 'dir0'])
1503
 
        self.assertContainsRe(out, "^dir0/file0.txt~3:v3",
1504
 
                              flags=TestGrep._reflags)
1505
 
        self.assertContainsRe(out, "^dir0/file0.txt~4:v3",
1506
 
                              flags=TestGrep._reflags)
1507
 
        self.assertContainsRe(out, "^dir0/file0.txt~5:v3",
1508
 
                              flags=TestGrep._reflags)
1509
 
        self.assertNotContainsRe(
1510
 
            out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
 
1335
        self.assertContainsRe(out, "^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
 
1336
        self.assertContainsRe(out, "^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
 
1337
        self.assertContainsRe(out, "^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
 
1338
        self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1511
1339
 
1512
1340
    def test_levels(self):
1513
1341
        """--levels=0 should show findings from merged revision.
1534
1362
 
1535
1363
        # levels should be ignored by wtree grep
1536
1364
        out, err = self.run_bzr(['grep', '--levels=0', 'line1'])
1537
 
        self.assertContainsRe(out, "^file0.txt:line1$",
1538
 
                              flags=TestGrep._reflags)
1539
 
        self.assertContainsRe(out, "^file1.txt:line1$",
1540
 
                              flags=TestGrep._reflags)
1541
 
        self.assertContainsRe(out, "^file0.txt:line10$",
1542
 
                              flags=TestGrep._reflags)
1543
 
        self.assertContainsRe(out, "^file1.txt:line10$",
1544
 
                              flags=TestGrep._reflags)
 
1365
        self.assertContainsRe(out, "^file0.txt:line1$", flags=TestGrep._reflags)
 
1366
        self.assertContainsRe(out, "^file1.txt:line1$", flags=TestGrep._reflags)
 
1367
        self.assertContainsRe(out, "^file0.txt:line10$", flags=TestGrep._reflags)
 
1368
        self.assertContainsRe(out, "^file1.txt:line10$", flags=TestGrep._reflags)
1545
1369
        self.assertEqual(len(out.splitlines()), 4)
1546
1370
 
1547
 
        out, err = self.run_bzr(
1548
 
            ['grep', '-r', 'last:1..', '--levels=0', 'line1'])
1549
 
        self.assertContainsRe(out, "^file0.txt~2:line1$",
1550
 
                              flags=TestGrep._reflags)
1551
 
        self.assertContainsRe(out, "^file1.txt~2:line1$",
1552
 
                              flags=TestGrep._reflags)
1553
 
        self.assertContainsRe(
1554
 
            out, "^file0.txt~1.1.1:line1$", flags=TestGrep._reflags)
1555
 
        self.assertContainsRe(
1556
 
            out, "^file1.txt~1.1.1:line1$", flags=TestGrep._reflags)
1557
 
        self.assertContainsRe(out, "^file0.txt~2:line10$",
1558
 
                              flags=TestGrep._reflags)
1559
 
        self.assertContainsRe(out, "^file1.txt~2:line10$",
1560
 
                              flags=TestGrep._reflags)
1561
 
        self.assertContainsRe(
1562
 
            out, "^file0.txt~1.1.1:line10$", flags=TestGrep._reflags)
1563
 
        self.assertContainsRe(
1564
 
            out, "^file1.txt~1.1.1:line10$", flags=TestGrep._reflags)
 
1371
        out, err = self.run_bzr(['grep', '-r', 'last:1..', '--levels=0', 'line1'])
 
1372
        self.assertContainsRe(out, "^file0.txt~2:line1$", flags=TestGrep._reflags)
 
1373
        self.assertContainsRe(out, "^file1.txt~2:line1$", flags=TestGrep._reflags)
 
1374
        self.assertContainsRe(out, "^file0.txt~1.1.1:line1$", flags=TestGrep._reflags)
 
1375
        self.assertContainsRe(out, "^file1.txt~1.1.1:line1$", flags=TestGrep._reflags)
 
1376
        self.assertContainsRe(out, "^file0.txt~2:line10$", flags=TestGrep._reflags)
 
1377
        self.assertContainsRe(out, "^file1.txt~2:line10$", flags=TestGrep._reflags)
 
1378
        self.assertContainsRe(out, "^file0.txt~1.1.1:line10$", flags=TestGrep._reflags)
 
1379
        self.assertContainsRe(out, "^file1.txt~1.1.1:line10$", flags=TestGrep._reflags)
1565
1380
        self.assertEqual(len(out.splitlines()), 8)
1566
1381
 
1567
 
        out, err = self.run_bzr(
1568
 
            ['grep', '-r', '-1..', '-n', '--levels=0', 'line1'])
1569
 
        self.assertContainsRe(out, "^file0.txt~2:1:line1$",
1570
 
                              flags=TestGrep._reflags)
1571
 
        self.assertContainsRe(out, "^file1.txt~2:1:line1$",
1572
 
                              flags=TestGrep._reflags)
1573
 
        self.assertContainsRe(
1574
 
            out, "^file0.txt~1.1.1:1:line1$", flags=TestGrep._reflags)
1575
 
        self.assertContainsRe(
1576
 
            out, "^file1.txt~1.1.1:1:line1$", flags=TestGrep._reflags)
1577
 
        self.assertContainsRe(
1578
 
            out, "^file0.txt~2:10:line10$", flags=TestGrep._reflags)
1579
 
        self.assertContainsRe(
1580
 
            out, "^file1.txt~2:10:line10$", flags=TestGrep._reflags)
1581
 
        self.assertContainsRe(
1582
 
            out, "^file0.txt~1.1.1:10:line10$", flags=TestGrep._reflags)
1583
 
        self.assertContainsRe(
1584
 
            out, "^file1.txt~1.1.1:10:line10$", flags=TestGrep._reflags)
 
1382
        out, err = self.run_bzr(['grep', '-r',  '-1..', '-n', '--levels=0', 'line1'])
 
1383
        self.assertContainsRe(out, "^file0.txt~2:1:line1$", flags=TestGrep._reflags)
 
1384
        self.assertContainsRe(out, "^file1.txt~2:1:line1$", flags=TestGrep._reflags)
 
1385
        self.assertContainsRe(out, "^file0.txt~1.1.1:1:line1$", flags=TestGrep._reflags)
 
1386
        self.assertContainsRe(out, "^file1.txt~1.1.1:1:line1$", flags=TestGrep._reflags)
 
1387
        self.assertContainsRe(out, "^file0.txt~2:10:line10$", flags=TestGrep._reflags)
 
1388
        self.assertContainsRe(out, "^file1.txt~2:10:line10$", flags=TestGrep._reflags)
 
1389
        self.assertContainsRe(out, "^file0.txt~1.1.1:10:line10$", flags=TestGrep._reflags)
 
1390
        self.assertContainsRe(out, "^file1.txt~1.1.1:10:line10$", flags=TestGrep._reflags)
1585
1391
        self.assertEqual(len(out.splitlines()), 8)
1586
1392
 
1587
1393
        # levels should be ignored by wtree grep
1588
1394
        out, err = self.run_bzr(['grep', '--levels=0', 'l.ne1'])
1589
 
        self.assertContainsRe(out, "^file0.txt:line1$",
1590
 
                              flags=TestGrep._reflags)
1591
 
        self.assertContainsRe(out, "^file1.txt:line1$",
1592
 
                              flags=TestGrep._reflags)
1593
 
        self.assertContainsRe(out, "^file0.txt:line10$",
1594
 
                              flags=TestGrep._reflags)
1595
 
        self.assertContainsRe(out, "^file1.txt:line10$",
1596
 
                              flags=TestGrep._reflags)
 
1395
        self.assertContainsRe(out, "^file0.txt:line1$", flags=TestGrep._reflags)
 
1396
        self.assertContainsRe(out, "^file1.txt:line1$", flags=TestGrep._reflags)
 
1397
        self.assertContainsRe(out, "^file0.txt:line10$", flags=TestGrep._reflags)
 
1398
        self.assertContainsRe(out, "^file1.txt:line10$", flags=TestGrep._reflags)
1597
1399
        self.assertEqual(len(out.splitlines()), 4)
1598
1400
 
1599
 
        out, err = self.run_bzr(
1600
 
            ['grep', '-r', 'last:1..', '--levels=0', 'lin.1'])
1601
 
        self.assertContainsRe(out, "^file0.txt~2:line1$",
1602
 
                              flags=TestGrep._reflags)
1603
 
        self.assertContainsRe(out, "^file1.txt~2:line1$",
1604
 
                              flags=TestGrep._reflags)
1605
 
        self.assertContainsRe(
1606
 
            out, "^file0.txt~1.1.1:line1$", flags=TestGrep._reflags)
1607
 
        self.assertContainsRe(
1608
 
            out, "^file1.txt~1.1.1:line1$", flags=TestGrep._reflags)
1609
 
        self.assertContainsRe(out, "^file0.txt~2:line10$",
1610
 
                              flags=TestGrep._reflags)
1611
 
        self.assertContainsRe(out, "^file1.txt~2:line10$",
1612
 
                              flags=TestGrep._reflags)
1613
 
        self.assertContainsRe(
1614
 
            out, "^file0.txt~1.1.1:line10$", flags=TestGrep._reflags)
1615
 
        self.assertContainsRe(
1616
 
            out, "^file1.txt~1.1.1:line10$", flags=TestGrep._reflags)
 
1401
        out, err = self.run_bzr(['grep', '-r', 'last:1..', '--levels=0', 'lin.1'])
 
1402
        self.assertContainsRe(out, "^file0.txt~2:line1$", flags=TestGrep._reflags)
 
1403
        self.assertContainsRe(out, "^file1.txt~2:line1$", flags=TestGrep._reflags)
 
1404
        self.assertContainsRe(out, "^file0.txt~1.1.1:line1$", flags=TestGrep._reflags)
 
1405
        self.assertContainsRe(out, "^file1.txt~1.1.1:line1$", flags=TestGrep._reflags)
 
1406
        self.assertContainsRe(out, "^file0.txt~2:line10$", flags=TestGrep._reflags)
 
1407
        self.assertContainsRe(out, "^file1.txt~2:line10$", flags=TestGrep._reflags)
 
1408
        self.assertContainsRe(out, "^file0.txt~1.1.1:line10$", flags=TestGrep._reflags)
 
1409
        self.assertContainsRe(out, "^file1.txt~1.1.1:line10$", flags=TestGrep._reflags)
1617
1410
        self.assertEqual(len(out.splitlines()), 8)
1618
1411
 
1619
 
        out, err = self.run_bzr(
1620
 
            ['grep', '-r', '-1..', '-n', '--levels=0', '.ine1'])
1621
 
        self.assertContainsRe(out, "file0.txt~2:1:line1",
1622
 
                              flags=TestGrep._reflags)
1623
 
        self.assertContainsRe(out, "file1.txt~2:1:line1",
1624
 
                              flags=TestGrep._reflags)
1625
 
        self.assertContainsRe(
1626
 
            out, "file0.txt~1.1.1:1:line1", flags=TestGrep._reflags)
1627
 
        self.assertContainsRe(
1628
 
            out, "file1.txt~1.1.1:1:line1", flags=TestGrep._reflags)
 
1412
        out, err = self.run_bzr(['grep', '-r',  '-1..', '-n', '--levels=0', '.ine1'])
 
1413
        self.assertContainsRe(out, "file0.txt~2:1:line1", flags=TestGrep._reflags)
 
1414
        self.assertContainsRe(out, "file1.txt~2:1:line1", flags=TestGrep._reflags)
 
1415
        self.assertContainsRe(out, "file0.txt~1.1.1:1:line1", flags=TestGrep._reflags)
 
1416
        self.assertContainsRe(out, "file1.txt~1.1.1:1:line1", flags=TestGrep._reflags)
1629
1417
 
1630
1418
    def test_dotted_rev_grep(self):
1631
1419
        """Grep in dotted revs
1650
1438
        out, err = self.run_bzr(['ci', '-m', 'merged'])
1651
1439
 
1652
1440
        out, err = self.run_bzr(['grep', '-r', '1.1.1..1.1.4', 'text'])
1653
 
        self.assertContainsRe(
1654
 
            out, "file1.txt~1.1.2:text 0", flags=TestGrep._reflags)
1655
 
        self.assertContainsRe(
1656
 
            out, "file1.txt~1.1.3:text 1", flags=TestGrep._reflags)
1657
 
        self.assertContainsRe(
1658
 
            out, "file1.txt~1.1.3:text 1", flags=TestGrep._reflags)
1659
 
        self.assertContainsRe(
1660
 
            out, "file1.txt~1.1.4:text 0", flags=TestGrep._reflags)
1661
 
        self.assertContainsRe(
1662
 
            out, "file1.txt~1.1.4:text 1", flags=TestGrep._reflags)
1663
 
        self.assertContainsRe(
1664
 
            out, "file1.txt~1.1.4:text 2", flags=TestGrep._reflags)
 
1441
        self.assertContainsRe(out, "file1.txt~1.1.2:text 0", flags=TestGrep._reflags)
 
1442
        self.assertContainsRe(out, "file1.txt~1.1.3:text 1", flags=TestGrep._reflags)
 
1443
        self.assertContainsRe(out, "file1.txt~1.1.3:text 1", flags=TestGrep._reflags)
 
1444
        self.assertContainsRe(out, "file1.txt~1.1.4:text 0", flags=TestGrep._reflags)
 
1445
        self.assertContainsRe(out, "file1.txt~1.1.4:text 1", flags=TestGrep._reflags)
 
1446
        self.assertContainsRe(out, "file1.txt~1.1.4:text 2", flags=TestGrep._reflags)
1665
1447
        self.assertEqual(len(out.splitlines()), 6)
1666
1448
 
1667
1449
    def test_versioned_binary_file_grep(self):
1676
1458
 
1677
1459
        # note: set --verbose/-v flag to get the skip message.
1678
1460
        out, err = self.run_bzr(['grep', '-v', '-r', 'last:1',
1679
 
                                 'lineNN', 'file0.bin'])
 
1461
            'lineNN', 'file0.bin'])
1680
1462
        self.assertNotContainsRe(out, "file0.bin", flags=TestGrep._reflags)
1681
 
        self.assertContainsRe(
1682
 
            err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
 
1463
        self.assertContainsRe(err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
1683
1464
        self.assertEqual(len(out.splitlines()), 0)
1684
1465
        self.assertEqual(len(err.splitlines()), 1)
1685
1466
 
1686
1467
        out, err = self.run_bzr(['grep', '-v', '-r', 'last:1',
1687
 
                                 'line.N', 'file0.bin'])
 
1468
            'line.N', 'file0.bin'])
1688
1469
        self.assertNotContainsRe(out, "file0.bin", flags=TestGrep._reflags)
1689
 
        self.assertContainsRe(
1690
 
            err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
 
1470
        self.assertContainsRe(err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
1691
1471
        self.assertEqual(len(out.splitlines()), 0)
1692
1472
        self.assertEqual(len(err.splitlines()), 1)
1693
1473
 
1702
1482
 
1703
1483
        # note: set --verbose/-v flag to get the skip message.
1704
1484
        out, err = self.run_bzr(['grep', '-v', 'lineNN', 'file0.bin'])
1705
 
        self.assertNotContainsRe(
1706
 
            out, "file0.bin:line1", flags=TestGrep._reflags)
1707
 
        self.assertContainsRe(
1708
 
            err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
 
1485
        self.assertNotContainsRe(out, "file0.bin:line1", flags=TestGrep._reflags)
 
1486
        self.assertContainsRe(err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
1709
1487
 
1710
1488
        # binary warning should not be shown without --verbose
1711
1489
        out, err = self.run_bzr(['grep', 'lineNN', 'file0.bin'])
1712
 
        self.assertNotContainsRe(
1713
 
            out, "file0.bin:line1", flags=TestGrep._reflags)
 
1490
        self.assertNotContainsRe(out, "file0.bin:line1", flags=TestGrep._reflags)
1714
1491
        self.assertNotContainsRe(err, "Binary file", flags=TestGrep._reflags)
1715
1492
 
1716
1493
    def test_revspec(self):
1731
1508
 
1732
1509
        out, err = self.run_bzr(['grep', '-r', 'revno:4..', 'v4'])
1733
1510
        self.assertContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
1734
 
        self.assertEqual(len(out.splitlines()), 2)  # find v4 in rev4 and rev5
 
1511
        self.assertEqual(len(out.splitlines()), 2) # find v4 in rev4 and rev5
1735
1512
 
1736
1513
        out, err = self.run_bzr(['grep', '-r', '..revno:3', 'v4'])
1737
1514
        self.assertNotContainsRe(out, "file0", flags=TestGrep._reflags)
1761
1538
        out, err = self.run_bzr(['grep', '--files-with-matches', 'HELLO'])
1762
1539
 
1763
1540
        self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1764
 
        self.assertContainsRe(out, "^dir0/file00.txt$",
1765
 
                              flags=TestGrep._reflags)
 
1541
        self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
1766
1542
        self.assertEqual(len(out.splitlines()), 2)
1767
1543
 
1768
1544
        # regex
1769
1545
        out, err = self.run_bzr(['grep', '--files-with-matches', 'HE.LO'])
1770
1546
 
1771
1547
        self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1772
 
        self.assertContainsRe(out, "^dir0/file00.txt$",
1773
 
                              flags=TestGrep._reflags)
 
1548
        self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
1774
1549
        self.assertEqual(len(out.splitlines()), 2)
1775
1550
 
1776
1551
        # fixed-string
1777
1552
        out, err = self.run_bzr(['grep', '-l', 'HELLO'])
1778
1553
 
1779
1554
        self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1780
 
        self.assertContainsRe(out, "^dir0/file00.txt$",
1781
 
                              flags=TestGrep._reflags)
 
1555
        self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
1782
1556
        self.assertEqual(len(out.splitlines()), 2)
1783
1557
 
1784
1558
        # regex
1785
1559
        out, err = self.run_bzr(['grep', '-l', 'HE.LO'])
1786
1560
 
1787
1561
        self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1788
 
        self.assertContainsRe(out, "^dir0/file00.txt$",
1789
 
                              flags=TestGrep._reflags)
 
1562
        self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
1790
1563
        self.assertEqual(len(out.splitlines()), 2)
1791
1564
 
1792
1565
        # fixed-string
1793
1566
        out, err = self.run_bzr(['grep', '-l', 'HELLO', 'dir0', 'file1.txt'])
1794
1567
 
1795
 
        self.assertContainsRe(out, "^dir0/file00.txt$",
1796
 
                              flags=TestGrep._reflags)
 
1568
        self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
1797
1569
        self.assertEqual(len(out.splitlines()), 1)
1798
1570
 
1799
1571
        # regex
1800
1572
        out, err = self.run_bzr(['grep', '-l', '.ELLO', 'dir0', 'file1.txt'])
1801
1573
 
1802
 
        self.assertContainsRe(out, "^dir0/file00.txt$",
1803
 
                              flags=TestGrep._reflags)
 
1574
        self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
1804
1575
        self.assertEqual(len(out.splitlines()), 1)
1805
1576
 
1806
1577
        # fixed-string
1845
1616
 
1846
1617
        # fixed-string
1847
1618
        out, err = self.run_bzr(['grep', '-r', '-1', '--files-with-matches',
1848
 
                                 'HELLO'])
 
1619
            'HELLO'])
1849
1620
 
1850
1621
        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1851
 
        self.assertContainsRe(out, "^dir0/file00.txt~7$",
1852
 
                              flags=TestGrep._reflags)
 
1622
        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1853
1623
        self.assertEqual(len(out.splitlines()), 2)
1854
1624
 
1855
1625
        # regex
1856
1626
        out, err = self.run_bzr(['grep', '-r', '-1', '--files-with-matches',
1857
 
                                 'H.LLO'])
 
1627
            'H.LLO'])
1858
1628
 
1859
1629
        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1860
 
        self.assertContainsRe(out, "^dir0/file00.txt~7$",
1861
 
                              flags=TestGrep._reflags)
 
1630
        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1862
1631
        self.assertEqual(len(out.splitlines()), 2)
1863
1632
 
1864
1633
        # fixed-string
1865
1634
        out, err = self.run_bzr(['grep', '-r', '6..7', '--files-with-matches',
1866
 
                                 'HELLO'])
 
1635
            'HELLO'])
1867
1636
 
1868
1637
        self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1869
1638
        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1870
 
        self.assertContainsRe(out, "^dir0/file00.txt~7$",
1871
 
                              flags=TestGrep._reflags)
 
1639
        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1872
1640
        self.assertEqual(len(out.splitlines()), 3)
1873
1641
 
1874
1642
        # regex
1875
1643
        out, err = self.run_bzr(['grep', '-r', '6..7', '--files-with-matches',
1876
 
                                 'H.LLO'])
 
1644
            'H.LLO'])
1877
1645
 
1878
1646
        self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1879
1647
        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1880
 
        self.assertContainsRe(out, "^dir0/file00.txt~7$",
1881
 
                              flags=TestGrep._reflags)
 
1648
        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1882
1649
        self.assertEqual(len(out.splitlines()), 3)
1883
1650
 
1884
1651
        # fixed-string
1885
1652
        out, err = self.run_bzr(['grep', '-r', '-1', '-l', 'HELLO'])
1886
1653
 
1887
1654
        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1888
 
        self.assertContainsRe(out, "^dir0/file00.txt~7$",
1889
 
                              flags=TestGrep._reflags)
 
1655
        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1890
1656
        self.assertEqual(len(out.splitlines()), 2)
1891
1657
 
1892
1658
        # regex
1893
1659
        out, err = self.run_bzr(['grep', '-r', '-1', '-l', 'H.LLO'])
1894
1660
 
1895
1661
        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1896
 
        self.assertContainsRe(out, "^dir0/file00.txt~7$",
1897
 
                              flags=TestGrep._reflags)
 
1662
        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1898
1663
        self.assertEqual(len(out.splitlines()), 2)
1899
1664
 
1900
1665
        # fixed-string
1901
1666
        out, err = self.run_bzr(['grep', '-l', 'HELLO', '-r', '-1',
1902
 
                                 'dir0', 'file1.txt'])
 
1667
            'dir0', 'file1.txt'])
1903
1668
 
1904
 
        self.assertContainsRe(out, "^dir0/file00.txt~7$",
1905
 
                              flags=TestGrep._reflags)
 
1669
        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1906
1670
        self.assertEqual(len(out.splitlines()), 1)
1907
1671
 
1908
1672
        # regex
1909
1673
        out, err = self.run_bzr(['grep', '-l', 'H.LLO', '-r', '-1',
1910
 
                                 'dir0', 'file1.txt'])
 
1674
            'dir0', 'file1.txt'])
1911
1675
 
1912
 
        self.assertContainsRe(out, "^dir0/file00.txt~7$",
1913
 
                              flags=TestGrep._reflags)
 
1676
        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1914
1677
        self.assertEqual(len(out.splitlines()), 1)
1915
1678
 
1916
1679
        # fixed-string
1917
1680
        out, err = self.run_bzr(['grep', '-l', 'HELLO',
1918
 
                                 '-r', '-2', 'file0.txt'])
 
1681
            '-r', '-2', 'file0.txt'])
1919
1682
 
1920
1683
        self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1921
1684
        self.assertEqual(len(out.splitlines()), 1)
1922
1685
 
1923
1686
        # regex
1924
1687
        out, err = self.run_bzr(['grep', '-l', 'HE.LO',
1925
 
                                 '-r', '-2', 'file0.txt'])
 
1688
            '-r', '-2', 'file0.txt'])
1926
1689
 
1927
1690
        self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1928
1691
        self.assertEqual(len(out.splitlines()), 1)
1929
1692
 
1930
1693
        # fixed-string
1931
1694
        out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
1932
 
                                 '-l', 'HELLO'])
 
1695
            '-l', 'HELLO'])
1933
1696
 
1934
1697
        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1935
1698
        self.assertEqual(len(out.splitlines()), 1)
1936
1699
 
1937
1700
        # regex
1938
1701
        out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
1939
 
                                 '-l', '.ELLO'])
 
1702
            '-l', '.ELLO'])
1940
1703
 
1941
1704
        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1942
1705
        self.assertEqual(len(out.splitlines()), 1)
1961
1724
        out, err = self.run_bzr(['grep', '--files-without-match', 'HELLO'])
1962
1725
 
1963
1726
        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1964
 
        self.assertContainsRe(out, "^dir0/file01.txt$",
1965
 
                              flags=TestGrep._reflags)
 
1727
        self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
1966
1728
        self.assertEqual(len(out.splitlines()), 2)
1967
1729
 
1968
1730
        # regex
1969
1731
        out, err = self.run_bzr(['grep', '--files-without-match', 'HE.LO'])
1970
1732
 
1971
1733
        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1972
 
        self.assertContainsRe(out, "^dir0/file01.txt$",
1973
 
                              flags=TestGrep._reflags)
 
1734
        self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
1974
1735
        self.assertEqual(len(out.splitlines()), 2)
1975
1736
 
1976
1737
        # fixed-string
1977
1738
        out, err = self.run_bzr(['grep', '-L', 'HELLO'])
1978
1739
 
1979
1740
        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1980
 
        self.assertContainsRe(out, "^dir0/file01.txt$",
1981
 
                              flags=TestGrep._reflags)
 
1741
        self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
1982
1742
        self.assertEqual(len(out.splitlines()), 2)
1983
1743
 
1984
1744
        # regex
1985
1745
        out, err = self.run_bzr(['grep', '-L', 'HE.LO'])
1986
1746
 
1987
1747
        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1988
 
        self.assertContainsRe(out, "^dir0/file01.txt$",
1989
 
                              flags=TestGrep._reflags)
 
1748
        self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
1990
1749
        self.assertEqual(len(out.splitlines()), 2)
1991
1750
 
1992
1751
        # fixed-string
1993
1752
        out, err = self.run_bzr(['grep', '-L', 'HELLO', 'dir0', 'file1.txt'])
1994
1753
 
1995
1754
        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1996
 
        self.assertContainsRe(out, "^dir0/file01.txt$",
1997
 
                              flags=TestGrep._reflags)
 
1755
        self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
1998
1756
        self.assertEqual(len(out.splitlines()), 2)
1999
1757
 
2000
1758
        # regex
2001
1759
        out, err = self.run_bzr(['grep', '-L', '.ELLO', 'dir0', 'file1.txt'])
2002
1760
 
2003
1761
        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
2004
 
        self.assertContainsRe(out, "^dir0/file01.txt$",
2005
 
                              flags=TestGrep._reflags)
 
1762
        self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
2006
1763
        self.assertEqual(len(out.splitlines()), 2)
2007
1764
 
2008
1765
        # fixed-string
2047
1804
 
2048
1805
        # fixed-string
2049
1806
        out, err = self.run_bzr(['grep', '-r', '-1', '--files-without-match',
2050
 
                                 'HELLO'])
 
1807
            'HELLO'])
2051
1808
 
2052
1809
        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2053
 
        self.assertContainsRe(out, "^dir0/file01.txt~7$",
2054
 
                              flags=TestGrep._reflags)
 
1810
        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
2055
1811
        self.assertEqual(len(out.splitlines()), 2)
2056
1812
 
2057
1813
        # regex
2058
1814
        out, err = self.run_bzr(['grep', '-r', '-1', '--files-without-match',
2059
 
                                 'H.LLO'])
 
1815
            'H.LLO'])
2060
1816
 
2061
1817
        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2062
 
        self.assertContainsRe(out, "^dir0/file01.txt~7$",
2063
 
                              flags=TestGrep._reflags)
 
1818
        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
2064
1819
        self.assertEqual(len(out.splitlines()), 2)
2065
1820
 
2066
1821
        # fixed-string
2067
1822
        out, err = self.run_bzr(['grep', '-r', '6..7', '--files-without-match',
2068
 
                                 'HELLO'])
 
1823
            'HELLO'])
2069
1824
 
2070
1825
        self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
2071
 
        self.assertContainsRe(out, "^dir0/file00.txt~6$",
2072
 
                              flags=TestGrep._reflags)
2073
 
        self.assertContainsRe(out, "^dir0/file01.txt~6$",
2074
 
                              flags=TestGrep._reflags)
 
1826
        self.assertContainsRe(out, "^dir0/file00.txt~6$", flags=TestGrep._reflags)
 
1827
        self.assertContainsRe(out, "^dir0/file01.txt~6$", flags=TestGrep._reflags)
2075
1828
        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2076
 
        self.assertContainsRe(out, "^dir0/file01.txt~7$",
2077
 
                              flags=TestGrep._reflags)
 
1829
        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
2078
1830
        self.assertEqual(len(out.splitlines()), 5)
2079
1831
 
2080
1832
        # regex
2081
1833
        out, err = self.run_bzr(['grep', '-r', '6..7', '--files-without-match',
2082
 
                                 'H.LLO'])
 
1834
            'H.LLO'])
2083
1835
 
2084
1836
        self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
2085
 
        self.assertContainsRe(out, "^dir0/file00.txt~6$",
2086
 
                              flags=TestGrep._reflags)
2087
 
        self.assertContainsRe(out, "^dir0/file01.txt~6$",
2088
 
                              flags=TestGrep._reflags)
 
1837
        self.assertContainsRe(out, "^dir0/file00.txt~6$", flags=TestGrep._reflags)
 
1838
        self.assertContainsRe(out, "^dir0/file01.txt~6$", flags=TestGrep._reflags)
2089
1839
        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2090
 
        self.assertContainsRe(out, "^dir0/file01.txt~7$",
2091
 
                              flags=TestGrep._reflags)
 
1840
        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
2092
1841
        self.assertEqual(len(out.splitlines()), 5)
2093
1842
 
2094
1843
        # fixed-string
2095
1844
        out, err = self.run_bzr(['grep', '-r', '-1', '-L', 'HELLO'])
2096
1845
 
2097
1846
        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2098
 
        self.assertContainsRe(out, "^dir0/file01.txt~7$",
2099
 
                              flags=TestGrep._reflags)
 
1847
        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
2100
1848
        self.assertEqual(len(out.splitlines()), 2)
2101
1849
 
2102
1850
        # regex
2103
1851
        out, err = self.run_bzr(['grep', '-r', '-1', '-L', 'H.LLO'])
2104
1852
 
2105
1853
        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2106
 
        self.assertContainsRe(out, "^dir0/file01.txt~7$",
2107
 
                              flags=TestGrep._reflags)
 
1854
        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
2108
1855
        self.assertEqual(len(out.splitlines()), 2)
2109
1856
 
2110
1857
        # fixed-string
2111
1858
        out, err = self.run_bzr(['grep', '-L', 'HELLO', '-r', '-1',
2112
 
                                 'dir0', 'file1.txt'])
 
1859
            'dir0', 'file1.txt'])
2113
1860
 
2114
1861
        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2115
 
        self.assertContainsRe(out, "^dir0/file01.txt~7$",
2116
 
                              flags=TestGrep._reflags)
 
1862
        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
2117
1863
        self.assertEqual(len(out.splitlines()), 2)
2118
1864
 
2119
1865
        # regex
2120
1866
        out, err = self.run_bzr(['grep', '-L', 'H.LLO', '-r', '-1',
2121
 
                                 'dir0', 'file1.txt'])
 
1867
            'dir0', 'file1.txt'])
2122
1868
 
2123
1869
        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2124
 
        self.assertContainsRe(out, "^dir0/file01.txt~7$",
2125
 
                              flags=TestGrep._reflags)
 
1870
        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
2126
1871
        self.assertEqual(len(out.splitlines()), 2)
2127
1872
 
2128
1873
        # fixed-string
2129
1874
        out, err = self.run_bzr(['grep', '-L', 'HELLO',
2130
 
                                 '-r', '-2', 'file1.txt'])
 
1875
            '-r', '-2', 'file1.txt'])
2131
1876
 
2132
1877
        self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
2133
1878
        self.assertEqual(len(out.splitlines()), 1)
2134
1879
 
2135
1880
        # regex
2136
1881
        out, err = self.run_bzr(['grep', '-L', 'HE.LO',
2137
 
                                 '-r', '-2', 'file1.txt'])
 
1882
            '-r', '-2', 'file1.txt'])
2138
1883
 
2139
1884
        self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
2140
1885
        self.assertEqual(len(out.splitlines()), 1)
2141
1886
 
2142
1887
        # fixed-string
2143
1888
        out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
2144
 
                                 '-L', 'HELLO'])
 
1889
            '-L', 'HELLO'])
2145
1890
 
2146
1891
        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2147
1892
        self.assertEqual(len(out.splitlines()), 1)
2148
1893
 
2149
1894
        # regex
2150
1895
        out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
2151
 
                                 '-L', '.ELLO'])
 
1896
            '-L', '.ELLO'])
2152
1897
 
2153
1898
        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
2154
1899
        self.assertEqual(len(out.splitlines()), 1)
2166
1911
        os.chdir(wd1)
2167
1912
 
2168
1913
        out, err = self.run_bzr(['grep', 'line1'], 3)
2169
 
        self.assertContainsRe(
2170
 
            err, "Cannot search working tree", flags=TestGrep._reflags)
 
1914
        self.assertContainsRe(err, "Cannot search working tree", flags=TestGrep._reflags)
2171
1915
        self.assertEqual(out, '')
2172
1916
 
2173
1917
        out, err = self.run_bzr(['grep', '-r', '1', 'line1'])
2174
 
        self.assertContainsRe(out, "file0.txt~1:line1",
2175
 
                              flags=TestGrep._reflags)
2176
 
        self.assertEqual(len(out.splitlines()), 2)  # finds line1 and line10
 
1918
        self.assertContainsRe(out, "file0.txt~1:line1", flags=TestGrep._reflags)
 
1919
        self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
2177
1920
 
2178
1921
 
2179
1922
class TestNonAscii(GrepTestBase):
2188
1931
        self.build_tree(contents)
2189
1932
        tree.add(contents)
2190
1933
        tree.commit("Initial commit")
2191
 
        as_utf8 = u"\u1234"
 
1934
        as_utf8 = u"\u1234".encode("UTF-8")
2192
1935
 
2193
1936
        # GZ 2010-06-07: Note we can't actually grep for \u1234 as the pattern
2194
1937
        #                is mangled according to the user encoding.
2195
 
        streams = self.run_bzr_raw(["grep", "--files-with-matches",
2196
 
                                    u"contents"], encoding="UTF-8")
2197
 
        as_utf8 = as_utf8.encode("UTF-8")
2198
 
        self.assertEqual(streams, (as_utf8 + b"\n", b""))
 
1938
        streams = self.run_bzr(["grep", "--files-with-matches",
 
1939
            u"contents"], encoding="UTF-8")
 
1940
        self.assertEqual(streams, (as_utf8 + "\n", ""))
2199
1941
 
2200
 
        streams = self.run_bzr_raw(["grep", "-r", "1", "--files-with-matches",
2201
 
                                    u"contents"], encoding="UTF-8")
2202
 
        self.assertEqual(streams, (as_utf8 + b"~1\n", b""))
 
1942
        streams = self.run_bzr(["grep", "-r", "1", "--files-with-matches",
 
1943
            u"contents"], encoding="UTF-8")
 
1944
        self.assertEqual(streams, (as_utf8 + "~1\n", ""))
2203
1945
 
2204
1946
        fileencoding = osutils.get_user_encoding()
2205
1947
        as_mangled = as_utf8.decode(fileencoding, "replace").encode("UTF-8")
2206
1948
 
2207
 
        streams = self.run_bzr_raw(["grep", "-n",
2208
 
                                    u"contents"], encoding="UTF-8")
2209
 
        self.assertEqual(streams, (b"%s:1:contents of %s\n" %
2210
 
                                   (as_utf8, as_mangled), b""))
 
1949
        streams = self.run_bzr(["grep", "-n",
 
1950
            u"contents"], encoding="UTF-8")
 
1951
        self.assertEqual(streams, ("%s:1:contents of %s\n" %
 
1952
            (as_utf8, as_mangled), ""))
2211
1953
 
2212
 
        streams = self.run_bzr_raw(["grep", "-n", "-r", "1",
2213
 
                                    u"contents"], encoding="UTF-8")
2214
 
        self.assertEqual(streams, (b"%s~1:1:contents of %s\n" %
2215
 
                                   (as_utf8, as_mangled), b""))
 
1954
        streams = self.run_bzr(["grep", "-n", "-r", "1",
 
1955
            u"contents"], encoding="UTF-8")
 
1956
        self.assertEqual(streams, ("%s~1:1:contents of %s\n" %
 
1957
            (as_utf8, as_mangled), ""))
2216
1958
 
2217
1959
 
2218
1960
class TestColorGrep(GrepTestBase):
2219
1961
    """Tests for the --color option."""
2220
1962
 
 
1963
    # GZ 2010-06-05: Does this really require the feature? Nothing prints.
 
1964
    _test_needs_features = [ColorFeature]
 
1965
 
2221
1966
    _rev_sep = color_string('~', fg=FG.BOLD_YELLOW)
2222
1967
    _sep = color_string(':', fg=FG.BOLD_CYAN)
2223
1968
 
2226
1971
        """
2227
1972
        out, err = self.run_bzr(['grep', '--color', 'foo', 'bar'], 3)
2228
1973
        self.assertEqual(out, '')
2229
 
        self.assertContainsRe(
2230
 
            err, 'Valid values for --color are', flags=TestGrep._reflags)
 
1974
        self.assertContainsRe(err, 'Valid values for --color are', flags=TestGrep._reflags)
2231
1975
 
2232
1976
    def test_ver_matching_files(self):
2233
1977
        """(versioned) Search for matches or no matches only"""
2240
1984
        # GZ 2010-06-05: Maybe modify the working tree here
2241
1985
 
2242
1986
        streams = self.run_bzr(["grep", "--color", "always", "-r", "1",
2243
 
                                "--files-with-matches", "aaa"])
 
1987
            "--files-with-matches", "aaa"])
2244
1988
        self.assertEqual(streams, ("".join([
2245
1989
            FG.MAGENTA, "d/aaa", self._rev_sep, "1", "\n"
2246
1990
            ]), ""))
2247
1991
 
2248
1992
        streams = self.run_bzr(["grep", "--color", "always", "-r", "1",
2249
 
                                "--files-without-match", "aaa"])
 
1993
            "--files-without-match", "aaa"])
2250
1994
        self.assertEqual(streams, ("".join([
2251
1995
            FG.MAGENTA, "bbb", self._rev_sep, "1", "\n"
2252
1996
            ]), ""))
2262
2006
        # GZ 2010-06-05: Maybe modify the working tree here
2263
2007
 
2264
2008
        streams = self.run_bzr(["grep", "--color", "always",
2265
 
                                "--files-with-matches", "aaa"])
 
2009
            "--files-with-matches", "aaa"])
2266
2010
        self.assertEqual(streams, ("".join([
2267
2011
            FG.MAGENTA, "d/aaa", FG.NONE, "\n"
2268
2012
            ]), ""))
2269
2013
 
2270
2014
        streams = self.run_bzr(["grep", "--color", "always",
2271
 
                                "--files-without-match", "aaa"])
 
2015
            "--files-without-match", "aaa"])
2272
2016
        self.assertEqual(streams, ("".join([
2273
2017
            FG.MAGENTA, "bbb", FG.NONE, "\n"
2274
2018
            ]), ""))
2285
2029
        # prepare colored result
2286
2030
        foo = color_string('foo', fg=FG.BOLD_RED)
2287
2031
        res = (FG.MAGENTA + 'file0.txt'
2288
 
               + self._rev_sep + '1' + self._sep
2289
 
               + foo + ' is ' + foo + 'bar1' + '\n')
 
2032
            + self._rev_sep + '1' + self._sep
 
2033
            + foo + ' is ' + foo + 'bar1' + '\n')
2290
2034
        txt_res = 'file0.txt~1:foo is foobar1\n'
2291
2035
 
2292
2036
        nres = (FG.MAGENTA + 'file0.txt'
2293
 
                + self._rev_sep + '1' + self._sep + '1' + self._sep
2294
 
                + foo + ' is ' + foo + 'bar1' + '\n')
 
2037
            + self._rev_sep + '1' + self._sep + '1' + self._sep
 
2038
            + foo + ' is ' + foo + 'bar1' + '\n')
2295
2039
 
2296
2040
        out, err = self.run_bzr(['grep', '--color',
2297
 
                                 'always', '-r', '1', 'foo'])
 
2041
            'always', '-r', '1', 'foo'])
2298
2042
        self.assertEqual(out, res)
2299
2043
        self.assertEqual(len(out.splitlines()), 1)
2300
2044
 
2301
2045
        # auto should produce plain text result
2302
2046
        # as stdout is redireched here.
2303
2047
        out, err = self.run_bzr(['grep', '--color',
2304
 
                                 'auto', '-r', '1', 'foo'])
 
2048
            'auto', '-r', '1', 'foo'])
2305
2049
        self.assertEqual(out, txt_res)
2306
2050
        self.assertEqual(len(out.splitlines()), 1)
2307
2051
 
2308
2052
        out, err = self.run_bzr(['grep', '-i', '--color',
2309
 
                                 'always', '-r', '1', 'FOO'])
 
2053
            'always', '-r', '1', 'FOO'])
2310
2054
        self.assertEqual(out, res)
2311
2055
        self.assertEqual(len(out.splitlines()), 1)
2312
2056
 
2313
2057
        out, err = self.run_bzr(['grep', '--color',
2314
 
                                 'always', '-r', '1', 'f.o'])
 
2058
            'always', '-r', '1', 'f.o'])
2315
2059
        self.assertEqual(out, res)
2316
2060
        self.assertEqual(len(out.splitlines()), 1)
2317
2061
 
2318
2062
        out, err = self.run_bzr(['grep', '-i', '--color',
2319
 
                                 'always', '-r', '1', 'F.O'])
 
2063
            'always', '-r', '1', 'F.O'])
2320
2064
        self.assertEqual(out, res)
2321
2065
        self.assertEqual(len(out.splitlines()), 1)
2322
2066
 
2323
2067
        out, err = self.run_bzr(['grep', '-n', '--color',
2324
 
                                 'always', '-r', '1', 'foo'])
 
2068
            'always', '-r', '1', 'foo'])
2325
2069
        self.assertEqual(out, nres)
2326
2070
        self.assertEqual(len(out.splitlines()), 1)
2327
2071
 
2328
2072
        out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2329
 
                                 'always', '-r', '1', 'FOO'])
 
2073
            'always', '-r', '1', 'FOO'])
2330
2074
        self.assertEqual(out, nres)
2331
2075
        self.assertEqual(len(out.splitlines()), 1)
2332
2076
 
2333
2077
        out, err = self.run_bzr(['grep', '-n', '--color',
2334
 
                                 'always', '-r', '1', 'f.o'])
 
2078
            'always', '-r', '1', 'f.o'])
2335
2079
        self.assertEqual(out, nres)
2336
2080
        self.assertEqual(len(out.splitlines()), 1)
2337
2081
 
2338
2082
        out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2339
 
                                 'always', '-r', '1', 'F.O'])
 
2083
            'always', '-r', '1', 'F.O'])
2340
2084
        self.assertEqual(out, nres)
2341
2085
        self.assertEqual(len(out.splitlines()), 1)
2342
2086
 
2352
2096
        # prepare colored result
2353
2097
        foo = color_string('foo', fg=FG.BOLD_RED)
2354
2098
        res = (FG.MAGENTA + 'file0.txt'
2355
 
               + self._sep + foo + ' is ' + foo + 'bar1' + '\n')
 
2099
            + self._sep + foo + ' is ' + foo + 'bar1' + '\n')
2356
2100
 
2357
2101
        nres = (FG.MAGENTA + 'file0.txt'
2358
 
                + self._sep + '1' + self._sep
2359
 
                + foo + ' is ' + foo + 'bar1' + '\n')
2360
 
 
2361
 
        out, err = self.run_bzr(['grep', '--color',
2362
 
                                 'always', 'foo'])
2363
 
        self.assertEqual(out, res)
2364
 
        self.assertEqual(len(out.splitlines()), 1)
2365
 
 
2366
 
        out, err = self.run_bzr(['grep', '-i', '--color',
2367
 
                                 'always', 'FOO'])
2368
 
        self.assertEqual(out, res)
2369
 
        self.assertEqual(len(out.splitlines()), 1)
2370
 
 
2371
 
        out, err = self.run_bzr(['grep', '--color',
2372
 
                                 'always', 'f.o'])
2373
 
        self.assertEqual(out, res)
2374
 
        self.assertEqual(len(out.splitlines()), 1)
2375
 
 
2376
 
        out, err = self.run_bzr(['grep', '-i', '--color',
2377
 
                                 'always', 'F.O'])
2378
 
        self.assertEqual(out, res)
2379
 
        self.assertEqual(len(out.splitlines()), 1)
2380
 
 
2381
 
        out, err = self.run_bzr(['grep', '-n', '--color',
2382
 
                                 'always', 'foo'])
2383
 
        self.assertEqual(out, nres)
2384
 
        self.assertEqual(len(out.splitlines()), 1)
2385
 
 
2386
 
        out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2387
 
                                 'always', 'FOO'])
2388
 
        self.assertEqual(out, nres)
2389
 
        self.assertEqual(len(out.splitlines()), 1)
2390
 
 
2391
 
        out, err = self.run_bzr(['grep', '-n', '--color',
2392
 
                                 'always', 'f.o'])
2393
 
        self.assertEqual(out, nres)
2394
 
        self.assertEqual(len(out.splitlines()), 1)
2395
 
 
2396
 
        out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2397
 
                                 'always', 'F.O'])
 
2102
            + self._sep + '1' + self._sep
 
2103
            + foo + ' is ' + foo + 'bar1' + '\n')
 
2104
 
 
2105
        out, err = self.run_bzr(['grep', '--color',
 
2106
            'always', 'foo'])
 
2107
        self.assertEqual(out, res)
 
2108
        self.assertEqual(len(out.splitlines()), 1)
 
2109
 
 
2110
        out, err = self.run_bzr(['grep', '-i', '--color',
 
2111
            'always', 'FOO'])
 
2112
        self.assertEqual(out, res)
 
2113
        self.assertEqual(len(out.splitlines()), 1)
 
2114
 
 
2115
        out, err = self.run_bzr(['grep', '--color',
 
2116
            'always', 'f.o'])
 
2117
        self.assertEqual(out, res)
 
2118
        self.assertEqual(len(out.splitlines()), 1)
 
2119
 
 
2120
        out, err = self.run_bzr(['grep', '-i', '--color',
 
2121
            'always', 'F.O'])
 
2122
        self.assertEqual(out, res)
 
2123
        self.assertEqual(len(out.splitlines()), 1)
 
2124
 
 
2125
        out, err = self.run_bzr(['grep', '-n', '--color',
 
2126
            'always', 'foo'])
 
2127
        self.assertEqual(out, nres)
 
2128
        self.assertEqual(len(out.splitlines()), 1)
 
2129
 
 
2130
        out, err = self.run_bzr(['grep', '-n', '-i', '--color',
 
2131
            'always', 'FOO'])
 
2132
        self.assertEqual(out, nres)
 
2133
        self.assertEqual(len(out.splitlines()), 1)
 
2134
 
 
2135
        out, err = self.run_bzr(['grep', '-n', '--color',
 
2136
            'always', 'f.o'])
 
2137
        self.assertEqual(out, nres)
 
2138
        self.assertEqual(len(out.splitlines()), 1)
 
2139
 
 
2140
        out, err = self.run_bzr(['grep', '-n', '-i', '--color',
 
2141
            'always', 'F.O'])
2398
2142
        self.assertEqual(out, nres)
2399
2143
        self.assertEqual(len(out.splitlines()), 1)
2400
2144
 
2429
2173
        self.assertEqualDiff(subst_dates(out), '''\
2430
2174
=== revno:3 ===
2431
2175
  === modified file 'hello'
2432
 
    --- hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2433
 
    +++ hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
 
2176
    --- hello   YYYY-MM-DD HH:MM:SS +ZZZZ
 
2177
    +++ hello   YYYY-MM-DD HH:MM:SS +ZZZZ
2434
2178
    +hello world!
2435
2179
=== revno:1 ===
2436
2180
  === added file 'hello'
2437
 
    --- hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2438
 
    +++ hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
 
2181
    --- hello   YYYY-MM-DD HH:MM:SS +ZZZZ
 
2182
    +++ hello   YYYY-MM-DD HH:MM:SS +ZZZZ
2439
2183
''')
2440
2184
 
2441
2185
    def test_grep_diff_revision(self):
2448
2192
        self.assertEqualDiff(subst_dates(out), '''\
2449
2193
=== revno:3 ===
2450
2194
  === modified file 'hello'
2451
 
    --- hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2452
 
    +++ hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
 
2195
    --- hello   YYYY-MM-DD HH:MM:SS +ZZZZ
 
2196
    +++ hello   YYYY-MM-DD HH:MM:SS +ZZZZ
2453
2197
    +hello world!
2454
2198
''')
2455
2199
 
2456
2200
    def test_grep_diff_revision_range(self):
2457
2201
        """grep -p revision range."""
2458
2202
        tree = self.make_example_branch()
2459
 
        self.build_tree_contents([('hello', b'hello world!1\n')])  # rev 3
 
2203
        self.build_tree_contents([('hello', b'hello world!1\n')]) # rev 3
2460
2204
        tree.commit('rev3')
2461
 
        self.build_tree_contents([('blah', b'hello world!2\n')])  # rev 4
 
2205
        self.build_tree_contents([('blah', b'hello world!2\n')]) # rev 4
2462
2206
        tree.add('blah')
2463
2207
        tree.commit('rev4')
2464
 
        with open('hello', 'a') as f:
2465
 
            f.write('hello world!3\n')
2466
 
        # self.build_tree_contents([('hello', 'hello world!3\n')]) # rev 5
 
2208
        open('hello', 'a').write('hello world!3\n')
 
2209
        #self.build_tree_contents([('hello', 'hello world!3\n')]) # rev 5
2467
2210
        tree.commit('rev5')
2468
2211
        out, err = self.run_bzr(['grep', '-p', '-r', '2..5', 'hello'])
2469
2212
        self.assertEqual(err, '')
2470
2213
        self.assertEqualDiff(subst_dates(out), '''\
2471
2214
=== revno:5 ===
2472
2215
  === modified file 'hello'
2473
 
    --- hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2474
 
    +++ hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
 
2216
    --- hello   YYYY-MM-DD HH:MM:SS +ZZZZ
 
2217
    +++ hello   YYYY-MM-DD HH:MM:SS +ZZZZ
2475
2218
    +hello world!3
2476
2219
=== revno:4 ===
2477
2220
  === added file 'blah'
2478
2221
    +hello world!2
2479
2222
=== revno:3 ===
2480
2223
  === modified file 'hello'
2481
 
    --- hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2482
 
    +++ hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
 
2224
    --- hello   YYYY-MM-DD HH:MM:SS +ZZZZ
 
2225
    +++ hello   YYYY-MM-DD HH:MM:SS +ZZZZ
2483
2226
    +hello world!1
2484
2227
''')
2485
2228
 
2489
2232
        self.build_tree_contents([('hello', b'hello world!\n')])
2490
2233
        tree.commit('updated hello')
2491
2234
        out, err = self.run_bzr(['grep', '--diff', '-r', '3',
2492
 
                                 '--color', 'always', 'hello'])
 
2235
            '--color', 'always', 'hello'])
2493
2236
        self.assertEqual(err, '')
2494
2237
        revno = color_string('=== revno:3 ===', fg=FG.BOLD_BLUE) + '\n'
2495
 
        filename = color_string(
2496
 
            "  === modified file 'hello'", fg=FG.BOLD_MAGENTA) + '\n'
 
2238
        filename = color_string("  === modified file 'hello'", fg=FG.BOLD_MAGENTA) + '\n'
2497
2239
        redhello = color_string('hello', fg=FG.BOLD_RED)
2498
2240
        diffstr = '''\
2499
 
    --- hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
2500
 
    +++ hello\tYYYY-MM-DD HH:MM:SS +ZZZZ
 
2241
    --- hello   YYYY-MM-DD HH:MM:SS +ZZZZ
 
2242
    +++ hello   YYYY-MM-DD HH:MM:SS +ZZZZ
2501
2243
    +hello world!
2502
2244
'''
2503
2245
        diffstr = diffstr.replace('hello', redhello)
2508
2250
        out, err = self.run_bzr(['init'])
2509
2251
        out, err = self.run_bzr(['grep', '--diff', 'foo'], 3)
2510
2252
        self.assertEqual(out, '')
2511
 
        self.assertContainsRe(
2512
 
            err, "ERROR:.*revision.* does not exist in branch")
 
2253
        self.assertContainsRe(err, "ERROR:.*revision.* does not exist in branch")
 
2254