/brz/remove-bazaar

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

« back to all changes in this revision

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

  • Committer: Jelmer Vernooij
  • Date: 2017-07-23 22:06:41 UTC
  • mfrom: (6738 trunk)
  • mto: This revision was merged to the branch mainline in revision 6739.
  • Revision ID: jelmer@jelmer.uk-20170723220641-69eczax9bmv8d6kk
Merge trunk, address review comments.

Show diffs side-by-side

added added

removed removed

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