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
- browse files at revision 7039
- compare with another revision
- compare with revision 7490.7.6
- download diff
- download tarball
- view history from revision 7039
- Committer: Breezy landing bot
- Author(s): Jelmer Vernooij
- Date: 2018-07-14 19:47:11 UTC
- mfrom: (7027.4.12 python3-blackbox)
- Revision ID: breezy.the.bot@gmail.com-20180714194711-h73vd0gzphiab6vf
Change run_bzr to use StringIOWithEncoding for stderr and stdout on python 3.
Merged from https://code.launchpad.net/~jelmer/brz/python3-blackbox/+merge/349090
Merged from https://code.launchpad.net/~jelmer/brz/python3-blackbox/+merge/349090
- files modified:
- breezy/builtins.py
added
removed
breezy/plugins/grep/test_grep.py
89
89
self._mk_unknown_file('file0.txt')
90
90
91
91
out, err = self.run_bzr(['grep', 'line1', 'file0.txt'])
92
self.assertContainsRe(out, b"file0.txt:line1", flags=TestGrep._reflags)
92
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
93
93
self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
94
94
95
95
out, err = self.run_bzr(['grep', 'line\\d+', 'file0.txt'])
96
self.assertContainsRe(out, b"file0.txt:line1", flags=TestGrep._reflags)
96
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
97
97
self.assertEqual(len(out.splitlines()), 10)
98
98
99
99
# unknown file is not grepped unless explicitely specified
100
100
out, err = self.run_bzr(['grep', 'line1'])
101
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
101
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
102
102
self.assertEqual(len(out.splitlines()), 0)
103
103
104
104
# unknown file is not grepped unless explicitely specified
105
105
out, err = self.run_bzr(['grep', 'line1$'])
106
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
106
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
107
107
self.assertEqual(len(out.splitlines()), 0)
108
108
109
109
def test_ver_basic_file(self):
115
115
self._mk_versioned_file('file0.txt')
116
116
117
117
out, err = self.run_bzr(['grep', '-r', '1', 'line1', 'file0.txt'])
118
self.assertContainsRe(out, b"file0.txt~1:line1", flags=TestGrep._reflags)
118
self.assertContainsRe(out, "file0.txt~1:line1", flags=TestGrep._reflags)
119
119
self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
120
120
121
121
out, err = self.run_bzr(['grep', '-r', '1', 'line[0-9]$', 'file0.txt'])
122
self.assertContainsRe(out, b"file0.txt~1:line1", flags=TestGrep._reflags)
122
self.assertContainsRe(out, "file0.txt~1:line1", flags=TestGrep._reflags)
123
123
self.assertEqual(len(out.splitlines()), 9)
124
124
125
125
# finds all the lines
126
126
out, err = self.run_bzr(['grep', '-r', '1', 'line[0-9]', 'file0.txt'])
127
self.assertContainsRe(out, b"file0.txt~1:line1", flags=TestGrep._reflags)
127
self.assertContainsRe(out, "file0.txt~1:line1", flags=TestGrep._reflags)
128
128
self.assertEqual(len(out.splitlines()), 10)
129
129
130
130
def test_wtree_basic_file(self):
137
137
self._update_file('file0.txt', 'ABC\n', checkin=False)
138
138
139
139
out, err = self.run_bzr(['grep', 'ABC', 'file0.txt'])
140
self.assertContainsRe(out, b"file0.txt:ABC", flags=TestGrep._reflags)
140
self.assertContainsRe(out, "file0.txt:ABC", flags=TestGrep._reflags)
141
141
self.assertEqual(len(out.splitlines()), 1)
142
142
143
143
out, err = self.run_bzr(['grep', '[A-Z]{3}', 'file0.txt'])
144
self.assertContainsRe(out, b"file0.txt:ABC", flags=TestGrep._reflags)
144
self.assertContainsRe(out, "file0.txt:ABC", flags=TestGrep._reflags)
145
145
self.assertEqual(len(out.splitlines()), 1)
146
146
147
147
out, err = self.run_bzr(['grep', '-r', 'last:1', 'ABC', 'file0.txt'])
148
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
148
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
149
149
self.assertEqual(len(out.splitlines()), 0)
150
150
151
151
out, err = self.run_bzr(['grep', '-r', 'last:1', '[A-Z]{3}', 'file0.txt'])
152
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
152
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
153
153
self.assertEqual(len(out.splitlines()), 0)
154
154
155
155
def test_ver_basic_include(self):
164
164
165
165
out, err = self.run_bzr(['grep', '-r', 'last:1',
166
166
'--include', '*.aa', '--include', '*.bb', 'line1'])
167
self.assertContainsRe(out, b"file0.aa~.:line1", flags=TestGrep._reflags)
168
self.assertContainsRe(out, b"file0.bb~.:line1", flags=TestGrep._reflags)
169
self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
167
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
168
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
169
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
170
170
# two lines each (line1, line10) from file0.aa and file0.bb
171
171
self.assertEqual(len(out.splitlines()), 4)
172
172
173
173
out, err = self.run_bzr(['grep', '-r', 'last:1',
174
174
'--include', '*.aa', '--include', '*.bb', 'line1$'])
175
self.assertContainsRe(out, b"file0.aa~.:line1", flags=TestGrep._reflags)
176
self.assertContainsRe(out, b"file0.bb~.:line1", flags=TestGrep._reflags)
177
self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
175
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
176
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
177
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
178
178
# one lines each (line1) from file0.aa and file0.bb
179
179
self.assertEqual(len(out.splitlines()), 2)
180
180
181
181
out, err = self.run_bzr(['grep', '-r', 'last:1',
182
182
'-I', '*.aa', '-I', '*.bb', 'line1'])
183
self.assertContainsRe(out, b"file0.aa~.:line1", flags=TestGrep._reflags)
184
self.assertContainsRe(out, b"file0.bb~.:line1", flags=TestGrep._reflags)
185
self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
183
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
184
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
185
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
186
186
# two lines each (line1, line10) from file0.aa and file0.bb
187
187
self.assertEqual(len(out.splitlines()), 4)
188
188
189
189
out, err = self.run_bzr(['grep', '-r', 'last:1',
190
190
'-I', '*.aa', '-I', '*.bb', 'line1$'])
191
self.assertContainsRe(out, b"file0.aa~.:line1", flags=TestGrep._reflags)
192
self.assertContainsRe(out, b"file0.bb~.:line1", flags=TestGrep._reflags)
193
self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
191
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
192
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
193
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
194
194
# one lines each (line1) from file0.aa and file0.bb
195
195
self.assertEqual(len(out.splitlines()), 2)
196
196
206
206
207
207
out, err = self.run_bzr(['grep', '--include', '*.aa',
208
208
'--include', '*.bb', 'line1'])
209
self.assertContainsRe(out, b"file0.aa:line1", flags=TestGrep._reflags)
210
self.assertContainsRe(out, b"file0.bb:line1", flags=TestGrep._reflags)
211
self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
209
self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
210
self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
211
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
212
212
# two lines each (line1, line10) from file0.aa and file0.bb
213
213
self.assertEqual(len(out.splitlines()), 4)
214
214
215
215
out, err = self.run_bzr(['grep', '--include', '*.aa',
216
216
'--include', '*.bb', 'line1$'])
217
self.assertContainsRe(out, b"file0.aa:line1", flags=TestGrep._reflags)
218
self.assertContainsRe(out, b"file0.bb:line1", flags=TestGrep._reflags)
219
self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
217
self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
218
self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
219
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
220
220
# one line each (line1) from file0.aa and file0.bb
221
221
self.assertEqual(len(out.splitlines()), 2)
222
222
232
232
233
233
out, err = self.run_bzr(['grep', '-r', 'last:1',
234
234
'--exclude', '*.cc', 'line1'])
235
self.assertContainsRe(out, b"file0.aa~.:line1$", flags=TestGrep._reflags)
236
self.assertContainsRe(out, b"file0.bb~.:line1$", flags=TestGrep._reflags)
237
self.assertContainsRe(out, b"file0.aa~.:line10", flags=TestGrep._reflags)
238
self.assertContainsRe(out, b"file0.bb~.:line10", flags=TestGrep._reflags)
239
self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
235
self.assertContainsRe(out, "file0.aa~.:line1$", flags=TestGrep._reflags)
236
self.assertContainsRe(out, "file0.bb~.:line1$", flags=TestGrep._reflags)
237
self.assertContainsRe(out, "file0.aa~.:line10", flags=TestGrep._reflags)
238
self.assertContainsRe(out, "file0.bb~.:line10", flags=TestGrep._reflags)
239
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
240
240
# two lines each (line1, line10) from file0.aa and file0.bb
241
241
self.assertEqual(len(out.splitlines()), 4)
242
242
243
243
out, err = self.run_bzr(['grep', '-r', 'last:1',
244
244
'--exclude', '*.cc', 'line1$'])
245
self.assertContainsRe(out, b"file0.aa~.:line1", flags=TestGrep._reflags)
246
self.assertContainsRe(out, b"file0.bb~.:line1", flags=TestGrep._reflags)
247
self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
245
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
246
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
247
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
248
248
# one line each (line1) from file0.aa and file0.bb
249
249
self.assertEqual(len(out.splitlines()), 2)
250
250
251
251
out, err = self.run_bzr(['grep', '-r', 'last:1',
252
252
'-X', '*.cc', 'line1'])
253
self.assertContainsRe(out, b"file0.aa~.:line1", flags=TestGrep._reflags)
254
self.assertContainsRe(out, b"file0.bb~.:line1", flags=TestGrep._reflags)
255
self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
253
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
254
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
255
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
256
256
# two lines each (line1, line10) from file0.aa and file0.bb
257
257
self.assertEqual(len(out.splitlines()), 4)
258
258
267
267
self._mk_versioned_file('file0.cc')
268
268
269
269
out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'line1'])
270
self.assertContainsRe(out, b"file0.aa:line1", flags=TestGrep._reflags)
271
self.assertContainsRe(out, b"file0.bb:line1", flags=TestGrep._reflags)
272
self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
270
self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
271
self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
272
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
273
273
# two lines each (line1, line10) from file0.aa and file0.bb
274
274
self.assertEqual(len(out.splitlines()), 4)
275
275
276
276
out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'lin.1$'])
277
self.assertContainsRe(out, b"file0.aa:line1", flags=TestGrep._reflags)
278
self.assertContainsRe(out, b"file0.bb:line1", flags=TestGrep._reflags)
279
self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
277
self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
278
self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
279
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
280
280
# one line each (line1) from file0.aa and file0.bb
281
281
self.assertEqual(len(out.splitlines()), 2)
282
282
291
291
self._mk_versioned_file('file2.txt', total_lines=2)
292
292
293
293
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line[1-2]$'])
294
self.assertContainsRe(out, b"file0.txt~.:line1", flags=TestGrep._reflags)
295
self.assertContainsRe(out, b"file0.txt~.:line2", flags=TestGrep._reflags)
296
self.assertContainsRe(out, b"file1.txt~.:line1", flags=TestGrep._reflags)
297
self.assertContainsRe(out, b"file1.txt~.:line2", flags=TestGrep._reflags)
298
self.assertContainsRe(out, b"file2.txt~.:line1", flags=TestGrep._reflags)
299
self.assertContainsRe(out, b"file2.txt~.:line2", flags=TestGrep._reflags)
294
self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
295
self.assertContainsRe(out, "file0.txt~.:line2", flags=TestGrep._reflags)
296
self.assertContainsRe(out, "file1.txt~.:line1", flags=TestGrep._reflags)
297
self.assertContainsRe(out, "file1.txt~.:line2", flags=TestGrep._reflags)
298
self.assertContainsRe(out, "file2.txt~.:line1", flags=TestGrep._reflags)
299
self.assertContainsRe(out, "file2.txt~.:line2", flags=TestGrep._reflags)
300
300
self.assertEqual(len(out.splitlines()), 6)
301
301
302
302
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line'])
303
self.assertContainsRe(out, b"file0.txt~.:line1", flags=TestGrep._reflags)
304
self.assertContainsRe(out, b"file0.txt~.:line2", flags=TestGrep._reflags)
305
self.assertContainsRe(out, b"file1.txt~.:line1", flags=TestGrep._reflags)
306
self.assertContainsRe(out, b"file1.txt~.:line2", flags=TestGrep._reflags)
307
self.assertContainsRe(out, b"file2.txt~.:line1", flags=TestGrep._reflags)
308
self.assertContainsRe(out, b"file2.txt~.:line2", flags=TestGrep._reflags)
303
self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
304
self.assertContainsRe(out, "file0.txt~.:line2", flags=TestGrep._reflags)
305
self.assertContainsRe(out, "file1.txt~.:line1", flags=TestGrep._reflags)
306
self.assertContainsRe(out, "file1.txt~.:line2", flags=TestGrep._reflags)
307
self.assertContainsRe(out, "file2.txt~.:line1", flags=TestGrep._reflags)
308
self.assertContainsRe(out, "file2.txt~.:line2", flags=TestGrep._reflags)
309
309
self.assertEqual(len(out.splitlines()), 6)
310
310
311
311
def test_multiple_wtree_files(self):
324
324
out, err = self.run_bzr(['grep', 'HELLO',
325
325
'file0.txt', 'file1.txt', 'file2.txt'])
326
326
327
self.assertContainsRe(out, b"file0.txt:HELLO", flags=TestGrep._reflags)
328
self.assertContainsRe(out, b"file1.txt:HELLO", flags=TestGrep._reflags)
329
self.assertContainsRe(out, b"file2.txt:HELLO", flags=TestGrep._reflags)
327
self.assertContainsRe(out, "file0.txt:HELLO", flags=TestGrep._reflags)
328
self.assertContainsRe(out, "file1.txt:HELLO", flags=TestGrep._reflags)
329
self.assertContainsRe(out, "file2.txt:HELLO", flags=TestGrep._reflags)
330
330
self.assertEqual(len(out.splitlines()), 3)
331
331
332
332
out, err = self.run_bzr(['grep', 'HELLO', '-r', 'last:1',
333
333
'file0.txt', 'file1.txt', 'file2.txt'])
334
334
335
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
336
self.assertContainsRe(out, b"file1.txt~.:HELLO", flags=TestGrep._reflags)
337
self.assertNotContainsRe(out, b"file2.txt", flags=TestGrep._reflags)
335
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
336
self.assertContainsRe(out, "file1.txt~.:HELLO", flags=TestGrep._reflags)
337
self.assertNotContainsRe(out, "file2.txt", flags=TestGrep._reflags)
338
338
self.assertEqual(len(out.splitlines()), 1)
339
339
340
340
out, err = self.run_bzr(['grep', 'HE..O',
341
341
'file0.txt', 'file1.txt', 'file2.txt'])
342
342
343
self.assertContainsRe(out, b"file0.txt:HELLO", flags=TestGrep._reflags)
344
self.assertContainsRe(out, b"file1.txt:HELLO", flags=TestGrep._reflags)
345
self.assertContainsRe(out, b"file2.txt:HELLO", flags=TestGrep._reflags)
343
self.assertContainsRe(out, "file0.txt:HELLO", flags=TestGrep._reflags)
344
self.assertContainsRe(out, "file1.txt:HELLO", flags=TestGrep._reflags)
345
self.assertContainsRe(out, "file2.txt:HELLO", flags=TestGrep._reflags)
346
346
self.assertEqual(len(out.splitlines()), 3)
347
347
348
348
out, err = self.run_bzr(['grep', 'HE..O', '-r', 'last:1',
349
349
'file0.txt', 'file1.txt', 'file2.txt'])
350
350
351
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
352
self.assertContainsRe(out, b"file1.txt~.:HELLO", flags=TestGrep._reflags)
353
self.assertNotContainsRe(out, b"file2.txt", flags=TestGrep._reflags)
351
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
352
self.assertContainsRe(out, "file1.txt~.:HELLO", flags=TestGrep._reflags)
353
self.assertNotContainsRe(out, "file2.txt", flags=TestGrep._reflags)
354
354
self.assertEqual(len(out.splitlines()), 1)
355
355
356
356
def test_ver_null_option(self):
408
408
self._mk_versioned_file('dir0/file0.txt')
409
409
410
410
out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1'])
411
self.assertNotContainsRe(out, b"file0.txt~.:line1", flags=TestGrep._reflags)
411
self.assertNotContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
412
412
self.assertEqual(len(out.splitlines()), 0)
413
413
414
414
out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1$'])
415
self.assertNotContainsRe(out, b"file0.txt~.:line1", flags=TestGrep._reflags)
415
self.assertNotContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
416
416
self.assertEqual(len(out.splitlines()), 0)
417
417
418
418
def test_wtree_file_in_dir_no_recursive(self):
425
425
self._mk_versioned_file('dir0/file0.txt')
426
426
427
427
out, err = self.run_bzr(['grep', '--no-recursive', 'line1'])
428
self.assertNotContainsRe(out, b"file0.txt:line1", flags=TestGrep._reflags)
428
self.assertNotContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
429
429
self.assertEqual(len(out.splitlines()), 0)
430
430
431
431
out, err = self.run_bzr(['grep', '--no-recursive', 'lin.1'])
432
self.assertNotContainsRe(out, b"file0.txt:line1", flags=TestGrep._reflags)
432
self.assertNotContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
433
433
self.assertEqual(len(out.splitlines()), 0)
434
434
435
435
def test_versioned_file_in_dir_recurse(self):
442
442
self._mk_versioned_file('dir0/file0.txt')
443
443
444
444
out, err = self.run_bzr(['grep', '-r', '-1', '.i.e1'])
445
self.assertContainsRe(out, b"^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
445
self.assertContainsRe(out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
446
446
# find line1 and line10
447
447
self.assertEqual(len(out.splitlines()), 2)
448
448
449
449
out, err = self.run_bzr(['grep', '-r', '-1', 'line1'])
450
self.assertContainsRe(out, b"^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
450
self.assertContainsRe(out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
451
451
# find line1 and line10
452
452
self.assertEqual(len(out.splitlines()), 2)
453
453
461
461
self._mk_versioned_file('dir0/file0.txt')
462
462
463
463
out, err = self.run_bzr(['grep', 'line1'])
464
self.assertContainsRe(out, b"^dir0/file0.txt:line1", flags=TestGrep._reflags)
464
self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
465
465
# find line1 and line10
466
466
self.assertEqual(len(out.splitlines()), 2)
467
467
468
468
out, err = self.run_bzr(['grep', 'lin.1'])
469
self.assertContainsRe(out, b"^dir0/file0.txt:line1", flags=TestGrep._reflags)
469
self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
470
470
# find line1 and line10
471
471
self.assertEqual(len(out.splitlines()), 2)
472
472
481
481
os.chdir('dir0')
482
482
483
483
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
484
self.assertContainsRe(out, b"^file0.txt~.:line1", flags=TestGrep._reflags)
484
self.assertContainsRe(out, "^file0.txt~.:line1", flags=TestGrep._reflags)
485
485
# finds line1 and line10
486
486
self.assertEqual(len(out.splitlines()), 2)
487
487
488
488
out, err = self.run_bzr(['grep', '-r', 'last:1', '.i.e1'])
489
self.assertContainsRe(out, b"^file0.txt~.:line1", flags=TestGrep._reflags)
489
self.assertContainsRe(out, "^file0.txt~.:line1", flags=TestGrep._reflags)
490
490
# finds line1 and line10
491
491
self.assertEqual(len(out.splitlines()), 2)
492
492
505
505
506
506
out, err = self.run_bzr(['grep', '-r', 'last:1',
507
507
'--include', '*.aa', 'line1'])
508
self.assertContainsRe(out, b"^file1.aa~5:line1$", flags=TestGrep._reflags)
509
self.assertContainsRe(out, b"^file1.aa~5:line10$", flags=TestGrep._reflags)
510
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
508
self.assertContainsRe(out, "^file1.aa~5:line1$", flags=TestGrep._reflags)
509
self.assertContainsRe(out, "^file1.aa~5:line10$", flags=TestGrep._reflags)
510
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
511
511
# finds line1 and line10
512
512
self.assertEqual(len(out.splitlines()), 2)
513
513
514
514
out, err = self.run_bzr(['grep', '-r', 'last:2..last:1',
515
515
'--include', '*.aa', 'line1'])
516
self.assertContainsRe(out, b"^file1.aa~4:line1$", flags=TestGrep._reflags)
517
self.assertContainsRe(out, b"^file1.aa~4:line10$", flags=TestGrep._reflags)
518
self.assertContainsRe(out, b"^file1.aa~5:line1$", flags=TestGrep._reflags)
519
self.assertContainsRe(out, b"^file1.aa~5:line10$", flags=TestGrep._reflags)
520
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
516
self.assertContainsRe(out, "^file1.aa~4:line1$", flags=TestGrep._reflags)
517
self.assertContainsRe(out, "^file1.aa~4:line10$", flags=TestGrep._reflags)
518
self.assertContainsRe(out, "^file1.aa~5:line1$", flags=TestGrep._reflags)
519
self.assertContainsRe(out, "^file1.aa~5:line10$", flags=TestGrep._reflags)
520
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
521
521
# finds line1 and line10 over two revisions
522
522
self.assertEqual(len(out.splitlines()), 4)
523
523
524
524
out, err = self.run_bzr(['grep', '-r', 'last:1',
525
525
'--include', '*.aa', 'lin.1'])
526
self.assertContainsRe(out, b"^file1.aa~5:line1$", flags=TestGrep._reflags)
527
self.assertContainsRe(out, b"^file1.aa~5:line10$", flags=TestGrep._reflags)
528
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
526
self.assertContainsRe(out, "^file1.aa~5:line1$", flags=TestGrep._reflags)
527
self.assertContainsRe(out, "^file1.aa~5:line10$", flags=TestGrep._reflags)
528
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
529
529
# finds line1 and line10
530
530
self.assertEqual(len(out.splitlines()), 2)
531
531
532
532
out, err = self.run_bzr(['grep', '-r', 'last:3..last:1',
533
533
'--include', '*.aa', 'lin.1'])
534
self.assertContainsRe(out, b"^file1.aa~3:line1$", flags=TestGrep._reflags)
535
self.assertContainsRe(out, b"^file1.aa~4:line1$", flags=TestGrep._reflags)
536
self.assertContainsRe(out, b"^file1.aa~5:line1$", flags=TestGrep._reflags)
537
self.assertContainsRe(out, b"^file1.aa~3:line10$", flags=TestGrep._reflags)
538
self.assertContainsRe(out, b"^file1.aa~4:line10$", flags=TestGrep._reflags)
539
self.assertContainsRe(out, b"^file1.aa~5:line10$", flags=TestGrep._reflags)
540
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
534
self.assertContainsRe(out, "^file1.aa~3:line1$", flags=TestGrep._reflags)
535
self.assertContainsRe(out, "^file1.aa~4:line1$", flags=TestGrep._reflags)
536
self.assertContainsRe(out, "^file1.aa~5:line1$", flags=TestGrep._reflags)
537
self.assertContainsRe(out, "^file1.aa~3:line10$", flags=TestGrep._reflags)
538
self.assertContainsRe(out, "^file1.aa~4:line10$", flags=TestGrep._reflags)
539
self.assertContainsRe(out, "^file1.aa~5:line10$", flags=TestGrep._reflags)
540
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
541
541
# finds line1 and line10 over 3 revisions
542
542
self.assertEqual(len(out.splitlines()), 6)
543
543
554
554
555
555
out, err = self.run_bzr(['grep', '-r', 'last:1',
556
556
'--exclude', '*.txt', 'line1'])
557
self.assertContainsRe(out, b"^file1.aa~.:line1", flags=TestGrep._reflags)
558
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
557
self.assertContainsRe(out, "^file1.aa~.:line1", flags=TestGrep._reflags)
558
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
559
559
# finds line1 and line10
560
560
self.assertEqual(len(out.splitlines()), 2)
561
561
562
562
out, err = self.run_bzr(['grep', '-r', 'last:1',
563
563
'--exclude', '*.txt', 'l[a-z]ne1'])
564
self.assertContainsRe(out, b"^file1.aa~.:line1", flags=TestGrep._reflags)
565
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
564
self.assertContainsRe(out, "^file1.aa~.:line1", flags=TestGrep._reflags)
565
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
566
566
# finds line1 and line10
567
567
self.assertEqual(len(out.splitlines()), 2)
568
568
577
577
os.chdir('dir0')
578
578
579
579
out, err = self.run_bzr(['grep', 'line1'])
580
self.assertContainsRe(out, b"^file0.txt:line1", flags=TestGrep._reflags)
580
self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
581
581
# finds line1 and line10
582
582
self.assertEqual(len(out.splitlines()), 2)
583
583
584
584
out, err = self.run_bzr(['grep', 'l[aeiou]ne1'])
585
self.assertContainsRe(out, b"^file0.txt:line1", flags=TestGrep._reflags)
585
self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
586
586
# finds line1 and line10
587
587
self.assertEqual(len(out.splitlines()), 2)
588
588
598
598
os.chdir('dir0')
599
599
600
600
out, err = self.run_bzr(['grep', '--include', '*.aa', 'line1'])
601
self.assertContainsRe(out, b"^file1.aa:line1", flags=TestGrep._reflags)
601
self.assertContainsRe(out, "^file1.aa:line1", flags=TestGrep._reflags)
602
602
# finds line1 and line10
603
603
self.assertEqual(len(out.splitlines()), 2)
604
604
605
605
out, err = self.run_bzr(['grep', '--include', '*.aa', 'l[ixn]ne1'])
606
self.assertContainsRe(out, b"^file1.aa:line1", flags=TestGrep._reflags)
607
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
606
self.assertContainsRe(out, "^file1.aa:line1", flags=TestGrep._reflags)
607
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
608
608
# finds line1 and line10
609
609
self.assertEqual(len(out.splitlines()), 2)
610
610
620
620
os.chdir('dir0')
621
621
622
622
out, err = self.run_bzr(['grep', '--exclude', '*.txt', 'li.e1'])
623
self.assertContainsRe(out, b"^file1.aa:line1$", flags=TestGrep._reflags)
624
self.assertContainsRe(out, b"^file1.aa:line10$", flags=TestGrep._reflags)
625
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
623
self.assertContainsRe(out, "^file1.aa:line1$", flags=TestGrep._reflags)
624
self.assertContainsRe(out, "^file1.aa:line10$", flags=TestGrep._reflags)
625
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
626
626
# finds line1 and line10
627
627
self.assertEqual(len(out.splitlines()), 2)
628
628
629
629
out, err = self.run_bzr(['grep', '--exclude', '*.txt', 'line1'])
630
self.assertContainsRe(out, b"^file1.aa:line1$", flags=TestGrep._reflags)
631
self.assertContainsRe(out, b"^file1.aa:line10$", flags=TestGrep._reflags)
632
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
630
self.assertContainsRe(out, "^file1.aa:line1$", flags=TestGrep._reflags)
631
self.assertContainsRe(out, "^file1.aa:line10$", flags=TestGrep._reflags)
632
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
633
633
# finds line1 and line10
634
634
self.assertEqual(len(out.splitlines()), 2)
635
635
651
651
652
652
out, err = self.run_bzr(['grep', '-r', 'last:1',
653
653
'--include', '*.aa', '--include', '*.bb', 'l..e1'])
654
self.assertContainsRe(out, b"^dir0/file0.aa~.:line1$", flags=TestGrep._reflags)
655
self.assertContainsRe(out, b"^dir1/file1.bb~.:line1$", flags=TestGrep._reflags)
656
self.assertContainsRe(out, b"^dir0/file0.aa~.:line10$", flags=TestGrep._reflags)
657
self.assertContainsRe(out, b"^dir1/file1.bb~.:line10$", flags=TestGrep._reflags)
658
self.assertNotContainsRe(out, b"file1.cc", flags=TestGrep._reflags)
654
self.assertContainsRe(out, "^dir0/file0.aa~.:line1$", flags=TestGrep._reflags)
655
self.assertContainsRe(out, "^dir1/file1.bb~.:line1$", flags=TestGrep._reflags)
656
self.assertContainsRe(out, "^dir0/file0.aa~.:line10$", flags=TestGrep._reflags)
657
self.assertContainsRe(out, "^dir1/file1.bb~.:line10$", flags=TestGrep._reflags)
658
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
659
659
# finds line1 and line10
660
660
self.assertEqual(len(out.splitlines()), 4)
661
661
662
662
out, err = self.run_bzr(['grep', '-r', 'last:1',
663
663
'--include', '*.aa', '--include', '*.bb', 'line1'])
664
self.assertContainsRe(out, b"^dir0/file0.aa~.:line1$", flags=TestGrep._reflags)
665
self.assertContainsRe(out, b"^dir1/file1.bb~.:line1$", flags=TestGrep._reflags)
666
self.assertContainsRe(out, b"^dir0/file0.aa~.:line10$", flags=TestGrep._reflags)
667
self.assertContainsRe(out, b"^dir1/file1.bb~.:line10$", flags=TestGrep._reflags)
668
self.assertNotContainsRe(out, b"file1.cc", flags=TestGrep._reflags)
664
self.assertContainsRe(out, "^dir0/file0.aa~.:line1$", flags=TestGrep._reflags)
665
self.assertContainsRe(out, "^dir1/file1.bb~.:line1$", flags=TestGrep._reflags)
666
self.assertContainsRe(out, "^dir0/file0.aa~.:line10$", flags=TestGrep._reflags)
667
self.assertContainsRe(out, "^dir1/file1.bb~.:line10$", flags=TestGrep._reflags)
668
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
669
669
# finds line1 and line10
670
670
self.assertEqual(len(out.splitlines()), 4)
671
671
687
687
688
688
out, err = self.run_bzr(['grep', '--include', '*.aa',
689
689
'--include', '*.bb', 'l.n.1'])
690
self.assertContainsRe(out, b"^dir0/file0.aa:line1$", flags=TestGrep._reflags)
691
self.assertContainsRe(out, b"^dir1/file1.bb:line1$", flags=TestGrep._reflags)
692
self.assertContainsRe(out, b"^dir0/file0.aa:line10$", flags=TestGrep._reflags)
693
self.assertContainsRe(out, b"^dir1/file1.bb:line10$", flags=TestGrep._reflags)
694
self.assertNotContainsRe(out, b"file1.cc", flags=TestGrep._reflags)
690
self.assertContainsRe(out, "^dir0/file0.aa:line1$", flags=TestGrep._reflags)
691
self.assertContainsRe(out, "^dir1/file1.bb:line1$", flags=TestGrep._reflags)
692
self.assertContainsRe(out, "^dir0/file0.aa:line10$", flags=TestGrep._reflags)
693
self.assertContainsRe(out, "^dir1/file1.bb:line10$", flags=TestGrep._reflags)
694
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
695
695
# finds line1 and line10
696
696
self.assertEqual(len(out.splitlines()), 4)
697
697
698
698
out, err = self.run_bzr(['grep', '--include', '*.aa',
699
699
'--include', '*.bb', 'line1'])
700
self.assertContainsRe(out, b"^dir0/file0.aa:line1$", flags=TestGrep._reflags)
701
self.assertContainsRe(out, b"^dir1/file1.bb:line1$", flags=TestGrep._reflags)
702
self.assertContainsRe(out, b"^dir0/file0.aa:line10$", flags=TestGrep._reflags)
703
self.assertContainsRe(out, b"^dir1/file1.bb:line10$", flags=TestGrep._reflags)
704
self.assertNotContainsRe(out, b"file1.cc", flags=TestGrep._reflags)
700
self.assertContainsRe(out, "^dir0/file0.aa:line1$", flags=TestGrep._reflags)
701
self.assertContainsRe(out, "^dir1/file1.bb:line1$", flags=TestGrep._reflags)
702
self.assertContainsRe(out, "^dir0/file0.aa:line10$", flags=TestGrep._reflags)
703
self.assertContainsRe(out, "^dir1/file1.bb:line10$", flags=TestGrep._reflags)
704
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
705
705
# finds line1 and line10
706
706
self.assertEqual(len(out.splitlines()), 4)
707
707
723
723
724
724
out, err = self.run_bzr(['grep', '-r', 'last:1',
725
725
'--exclude', '*.cc', 'l..e1'])
726
self.assertContainsRe(out, b"^dir0/file0.aa~.:line1", flags=TestGrep._reflags)
727
self.assertContainsRe(out, b"^dir1/file1.bb~.:line1", flags=TestGrep._reflags)
728
self.assertNotContainsRe(out, b"file1.cc", flags=TestGrep._reflags)
726
self.assertContainsRe(out, "^dir0/file0.aa~.:line1", flags=TestGrep._reflags)
727
self.assertContainsRe(out, "^dir1/file1.bb~.:line1", flags=TestGrep._reflags)
728
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
729
729
730
730
out, err = self.run_bzr(['grep', '-r', 'last:1',
731
731
'--exclude', '*.cc', 'line1'])
732
self.assertContainsRe(out, b"^dir0/file0.aa~.:line1", flags=TestGrep._reflags)
733
self.assertContainsRe(out, b"^dir1/file1.bb~.:line1", flags=TestGrep._reflags)
734
self.assertNotContainsRe(out, b"file1.cc", flags=TestGrep._reflags)
732
self.assertContainsRe(out, "^dir0/file0.aa~.:line1", flags=TestGrep._reflags)
733
self.assertContainsRe(out, "^dir1/file1.bb~.:line1", flags=TestGrep._reflags)
734
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
735
735
736
736
def test_wtree_exclude_from_outside_dir(self):
737
737
"""(wtree) Ensure --exclude is respected during recursive search.
750
750
self._mk_versioned_file('dir2/file2.cc')
751
751
752
752
out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'l[hijk]ne1'])
753
self.assertContainsRe(out, b"^dir0/file0.aa:line1", flags=TestGrep._reflags)
754
self.assertContainsRe(out, b"^dir1/file1.bb:line1", flags=TestGrep._reflags)
755
self.assertNotContainsRe(out, b"file1.cc", flags=TestGrep._reflags)
753
self.assertContainsRe(out, "^dir0/file0.aa:line1", flags=TestGrep._reflags)
754
self.assertContainsRe(out, "^dir1/file1.bb:line1", flags=TestGrep._reflags)
755
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
756
756
757
757
out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'line1'])
758
self.assertContainsRe(out, b"^dir0/file0.aa:line1", flags=TestGrep._reflags)
759
self.assertContainsRe(out, b"^dir1/file1.bb:line1", flags=TestGrep._reflags)
760
self.assertNotContainsRe(out, b"file1.cc", flags=TestGrep._reflags)
758
self.assertContainsRe(out, "^dir0/file0.aa:line1", flags=TestGrep._reflags)
759
self.assertContainsRe(out, "^dir1/file1.bb:line1", flags=TestGrep._reflags)
760
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
761
761
762
762
def test_workingtree_files_from_outside_dir(self):
763
763
"""(wtree) Grep for pattern with dirs passed as argument.
773
773
self._mk_versioned_file('dir1/file1.txt')
774
774
775
775
out, err = self.run_bzr(['grep', 'l[aeiou]ne1', 'dir0', 'dir1'])
776
self.assertContainsRe(out, b"^dir0/file0.txt:line1", flags=TestGrep._reflags)
777
self.assertContainsRe(out, b"^dir1/file1.txt:line1", flags=TestGrep._reflags)
776
self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
777
self.assertContainsRe(out, "^dir1/file1.txt:line1", flags=TestGrep._reflags)
778
778
779
779
out, err = self.run_bzr(['grep', 'line1', 'dir0', 'dir1'])
780
self.assertContainsRe(out, b"^dir0/file0.txt:line1", flags=TestGrep._reflags)
781
self.assertContainsRe(out, b"^dir1/file1.txt:line1", flags=TestGrep._reflags)
780
self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
781
self.assertContainsRe(out, "^dir1/file1.txt:line1", flags=TestGrep._reflags)
782
782
783
783
def test_versioned_files_from_outside_dir(self):
784
784
"""(versioned) Grep for pattern with dirs passed as argument.
794
794
self._mk_versioned_file('dir1/file1.txt')
795
795
796
796
out, err = self.run_bzr(['grep', '-r', 'last:1', '.ine1', 'dir0', 'dir1'])
797
self.assertContainsRe(out, b"^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
798
self.assertContainsRe(out, b"^dir1/file1.txt~.:line1", flags=TestGrep._reflags)
797
self.assertContainsRe(out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
798
self.assertContainsRe(out, "^dir1/file1.txt~.:line1", flags=TestGrep._reflags)
799
799
800
800
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1', 'dir0', 'dir1'])
801
self.assertContainsRe(out, b"^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
802
self.assertContainsRe(out, b"^dir1/file1.txt~.:line1", flags=TestGrep._reflags)
801
self.assertContainsRe(out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
802
self.assertContainsRe(out, "^dir1/file1.txt~.:line1", flags=TestGrep._reflags)
803
803
804
804
def test_wtree_files_from_outside_dir(self):
805
805
"""(wtree) Grep for pattern with dirs passed as argument.
815
815
self._mk_versioned_file('dir1/file1.txt')
816
816
817
817
out, err = self.run_bzr(['grep', 'li.e1', 'dir0', 'dir1'])
818
self.assertContainsRe(out, b"^dir0/file0.txt:line1", flags=TestGrep._reflags)
819
self.assertContainsRe(out, b"^dir1/file1.txt:line1", flags=TestGrep._reflags)
818
self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
819
self.assertContainsRe(out, "^dir1/file1.txt:line1", flags=TestGrep._reflags)
820
820
821
821
out, err = self.run_bzr(['grep', 'line1', 'dir0', 'dir1'])
822
self.assertContainsRe(out, b"^dir0/file0.txt:line1", flags=TestGrep._reflags)
823
self.assertContainsRe(out, b"^dir1/file1.txt:line1", flags=TestGrep._reflags)
822
self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
823
self.assertContainsRe(out, "^dir1/file1.txt:line1", flags=TestGrep._reflags)
824
824
825
825
def test_versioned_files_from_outside_two_dirs(self):
826
826
"""(versioned) Grep for pattern with two levels of nested dir.
839
839
self._mk_versioned_file('dir0/dir00/file0.txt')
840
840
841
841
out, err = self.run_bzr(['grep', '-r', 'last:1', 'l.ne1', 'dir0/dir00'])
842
self.assertContainsRe(out, b"^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
842
self.assertContainsRe(out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
843
843
844
844
out, err = self.run_bzr(['grep', '-r', 'last:1', 'l.ne1'])
845
self.assertContainsRe(out, b"^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
845
self.assertContainsRe(out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
846
846
847
847
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1', 'dir0/dir00'])
848
self.assertContainsRe(out, b"^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
848
self.assertContainsRe(out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
849
849
850
850
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
851
self.assertContainsRe(out, b"^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
851
self.assertContainsRe(out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
852
852
853
853
def test_wtree_files_from_outside_two_dirs(self):
854
854
"""(wtree) Grep for pattern with two levels of nested dir.
867
867
self._mk_versioned_file('dir0/dir00/file0.txt')
868
868
869
869
out, err = self.run_bzr(['grep', 'lin.1', 'dir0/dir00'])
870
self.assertContainsRe(out, b"^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
870
self.assertContainsRe(out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
871
871
872
872
out, err = self.run_bzr(['grep', 'li.e1'])
873
self.assertContainsRe(out, b"^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
873
self.assertContainsRe(out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
874
874
875
875
out, err = self.run_bzr(['grep', 'line1', 'dir0/dir00'])
876
self.assertContainsRe(out, b"^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
876
self.assertContainsRe(out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
877
877
878
878
out, err = self.run_bzr(['grep', 'line1'])
879
self.assertContainsRe(out, b"^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
879
self.assertContainsRe(out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
880
880
881
881
def test_versioned_file_within_dir_two_levels(self):
882
882
"""(versioned) Search for pattern while in nested dir (two levels).
890
890
os.chdir('dir0')
891
891
892
892
out, err = self.run_bzr(['grep', '-r', 'last:1', '.ine1'])
893
self.assertContainsRe(out, b"^dir1/file0.txt~.:line1", flags=TestGrep._reflags)
893
self.assertContainsRe(out, "^dir1/file0.txt~.:line1", flags=TestGrep._reflags)
894
894
895
895
out, err = self.run_bzr(['grep', '-r', 'last:1', '--from-root', 'l.ne1'])
896
self.assertContainsRe(out, b"^dir0/dir1/file0.txt~.:line1", flags=TestGrep._reflags)
896
self.assertContainsRe(out, "^dir0/dir1/file0.txt~.:line1", flags=TestGrep._reflags)
897
897
898
898
out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1'])
899
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
899
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
900
900
901
901
out, err = self.run_bzr(['grep', '-r', 'last:1', 'lin.1'])
902
self.assertContainsRe(out, b"^dir1/file0.txt~.:line1", flags=TestGrep._reflags)
902
self.assertContainsRe(out, "^dir1/file0.txt~.:line1", flags=TestGrep._reflags)
903
903
904
904
out, err = self.run_bzr(['grep', '-r', 'last:1', '--from-root', 'line1'])
905
self.assertContainsRe(out, b"^dir0/dir1/file0.txt~.:line1", flags=TestGrep._reflags)
905
self.assertContainsRe(out, "^dir0/dir1/file0.txt~.:line1", flags=TestGrep._reflags)
906
906
907
907
out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1'])
908
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
908
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
909
909
self.assertEqual(len(out.splitlines()), 0)
910
910
911
911
def test_wtree_file_within_dir_two_levels(self):
920
920
os.chdir('dir0')
921
921
922
922
out, err = self.run_bzr(['grep', 'l[hij]ne1'])
923
self.assertContainsRe(out, b"^dir1/file0.txt:line1", flags=TestGrep._reflags)
923
self.assertContainsRe(out, "^dir1/file0.txt:line1", flags=TestGrep._reflags)
924
924
925
925
out, err = self.run_bzr(['grep', '--from-root', 'l.ne1'])
926
self.assertContainsRe(out, b"^dir0/dir1/file0.txt:line1", flags=TestGrep._reflags)
926
self.assertContainsRe(out, "^dir0/dir1/file0.txt:line1", flags=TestGrep._reflags)
927
927
928
928
out, err = self.run_bzr(['grep', '--no-recursive', 'lin.1'])
929
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
929
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
930
930
931
931
out, err = self.run_bzr(['grep', 'line1'])
932
self.assertContainsRe(out, b"^dir1/file0.txt:line1", flags=TestGrep._reflags)
932
self.assertContainsRe(out, "^dir1/file0.txt:line1", flags=TestGrep._reflags)
933
933
934
934
out, err = self.run_bzr(['grep', '--from-root', 'line1'])
935
self.assertContainsRe(out, b"^dir0/dir1/file0.txt:line1", flags=TestGrep._reflags)
935
self.assertContainsRe(out, "^dir0/dir1/file0.txt:line1", flags=TestGrep._reflags)
936
936
937
937
out, err = self.run_bzr(['grep', '--no-recursive', 'line1'])
938
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
938
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
939
939
940
940
def test_versioned_ignore_case_no_match(self):
941
941
"""(versioned) Match fails without --ignore-case.
946
946
self._mk_versioned_file('file0.txt')
947
947
948
948
out, err = self.run_bzr(['grep', '-r', 'last:1', 'LinE1', 'file0.txt'])
949
self.assertNotContainsRe(out, b"file0.txt~.:line1", flags=TestGrep._reflags)
949
self.assertNotContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
950
950
951
951
out, err = self.run_bzr(['grep', '-r', 'last:1', 'Li.E1', 'file0.txt'])
952
self.assertNotContainsRe(out, b"file0.txt~.:line1", flags=TestGrep._reflags)
952
self.assertNotContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
953
953
954
954
def test_wtree_ignore_case_no_match(self):
955
955
"""(wtree) Match fails without --ignore-case.
960
960
self._mk_versioned_file('file0.txt')
961
961
962
962
out, err = self.run_bzr(['grep', 'LinE1', 'file0.txt'])
963
self.assertNotContainsRe(out, b"file0.txt:line1", flags=TestGrep._reflags)
963
self.assertNotContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
964
964
965
965
out, err = self.run_bzr(['grep', '.inE1', 'file0.txt'])
966
self.assertNotContainsRe(out, b"file0.txt:line1", flags=TestGrep._reflags)
966
self.assertNotContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
967
967
968
968
def test_versioned_ignore_case_match(self):
969
969
"""(versioned) Match fails without --ignore-case.
975
975
976
976
out, err = self.run_bzr(['grep', '-r', 'last:1',
977
977
'-i', 'Li.E1', 'file0.txt'])
978
self.assertContainsRe(out, b"file0.txt~.:line1", flags=TestGrep._reflags)
978
self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
979
979
980
980
out, err = self.run_bzr(['grep', '-r', 'last:1',
981
981
'-i', 'LinE1', 'file0.txt'])
982
self.assertContainsRe(out, b"file0.txt~.:line1", flags=TestGrep._reflags)
982
self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
983
983
984
984
out, err = self.run_bzr(['grep', '-r', 'last:1',
985
985
'--ignore-case', 'LinE1', 'file0.txt'])
986
self.assertContainsRe(out, b"^file0.txt~.:line1", flags=TestGrep._reflags)
986
self.assertContainsRe(out, "^file0.txt~.:line1", flags=TestGrep._reflags)
987
987
988
988
def test_wtree_ignore_case_match(self):
989
989
"""(wtree) Match fails without --ignore-case.
994
994
self._mk_versioned_file('file0.txt')
995
995
996
996
out, err = self.run_bzr(['grep', '-i', 'LinE1', 'file0.txt'])
997
self.assertContainsRe(out, b"file0.txt:line1", flags=TestGrep._reflags)
997
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
998
998
999
999
out, err = self.run_bzr(['grep', '--ignore-case', 'LinE1', 'file0.txt'])
1000
self.assertContainsRe(out, b"^file0.txt:line1", flags=TestGrep._reflags)
1000
self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
1001
1001
1002
1002
out, err = self.run_bzr(['grep', '--ignore-case', 'Li.E1', 'file0.txt'])
1003
self.assertContainsRe(out, b"^file0.txt:line1", flags=TestGrep._reflags)
1003
self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
1004
1004
1005
1005
def test_versioned_from_root_fail(self):
1006
1006
"""(versioned) Match should fail without --from-root.
1013
1013
os.chdir('dir0')
1014
1014
1015
1015
out, err = self.run_bzr(['grep', '-r', 'last:1', 'li.e1'])
1016
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
1016
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1017
1017
1018
1018
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
1019
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
1019
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1020
1020
1021
1021
def test_wtree_from_root_fail(self):
1022
1022
"""(wtree) Match should fail without --from-root.
1029
1029
os.chdir('dir0')
1030
1030
1031
1031
out, err = self.run_bzr(['grep', 'line1'])
1032
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
1032
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1033
1033
1034
1034
out, err = self.run_bzr(['grep', 'li.e1'])
1035
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
1035
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1036
1036
1037
1037
def test_versioned_from_root_pass(self):
1038
1038
"""(versioned) Match pass with --from-root.
1046
1046
1047
1047
out, err = self.run_bzr(['grep', '-r', 'last:1',
1048
1048
'--from-root', 'l.ne1'])
1049
self.assertContainsRe(out, b"file0.txt~.:line1", flags=TestGrep._reflags)
1049
self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
1050
1050
1051
1051
out, err = self.run_bzr(['grep', '-r', 'last:1',
1052
1052
'--from-root', 'line1'])
1053
self.assertContainsRe(out, b"file0.txt~.:line1", flags=TestGrep._reflags)
1053
self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
1054
1054
1055
1055
def test_wtree_from_root_pass(self):
1056
1056
"""(wtree) Match pass with --from-root.
1063
1063
os.chdir('dir0')
1064
1064
1065
1065
out, err = self.run_bzr(['grep', '--from-root', 'lin.1'])
1066
self.assertContainsRe(out, b"file0.txt:line1", flags=TestGrep._reflags)
1066
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
1067
1067
1068
1068
out, err = self.run_bzr(['grep', '--from-root', 'line1'])
1069
self.assertContainsRe(out, b"file0.txt:line1", flags=TestGrep._reflags)
1069
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
1070
1070
1071
1071
def test_versioned_with_line_number(self):
1072
1072
"""(versioned) Search for pattern with --line-number.
1078
1078
1079
1079
out, err = self.run_bzr(['grep', '-r', 'last:1',
1080
1080
'--line-number', 'li.e3', 'file0.txt'])
1081
self.assertContainsRe(out, b"file0.txt~.:3:line3", flags=TestGrep._reflags)
1081
self.assertContainsRe(out, "file0.txt~.:3:line3", flags=TestGrep._reflags)
1082
1082
1083
1083
out, err = self.run_bzr(['grep', '-r', 'last:1',
1084
1084
'--line-number', 'line3', 'file0.txt'])
1085
self.assertContainsRe(out, b"file0.txt~.:3:line3", flags=TestGrep._reflags)
1085
self.assertContainsRe(out, "file0.txt~.:3:line3", flags=TestGrep._reflags)
1086
1086
1087
1087
out, err = self.run_bzr(['grep', '-r', 'last:1',
1088
1088
'-n', 'line1', 'file0.txt'])
1089
self.assertContainsRe(out, b"file0.txt~.:1:line1", flags=TestGrep._reflags)
1089
self.assertContainsRe(out, "file0.txt~.:1:line1", flags=TestGrep._reflags)
1090
1090
1091
1091
out, err = self.run_bzr(['grep', '-n', 'line[0-9]', 'file0.txt'])
1092
self.assertContainsRe(out, b"file0.txt:3:line3", flags=TestGrep._reflags)
1092
self.assertContainsRe(out, "file0.txt:3:line3", flags=TestGrep._reflags)
1093
1093
1094
1094
def test_wtree_with_line_number(self):
1095
1095
"""(wtree) Search for pattern with --line-number.
1100
1100
self._mk_versioned_file('file0.txt')
1101
1101
1102
1102
out, err = self.run_bzr(['grep', '--line-number', 'line3', 'file0.txt'])
1103
self.assertContainsRe(out, b"file0.txt:3:line3", flags=TestGrep._reflags)
1103
self.assertContainsRe(out, "file0.txt:3:line3", flags=TestGrep._reflags)
1104
1104
1105
1105
out, err = self.run_bzr(['grep', '-n', 'line1', 'file0.txt'])
1106
self.assertContainsRe(out, b"file0.txt:1:line1", flags=TestGrep._reflags)
1106
self.assertContainsRe(out, "file0.txt:1:line1", flags=TestGrep._reflags)
1107
1107
1108
1108
out, err = self.run_bzr(['grep', '-n', '[hjkl]ine1', 'file0.txt'])
1109
self.assertContainsRe(out, b"file0.txt:1:line1", flags=TestGrep._reflags)
1109
self.assertContainsRe(out, "file0.txt:1:line1", flags=TestGrep._reflags)
1110
1110
1111
1111
out, err = self.run_bzr(['grep', '-n', 'line[0-9]', 'file0.txt'])
1112
self.assertContainsRe(out, b"file0.txt:3:line3", flags=TestGrep._reflags)
1112
self.assertContainsRe(out, "file0.txt:3:line3", flags=TestGrep._reflags)
1113
1113
1114
1114
def test_revno_basic_history_grep_file(self):
1115
1115
"""Search for pattern in specific revision number in a file.
1125
1125
1126
1126
# rev 2 should not have text 'v3'
1127
1127
out, err = self.run_bzr(['grep', '-r', '2', 'v3', fname])
1128
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
1128
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1129
1129
1130
1130
# rev 3 should not have text 'v3'
1131
1131
out, err = self.run_bzr(['grep', '-r', '3', 'v3', fname])
1132
self.assertContainsRe(out, b"file0.txt~3:v3.*", flags=TestGrep._reflags)
1132
self.assertContainsRe(out, "file0.txt~3:v3.*", flags=TestGrep._reflags)
1133
1133
1134
1134
# rev 3 should not have text 'v3' with line number
1135
1135
out, err = self.run_bzr(['grep', '-r', '3', '-n', 'v3', fname])
1136
self.assertContainsRe(out, b"file0.txt~3:2:v3.*", flags=TestGrep._reflags)
1136
self.assertContainsRe(out, "file0.txt~3:2:v3.*", flags=TestGrep._reflags)
1137
1137
1138
1138
# rev 2 should not have text 'v3'
1139
1139
out, err = self.run_bzr(['grep', '-r', '2', '[tuv]3', fname])
1140
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
1140
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1141
1141
1142
1142
# rev 3 should not have text 'v3'
1143
1143
out, err = self.run_bzr(['grep', '-r', '3', '[tuv]3', fname])
1144
self.assertContainsRe(out, b"file0.txt~3:v3.*", flags=TestGrep._reflags)
1144
self.assertContainsRe(out, "file0.txt~3:v3.*", flags=TestGrep._reflags)
1145
1145
1146
1146
# rev 3 should not have text 'v3' with line number
1147
1147
out, err = self.run_bzr(['grep', '-r', '3', '-n', '[tuv]3', fname])
1148
self.assertContainsRe(out, b"file0.txt~3:2:v3.*", flags=TestGrep._reflags)
1148
self.assertContainsRe(out, "file0.txt~3:2:v3.*", flags=TestGrep._reflags)
1149
1149
1150
1150
def test_revno_basic_history_grep_full(self):
1151
1151
"""Search for pattern in specific revision number in a file.
1162
1162
1163
1163
# rev 2 should not have text 'v3'
1164
1164
out, err = self.run_bzr(['grep', '-r', '2', 'v3'])
1165
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
1165
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1166
1166
1167
1167
# rev 3 should not have text 'v3'
1168
1168
out, err = self.run_bzr(['grep', '-r', '3', 'v3'])
1169
self.assertContainsRe(out, b"file0.txt~3:v3", flags=TestGrep._reflags)
1169
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1170
1170
1171
1171
# rev 3 should not have text 'v3' with line number
1172
1172
out, err = self.run_bzr(['grep', '-r', '3', '-n', 'v3'])
1173
self.assertContainsRe(out, b"file0.txt~3:1:v3", flags=TestGrep._reflags)
1173
self.assertContainsRe(out, "file0.txt~3:1:v3", flags=TestGrep._reflags)
1174
1174
1175
1175
# rev 2 should not have text 'v3'
1176
1176
out, err = self.run_bzr(['grep', '-r', '2', '[tuv]3'])
1177
self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
1177
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1178
1178
1179
1179
# rev 3 should not have text 'v3'
1180
1180
out, err = self.run_bzr(['grep', '-r', '3', '[tuv]3'])
1181
self.assertContainsRe(out, b"file0.txt~3:v3", flags=TestGrep._reflags)
1181
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1182
1182
1183
1183
# rev 3 should not have text 'v3' with line number
1184
1184
out, err = self.run_bzr(['grep', '-r', '3', '-n', '[tuv]3'])
1185
self.assertContainsRe(out, b"file0.txt~3:1:v3", flags=TestGrep._reflags)
1185
self.assertContainsRe(out, "file0.txt~3:1:v3", flags=TestGrep._reflags)
1186
1186
1187
1187
def test_revno_versioned_file_in_dir(self):
1188
1188
"""Grep specific version of file withing dir.
1198
1198
1199
1199
# v4 should not be present in revno 3
1200
1200
out, err = self.run_bzr(['grep', '-r', 'last:3', 'v4'])
1201
self.assertNotContainsRe(out, b"^dir0/file0.txt", flags=TestGrep._reflags)
1201
self.assertNotContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
1202
1202
1203
1203
# v4 should be present in revno 4
1204
1204
out, err = self.run_bzr(['grep', '-r', 'last:2', 'v4'])
1205
self.assertContainsRe(out, b"^dir0/file0.txt~4:v4", flags=TestGrep._reflags)
1205
self.assertContainsRe(out, "^dir0/file0.txt~4:v4", flags=TestGrep._reflags)
1206
1206
1207
1207
# v4 should not be present in revno 3
1208
1208
out, err = self.run_bzr(['grep', '-r', 'last:3', '[tuv]4'])
1209
self.assertNotContainsRe(out, b"^dir0/file0.txt", flags=TestGrep._reflags)
1209
self.assertNotContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
1210
1210
1211
1211
# v4 should be present in revno 4
1212
1212
out, err = self.run_bzr(['grep', '-r', 'last:2', '[tuv]4'])
1213
self.assertContainsRe(out, b"^dir0/file0.txt~4:v4", flags=TestGrep._reflags)
1213
self.assertContainsRe(out, "^dir0/file0.txt~4:v4", flags=TestGrep._reflags)
1214
1214
1215
1215
def test_revno_range_basic_history_grep(self):
1216
1216
"""Search for pattern in revision range for file.
1227
1227
self._update_file(fname, text="v6 text\n") # rev6
1228
1228
1229
1229
out, err = self.run_bzr(['grep', '-r', '1..', 'v3'])
1230
self.assertContainsRe(out, b"file0.txt~3:v3", flags=TestGrep._reflags)
1231
self.assertContainsRe(out, b"file0.txt~4:v3", flags=TestGrep._reflags)
1232
self.assertContainsRe(out, b"file0.txt~5:v3", flags=TestGrep._reflags)
1233
self.assertContainsRe(out, b"file0.txt~6:v3", flags=TestGrep._reflags)
1230
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1231
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1232
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1233
self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1234
1234
self.assertEqual(len(out.splitlines()), 4)
1235
1235
1236
1236
out, err = self.run_bzr(['grep', '-r', '..1', 'v3'])
1238
1238
self.assertEqual(len(out.splitlines()), 0)
1239
1239
1240
1240
out, err = self.run_bzr(['grep', '-r', '..6', 'v3'])
1241
self.assertContainsRe(out, b"file0.txt~3:v3", flags=TestGrep._reflags)
1242
self.assertContainsRe(out, b"file0.txt~4:v3", flags=TestGrep._reflags)
1243
self.assertContainsRe(out, b"file0.txt~5:v3", flags=TestGrep._reflags)
1244
self.assertContainsRe(out, b"file0.txt~6:v3", flags=TestGrep._reflags)
1241
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1242
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1243
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1244
self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1245
1245
self.assertEqual(len(out.splitlines()), 4)
1246
1246
1247
1247
out, err = self.run_bzr(['grep', '-r', '..', 'v3'])
1248
self.assertContainsRe(out, b"file0.txt~3:v3", flags=TestGrep._reflags)
1249
self.assertContainsRe(out, b"file0.txt~4:v3", flags=TestGrep._reflags)
1250
self.assertContainsRe(out, b"file0.txt~5:v3", flags=TestGrep._reflags)
1251
self.assertContainsRe(out, b"file0.txt~6:v3", flags=TestGrep._reflags)
1248
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1249
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1250
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1251
self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1252
1252
self.assertEqual(len(out.splitlines()), 4)
1253
1253
1254
1254
out, err = self.run_bzr(['grep', '-r', '1..5', 'v3'])
1255
self.assertContainsRe(out, b"file0.txt~3:v3", flags=TestGrep._reflags)
1256
self.assertContainsRe(out, b"file0.txt~4:v3", flags=TestGrep._reflags)
1257
self.assertContainsRe(out, b"file0.txt~5:v3", flags=TestGrep._reflags)
1255
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1256
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1257
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1258
1258
self.assertNotContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1259
1259
self.assertEqual(len(out.splitlines()), 3)
1260
1260
1261
1261
out, err = self.run_bzr(['grep', '-r', '5..1', 'v3'])
1262
self.assertContainsRe(out, b"file0.txt~3:v3", flags=TestGrep._reflags)
1263
self.assertContainsRe(out, b"file0.txt~4:v3", flags=TestGrep._reflags)
1264
self.assertContainsRe(out, b"file0.txt~5:v3", flags=TestGrep._reflags)
1262
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1263
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1264
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1265
1265
self.assertNotContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1266
1266
self.assertEqual(len(out.splitlines()), 3)
1267
1267
1268
1268
out, err = self.run_bzr(['grep', '-r', '1..', '[tuv]3'])
1269
self.assertContainsRe(out, b"file0.txt~3:v3", flags=TestGrep._reflags)
1270
self.assertContainsRe(out, b"file0.txt~4:v3", flags=TestGrep._reflags)
1271
self.assertContainsRe(out, b"file0.txt~5:v3", flags=TestGrep._reflags)
1272
self.assertContainsRe(out, b"file0.txt~6:v3", flags=TestGrep._reflags)
1269
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1270
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1271
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1272
self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1273
1273
self.assertEqual(len(out.splitlines()), 4)
1274
1274
1275
1275
out, err = self.run_bzr(['grep', '-r', '1..5', '[tuv]3'])
1276
self.assertContainsRe(out, b"file0.txt~3:v3", flags=TestGrep._reflags)
1277
self.assertContainsRe(out, b"file0.txt~4:v3", flags=TestGrep._reflags)
1278
self.assertContainsRe(out, b"file0.txt~5:v3", flags=TestGrep._reflags)
1276
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1277
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1278
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1279
1279
self.assertNotContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1280
1280
self.assertEqual(len(out.splitlines()), 3)
1281
1281
1282
1282
out, err = self.run_bzr(['grep', '-r', '5..1', '[tuv]3'])
1283
self.assertContainsRe(out, b"file0.txt~3:v3", flags=TestGrep._reflags)
1284
self.assertContainsRe(out, b"file0.txt~4:v3", flags=TestGrep._reflags)
1285
self.assertContainsRe(out, b"file0.txt~5:v3", flags=TestGrep._reflags)
1283
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1284
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1285
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1286
1286
self.assertNotContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1287
1287
self.assertEqual(len(out.splitlines()), 3)
1288
1288
1300
1300
self._update_file('dir0/file0.txt', "v6 text\n") # rev6
1301
1301
1302
1302
out, err = self.run_bzr(['grep', '-r', '2..5', 'v3'])
1303
self.assertContainsRe(out, b"^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
1304
self.assertContainsRe(out, b"^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
1305
self.assertContainsRe(out, b"^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
1303
self.assertContainsRe(out, "^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
1304
self.assertContainsRe(out, "^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
1305
self.assertContainsRe(out, "^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
1306
1306
self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1307
1307
self.assertEqual(len(out.splitlines()), 3)
1308
1308
1309
1309
out, err = self.run_bzr(['grep', '-r', '2..5', '[tuv]3'])
1310
self.assertContainsRe(out, b"^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
1311
self.assertContainsRe(out, b"^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
1312
self.assertContainsRe(out, b"^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
1310
self.assertContainsRe(out, "^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
1311
self.assertContainsRe(out, "^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
1312
self.assertContainsRe(out, "^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
1313
1313
self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1314
1314
self.assertEqual(len(out.splitlines()), 3)
1315
1315
1327
1327
self._update_file('dir0/file0.txt', "v6 text\n") # rev6
1328
1328
1329
1329
out, err = self.run_bzr(['grep', '-r', '2..5', 'v3', 'dir0'])
1330
self.assertContainsRe(out, b"^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
1331
self.assertContainsRe(out, b"^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
1332
self.assertContainsRe(out, b"^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
1330
self.assertContainsRe(out, "^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
1331
self.assertContainsRe(out, "^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
1332
self.assertContainsRe(out, "^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
1333
1333
self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1334
1334
1335
1335
out, err = self.run_bzr(['grep', '-r', '2..5', '[tuv]3', 'dir0'])
1336
self.assertContainsRe(out, b"^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
1337
self.assertContainsRe(out, b"^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
1338
self.assertContainsRe(out, b"^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
1336
self.assertContainsRe(out, "^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
1337
self.assertContainsRe(out, "^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
1338
self.assertContainsRe(out, "^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
1339
1339
self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1340
1340
1341
1341
def test_levels(self):
1358
1358
out, err = self.run_bzr(['ci', '-m', 'merged'])
1359
1359
1360
1360
out, err = self.run_bzr(['grep', 'line1'])
1361
self.assertContainsRe(out, b"file0.txt:line1", flags=TestGrep._reflags)
1362
self.assertContainsRe(out, b"file1.txt:line1", flags=TestGrep._reflags)
1361
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
1362
self.assertContainsRe(out, "file1.txt:line1", flags=TestGrep._reflags)
1363
1363
1364
1364
# levels should be ignored by wtree grep
1365
1365
out, err = self.run_bzr(['grep', '--levels=0', 'line1'])
1366
self.assertContainsRe(out, b"^file0.txt:line1$", flags=TestGrep._reflags)
1367
self.assertContainsRe(out, b"^file1.txt:line1$", flags=TestGrep._reflags)
1368
self.assertContainsRe(out, b"^file0.txt:line10$", flags=TestGrep._reflags)
1369
self.assertContainsRe(out, b"^file1.txt:line10$", flags=TestGrep._reflags)
1366
self.assertContainsRe(out, "^file0.txt:line1$", flags=TestGrep._reflags)
1367
self.assertContainsRe(out, "^file1.txt:line1$", flags=TestGrep._reflags)
1368
self.assertContainsRe(out, "^file0.txt:line10$", flags=TestGrep._reflags)
1369
self.assertContainsRe(out, "^file1.txt:line10$", flags=TestGrep._reflags)
1370
1370
self.assertEqual(len(out.splitlines()), 4)
1371
1371
1372
1372
out, err = self.run_bzr(['grep', '-r', 'last:1..', '--levels=0', 'line1'])
1373
self.assertContainsRe(out, b"^file0.txt~2:line1$", flags=TestGrep._reflags)
1374
self.assertContainsRe(out, b"^file1.txt~2:line1$", flags=TestGrep._reflags)
1375
self.assertContainsRe(out, b"^file0.txt~1.1.1:line1$", flags=TestGrep._reflags)
1376
self.assertContainsRe(out, b"^file1.txt~1.1.1:line1$", flags=TestGrep._reflags)
1377
self.assertContainsRe(out, b"^file0.txt~2:line10$", flags=TestGrep._reflags)
1378
self.assertContainsRe(out, b"^file1.txt~2:line10$", flags=TestGrep._reflags)
1379
self.assertContainsRe(out, b"^file0.txt~1.1.1:line10$", flags=TestGrep._reflags)
1380
self.assertContainsRe(out, b"^file1.txt~1.1.1:line10$", flags=TestGrep._reflags)
1373
self.assertContainsRe(out, "^file0.txt~2:line1$", flags=TestGrep._reflags)
1374
self.assertContainsRe(out, "^file1.txt~2:line1$", flags=TestGrep._reflags)
1375
self.assertContainsRe(out, "^file0.txt~1.1.1:line1$", flags=TestGrep._reflags)
1376
self.assertContainsRe(out, "^file1.txt~1.1.1:line1$", flags=TestGrep._reflags)
1377
self.assertContainsRe(out, "^file0.txt~2:line10$", flags=TestGrep._reflags)
1378
self.assertContainsRe(out, "^file1.txt~2:line10$", flags=TestGrep._reflags)
1379
self.assertContainsRe(out, "^file0.txt~1.1.1:line10$", flags=TestGrep._reflags)
1380
self.assertContainsRe(out, "^file1.txt~1.1.1:line10$", flags=TestGrep._reflags)
1381
1381
self.assertEqual(len(out.splitlines()), 8)
1382
1382
1383
1383
out, err = self.run_bzr(['grep', '-r', '-1..', '-n', '--levels=0', 'line1'])
1384
self.assertContainsRe(out, b"^file0.txt~2:1:line1$", flags=TestGrep._reflags)
1385
self.assertContainsRe(out, b"^file1.txt~2:1:line1$", flags=TestGrep._reflags)
1386
self.assertContainsRe(out, b"^file0.txt~1.1.1:1:line1$", flags=TestGrep._reflags)
1387
self.assertContainsRe(out, b"^file1.txt~1.1.1:1:line1$", flags=TestGrep._reflags)
1388
self.assertContainsRe(out, b"^file0.txt~2:10:line10$", flags=TestGrep._reflags)
1389
self.assertContainsRe(out, b"^file1.txt~2:10:line10$", flags=TestGrep._reflags)
1390
self.assertContainsRe(out, b"^file0.txt~1.1.1:10:line10$", flags=TestGrep._reflags)
1391
self.assertContainsRe(out, b"^file1.txt~1.1.1:10:line10$", flags=TestGrep._reflags)
1384
self.assertContainsRe(out, "^file0.txt~2:1:line1$", flags=TestGrep._reflags)
1385
self.assertContainsRe(out, "^file1.txt~2:1:line1$", flags=TestGrep._reflags)
1386
self.assertContainsRe(out, "^file0.txt~1.1.1:1:line1$", flags=TestGrep._reflags)
1387
self.assertContainsRe(out, "^file1.txt~1.1.1:1:line1$", flags=TestGrep._reflags)
1388
self.assertContainsRe(out, "^file0.txt~2:10:line10$", flags=TestGrep._reflags)
1389
self.assertContainsRe(out, "^file1.txt~2:10:line10$", flags=TestGrep._reflags)
1390
self.assertContainsRe(out, "^file0.txt~1.1.1:10:line10$", flags=TestGrep._reflags)
1391
self.assertContainsRe(out, "^file1.txt~1.1.1:10:line10$", flags=TestGrep._reflags)
1392
1392
self.assertEqual(len(out.splitlines()), 8)
1393
1393
1394
1394
# levels should be ignored by wtree grep
1395
1395
out, err = self.run_bzr(['grep', '--levels=0', 'l.ne1'])
1396
self.assertContainsRe(out, b"^file0.txt:line1$", flags=TestGrep._reflags)
1397
self.assertContainsRe(out, b"^file1.txt:line1$", flags=TestGrep._reflags)
1398
self.assertContainsRe(out, b"^file0.txt:line10$", flags=TestGrep._reflags)
1399
self.assertContainsRe(out, b"^file1.txt:line10$", flags=TestGrep._reflags)
1396
self.assertContainsRe(out, "^file0.txt:line1$", flags=TestGrep._reflags)
1397
self.assertContainsRe(out, "^file1.txt:line1$", flags=TestGrep._reflags)
1398
self.assertContainsRe(out, "^file0.txt:line10$", flags=TestGrep._reflags)
1399
self.assertContainsRe(out, "^file1.txt:line10$", flags=TestGrep._reflags)
1400
1400
self.assertEqual(len(out.splitlines()), 4)
1401
1401
1402
1402
out, err = self.run_bzr(['grep', '-r', 'last:1..', '--levels=0', 'lin.1'])
1403
self.assertContainsRe(out, b"^file0.txt~2:line1$", flags=TestGrep._reflags)
1404
self.assertContainsRe(out, b"^file1.txt~2:line1$", flags=TestGrep._reflags)
1405
self.assertContainsRe(out, b"^file0.txt~1.1.1:line1$", flags=TestGrep._reflags)
1406
self.assertContainsRe(out, b"^file1.txt~1.1.1:line1$", flags=TestGrep._reflags)
1407
self.assertContainsRe(out, b"^file0.txt~2:line10$", flags=TestGrep._reflags)
1408
self.assertContainsRe(out, b"^file1.txt~2:line10$", flags=TestGrep._reflags)
1409
self.assertContainsRe(out, b"^file0.txt~1.1.1:line10$", flags=TestGrep._reflags)
1410
self.assertContainsRe(out, b"^file1.txt~1.1.1:line10$", flags=TestGrep._reflags)
1403
self.assertContainsRe(out, "^file0.txt~2:line1$", flags=TestGrep._reflags)
1404
self.assertContainsRe(out, "^file1.txt~2:line1$", flags=TestGrep._reflags)
1405
self.assertContainsRe(out, "^file0.txt~1.1.1:line1$", flags=TestGrep._reflags)
1406
self.assertContainsRe(out, "^file1.txt~1.1.1:line1$", flags=TestGrep._reflags)
1407
self.assertContainsRe(out, "^file0.txt~2:line10$", flags=TestGrep._reflags)
1408
self.assertContainsRe(out, "^file1.txt~2:line10$", flags=TestGrep._reflags)
1409
self.assertContainsRe(out, "^file0.txt~1.1.1:line10$", flags=TestGrep._reflags)
1410
self.assertContainsRe(out, "^file1.txt~1.1.1:line10$", flags=TestGrep._reflags)
1411
1411
self.assertEqual(len(out.splitlines()), 8)
1412
1412
1413
1413
out, err = self.run_bzr(['grep', '-r', '-1..', '-n', '--levels=0', '.ine1'])
1414
self.assertContainsRe(out, b"file0.txt~2:1:line1", flags=TestGrep._reflags)
1415
self.assertContainsRe(out, b"file1.txt~2:1:line1", flags=TestGrep._reflags)
1416
self.assertContainsRe(out, b"file0.txt~1.1.1:1:line1", flags=TestGrep._reflags)
1417
self.assertContainsRe(out, b"file1.txt~1.1.1:1:line1", flags=TestGrep._reflags)
1414
self.assertContainsRe(out, "file0.txt~2:1:line1", flags=TestGrep._reflags)
1415
self.assertContainsRe(out, "file1.txt~2:1:line1", flags=TestGrep._reflags)
1416
self.assertContainsRe(out, "file0.txt~1.1.1:1:line1", flags=TestGrep._reflags)
1417
self.assertContainsRe(out, "file1.txt~1.1.1:1:line1", flags=TestGrep._reflags)
1418
1418
1419
1419
def test_dotted_rev_grep(self):
1420
1420
"""Grep in dotted revs
1439
1439
out, err = self.run_bzr(['ci', '-m', 'merged'])
1440
1440
1441
1441
out, err = self.run_bzr(['grep', '-r', '1.1.1..1.1.4', 'text'])
1442
self.assertContainsRe(out, b"file1.txt~1.1.2:text 0", flags=TestGrep._reflags)
1443
self.assertContainsRe(out, b"file1.txt~1.1.3:text 1", flags=TestGrep._reflags)
1444
self.assertContainsRe(out, b"file1.txt~1.1.3:text 1", flags=TestGrep._reflags)
1445
self.assertContainsRe(out, b"file1.txt~1.1.4:text 0", flags=TestGrep._reflags)
1446
self.assertContainsRe(out, b"file1.txt~1.1.4:text 1", flags=TestGrep._reflags)
1447
self.assertContainsRe(out, b"file1.txt~1.1.4:text 2", flags=TestGrep._reflags)
1442
self.assertContainsRe(out, "file1.txt~1.1.2:text 0", 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.3:text 1", flags=TestGrep._reflags)
1445
self.assertContainsRe(out, "file1.txt~1.1.4:text 0", flags=TestGrep._reflags)
1446
self.assertContainsRe(out, "file1.txt~1.1.4:text 1", flags=TestGrep._reflags)
1447
self.assertContainsRe(out, "file1.txt~1.1.4:text 2", flags=TestGrep._reflags)
1448
1448
self.assertEqual(len(out.splitlines()), 6)
1449
1449
1450
1450
def test_versioned_binary_file_grep(self):
1460
1460
# note: set --verbose/-v flag to get the skip message.
1461
1461
out, err = self.run_bzr(['grep', '-v', '-r', 'last:1',
1462
1462
'lineNN', 'file0.bin'])
1463
self.assertNotContainsRe(out, b"file0.bin", flags=TestGrep._reflags)
1464
self.assertContainsRe(err, b"Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
1463
self.assertNotContainsRe(out, "file0.bin", flags=TestGrep._reflags)
1464
self.assertContainsRe(err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
1465
1465
self.assertEqual(len(out.splitlines()), 0)
1466
1466
self.assertEqual(len(err.splitlines()), 1)
1467
1467
1468
1468
out, err = self.run_bzr(['grep', '-v', '-r', 'last:1',
1469
1469
'line.N', 'file0.bin'])
1470
self.assertNotContainsRe(out, b"file0.bin", flags=TestGrep._reflags)
1471
self.assertContainsRe(err, b"Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
1470
self.assertNotContainsRe(out, "file0.bin", flags=TestGrep._reflags)
1471
self.assertContainsRe(err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
1472
1472
self.assertEqual(len(out.splitlines()), 0)
1473
1473
self.assertEqual(len(err.splitlines()), 1)
1474
1474
1483
1483
1484
1484
# note: set --verbose/-v flag to get the skip message.
1485
1485
out, err = self.run_bzr(['grep', '-v', 'lineNN', 'file0.bin'])
1486
self.assertNotContainsRe(out, b"file0.bin:line1", flags=TestGrep._reflags)
1487
self.assertContainsRe(err, b"Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
1486
self.assertNotContainsRe(out, "file0.bin:line1", flags=TestGrep._reflags)
1487
self.assertContainsRe(err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
1488
1488
1489
1489
# binary warning should not be shown without --verbose
1490
1490
out, err = self.run_bzr(['grep', 'lineNN', 'file0.bin'])
1491
self.assertNotContainsRe(out, b"file0.bin:line1", flags=TestGrep._reflags)
1492
self.assertNotContainsRe(err, b"Binary file", flags=TestGrep._reflags)
1491
self.assertNotContainsRe(out, "file0.bin:line1", flags=TestGrep._reflags)
1492
self.assertNotContainsRe(err, "Binary file", flags=TestGrep._reflags)
1493
1493
1494
1494
def test_revspec(self):
1495
1495
"""Ensure various revspecs work
1508
1508
self.assertEqual(len(out.splitlines()), 0)
1509
1509
1510
1510
out, err = self.run_bzr(['grep', '-r', 'revno:4..', 'v4'])
1511
self.assertContainsRe(out, b"^dir0/file0.txt", flags=TestGrep._reflags)
1511
self.assertContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
1512
1512
self.assertEqual(len(out.splitlines()), 2) # find v4 in rev4 and rev5
1513
1513
1514
1514
out, err = self.run_bzr(['grep', '-r', '..revno:3', 'v4'])
1516
1516
self.assertEqual(len(out.splitlines()), 0)
1517
1517
1518
1518
out, err = self.run_bzr(['grep', '-r', '..revno:3', 'v3'])
1519
self.assertContainsRe(out, b"^dir0/file0.txt", flags=TestGrep._reflags)
1519
self.assertContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
1520
1520
self.assertEqual(len(out.splitlines()), 1)
1521
1521
1522
1522
def test_wtree_files_with_matches(self):
1538
1538
# fixed-string
1539
1539
out, err = self.run_bzr(['grep', '--files-with-matches', 'HELLO'])
1540
1540
1541
self.assertContainsRe(out, b"^file0.txt$", flags=TestGrep._reflags)
1542
self.assertContainsRe(out, b"^dir0/file00.txt$", flags=TestGrep._reflags)
1541
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1542
self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
1543
1543
self.assertEqual(len(out.splitlines()), 2)
1544
1544
1545
1545
# regex
1546
1546
out, err = self.run_bzr(['grep', '--files-with-matches', 'HE.LO'])
1547
1547
1548
self.assertContainsRe(out, b"^file0.txt$", flags=TestGrep._reflags)
1549
self.assertContainsRe(out, b"^dir0/file00.txt$", flags=TestGrep._reflags)
1548
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1549
self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
1550
1550
self.assertEqual(len(out.splitlines()), 2)
1551
1551
1552
1552
# fixed-string
1553
1553
out, err = self.run_bzr(['grep', '-l', 'HELLO'])
1554
1554
1555
self.assertContainsRe(out, b"^file0.txt$", flags=TestGrep._reflags)
1556
self.assertContainsRe(out, b"^dir0/file00.txt$", flags=TestGrep._reflags)
1555
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1556
self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
1557
1557
self.assertEqual(len(out.splitlines()), 2)
1558
1558
1559
1559
# regex
1560
1560
out, err = self.run_bzr(['grep', '-l', 'HE.LO'])
1561
1561
1562
self.assertContainsRe(out, b"^file0.txt$", flags=TestGrep._reflags)
1563
self.assertContainsRe(out, b"^dir0/file00.txt$", flags=TestGrep._reflags)
1562
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1563
self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
1564
1564
self.assertEqual(len(out.splitlines()), 2)
1565
1565
1566
1566
# fixed-string
1567
1567
out, err = self.run_bzr(['grep', '-l', 'HELLO', 'dir0', 'file1.txt'])
1568
1568
1569
self.assertContainsRe(out, b"^dir0/file00.txt$", flags=TestGrep._reflags)
1569
self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
1570
1570
self.assertEqual(len(out.splitlines()), 1)
1571
1571
1572
1572
# regex
1573
1573
out, err = self.run_bzr(['grep', '-l', '.ELLO', 'dir0', 'file1.txt'])
1574
1574
1575
self.assertContainsRe(out, b"^dir0/file00.txt$", flags=TestGrep._reflags)
1575
self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
1576
1576
self.assertEqual(len(out.splitlines()), 1)
1577
1577
1578
1578
# fixed-string
1579
1579
out, err = self.run_bzr(['grep', '-l', 'HELLO', 'file0.txt'])
1580
1580
1581
self.assertContainsRe(out, b"^file0.txt$", flags=TestGrep._reflags)
1581
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1582
1582
self.assertEqual(len(out.splitlines()), 1)
1583
1583
1584
1584
# regex
1585
1585
out, err = self.run_bzr(['grep', '-l', '.ELLO', 'file0.txt'])
1586
1586
1587
self.assertContainsRe(out, b"^file0.txt$", flags=TestGrep._reflags)
1587
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1588
1588
self.assertEqual(len(out.splitlines()), 1)
1589
1589
1590
1590
# fixed-string
1591
1591
out, err = self.run_bzr(['grep', '--no-recursive', '-l', 'HELLO'])
1592
1592
1593
self.assertContainsRe(out, b"^file0.txt$", flags=TestGrep._reflags)
1593
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1594
1594
self.assertEqual(len(out.splitlines()), 1)
1595
1595
1596
1596
# regex
1597
1597
out, err = self.run_bzr(['grep', '--no-recursive', '-l', '.ELLO'])
1598
1598
1599
self.assertContainsRe(out, b"^file0.txt$", flags=TestGrep._reflags)
1599
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1600
1600
self.assertEqual(len(out.splitlines()), 1)
1601
1601
1602
1602
def test_ver_files_with_matches(self):
1619
1619
out, err = self.run_bzr(['grep', '-r', '-1', '--files-with-matches',
1620
1620
'HELLO'])
1621
1621
1622
self.assertContainsRe(out, b"^file0.txt~7$", flags=TestGrep._reflags)
1623
self.assertContainsRe(out, b"^dir0/file00.txt~7$", flags=TestGrep._reflags)
1622
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1623
self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1624
1624
self.assertEqual(len(out.splitlines()), 2)
1625
1625
1626
1626
# regex
1627
1627
out, err = self.run_bzr(['grep', '-r', '-1', '--files-with-matches',
1628
1628
'H.LLO'])
1629
1629
1630
self.assertContainsRe(out, b"^file0.txt~7$", flags=TestGrep._reflags)
1631
self.assertContainsRe(out, b"^dir0/file00.txt~7$", flags=TestGrep._reflags)
1630
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1631
self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1632
1632
self.assertEqual(len(out.splitlines()), 2)
1633
1633
1634
1634
# fixed-string
1635
1635
out, err = self.run_bzr(['grep', '-r', '6..7', '--files-with-matches',
1636
1636
'HELLO'])
1637
1637
1638
self.assertContainsRe(out, b"^file0.txt~6$", flags=TestGrep._reflags)
1639
self.assertContainsRe(out, b"^file0.txt~7$", flags=TestGrep._reflags)
1640
self.assertContainsRe(out, b"^dir0/file00.txt~7$", flags=TestGrep._reflags)
1638
self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1639
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1640
self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1641
1641
self.assertEqual(len(out.splitlines()), 3)
1642
1642
1643
1643
# regex
1644
1644
out, err = self.run_bzr(['grep', '-r', '6..7', '--files-with-matches',
1645
1645
'H.LLO'])
1646
1646
1647
self.assertContainsRe(out, b"^file0.txt~6$", flags=TestGrep._reflags)
1648
self.assertContainsRe(out, b"^file0.txt~7$", flags=TestGrep._reflags)
1649
self.assertContainsRe(out, b"^dir0/file00.txt~7$", flags=TestGrep._reflags)
1647
self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1648
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1649
self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1650
1650
self.assertEqual(len(out.splitlines()), 3)
1651
1651
1652
1652
# fixed-string
1653
1653
out, err = self.run_bzr(['grep', '-r', '-1', '-l', 'HELLO'])
1654
1654
1655
self.assertContainsRe(out, b"^file0.txt~7$", flags=TestGrep._reflags)
1656
self.assertContainsRe(out, b"^dir0/file00.txt~7$", flags=TestGrep._reflags)
1655
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1656
self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1657
1657
self.assertEqual(len(out.splitlines()), 2)
1658
1658
1659
1659
# regex
1660
1660
out, err = self.run_bzr(['grep', '-r', '-1', '-l', 'H.LLO'])
1661
1661
1662
self.assertContainsRe(out, b"^file0.txt~7$", flags=TestGrep._reflags)
1663
self.assertContainsRe(out, b"^dir0/file00.txt~7$", flags=TestGrep._reflags)
1662
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1663
self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1664
1664
self.assertEqual(len(out.splitlines()), 2)
1665
1665
1666
1666
# fixed-string
1667
1667
out, err = self.run_bzr(['grep', '-l', 'HELLO', '-r', '-1',
1668
1668
'dir0', 'file1.txt'])
1669
1669
1670
self.assertContainsRe(out, b"^dir0/file00.txt~7$", flags=TestGrep._reflags)
1670
self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1671
1671
self.assertEqual(len(out.splitlines()), 1)
1672
1672
1673
1673
# regex
1674
1674
out, err = self.run_bzr(['grep', '-l', 'H.LLO', '-r', '-1',
1675
1675
'dir0', 'file1.txt'])
1676
1676
1677
self.assertContainsRe(out, b"^dir0/file00.txt~7$", flags=TestGrep._reflags)
1677
self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1678
1678
self.assertEqual(len(out.splitlines()), 1)
1679
1679
1680
1680
# fixed-string
1681
1681
out, err = self.run_bzr(['grep', '-l', 'HELLO',
1682
1682
'-r', '-2', 'file0.txt'])
1683
1683
1684
self.assertContainsRe(out, b"^file0.txt~6$", flags=TestGrep._reflags)
1684
self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1685
1685
self.assertEqual(len(out.splitlines()), 1)
1686
1686
1687
1687
# regex
1688
1688
out, err = self.run_bzr(['grep', '-l', 'HE.LO',
1689
1689
'-r', '-2', 'file0.txt'])
1690
1690
1691
self.assertContainsRe(out, b"^file0.txt~6$", flags=TestGrep._reflags)
1691
self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1692
1692
self.assertEqual(len(out.splitlines()), 1)
1693
1693
1694
1694
# fixed-string
1695
1695
out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
1696
1696
'-l', 'HELLO'])
1697
1697
1698
self.assertContainsRe(out, b"^file0.txt~7$", flags=TestGrep._reflags)
1698
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1699
1699
self.assertEqual(len(out.splitlines()), 1)
1700
1700
1701
1701
# regex
1702
1702
out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
1703
1703
'-l', '.ELLO'])
1704
1704
1705
self.assertContainsRe(out, b"^file0.txt~7$", flags=TestGrep._reflags)
1705
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1706
1706
self.assertEqual(len(out.splitlines()), 1)
1707
1707
1708
1708
def test_wtree_files_without_matches(self):
1724
1724
# fixed-string
1725
1725
out, err = self.run_bzr(['grep', '--files-without-match', 'HELLO'])
1726
1726
1727
self.assertContainsRe(out, b"^file1.txt$", flags=TestGrep._reflags)
1728
self.assertContainsRe(out, b"^dir0/file01.txt$", flags=TestGrep._reflags)
1727
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1728
self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
1729
1729
self.assertEqual(len(out.splitlines()), 2)
1730
1730
1731
1731
# regex
1732
1732
out, err = self.run_bzr(['grep', '--files-without-match', 'HE.LO'])
1733
1733
1734
self.assertContainsRe(out, b"^file1.txt$", flags=TestGrep._reflags)
1735
self.assertContainsRe(out, b"^dir0/file01.txt$", flags=TestGrep._reflags)
1734
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1735
self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
1736
1736
self.assertEqual(len(out.splitlines()), 2)
1737
1737
1738
1738
# fixed-string
1739
1739
out, err = self.run_bzr(['grep', '-L', 'HELLO'])
1740
1740
1741
self.assertContainsRe(out, b"^file1.txt$", flags=TestGrep._reflags)
1742
self.assertContainsRe(out, b"^dir0/file01.txt$", flags=TestGrep._reflags)
1741
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1742
self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
1743
1743
self.assertEqual(len(out.splitlines()), 2)
1744
1744
1745
1745
# regex
1746
1746
out, err = self.run_bzr(['grep', '-L', 'HE.LO'])
1747
1747
1748
self.assertContainsRe(out, b"^file1.txt$", flags=TestGrep._reflags)
1749
self.assertContainsRe(out, b"^dir0/file01.txt$", flags=TestGrep._reflags)
1748
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1749
self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
1750
1750
self.assertEqual(len(out.splitlines()), 2)
1751
1751
1752
1752
# fixed-string
1753
1753
out, err = self.run_bzr(['grep', '-L', 'HELLO', 'dir0', 'file1.txt'])
1754
1754
1755
self.assertContainsRe(out, b"^file1.txt$", flags=TestGrep._reflags)
1756
self.assertContainsRe(out, b"^dir0/file01.txt$", flags=TestGrep._reflags)
1755
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1756
self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
1757
1757
self.assertEqual(len(out.splitlines()), 2)
1758
1758
1759
1759
# regex
1760
1760
out, err = self.run_bzr(['grep', '-L', '.ELLO', 'dir0', 'file1.txt'])
1761
1761
1762
self.assertContainsRe(out, b"^file1.txt$", flags=TestGrep._reflags)
1763
self.assertContainsRe(out, b"^dir0/file01.txt$", flags=TestGrep._reflags)
1762
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1763
self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
1764
1764
self.assertEqual(len(out.splitlines()), 2)
1765
1765
1766
1766
# fixed-string
1767
1767
out, err = self.run_bzr(['grep', '-L', 'HELLO', 'file1.txt'])
1768
1768
1769
self.assertContainsRe(out, b"^file1.txt$", flags=TestGrep._reflags)
1769
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1770
1770
self.assertEqual(len(out.splitlines()), 1)
1771
1771
1772
1772
# regex
1773
1773
out, err = self.run_bzr(['grep', '-L', '.ELLO', 'file1.txt'])
1774
1774
1775
self.assertContainsRe(out, b"^file1.txt$", flags=TestGrep._reflags)
1775
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1776
1776
self.assertEqual(len(out.splitlines()), 1)
1777
1777
1778
1778
# fixed-string
1779
1779
out, err = self.run_bzr(['grep', '--no-recursive', '-L', 'HELLO'])
1780
1780
1781
self.assertContainsRe(out, b"^file1.txt$", flags=TestGrep._reflags)
1781
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1782
1782
self.assertEqual(len(out.splitlines()), 1)
1783
1783
1784
1784
# regex
1785
1785
out, err = self.run_bzr(['grep', '--no-recursive', '-L', '.ELLO'])
1786
1786
1787
self.assertContainsRe(out, b"^file1.txt$", flags=TestGrep._reflags)
1787
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1788
1788
self.assertEqual(len(out.splitlines()), 1)
1789
1789
1790
1790
def test_ver_files_without_matches(self):
1807
1807
out, err = self.run_bzr(['grep', '-r', '-1', '--files-without-match',
1808
1808
'HELLO'])
1809
1809
1810
self.assertContainsRe(out, b"^file1.txt~7$", flags=TestGrep._reflags)
1811
self.assertContainsRe(out, b"^dir0/file01.txt~7$", flags=TestGrep._reflags)
1810
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1811
self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
1812
1812
self.assertEqual(len(out.splitlines()), 2)
1813
1813
1814
1814
# regex
1815
1815
out, err = self.run_bzr(['grep', '-r', '-1', '--files-without-match',
1816
1816
'H.LLO'])
1817
1817
1818
self.assertContainsRe(out, b"^file1.txt~7$", flags=TestGrep._reflags)
1819
self.assertContainsRe(out, b"^dir0/file01.txt~7$", flags=TestGrep._reflags)
1818
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1819
self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
1820
1820
self.assertEqual(len(out.splitlines()), 2)
1821
1821
1822
1822
# fixed-string
1823
1823
out, err = self.run_bzr(['grep', '-r', '6..7', '--files-without-match',
1824
1824
'HELLO'])
1825
1825
1826
self.assertContainsRe(out, b"^file1.txt~6$", flags=TestGrep._reflags)
1827
self.assertContainsRe(out, b"^dir0/file00.txt~6$", flags=TestGrep._reflags)
1828
self.assertContainsRe(out, b"^dir0/file01.txt~6$", flags=TestGrep._reflags)
1829
self.assertContainsRe(out, b"^file1.txt~7$", flags=TestGrep._reflags)
1830
self.assertContainsRe(out, b"^dir0/file01.txt~7$", flags=TestGrep._reflags)
1826
self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
1827
self.assertContainsRe(out, "^dir0/file00.txt~6$", flags=TestGrep._reflags)
1828
self.assertContainsRe(out, "^dir0/file01.txt~6$", flags=TestGrep._reflags)
1829
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1830
self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
1831
1831
self.assertEqual(len(out.splitlines()), 5)
1832
1832
1833
1833
# regex
1834
1834
out, err = self.run_bzr(['grep', '-r', '6..7', '--files-without-match',
1835
1835
'H.LLO'])
1836
1836
1837
self.assertContainsRe(out, b"^file1.txt~6$", flags=TestGrep._reflags)
1838
self.assertContainsRe(out, b"^dir0/file00.txt~6$", flags=TestGrep._reflags)
1839
self.assertContainsRe(out, b"^dir0/file01.txt~6$", flags=TestGrep._reflags)
1840
self.assertContainsRe(out, b"^file1.txt~7$", flags=TestGrep._reflags)
1841
self.assertContainsRe(out, b"^dir0/file01.txt~7$", flags=TestGrep._reflags)
1837
self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
1838
self.assertContainsRe(out, "^dir0/file00.txt~6$", flags=TestGrep._reflags)
1839
self.assertContainsRe(out, "^dir0/file01.txt~6$", flags=TestGrep._reflags)
1840
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1841
self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
1842
1842
self.assertEqual(len(out.splitlines()), 5)
1843
1843
1844
1844
# fixed-string
1845
1845
out, err = self.run_bzr(['grep', '-r', '-1', '-L', 'HELLO'])
1846
1846
1847
self.assertContainsRe(out, b"^file1.txt~7$", flags=TestGrep._reflags)
1848
self.assertContainsRe(out, b"^dir0/file01.txt~7$", flags=TestGrep._reflags)
1847
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1848
self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
1849
1849
self.assertEqual(len(out.splitlines()), 2)
1850
1850
1851
1851
# regex
1852
1852
out, err = self.run_bzr(['grep', '-r', '-1', '-L', 'H.LLO'])
1853
1853
1854
self.assertContainsRe(out, b"^file1.txt~7$", flags=TestGrep._reflags)
1855
self.assertContainsRe(out, b"^dir0/file01.txt~7$", flags=TestGrep._reflags)
1854
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1855
self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
1856
1856
self.assertEqual(len(out.splitlines()), 2)
1857
1857
1858
1858
# fixed-string
1859
1859
out, err = self.run_bzr(['grep', '-L', 'HELLO', '-r', '-1',
1860
1860
'dir0', 'file1.txt'])
1861
1861
1862
self.assertContainsRe(out, b"^file1.txt~7$", flags=TestGrep._reflags)
1863
self.assertContainsRe(out, b"^dir0/file01.txt~7$", flags=TestGrep._reflags)
1862
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1863
self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
1864
1864
self.assertEqual(len(out.splitlines()), 2)
1865
1865
1866
1866
# regex
1867
1867
out, err = self.run_bzr(['grep', '-L', 'H.LLO', '-r', '-1',
1868
1868
'dir0', 'file1.txt'])
1869
1869
1870
self.assertContainsRe(out, b"^file1.txt~7$", flags=TestGrep._reflags)
1871
self.assertContainsRe(out, b"^dir0/file01.txt~7$", flags=TestGrep._reflags)
1870
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1871
self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
1872
1872
self.assertEqual(len(out.splitlines()), 2)
1873
1873
1874
1874
# fixed-string
1875
1875
out, err = self.run_bzr(['grep', '-L', 'HELLO',
1876
1876
'-r', '-2', 'file1.txt'])
1877
1877
1878
self.assertContainsRe(out, b"^file1.txt~6$", flags=TestGrep._reflags)
1878
self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
1879
1879
self.assertEqual(len(out.splitlines()), 1)
1880
1880
1881
1881
# regex
1882
1882
out, err = self.run_bzr(['grep', '-L', 'HE.LO',
1883
1883
'-r', '-2', 'file1.txt'])
1884
1884
1885
self.assertContainsRe(out, b"^file1.txt~6$", flags=TestGrep._reflags)
1885
self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
1886
1886
self.assertEqual(len(out.splitlines()), 1)
1887
1887
1888
1888
# fixed-string
1889
1889
out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
1890
1890
'-L', 'HELLO'])
1891
1891
1892
self.assertContainsRe(out, b"^file1.txt~7$", flags=TestGrep._reflags)
1892
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1893
1893
self.assertEqual(len(out.splitlines()), 1)
1894
1894
1895
1895
# regex
1896
1896
out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
1897
1897
'-L', '.ELLO'])
1898
1898
1899
self.assertContainsRe(out, b"^file1.txt~7$", flags=TestGrep._reflags)
1899
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1900
1900
self.assertEqual(len(out.splitlines()), 1)
1901
1901
1902
1902
def test_no_tree(self):
1912
1912
os.chdir(wd1)
1913
1913
1914
1914
out, err = self.run_bzr(['grep', 'line1'], 3)
1915
self.assertContainsRe(err, b"Cannot search working tree", flags=TestGrep._reflags)
1915
self.assertContainsRe(err, "Cannot search working tree", flags=TestGrep._reflags)
1916
1916
self.assertEqual(out, '')
1917
1917
1918
1918
out, err = self.run_bzr(['grep', '-r', '1', 'line1'])
1919
self.assertContainsRe(out, b"file0.txt~1:line1", flags=TestGrep._reflags)
1919
self.assertContainsRe(out, "file0.txt~1:line1", flags=TestGrep._reflags)
1920
1920
self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
1921
1921
1922
1922
1969
1969
"""
1970
1970
out, err = self.run_bzr(['grep', '--color', 'foo', 'bar'], 3)
1971
1971
self.assertEqual(out, '')
1972
self.assertContainsRe(err, b'Valid values for --color are', flags=TestGrep._reflags)
1972
self.assertContainsRe(err, 'Valid values for --color are', flags=TestGrep._reflags)
1973
1973
1974
1974
def test_ver_matching_files(self):
1975
1975
"""(versioned) Search for matches or no matches only"""
2249
2249
out, err = self.run_bzr(['init'])
2250
2250
out, err = self.run_bzr(['grep', '--diff', 'foo'], 3)
2251
2251
self.assertEqual(out, b'')
2252
self.assertContainsRe(err, b"ERROR:.*revision.* does not exist in branch")
2252
self.assertContainsRe(err, "ERROR:.*revision.* does not exist in branch")
2253
2253
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0