~bzr-pqm/bzr/bzr.dev
» Revision
6437.26.4
(compared to revision 6617)
: bzrlib/plugins/grep/test_grep.py
« back to all changes in this revision
Viewing changes to bzrlib/plugins/grep/test_grep.py
- browse files at revision 6437.26.4
- compare with another revision
- download diff
- download tarball
- view history from revision 6437.26.4
- Committer: Martin Packman
- Date: 2012-02-01 13:24:42 UTC
- mto: (6437.23.4 2.5)
- mto: This revision was merged to the branch mainline in revision 6462.
- Revision ID: martin.packman@canonical.com-20120201132442-ela7jc4mxv4b058o
Treat path for .bzr.log as unicode
- files added:
- bzrlib/doc_generate/builders
- bzrlib/doc_generate/writers
- bzrlib/tests/doc_generate
- bzrlib/tests/doc_generate/builders
- bzrlib/tests/doc_generate/writers
- files removed:
- bzrlib/_termcolor.py
- bzrlib/branchfmt
- bzrlib/plugins/grep
- files modified:
- .bzrignore
added
removed
bzrlib/plugins/grep/test_grep.py
1
# Copyright (C) 2010, 2011, 2012, 2016 Canonical Ltd
2
#
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
7
#
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
12
#
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
17
from __future__ import absolute_import
18
19
import os
20
import re
21
import unicodedata as ud
22
23
from bzrlib import tests, osutils
24
from bzrlib._termcolor import color_string, FG
25
26
from bzrlib.tests.features import (
27
ColorFeature,
28
UnicodeFilenameFeature,
29
)
30
31
# NOTE: As bzr-grep optimizes PATTERN search to -F/--fixed-string
32
# for patterns that are not alphanumeric+whitespace, we test grep
33
# specfically with patterns that have special characters so that
34
# regex path is tested. alphanumeric patterns test the -F path.
35
36
class GrepTestBase(tests.TestCaseWithTransport):
37
"""Base class for testing grep.
38
39
Provides support methods for creating directory and file revisions.
40
"""
41
_reflags = re.MULTILINE|re.DOTALL
42
43
def _mk_file(self, path, line_prefix, total_lines, versioned):
44
text=''
45
for i in range(total_lines):
46
text += line_prefix + str(i+1) + "\n"
47
48
open(path, 'w').write(text)
49
if versioned:
50
self.run_bzr(['add', path])
51
self.run_bzr(['ci', '-m', '"' + path + '"'])
52
53
def _update_file(self, path, text, checkin=True):
54
"""append text to file 'path' and check it in"""
55
open(path, 'a').write(text)
56
if checkin:
57
self.run_bzr(['ci', path, '-m', '"' + path + '"'])
58
59
def _mk_unknown_file(self, path, line_prefix='line', total_lines=10):
60
self._mk_file(path, line_prefix, total_lines, versioned=False)
61
62
def _mk_versioned_file(self, path, line_prefix='line', total_lines=10):
63
self._mk_file(path, line_prefix, total_lines, versioned=True)
64
65
def _mk_dir(self, path, versioned):
66
os.mkdir(path)
67
if versioned:
68
self.run_bzr(['add', path])
69
self.run_bzr(['ci', '-m', '"' + path + '"'])
70
71
def _mk_unknown_dir(self, path):
72
self._mk_dir(path, versioned=False)
73
74
def _mk_versioned_dir(self, path):
75
self._mk_dir(path, versioned=True)
76
77
78
class TestGrep(GrepTestBase):
79
"""Core functional tests for grep."""
80
81
def test_basic_unknown_file(self):
82
"""Search for pattern in specfic file.
83
84
If specified file is unknown, grep it anyway."""
85
wd = 'foobar0'
86
self.make_branch_and_tree(wd)
87
os.chdir(wd)
88
self._mk_unknown_file('file0.txt')
89
90
out, err = self.run_bzr(['grep', 'line1', 'file0.txt'])
91
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
92
self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
93
94
out, err = self.run_bzr(['grep', 'line\d+', 'file0.txt'])
95
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
96
self.assertEqual(len(out.splitlines()), 10)
97
98
# unknown file is not grepped unless explicitely specified
99
out, err = self.run_bzr(['grep', 'line1'])
100
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
101
self.assertEqual(len(out.splitlines()), 0)
102
103
# unknown file is not grepped unless explicitely specified
104
out, err = self.run_bzr(['grep', 'line1$'])
105
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
106
self.assertEqual(len(out.splitlines()), 0)
107
108
def test_ver_basic_file(self):
109
"""(versioned) Search for pattern in specfic file.
110
"""
111
wd = 'foobar0'
112
self.make_branch_and_tree(wd)
113
os.chdir(wd)
114
self._mk_versioned_file('file0.txt')
115
116
out, err = self.run_bzr(['grep', '-r', '1', 'line1', 'file0.txt'])
117
self.assertContainsRe(out, "file0.txt~1:line1", flags=TestGrep._reflags)
118
self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
119
120
out, err = self.run_bzr(['grep', '-r', '1', 'line[0-9]$', 'file0.txt'])
121
self.assertContainsRe(out, "file0.txt~1:line1", flags=TestGrep._reflags)
122
self.assertEqual(len(out.splitlines()), 9)
123
124
# finds all the lines
125
out, err = self.run_bzr(['grep', '-r', '1', 'line[0-9]', 'file0.txt'])
126
self.assertContainsRe(out, "file0.txt~1:line1", flags=TestGrep._reflags)
127
self.assertEqual(len(out.splitlines()), 10)
128
129
def test_wtree_basic_file(self):
130
"""(wtree) Search for pattern in specfic file.
131
"""
132
wd = 'foobar0'
133
self.make_branch_and_tree(wd)
134
os.chdir(wd)
135
self._mk_versioned_file('file0.txt')
136
self._update_file('file0.txt', 'ABC\n', checkin=False)
137
138
out, err = self.run_bzr(['grep', 'ABC', 'file0.txt'])
139
self.assertContainsRe(out, "file0.txt:ABC", flags=TestGrep._reflags)
140
self.assertEqual(len(out.splitlines()), 1)
141
142
out, err = self.run_bzr(['grep', '[A-Z]{3}', 'file0.txt'])
143
self.assertContainsRe(out, "file0.txt:ABC", flags=TestGrep._reflags)
144
self.assertEqual(len(out.splitlines()), 1)
145
146
out, err = self.run_bzr(['grep', '-r', 'last:1', 'ABC', 'file0.txt'])
147
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
148
self.assertEqual(len(out.splitlines()), 0)
149
150
out, err = self.run_bzr(['grep', '-r', 'last:1', '[A-Z]{3}', 'file0.txt'])
151
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
152
self.assertEqual(len(out.splitlines()), 0)
153
154
def test_ver_basic_include(self):
155
"""(versioned) Ensure that -I flag is respected.
156
"""
157
wd = 'foobar0'
158
self.make_branch_and_tree(wd)
159
os.chdir(wd)
160
self._mk_versioned_file('file0.aa')
161
self._mk_versioned_file('file0.bb')
162
self._mk_versioned_file('file0.cc')
163
164
out, err = self.run_bzr(['grep', '-r', 'last:1',
165
'--include', '*.aa', '--include', '*.bb', 'line1'])
166
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
167
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
168
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
169
# two lines each (line1, line10) from file0.aa and file0.bb
170
self.assertEqual(len(out.splitlines()), 4)
171
172
out, err = self.run_bzr(['grep', '-r', 'last:1',
173
'--include', '*.aa', '--include', '*.bb', 'line1$'])
174
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
175
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
176
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
177
# one lines each (line1) from file0.aa and file0.bb
178
self.assertEqual(len(out.splitlines()), 2)
179
180
out, err = self.run_bzr(['grep', '-r', 'last:1',
181
'-I', '*.aa', '-I', '*.bb', 'line1'])
182
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
183
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
184
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
185
# two lines each (line1, line10) from file0.aa and file0.bb
186
self.assertEqual(len(out.splitlines()), 4)
187
188
out, err = self.run_bzr(['grep', '-r', 'last:1',
189
'-I', '*.aa', '-I', '*.bb', 'line1$'])
190
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
191
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
192
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
193
# one lines each (line1) from file0.aa and file0.bb
194
self.assertEqual(len(out.splitlines()), 2)
195
196
def test_wtree_basic_include(self):
197
"""(wtree) Ensure that --include flag is respected.
198
"""
199
wd = 'foobar0'
200
self.make_branch_and_tree(wd)
201
os.chdir(wd)
202
self._mk_versioned_file('file0.aa')
203
self._mk_versioned_file('file0.bb')
204
self._mk_versioned_file('file0.cc')
205
206
out, err = self.run_bzr(['grep', '--include', '*.aa',
207
'--include', '*.bb', 'line1'])
208
self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
209
self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
210
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
211
# two lines each (line1, line10) from file0.aa and file0.bb
212
self.assertEqual(len(out.splitlines()), 4)
213
214
out, err = self.run_bzr(['grep', '--include', '*.aa',
215
'--include', '*.bb', 'line1$'])
216
self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
217
self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
218
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
219
# one line each (line1) from file0.aa and file0.bb
220
self.assertEqual(len(out.splitlines()), 2)
221
222
def test_ver_basic_exclude(self):
223
"""(versioned) Ensure that --exclude flag is respected.
224
"""
225
wd = 'foobar0'
226
self.make_branch_and_tree(wd)
227
os.chdir(wd)
228
self._mk_versioned_file('file0.aa')
229
self._mk_versioned_file('file0.bb')
230
self._mk_versioned_file('file0.cc')
231
232
out, err = self.run_bzr(['grep', '-r', 'last:1',
233
'--exclude', '*.cc', 'line1'])
234
self.assertContainsRe(out, "file0.aa~.:line1$", flags=TestGrep._reflags)
235
self.assertContainsRe(out, "file0.bb~.:line1$", flags=TestGrep._reflags)
236
self.assertContainsRe(out, "file0.aa~.:line10", flags=TestGrep._reflags)
237
self.assertContainsRe(out, "file0.bb~.:line10", flags=TestGrep._reflags)
238
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
239
# two lines each (line1, line10) from file0.aa and file0.bb
240
self.assertEqual(len(out.splitlines()), 4)
241
242
out, err = self.run_bzr(['grep', '-r', 'last:1',
243
'--exclude', '*.cc', 'line1$'])
244
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
245
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
246
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
247
# one line each (line1) from file0.aa and file0.bb
248
self.assertEqual(len(out.splitlines()), 2)
249
250
out, err = self.run_bzr(['grep', '-r', 'last:1',
251
'-X', '*.cc', 'line1'])
252
self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
253
self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
254
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
255
# two lines each (line1, line10) from file0.aa and file0.bb
256
self.assertEqual(len(out.splitlines()), 4)
257
258
def test_wtree_basic_exclude(self):
259
"""(wtree) Ensure that --exclude flag is respected.
260
"""
261
wd = 'foobar0'
262
self.make_branch_and_tree(wd)
263
os.chdir(wd)
264
self._mk_versioned_file('file0.aa')
265
self._mk_versioned_file('file0.bb')
266
self._mk_versioned_file('file0.cc')
267
268
out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'line1'])
269
self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
270
self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
271
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
272
# two lines each (line1, line10) from file0.aa and file0.bb
273
self.assertEqual(len(out.splitlines()), 4)
274
275
out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'lin.1$'])
276
self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
277
self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
278
self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
279
# one line each (line1) from file0.aa and file0.bb
280
self.assertEqual(len(out.splitlines()), 2)
281
282
def test_ver_multiple_files(self):
283
"""(versioned) Search for pattern in multiple files.
284
"""
285
wd = 'foobar0'
286
self.make_branch_and_tree(wd)
287
os.chdir(wd)
288
self._mk_versioned_file('file0.txt', total_lines=2)
289
self._mk_versioned_file('file1.txt', total_lines=2)
290
self._mk_versioned_file('file2.txt', total_lines=2)
291
292
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line[1-2]$'])
293
self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
294
self.assertContainsRe(out, "file0.txt~.:line2", flags=TestGrep._reflags)
295
self.assertContainsRe(out, "file1.txt~.:line1", flags=TestGrep._reflags)
296
self.assertContainsRe(out, "file1.txt~.:line2", flags=TestGrep._reflags)
297
self.assertContainsRe(out, "file2.txt~.:line1", flags=TestGrep._reflags)
298
self.assertContainsRe(out, "file2.txt~.:line2", flags=TestGrep._reflags)
299
self.assertEqual(len(out.splitlines()), 6)
300
301
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line'])
302
self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
303
self.assertContainsRe(out, "file0.txt~.:line2", flags=TestGrep._reflags)
304
self.assertContainsRe(out, "file1.txt~.:line1", flags=TestGrep._reflags)
305
self.assertContainsRe(out, "file1.txt~.:line2", flags=TestGrep._reflags)
306
self.assertContainsRe(out, "file2.txt~.:line1", flags=TestGrep._reflags)
307
self.assertContainsRe(out, "file2.txt~.:line2", flags=TestGrep._reflags)
308
self.assertEqual(len(out.splitlines()), 6)
309
310
def test_multiple_wtree_files(self):
311
"""(wtree) Search for pattern in multiple files in working tree.
312
"""
313
wd = 'foobar0'
314
self.make_branch_and_tree(wd)
315
os.chdir(wd)
316
self._mk_versioned_file('file0.txt', total_lines=2)
317
self._mk_versioned_file('file1.txt', total_lines=2)
318
self._mk_versioned_file('file2.txt', total_lines=2)
319
self._update_file('file0.txt', 'HELLO\n', checkin=False)
320
self._update_file('file1.txt', 'HELLO\n', checkin=True)
321
self._update_file('file2.txt', 'HELLO\n', checkin=False)
322
323
out, err = self.run_bzr(['grep', 'HELLO',
324
'file0.txt', 'file1.txt', 'file2.txt'])
325
326
self.assertContainsRe(out, "file0.txt:HELLO", flags=TestGrep._reflags)
327
self.assertContainsRe(out, "file1.txt:HELLO", flags=TestGrep._reflags)
328
self.assertContainsRe(out, "file2.txt:HELLO", flags=TestGrep._reflags)
329
self.assertEqual(len(out.splitlines()), 3)
330
331
out, err = self.run_bzr(['grep', 'HELLO', '-r', 'last:1',
332
'file0.txt', 'file1.txt', 'file2.txt'])
333
334
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
335
self.assertContainsRe(out, "file1.txt~.:HELLO", flags=TestGrep._reflags)
336
self.assertNotContainsRe(out, "file2.txt", flags=TestGrep._reflags)
337
self.assertEqual(len(out.splitlines()), 1)
338
339
out, err = self.run_bzr(['grep', 'HE..O',
340
'file0.txt', 'file1.txt', 'file2.txt'])
341
342
self.assertContainsRe(out, "file0.txt:HELLO", flags=TestGrep._reflags)
343
self.assertContainsRe(out, "file1.txt:HELLO", flags=TestGrep._reflags)
344
self.assertContainsRe(out, "file2.txt:HELLO", flags=TestGrep._reflags)
345
self.assertEqual(len(out.splitlines()), 3)
346
347
out, err = self.run_bzr(['grep', 'HE..O', '-r', 'last:1',
348
'file0.txt', 'file1.txt', 'file2.txt'])
349
350
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
351
self.assertContainsRe(out, "file1.txt~.:HELLO", flags=TestGrep._reflags)
352
self.assertNotContainsRe(out, "file2.txt", flags=TestGrep._reflags)
353
self.assertEqual(len(out.splitlines()), 1)
354
355
def test_ver_null_option(self):
356
"""(versioned) --null option should use NUL instead of newline.
357
"""
358
wd = 'foobar0'
359
self.make_branch_and_tree(wd)
360
os.chdir(wd)
361
self._mk_versioned_file('file0.txt', total_lines=3)
362
363
nref = ud.normalize(u'NFC', u"file0.txt~1:line1\0file0.txt~1:line2\0file0.txt~1:line3\0")
364
365
out, err = self.run_bzr(['grep', '-r', 'last:1', '--null', 'line[1-3]'])
366
nout = ud.normalize(u'NFC', out.decode('utf-8', 'ignore'))
367
self.assertEqual(nout, nref)
368
self.assertEqual(len(out.splitlines()), 1)
369
370
out, err = self.run_bzr(['grep', '-r', 'last:1', '-Z', 'line[1-3]'])
371
nout = ud.normalize(u'NFC', out.decode('utf-8', 'ignore'))
372
self.assertEqual(nout, nref)
373
self.assertEqual(len(out.splitlines()), 1)
374
375
out, err = self.run_bzr(['grep', '-r', 'last:1', '--null', 'line'])
376
nout = ud.normalize(u'NFC', out.decode('utf-8', 'ignore'))
377
self.assertEqual(nout, nref)
378
self.assertEqual(len(out.splitlines()), 1)
379
380
def test_wtree_null_option(self):
381
"""(wtree) --null option should use NUL instead of newline.
382
"""
383
wd = 'foobar0'
384
self.make_branch_and_tree(wd)
385
os.chdir(wd)
386
self._mk_versioned_file('file0.txt', total_lines=3)
387
388
out, err = self.run_bzr(['grep', '--null', 'line[1-3]'])
389
self.assertEqual(out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
390
self.assertEqual(len(out.splitlines()), 1)
391
392
out, err = self.run_bzr(['grep', '-Z', 'line[1-3]'])
393
self.assertEqual(out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
394
self.assertEqual(len(out.splitlines()), 1)
395
396
out, err = self.run_bzr(['grep', '-Z', 'line'])
397
self.assertEqual(out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
398
self.assertEqual(len(out.splitlines()), 1)
399
400
def test_versioned_file_in_dir_no_recursive(self):
401
"""(versioned) Should not recurse with --no-recursive"""
402
wd = 'foobar0'
403
self.make_branch_and_tree(wd)
404
os.chdir(wd)
405
self._mk_versioned_file('fileX.txt', line_prefix='lin')
406
self._mk_versioned_dir('dir0')
407
self._mk_versioned_file('dir0/file0.txt')
408
409
out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1'])
410
self.assertNotContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
411
self.assertEqual(len(out.splitlines()), 0)
412
413
out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1$'])
414
self.assertNotContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
415
self.assertEqual(len(out.splitlines()), 0)
416
417
def test_wtree_file_in_dir_no_recursive(self):
418
"""(wtree) Should not recurse with --no-recursive"""
419
wd = 'foobar0'
420
self.make_branch_and_tree(wd)
421
os.chdir(wd)
422
self._mk_versioned_file('fileX.txt', line_prefix='lin')
423
self._mk_versioned_dir('dir0')
424
self._mk_versioned_file('dir0/file0.txt')
425
426
out, err = self.run_bzr(['grep', '--no-recursive', 'line1'])
427
self.assertNotContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
428
self.assertEqual(len(out.splitlines()), 0)
429
430
out, err = self.run_bzr(['grep', '--no-recursive', 'lin.1'])
431
self.assertNotContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
432
self.assertEqual(len(out.splitlines()), 0)
433
434
def test_versioned_file_in_dir_recurse(self):
435
"""(versioned) Should recurse by default.
436
"""
437
wd = 'foobar0'
438
self.make_branch_and_tree(wd)
439
os.chdir(wd)
440
self._mk_versioned_dir('dir0')
441
self._mk_versioned_file('dir0/file0.txt')
442
443
out, err = self.run_bzr(['grep', '-r', '-1', '.i.e1'])
444
self.assertContainsRe(out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
445
# find line1 and line10
446
self.assertEqual(len(out.splitlines()), 2)
447
448
out, err = self.run_bzr(['grep', '-r', '-1', 'line1'])
449
self.assertContainsRe(out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
450
# find line1 and line10
451
self.assertEqual(len(out.splitlines()), 2)
452
453
def test_wtree_file_in_dir_recurse(self):
454
"""(wtree) Should recurse by default.
455
"""
456
wd = 'foobar0'
457
self.make_branch_and_tree(wd)
458
os.chdir(wd)
459
self._mk_versioned_dir('dir0')
460
self._mk_versioned_file('dir0/file0.txt')
461
462
out, err = self.run_bzr(['grep', 'line1'])
463
self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
464
# find line1 and line10
465
self.assertEqual(len(out.splitlines()), 2)
466
467
out, err = self.run_bzr(['grep', 'lin.1'])
468
self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
469
# find line1 and line10
470
self.assertEqual(len(out.splitlines()), 2)
471
472
def test_versioned_file_within_dir(self):
473
"""(versioned) Search for pattern while in nested dir.
474
"""
475
wd = 'foobar0'
476
self.make_branch_and_tree(wd)
477
os.chdir(wd)
478
self._mk_versioned_dir('dir0')
479
self._mk_versioned_file('dir0/file0.txt')
480
os.chdir('dir0')
481
482
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
483
self.assertContainsRe(out, "^file0.txt~.:line1", flags=TestGrep._reflags)
484
# finds line1 and line10
485
self.assertEqual(len(out.splitlines()), 2)
486
487
out, err = self.run_bzr(['grep', '-r', 'last:1', '.i.e1'])
488
self.assertContainsRe(out, "^file0.txt~.:line1", flags=TestGrep._reflags)
489
# finds line1 and line10
490
self.assertEqual(len(out.splitlines()), 2)
491
492
def test_versioned_include_file_within_dir(self):
493
"""(versioned) Ensure --include is respected with file within dir.
494
"""
495
wd = 'foobar0'
496
self.make_branch_and_tree(wd)
497
os.chdir(wd)
498
self._mk_versioned_dir('dir0') # revno 1
499
self._mk_versioned_file('dir0/file0.txt') # revno 2
500
self._mk_versioned_file('dir0/file1.aa') # revno 3
501
self._update_file('dir0/file1.aa', 'hello\n') # revno 4
502
self._update_file('dir0/file0.txt', 'hello\n') # revno 5
503
os.chdir('dir0')
504
505
out, err = self.run_bzr(['grep', '-r', 'last:1',
506
'--include', '*.aa', 'line1'])
507
self.assertContainsRe(out, "^file1.aa~5:line1$", flags=TestGrep._reflags)
508
self.assertContainsRe(out, "^file1.aa~5:line10$", flags=TestGrep._reflags)
509
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
510
# finds line1 and line10
511
self.assertEqual(len(out.splitlines()), 2)
512
513
out, err = self.run_bzr(['grep', '-r', 'last:2..last:1',
514
'--include', '*.aa', 'line1'])
515
self.assertContainsRe(out, "^file1.aa~4:line1$", flags=TestGrep._reflags)
516
self.assertContainsRe(out, "^file1.aa~4:line10$", flags=TestGrep._reflags)
517
self.assertContainsRe(out, "^file1.aa~5:line1$", flags=TestGrep._reflags)
518
self.assertContainsRe(out, "^file1.aa~5:line10$", flags=TestGrep._reflags)
519
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
520
# finds line1 and line10 over two revisions
521
self.assertEqual(len(out.splitlines()), 4)
522
523
out, err = self.run_bzr(['grep', '-r', 'last:1',
524
'--include', '*.aa', 'lin.1'])
525
self.assertContainsRe(out, "^file1.aa~5:line1$", flags=TestGrep._reflags)
526
self.assertContainsRe(out, "^file1.aa~5:line10$", flags=TestGrep._reflags)
527
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
528
# finds line1 and line10
529
self.assertEqual(len(out.splitlines()), 2)
530
531
out, err = self.run_bzr(['grep', '-r', 'last:3..last:1',
532
'--include', '*.aa', 'lin.1'])
533
self.assertContainsRe(out, "^file1.aa~3:line1$", flags=TestGrep._reflags)
534
self.assertContainsRe(out, "^file1.aa~4:line1$", flags=TestGrep._reflags)
535
self.assertContainsRe(out, "^file1.aa~5:line1$", flags=TestGrep._reflags)
536
self.assertContainsRe(out, "^file1.aa~3:line10$", flags=TestGrep._reflags)
537
self.assertContainsRe(out, "^file1.aa~4:line10$", flags=TestGrep._reflags)
538
self.assertContainsRe(out, "^file1.aa~5:line10$", flags=TestGrep._reflags)
539
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
540
# finds line1 and line10 over 3 revisions
541
self.assertEqual(len(out.splitlines()), 6)
542
543
def test_versioned_exclude_file_within_dir(self):
544
"""(versioned) Ensure --exclude is respected with file within dir.
545
"""
546
wd = 'foobar0'
547
self.make_branch_and_tree(wd)
548
os.chdir(wd)
549
self._mk_versioned_dir('dir0')
550
self._mk_versioned_file('dir0/file0.txt')
551
self._mk_versioned_file('dir0/file1.aa')
552
os.chdir('dir0')
553
554
out, err = self.run_bzr(['grep', '-r', 'last:1',
555
'--exclude', '*.txt', 'line1'])
556
self.assertContainsRe(out, "^file1.aa~.:line1", flags=TestGrep._reflags)
557
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
558
# finds line1 and line10
559
self.assertEqual(len(out.splitlines()), 2)
560
561
out, err = self.run_bzr(['grep', '-r', 'last:1',
562
'--exclude', '*.txt', 'l[a-z]ne1'])
563
self.assertContainsRe(out, "^file1.aa~.:line1", flags=TestGrep._reflags)
564
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
565
# finds line1 and line10
566
self.assertEqual(len(out.splitlines()), 2)
567
568
def test_wtree_file_within_dir(self):
569
"""(wtree) Search for pattern while in nested dir.
570
"""
571
wd = 'foobar0'
572
self.make_branch_and_tree(wd)
573
os.chdir(wd)
574
self._mk_versioned_dir('dir0')
575
self._mk_versioned_file('dir0/file0.txt')
576
os.chdir('dir0')
577
578
out, err = self.run_bzr(['grep', 'line1'])
579
self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
580
# finds line1 and line10
581
self.assertEqual(len(out.splitlines()), 2)
582
583
out, err = self.run_bzr(['grep', 'l[aeiou]ne1'])
584
self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
585
# finds line1 and line10
586
self.assertEqual(len(out.splitlines()), 2)
587
588
def test_wtree_include_file_within_dir(self):
589
"""(wtree) Ensure --include is respected with file within dir.
590
"""
591
wd = 'foobar0'
592
self.make_branch_and_tree(wd)
593
os.chdir(wd)
594
self._mk_versioned_dir('dir0')
595
self._mk_versioned_file('dir0/file0.txt')
596
self._mk_versioned_file('dir0/file1.aa')
597
os.chdir('dir0')
598
599
out, err = self.run_bzr(['grep', '--include', '*.aa', 'line1'])
600
self.assertContainsRe(out, "^file1.aa:line1", flags=TestGrep._reflags)
601
# finds line1 and line10
602
self.assertEqual(len(out.splitlines()), 2)
603
604
out, err = self.run_bzr(['grep', '--include', '*.aa', 'l[ixn]ne1'])
605
self.assertContainsRe(out, "^file1.aa:line1", flags=TestGrep._reflags)
606
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
607
# finds line1 and line10
608
self.assertEqual(len(out.splitlines()), 2)
609
610
def test_wtree_exclude_file_within_dir(self):
611
"""(wtree) Ensure --exclude is respected with file within dir.
612
"""
613
wd = 'foobar0'
614
self.make_branch_and_tree(wd)
615
os.chdir(wd)
616
self._mk_versioned_dir('dir0')
617
self._mk_versioned_file('dir0/file0.txt')
618
self._mk_versioned_file('dir0/file1.aa')
619
os.chdir('dir0')
620
621
out, err = self.run_bzr(['grep', '--exclude', '*.txt', 'li.e1'])
622
self.assertContainsRe(out, "^file1.aa:line1$", flags=TestGrep._reflags)
623
self.assertContainsRe(out, "^file1.aa:line10$", flags=TestGrep._reflags)
624
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
625
# finds line1 and line10
626
self.assertEqual(len(out.splitlines()), 2)
627
628
out, err = self.run_bzr(['grep', '--exclude', '*.txt', 'line1'])
629
self.assertContainsRe(out, "^file1.aa:line1$", flags=TestGrep._reflags)
630
self.assertContainsRe(out, "^file1.aa:line10$", flags=TestGrep._reflags)
631
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
632
# finds line1 and line10
633
self.assertEqual(len(out.splitlines()), 2)
634
635
def test_versioned_include_from_outside_dir(self):
636
"""(versioned) Ensure --include is respected during recursive search.
637
"""
638
wd = 'foobar0'
639
self.make_branch_and_tree(wd)
640
os.chdir(wd)
641
642
self._mk_versioned_dir('dir0')
643
self._mk_versioned_file('dir0/file0.aa')
644
645
self._mk_versioned_dir('dir1')
646
self._mk_versioned_file('dir1/file1.bb')
647
648
self._mk_versioned_dir('dir2')
649
self._mk_versioned_file('dir2/file2.cc')
650
651
out, err = self.run_bzr(['grep', '-r', 'last:1',
652
'--include', '*.aa', '--include', '*.bb', 'l..e1'])
653
self.assertContainsRe(out, "^dir0/file0.aa~.:line1$", flags=TestGrep._reflags)
654
self.assertContainsRe(out, "^dir1/file1.bb~.:line1$", flags=TestGrep._reflags)
655
self.assertContainsRe(out, "^dir0/file0.aa~.:line10$", flags=TestGrep._reflags)
656
self.assertContainsRe(out, "^dir1/file1.bb~.:line10$", flags=TestGrep._reflags)
657
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
658
# finds line1 and line10
659
self.assertEqual(len(out.splitlines()), 4)
660
661
out, err = self.run_bzr(['grep', '-r', 'last:1',
662
'--include', '*.aa', '--include', '*.bb', 'line1'])
663
self.assertContainsRe(out, "^dir0/file0.aa~.:line1$", flags=TestGrep._reflags)
664
self.assertContainsRe(out, "^dir1/file1.bb~.:line1$", flags=TestGrep._reflags)
665
self.assertContainsRe(out, "^dir0/file0.aa~.:line10$", flags=TestGrep._reflags)
666
self.assertContainsRe(out, "^dir1/file1.bb~.:line10$", flags=TestGrep._reflags)
667
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
668
# finds line1 and line10
669
self.assertEqual(len(out.splitlines()), 4)
670
671
def test_wtree_include_from_outside_dir(self):
672
"""(wtree) Ensure --include is respected during recursive search.
673
"""
674
wd = 'foobar0'
675
self.make_branch_and_tree(wd)
676
os.chdir(wd)
677
678
self._mk_versioned_dir('dir0')
679
self._mk_versioned_file('dir0/file0.aa')
680
681
self._mk_versioned_dir('dir1')
682
self._mk_versioned_file('dir1/file1.bb')
683
684
self._mk_versioned_dir('dir2')
685
self._mk_versioned_file('dir2/file2.cc')
686
687
out, err = self.run_bzr(['grep', '--include', '*.aa',
688
'--include', '*.bb', 'l.n.1'])
689
self.assertContainsRe(out, "^dir0/file0.aa:line1$", flags=TestGrep._reflags)
690
self.assertContainsRe(out, "^dir1/file1.bb:line1$", flags=TestGrep._reflags)
691
self.assertContainsRe(out, "^dir0/file0.aa:line10$", flags=TestGrep._reflags)
692
self.assertContainsRe(out, "^dir1/file1.bb:line10$", flags=TestGrep._reflags)
693
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
694
# finds line1 and line10
695
self.assertEqual(len(out.splitlines()), 4)
696
697
out, err = self.run_bzr(['grep', '--include', '*.aa',
698
'--include', '*.bb', 'line1'])
699
self.assertContainsRe(out, "^dir0/file0.aa:line1$", flags=TestGrep._reflags)
700
self.assertContainsRe(out, "^dir1/file1.bb:line1$", flags=TestGrep._reflags)
701
self.assertContainsRe(out, "^dir0/file0.aa:line10$", flags=TestGrep._reflags)
702
self.assertContainsRe(out, "^dir1/file1.bb:line10$", flags=TestGrep._reflags)
703
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
704
# finds line1 and line10
705
self.assertEqual(len(out.splitlines()), 4)
706
707
def test_versioned_exclude_from_outside_dir(self):
708
"""(versioned) Ensure --exclude is respected during recursive search.
709
"""
710
wd = 'foobar0'
711
self.make_branch_and_tree(wd)
712
os.chdir(wd)
713
714
self._mk_versioned_dir('dir0')
715
self._mk_versioned_file('dir0/file0.aa')
716
717
self._mk_versioned_dir('dir1')
718
self._mk_versioned_file('dir1/file1.bb')
719
720
self._mk_versioned_dir('dir2')
721
self._mk_versioned_file('dir2/file2.cc')
722
723
out, err = self.run_bzr(['grep', '-r', 'last:1',
724
'--exclude', '*.cc', 'l..e1'])
725
self.assertContainsRe(out, "^dir0/file0.aa~.:line1", flags=TestGrep._reflags)
726
self.assertContainsRe(out, "^dir1/file1.bb~.:line1", flags=TestGrep._reflags)
727
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
728
729
out, err = self.run_bzr(['grep', '-r', 'last:1',
730
'--exclude', '*.cc', 'line1'])
731
self.assertContainsRe(out, "^dir0/file0.aa~.:line1", flags=TestGrep._reflags)
732
self.assertContainsRe(out, "^dir1/file1.bb~.:line1", flags=TestGrep._reflags)
733
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
734
735
def test_wtree_exclude_from_outside_dir(self):
736
"""(wtree) Ensure --exclude is respected during recursive search.
737
"""
738
wd = 'foobar0'
739
self.make_branch_and_tree(wd)
740
os.chdir(wd)
741
742
self._mk_versioned_dir('dir0')
743
self._mk_versioned_file('dir0/file0.aa')
744
745
self._mk_versioned_dir('dir1')
746
self._mk_versioned_file('dir1/file1.bb')
747
748
self._mk_versioned_dir('dir2')
749
self._mk_versioned_file('dir2/file2.cc')
750
751
out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'l[hijk]ne1'])
752
self.assertContainsRe(out, "^dir0/file0.aa:line1", flags=TestGrep._reflags)
753
self.assertContainsRe(out, "^dir1/file1.bb:line1", flags=TestGrep._reflags)
754
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
755
756
out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'line1'])
757
self.assertContainsRe(out, "^dir0/file0.aa:line1", flags=TestGrep._reflags)
758
self.assertContainsRe(out, "^dir1/file1.bb:line1", flags=TestGrep._reflags)
759
self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
760
761
def test_workingtree_files_from_outside_dir(self):
762
"""(wtree) Grep for pattern with dirs passed as argument.
763
"""
764
wd = 'foobar0'
765
self.make_branch_and_tree(wd)
766
os.chdir(wd)
767
768
self._mk_versioned_dir('dir0')
769
self._mk_versioned_file('dir0/file0.txt')
770
771
self._mk_versioned_dir('dir1')
772
self._mk_versioned_file('dir1/file1.txt')
773
774
out, err = self.run_bzr(['grep', 'l[aeiou]ne1', 'dir0', 'dir1'])
775
self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
776
self.assertContainsRe(out, "^dir1/file1.txt:line1", flags=TestGrep._reflags)
777
778
out, err = self.run_bzr(['grep', 'line1', 'dir0', 'dir1'])
779
self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
780
self.assertContainsRe(out, "^dir1/file1.txt:line1", flags=TestGrep._reflags)
781
782
def test_versioned_files_from_outside_dir(self):
783
"""(versioned) Grep for pattern with dirs passed as argument.
784
"""
785
wd = 'foobar0'
786
self.make_branch_and_tree(wd)
787
os.chdir(wd)
788
789
self._mk_versioned_dir('dir0')
790
self._mk_versioned_file('dir0/file0.txt')
791
792
self._mk_versioned_dir('dir1')
793
self._mk_versioned_file('dir1/file1.txt')
794
795
out, err = self.run_bzr(['grep', '-r', 'last:1', '.ine1', 'dir0', 'dir1'])
796
self.assertContainsRe(out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
797
self.assertContainsRe(out, "^dir1/file1.txt~.:line1", flags=TestGrep._reflags)
798
799
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1', 'dir0', 'dir1'])
800
self.assertContainsRe(out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
801
self.assertContainsRe(out, "^dir1/file1.txt~.:line1", flags=TestGrep._reflags)
802
803
def test_wtree_files_from_outside_dir(self):
804
"""(wtree) Grep for pattern with dirs passed as argument.
805
"""
806
wd = 'foobar0'
807
self.make_branch_and_tree(wd)
808
os.chdir(wd)
809
810
self._mk_versioned_dir('dir0')
811
self._mk_versioned_file('dir0/file0.txt')
812
813
self._mk_versioned_dir('dir1')
814
self._mk_versioned_file('dir1/file1.txt')
815
816
out, err = self.run_bzr(['grep', 'li.e1', 'dir0', 'dir1'])
817
self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
818
self.assertContainsRe(out, "^dir1/file1.txt:line1", flags=TestGrep._reflags)
819
820
out, err = self.run_bzr(['grep', 'line1', 'dir0', 'dir1'])
821
self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
822
self.assertContainsRe(out, "^dir1/file1.txt:line1", flags=TestGrep._reflags)
823
824
def test_versioned_files_from_outside_two_dirs(self):
825
"""(versioned) Grep for pattern with two levels of nested dir.
826
"""
827
wd = 'foobar0'
828
self.make_branch_and_tree(wd)
829
os.chdir(wd)
830
831
self._mk_versioned_dir('dir0')
832
self._mk_versioned_file('dir0/file0.txt')
833
834
self._mk_versioned_dir('dir1')
835
self._mk_versioned_file('dir1/file1.txt')
836
837
self._mk_versioned_dir('dir0/dir00')
838
self._mk_versioned_file('dir0/dir00/file0.txt')
839
840
out, err = self.run_bzr(['grep', '-r', 'last:1', 'l.ne1', 'dir0/dir00'])
841
self.assertContainsRe(out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
842
843
out, err = self.run_bzr(['grep', '-r', 'last:1', 'l.ne1'])
844
self.assertContainsRe(out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
845
846
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1', 'dir0/dir00'])
847
self.assertContainsRe(out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
848
849
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
850
self.assertContainsRe(out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
851
852
def test_wtree_files_from_outside_two_dirs(self):
853
"""(wtree) Grep for pattern with two levels of nested dir.
854
"""
855
wd = 'foobar0'
856
self.make_branch_and_tree(wd)
857
os.chdir(wd)
858
859
self._mk_versioned_dir('dir0')
860
self._mk_versioned_file('dir0/file0.txt')
861
862
self._mk_versioned_dir('dir1')
863
self._mk_versioned_file('dir1/file1.txt')
864
865
self._mk_versioned_dir('dir0/dir00')
866
self._mk_versioned_file('dir0/dir00/file0.txt')
867
868
out, err = self.run_bzr(['grep', 'lin.1', 'dir0/dir00'])
869
self.assertContainsRe(out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
870
871
out, err = self.run_bzr(['grep', 'li.e1'])
872
self.assertContainsRe(out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
873
874
out, err = self.run_bzr(['grep', 'line1', 'dir0/dir00'])
875
self.assertContainsRe(out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
876
877
out, err = self.run_bzr(['grep', 'line1'])
878
self.assertContainsRe(out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
879
880
def test_versioned_file_within_dir_two_levels(self):
881
"""(versioned) Search for pattern while in nested dir (two levels).
882
"""
883
wd = 'foobar0'
884
self.make_branch_and_tree(wd)
885
os.chdir(wd)
886
self._mk_versioned_dir('dir0')
887
self._mk_versioned_dir('dir0/dir1')
888
self._mk_versioned_file('dir0/dir1/file0.txt')
889
os.chdir('dir0')
890
891
out, err = self.run_bzr(['grep', '-r', 'last:1', '.ine1'])
892
self.assertContainsRe(out, "^dir1/file0.txt~.:line1", flags=TestGrep._reflags)
893
894
out, err = self.run_bzr(['grep', '-r', 'last:1', '--from-root', 'l.ne1'])
895
self.assertContainsRe(out, "^dir0/dir1/file0.txt~.:line1", flags=TestGrep._reflags)
896
897
out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1'])
898
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
899
900
out, err = self.run_bzr(['grep', '-r', 'last:1', 'lin.1'])
901
self.assertContainsRe(out, "^dir1/file0.txt~.:line1", flags=TestGrep._reflags)
902
903
out, err = self.run_bzr(['grep', '-r', 'last:1', '--from-root', 'line1'])
904
self.assertContainsRe(out, "^dir0/dir1/file0.txt~.:line1", flags=TestGrep._reflags)
905
906
out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1'])
907
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
908
self.assertEqual(len(out.splitlines()), 0)
909
910
def test_wtree_file_within_dir_two_levels(self):
911
"""(wtree) Search for pattern while in nested dir (two levels).
912
"""
913
wd = 'foobar0'
914
self.make_branch_and_tree(wd)
915
os.chdir(wd)
916
self._mk_versioned_dir('dir0')
917
self._mk_versioned_dir('dir0/dir1')
918
self._mk_versioned_file('dir0/dir1/file0.txt')
919
os.chdir('dir0')
920
921
out, err = self.run_bzr(['grep', 'l[hij]ne1'])
922
self.assertContainsRe(out, "^dir1/file0.txt:line1", flags=TestGrep._reflags)
923
924
out, err = self.run_bzr(['grep', '--from-root', 'l.ne1'])
925
self.assertContainsRe(out, "^dir0/dir1/file0.txt:line1", flags=TestGrep._reflags)
926
927
out, err = self.run_bzr(['grep', '--no-recursive', 'lin.1'])
928
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
929
930
out, err = self.run_bzr(['grep', 'line1'])
931
self.assertContainsRe(out, "^dir1/file0.txt:line1", flags=TestGrep._reflags)
932
933
out, err = self.run_bzr(['grep', '--from-root', 'line1'])
934
self.assertContainsRe(out, "^dir0/dir1/file0.txt:line1", flags=TestGrep._reflags)
935
936
out, err = self.run_bzr(['grep', '--no-recursive', 'line1'])
937
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
938
939
def test_versioned_ignore_case_no_match(self):
940
"""(versioned) Match fails without --ignore-case.
941
"""
942
wd = 'foobar0'
943
self.make_branch_and_tree(wd)
944
os.chdir(wd)
945
self._mk_versioned_file('file0.txt')
946
947
out, err = self.run_bzr(['grep', '-r', 'last:1', 'LinE1', 'file0.txt'])
948
self.assertNotContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
949
950
out, err = self.run_bzr(['grep', '-r', 'last:1', 'Li.E1', 'file0.txt'])
951
self.assertNotContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
952
953
def test_wtree_ignore_case_no_match(self):
954
"""(wtree) Match fails without --ignore-case.
955
"""
956
wd = 'foobar0'
957
self.make_branch_and_tree(wd)
958
os.chdir(wd)
959
self._mk_versioned_file('file0.txt')
960
961
out, err = self.run_bzr(['grep', 'LinE1', 'file0.txt'])
962
self.assertNotContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
963
964
out, err = self.run_bzr(['grep', '.inE1', 'file0.txt'])
965
self.assertNotContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
966
967
def test_versioned_ignore_case_match(self):
968
"""(versioned) Match fails without --ignore-case.
969
"""
970
wd = 'foobar0'
971
self.make_branch_and_tree(wd)
972
os.chdir(wd)
973
self._mk_versioned_file('file0.txt')
974
975
out, err = self.run_bzr(['grep', '-r', 'last:1',
976
'-i', 'Li.E1', 'file0.txt'])
977
self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
978
979
out, err = self.run_bzr(['grep', '-r', 'last:1',
980
'-i', 'LinE1', 'file0.txt'])
981
self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
982
983
out, err = self.run_bzr(['grep', '-r', 'last:1',
984
'--ignore-case', 'LinE1', 'file0.txt'])
985
self.assertContainsRe(out, "^file0.txt~.:line1", flags=TestGrep._reflags)
986
987
def test_wtree_ignore_case_match(self):
988
"""(wtree) Match fails without --ignore-case.
989
"""
990
wd = 'foobar0'
991
self.make_branch_and_tree(wd)
992
os.chdir(wd)
993
self._mk_versioned_file('file0.txt')
994
995
out, err = self.run_bzr(['grep', '-i', 'LinE1', 'file0.txt'])
996
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
997
998
out, err = self.run_bzr(['grep', '--ignore-case', 'LinE1', 'file0.txt'])
999
self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
1000
1001
out, err = self.run_bzr(['grep', '--ignore-case', 'Li.E1', 'file0.txt'])
1002
self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
1003
1004
def test_versioned_from_root_fail(self):
1005
"""(versioned) Match should fail without --from-root.
1006
"""
1007
wd = 'foobar0'
1008
self.make_branch_and_tree(wd)
1009
os.chdir(wd)
1010
self._mk_versioned_file('file0.txt')
1011
self._mk_versioned_dir('dir0')
1012
os.chdir('dir0')
1013
1014
out, err = self.run_bzr(['grep', '-r', 'last:1', 'li.e1'])
1015
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1016
1017
out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
1018
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1019
1020
def test_wtree_from_root_fail(self):
1021
"""(wtree) Match should fail without --from-root.
1022
"""
1023
wd = 'foobar0'
1024
self.make_branch_and_tree(wd)
1025
os.chdir(wd)
1026
self._mk_versioned_file('file0.txt')
1027
self._mk_versioned_dir('dir0')
1028
os.chdir('dir0')
1029
1030
out, err = self.run_bzr(['grep', 'line1'])
1031
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1032
1033
out, err = self.run_bzr(['grep', 'li.e1'])
1034
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1035
1036
def test_versioned_from_root_pass(self):
1037
"""(versioned) Match pass with --from-root.
1038
"""
1039
wd = 'foobar0'
1040
self.make_branch_and_tree(wd)
1041
os.chdir(wd)
1042
self._mk_versioned_file('file0.txt')
1043
self._mk_versioned_dir('dir0')
1044
os.chdir('dir0')
1045
1046
out, err = self.run_bzr(['grep', '-r', 'last:1',
1047
'--from-root', 'l.ne1'])
1048
self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
1049
1050
out, err = self.run_bzr(['grep', '-r', 'last:1',
1051
'--from-root', 'line1'])
1052
self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
1053
1054
def test_wtree_from_root_pass(self):
1055
"""(wtree) Match pass with --from-root.
1056
"""
1057
wd = 'foobar0'
1058
self.make_branch_and_tree(wd)
1059
os.chdir(wd)
1060
self._mk_versioned_file('file0.txt')
1061
self._mk_versioned_dir('dir0')
1062
os.chdir('dir0')
1063
1064
out, err = self.run_bzr(['grep', '--from-root', 'lin.1'])
1065
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
1066
1067
out, err = self.run_bzr(['grep', '--from-root', 'line1'])
1068
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
1069
1070
def test_versioned_with_line_number(self):
1071
"""(versioned) Search for pattern with --line-number.
1072
"""
1073
wd = 'foobar0'
1074
self.make_branch_and_tree(wd)
1075
os.chdir(wd)
1076
self._mk_versioned_file('file0.txt')
1077
1078
out, err = self.run_bzr(['grep', '-r', 'last:1',
1079
'--line-number', 'li.e3', 'file0.txt'])
1080
self.assertContainsRe(out, "file0.txt~.:3:line3", flags=TestGrep._reflags)
1081
1082
out, err = self.run_bzr(['grep', '-r', 'last:1',
1083
'--line-number', 'line3', 'file0.txt'])
1084
self.assertContainsRe(out, "file0.txt~.:3:line3", flags=TestGrep._reflags)
1085
1086
out, err = self.run_bzr(['grep', '-r', 'last:1',
1087
'-n', 'line1', 'file0.txt'])
1088
self.assertContainsRe(out, "file0.txt~.:1:line1", flags=TestGrep._reflags)
1089
1090
out, err = self.run_bzr(['grep', '-n', 'line[0-9]', 'file0.txt'])
1091
self.assertContainsRe(out, "file0.txt:3:line3", flags=TestGrep._reflags)
1092
1093
def test_wtree_with_line_number(self):
1094
"""(wtree) Search for pattern with --line-number.
1095
"""
1096
wd = 'foobar0'
1097
self.make_branch_and_tree(wd)
1098
os.chdir(wd)
1099
self._mk_versioned_file('file0.txt')
1100
1101
out, err = self.run_bzr(['grep', '--line-number', 'line3', 'file0.txt'])
1102
self.assertContainsRe(out, "file0.txt:3:line3", flags=TestGrep._reflags)
1103
1104
out, err = self.run_bzr(['grep', '-n', 'line1', 'file0.txt'])
1105
self.assertContainsRe(out, "file0.txt:1:line1", flags=TestGrep._reflags)
1106
1107
out, err = self.run_bzr(['grep', '-n', '[hjkl]ine1', 'file0.txt'])
1108
self.assertContainsRe(out, "file0.txt:1:line1", flags=TestGrep._reflags)
1109
1110
out, err = self.run_bzr(['grep', '-n', 'line[0-9]', 'file0.txt'])
1111
self.assertContainsRe(out, "file0.txt:3:line3", flags=TestGrep._reflags)
1112
1113
def test_revno_basic_history_grep_file(self):
1114
"""Search for pattern in specific revision number in a file.
1115
"""
1116
wd = 'foobar0'
1117
fname = 'file0.txt'
1118
self.make_branch_and_tree(wd)
1119
os.chdir(wd)
1120
self._mk_versioned_file(fname, total_lines=0)
1121
self._update_file(fname, text="v2 text\n")
1122
self._update_file(fname, text="v3 text\n")
1123
self._update_file(fname, text="v4 text\n")
1124
1125
# rev 2 should not have text 'v3'
1126
out, err = self.run_bzr(['grep', '-r', '2', 'v3', fname])
1127
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1128
1129
# rev 3 should not have text 'v3'
1130
out, err = self.run_bzr(['grep', '-r', '3', 'v3', fname])
1131
self.assertContainsRe(out, "file0.txt~3:v3.*", flags=TestGrep._reflags)
1132
1133
# rev 3 should not have text 'v3' with line number
1134
out, err = self.run_bzr(['grep', '-r', '3', '-n', 'v3', fname])
1135
self.assertContainsRe(out, "file0.txt~3:2:v3.*", flags=TestGrep._reflags)
1136
1137
# rev 2 should not have text 'v3'
1138
out, err = self.run_bzr(['grep', '-r', '2', '[tuv]3', fname])
1139
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1140
1141
# rev 3 should not have text 'v3'
1142
out, err = self.run_bzr(['grep', '-r', '3', '[tuv]3', fname])
1143
self.assertContainsRe(out, "file0.txt~3:v3.*", flags=TestGrep._reflags)
1144
1145
# rev 3 should not have text 'v3' with line number
1146
out, err = self.run_bzr(['grep', '-r', '3', '-n', '[tuv]3', fname])
1147
self.assertContainsRe(out, "file0.txt~3:2:v3.*", flags=TestGrep._reflags)
1148
1149
def test_revno_basic_history_grep_full(self):
1150
"""Search for pattern in specific revision number in a file.
1151
"""
1152
wd = 'foobar0'
1153
fname = 'file0.txt'
1154
self.make_branch_and_tree(wd)
1155
os.chdir(wd)
1156
self._mk_versioned_file(fname, total_lines=0) # rev1
1157
self._mk_versioned_file('file1.txt') # rev2
1158
self._update_file(fname, text="v3 text\n") # rev3
1159
self._update_file(fname, text="v4 text\n") # rev4
1160
self._update_file(fname, text="v5 text\n") # rev5
1161
1162
# rev 2 should not have text 'v3'
1163
out, err = self.run_bzr(['grep', '-r', '2', 'v3'])
1164
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1165
1166
# rev 3 should not have text 'v3'
1167
out, err = self.run_bzr(['grep', '-r', '3', 'v3'])
1168
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1169
1170
# rev 3 should not have text 'v3' with line number
1171
out, err = self.run_bzr(['grep', '-r', '3', '-n', 'v3'])
1172
self.assertContainsRe(out, "file0.txt~3:1:v3", flags=TestGrep._reflags)
1173
1174
# rev 2 should not have text 'v3'
1175
out, err = self.run_bzr(['grep', '-r', '2', '[tuv]3'])
1176
self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
1177
1178
# rev 3 should not have text 'v3'
1179
out, err = self.run_bzr(['grep', '-r', '3', '[tuv]3'])
1180
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1181
1182
# rev 3 should not have text 'v3' with line number
1183
out, err = self.run_bzr(['grep', '-r', '3', '-n', '[tuv]3'])
1184
self.assertContainsRe(out, "file0.txt~3:1:v3", flags=TestGrep._reflags)
1185
1186
def test_revno_versioned_file_in_dir(self):
1187
"""Grep specific version of file withing dir.
1188
"""
1189
wd = 'foobar0'
1190
self.make_branch_and_tree(wd)
1191
os.chdir(wd)
1192
self._mk_versioned_dir('dir0') # rev1
1193
self._mk_versioned_file('dir0/file0.txt') # rev2
1194
self._update_file('dir0/file0.txt', "v3 text\n") # rev3
1195
self._update_file('dir0/file0.txt', "v4 text\n") # rev4
1196
self._update_file('dir0/file0.txt', "v5 text\n") # rev5
1197
1198
# v4 should not be present in revno 3
1199
out, err = self.run_bzr(['grep', '-r', 'last:3', 'v4'])
1200
self.assertNotContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
1201
1202
# v4 should be present in revno 4
1203
out, err = self.run_bzr(['grep', '-r', 'last:2', 'v4'])
1204
self.assertContainsRe(out, "^dir0/file0.txt~4:v4", flags=TestGrep._reflags)
1205
1206
# v4 should not be present in revno 3
1207
out, err = self.run_bzr(['grep', '-r', 'last:3', '[tuv]4'])
1208
self.assertNotContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
1209
1210
# v4 should be present in revno 4
1211
out, err = self.run_bzr(['grep', '-r', 'last:2', '[tuv]4'])
1212
self.assertContainsRe(out, "^dir0/file0.txt~4:v4", flags=TestGrep._reflags)
1213
1214
def test_revno_range_basic_history_grep(self):
1215
"""Search for pattern in revision range for file.
1216
"""
1217
wd = 'foobar0'
1218
fname = 'file0.txt'
1219
self.make_branch_and_tree(wd)
1220
os.chdir(wd)
1221
self._mk_versioned_file(fname, total_lines=0) # rev1
1222
self._mk_versioned_file('file1.txt') # rev2
1223
self._update_file(fname, text="v3 text\n") # rev3
1224
self._update_file(fname, text="v4 text\n") # rev4
1225
self._update_file(fname, text="v5 text\n") # rev5
1226
self._update_file(fname, text="v6 text\n") # rev6
1227
1228
out, err = self.run_bzr(['grep', '-r', '1..', 'v3'])
1229
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1230
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1231
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1232
self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1233
self.assertEqual(len(out.splitlines()), 4)
1234
1235
out, err = self.run_bzr(['grep', '-r', '..1', 'v3'])
1236
# searching only rev1 gives nothing
1237
self.assertEqual(len(out.splitlines()), 0)
1238
1239
out, err = self.run_bzr(['grep', '-r', '..6', 'v3'])
1240
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1241
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1242
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1243
self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1244
self.assertEqual(len(out.splitlines()), 4)
1245
1246
out, err = self.run_bzr(['grep', '-r', '..', 'v3'])
1247
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1248
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1249
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1250
self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1251
self.assertEqual(len(out.splitlines()), 4)
1252
1253
out, err = self.run_bzr(['grep', '-r', '1..5', 'v3'])
1254
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1255
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1256
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1257
self.assertNotContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1258
self.assertEqual(len(out.splitlines()), 3)
1259
1260
out, err = self.run_bzr(['grep', '-r', '5..1', 'v3'])
1261
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1262
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1263
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1264
self.assertNotContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1265
self.assertEqual(len(out.splitlines()), 3)
1266
1267
out, err = self.run_bzr(['grep', '-r', '1..', '[tuv]3'])
1268
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1269
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1270
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1271
self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1272
self.assertEqual(len(out.splitlines()), 4)
1273
1274
out, err = self.run_bzr(['grep', '-r', '1..5', '[tuv]3'])
1275
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1276
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1277
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1278
self.assertNotContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1279
self.assertEqual(len(out.splitlines()), 3)
1280
1281
out, err = self.run_bzr(['grep', '-r', '5..1', '[tuv]3'])
1282
self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
1283
self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
1284
self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
1285
self.assertNotContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
1286
self.assertEqual(len(out.splitlines()), 3)
1287
1288
def test_revno_range_versioned_file_in_dir(self):
1289
"""Grep rev-range for pattern for file withing a dir.
1290
"""
1291
wd = 'foobar0'
1292
self.make_branch_and_tree(wd)
1293
os.chdir(wd)
1294
self._mk_versioned_dir('dir0') # rev1
1295
self._mk_versioned_file('dir0/file0.txt') # rev2
1296
self._update_file('dir0/file0.txt', "v3 text\n") # rev3
1297
self._update_file('dir0/file0.txt', "v4 text\n") # rev4
1298
self._update_file('dir0/file0.txt', "v5 text\n") # rev5
1299
self._update_file('dir0/file0.txt', "v6 text\n") # rev6
1300
1301
out, err = self.run_bzr(['grep', '-r', '2..5', 'v3'])
1302
self.assertContainsRe(out, "^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
1303
self.assertContainsRe(out, "^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
1304
self.assertContainsRe(out, "^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
1305
self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1306
self.assertEqual(len(out.splitlines()), 3)
1307
1308
out, err = self.run_bzr(['grep', '-r', '2..5', '[tuv]3'])
1309
self.assertContainsRe(out, "^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
1310
self.assertContainsRe(out, "^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
1311
self.assertContainsRe(out, "^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
1312
self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1313
self.assertEqual(len(out.splitlines()), 3)
1314
1315
def test_revno_range_versioned_file_from_outside_dir(self):
1316
"""Grep rev-range for pattern from outside dir.
1317
"""
1318
wd = 'foobar0'
1319
self.make_branch_and_tree(wd)
1320
os.chdir(wd)
1321
self._mk_versioned_dir('dir0') # rev1
1322
self._mk_versioned_file('dir0/file0.txt') # rev2
1323
self._update_file('dir0/file0.txt', "v3 text\n") # rev3
1324
self._update_file('dir0/file0.txt', "v4 text\n") # rev4
1325
self._update_file('dir0/file0.txt', "v5 text\n") # rev5
1326
self._update_file('dir0/file0.txt', "v6 text\n") # rev6
1327
1328
out, err = self.run_bzr(['grep', '-r', '2..5', 'v3', 'dir0'])
1329
self.assertContainsRe(out, "^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
1330
self.assertContainsRe(out, "^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
1331
self.assertContainsRe(out, "^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
1332
self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1333
1334
out, err = self.run_bzr(['grep', '-r', '2..5', '[tuv]3', 'dir0'])
1335
self.assertContainsRe(out, "^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
1336
self.assertContainsRe(out, "^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
1337
self.assertContainsRe(out, "^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
1338
self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
1339
1340
def test_levels(self):
1341
"""--levels=0 should show findings from merged revision.
1342
"""
1343
wd0 = 'foobar0'
1344
wd1 = 'foobar1'
1345
1346
self.make_branch_and_tree(wd0)
1347
os.chdir(wd0)
1348
self._mk_versioned_file('file0.txt')
1349
os.chdir('..')
1350
1351
out, err = self.run_bzr(['branch', wd0, wd1])
1352
os.chdir(wd1)
1353
self._mk_versioned_file('file1.txt')
1354
os.chdir(osutils.pathjoin('..', wd0))
1355
1356
out, err = self.run_bzr(['merge', osutils.pathjoin('..', wd1)])
1357
out, err = self.run_bzr(['ci', '-m', 'merged'])
1358
1359
out, err = self.run_bzr(['grep', 'line1'])
1360
self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
1361
self.assertContainsRe(out, "file1.txt:line1", flags=TestGrep._reflags)
1362
1363
# levels should be ignored by wtree grep
1364
out, err = self.run_bzr(['grep', '--levels=0', 'line1'])
1365
self.assertContainsRe(out, "^file0.txt:line1$", flags=TestGrep._reflags)
1366
self.assertContainsRe(out, "^file1.txt:line1$", flags=TestGrep._reflags)
1367
self.assertContainsRe(out, "^file0.txt:line10$", flags=TestGrep._reflags)
1368
self.assertContainsRe(out, "^file1.txt:line10$", flags=TestGrep._reflags)
1369
self.assertEqual(len(out.splitlines()), 4)
1370
1371
out, err = self.run_bzr(['grep', '-r', 'last:1..', '--levels=0', 'line1'])
1372
self.assertContainsRe(out, "^file0.txt~2:line1$", flags=TestGrep._reflags)
1373
self.assertContainsRe(out, "^file1.txt~2:line1$", flags=TestGrep._reflags)
1374
self.assertContainsRe(out, "^file0.txt~1.1.1:line1$", flags=TestGrep._reflags)
1375
self.assertContainsRe(out, "^file1.txt~1.1.1:line1$", flags=TestGrep._reflags)
1376
self.assertContainsRe(out, "^file0.txt~2:line10$", flags=TestGrep._reflags)
1377
self.assertContainsRe(out, "^file1.txt~2:line10$", flags=TestGrep._reflags)
1378
self.assertContainsRe(out, "^file0.txt~1.1.1:line10$", flags=TestGrep._reflags)
1379
self.assertContainsRe(out, "^file1.txt~1.1.1:line10$", flags=TestGrep._reflags)
1380
self.assertEqual(len(out.splitlines()), 8)
1381
1382
out, err = self.run_bzr(['grep', '-r', '-1..', '-n', '--levels=0', 'line1'])
1383
self.assertContainsRe(out, "^file0.txt~2:1:line1$", flags=TestGrep._reflags)
1384
self.assertContainsRe(out, "^file1.txt~2:1:line1$", flags=TestGrep._reflags)
1385
self.assertContainsRe(out, "^file0.txt~1.1.1:1:line1$", flags=TestGrep._reflags)
1386
self.assertContainsRe(out, "^file1.txt~1.1.1:1:line1$", flags=TestGrep._reflags)
1387
self.assertContainsRe(out, "^file0.txt~2:10:line10$", flags=TestGrep._reflags)
1388
self.assertContainsRe(out, "^file1.txt~2:10:line10$", flags=TestGrep._reflags)
1389
self.assertContainsRe(out, "^file0.txt~1.1.1:10:line10$", flags=TestGrep._reflags)
1390
self.assertContainsRe(out, "^file1.txt~1.1.1:10:line10$", flags=TestGrep._reflags)
1391
self.assertEqual(len(out.splitlines()), 8)
1392
1393
# levels should be ignored by wtree grep
1394
out, err = self.run_bzr(['grep', '--levels=0', 'l.ne1'])
1395
self.assertContainsRe(out, "^file0.txt:line1$", flags=TestGrep._reflags)
1396
self.assertContainsRe(out, "^file1.txt:line1$", flags=TestGrep._reflags)
1397
self.assertContainsRe(out, "^file0.txt:line10$", flags=TestGrep._reflags)
1398
self.assertContainsRe(out, "^file1.txt:line10$", flags=TestGrep._reflags)
1399
self.assertEqual(len(out.splitlines()), 4)
1400
1401
out, err = self.run_bzr(['grep', '-r', 'last:1..', '--levels=0', 'lin.1'])
1402
self.assertContainsRe(out, "^file0.txt~2:line1$", flags=TestGrep._reflags)
1403
self.assertContainsRe(out, "^file1.txt~2:line1$", flags=TestGrep._reflags)
1404
self.assertContainsRe(out, "^file0.txt~1.1.1:line1$", flags=TestGrep._reflags)
1405
self.assertContainsRe(out, "^file1.txt~1.1.1:line1$", flags=TestGrep._reflags)
1406
self.assertContainsRe(out, "^file0.txt~2:line10$", flags=TestGrep._reflags)
1407
self.assertContainsRe(out, "^file1.txt~2:line10$", flags=TestGrep._reflags)
1408
self.assertContainsRe(out, "^file0.txt~1.1.1:line10$", flags=TestGrep._reflags)
1409
self.assertContainsRe(out, "^file1.txt~1.1.1:line10$", flags=TestGrep._reflags)
1410
self.assertEqual(len(out.splitlines()), 8)
1411
1412
out, err = self.run_bzr(['grep', '-r', '-1..', '-n', '--levels=0', '.ine1'])
1413
self.assertContainsRe(out, "file0.txt~2:1:line1", flags=TestGrep._reflags)
1414
self.assertContainsRe(out, "file1.txt~2:1:line1", flags=TestGrep._reflags)
1415
self.assertContainsRe(out, "file0.txt~1.1.1:1:line1", flags=TestGrep._reflags)
1416
self.assertContainsRe(out, "file1.txt~1.1.1:1:line1", flags=TestGrep._reflags)
1417
1418
def test_dotted_rev_grep(self):
1419
"""Grep in dotted revs
1420
"""
1421
wd0 = 'foobar0'
1422
wd1 = 'foobar1'
1423
1424
self.make_branch_and_tree(wd0)
1425
os.chdir(wd0)
1426
self._mk_versioned_file('file0.txt')
1427
os.chdir('..')
1428
1429
out, err = self.run_bzr(['branch', wd0, wd1])
1430
os.chdir(wd1)
1431
self._mk_versioned_file('file1.txt') # revno 1.1.1
1432
self._update_file('file1.txt', "text 0\n") # revno 1.1.2
1433
self._update_file('file1.txt', "text 1\n") # revno 1.1.3
1434
self._update_file('file1.txt', "text 2\n") # revno 1.1.4
1435
os.chdir(osutils.pathjoin('..', wd0))
1436
1437
out, err = self.run_bzr(['merge', osutils.pathjoin('..', wd1)])
1438
out, err = self.run_bzr(['ci', '-m', 'merged'])
1439
1440
out, err = self.run_bzr(['grep', '-r', '1.1.1..1.1.4', 'text'])
1441
self.assertContainsRe(out, "file1.txt~1.1.2:text 0", flags=TestGrep._reflags)
1442
self.assertContainsRe(out, "file1.txt~1.1.3:text 1", flags=TestGrep._reflags)
1443
self.assertContainsRe(out, "file1.txt~1.1.3:text 1", flags=TestGrep._reflags)
1444
self.assertContainsRe(out, "file1.txt~1.1.4:text 0", flags=TestGrep._reflags)
1445
self.assertContainsRe(out, "file1.txt~1.1.4:text 1", flags=TestGrep._reflags)
1446
self.assertContainsRe(out, "file1.txt~1.1.4:text 2", flags=TestGrep._reflags)
1447
self.assertEqual(len(out.splitlines()), 6)
1448
1449
def test_versioned_binary_file_grep(self):
1450
"""(versioned) Grep for pattern in binary file.
1451
"""
1452
wd = 'foobar0'
1453
self.make_branch_and_tree(wd)
1454
os.chdir(wd)
1455
self._mk_versioned_file('file.txt')
1456
self._mk_versioned_file('file0.bin')
1457
self._update_file('file0.bin', "\x00lineNN\x00\n")
1458
1459
# note: set --verbose/-v flag to get the skip message.
1460
out, err = self.run_bzr(['grep', '-v', '-r', 'last:1',
1461
'lineNN', 'file0.bin'])
1462
self.assertNotContainsRe(out, "file0.bin", flags=TestGrep._reflags)
1463
self.assertContainsRe(err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
1464
self.assertEqual(len(out.splitlines()), 0)
1465
self.assertEqual(len(err.splitlines()), 1)
1466
1467
out, err = self.run_bzr(['grep', '-v', '-r', 'last:1',
1468
'line.N', 'file0.bin'])
1469
self.assertNotContainsRe(out, "file0.bin", flags=TestGrep._reflags)
1470
self.assertContainsRe(err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
1471
self.assertEqual(len(out.splitlines()), 0)
1472
self.assertEqual(len(err.splitlines()), 1)
1473
1474
def test_wtree_binary_file_grep(self):
1475
"""(wtree) Grep for pattern in binary file.
1476
"""
1477
wd = 'foobar0'
1478
self.make_branch_and_tree(wd)
1479
os.chdir(wd)
1480
self._mk_versioned_file('file0.bin')
1481
self._update_file('file0.bin', "\x00lineNN\x00\n")
1482
1483
# note: set --verbose/-v flag to get the skip message.
1484
out, err = self.run_bzr(['grep', '-v', 'lineNN', 'file0.bin'])
1485
self.assertNotContainsRe(out, "file0.bin:line1", flags=TestGrep._reflags)
1486
self.assertContainsRe(err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
1487
1488
# binary warning should not be shown without --verbose
1489
out, err = self.run_bzr(['grep', 'lineNN', 'file0.bin'])
1490
self.assertNotContainsRe(out, "file0.bin:line1", flags=TestGrep._reflags)
1491
self.assertNotContainsRe(err, "Binary file", flags=TestGrep._reflags)
1492
1493
def test_revspec(self):
1494
"""Ensure various revspecs work
1495
"""
1496
wd = 'foobar0'
1497
self.make_branch_and_tree(wd)
1498
os.chdir(wd)
1499
self._mk_versioned_dir('dir0') # rev1
1500
self._mk_versioned_file('dir0/file0.txt') # rev2
1501
self._update_file('dir0/file0.txt', "v3 text\n") # rev3
1502
self._update_file('dir0/file0.txt', "v4 text\n") # rev4
1503
self._update_file('dir0/file0.txt', "v5 text\n") # rev5
1504
1505
out, err = self.run_bzr(['grep', '-r', 'revno:1..2', 'v3'])
1506
self.assertNotContainsRe(out, "file0", flags=TestGrep._reflags)
1507
self.assertEqual(len(out.splitlines()), 0)
1508
1509
out, err = self.run_bzr(['grep', '-r', 'revno:4..', 'v4'])
1510
self.assertContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
1511
self.assertEqual(len(out.splitlines()), 2) # find v4 in rev4 and rev5
1512
1513
out, err = self.run_bzr(['grep', '-r', '..revno:3', 'v4'])
1514
self.assertNotContainsRe(out, "file0", flags=TestGrep._reflags)
1515
self.assertEqual(len(out.splitlines()), 0)
1516
1517
out, err = self.run_bzr(['grep', '-r', '..revno:3', 'v3'])
1518
self.assertContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
1519
self.assertEqual(len(out.splitlines()), 1)
1520
1521
def test_wtree_files_with_matches(self):
1522
"""(wtree) Ensure --files-with-matches, -l works
1523
"""
1524
wd = 'foobar0'
1525
self.make_branch_and_tree(wd)
1526
os.chdir(wd)
1527
1528
self._mk_versioned_file('file0.txt', total_lines=2)
1529
self._mk_versioned_file('file1.txt', total_lines=2)
1530
self._mk_versioned_dir('dir0')
1531
self._mk_versioned_file('dir0/file00.txt', total_lines=2)
1532
self._mk_versioned_file('dir0/file01.txt', total_lines=2)
1533
1534
self._update_file('file0.txt', 'HELLO\n', checkin=False)
1535
self._update_file('dir0/file00.txt', 'HELLO\n', checkin=False)
1536
1537
# fixed-string
1538
out, err = self.run_bzr(['grep', '--files-with-matches', 'HELLO'])
1539
1540
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1541
self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
1542
self.assertEqual(len(out.splitlines()), 2)
1543
1544
# regex
1545
out, err = self.run_bzr(['grep', '--files-with-matches', 'HE.LO'])
1546
1547
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1548
self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
1549
self.assertEqual(len(out.splitlines()), 2)
1550
1551
# fixed-string
1552
out, err = self.run_bzr(['grep', '-l', 'HELLO'])
1553
1554
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1555
self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
1556
self.assertEqual(len(out.splitlines()), 2)
1557
1558
# regex
1559
out, err = self.run_bzr(['grep', '-l', 'HE.LO'])
1560
1561
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1562
self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
1563
self.assertEqual(len(out.splitlines()), 2)
1564
1565
# fixed-string
1566
out, err = self.run_bzr(['grep', '-l', 'HELLO', 'dir0', 'file1.txt'])
1567
1568
self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
1569
self.assertEqual(len(out.splitlines()), 1)
1570
1571
# regex
1572
out, err = self.run_bzr(['grep', '-l', '.ELLO', 'dir0', 'file1.txt'])
1573
1574
self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
1575
self.assertEqual(len(out.splitlines()), 1)
1576
1577
# fixed-string
1578
out, err = self.run_bzr(['grep', '-l', 'HELLO', 'file0.txt'])
1579
1580
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1581
self.assertEqual(len(out.splitlines()), 1)
1582
1583
# regex
1584
out, err = self.run_bzr(['grep', '-l', '.ELLO', 'file0.txt'])
1585
1586
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1587
self.assertEqual(len(out.splitlines()), 1)
1588
1589
# fixed-string
1590
out, err = self.run_bzr(['grep', '--no-recursive', '-l', 'HELLO'])
1591
1592
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1593
self.assertEqual(len(out.splitlines()), 1)
1594
1595
# regex
1596
out, err = self.run_bzr(['grep', '--no-recursive', '-l', '.ELLO'])
1597
1598
self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
1599
self.assertEqual(len(out.splitlines()), 1)
1600
1601
def test_ver_files_with_matches(self):
1602
"""(ver) Ensure --files-with-matches, -l works
1603
"""
1604
wd = 'foobar0'
1605
self.make_branch_and_tree(wd)
1606
os.chdir(wd)
1607
1608
self._mk_versioned_file('file0.txt', total_lines=2) # rev 1
1609
self._mk_versioned_file('file1.txt', total_lines=2) # rev 2
1610
self._mk_versioned_dir('dir0') # rev 3
1611
self._mk_versioned_file('dir0/file00.txt', total_lines=2) # rev 4
1612
self._mk_versioned_file('dir0/file01.txt', total_lines=2) # rev 5
1613
1614
self._update_file('file0.txt', 'HELLO\n') # rev 6
1615
self._update_file('dir0/file00.txt', 'HELLO\n') # rev 7
1616
1617
# fixed-string
1618
out, err = self.run_bzr(['grep', '-r', '-1', '--files-with-matches',
1619
'HELLO'])
1620
1621
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1622
self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1623
self.assertEqual(len(out.splitlines()), 2)
1624
1625
# regex
1626
out, err = self.run_bzr(['grep', '-r', '-1', '--files-with-matches',
1627
'H.LLO'])
1628
1629
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1630
self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1631
self.assertEqual(len(out.splitlines()), 2)
1632
1633
# fixed-string
1634
out, err = self.run_bzr(['grep', '-r', '6..7', '--files-with-matches',
1635
'HELLO'])
1636
1637
self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1638
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1639
self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1640
self.assertEqual(len(out.splitlines()), 3)
1641
1642
# regex
1643
out, err = self.run_bzr(['grep', '-r', '6..7', '--files-with-matches',
1644
'H.LLO'])
1645
1646
self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1647
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1648
self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1649
self.assertEqual(len(out.splitlines()), 3)
1650
1651
# fixed-string
1652
out, err = self.run_bzr(['grep', '-r', '-1', '-l', 'HELLO'])
1653
1654
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1655
self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1656
self.assertEqual(len(out.splitlines()), 2)
1657
1658
# regex
1659
out, err = self.run_bzr(['grep', '-r', '-1', '-l', 'H.LLO'])
1660
1661
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1662
self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1663
self.assertEqual(len(out.splitlines()), 2)
1664
1665
# fixed-string
1666
out, err = self.run_bzr(['grep', '-l', 'HELLO', '-r', '-1',
1667
'dir0', 'file1.txt'])
1668
1669
self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1670
self.assertEqual(len(out.splitlines()), 1)
1671
1672
# regex
1673
out, err = self.run_bzr(['grep', '-l', 'H.LLO', '-r', '-1',
1674
'dir0', 'file1.txt'])
1675
1676
self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
1677
self.assertEqual(len(out.splitlines()), 1)
1678
1679
# fixed-string
1680
out, err = self.run_bzr(['grep', '-l', 'HELLO',
1681
'-r', '-2', 'file0.txt'])
1682
1683
self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1684
self.assertEqual(len(out.splitlines()), 1)
1685
1686
# regex
1687
out, err = self.run_bzr(['grep', '-l', 'HE.LO',
1688
'-r', '-2', 'file0.txt'])
1689
1690
self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
1691
self.assertEqual(len(out.splitlines()), 1)
1692
1693
# fixed-string
1694
out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
1695
'-l', 'HELLO'])
1696
1697
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1698
self.assertEqual(len(out.splitlines()), 1)
1699
1700
# regex
1701
out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
1702
'-l', '.ELLO'])
1703
1704
self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
1705
self.assertEqual(len(out.splitlines()), 1)
1706
1707
def test_wtree_files_without_matches(self):
1708
"""(wtree) Ensure --files-without-match, -L works
1709
"""
1710
wd = 'foobar0'
1711
self.make_branch_and_tree(wd)
1712
os.chdir(wd)
1713
1714
self._mk_versioned_file('file0.txt', total_lines=2)
1715
self._mk_versioned_file('file1.txt', total_lines=2)
1716
self._mk_versioned_dir('dir0')
1717
self._mk_versioned_file('dir0/file00.txt', total_lines=2)
1718
self._mk_versioned_file('dir0/file01.txt', total_lines=2)
1719
1720
self._update_file('file0.txt', 'HELLO\n', checkin=False)
1721
self._update_file('dir0/file00.txt', 'HELLO\n', checkin=False)
1722
1723
# fixed-string
1724
out, err = self.run_bzr(['grep', '--files-without-match', 'HELLO'])
1725
1726
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1727
self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
1728
self.assertEqual(len(out.splitlines()), 2)
1729
1730
# regex
1731
out, err = self.run_bzr(['grep', '--files-without-match', 'HE.LO'])
1732
1733
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1734
self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
1735
self.assertEqual(len(out.splitlines()), 2)
1736
1737
# fixed-string
1738
out, err = self.run_bzr(['grep', '-L', 'HELLO'])
1739
1740
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1741
self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
1742
self.assertEqual(len(out.splitlines()), 2)
1743
1744
# regex
1745
out, err = self.run_bzr(['grep', '-L', 'HE.LO'])
1746
1747
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1748
self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
1749
self.assertEqual(len(out.splitlines()), 2)
1750
1751
# fixed-string
1752
out, err = self.run_bzr(['grep', '-L', 'HELLO', 'dir0', 'file1.txt'])
1753
1754
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1755
self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
1756
self.assertEqual(len(out.splitlines()), 2)
1757
1758
# regex
1759
out, err = self.run_bzr(['grep', '-L', '.ELLO', 'dir0', 'file1.txt'])
1760
1761
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1762
self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
1763
self.assertEqual(len(out.splitlines()), 2)
1764
1765
# fixed-string
1766
out, err = self.run_bzr(['grep', '-L', 'HELLO', 'file1.txt'])
1767
1768
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1769
self.assertEqual(len(out.splitlines()), 1)
1770
1771
# regex
1772
out, err = self.run_bzr(['grep', '-L', '.ELLO', 'file1.txt'])
1773
1774
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1775
self.assertEqual(len(out.splitlines()), 1)
1776
1777
# fixed-string
1778
out, err = self.run_bzr(['grep', '--no-recursive', '-L', 'HELLO'])
1779
1780
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1781
self.assertEqual(len(out.splitlines()), 1)
1782
1783
# regex
1784
out, err = self.run_bzr(['grep', '--no-recursive', '-L', '.ELLO'])
1785
1786
self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
1787
self.assertEqual(len(out.splitlines()), 1)
1788
1789
def test_ver_files_without_matches(self):
1790
"""(ver) Ensure --files-without-match, -L works
1791
"""
1792
wd = 'foobar0'
1793
self.make_branch_and_tree(wd)
1794
os.chdir(wd)
1795
1796
self._mk_versioned_file('file0.txt', total_lines=2) # rev 1
1797
self._mk_versioned_file('file1.txt', total_lines=2) # rev 2
1798
self._mk_versioned_dir('dir0') # rev 3
1799
self._mk_versioned_file('dir0/file00.txt', total_lines=2) # rev 4
1800
self._mk_versioned_file('dir0/file01.txt', total_lines=2) # rev 5
1801
1802
self._update_file('file0.txt', 'HELLO\n') # rev 6
1803
self._update_file('dir0/file00.txt', 'HELLO\n') # rev 7
1804
1805
# fixed-string
1806
out, err = self.run_bzr(['grep', '-r', '-1', '--files-without-match',
1807
'HELLO'])
1808
1809
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1810
self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
1811
self.assertEqual(len(out.splitlines()), 2)
1812
1813
# regex
1814
out, err = self.run_bzr(['grep', '-r', '-1', '--files-without-match',
1815
'H.LLO'])
1816
1817
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1818
self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
1819
self.assertEqual(len(out.splitlines()), 2)
1820
1821
# fixed-string
1822
out, err = self.run_bzr(['grep', '-r', '6..7', '--files-without-match',
1823
'HELLO'])
1824
1825
self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
1826
self.assertContainsRe(out, "^dir0/file00.txt~6$", flags=TestGrep._reflags)
1827
self.assertContainsRe(out, "^dir0/file01.txt~6$", flags=TestGrep._reflags)
1828
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1829
self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
1830
self.assertEqual(len(out.splitlines()), 5)
1831
1832
# regex
1833
out, err = self.run_bzr(['grep', '-r', '6..7', '--files-without-match',
1834
'H.LLO'])
1835
1836
self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
1837
self.assertContainsRe(out, "^dir0/file00.txt~6$", flags=TestGrep._reflags)
1838
self.assertContainsRe(out, "^dir0/file01.txt~6$", flags=TestGrep._reflags)
1839
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1840
self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
1841
self.assertEqual(len(out.splitlines()), 5)
1842
1843
# fixed-string
1844
out, err = self.run_bzr(['grep', '-r', '-1', '-L', 'HELLO'])
1845
1846
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1847
self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
1848
self.assertEqual(len(out.splitlines()), 2)
1849
1850
# regex
1851
out, err = self.run_bzr(['grep', '-r', '-1', '-L', 'H.LLO'])
1852
1853
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1854
self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
1855
self.assertEqual(len(out.splitlines()), 2)
1856
1857
# fixed-string
1858
out, err = self.run_bzr(['grep', '-L', 'HELLO', '-r', '-1',
1859
'dir0', 'file1.txt'])
1860
1861
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1862
self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
1863
self.assertEqual(len(out.splitlines()), 2)
1864
1865
# regex
1866
out, err = self.run_bzr(['grep', '-L', 'H.LLO', '-r', '-1',
1867
'dir0', 'file1.txt'])
1868
1869
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1870
self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
1871
self.assertEqual(len(out.splitlines()), 2)
1872
1873
# fixed-string
1874
out, err = self.run_bzr(['grep', '-L', 'HELLO',
1875
'-r', '-2', 'file1.txt'])
1876
1877
self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
1878
self.assertEqual(len(out.splitlines()), 1)
1879
1880
# regex
1881
out, err = self.run_bzr(['grep', '-L', 'HE.LO',
1882
'-r', '-2', 'file1.txt'])
1883
1884
self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
1885
self.assertEqual(len(out.splitlines()), 1)
1886
1887
# fixed-string
1888
out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
1889
'-L', 'HELLO'])
1890
1891
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1892
self.assertEqual(len(out.splitlines()), 1)
1893
1894
# regex
1895
out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
1896
'-L', '.ELLO'])
1897
1898
self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1899
self.assertEqual(len(out.splitlines()), 1)
1900
1901
def test_no_tree(self):
1902
"""Ensure grep works without working tree.
1903
"""
1904
wd0 = 'foobar0'
1905
wd1 = 'foobar1'
1906
self.make_branch_and_tree(wd0)
1907
os.chdir(wd0)
1908
self._mk_versioned_file('file0.txt')
1909
os.chdir('..')
1910
out, err = self.run_bzr(['branch', '--no-tree', wd0, wd1])
1911
os.chdir(wd1)
1912
1913
out, err = self.run_bzr(['grep', 'line1'], 3)
1914
self.assertContainsRe(err, "Cannot search working tree", flags=TestGrep._reflags)
1915
self.assertEqual(out, '')
1916
1917
out, err = self.run_bzr(['grep', '-r', '1', 'line1'])
1918
self.assertContainsRe(out, "file0.txt~1:line1", flags=TestGrep._reflags)
1919
self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
1920
1921
1922
class TestNonAscii(GrepTestBase):
1923
"""Tests for non-ascii filenames and file contents"""
1924
1925
_test_needs_features = [UnicodeFilenameFeature]
1926
1927
def test_unicode_only_file(self):
1928
"""Test filename and contents that requires a unicode encoding"""
1929
tree = self.make_branch_and_tree(".")
1930
contents = [u"\u1234"]
1931
self.build_tree(contents)
1932
tree.add(contents)
1933
tree.commit("Initial commit")
1934
as_utf8 = u"\u1234".encode("UTF-8")
1935
1936
# GZ 2010-06-07: Note we can't actually grep for \u1234 as the pattern
1937
# is mangled according to the user encoding.
1938
streams = self.run_bzr(["grep", "--files-with-matches",
1939
u"contents"], encoding="UTF-8")
1940
self.assertEqual(streams, (as_utf8 + "\n", ""))
1941
1942
streams = self.run_bzr(["grep", "-r", "1", "--files-with-matches",
1943
u"contents"], encoding="UTF-8")
1944
self.assertEqual(streams, (as_utf8 + "~1\n", ""))
1945
1946
fileencoding = osutils.get_user_encoding()
1947
as_mangled = as_utf8.decode(fileencoding, "replace").encode("UTF-8")
1948
1949
streams = self.run_bzr(["grep", "-n",
1950
u"contents"], encoding="UTF-8")
1951
self.assertEqual(streams, ("%s:1:contents of %s\n" %
1952
(as_utf8, as_mangled), ""))
1953
1954
streams = self.run_bzr(["grep", "-n", "-r", "1",
1955
u"contents"], encoding="UTF-8")
1956
self.assertEqual(streams, ("%s~1:1:contents of %s\n" %
1957
(as_utf8, as_mangled), ""))
1958
1959
1960
class TestColorGrep(GrepTestBase):
1961
"""Tests for the --color option."""
1962
1963
# GZ 2010-06-05: Does this really require the feature? Nothing prints.
1964
_test_needs_features = [ColorFeature]
1965
1966
_rev_sep = color_string('~', fg=FG.BOLD_YELLOW)
1967
_sep = color_string(':', fg=FG.BOLD_CYAN)
1968
1969
def test_color_option(self):
1970
"""Ensure options for color are valid.
1971
"""
1972
out, err = self.run_bzr(['grep', '--color', 'foo', 'bar'], 3)
1973
self.assertEqual(out, '')
1974
self.assertContainsRe(err, 'Valid values for --color are', flags=TestGrep._reflags)
1975
1976
def test_ver_matching_files(self):
1977
"""(versioned) Search for matches or no matches only"""
1978
tree = self.make_branch_and_tree(".")
1979
contents = ["d/", "d/aaa", "bbb"]
1980
self.build_tree(contents)
1981
tree.add(contents)
1982
tree.commit("Initial commit")
1983
1984
# GZ 2010-06-05: Maybe modify the working tree here
1985
1986
streams = self.run_bzr(["grep", "--color", "always", "-r", "1",
1987
"--files-with-matches", "aaa"])
1988
self.assertEqual(streams, ("".join([
1989
FG.MAGENTA, "d/aaa", self._rev_sep, "1", "\n"
1990
]), ""))
1991
1992
streams = self.run_bzr(["grep", "--color", "always", "-r", "1",
1993
"--files-without-match", "aaa"])
1994
self.assertEqual(streams, ("".join([
1995
FG.MAGENTA, "bbb", self._rev_sep, "1", "\n"
1996
]), ""))
1997
1998
def test_wtree_matching_files(self):
1999
"""(wtree) Search for matches or no matches only"""
2000
tree = self.make_branch_and_tree(".")
2001
contents = ["d/", "d/aaa", "bbb"]
2002
self.build_tree(contents)
2003
tree.add(contents)
2004
tree.commit("Initial commit")
2005
2006
# GZ 2010-06-05: Maybe modify the working tree here
2007
2008
streams = self.run_bzr(["grep", "--color", "always",
2009
"--files-with-matches", "aaa"])
2010
self.assertEqual(streams, ("".join([
2011
FG.MAGENTA, "d/aaa", FG.NONE, "\n"
2012
]), ""))
2013
2014
streams = self.run_bzr(["grep", "--color", "always",
2015
"--files-without-match", "aaa"])
2016
self.assertEqual(streams, ("".join([
2017
FG.MAGENTA, "bbb", FG.NONE, "\n"
2018
]), ""))
2019
2020
def test_ver_basic_file(self):
2021
"""(versioned) Search for pattern in specfic file.
2022
"""
2023
wd = 'foobar0'
2024
self.make_branch_and_tree(wd)
2025
os.chdir(wd)
2026
lp = 'foo is foobar'
2027
self._mk_versioned_file('file0.txt', line_prefix=lp, total_lines=1)
2028
2029
# prepare colored result
2030
foo = color_string('foo', fg=FG.BOLD_RED)
2031
res = (FG.MAGENTA + 'file0.txt'
2032
+ self._rev_sep + '1' + self._sep
2033
+ foo + ' is ' + foo + 'bar1' + '\n')
2034
txt_res = 'file0.txt~1:foo is foobar1\n'
2035
2036
nres = (FG.MAGENTA + 'file0.txt'
2037
+ self._rev_sep + '1' + self._sep + '1' + self._sep
2038
+ foo + ' is ' + foo + 'bar1' + '\n')
2039
2040
out, err = self.run_bzr(['grep', '--color',
2041
'always', '-r', '1', 'foo'])
2042
self.assertEqual(out, res)
2043
self.assertEqual(len(out.splitlines()), 1)
2044
2045
# auto should produce plain text result
2046
# as stdout is redireched here.
2047
out, err = self.run_bzr(['grep', '--color',
2048
'auto', '-r', '1', 'foo'])
2049
self.assertEqual(out, txt_res)
2050
self.assertEqual(len(out.splitlines()), 1)
2051
2052
out, err = self.run_bzr(['grep', '-i', '--color',
2053
'always', '-r', '1', 'FOO'])
2054
self.assertEqual(out, res)
2055
self.assertEqual(len(out.splitlines()), 1)
2056
2057
out, err = self.run_bzr(['grep', '--color',
2058
'always', '-r', '1', 'f.o'])
2059
self.assertEqual(out, res)
2060
self.assertEqual(len(out.splitlines()), 1)
2061
2062
out, err = self.run_bzr(['grep', '-i', '--color',
2063
'always', '-r', '1', 'F.O'])
2064
self.assertEqual(out, res)
2065
self.assertEqual(len(out.splitlines()), 1)
2066
2067
out, err = self.run_bzr(['grep', '-n', '--color',
2068
'always', '-r', '1', 'foo'])
2069
self.assertEqual(out, nres)
2070
self.assertEqual(len(out.splitlines()), 1)
2071
2072
out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2073
'always', '-r', '1', 'FOO'])
2074
self.assertEqual(out, nres)
2075
self.assertEqual(len(out.splitlines()), 1)
2076
2077
out, err = self.run_bzr(['grep', '-n', '--color',
2078
'always', '-r', '1', 'f.o'])
2079
self.assertEqual(out, nres)
2080
self.assertEqual(len(out.splitlines()), 1)
2081
2082
out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2083
'always', '-r', '1', 'F.O'])
2084
self.assertEqual(out, nres)
2085
self.assertEqual(len(out.splitlines()), 1)
2086
2087
def test_wtree_basic_file(self):
2088
"""(wtree) Search for pattern in specfic file.
2089
"""
2090
wd = 'foobar0'
2091
self.make_branch_and_tree(wd)
2092
os.chdir(wd)
2093
lp = 'foo is foobar'
2094
self._mk_versioned_file('file0.txt', line_prefix=lp, total_lines=1)
2095
2096
# prepare colored result
2097
foo = color_string('foo', fg=FG.BOLD_RED)
2098
res = (FG.MAGENTA + 'file0.txt'
2099
+ self._sep + foo + ' is ' + foo + 'bar1' + '\n')
2100
2101
nres = (FG.MAGENTA + 'file0.txt'
2102
+ self._sep + '1' + self._sep
2103
+ foo + ' is ' + foo + 'bar1' + '\n')
2104
2105
out, err = self.run_bzr(['grep', '--color',
2106
'always', 'foo'])
2107
self.assertEqual(out, res)
2108
self.assertEqual(len(out.splitlines()), 1)
2109
2110
out, err = self.run_bzr(['grep', '-i', '--color',
2111
'always', 'FOO'])
2112
self.assertEqual(out, res)
2113
self.assertEqual(len(out.splitlines()), 1)
2114
2115
out, err = self.run_bzr(['grep', '--color',
2116
'always', 'f.o'])
2117
self.assertEqual(out, res)
2118
self.assertEqual(len(out.splitlines()), 1)
2119
2120
out, err = self.run_bzr(['grep', '-i', '--color',
2121
'always', 'F.O'])
2122
self.assertEqual(out, res)
2123
self.assertEqual(len(out.splitlines()), 1)
2124
2125
out, err = self.run_bzr(['grep', '-n', '--color',
2126
'always', 'foo'])
2127
self.assertEqual(out, nres)
2128
self.assertEqual(len(out.splitlines()), 1)
2129
2130
out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2131
'always', 'FOO'])
2132
self.assertEqual(out, nres)
2133
self.assertEqual(len(out.splitlines()), 1)
2134
2135
out, err = self.run_bzr(['grep', '-n', '--color',
2136
'always', 'f.o'])
2137
self.assertEqual(out, nres)
2138
self.assertEqual(len(out.splitlines()), 1)
2139
2140
out, err = self.run_bzr(['grep', '-n', '-i', '--color',
2141
'always', 'F.O'])
2142
self.assertEqual(out, nres)
2143
self.assertEqual(len(out.splitlines()), 1)
2144
2145
2146
# copied from bzrlib.tests.blackbox.test_diff
2147
def subst_dates(string):
2148
"""Replace date strings with constant values."""
2149
return re.sub(r'\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} [-\+]\d{4}',
2150
'YYYY-MM-DD HH:MM:SS +ZZZZ', string)
2151
2152
2153
class TestGrepDiff(tests.TestCaseWithTransport):
2154
2155
def make_example_branch(self):
2156
tree = self.make_branch_and_tree('.')
2157
self.build_tree_contents([
2158
('hello', 'foo\n'),
2159
('goodbye', 'baz\n')])
2160
tree.add(['hello'])
2161
tree.commit('setup')
2162
tree.add(['goodbye'])
2163
tree.commit('setup')
2164
return tree
2165
2166
def test_grep_diff_basic(self):
2167
"""grep -p basic test."""
2168
tree = self.make_example_branch()
2169
self.build_tree_contents([('hello', 'hello world!\n')])
2170
tree.commit('updated hello')
2171
out, err = self.run_bzr(['grep', '-p', 'hello'])
2172
self.assertEqual(err, '')
2173
self.assertEqualDiff(subst_dates(out), '''\
2174
=== revno:3 ===
2175
=== modified file 'hello'
2176
--- hello YYYY-MM-DD HH:MM:SS +ZZZZ
2177
+++ hello YYYY-MM-DD HH:MM:SS +ZZZZ
2178
+hello world!
2179
=== revno:1 ===
2180
=== added file 'hello'
2181
--- hello YYYY-MM-DD HH:MM:SS +ZZZZ
2182
+++ hello YYYY-MM-DD HH:MM:SS +ZZZZ
2183
''')
2184
2185
def test_grep_diff_revision(self):
2186
"""grep -p specific revision."""
2187
tree = self.make_example_branch()
2188
self.build_tree_contents([('hello', 'hello world!\n')])
2189
tree.commit('updated hello')
2190
out, err = self.run_bzr(['grep', '-p', '-r', '3', 'hello'])
2191
self.assertEqual(err, '')
2192
self.assertEqualDiff(subst_dates(out), '''\
2193
=== revno:3 ===
2194
=== modified file 'hello'
2195
--- hello YYYY-MM-DD HH:MM:SS +ZZZZ
2196
+++ hello YYYY-MM-DD HH:MM:SS +ZZZZ
2197
+hello world!
2198
''')
2199
2200
def test_grep_diff_revision_range(self):
2201
"""grep -p revision range."""
2202
tree = self.make_example_branch()
2203
self.build_tree_contents([('hello', 'hello world!1\n')]) # rev 3
2204
tree.commit('rev3')
2205
self.build_tree_contents([('blah', 'hello world!2\n')]) # rev 4
2206
tree.add('blah')
2207
tree.commit('rev4')
2208
open('hello', 'a').write('hello world!3\n')
2209
#self.build_tree_contents([('hello', 'hello world!3\n')]) # rev 5
2210
tree.commit('rev5')
2211
out, err = self.run_bzr(['grep', '-p', '-r', '2..5', 'hello'])
2212
self.assertEqual(err, '')
2213
self.assertEqualDiff(subst_dates(out), '''\
2214
=== revno:5 ===
2215
=== modified file 'hello'
2216
--- hello YYYY-MM-DD HH:MM:SS +ZZZZ
2217
+++ hello YYYY-MM-DD HH:MM:SS +ZZZZ
2218
+hello world!3
2219
=== revno:4 ===
2220
=== added file 'blah'
2221
+hello world!2
2222
=== revno:3 ===
2223
=== modified file 'hello'
2224
--- hello YYYY-MM-DD HH:MM:SS +ZZZZ
2225
+++ hello YYYY-MM-DD HH:MM:SS +ZZZZ
2226
+hello world!1
2227
''')
2228
2229
def test_grep_diff_color(self):
2230
"""grep -p color test."""
2231
tree = self.make_example_branch()
2232
self.build_tree_contents([('hello', 'hello world!\n')])
2233
tree.commit('updated hello')
2234
out, err = self.run_bzr(['grep', '--diff', '-r', '3',
2235
'--color', 'always', 'hello'])
2236
self.assertEqual(err, '')
2237
revno = color_string('=== revno:3 ===', fg=FG.BOLD_BLUE) + '\n'
2238
filename = color_string(" === modified file 'hello'", fg=FG.BOLD_MAGENTA) + '\n'
2239
redhello = color_string('hello', fg=FG.BOLD_RED)
2240
diffstr = '''\
2241
--- hello YYYY-MM-DD HH:MM:SS +ZZZZ
2242
+++ hello YYYY-MM-DD HH:MM:SS +ZZZZ
2243
+hello world!
2244
'''
2245
diffstr = diffstr.replace('hello', redhello)
2246
self.assertEqualDiff(subst_dates(out), revno + filename + diffstr)
2247
2248
def test_grep_norevs(self):
2249
"""grep -p with zero revisions."""
2250
out, err = self.run_bzr(['init'])
2251
out, err = self.run_bzr(['grep', '--diff', 'foo'], 3)
2252
self.assertEqual(out, '')
2253
self.assertContainsRe(err, "ERROR:.*revision.* does not exist in branch")
2254
Loggerhead is a web-based interface for Breezy
Version: 2.0.1