/brz/remove-bazaar : contents of bzrlib/plugins/grep/test

: (revision 6531.3.2)

To get this branch, use:

bzr branch
http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

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