/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

  • Committer: Jelmer Vernooij
  • Date: 2018-11-17 00:47:52 UTC
  • mfrom: (7182 work)
  • mto: This revision was merged to the branch mainline in revision 7305.
  • Revision ID: jelmer@jelmer.uk-20181117004752-6ywampe5pfywlby4
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/plugins/grep/test_grep.py
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
 
36
37
class GrepTestBase(tests.TestCaseWithTransport):
37
38
    """Base class for testing grep.
38
39
 
39
40
    Provides support methods for creating directory and file revisions.
40
41
    """
41
 
    _reflags = re.MULTILINE|re.DOTALL
 
42
    _reflags = re.MULTILINE | re.DOTALL
42
43
 
43
44
    def _mk_file(self, path, line_prefix, total_lines, versioned):
44
 
        text=''
 
45
        text = ''
45
46
        for i in range(total_lines):
46
 
            text += line_prefix + str(i+1) + "\n"
 
47
            text += line_prefix + str(i + 1) + "\n"
47
48
 
48
49
        with open(path, 'w') as f:
49
50
            f.write(text)
91
92
 
92
93
        out, err = self.run_bzr(['grep', 'line1', 'file0.txt'])
93
94
        self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
94
 
        self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
 
95
        self.assertEqual(len(out.splitlines()), 2)  # finds line1 and line10
95
96
 
96
97
        out, err = self.run_bzr(['grep', 'line\\d+', 'file0.txt'])
97
98
        self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
116
117
        self._mk_versioned_file('file0.txt')
117
118
 
118
119
        out, err = self.run_bzr(['grep', '-r', '1', 'line1', 'file0.txt'])
119
 
        self.assertContainsRe(out, "file0.txt~1:line1", flags=TestGrep._reflags)
120
 
        self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
 
120
        self.assertContainsRe(out, "file0.txt~1:line1",
 
121
                              flags=TestGrep._reflags)
 
122
        self.assertEqual(len(out.splitlines()), 2)  # finds line1 and line10
121
123
 
122
124
        out, err = self.run_bzr(['grep', '-r', '1', 'line[0-9]$', 'file0.txt'])
123
 
        self.assertContainsRe(out, "file0.txt~1:line1", flags=TestGrep._reflags)
 
125
        self.assertContainsRe(out, "file0.txt~1:line1",
 
126
                              flags=TestGrep._reflags)
124
127
        self.assertEqual(len(out.splitlines()), 9)
125
128
 
126
129
        # finds all the lines
127
130
        out, err = self.run_bzr(['grep', '-r', '1', 'line[0-9]', 'file0.txt'])
128
 
        self.assertContainsRe(out, "file0.txt~1:line1", flags=TestGrep._reflags)
 
131
        self.assertContainsRe(out, "file0.txt~1:line1",
 
132
                              flags=TestGrep._reflags)
129
133
        self.assertEqual(len(out.splitlines()), 10)
130
134
 
131
135
    def test_wtree_basic_file(self):
149
153
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
150
154
        self.assertEqual(len(out.splitlines()), 0)
151
155
 
152
 
        out, err = self.run_bzr(['grep', '-r', 'last:1', '[A-Z]{3}', 'file0.txt'])
 
156
        out, err = self.run_bzr(
 
157
            ['grep', '-r', 'last:1', '[A-Z]{3}', 'file0.txt'])
153
158
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
154
159
        self.assertEqual(len(out.splitlines()), 0)
155
160
 
164
169
        self._mk_versioned_file('file0.cc')
165
170
 
166
171
        out, err = self.run_bzr(['grep', '-r', 'last:1',
167
 
            '--include', '*.aa', '--include', '*.bb', 'line1'])
 
172
                                 '--include', '*.aa', '--include', '*.bb', 'line1'])
168
173
        self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
169
174
        self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
170
175
        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
172
177
        self.assertEqual(len(out.splitlines()), 4)
173
178
 
174
179
        out, err = self.run_bzr(['grep', '-r', 'last:1',
175
 
            '--include', '*.aa', '--include', '*.bb', 'line1$'])
 
180
                                 '--include', '*.aa', '--include', '*.bb', 'line1$'])
176
181
        self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
177
182
        self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
178
183
        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
180
185
        self.assertEqual(len(out.splitlines()), 2)
181
186
 
182
187
        out, err = self.run_bzr(['grep', '-r', 'last:1',
183
 
            '-I', '*.aa', '-I', '*.bb', 'line1'])
 
188
                                 '-I', '*.aa', '-I', '*.bb', 'line1'])
184
189
        self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
185
190
        self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
186
191
        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
188
193
        self.assertEqual(len(out.splitlines()), 4)
189
194
 
190
195
        out, err = self.run_bzr(['grep', '-r', 'last:1',
191
 
            '-I', '*.aa', '-I', '*.bb', 'line1$'])
 
196
                                 '-I', '*.aa', '-I', '*.bb', 'line1$'])
192
197
        self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
193
198
        self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
194
199
        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
206
211
        self._mk_versioned_file('file0.cc')
207
212
 
208
213
        out, err = self.run_bzr(['grep', '--include', '*.aa',
209
 
            '--include', '*.bb', 'line1'])
 
214
                                 '--include', '*.bb', 'line1'])
210
215
        self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
211
216
        self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
212
217
        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
214
219
        self.assertEqual(len(out.splitlines()), 4)
215
220
 
216
221
        out, err = self.run_bzr(['grep', '--include', '*.aa',
217
 
            '--include', '*.bb', 'line1$'])
 
222
                                 '--include', '*.bb', 'line1$'])
218
223
        self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
219
224
        self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
220
225
        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
232
237
        self._mk_versioned_file('file0.cc')
233
238
 
234
239
        out, err = self.run_bzr(['grep', '-r', 'last:1',
235
 
            '--exclude', '*.cc', 'line1'])
236
 
        self.assertContainsRe(out, "file0.aa~.:line1$", flags=TestGrep._reflags)
237
 
        self.assertContainsRe(out, "file0.bb~.:line1$", flags=TestGrep._reflags)
238
 
        self.assertContainsRe(out, "file0.aa~.:line10", flags=TestGrep._reflags)
239
 
        self.assertContainsRe(out, "file0.bb~.:line10", flags=TestGrep._reflags)
 
240
                                 '--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)
240
249
        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
241
250
        # two lines each (line1, line10) from file0.aa and file0.bb
242
251
        self.assertEqual(len(out.splitlines()), 4)
243
252
 
244
253
        out, err = self.run_bzr(['grep', '-r', 'last:1',
245
 
            '--exclude', '*.cc', 'line1$'])
 
254
                                 '--exclude', '*.cc', 'line1$'])
246
255
        self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
247
256
        self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
248
257
        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
250
259
        self.assertEqual(len(out.splitlines()), 2)
251
260
 
252
261
        out, err = self.run_bzr(['grep', '-r', 'last:1',
253
 
            '-X', '*.cc', 'line1'])
 
262
                                 '-X', '*.cc', 'line1'])
254
263
        self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
255
264
        self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
256
265
        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
292
301
        self._mk_versioned_file('file2.txt', total_lines=2)
293
302
 
294
303
        out, err = self.run_bzr(['grep', '-r', 'last:1', 'line[1-2]$'])
295
 
        self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
296
 
        self.assertContainsRe(out, "file0.txt~.:line2", flags=TestGrep._reflags)
297
 
        self.assertContainsRe(out, "file1.txt~.:line1", flags=TestGrep._reflags)
298
 
        self.assertContainsRe(out, "file1.txt~.:line2", flags=TestGrep._reflags)
299
 
        self.assertContainsRe(out, "file2.txt~.:line1", flags=TestGrep._reflags)
300
 
        self.assertContainsRe(out, "file2.txt~.:line2", flags=TestGrep._reflags)
 
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)
301
316
        self.assertEqual(len(out.splitlines()), 6)
302
317
 
303
318
        out, err = self.run_bzr(['grep', '-r', 'last:1', 'line'])
304
 
        self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
305
 
        self.assertContainsRe(out, "file0.txt~.:line2", flags=TestGrep._reflags)
306
 
        self.assertContainsRe(out, "file1.txt~.:line1", flags=TestGrep._reflags)
307
 
        self.assertContainsRe(out, "file1.txt~.:line2", flags=TestGrep._reflags)
308
 
        self.assertContainsRe(out, "file2.txt~.:line1", flags=TestGrep._reflags)
309
 
        self.assertContainsRe(out, "file2.txt~.:line2", flags=TestGrep._reflags)
 
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)
310
331
        self.assertEqual(len(out.splitlines()), 6)
311
332
 
312
333
    def test_multiple_wtree_files(self):
323
344
        self._update_file('file2.txt', 'HELLO\n', checkin=False)
324
345
 
325
346
        out, err = self.run_bzr(['grep', 'HELLO',
326
 
            'file0.txt', 'file1.txt', 'file2.txt'])
 
347
                                 'file0.txt', 'file1.txt', 'file2.txt'])
327
348
 
328
349
        self.assertContainsRe(out, "file0.txt:HELLO", flags=TestGrep._reflags)
329
350
        self.assertContainsRe(out, "file1.txt:HELLO", flags=TestGrep._reflags)
331
352
        self.assertEqual(len(out.splitlines()), 3)
332
353
 
333
354
        out, err = self.run_bzr(['grep', 'HELLO', '-r', 'last:1',
334
 
            'file0.txt', 'file1.txt', 'file2.txt'])
 
355
                                 'file0.txt', 'file1.txt', 'file2.txt'])
335
356
 
336
357
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
337
 
        self.assertContainsRe(out, "file1.txt~.:HELLO", flags=TestGrep._reflags)
 
358
        self.assertContainsRe(out, "file1.txt~.:HELLO",
 
359
                              flags=TestGrep._reflags)
338
360
        self.assertNotContainsRe(out, "file2.txt", flags=TestGrep._reflags)
339
361
        self.assertEqual(len(out.splitlines()), 1)
340
362
 
341
363
        out, err = self.run_bzr(['grep', 'HE..O',
342
 
            'file0.txt', 'file1.txt', 'file2.txt'])
 
364
                                 'file0.txt', 'file1.txt', 'file2.txt'])
343
365
 
344
366
        self.assertContainsRe(out, "file0.txt:HELLO", flags=TestGrep._reflags)
345
367
        self.assertContainsRe(out, "file1.txt:HELLO", flags=TestGrep._reflags)
347
369
        self.assertEqual(len(out.splitlines()), 3)
348
370
 
349
371
        out, err = self.run_bzr(['grep', 'HE..O', '-r', 'last:1',
350
 
            'file0.txt', 'file1.txt', 'file2.txt'])
 
372
                                 'file0.txt', 'file1.txt', 'file2.txt'])
351
373
 
352
374
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
353
 
        self.assertContainsRe(out, "file1.txt~.:HELLO", flags=TestGrep._reflags)
 
375
        self.assertContainsRe(out, "file1.txt~.:HELLO",
 
376
                              flags=TestGrep._reflags)
354
377
        self.assertNotContainsRe(out, "file2.txt", flags=TestGrep._reflags)
355
378
        self.assertEqual(len(out.splitlines()), 1)
356
379
 
362
385
        os.chdir(wd)
363
386
        self._mk_versioned_file('file0.txt', total_lines=3)
364
387
 
365
 
        nref = ud.normalize(u'NFC', u"file0.txt~1:line1\0file0.txt~1:line2\0file0.txt~1:line3\0")
 
388
        nref = ud.normalize(
 
389
            u'NFC', u"file0.txt~1:line1\0file0.txt~1:line2\0file0.txt~1:line3\0")
366
390
 
367
 
        out, err = self.run_bzr(['grep', '-r', 'last:1', '--null', 'line[1-3]'])
 
391
        out, err = self.run_bzr(
 
392
            ['grep', '-r', 'last:1', '--null', 'line[1-3]'])
368
393
        if not PY3:
369
394
            out = out.decode('utf-8', 'ignore')
370
395
        nout = ud.normalize(u'NFC', out)
394
419
        self._mk_versioned_file('file0.txt', total_lines=3)
395
420
 
396
421
        out, err = self.run_bzr(['grep', '--null', 'line[1-3]'])
397
 
        self.assertEqual(out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
 
422
        self.assertEqual(
 
423
            out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
398
424
        self.assertEqual(len(out.splitlines()), 1)
399
425
 
400
426
        out, err = self.run_bzr(['grep', '-Z', 'line[1-3]'])
401
 
        self.assertEqual(out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
 
427
        self.assertEqual(
 
428
            out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
402
429
        self.assertEqual(len(out.splitlines()), 1)
403
430
 
404
431
        out, err = self.run_bzr(['grep', '-Z', 'line'])
405
 
        self.assertEqual(out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
 
432
        self.assertEqual(
 
433
            out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
406
434
        self.assertEqual(len(out.splitlines()), 1)
407
435
 
408
436
    def test_versioned_file_in_dir_no_recursive(self):
414
442
        self._mk_versioned_dir('dir0')
415
443
        self._mk_versioned_file('dir0/file0.txt')
416
444
 
417
 
        out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1'])
418
 
        self.assertNotContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
 
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)
419
449
        self.assertEqual(len(out.splitlines()), 0)
420
450
 
421
 
        out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1$'])
422
 
        self.assertNotContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
 
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)
423
455
        self.assertEqual(len(out.splitlines()), 0)
424
456
 
425
457
    def test_wtree_file_in_dir_no_recursive(self):
432
464
        self._mk_versioned_file('dir0/file0.txt')
433
465
 
434
466
        out, err = self.run_bzr(['grep', '--no-recursive', 'line1'])
435
 
        self.assertNotContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
 
467
        self.assertNotContainsRe(
 
468
            out, "file0.txt:line1", flags=TestGrep._reflags)
436
469
        self.assertEqual(len(out.splitlines()), 0)
437
470
 
438
471
        out, err = self.run_bzr(['grep', '--no-recursive', 'lin.1'])
439
 
        self.assertNotContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
 
472
        self.assertNotContainsRe(
 
473
            out, "file0.txt:line1", flags=TestGrep._reflags)
440
474
        self.assertEqual(len(out.splitlines()), 0)
441
475
 
442
476
    def test_versioned_file_in_dir_recurse(self):
449
483
        self._mk_versioned_file('dir0/file0.txt')
450
484
 
451
485
        out, err = self.run_bzr(['grep', '-r', '-1', '.i.e1'])
452
 
        self.assertContainsRe(out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
 
486
        self.assertContainsRe(
 
487
            out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
453
488
        # find line1 and line10
454
489
        self.assertEqual(len(out.splitlines()), 2)
455
490
 
456
491
        out, err = self.run_bzr(['grep', '-r', '-1', 'line1'])
457
 
        self.assertContainsRe(out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
 
492
        self.assertContainsRe(
 
493
            out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
458
494
        # find line1 and line10
459
495
        self.assertEqual(len(out.splitlines()), 2)
460
496
 
468
504
        self._mk_versioned_file('dir0/file0.txt')
469
505
 
470
506
        out, err = self.run_bzr(['grep', 'line1'])
471
 
        self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
 
507
        self.assertContainsRe(out, "^dir0/file0.txt:line1",
 
508
                              flags=TestGrep._reflags)
472
509
        # find line1 and line10
473
510
        self.assertEqual(len(out.splitlines()), 2)
474
511
 
475
512
        out, err = self.run_bzr(['grep', 'lin.1'])
476
 
        self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
 
513
        self.assertContainsRe(out, "^dir0/file0.txt:line1",
 
514
                              flags=TestGrep._reflags)
477
515
        # find line1 and line10
478
516
        self.assertEqual(len(out.splitlines()), 2)
479
517
 
488
526
        os.chdir('dir0')
489
527
 
490
528
        out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
491
 
        self.assertContainsRe(out, "^file0.txt~.:line1", flags=TestGrep._reflags)
 
529
        self.assertContainsRe(out, "^file0.txt~.:line1",
 
530
                              flags=TestGrep._reflags)
492
531
        # finds line1 and line10
493
532
        self.assertEqual(len(out.splitlines()), 2)
494
533
 
495
534
        out, err = self.run_bzr(['grep', '-r', 'last:1', '.i.e1'])
496
 
        self.assertContainsRe(out, "^file0.txt~.:line1", flags=TestGrep._reflags)
 
535
        self.assertContainsRe(out, "^file0.txt~.:line1",
 
536
                              flags=TestGrep._reflags)
497
537
        # finds line1 and line10
498
538
        self.assertEqual(len(out.splitlines()), 2)
499
539
 
511
551
        os.chdir('dir0')
512
552
 
513
553
        out, err = self.run_bzr(['grep', '-r', 'last:1',
514
 
            '--include', '*.aa', 'line1'])
515
 
        self.assertContainsRe(out, "^file1.aa~5:line1$", flags=TestGrep._reflags)
516
 
        self.assertContainsRe(out, "^file1.aa~5:line10$", flags=TestGrep._reflags)
 
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)
517
559
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
518
560
        # finds line1 and line10
519
561
        self.assertEqual(len(out.splitlines()), 2)
520
562
 
521
563
        out, err = self.run_bzr(['grep', '-r', 'last:2..last:1',
522
 
            '--include', '*.aa', 'line1'])
523
 
        self.assertContainsRe(out, "^file1.aa~4:line1$", flags=TestGrep._reflags)
524
 
        self.assertContainsRe(out, "^file1.aa~4:line10$", flags=TestGrep._reflags)
525
 
        self.assertContainsRe(out, "^file1.aa~5:line1$", flags=TestGrep._reflags)
526
 
        self.assertContainsRe(out, "^file1.aa~5:line10$", flags=TestGrep._reflags)
 
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)
527
573
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
528
574
        # finds line1 and line10 over two revisions
529
575
        self.assertEqual(len(out.splitlines()), 4)
530
576
 
531
577
        out, err = self.run_bzr(['grep', '-r', 'last:1',
532
 
            '--include', '*.aa', 'lin.1'])
533
 
        self.assertContainsRe(out, "^file1.aa~5:line1$", flags=TestGrep._reflags)
534
 
        self.assertContainsRe(out, "^file1.aa~5:line10$", flags=TestGrep._reflags)
 
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)
535
583
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
536
584
        # finds line1 and line10
537
585
        self.assertEqual(len(out.splitlines()), 2)
538
586
 
539
587
        out, err = self.run_bzr(['grep', '-r', 'last:3..last:1',
540
 
            '--include', '*.aa', 'lin.1'])
541
 
        self.assertContainsRe(out, "^file1.aa~3:line1$", flags=TestGrep._reflags)
542
 
        self.assertContainsRe(out, "^file1.aa~4:line1$", flags=TestGrep._reflags)
543
 
        self.assertContainsRe(out, "^file1.aa~5:line1$", flags=TestGrep._reflags)
544
 
        self.assertContainsRe(out, "^file1.aa~3:line10$", flags=TestGrep._reflags)
545
 
        self.assertContainsRe(out, "^file1.aa~4:line10$", flags=TestGrep._reflags)
546
 
        self.assertContainsRe(out, "^file1.aa~5:line10$", flags=TestGrep._reflags)
 
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)
547
601
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
548
602
        # finds line1 and line10 over 3 revisions
549
603
        self.assertEqual(len(out.splitlines()), 6)
560
614
        os.chdir('dir0')
561
615
 
562
616
        out, err = self.run_bzr(['grep', '-r', 'last:1',
563
 
            '--exclude', '*.txt', 'line1'])
564
 
        self.assertContainsRe(out, "^file1.aa~.:line1", flags=TestGrep._reflags)
 
617
                                 '--exclude', '*.txt', 'line1'])
 
618
        self.assertContainsRe(out, "^file1.aa~.:line1",
 
619
                              flags=TestGrep._reflags)
565
620
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
566
621
        # finds line1 and line10
567
622
        self.assertEqual(len(out.splitlines()), 2)
568
623
 
569
624
        out, err = self.run_bzr(['grep', '-r', 'last:1',
570
 
            '--exclude', '*.txt', 'l[a-z]ne1'])
571
 
        self.assertContainsRe(out, "^file1.aa~.:line1", flags=TestGrep._reflags)
 
625
                                 '--exclude', '*.txt', 'l[a-z]ne1'])
 
626
        self.assertContainsRe(out, "^file1.aa~.:line1",
 
627
                              flags=TestGrep._reflags)
572
628
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
573
629
        # finds line1 and line10
574
630
        self.assertEqual(len(out.splitlines()), 2)
628
684
 
629
685
        out, err = self.run_bzr(['grep', '--exclude', '*.txt', 'li.e1'])
630
686
        self.assertContainsRe(out, "^file1.aa:line1$", flags=TestGrep._reflags)
631
 
        self.assertContainsRe(out, "^file1.aa:line10$", flags=TestGrep._reflags)
 
687
        self.assertContainsRe(out, "^file1.aa:line10$",
 
688
                              flags=TestGrep._reflags)
632
689
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
633
690
        # finds line1 and line10
634
691
        self.assertEqual(len(out.splitlines()), 2)
635
692
 
636
693
        out, err = self.run_bzr(['grep', '--exclude', '*.txt', 'line1'])
637
694
        self.assertContainsRe(out, "^file1.aa:line1$", flags=TestGrep._reflags)
638
 
        self.assertContainsRe(out, "^file1.aa:line10$", flags=TestGrep._reflags)
 
695
        self.assertContainsRe(out, "^file1.aa:line10$",
 
696
                              flags=TestGrep._reflags)
639
697
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
640
698
        # finds line1 and line10
641
699
        self.assertEqual(len(out.splitlines()), 2)
657
715
        self._mk_versioned_file('dir2/file2.cc')
658
716
 
659
717
        out, err = self.run_bzr(['grep', '-r', 'last:1',
660
 
            '--include', '*.aa', '--include', '*.bb', 'l..e1'])
661
 
        self.assertContainsRe(out, "^dir0/file0.aa~.:line1$", flags=TestGrep._reflags)
662
 
        self.assertContainsRe(out, "^dir1/file1.bb~.:line1$", flags=TestGrep._reflags)
663
 
        self.assertContainsRe(out, "^dir0/file0.aa~.:line10$", flags=TestGrep._reflags)
664
 
        self.assertContainsRe(out, "^dir1/file1.bb~.:line10$", flags=TestGrep._reflags)
 
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)
665
727
        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
666
728
        # finds line1 and line10
667
729
        self.assertEqual(len(out.splitlines()), 4)
668
730
 
669
731
        out, err = self.run_bzr(['grep', '-r', 'last:1',
670
 
            '--include', '*.aa', '--include', '*.bb', 'line1'])
671
 
        self.assertContainsRe(out, "^dir0/file0.aa~.:line1$", flags=TestGrep._reflags)
672
 
        self.assertContainsRe(out, "^dir1/file1.bb~.:line1$", flags=TestGrep._reflags)
673
 
        self.assertContainsRe(out, "^dir0/file0.aa~.:line10$", flags=TestGrep._reflags)
674
 
        self.assertContainsRe(out, "^dir1/file1.bb~.:line10$", flags=TestGrep._reflags)
 
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)
675
741
        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
676
742
        # finds line1 and line10
677
743
        self.assertEqual(len(out.splitlines()), 4)
693
759
        self._mk_versioned_file('dir2/file2.cc')
694
760
 
695
761
        out, err = self.run_bzr(['grep', '--include', '*.aa',
696
 
            '--include', '*.bb', 'l.n.1'])
697
 
        self.assertContainsRe(out, "^dir0/file0.aa:line1$", flags=TestGrep._reflags)
698
 
        self.assertContainsRe(out, "^dir1/file1.bb:line1$", flags=TestGrep._reflags)
699
 
        self.assertContainsRe(out, "^dir0/file0.aa:line10$", flags=TestGrep._reflags)
700
 
        self.assertContainsRe(out, "^dir1/file1.bb:line10$", flags=TestGrep._reflags)
 
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)
701
771
        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
702
772
        # finds line1 and line10
703
773
        self.assertEqual(len(out.splitlines()), 4)
704
774
 
705
775
        out, err = self.run_bzr(['grep', '--include', '*.aa',
706
 
            '--include', '*.bb', 'line1'])
707
 
        self.assertContainsRe(out, "^dir0/file0.aa:line1$", flags=TestGrep._reflags)
708
 
        self.assertContainsRe(out, "^dir1/file1.bb:line1$", flags=TestGrep._reflags)
709
 
        self.assertContainsRe(out, "^dir0/file0.aa:line10$", flags=TestGrep._reflags)
710
 
        self.assertContainsRe(out, "^dir1/file1.bb:line10$", flags=TestGrep._reflags)
 
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)
711
785
        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
712
786
        # finds line1 and line10
713
787
        self.assertEqual(len(out.splitlines()), 4)
729
803
        self._mk_versioned_file('dir2/file2.cc')
730
804
 
731
805
        out, err = self.run_bzr(['grep', '-r', 'last:1',
732
 
            '--exclude', '*.cc', 'l..e1'])
733
 
        self.assertContainsRe(out, "^dir0/file0.aa~.:line1", flags=TestGrep._reflags)
734
 
        self.assertContainsRe(out, "^dir1/file1.bb~.:line1", flags=TestGrep._reflags)
 
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)
735
811
        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
736
812
 
737
813
        out, err = self.run_bzr(['grep', '-r', 'last:1',
738
 
            '--exclude', '*.cc', 'line1'])
739
 
        self.assertContainsRe(out, "^dir0/file0.aa~.:line1", flags=TestGrep._reflags)
740
 
        self.assertContainsRe(out, "^dir1/file1.bb~.:line1", flags=TestGrep._reflags)
 
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)
741
819
        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
742
820
 
743
821
    def test_wtree_exclude_from_outside_dir(self):
757
835
        self._mk_versioned_file('dir2/file2.cc')
758
836
 
759
837
        out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'l[hijk]ne1'])
760
 
        self.assertContainsRe(out, "^dir0/file0.aa:line1", flags=TestGrep._reflags)
761
 
        self.assertContainsRe(out, "^dir1/file1.bb:line1", flags=TestGrep._reflags)
 
838
        self.assertContainsRe(out, "^dir0/file0.aa:line1",
 
839
                              flags=TestGrep._reflags)
 
840
        self.assertContainsRe(out, "^dir1/file1.bb:line1",
 
841
                              flags=TestGrep._reflags)
762
842
        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
763
843
 
764
844
        out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'line1'])
765
 
        self.assertContainsRe(out, "^dir0/file0.aa:line1", flags=TestGrep._reflags)
766
 
        self.assertContainsRe(out, "^dir1/file1.bb:line1", flags=TestGrep._reflags)
 
845
        self.assertContainsRe(out, "^dir0/file0.aa:line1",
 
846
                              flags=TestGrep._reflags)
 
847
        self.assertContainsRe(out, "^dir1/file1.bb:line1",
 
848
                              flags=TestGrep._reflags)
767
849
        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
768
850
 
769
851
    def test_workingtree_files_from_outside_dir(self):
780
862
        self._mk_versioned_file('dir1/file1.txt')
781
863
 
782
864
        out, err = self.run_bzr(['grep', 'l[aeiou]ne1', 'dir0', 'dir1'])
783
 
        self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
784
 
        self.assertContainsRe(out, "^dir1/file1.txt:line1", flags=TestGrep._reflags)
 
865
        self.assertContainsRe(out, "^dir0/file0.txt:line1",
 
866
                              flags=TestGrep._reflags)
 
867
        self.assertContainsRe(out, "^dir1/file1.txt:line1",
 
868
                              flags=TestGrep._reflags)
785
869
 
786
870
        out, err = self.run_bzr(['grep', 'line1', 'dir0', 'dir1'])
787
 
        self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
788
 
        self.assertContainsRe(out, "^dir1/file1.txt:line1", flags=TestGrep._reflags)
 
871
        self.assertContainsRe(out, "^dir0/file0.txt:line1",
 
872
                              flags=TestGrep._reflags)
 
873
        self.assertContainsRe(out, "^dir1/file1.txt:line1",
 
874
                              flags=TestGrep._reflags)
789
875
 
790
876
    def test_versioned_files_from_outside_dir(self):
791
877
        """(versioned) Grep for pattern with dirs passed as argument.
800
886
        self._mk_versioned_dir('dir1')
801
887
        self._mk_versioned_file('dir1/file1.txt')
802
888
 
803
 
        out, err = self.run_bzr(['grep', '-r', 'last:1', '.ine1', 'dir0', 'dir1'])
804
 
        self.assertContainsRe(out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
805
 
        self.assertContainsRe(out, "^dir1/file1.txt~.:line1", flags=TestGrep._reflags)
 
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)
806
895
 
807
 
        out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1', 'dir0', 'dir1'])
808
 
        self.assertContainsRe(out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
809
 
        self.assertContainsRe(out, "^dir1/file1.txt~.:line1", flags=TestGrep._reflags)
 
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)
810
902
 
811
903
    def test_wtree_files_from_outside_dir(self):
812
904
        """(wtree) Grep for pattern with dirs passed as argument.
822
914
        self._mk_versioned_file('dir1/file1.txt')
823
915
 
824
916
        out, err = self.run_bzr(['grep', 'li.e1', 'dir0', 'dir1'])
825
 
        self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
826
 
        self.assertContainsRe(out, "^dir1/file1.txt:line1", flags=TestGrep._reflags)
 
917
        self.assertContainsRe(out, "^dir0/file0.txt:line1",
 
918
                              flags=TestGrep._reflags)
 
919
        self.assertContainsRe(out, "^dir1/file1.txt:line1",
 
920
                              flags=TestGrep._reflags)
827
921
 
828
922
        out, err = self.run_bzr(['grep', 'line1', 'dir0', 'dir1'])
829
 
        self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
830
 
        self.assertContainsRe(out, "^dir1/file1.txt:line1", flags=TestGrep._reflags)
 
923
        self.assertContainsRe(out, "^dir0/file0.txt:line1",
 
924
                              flags=TestGrep._reflags)
 
925
        self.assertContainsRe(out, "^dir1/file1.txt:line1",
 
926
                              flags=TestGrep._reflags)
831
927
 
832
928
    def test_versioned_files_from_outside_two_dirs(self):
833
929
        """(versioned) Grep for pattern with two levels of nested dir.
845
941
        self._mk_versioned_dir('dir0/dir00')
846
942
        self._mk_versioned_file('dir0/dir00/file0.txt')
847
943
 
848
 
        out, err = self.run_bzr(['grep', '-r', 'last:1', 'l.ne1', 'dir0/dir00'])
849
 
        self.assertContainsRe(out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
 
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)
850
948
 
851
949
        out, err = self.run_bzr(['grep', '-r', 'last:1', 'l.ne1'])
852
 
        self.assertContainsRe(out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
 
950
        self.assertContainsRe(
 
951
            out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
853
952
 
854
 
        out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1', 'dir0/dir00'])
855
 
        self.assertContainsRe(out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
 
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)
856
957
 
857
958
        out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
858
 
        self.assertContainsRe(out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
 
959
        self.assertContainsRe(
 
960
            out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
859
961
 
860
962
    def test_wtree_files_from_outside_two_dirs(self):
861
963
        """(wtree) Grep for pattern with two levels of nested dir.
874
976
        self._mk_versioned_file('dir0/dir00/file0.txt')
875
977
 
876
978
        out, err = self.run_bzr(['grep', 'lin.1', 'dir0/dir00'])
877
 
        self.assertContainsRe(out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
 
979
        self.assertContainsRe(
 
980
            out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
878
981
 
879
982
        out, err = self.run_bzr(['grep', 'li.e1'])
880
 
        self.assertContainsRe(out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
 
983
        self.assertContainsRe(
 
984
            out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
881
985
 
882
986
        out, err = self.run_bzr(['grep', 'line1', 'dir0/dir00'])
883
 
        self.assertContainsRe(out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
 
987
        self.assertContainsRe(
 
988
            out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
884
989
 
885
990
        out, err = self.run_bzr(['grep', 'line1'])
886
 
        self.assertContainsRe(out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
 
991
        self.assertContainsRe(
 
992
            out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
887
993
 
888
994
    def test_versioned_file_within_dir_two_levels(self):
889
995
        """(versioned) Search for pattern while in nested dir (two levels).
897
1003
        os.chdir('dir0')
898
1004
 
899
1005
        out, err = self.run_bzr(['grep', '-r', 'last:1', '.ine1'])
900
 
        self.assertContainsRe(out, "^dir1/file0.txt~.:line1", flags=TestGrep._reflags)
901
 
 
902
 
        out, err = self.run_bzr(['grep', '-r', 'last:1', '--from-root', 'l.ne1'])
903
 
        self.assertContainsRe(out, "^dir0/dir1/file0.txt~.:line1", flags=TestGrep._reflags)
904
 
 
905
 
        out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1'])
 
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'])
906
1016
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
907
1017
 
908
1018
        out, err = self.run_bzr(['grep', '-r', 'last:1', 'lin.1'])
909
 
        self.assertContainsRe(out, "^dir1/file0.txt~.:line1", flags=TestGrep._reflags)
910
 
 
911
 
        out, err = self.run_bzr(['grep', '-r', 'last:1', '--from-root', 'line1'])
912
 
        self.assertContainsRe(out, "^dir0/dir1/file0.txt~.:line1", flags=TestGrep._reflags)
913
 
 
914
 
        out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1'])
 
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'])
915
1029
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
916
1030
        self.assertEqual(len(out.splitlines()), 0)
917
1031
 
927
1041
        os.chdir('dir0')
928
1042
 
929
1043
        out, err = self.run_bzr(['grep', 'l[hij]ne1'])
930
 
        self.assertContainsRe(out, "^dir1/file0.txt:line1", flags=TestGrep._reflags)
 
1044
        self.assertContainsRe(out, "^dir1/file0.txt:line1",
 
1045
                              flags=TestGrep._reflags)
931
1046
 
932
1047
        out, err = self.run_bzr(['grep', '--from-root', 'l.ne1'])
933
 
        self.assertContainsRe(out, "^dir0/dir1/file0.txt:line1", flags=TestGrep._reflags)
 
1048
        self.assertContainsRe(
 
1049
            out, "^dir0/dir1/file0.txt:line1", flags=TestGrep._reflags)
934
1050
 
935
1051
        out, err = self.run_bzr(['grep', '--no-recursive', 'lin.1'])
936
1052
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
937
1053
 
938
1054
        out, err = self.run_bzr(['grep', 'line1'])
939
 
        self.assertContainsRe(out, "^dir1/file0.txt:line1", flags=TestGrep._reflags)
 
1055
        self.assertContainsRe(out, "^dir1/file0.txt:line1",
 
1056
                              flags=TestGrep._reflags)
940
1057
 
941
1058
        out, err = self.run_bzr(['grep', '--from-root', 'line1'])
942
 
        self.assertContainsRe(out, "^dir0/dir1/file0.txt:line1", flags=TestGrep._reflags)
 
1059
        self.assertContainsRe(
 
1060
            out, "^dir0/dir1/file0.txt:line1", flags=TestGrep._reflags)
943
1061
 
944
1062
        out, err = self.run_bzr(['grep', '--no-recursive', 'line1'])
945
1063
        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
953
1071
        self._mk_versioned_file('file0.txt')
954
1072
 
955
1073
        out, err = self.run_bzr(['grep', '-r', 'last:1', 'LinE1', 'file0.txt'])
956
 
        self.assertNotContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
 
1074
        self.assertNotContainsRe(
 
1075
            out, "file0.txt~.:line1", flags=TestGrep._reflags)
957
1076
 
958
1077
        out, err = self.run_bzr(['grep', '-r', 'last:1', 'Li.E1', 'file0.txt'])
959
 
        self.assertNotContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
 
1078
        self.assertNotContainsRe(
 
1079
            out, "file0.txt~.:line1", flags=TestGrep._reflags)
960
1080
 
961
1081
    def test_wtree_ignore_case_no_match(self):
962
1082
        """(wtree) Match fails without --ignore-case.
967
1087
        self._mk_versioned_file('file0.txt')
968
1088
 
969
1089
        out, err = self.run_bzr(['grep', 'LinE1', 'file0.txt'])
970
 
        self.assertNotContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
 
1090
        self.assertNotContainsRe(
 
1091
            out, "file0.txt:line1", flags=TestGrep._reflags)
971
1092
 
972
1093
        out, err = self.run_bzr(['grep', '.inE1', 'file0.txt'])
973
 
        self.assertNotContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
 
1094
        self.assertNotContainsRe(
 
1095
            out, "file0.txt:line1", flags=TestGrep._reflags)
974
1096
 
975
1097
    def test_versioned_ignore_case_match(self):
976
1098
        """(versioned) Match fails without --ignore-case.
981
1103
        self._mk_versioned_file('file0.txt')
982
1104
 
983
1105
        out, err = self.run_bzr(['grep', '-r', 'last:1',
984
 
            '-i', 'Li.E1', 'file0.txt'])
985
 
        self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
986
 
 
987
 
        out, err = self.run_bzr(['grep', '-r', 'last:1',
988
 
            '-i', 'LinE1', 'file0.txt'])
989
 
        self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
990
 
 
991
 
        out, err = self.run_bzr(['grep', '-r', 'last:1',
992
 
            '--ignore-case', 'LinE1', 'file0.txt'])
993
 
        self.assertContainsRe(out, "^file0.txt~.:line1", flags=TestGrep._reflags)
 
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)
994
1119
 
995
1120
    def test_wtree_ignore_case_match(self):
996
1121
        """(wtree) Match fails without --ignore-case.
1003
1128
        out, err = self.run_bzr(['grep', '-i', 'LinE1', 'file0.txt'])
1004
1129
        self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
1005
1130
 
1006
 
        out, err = self.run_bzr(['grep', '--ignore-case', 'LinE1', 'file0.txt'])
 
1131
        out, err = self.run_bzr(
 
1132
            ['grep', '--ignore-case', 'LinE1', 'file0.txt'])
1007
1133
        self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
1008
1134
 
1009
 
        out, err = self.run_bzr(['grep', '--ignore-case', 'Li.E1', 'file0.txt'])
 
1135
        out, err = self.run_bzr(
 
1136
            ['grep', '--ignore-case', 'Li.E1', 'file0.txt'])
1010
1137
        self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
1011
1138
 
1012
1139
    def test_versioned_from_root_fail(self):
1052
1179
        os.chdir('dir0')
1053
1180
 
1054
1181
        out, err = self.run_bzr(['grep', '-r', 'last:1',
1055
 
            '--from-root', 'l.ne1'])
1056
 
        self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
 
1182
                                 '--from-root', 'l.ne1'])
 
1183
        self.assertContainsRe(out, "file0.txt~.:line1",
 
1184
                              flags=TestGrep._reflags)
1057
1185
 
1058
1186
        out, err = self.run_bzr(['grep', '-r', 'last:1',
1059
 
            '--from-root', 'line1'])
1060
 
        self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
 
1187
                                 '--from-root', 'line1'])
 
1188
        self.assertContainsRe(out, "file0.txt~.:line1",
 
1189
                              flags=TestGrep._reflags)
1061
1190
 
1062
1191
    def test_wtree_from_root_pass(self):
1063
1192
        """(wtree) Match pass with --from-root.
1084
1213
        self._mk_versioned_file('file0.txt')
1085
1214
 
1086
1215
        out, err = self.run_bzr(['grep', '-r', 'last:1',
1087
 
            '--line-number', 'li.e3', 'file0.txt'])
1088
 
        self.assertContainsRe(out, "file0.txt~.:3:line3", flags=TestGrep._reflags)
1089
 
 
1090
 
        out, err = self.run_bzr(['grep', '-r', 'last:1',
1091
 
            '--line-number', 'line3', 'file0.txt'])
1092
 
        self.assertContainsRe(out, "file0.txt~.:3:line3", flags=TestGrep._reflags)
1093
 
 
1094
 
        out, err = self.run_bzr(['grep', '-r', 'last:1',
1095
 
            '-n', 'line1', 'file0.txt'])
1096
 
        self.assertContainsRe(out, "file0.txt~.:1:line1", flags=TestGrep._reflags)
 
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)
1097
1229
 
1098
1230
        out, err = self.run_bzr(['grep', '-n', 'line[0-9]', 'file0.txt'])
1099
 
        self.assertContainsRe(out, "file0.txt:3:line3", flags=TestGrep._reflags)
 
1231
        self.assertContainsRe(out, "file0.txt:3:line3",
 
1232
                              flags=TestGrep._reflags)
1100
1233
 
1101
1234
    def test_wtree_with_line_number(self):
1102
1235
        """(wtree) Search for pattern with --line-number.
1106
1239
        os.chdir(wd)
1107
1240
        self._mk_versioned_file('file0.txt')
1108
1241
 
1109
 
        out, err = self.run_bzr(['grep', '--line-number', 'line3', 'file0.txt'])
1110
 
        self.assertContainsRe(out, "file0.txt:3:line3", flags=TestGrep._reflags)
 
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)
1111
1246
 
1112
1247
        out, err = self.run_bzr(['grep', '-n', 'line1', 'file0.txt'])
1113
 
        self.assertContainsRe(out, "file0.txt:1:line1", flags=TestGrep._reflags)
 
1248
        self.assertContainsRe(out, "file0.txt:1:line1",
 
1249
                              flags=TestGrep._reflags)
1114
1250
 
1115
1251
        out, err = self.run_bzr(['grep', '-n', '[hjkl]ine1', 'file0.txt'])
1116
 
        self.assertContainsRe(out, "file0.txt:1:line1", flags=TestGrep._reflags)
 
1252
        self.assertContainsRe(out, "file0.txt:1:line1",
 
1253
                              flags=TestGrep._reflags)
1117
1254
 
1118
1255
        out, err = self.run_bzr(['grep', '-n', 'line[0-9]', 'file0.txt'])
1119
 
        self.assertContainsRe(out, "file0.txt:3:line3", flags=TestGrep._reflags)
 
1256
        self.assertContainsRe(out, "file0.txt:3:line3",
 
1257
                              flags=TestGrep._reflags)
1120
1258
 
1121
1259
    def test_revno_basic_history_grep_file(self):
1122
1260
        """Search for pattern in specific revision number in a file.
1140
1278
 
1141
1279
        # rev 3 should not have text 'v3' with line number
1142
1280
        out, err = self.run_bzr(['grep', '-r', '3', '-n', 'v3', fname])
1143
 
        self.assertContainsRe(out, "file0.txt~3:2:v3.*", flags=TestGrep._reflags)
 
1281
        self.assertContainsRe(out, "file0.txt~3:2:v3.*",
 
1282
                              flags=TestGrep._reflags)
1144
1283
 
1145
1284
        # rev 2 should not have text 'v3'
1146
1285
        out, err = self.run_bzr(['grep', '-r', '2', '[tuv]3', fname])
1152
1291
 
1153
1292
        # rev 3 should not have text 'v3' with line number
1154
1293
        out, err = self.run_bzr(['grep', '-r', '3', '-n', '[tuv]3', fname])
1155
 
        self.assertContainsRe(out, "file0.txt~3:2:v3.*", flags=TestGrep._reflags)
 
1294
        self.assertContainsRe(out, "file0.txt~3:2:v3.*",
 
1295
                              flags=TestGrep._reflags)
1156
1296
 
1157
1297
    def test_revno_basic_history_grep_full(self):
1158
1298
        """Search for pattern in specific revision number in a file.
1161
1301
        fname = 'file0.txt'
1162
1302
        self.make_branch_and_tree(wd)
1163
1303
        os.chdir(wd)
1164
 
        self._mk_versioned_file(fname, total_lines=0) # rev1
 
1304
        self._mk_versioned_file(fname, total_lines=0)  # rev1
1165
1305
        self._mk_versioned_file('file1.txt')          # rev2
1166
1306
        self._update_file(fname, text="v3 text\n")    # rev3
1167
1307
        self._update_file(fname, text="v4 text\n")    # rev4
1205
1345
 
1206
1346
        # v4 should not be present in revno 3
1207
1347
        out, err = self.run_bzr(['grep', '-r', 'last:3', 'v4'])
1208
 
        self.assertNotContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
 
1348
        self.assertNotContainsRe(
 
1349
            out, "^dir0/file0.txt", flags=TestGrep._reflags)
1209
1350
 
1210
1351
        # v4 should be present in revno 4
1211
1352
        out, err = self.run_bzr(['grep', '-r', 'last:2', 'v4'])
1212
 
        self.assertContainsRe(out, "^dir0/file0.txt~4:v4", flags=TestGrep._reflags)
 
1353
        self.assertContainsRe(out, "^dir0/file0.txt~4:v4",
 
1354
                              flags=TestGrep._reflags)
1213
1355
 
1214
1356
        # v4 should not be present in revno 3
1215
1357
        out, err = self.run_bzr(['grep', '-r', 'last:3', '[tuv]4'])
1216
 
        self.assertNotContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
 
1358
        self.assertNotContainsRe(
 
1359
            out, "^dir0/file0.txt", flags=TestGrep._reflags)
1217
1360
 
1218
1361
        # v4 should be present in revno 4
1219
1362
        out, err = self.run_bzr(['grep', '-r', 'last:2', '[tuv]4'])
1220
 
        self.assertContainsRe(out, "^dir0/file0.txt~4:v4", flags=TestGrep._reflags)
 
1363
        self.assertContainsRe(out, "^dir0/file0.txt~4:v4",
 
1364
                              flags=TestGrep._reflags)
1221
1365
 
1222
1366
    def test_revno_range_basic_history_grep(self):
1223
1367
        """Search for pattern in revision range for file.
1226
1370
        fname = 'file0.txt'
1227
1371
        self.make_branch_and_tree(wd)
1228
1372
        os.chdir(wd)
1229
 
        self._mk_versioned_file(fname, total_lines=0) # rev1
 
1373
        self._mk_versioned_file(fname, total_lines=0)  # rev1
1230
1374
        self._mk_versioned_file('file1.txt')          # rev2
1231
1375
        self._update_file(fname, text="v3 text\n")    # rev3
1232
1376
        self._update_file(fname, text="v4 text\n")    # rev4
1262
1406
        self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1263
1407
        self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1264
1408
        self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1265
 
        self.assertNotContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
 
1409
        self.assertNotContainsRe(
 
1410
            out, "file0.txt~6:v3", flags=TestGrep._reflags)
1266
1411
        self.assertEqual(len(out.splitlines()), 3)
1267
1412
 
1268
1413
        out, err = self.run_bzr(['grep', '-r', '5..1', 'v3'])
1269
1414
        self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1270
1415
        self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1271
1416
        self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1272
 
        self.assertNotContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
 
1417
        self.assertNotContainsRe(
 
1418
            out, "file0.txt~6:v3", flags=TestGrep._reflags)
1273
1419
        self.assertEqual(len(out.splitlines()), 3)
1274
1420
 
1275
1421
        out, err = self.run_bzr(['grep', '-r', '1..', '[tuv]3'])
1283
1429
        self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1284
1430
        self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1285
1431
        self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1286
 
        self.assertNotContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
 
1432
        self.assertNotContainsRe(
 
1433
            out, "file0.txt~6:v3", flags=TestGrep._reflags)
1287
1434
        self.assertEqual(len(out.splitlines()), 3)
1288
1435
 
1289
1436
        out, err = self.run_bzr(['grep', '-r', '5..1', '[tuv]3'])
1290
1437
        self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1291
1438
        self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1292
1439
        self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1293
 
        self.assertNotContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
 
1440
        self.assertNotContainsRe(
 
1441
            out, "file0.txt~6:v3", flags=TestGrep._reflags)
1294
1442
        self.assertEqual(len(out.splitlines()), 3)
1295
1443
 
1296
1444
    def test_revno_range_versioned_file_in_dir(self):
1307
1455
        self._update_file('dir0/file0.txt', "v6 text\n")    # rev6
1308
1456
 
1309
1457
        out, err = self.run_bzr(['grep', '-r', '2..5', 'v3'])
1310
 
        self.assertContainsRe(out, "^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
1311
 
        self.assertContainsRe(out, "^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
1312
 
        self.assertContainsRe(out, "^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
1313
 
        self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
 
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)
1314
1466
        self.assertEqual(len(out.splitlines()), 3)
1315
1467
 
1316
1468
        out, err = self.run_bzr(['grep', '-r', '2..5', '[tuv]3'])
1317
 
        self.assertContainsRe(out, "^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
1318
 
        self.assertContainsRe(out, "^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
1319
 
        self.assertContainsRe(out, "^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
1320
 
        self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
 
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)
1321
1477
        self.assertEqual(len(out.splitlines()), 3)
1322
1478
 
1323
1479
    def test_revno_range_versioned_file_from_outside_dir(self):
1334
1490
        self._update_file('dir0/file0.txt', "v6 text\n")    # rev6
1335
1491
 
1336
1492
        out, err = self.run_bzr(['grep', '-r', '2..5', 'v3', 'dir0'])
1337
 
        self.assertContainsRe(out, "^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
1338
 
        self.assertContainsRe(out, "^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
1339
 
        self.assertContainsRe(out, "^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
1340
 
        self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
 
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)
1341
1501
 
1342
1502
        out, err = self.run_bzr(['grep', '-r', '2..5', '[tuv]3', 'dir0'])
1343
 
        self.assertContainsRe(out, "^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
1344
 
        self.assertContainsRe(out, "^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
1345
 
        self.assertContainsRe(out, "^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
1346
 
        self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
 
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)
1347
1511
 
1348
1512
    def test_levels(self):
1349
1513
        """--levels=0 should show findings from merged revision.
1370
1534
 
1371
1535
        # levels should be ignored by wtree grep
1372
1536
        out, err = self.run_bzr(['grep', '--levels=0', 'line1'])
1373
 
        self.assertContainsRe(out, "^file0.txt:line1$", flags=TestGrep._reflags)
1374
 
        self.assertContainsRe(out, "^file1.txt:line1$", flags=TestGrep._reflags)
1375
 
        self.assertContainsRe(out, "^file0.txt:line10$", flags=TestGrep._reflags)
1376
 
        self.assertContainsRe(out, "^file1.txt:line10$", flags=TestGrep._reflags)
 
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)
1377
1545
        self.assertEqual(len(out.splitlines()), 4)
1378
1546
 
1379
 
        out, err = self.run_bzr(['grep', '-r', 'last:1..', '--levels=0', 'line1'])
1380
 
        self.assertContainsRe(out, "^file0.txt~2:line1$", flags=TestGrep._reflags)
1381
 
        self.assertContainsRe(out, "^file1.txt~2:line1$", flags=TestGrep._reflags)
1382
 
        self.assertContainsRe(out, "^file0.txt~1.1.1:line1$", flags=TestGrep._reflags)
1383
 
        self.assertContainsRe(out, "^file1.txt~1.1.1:line1$", flags=TestGrep._reflags)
1384
 
        self.assertContainsRe(out, "^file0.txt~2:line10$", flags=TestGrep._reflags)
1385
 
        self.assertContainsRe(out, "^file1.txt~2:line10$", flags=TestGrep._reflags)
1386
 
        self.assertContainsRe(out, "^file0.txt~1.1.1:line10$", flags=TestGrep._reflags)
1387
 
        self.assertContainsRe(out, "^file1.txt~1.1.1:line10$", flags=TestGrep._reflags)
 
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)
1388
1565
        self.assertEqual(len(out.splitlines()), 8)
1389
1566
 
1390
 
        out, err = self.run_bzr(['grep', '-r',  '-1..', '-n', '--levels=0', 'line1'])
1391
 
        self.assertContainsRe(out, "^file0.txt~2:1:line1$", flags=TestGrep._reflags)
1392
 
        self.assertContainsRe(out, "^file1.txt~2:1:line1$", flags=TestGrep._reflags)
1393
 
        self.assertContainsRe(out, "^file0.txt~1.1.1:1:line1$", flags=TestGrep._reflags)
1394
 
        self.assertContainsRe(out, "^file1.txt~1.1.1:1:line1$", flags=TestGrep._reflags)
1395
 
        self.assertContainsRe(out, "^file0.txt~2:10:line10$", flags=TestGrep._reflags)
1396
 
        self.assertContainsRe(out, "^file1.txt~2:10:line10$", flags=TestGrep._reflags)
1397
 
        self.assertContainsRe(out, "^file0.txt~1.1.1:10:line10$", flags=TestGrep._reflags)
1398
 
        self.assertContainsRe(out, "^file1.txt~1.1.1:10:line10$", flags=TestGrep._reflags)
 
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)
1399
1585
        self.assertEqual(len(out.splitlines()), 8)
1400
1586
 
1401
1587
        # levels should be ignored by wtree grep
1402
1588
        out, err = self.run_bzr(['grep', '--levels=0', 'l.ne1'])
1403
 
        self.assertContainsRe(out, "^file0.txt:line1$", flags=TestGrep._reflags)
1404
 
        self.assertContainsRe(out, "^file1.txt:line1$", flags=TestGrep._reflags)
1405
 
        self.assertContainsRe(out, "^file0.txt:line10$", flags=TestGrep._reflags)
1406
 
        self.assertContainsRe(out, "^file1.txt:line10$", flags=TestGrep._reflags)
 
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)
1407
1597
        self.assertEqual(len(out.splitlines()), 4)
1408
1598
 
1409
 
        out, err = self.run_bzr(['grep', '-r', 'last:1..', '--levels=0', 'lin.1'])
1410
 
        self.assertContainsRe(out, "^file0.txt~2:line1$", flags=TestGrep._reflags)
1411
 
        self.assertContainsRe(out, "^file1.txt~2:line1$", flags=TestGrep._reflags)
1412
 
        self.assertContainsRe(out, "^file0.txt~1.1.1:line1$", flags=TestGrep._reflags)
1413
 
        self.assertContainsRe(out, "^file1.txt~1.1.1:line1$", flags=TestGrep._reflags)
1414
 
        self.assertContainsRe(out, "^file0.txt~2:line10$", flags=TestGrep._reflags)
1415
 
        self.assertContainsRe(out, "^file1.txt~2:line10$", flags=TestGrep._reflags)
1416
 
        self.assertContainsRe(out, "^file0.txt~1.1.1:line10$", flags=TestGrep._reflags)
1417
 
        self.assertContainsRe(out, "^file1.txt~1.1.1:line10$", flags=TestGrep._reflags)
 
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)
1418
1617
        self.assertEqual(len(out.splitlines()), 8)
1419
1618
 
1420
 
        out, err = self.run_bzr(['grep', '-r',  '-1..', '-n', '--levels=0', '.ine1'])
1421
 
        self.assertContainsRe(out, "file0.txt~2:1:line1", flags=TestGrep._reflags)
1422
 
        self.assertContainsRe(out, "file1.txt~2:1:line1", flags=TestGrep._reflags)
1423
 
        self.assertContainsRe(out, "file0.txt~1.1.1:1:line1", flags=TestGrep._reflags)
1424
 
        self.assertContainsRe(out, "file1.txt~1.1.1:1:line1", flags=TestGrep._reflags)
 
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)
1425
1629
 
1426
1630
    def test_dotted_rev_grep(self):
1427
1631
        """Grep in dotted revs
1446
1650
        out, err = self.run_bzr(['ci', '-m', 'merged'])
1447
1651
 
1448
1652
        out, err = self.run_bzr(['grep', '-r', '1.1.1..1.1.4', 'text'])
1449
 
        self.assertContainsRe(out, "file1.txt~1.1.2:text 0", flags=TestGrep._reflags)
1450
 
        self.assertContainsRe(out, "file1.txt~1.1.3:text 1", flags=TestGrep._reflags)
1451
 
        self.assertContainsRe(out, "file1.txt~1.1.3:text 1", flags=TestGrep._reflags)
1452
 
        self.assertContainsRe(out, "file1.txt~1.1.4:text 0", flags=TestGrep._reflags)
1453
 
        self.assertContainsRe(out, "file1.txt~1.1.4:text 1", flags=TestGrep._reflags)
1454
 
        self.assertContainsRe(out, "file1.txt~1.1.4:text 2", flags=TestGrep._reflags)
 
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)
1455
1665
        self.assertEqual(len(out.splitlines()), 6)
1456
1666
 
1457
1667
    def test_versioned_binary_file_grep(self):
1466
1676
 
1467
1677
        # note: set --verbose/-v flag to get the skip message.
1468
1678
        out, err = self.run_bzr(['grep', '-v', '-r', 'last:1',
1469
 
            'lineNN', 'file0.bin'])
 
1679
                                 'lineNN', 'file0.bin'])
1470
1680
        self.assertNotContainsRe(out, "file0.bin", flags=TestGrep._reflags)
1471
 
        self.assertContainsRe(err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
 
1681
        self.assertContainsRe(
 
1682
            err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
1472
1683
        self.assertEqual(len(out.splitlines()), 0)
1473
1684
        self.assertEqual(len(err.splitlines()), 1)
1474
1685
 
1475
1686
        out, err = self.run_bzr(['grep', '-v', '-r', 'last:1',
1476
 
            'line.N', 'file0.bin'])
 
1687
                                 'line.N', 'file0.bin'])
1477
1688
        self.assertNotContainsRe(out, "file0.bin", flags=TestGrep._reflags)
1478
 
        self.assertContainsRe(err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
 
1689
        self.assertContainsRe(
 
1690
            err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
1479
1691
        self.assertEqual(len(out.splitlines()), 0)
1480
1692
        self.assertEqual(len(err.splitlines()), 1)
1481
1693
 
1490
1702
 
1491
1703
        # note: set --verbose/-v flag to get the skip message.
1492
1704
        out, err = self.run_bzr(['grep', '-v', 'lineNN', 'file0.bin'])
1493
 
        self.assertNotContainsRe(out, "file0.bin:line1", flags=TestGrep._reflags)
1494
 
        self.assertContainsRe(err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
 
1705
        self.assertNotContainsRe(
 
1706
            out, "file0.bin:line1", flags=TestGrep._reflags)
 
1707
        self.assertContainsRe(
 
1708
            err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
1495
1709
 
1496
1710
        # binary warning should not be shown without --verbose
1497
1711
        out, err = self.run_bzr(['grep', 'lineNN', 'file0.bin'])
1498
 
        self.assertNotContainsRe(out, "file0.bin:line1", flags=TestGrep._reflags)
 
1712
        self.assertNotContainsRe(
 
1713
            out, "file0.bin:line1", flags=TestGrep._reflags)
1499
1714
        self.assertNotContainsRe(err, "Binary file", flags=TestGrep._reflags)
1500
1715
 
1501
1716
    def test_revspec(self):
1516
1731
 
1517
1732
        out, err = self.run_bzr(['grep', '-r', 'revno:4..', 'v4'])
1518
1733
        self.assertContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
1519
 
        self.assertEqual(len(out.splitlines()), 2) # find v4 in rev4 and rev5
 
1734
        self.assertEqual(len(out.splitlines()), 2)  # find v4 in rev4 and rev5
1520
1735
 
1521
1736
        out, err = self.run_bzr(['grep', '-r', '..revno:3', 'v4'])
1522
1737
        self.assertNotContainsRe(out, "file0", flags=TestGrep._reflags)
1546
1761
        out, err = self.run_bzr(['grep', '--files-with-matches', 'HELLO'])
1547
1762
 
1548
1763
        self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1549
 
        self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
 
1764
        self.assertContainsRe(out, "^dir0/file00.txt$",
 
1765
                              flags=TestGrep._reflags)
1550
1766
        self.assertEqual(len(out.splitlines()), 2)
1551
1767
 
1552
1768
        # regex
1553
1769
        out, err = self.run_bzr(['grep', '--files-with-matches', 'HE.LO'])
1554
1770
 
1555
1771
        self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1556
 
        self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
 
1772
        self.assertContainsRe(out, "^dir0/file00.txt$",
 
1773
                              flags=TestGrep._reflags)
1557
1774
        self.assertEqual(len(out.splitlines()), 2)
1558
1775
 
1559
1776
        # fixed-string
1560
1777
        out, err = self.run_bzr(['grep', '-l', 'HELLO'])
1561
1778
 
1562
1779
        self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1563
 
        self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
 
1780
        self.assertContainsRe(out, "^dir0/file00.txt$",
 
1781
                              flags=TestGrep._reflags)
1564
1782
        self.assertEqual(len(out.splitlines()), 2)
1565
1783
 
1566
1784
        # regex
1567
1785
        out, err = self.run_bzr(['grep', '-l', 'HE.LO'])
1568
1786
 
1569
1787
        self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1570
 
        self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
 
1788
        self.assertContainsRe(out, "^dir0/file00.txt$",
 
1789
                              flags=TestGrep._reflags)
1571
1790
        self.assertEqual(len(out.splitlines()), 2)
1572
1791
 
1573
1792
        # fixed-string
1574
1793
        out, err = self.run_bzr(['grep', '-l', 'HELLO', 'dir0', 'file1.txt'])
1575
1794
 
1576
 
        self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
 
1795
        self.assertContainsRe(out, "^dir0/file00.txt$",
 
1796
                              flags=TestGrep._reflags)
1577
1797
        self.assertEqual(len(out.splitlines()), 1)
1578
1798
 
1579
1799
        # regex
1580
1800
        out, err = self.run_bzr(['grep', '-l', '.ELLO', 'dir0', 'file1.txt'])
1581
1801
 
1582
 
        self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
 
1802
        self.assertContainsRe(out, "^dir0/file00.txt$",
 
1803
                              flags=TestGrep._reflags)
1583
1804
        self.assertEqual(len(out.splitlines()), 1)
1584
1805
 
1585
1806
        # fixed-string
1624
1845
 
1625
1846
        # fixed-string
1626
1847
        out, err = self.run_bzr(['grep', '-r', '-1', '--files-with-matches',
1627
 
            'HELLO'])
 
1848
                                 'HELLO'])
1628
1849
 
1629
1850
        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1630
 
        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
 
1851
        self.assertContainsRe(out, "^dir0/file00.txt~7$",
 
1852
                              flags=TestGrep._reflags)
1631
1853
        self.assertEqual(len(out.splitlines()), 2)
1632
1854
 
1633
1855
        # regex
1634
1856
        out, err = self.run_bzr(['grep', '-r', '-1', '--files-with-matches',
1635
 
            'H.LLO'])
 
1857
                                 'H.LLO'])
1636
1858
 
1637
1859
        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1638
 
        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
 
1860
        self.assertContainsRe(out, "^dir0/file00.txt~7$",
 
1861
                              flags=TestGrep._reflags)
1639
1862
        self.assertEqual(len(out.splitlines()), 2)
1640
1863
 
1641
1864
        # fixed-string
1642
1865
        out, err = self.run_bzr(['grep', '-r', '6..7', '--files-with-matches',
1643
 
            'HELLO'])
 
1866
                                 'HELLO'])
1644
1867
 
1645
1868
        self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1646
1869
        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1647
 
        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
 
1870
        self.assertContainsRe(out, "^dir0/file00.txt~7$",
 
1871
                              flags=TestGrep._reflags)
1648
1872
        self.assertEqual(len(out.splitlines()), 3)
1649
1873
 
1650
1874
        # regex
1651
1875
        out, err = self.run_bzr(['grep', '-r', '6..7', '--files-with-matches',
1652
 
            'H.LLO'])
 
1876
                                 'H.LLO'])
1653
1877
 
1654
1878
        self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1655
1879
        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1656
 
        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
 
1880
        self.assertContainsRe(out, "^dir0/file00.txt~7$",
 
1881
                              flags=TestGrep._reflags)
1657
1882
        self.assertEqual(len(out.splitlines()), 3)
1658
1883
 
1659
1884
        # fixed-string
1660
1885
        out, err = self.run_bzr(['grep', '-r', '-1', '-l', 'HELLO'])
1661
1886
 
1662
1887
        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1663
 
        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
 
1888
        self.assertContainsRe(out, "^dir0/file00.txt~7$",
 
1889
                              flags=TestGrep._reflags)
1664
1890
        self.assertEqual(len(out.splitlines()), 2)
1665
1891
 
1666
1892
        # regex
1667
1893
        out, err = self.run_bzr(['grep', '-r', '-1', '-l', 'H.LLO'])
1668
1894
 
1669
1895
        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1670
 
        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
 
1896
        self.assertContainsRe(out, "^dir0/file00.txt~7$",
 
1897
                              flags=TestGrep._reflags)
1671
1898
        self.assertEqual(len(out.splitlines()), 2)
1672
1899
 
1673
1900
        # fixed-string
1674
1901
        out, err = self.run_bzr(['grep', '-l', 'HELLO', '-r', '-1',
1675
 
            'dir0', 'file1.txt'])
 
1902
                                 'dir0', 'file1.txt'])
1676
1903
 
1677
 
        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
 
1904
        self.assertContainsRe(out, "^dir0/file00.txt~7$",
 
1905
                              flags=TestGrep._reflags)
1678
1906
        self.assertEqual(len(out.splitlines()), 1)
1679
1907
 
1680
1908
        # regex
1681
1909
        out, err = self.run_bzr(['grep', '-l', 'H.LLO', '-r', '-1',
1682
 
            'dir0', 'file1.txt'])
 
1910
                                 'dir0', 'file1.txt'])
1683
1911
 
1684
 
        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
 
1912
        self.assertContainsRe(out, "^dir0/file00.txt~7$",
 
1913
                              flags=TestGrep._reflags)
1685
1914
        self.assertEqual(len(out.splitlines()), 1)
1686
1915
 
1687
1916
        # fixed-string
1688
1917
        out, err = self.run_bzr(['grep', '-l', 'HELLO',
1689
 
            '-r', '-2', 'file0.txt'])
 
1918
                                 '-r', '-2', 'file0.txt'])
1690
1919
 
1691
1920
        self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1692
1921
        self.assertEqual(len(out.splitlines()), 1)
1693
1922
 
1694
1923
        # regex
1695
1924
        out, err = self.run_bzr(['grep', '-l', 'HE.LO',
1696
 
            '-r', '-2', 'file0.txt'])
 
1925
                                 '-r', '-2', 'file0.txt'])
1697
1926
 
1698
1927
        self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1699
1928
        self.assertEqual(len(out.splitlines()), 1)
1700
1929
 
1701
1930
        # fixed-string
1702
1931
        out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
1703
 
            '-l', 'HELLO'])
 
1932
                                 '-l', 'HELLO'])
1704
1933
 
1705
1934
        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1706
1935
        self.assertEqual(len(out.splitlines()), 1)
1707
1936
 
1708
1937
        # regex
1709
1938
        out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
1710
 
            '-l', '.ELLO'])
 
1939
                                 '-l', '.ELLO'])
1711
1940
 
1712
1941
        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1713
1942
        self.assertEqual(len(out.splitlines()), 1)
1732
1961
        out, err = self.run_bzr(['grep', '--files-without-match', 'HELLO'])
1733
1962
 
1734
1963
        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1735
 
        self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
 
1964
        self.assertContainsRe(out, "^dir0/file01.txt$",
 
1965
                              flags=TestGrep._reflags)
1736
1966
        self.assertEqual(len(out.splitlines()), 2)
1737
1967
 
1738
1968
        # regex
1739
1969
        out, err = self.run_bzr(['grep', '--files-without-match', 'HE.LO'])
1740
1970
 
1741
1971
        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1742
 
        self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
 
1972
        self.assertContainsRe(out, "^dir0/file01.txt$",
 
1973
                              flags=TestGrep._reflags)
1743
1974
        self.assertEqual(len(out.splitlines()), 2)
1744
1975
 
1745
1976
        # fixed-string
1746
1977
        out, err = self.run_bzr(['grep', '-L', 'HELLO'])
1747
1978
 
1748
1979
        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1749
 
        self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
 
1980
        self.assertContainsRe(out, "^dir0/file01.txt$",
 
1981
                              flags=TestGrep._reflags)
1750
1982
        self.assertEqual(len(out.splitlines()), 2)
1751
1983
 
1752
1984
        # regex
1753
1985
        out, err = self.run_bzr(['grep', '-L', 'HE.LO'])
1754
1986
 
1755
1987
        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1756
 
        self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
 
1988
        self.assertContainsRe(out, "^dir0/file01.txt$",
 
1989
                              flags=TestGrep._reflags)
1757
1990
        self.assertEqual(len(out.splitlines()), 2)
1758
1991
 
1759
1992
        # fixed-string
1760
1993
        out, err = self.run_bzr(['grep', '-L', 'HELLO', 'dir0', 'file1.txt'])
1761
1994
 
1762
1995
        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1763
 
        self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
 
1996
        self.assertContainsRe(out, "^dir0/file01.txt$",
 
1997
                              flags=TestGrep._reflags)
1764
1998
        self.assertEqual(len(out.splitlines()), 2)
1765
1999
 
1766
2000
        # regex
1767
2001
        out, err = self.run_bzr(['grep', '-L', '.ELLO', 'dir0', 'file1.txt'])
1768
2002
 
1769
2003
        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1770
 
        self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
 
2004
        self.assertContainsRe(out, "^dir0/file01.txt$",
 
2005
                              flags=TestGrep._reflags)
1771
2006
        self.assertEqual(len(out.splitlines()), 2)
1772
2007
 
1773
2008
        # fixed-string
1812
2047
 
1813
2048
        # fixed-string
1814
2049
        out, err = self.run_bzr(['grep', '-r', '-1', '--files-without-match',
1815
 
            'HELLO'])
 
2050
                                 'HELLO'])
1816
2051
 
1817
2052
        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1818
 
        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
 
2053
        self.assertContainsRe(out, "^dir0/file01.txt~7$",
 
2054
                              flags=TestGrep._reflags)
1819
2055
        self.assertEqual(len(out.splitlines()), 2)
1820
2056
 
1821
2057
        # regex
1822
2058
        out, err = self.run_bzr(['grep', '-r', '-1', '--files-without-match',
1823
 
            'H.LLO'])
 
2059
                                 'H.LLO'])
1824
2060
 
1825
2061
        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1826
 
        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
 
2062
        self.assertContainsRe(out, "^dir0/file01.txt~7$",
 
2063
                              flags=TestGrep._reflags)
1827
2064
        self.assertEqual(len(out.splitlines()), 2)
1828
2065
 
1829
2066
        # fixed-string
1830
2067
        out, err = self.run_bzr(['grep', '-r', '6..7', '--files-without-match',
1831
 
            'HELLO'])
 
2068
                                 'HELLO'])
1832
2069
 
1833
2070
        self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
1834
 
        self.assertContainsRe(out, "^dir0/file00.txt~6$", flags=TestGrep._reflags)
1835
 
        self.assertContainsRe(out, "^dir0/file01.txt~6$", flags=TestGrep._reflags)
 
2071
        self.assertContainsRe(out, "^dir0/file00.txt~6$",
 
2072
                              flags=TestGrep._reflags)
 
2073
        self.assertContainsRe(out, "^dir0/file01.txt~6$",
 
2074
                              flags=TestGrep._reflags)
1836
2075
        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1837
 
        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
 
2076
        self.assertContainsRe(out, "^dir0/file01.txt~7$",
 
2077
                              flags=TestGrep._reflags)
1838
2078
        self.assertEqual(len(out.splitlines()), 5)
1839
2079
 
1840
2080
        # regex
1841
2081
        out, err = self.run_bzr(['grep', '-r', '6..7', '--files-without-match',
1842
 
            'H.LLO'])
 
2082
                                 'H.LLO'])
1843
2083
 
1844
2084
        self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
1845
 
        self.assertContainsRe(out, "^dir0/file00.txt~6$", flags=TestGrep._reflags)
1846
 
        self.assertContainsRe(out, "^dir0/file01.txt~6$", flags=TestGrep._reflags)
 
2085
        self.assertContainsRe(out, "^dir0/file00.txt~6$",
 
2086
                              flags=TestGrep._reflags)
 
2087
        self.assertContainsRe(out, "^dir0/file01.txt~6$",
 
2088
                              flags=TestGrep._reflags)
1847
2089
        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1848
 
        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
 
2090
        self.assertContainsRe(out, "^dir0/file01.txt~7$",
 
2091
                              flags=TestGrep._reflags)
1849
2092
        self.assertEqual(len(out.splitlines()), 5)
1850
2093
 
1851
2094
        # fixed-string
1852
2095
        out, err = self.run_bzr(['grep', '-r', '-1', '-L', 'HELLO'])
1853
2096
 
1854
2097
        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1855
 
        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
 
2098
        self.assertContainsRe(out, "^dir0/file01.txt~7$",
 
2099
                              flags=TestGrep._reflags)
1856
2100
        self.assertEqual(len(out.splitlines()), 2)
1857
2101
 
1858
2102
        # regex
1859
2103
        out, err = self.run_bzr(['grep', '-r', '-1', '-L', 'H.LLO'])
1860
2104
 
1861
2105
        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1862
 
        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
 
2106
        self.assertContainsRe(out, "^dir0/file01.txt~7$",
 
2107
                              flags=TestGrep._reflags)
1863
2108
        self.assertEqual(len(out.splitlines()), 2)
1864
2109
 
1865
2110
        # fixed-string
1866
2111
        out, err = self.run_bzr(['grep', '-L', 'HELLO', '-r', '-1',
1867
 
            'dir0', 'file1.txt'])
 
2112
                                 'dir0', 'file1.txt'])
1868
2113
 
1869
2114
        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1870
 
        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
 
2115
        self.assertContainsRe(out, "^dir0/file01.txt~7$",
 
2116
                              flags=TestGrep._reflags)
1871
2117
        self.assertEqual(len(out.splitlines()), 2)
1872
2118
 
1873
2119
        # regex
1874
2120
        out, err = self.run_bzr(['grep', '-L', 'H.LLO', '-r', '-1',
1875
 
            'dir0', 'file1.txt'])
 
2121
                                 'dir0', 'file1.txt'])
1876
2122
 
1877
2123
        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1878
 
        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
 
2124
        self.assertContainsRe(out, "^dir0/file01.txt~7$",
 
2125
                              flags=TestGrep._reflags)
1879
2126
        self.assertEqual(len(out.splitlines()), 2)
1880
2127
 
1881
2128
        # fixed-string
1882
2129
        out, err = self.run_bzr(['grep', '-L', 'HELLO',
1883
 
            '-r', '-2', 'file1.txt'])
 
2130
                                 '-r', '-2', 'file1.txt'])
1884
2131
 
1885
2132
        self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
1886
2133
        self.assertEqual(len(out.splitlines()), 1)
1887
2134
 
1888
2135
        # regex
1889
2136
        out, err = self.run_bzr(['grep', '-L', 'HE.LO',
1890
 
            '-r', '-2', 'file1.txt'])
 
2137
                                 '-r', '-2', 'file1.txt'])
1891
2138
 
1892
2139
        self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
1893
2140
        self.assertEqual(len(out.splitlines()), 1)
1894
2141
 
1895
2142
        # fixed-string
1896
2143
        out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
1897
 
            '-L', 'HELLO'])
 
2144
                                 '-L', 'HELLO'])
1898
2145
 
1899
2146
        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1900
2147
        self.assertEqual(len(out.splitlines()), 1)
1901
2148
 
1902
2149
        # regex
1903
2150
        out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
1904
 
            '-L', '.ELLO'])
 
2151
                                 '-L', '.ELLO'])
1905
2152
 
1906
2153
        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1907
2154
        self.assertEqual(len(out.splitlines()), 1)
1919
2166
        os.chdir(wd1)
1920
2167
 
1921
2168
        out, err = self.run_bzr(['grep', 'line1'], 3)
1922
 
        self.assertContainsRe(err, "Cannot search working tree", flags=TestGrep._reflags)
 
2169
        self.assertContainsRe(
 
2170
            err, "Cannot search working tree", flags=TestGrep._reflags)
1923
2171
        self.assertEqual(out, '')
1924
2172
 
1925
2173
        out, err = self.run_bzr(['grep', '-r', '1', 'line1'])
1926
 
        self.assertContainsRe(out, "file0.txt~1:line1", flags=TestGrep._reflags)
1927
 
        self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
 
2174
        self.assertContainsRe(out, "file0.txt~1:line1",
 
2175
                              flags=TestGrep._reflags)
 
2176
        self.assertEqual(len(out.splitlines()), 2)  # finds line1 and line10
1928
2177
 
1929
2178
 
1930
2179
class TestNonAscii(GrepTestBase):
1944
2193
        # GZ 2010-06-07: Note we can't actually grep for \u1234 as the pattern
1945
2194
        #                is mangled according to the user encoding.
1946
2195
        streams = self.run_bzr_raw(["grep", "--files-with-matches",
1947
 
            u"contents"], encoding="UTF-8")
 
2196
                                    u"contents"], encoding="UTF-8")
1948
2197
        as_utf8 = as_utf8.encode("UTF-8")
1949
2198
        self.assertEqual(streams, (as_utf8 + b"\n", b""))
1950
2199
 
1951
2200
        streams = self.run_bzr_raw(["grep", "-r", "1", "--files-with-matches",
1952
 
            u"contents"], encoding="UTF-8")
 
2201
                                    u"contents"], encoding="UTF-8")
1953
2202
        self.assertEqual(streams, (as_utf8 + b"~1\n", b""))
1954
2203
 
1955
2204
        fileencoding = osutils.get_user_encoding()
1956
2205
        as_mangled = as_utf8.decode(fileencoding, "replace").encode("UTF-8")
1957
2206
 
1958
2207
        streams = self.run_bzr_raw(["grep", "-n",
1959
 
            u"contents"], encoding="UTF-8")
 
2208
                                    u"contents"], encoding="UTF-8")
1960
2209
        self.assertEqual(streams, (b"%s:1:contents of %s\n" %
1961
 
            (as_utf8, as_mangled), b""))
 
2210
                                   (as_utf8, as_mangled), b""))
1962
2211
 
1963
2212
        streams = self.run_bzr_raw(["grep", "-n", "-r", "1",
1964
 
            u"contents"], encoding="UTF-8")
 
2213
                                    u"contents"], encoding="UTF-8")
1965
2214
        self.assertEqual(streams, (b"%s~1:1:contents of %s\n" %
1966
 
            (as_utf8, as_mangled), b""))
 
2215
                                   (as_utf8, as_mangled), b""))
1967
2216
 
1968
2217
 
1969
2218
class TestColorGrep(GrepTestBase):
1977
2226
        """
1978
2227
        out, err = self.run_bzr(['grep', '--color', 'foo', 'bar'], 3)
1979
2228
        self.assertEqual(out, '')
1980
 
        self.assertContainsRe(err, 'Valid values for --color are', flags=TestGrep._reflags)
 
2229
        self.assertContainsRe(
 
2230
            err, 'Valid values for --color are', flags=TestGrep._reflags)
1981
2231
 
1982
2232
    def test_ver_matching_files(self):
1983
2233
        """(versioned) Search for matches or no matches only"""
1990
2240
        # GZ 2010-06-05: Maybe modify the working tree here
1991
2241
 
1992
2242
        streams = self.run_bzr(["grep", "--color", "always", "-r", "1",
1993
 
            "--files-with-matches", "aaa"])
 
2243
                                "--files-with-matches", "aaa"])
1994
2244
        self.assertEqual(streams, ("".join([
1995
2245
            FG.MAGENTA, "d/aaa", self._rev_sep, "1", "\n"
1996
2246
            ]), ""))
1997
2247
 
1998
2248
        streams = self.run_bzr(["grep", "--color", "always", "-r", "1",
1999
 
            "--files-without-match", "aaa"])
 
2249
                                "--files-without-match", "aaa"])
2000
2250
        self.assertEqual(streams, ("".join([
2001
2251
            FG.MAGENTA, "bbb", self._rev_sep, "1", "\n"
2002
2252
            ]), ""))
2012
2262
        # GZ 2010-06-05: Maybe modify the working tree here
2013
2263
 
2014
2264
        streams = self.run_bzr(["grep", "--color", "always",
2015
 
            "--files-with-matches", "aaa"])
 
2265
                                "--files-with-matches", "aaa"])
2016
2266
        self.assertEqual(streams, ("".join([
2017
2267
            FG.MAGENTA, "d/aaa", FG.NONE, "\n"
2018
2268
            ]), ""))
2019
2269
 
2020
2270
        streams = self.run_bzr(["grep", "--color", "always",
2021
 
            "--files-without-match", "aaa"])
 
2271
                                "--files-without-match", "aaa"])
2022
2272
        self.assertEqual(streams, ("".join([
2023
2273
            FG.MAGENTA, "bbb", FG.NONE, "\n"
2024
2274
            ]), ""))
2035
2285
        # prepare colored result
2036
2286
        foo = color_string('foo', fg=FG.BOLD_RED)
2037
2287
        res = (FG.MAGENTA + 'file0.txt'
2038
 
            + self._rev_sep + '1' + self._sep
2039
 
            + foo + ' is ' + foo + 'bar1' + '\n')
 
2288
               + self._rev_sep + '1' + self._sep
 
2289
               + foo + ' is ' + foo + 'bar1' + '\n')
2040
2290
        txt_res = 'file0.txt~1:foo is foobar1\n'
2041
2291
 
2042
2292
        nres = (FG.MAGENTA + 'file0.txt'
2043
 
            + self._rev_sep + '1' + self._sep + '1' + self._sep
2044
 
            + foo + ' is ' + foo + 'bar1' + '\n')
 
2293
                + self._rev_sep + '1' + self._sep + '1' + self._sep
 
2294
                + foo + ' is ' + foo + 'bar1' + '\n')
2045
2295
 
2046
2296
        out, err = self.run_bzr(['grep', '--color',
2047
 
            'always', '-r', '1', 'foo'])
 
2297
                                 'always', '-r', '1', 'foo'])
2048
2298
        self.assertEqual(out, res)
2049
2299
        self.assertEqual(len(out.splitlines()), 1)
2050
2300
 
2051
2301
        # auto should produce plain text result
2052
2302
        # as stdout is redireched here.
2053
2303
        out, err = self.run_bzr(['grep', '--color',
2054
 
            'auto', '-r', '1', 'foo'])
 
2304
                                 'auto', '-r', '1', 'foo'])
2055
2305
        self.assertEqual(out, txt_res)
2056
2306
        self.assertEqual(len(out.splitlines()), 1)
2057
2307
 
2058
2308
        out, err = self.run_bzr(['grep', '-i', '--color',
2059
 
            'always', '-r', '1', 'FOO'])
 
2309
                                 'always', '-r', '1', 'FOO'])
2060
2310
        self.assertEqual(out, res)
2061
2311
        self.assertEqual(len(out.splitlines()), 1)
2062
2312
 
2063
2313
        out, err = self.run_bzr(['grep', '--color',
2064
 
            'always', '-r', '1', 'f.o'])
 
2314
                                 'always', '-r', '1', 'f.o'])
2065
2315
        self.assertEqual(out, res)
2066
2316
        self.assertEqual(len(out.splitlines()), 1)
2067
2317
 
2068
2318
        out, err = self.run_bzr(['grep', '-i', '--color',
2069
 
            'always', '-r', '1', 'F.O'])
 
2319
                                 'always', '-r', '1', 'F.O'])
2070
2320
        self.assertEqual(out, res)
2071
2321
        self.assertEqual(len(out.splitlines()), 1)
2072
2322
 
2073
2323
        out, err = self.run_bzr(['grep', '-n', '--color',
2074
 
            'always', '-r', '1', 'foo'])
 
2324
                                 'always', '-r', '1', 'foo'])
2075
2325
        self.assertEqual(out, nres)
2076
2326
        self.assertEqual(len(out.splitlines()), 1)
2077
2327
 
2078
2328
        out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2079
 
            'always', '-r', '1', 'FOO'])
 
2329
                                 'always', '-r', '1', 'FOO'])
2080
2330
        self.assertEqual(out, nres)
2081
2331
        self.assertEqual(len(out.splitlines()), 1)
2082
2332
 
2083
2333
        out, err = self.run_bzr(['grep', '-n', '--color',
2084
 
            'always', '-r', '1', 'f.o'])
 
2334
                                 'always', '-r', '1', 'f.o'])
2085
2335
        self.assertEqual(out, nres)
2086
2336
        self.assertEqual(len(out.splitlines()), 1)
2087
2337
 
2088
2338
        out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2089
 
            'always', '-r', '1', 'F.O'])
 
2339
                                 'always', '-r', '1', 'F.O'])
2090
2340
        self.assertEqual(out, nres)
2091
2341
        self.assertEqual(len(out.splitlines()), 1)
2092
2342
 
2102
2352
        # prepare colored result
2103
2353
        foo = color_string('foo', fg=FG.BOLD_RED)
2104
2354
        res = (FG.MAGENTA + 'file0.txt'
2105
 
            + self._sep + foo + ' is ' + foo + 'bar1' + '\n')
 
2355
               + self._sep + foo + ' is ' + foo + 'bar1' + '\n')
2106
2356
 
2107
2357
        nres = (FG.MAGENTA + 'file0.txt'
2108
 
            + self._sep + '1' + self._sep
2109
 
            + foo + ' is ' + foo + 'bar1' + '\n')
2110
 
 
2111
 
        out, err = self.run_bzr(['grep', '--color',
2112
 
            'always', 'foo'])
2113
 
        self.assertEqual(out, res)
2114
 
        self.assertEqual(len(out.splitlines()), 1)
2115
 
 
2116
 
        out, err = self.run_bzr(['grep', '-i', '--color',
2117
 
            'always', 'FOO'])
2118
 
        self.assertEqual(out, res)
2119
 
        self.assertEqual(len(out.splitlines()), 1)
2120
 
 
2121
 
        out, err = self.run_bzr(['grep', '--color',
2122
 
            'always', 'f.o'])
2123
 
        self.assertEqual(out, res)
2124
 
        self.assertEqual(len(out.splitlines()), 1)
2125
 
 
2126
 
        out, err = self.run_bzr(['grep', '-i', '--color',
2127
 
            'always', 'F.O'])
2128
 
        self.assertEqual(out, res)
2129
 
        self.assertEqual(len(out.splitlines()), 1)
2130
 
 
2131
 
        out, err = self.run_bzr(['grep', '-n', '--color',
2132
 
            'always', 'foo'])
2133
 
        self.assertEqual(out, nres)
2134
 
        self.assertEqual(len(out.splitlines()), 1)
2135
 
 
2136
 
        out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2137
 
            'always', 'FOO'])
2138
 
        self.assertEqual(out, nres)
2139
 
        self.assertEqual(len(out.splitlines()), 1)
2140
 
 
2141
 
        out, err = self.run_bzr(['grep', '-n', '--color',
2142
 
            'always', 'f.o'])
2143
 
        self.assertEqual(out, nres)
2144
 
        self.assertEqual(len(out.splitlines()), 1)
2145
 
 
2146
 
        out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2147
 
            'always', 'F.O'])
 
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'])
2148
2398
        self.assertEqual(out, nres)
2149
2399
        self.assertEqual(len(out.splitlines()), 1)
2150
2400
 
2206
2456
    def test_grep_diff_revision_range(self):
2207
2457
        """grep -p revision range."""
2208
2458
        tree = self.make_example_branch()
2209
 
        self.build_tree_contents([('hello', b'hello world!1\n')]) # rev 3
 
2459
        self.build_tree_contents([('hello', b'hello world!1\n')])  # rev 3
2210
2460
        tree.commit('rev3')
2211
 
        self.build_tree_contents([('blah', b'hello world!2\n')]) # rev 4
 
2461
        self.build_tree_contents([('blah', b'hello world!2\n')])  # rev 4
2212
2462
        tree.add('blah')
2213
2463
        tree.commit('rev4')
2214
2464
        with open('hello', 'a') as f:
2215
2465
            f.write('hello world!3\n')
2216
 
        #self.build_tree_contents([('hello', 'hello world!3\n')]) # rev 5
 
2466
        # self.build_tree_contents([('hello', 'hello world!3\n')]) # rev 5
2217
2467
        tree.commit('rev5')
2218
2468
        out, err = self.run_bzr(['grep', '-p', '-r', '2..5', 'hello'])
2219
2469
        self.assertEqual(err, '')
2239
2489
        self.build_tree_contents([('hello', b'hello world!\n')])
2240
2490
        tree.commit('updated hello')
2241
2491
        out, err = self.run_bzr(['grep', '--diff', '-r', '3',
2242
 
            '--color', 'always', 'hello'])
 
2492
                                 '--color', 'always', 'hello'])
2243
2493
        self.assertEqual(err, '')
2244
2494
        revno = color_string('=== revno:3 ===', fg=FG.BOLD_BLUE) + '\n'
2245
 
        filename = color_string("  === modified file 'hello'", fg=FG.BOLD_MAGENTA) + '\n'
 
2495
        filename = color_string(
 
2496
            "  === modified file 'hello'", fg=FG.BOLD_MAGENTA) + '\n'
2246
2497
        redhello = color_string('hello', fg=FG.BOLD_RED)
2247
2498
        diffstr = '''\
2248
2499
    --- hello   YYYY-MM-DD HH:MM:SS +ZZZZ
2257
2508
        out, err = self.run_bzr(['init'])
2258
2509
        out, err = self.run_bzr(['grep', '--diff', 'foo'], 3)
2259
2510
        self.assertEqual(out, '')
2260
 
        self.assertContainsRe(err, "ERROR:.*revision.* does not exist in branch")
 
2511
        self.assertContainsRe(
 
2512
            err, "ERROR:.*revision.* does not exist in branch")