/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/tests/test_grep.py

  • Committer: Jelmer Vernooij
  • Date: 2020-05-06 02:13:25 UTC
  • mfrom: (7490.7.21 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200506021325-awbmmqu1zyorz7sj
Merge 3.1 branch.

Show diffs side-by-side

added added

removed removed

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