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

: (revision 7012)

To get this branch, use:

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

6614.1.3 by Vincent Ladeuil Fix assertEquals being deprecated by using assertEqual.	1	# Copyright (C) 2010, 2011, 2012, 2016 Canonical Ltd
0.40.11 by Parth Malwankar added basic test	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
6624 by Jelmer Vernooĳ Merge Python3 porting work ('py3 pokes')	23	from ... import tests, osutils
	24	from ..._termcolor import color_string, FG
0.40.11 by Parth Malwankar added basic test	25
6624 by Jelmer Vernooĳ Merge Python3 porting work ('py3 pokes')	26	from ...tests.features import (
6531.3.8 by Jelmer Vernooij Move color feature into bzrlib.tests.features.	27	ColorFeature,
	28	UnicodeFilenameFeature,
	29	)
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.	30
0.40.87 by Parth Malwankar updated tests for better coverage of pattern and fixed-string match.	31	# NOTE: As bzr-grep optimizes PATTERN search to -F/--fixed-string
	32	# for patterns that are not alphanumeric+whitespace, we test grep
	33	# specfically with patterns that have special characters so that
	34	# regex path is tested. alphanumeric patterns test the -F path.
	35
0.43.11 by Parth Malwankar test cases for colored results.	36	class GrepTestBase(tests.TestCaseWithTransport):
	37	"""Base class for testing grep.
	38
	39	Provides support methods for creating directory and file revisions.
	40	"""
0.40.99 by Parth Malwankar updated tests to use assertContainsRe/assertNotContainsRe	41	_reflags = re.MULTILINE\|re.DOTALL
0.40.11 by Parth Malwankar added basic test	42
0.40.26 by Parth Malwankar test passing for multiple matches	43	def _mk_file(self, path, line_prefix, total_lines, versioned):
0.40.13 by Parth Malwankar added tests for -R and -i	44	text=''
	45	for i in range(total_lines):
	46	text += line_prefix + str(i+1) + "\n"
	47
6973.12.11 by Jelmer Vernooĳ Fix some more tests.	48	with open(path, 'w') as f:
6973.12.11 by Jelmer Vernooĳ Fix some more tests.	49	f.write(text)
0.40.12 by Parth Malwankar added test for versioned file	50	if versioned:
0.40.12 by Parth Malwankar added test for versioned file	51	self.run_bzr(['add', path])
0.40.25 by Parth Malwankar added test case for multilevel dir.	52	self.run_bzr(['ci', '-m', '"' + path + '"'])
0.40.12 by Parth Malwankar added test for versioned file	53
0.41.14 by Parth Malwankar updated help and added test.	54	def _update_file(self, path, text, checkin=True):
0.40.34 by Parth Malwankar added tests for single revision history search	55	"""append text to file 'path' and check it in"""
6973.12.11 by Jelmer Vernooĳ Fix some more tests.	56	with open(path, 'a') as f:
6973.12.11 by Jelmer Vernooĳ Fix some more tests.	57	f.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
6798.1.1 by Jelmer Vernooĳ Properly escape backslashes.	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.41.17 by Parth Malwankar added tests.	1451	def test_versioned_binary_file_grep(self):
	1452	"""(versioned) Grep for pattern in binary file.
	1453	"""
	1454	wd = 'foobar0'
	1455	self.make_branch_and_tree(wd)
	1456	os.chdir(wd)
0.40.107 by Parth Malwankar made tests more precise	1457	self._mk_versioned_file('file.txt')
0.40.60 by Parth Malwankar 'binary file skipped' warning is only shown with --verbose flag	1458	self._mk_versioned_file('file0.bin')
	1459	self._update_file('file0.bin', "\x00lineNN\x00\n")
	1460
	1461	# note: set --verbose/-v flag to get the skip message.
	1462	out, err = self.run_bzr(['grep', '-v', '-r', 'last:1',
	1463	'lineNN', 'file0.bin'])
0.40.99 by Parth Malwankar updated tests to use assertContainsRe/assertNotContainsRe	1464	self.assertNotContainsRe(out, "file0.bin", flags=TestGrep._reflags)
	1465	self.assertContainsRe(err, "Binary file.file0.bin.skipped", flags=TestGrep._reflags)
0.40.109 by Parth Malwankar changed assertTrue to assertEqual	1466	self.assertEqual(len(out.splitlines()), 0)
	1467	self.assertEqual(len(err.splitlines()), 1)
0.41.17 by Parth Malwankar added tests.	1468
0.40.87 by Parth Malwankar updated tests for better coverage of pattern and fixed-string match.	1469	out, err = self.run_bzr(['grep', '-v', '-r', 'last:1',
	1470	'line.N', 'file0.bin'])
0.40.99 by Parth Malwankar updated tests to use assertContainsRe/assertNotContainsRe	1471	self.assertNotContainsRe(out, "file0.bin", flags=TestGrep._reflags)
	1472	self.assertContainsRe(err, "Binary file.file0.bin.skipped", flags=TestGrep._reflags)
0.40.109 by Parth Malwankar changed assertTrue to assertEqual	1473	self.assertEqual(len(out.splitlines()), 0)
	1474	self.assertEqual(len(err.splitlines()), 1)
0.40.87 by Parth Malwankar updated tests for better coverage of pattern and fixed-string match.	1475
0.41.17 by Parth Malwankar added tests.	1476	def test_wtree_binary_file_grep(self):
	1477	"""(wtree) Grep for pattern in binary file.
	1478	"""
0.40.47 by Parth Malwankar fixes bug #531336. binary files are now skipped.	1479	wd = 'foobar0'
	1480	self.make_branch_and_tree(wd)
	1481	os.chdir(wd)
0.40.60 by Parth Malwankar 'binary file skipped' warning is only shown with --verbose flag	1482	self._mk_versioned_file('file0.bin')
	1483	self._update_file('file0.bin', "\x00lineNN\x00\n")
	1484
	1485	# note: set --verbose/-v flag to get the skip message.
	1486	out, err = self.run_bzr(['grep', '-v', 'lineNN', 'file0.bin'])
0.40.99 by Parth Malwankar updated tests to use assertContainsRe/assertNotContainsRe	1487	self.assertNotContainsRe(out, "file0.bin:line1", flags=TestGrep._reflags)
	1488	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	1489
	1490	# binary warning should not be shown without --verbose
	1491	out, err = self.run_bzr(['grep', 'lineNN', 'file0.bin'])
0.40.99 by Parth Malwankar updated tests to use assertContainsRe/assertNotContainsRe	1492	self.assertNotContainsRe(out, "file0.bin:line1", flags=TestGrep._reflags)
	1493	self.assertNotContainsRe(err, "Binary file", flags=TestGrep._reflags)
0.40.47 by Parth Malwankar fixes bug #531336. binary files are now skipped.	1494
0.40.96 by Parth Malwankar added test to ensure that various revspecs work.	1495	def test_revspec(self):
	1496	"""Ensure various revspecs work
	1497	"""
	1498	wd = 'foobar0'
	1499	self.make_branch_and_tree(wd)
	1500	os.chdir(wd)
	1501	self._mk_versioned_dir('dir0') # rev1
	1502	self._mk_versioned_file('dir0/file0.txt') # rev2
	1503	self._update_file('dir0/file0.txt', "v3 text\n") # rev3
	1504	self._update_file('dir0/file0.txt', "v4 text\n") # rev4
	1505	self._update_file('dir0/file0.txt', "v5 text\n") # rev5
	1506
	1507	out, err = self.run_bzr(['grep', '-r', 'revno:1..2', 'v3'])
0.40.99 by Parth Malwankar updated tests to use assertContainsRe/assertNotContainsRe	1508	self.assertNotContainsRe(out, "file0", flags=TestGrep._reflags)
0.40.110 by Parth Malwankar made some tests more precise	1509	self.assertEqual(len(out.splitlines()), 0)
0.40.96 by Parth Malwankar added test to ensure that various revspecs work.	1510
	1511	out, err = self.run_bzr(['grep', '-r', 'revno:4..', 'v4'])
0.40.99 by Parth Malwankar updated tests to use assertContainsRe/assertNotContainsRe	1512	self.assertContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
0.40.110 by Parth Malwankar made some tests more precise	1513	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.	1514
	1515	out, err = self.run_bzr(['grep', '-r', '..revno:3', 'v4'])
0.40.99 by Parth Malwankar updated tests to use assertContainsRe/assertNotContainsRe	1516	self.assertNotContainsRe(out, "file0", flags=TestGrep._reflags)
0.40.110 by Parth Malwankar made some tests more precise	1517	self.assertEqual(len(out.splitlines()), 0)
0.40.96 by Parth Malwankar added test to ensure that various revspecs work.	1518
	1519	out, err = self.run_bzr(['grep', '-r', '..revno:3', 'v3'])
0.40.99 by Parth Malwankar updated tests to use assertContainsRe/assertNotContainsRe	1520	self.assertContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
0.40.110 by Parth Malwankar made some tests more precise	1521	self.assertEqual(len(out.splitlines()), 1)
0.40.96 by Parth Malwankar added test to ensure that various revspecs work.	1522
0.40.114 by Parth Malwankar test for wtree -l/--files-with-matches	1523	def test_wtree_files_with_matches(self):
	1524	"""(wtree) Ensure --files-with-matches, -l works
	1525	"""
	1526	wd = 'foobar0'
	1527	self.make_branch_and_tree(wd)
	1528	os.chdir(wd)
	1529
	1530	self._mk_versioned_file('file0.txt', total_lines=2)
	1531	self._mk_versioned_file('file1.txt', total_lines=2)
	1532	self._mk_versioned_dir('dir0')
	1533	self._mk_versioned_file('dir0/file00.txt', total_lines=2)
	1534	self._mk_versioned_file('dir0/file01.txt', total_lines=2)
	1535
	1536	self._update_file('file0.txt', 'HELLO\n', checkin=False)
	1537	self._update_file('dir0/file00.txt', 'HELLO\n', checkin=False)
	1538
0.40.123 by Parth Malwankar added regex tests for wtree -l search	1539	# fixed-string
0.40.114 by Parth Malwankar test for wtree -l/--files-with-matches	1540	out, err = self.run_bzr(['grep', '--files-with-matches', 'HELLO'])
	1541
	1542	self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
	1543	self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
	1544	self.assertEqual(len(out.splitlines()), 2)
	1545
0.40.123 by Parth Malwankar added regex tests for wtree -l search	1546	# regex
	1547	out, err = self.run_bzr(['grep', '--files-with-matches', 'HE.LO'])
	1548
	1549	self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
	1550	self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
	1551	self.assertEqual(len(out.splitlines()), 2)
	1552
	1553	# fixed-string
0.40.114 by Parth Malwankar test for wtree -l/--files-with-matches	1554	out, err = self.run_bzr(['grep', '-l', 'HELLO'])
	1555
	1556	self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
	1557	self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
	1558	self.assertEqual(len(out.splitlines()), 2)
	1559
0.40.123 by Parth Malwankar added regex tests for wtree -l search	1560	# regex
	1561	out, err = self.run_bzr(['grep', '-l', 'HE.LO'])
	1562
	1563	self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
	1564	self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
	1565	self.assertEqual(len(out.splitlines()), 2)
	1566
	1567	# fixed-string
0.40.114 by Parth Malwankar test for wtree -l/--files-with-matches	1568	out, err = self.run_bzr(['grep', '-l', 'HELLO', 'dir0', 'file1.txt'])
	1569
	1570	self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
	1571	self.assertEqual(len(out.splitlines()), 1)
	1572
0.40.123 by Parth Malwankar added regex tests for wtree -l search	1573	# regex
	1574	out, err = self.run_bzr(['grep', '-l', '.ELLO', 'dir0', 'file1.txt'])
	1575
	1576	self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
	1577	self.assertEqual(len(out.splitlines()), 1)
	1578
	1579	# fixed-string
0.40.114 by Parth Malwankar test for wtree -l/--files-with-matches	1580	out, err = self.run_bzr(['grep', '-l', 'HELLO', 'file0.txt'])
	1581
	1582	self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
	1583	self.assertEqual(len(out.splitlines()), 1)
	1584
0.40.123 by Parth Malwankar added regex tests for wtree -l search	1585	# regex
	1586	out, err = self.run_bzr(['grep', '-l', '.ELLO', 'file0.txt'])
	1587
	1588	self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
	1589	self.assertEqual(len(out.splitlines()), 1)
	1590
	1591	# fixed-string
0.40.114 by Parth Malwankar test for wtree -l/--files-with-matches	1592	out, err = self.run_bzr(['grep', '--no-recursive', '-l', 'HELLO'])
	1593
	1594	self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
	1595	self.assertEqual(len(out.splitlines()), 1)
	1596
0.40.123 by Parth Malwankar added regex tests for wtree -l search	1597	# regex
	1598	out, err = self.run_bzr(['grep', '--no-recursive', '-l', '.ELLO'])
	1599
	1600	self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
	1601	self.assertEqual(len(out.splitlines()), 1)
	1602
0.40.115 by Parth Malwankar added test for versioned grep.	1603	def test_ver_files_with_matches(self):
	1604	"""(ver) Ensure --files-with-matches, -l works
	1605	"""
	1606	wd = 'foobar0'
	1607	self.make_branch_and_tree(wd)
	1608	os.chdir(wd)
	1609
	1610	self._mk_versioned_file('file0.txt', total_lines=2) # rev 1
	1611	self._mk_versioned_file('file1.txt', total_lines=2) # rev 2
	1612	self._mk_versioned_dir('dir0') # rev 3
	1613	self._mk_versioned_file('dir0/file00.txt', total_lines=2) # rev 4
	1614	self._mk_versioned_file('dir0/file01.txt', total_lines=2) # rev 5
	1615
	1616	self._update_file('file0.txt', 'HELLO\n') # rev 6
	1617	self._update_file('dir0/file00.txt', 'HELLO\n') # rev 7
	1618
0.40.120 by Parth Malwankar added tests for regex search for -l/--files-with-matches	1619	# fixed-string
	1620	out, err = self.run_bzr(['grep', '-r', '-1', '--files-with-matches',
	1621	'HELLO'])
	1622
	1623	self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
	1624	self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
	1625	self.assertEqual(len(out.splitlines()), 2)
	1626
	1627	# regex
	1628	out, err = self.run_bzr(['grep', '-r', '-1', '--files-with-matches',
	1629	'H.LLO'])
	1630
	1631	self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
	1632	self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
	1633	self.assertEqual(len(out.splitlines()), 2)
	1634
	1635	# fixed-string
	1636	out, err = self.run_bzr(['grep', '-r', '6..7', '--files-with-matches',
	1637	'HELLO'])
	1638
	1639	self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
	1640	self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
	1641	self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
	1642	self.assertEqual(len(out.splitlines()), 3)
	1643
	1644	# regex
	1645	out, err = self.run_bzr(['grep', '-r', '6..7', '--files-with-matches',
	1646	'H.LLO'])
	1647
	1648	self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
	1649	self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
	1650	self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
	1651	self.assertEqual(len(out.splitlines()), 3)
	1652
	1653	# fixed-string
0.40.115 by Parth Malwankar added test for versioned grep.	1654	out, err = self.run_bzr(['grep', '-r', '-1', '-l', 'HELLO'])
	1655
	1656	self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
	1657	self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
	1658	self.assertEqual(len(out.splitlines()), 2)
	1659
0.40.120 by Parth Malwankar added tests for regex search for -l/--files-with-matches	1660	# regex
	1661	out, err = self.run_bzr(['grep', '-r', '-1', '-l', 'H.LLO'])
	1662
	1663	self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
	1664	self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
	1665	self.assertEqual(len(out.splitlines()), 2)
	1666
	1667	# fixed-string
0.40.115 by Parth Malwankar added test for versioned grep.	1668	out, err = self.run_bzr(['grep', '-l', 'HELLO', '-r', '-1',
	1669	'dir0', 'file1.txt'])
	1670
	1671	self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
	1672	self.assertEqual(len(out.splitlines()), 1)
	1673
0.40.120 by Parth Malwankar added tests for regex search for -l/--files-with-matches	1674	# regex
	1675	out, err = self.run_bzr(['grep', '-l', 'H.LLO', '-r', '-1',
	1676	'dir0', 'file1.txt'])
	1677
	1678	self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
	1679	self.assertEqual(len(out.splitlines()), 1)
	1680
	1681	# fixed-string
0.40.115 by Parth Malwankar added test for versioned grep.	1682	out, err = self.run_bzr(['grep', '-l', 'HELLO',
	1683	'-r', '-2', 'file0.txt'])
	1684
	1685	self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
	1686	self.assertEqual(len(out.splitlines()), 1)
	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', '-l', 'HE.LO',
	1690	'-r', '-2', 'file0.txt'])
	1691
	1692	self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
	1693	self.assertEqual(len(out.splitlines()), 1)
	1694
	1695	# fixed-string
0.40.115 by Parth Malwankar added test for versioned grep.	1696	out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
	1697	'-l', 'HELLO'])
	1698
	1699	self.assertContainsRe(out, "^file0.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', '--no-recursive', '-r', '-1',
	1704	'-l', '.ELLO'])
	1705
	1706	self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
	1707	self.assertEqual(len(out.splitlines()), 1)
0.40.114 by Parth Malwankar test for wtree -l/--files-with-matches	1708
0.40.124 by Parth Malwankar added test for wtree grep with -L/--files-without-match	1709	def test_wtree_files_without_matches(self):
0.40.126 by Parth Malwankar renamed --files-without-matches => --files-without-match	1710	"""(wtree) Ensure --files-without-match, -L works
0.40.124 by Parth Malwankar added test for wtree grep with -L/--files-without-match	1711	"""
	1712	wd = 'foobar0'
	1713	self.make_branch_and_tree(wd)
	1714	os.chdir(wd)
	1715
	1716	self._mk_versioned_file('file0.txt', total_lines=2)
	1717	self._mk_versioned_file('file1.txt', total_lines=2)
	1718	self._mk_versioned_dir('dir0')
	1719	self._mk_versioned_file('dir0/file00.txt', total_lines=2)
	1720	self._mk_versioned_file('dir0/file01.txt', total_lines=2)
	1721
	1722	self._update_file('file0.txt', 'HELLO\n', checkin=False)
	1723	self._update_file('dir0/file00.txt', 'HELLO\n', checkin=False)
	1724
	1725	# fixed-string
0.40.126 by Parth Malwankar renamed --files-without-matches => --files-without-match	1726	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	1727
	1728	self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
	1729	self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
	1730	self.assertEqual(len(out.splitlines()), 2)
	1731
	1732	# regex
0.40.126 by Parth Malwankar renamed --files-without-matches => --files-without-match	1733	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	1734
	1735	self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
	1736	self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
	1737	self.assertEqual(len(out.splitlines()), 2)
	1738
	1739	# fixed-string
	1740	out, err = self.run_bzr(['grep', '-L', 'HELLO'])
	1741
	1742	self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
	1743	self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
	1744	self.assertEqual(len(out.splitlines()), 2)
	1745
	1746	# regex
	1747	out, err = self.run_bzr(['grep', '-L', 'HE.LO'])
	1748
	1749	self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
	1750	self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
	1751	self.assertEqual(len(out.splitlines()), 2)
	1752
	1753	# fixed-string
	1754	out, err = self.run_bzr(['grep', '-L', 'HELLO', 'dir0', 'file1.txt'])
	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
	1761	out, err = self.run_bzr(['grep', '-L', '.ELLO', 'dir0', 'file1.txt'])
	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', 'file1.txt'])
	1769
	1770	self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
	1771	self.assertEqual(len(out.splitlines()), 1)
	1772
	1773	# regex
	1774	out, err = self.run_bzr(['grep', '-L', '.ELLO', 'file1.txt'])
	1775
	1776	self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
	1777	self.assertEqual(len(out.splitlines()), 1)
	1778
	1779	# fixed-string
	1780	out, err = self.run_bzr(['grep', '--no-recursive', '-L', 'HELLO'])
	1781
	1782	self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
	1783	self.assertEqual(len(out.splitlines()), 1)
	1784
	1785	# regex
	1786	out, err = self.run_bzr(['grep', '--no-recursive', '-L', '.ELLO'])
	1787
	1788	self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
	1789	self.assertEqual(len(out.splitlines()), 1)
	1790
0.40.122 by Parth Malwankar added test for versioned -L and some fixes.	1791	def test_ver_files_without_matches(self):
0.40.126 by Parth Malwankar renamed --files-without-matches => --files-without-match	1792	"""(ver) Ensure --files-without-match, -L works
0.40.122 by Parth Malwankar added test for versioned -L and some fixes.	1793	"""
	1794	wd = 'foobar0'
	1795	self.make_branch_and_tree(wd)
	1796	os.chdir(wd)
	1797
	1798	self._mk_versioned_file('file0.txt', total_lines=2) # rev 1
	1799	self._mk_versioned_file('file1.txt', total_lines=2) # rev 2
	1800	self._mk_versioned_dir('dir0') # rev 3
	1801	self._mk_versioned_file('dir0/file00.txt', total_lines=2) # rev 4
	1802	self._mk_versioned_file('dir0/file01.txt', total_lines=2) # rev 5
	1803
	1804	self._update_file('file0.txt', 'HELLO\n') # rev 6
	1805	self._update_file('dir0/file00.txt', 'HELLO\n') # rev 7
	1806
	1807	# fixed-string
0.40.126 by Parth Malwankar renamed --files-without-matches => --files-without-match	1808	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.	1809	'HELLO'])
	1810
	1811	self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
	1812	self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
	1813	self.assertEqual(len(out.splitlines()), 2)
	1814
	1815	# regex
0.40.126 by Parth Malwankar renamed --files-without-matches => --files-without-match	1816	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.	1817	'H.LLO'])
	1818
	1819	self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
	1820	self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
	1821	self.assertEqual(len(out.splitlines()), 2)
	1822
	1823	# fixed-string
0.40.126 by Parth Malwankar renamed --files-without-matches => --files-without-match	1824	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.	1825	'HELLO'])
	1826
	1827	self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
	1828	self.assertContainsRe(out, "^dir0/file00.txt~6$", flags=TestGrep._reflags)
	1829	self.assertContainsRe(out, "^dir0/file01.txt~6$", flags=TestGrep._reflags)
	1830	self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
	1831	self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
	1832	self.assertEqual(len(out.splitlines()), 5)
	1833
	1834	# regex
0.40.126 by Parth Malwankar renamed --files-without-matches => --files-without-match	1835	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.	1836	'H.LLO'])
	1837
	1838	self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
	1839	self.assertContainsRe(out, "^dir0/file00.txt~6$", flags=TestGrep._reflags)
	1840	self.assertContainsRe(out, "^dir0/file01.txt~6$", flags=TestGrep._reflags)
	1841	self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
	1842	self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
	1843	self.assertEqual(len(out.splitlines()), 5)
	1844
	1845	# fixed-string
	1846	out, err = self.run_bzr(['grep', '-r', '-1', '-L', 'HELLO'])
	1847
	1848	self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
	1849	self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
	1850	self.assertEqual(len(out.splitlines()), 2)
	1851
	1852	# regex
	1853	out, err = self.run_bzr(['grep', '-r', '-1', '-L', 'H.LLO'])
	1854
	1855	self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
	1856	self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
	1857	self.assertEqual(len(out.splitlines()), 2)
	1858
	1859	# fixed-string
	1860	out, err = self.run_bzr(['grep', '-L', 'HELLO', '-r', '-1',
	1861	'dir0', 'file1.txt'])
	1862
	1863	self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
	1864	self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
	1865	self.assertEqual(len(out.splitlines()), 2)
	1866
	1867	# regex
	1868	out, err = self.run_bzr(['grep', '-L', 'H.LLO', '-r', '-1',
	1869	'dir0', 'file1.txt'])
	1870
	1871	self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
	1872	self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
	1873	self.assertEqual(len(out.splitlines()), 2)
	1874
	1875	# fixed-string
	1876	out, err = self.run_bzr(['grep', '-L', 'HELLO',
	1877	'-r', '-2', 'file1.txt'])
	1878
	1879	self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
	1880	self.assertEqual(len(out.splitlines()), 1)
	1881
	1882	# regex
	1883	out, err = self.run_bzr(['grep', '-L', 'HE.LO',
	1884	'-r', '-2', 'file1.txt'])
	1885
	1886	self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
	1887	self.assertEqual(len(out.splitlines()), 1)
	1888
	1889	# fixed-string
	1890	out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
	1891	'-L', 'HELLO'])
	1892
	1893	self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
	1894	self.assertEqual(len(out.splitlines()), 1)
	1895
	1896	# regex
	1897	out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
	1898	'-L', '.ELLO'])
	1899
1900	self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
1901	self.assertEqual(len(out.splitlines()), 1)
1902
0.40.131 by Parth Malwankar bzr grep now allows grepping with -r even when no tree exists.	1903	def test_no_tree(self):
	1904	"""Ensure grep works without working tree.
	1905	"""
	1906	wd0 = 'foobar0'
	1907	wd1 = 'foobar1'
	1908	self.make_branch_and_tree(wd0)
	1909	os.chdir(wd0)
	1910	self._mk_versioned_file('file0.txt')
	1911	os.chdir('..')
	1912	out, err = self.run_bzr(['branch', '--no-tree', wd0, wd1])
	1913	os.chdir(wd1)
	1914
	1915	out, err = self.run_bzr(['grep', 'line1'], 3)
	1916	self.assertContainsRe(err, "Cannot search working tree", flags=TestGrep._reflags)
	1917	self.assertEqual(out, '')
	1918
	1919	out, err = self.run_bzr(['grep', '-r', '1', 'line1'])
	1920	self.assertContainsRe(out, "file0.txt~1:line1", flags=TestGrep._reflags)
	1921	self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
	1922
0.43.11 by Parth Malwankar test cases for colored results.	1923
0.46.21 by Martin Fix and test bytes/unicode issue but there's more to do in this area	1924	class TestNonAscii(GrepTestBase):
	1925	"""Tests for non-ascii filenames and file contents"""
	1926
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.	1927	_test_needs_features = [UnicodeFilenameFeature]
0.46.21 by Martin Fix and test bytes/unicode issue but there's more to do in this area	1928
	1929	def test_unicode_only_file(self):
	1930	"""Test filename and contents that requires a unicode encoding"""
	1931	tree = self.make_branch_and_tree(".")
	1932	contents = [u"\u1234"]
	1933	self.build_tree(contents)
	1934	tree.add(contents)
	1935	tree.commit("Initial commit")
	1936	as_utf8 = u"\u1234".encode("UTF-8")
	1937
	1938	# GZ 2010-06-07: Note we can't actually grep for \u1234 as the pattern
	1939	# is mangled according to the user encoding.
	1940	streams = self.run_bzr(["grep", "--files-with-matches",
	1941	u"contents"], encoding="UTF-8")
	1942	self.assertEqual(streams, (as_utf8 + "\n", ""))
	1943
	1944	streams = self.run_bzr(["grep", "-r", "1", "--files-with-matches",
	1945	u"contents"], encoding="UTF-8")
	1946	self.assertEqual(streams, (as_utf8 + "~1\n", ""))
	1947
	1948	fileencoding = osutils.get_user_encoding()
	1949	as_mangled = as_utf8.decode(fileencoding, "replace").encode("UTF-8")
	1950
	1951	streams = self.run_bzr(["grep", "-n",
	1952	u"contents"], encoding="UTF-8")
	1953	self.assertEqual(streams, ("%s:1:contents of %s\n" %
	1954	(as_utf8, as_mangled), ""))
	1955
	1956	streams = self.run_bzr(["grep", "-n", "-r", "1",
	1957	u"contents"], encoding="UTF-8")
	1958	self.assertEqual(streams, ("%s~1:1:contents of %s\n" %
	1959	(as_utf8, as_mangled), ""))
	1960
	1961
0.43.11 by Parth Malwankar test cases for colored results.	1962	class TestColorGrep(GrepTestBase):
0.43.11 by Parth Malwankar test cases for colored results.	1963	"""Tests for the --color option."""
0.43.12 by Parth Malwankar added feature for running color tests conditionally	1964
0.46.17 by Martin Fix previously untested issue with colour and match-only, and test a related issue	1965	# GZ 2010-06-05: Does this really require the feature? Nothing prints.
6531.3.8 by Jelmer Vernooij Move color feature into bzrlib.tests.features.	1966	_test_needs_features = [ColorFeature]
0.43.12 by Parth Malwankar added feature for running color tests conditionally	1967
0.43.11 by Parth Malwankar test cases for colored results.	1968	_rev_sep = color_string('~', fg=FG.BOLD_YELLOW)
	1969	_sep = color_string(':', fg=FG.BOLD_CYAN)
	1970
	1971	def test_color_option(self):
	1972	"""Ensure options for color are valid.
	1973	"""
	1974	out, err = self.run_bzr(['grep', '--color', 'foo', 'bar'], 3)
	1975	self.assertEqual(out, '')
	1976	self.assertContainsRe(err, 'Valid values for --color are', flags=TestGrep._reflags)
	1977
0.46.17 by Martin Fix previously untested issue with colour and match-only, and test a related issue	1978	def test_ver_matching_files(self):
	1979	"""(versioned) Search for matches or no matches only"""
	1980	tree = self.make_branch_and_tree(".")
	1981	contents = ["d/", "d/aaa", "bbb"]
	1982	self.build_tree(contents)
	1983	tree.add(contents)
	1984	tree.commit("Initial commit")
	1985
	1986	# GZ 2010-06-05: Maybe modify the working tree here
	1987
	1988	streams = self.run_bzr(["grep", "--color", "always", "-r", "1",
	1989	"--files-with-matches", "aaa"])
	1990	self.assertEqual(streams, ("".join([
	1991	FG.MAGENTA, "d/aaa", self._rev_sep, "1", "\n"
	1992	]), ""))
	1993
	1994	streams = self.run_bzr(["grep", "--color", "always", "-r", "1",
	1995	"--files-without-match", "aaa"])
	1996	self.assertEqual(streams, ("".join([
	1997	FG.MAGENTA, "bbb", self._rev_sep, "1", "\n"
	1998	]), ""))
	1999
	2000	def test_wtree_matching_files(self):
	2001	"""(wtree) Search for matches or no matches only"""
	2002	tree = self.make_branch_and_tree(".")
	2003	contents = ["d/", "d/aaa", "bbb"]
	2004	self.build_tree(contents)
	2005	tree.add(contents)
	2006	tree.commit("Initial commit")
	2007
	2008	# GZ 2010-06-05: Maybe modify the working tree here
	2009
	2010	streams = self.run_bzr(["grep", "--color", "always",
	2011	"--files-with-matches", "aaa"])
	2012	self.assertEqual(streams, ("".join([
	2013	FG.MAGENTA, "d/aaa", FG.NONE, "\n"
	2014	]), ""))
	2015
	2016	streams = self.run_bzr(["grep", "--color", "always",
	2017	"--files-without-match", "aaa"])
	2018	self.assertEqual(streams, ("".join([
	2019	FG.MAGENTA, "bbb", FG.NONE, "\n"
	2020	]), ""))
	2021
0.43.11 by Parth Malwankar test cases for colored results.	2022	def test_ver_basic_file(self):
	2023	"""(versioned) Search for pattern in specfic file.
	2024	"""
	2025	wd = 'foobar0'
	2026	self.make_branch_and_tree(wd)
	2027	os.chdir(wd)
	2028	lp = 'foo is foobar'
	2029	self._mk_versioned_file('file0.txt', line_prefix=lp, total_lines=1)
	2030
	2031	# prepare colored result
	2032	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	2033	res = (FG.MAGENTA + 'file0.txt'
0.43.11 by Parth Malwankar test cases for colored results.	2034	+ self._rev_sep + '1' + self._sep
0.43.11 by Parth Malwankar test cases for colored results.	2035	+ foo + ' is ' + foo + 'bar1' + '\n')
0.40.133 by Parth Malwankar added test case to check --color=auto	2036	txt_res = 'file0.txt~1:foo is foobar1\n'
0.43.11 by Parth Malwankar test cases for colored results.	2037
0.46.4 by Martin Move remaining formatting setup out of _file_grep and save a colour switch as a side effect	2038	nres = (FG.MAGENTA + 'file0.txt'
0.43.11 by Parth Malwankar test cases for colored results.	2039	+ self._rev_sep + '1' + self._sep + '1' + self._sep
	2040	+ foo + ' is ' + foo + 'bar1' + '\n')
	2041
	2042	out, err = self.run_bzr(['grep', '--color',
	2043	'always', '-r', '1', 'foo'])
	2044	self.assertEqual(out, res)
	2045	self.assertEqual(len(out.splitlines()), 1)
	2046
0.40.133 by Parth Malwankar added test case to check --color=auto	2047	# auto should produce plain text result
	2048	# as stdout is redireched here.
	2049	out, err = self.run_bzr(['grep', '--color',
	2050	'auto', '-r', '1', 'foo'])
	2051	self.assertEqual(out, txt_res)
	2052	self.assertEqual(len(out.splitlines()), 1)
	2053
0.43.11 by Parth Malwankar test cases for colored results.	2054	out, err = self.run_bzr(['grep', '-i', '--color',
	2055	'always', '-r', '1', 'FOO'])
	2056	self.assertEqual(out, res)
	2057	self.assertEqual(len(out.splitlines()), 1)
	2058
	2059	out, err = self.run_bzr(['grep', '--color',
	2060	'always', '-r', '1', 'f.o'])
	2061	self.assertEqual(out, res)
	2062	self.assertEqual(len(out.splitlines()), 1)
	2063
	2064	out, err = self.run_bzr(['grep', '-i', '--color',
	2065	'always', '-r', '1', 'F.O'])
	2066	self.assertEqual(out, res)
	2067	self.assertEqual(len(out.splitlines()), 1)
	2068
	2069	out, err = self.run_bzr(['grep', '-n', '--color',
	2070	'always', '-r', '1', 'foo'])
	2071	self.assertEqual(out, nres)
	2072	self.assertEqual(len(out.splitlines()), 1)
	2073
	2074	out, err = self.run_bzr(['grep', '-n', '-i', '--color',
	2075	'always', '-r', '1', 'FOO'])
	2076	self.assertEqual(out, nres)
	2077	self.assertEqual(len(out.splitlines()), 1)
	2078
	2079	out, err = self.run_bzr(['grep', '-n', '--color',
	2080	'always', '-r', '1', 'f.o'])
	2081	self.assertEqual(out, nres)
	2082	self.assertEqual(len(out.splitlines()), 1)
	2083
	2084	out, err = self.run_bzr(['grep', '-n', '-i', '--color',
	2085	'always', '-r', '1', 'F.O'])
	2086	self.assertEqual(out, nres)
	2087	self.assertEqual(len(out.splitlines()), 1)
	2088
	2089	def test_wtree_basic_file(self):
	2090	"""(wtree) Search for pattern in specfic file.
	2091	"""
	2092	wd = 'foobar0'
	2093	self.make_branch_and_tree(wd)
	2094	os.chdir(wd)
	2095	lp = 'foo is foobar'
	2096	self._mk_versioned_file('file0.txt', line_prefix=lp, total_lines=1)
	2097
	2098	# prepare colored result
	2099	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	2100	res = (FG.MAGENTA + 'file0.txt'
0.43.11 by Parth Malwankar test cases for colored results.	2101	+ self._sep + foo + ' is ' + foo + 'bar1' + '\n')
0.43.11 by Parth Malwankar test cases for colored results.	2102
0.46.4 by Martin Move remaining formatting setup out of _file_grep and save a colour switch as a side effect	2103	nres = (FG.MAGENTA + 'file0.txt'
0.43.11 by Parth Malwankar test cases for colored results.	2104	+ self._sep + '1' + self._sep
	2105	+ foo + ' is ' + foo + 'bar1' + '\n')
	2106
	2107	out, err = self.run_bzr(['grep', '--color',
	2108	'always', 'foo'])
	2109	self.assertEqual(out, res)
	2110	self.assertEqual(len(out.splitlines()), 1)
	2111
	2112	out, err = self.run_bzr(['grep', '-i', '--color',
	2113	'always', 'FOO'])
	2114	self.assertEqual(out, res)
	2115	self.assertEqual(len(out.splitlines()), 1)
	2116
	2117	out, err = self.run_bzr(['grep', '--color',
	2118	'always', 'f.o'])
	2119	self.assertEqual(out, res)
	2120	self.assertEqual(len(out.splitlines()), 1)
	2121
	2122	out, err = self.run_bzr(['grep', '-i', '--color',
	2123	'always', 'F.O'])
	2124	self.assertEqual(out, res)
	2125	self.assertEqual(len(out.splitlines()), 1)
	2126
	2127	out, err = self.run_bzr(['grep', '-n', '--color',
	2128	'always', 'foo'])
	2129	self.assertEqual(out, nres)
	2130	self.assertEqual(len(out.splitlines()), 1)
	2131
	2132	out, err = self.run_bzr(['grep', '-n', '-i', '--color',
	2133	'always', 'FOO'])
	2134	self.assertEqual(out, nres)
	2135	self.assertEqual(len(out.splitlines()), 1)
	2136
	2137	out, err = self.run_bzr(['grep', '-n', '--color',
	2138	'always', 'f.o'])
	2139	self.assertEqual(out, nres)
	2140	self.assertEqual(len(out.splitlines()), 1)
	2141
	2142	out, err = self.run_bzr(['grep', '-n', '-i', '--color',
	2143	'always', 'F.O'])
	2144	self.assertEqual(out, nres)
	2145	self.assertEqual(len(out.splitlines()), 1)
	2146
0.48.9 by Parth Malwankar added inital test for 'grep -p'	2147
6622.1.34 by Jelmer Vernooĳ Rename brzlib => breezy.	2148	# copied from breezy.tests.blackbox.test_diff
0.48.9 by Parth Malwankar added inital test for 'grep -p'	2149	def subst_dates(string):
	2150	"""Replace date strings with constant values."""
	2151	return re.sub(r'\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} [-\+]\d{4}',
	2152	'YYYY-MM-DD HH:MM:SS +ZZZZ', string)
	2153
	2154
	2155	class TestGrepDiff(tests.TestCaseWithTransport):
	2156
	2157	def make_example_branch(self):
	2158	tree = self.make_branch_and_tree('.')
	2159	self.build_tree_contents([
6855.4.1 by Jelmer Vernooĳ Yet more bees.	2160	('hello', b'foo\n'),
6855.4.1 by Jelmer Vernooĳ Yet more bees.	2161	('goodbye', b'baz\n')])
0.48.9 by Parth Malwankar added inital test for 'grep -p'	2162	tree.add(['hello'])
	2163	tree.commit('setup')
	2164	tree.add(['goodbye'])
	2165	tree.commit('setup')
	2166	return tree
	2167
	2168	def test_grep_diff_basic(self):
	2169	"""grep -p basic test."""
	2170	tree = self.make_example_branch()
6855.4.1 by Jelmer Vernooĳ Yet more bees.	2171	self.build_tree_contents([('hello', b'hello world!\n')])
0.48.9 by Parth Malwankar added inital test for 'grep -p'	2172	tree.commit('updated hello')
0.48.9 by Parth Malwankar added inital test for 'grep -p'	2173	out, err = self.run_bzr(['grep', '-p', 'hello'])
6614.1.3 by Vincent Ladeuil Fix assertEquals being deprecated by using assertEqual.	2174	self.assertEqual(err, '')
0.48.9 by Parth Malwankar added inital test for 'grep -p'	2175	self.assertEqualDiff(subst_dates(out), '''\
0.48.10 by Parth Malwankar more tests for 'grep --diff'	2176	=== revno:3 ===
0.48.9 by Parth Malwankar added inital test for 'grep -p'	2177	=== modified file 'hello'
	2178	--- hello YYYY-MM-DD HH:MM:SS +ZZZZ
	2179	+++ hello YYYY-MM-DD HH:MM:SS +ZZZZ
	2180	+hello world!
0.48.10 by Parth Malwankar more tests for 'grep --diff'	2181	=== revno:1 ===
0.48.9 by Parth Malwankar added inital test for 'grep -p'	2182	=== added file 'hello'
	2183	--- hello YYYY-MM-DD HH:MM:SS +ZZZZ
	2184	+++ hello YYYY-MM-DD HH:MM:SS +ZZZZ
	2185	''')
	2186
0.48.10 by Parth Malwankar more tests for 'grep --diff'	2187	def test_grep_diff_revision(self):
	2188	"""grep -p specific revision."""
	2189	tree = self.make_example_branch()
6855.4.1 by Jelmer Vernooĳ Yet more bees.	2190	self.build_tree_contents([('hello', b'hello world!\n')])
0.48.10 by Parth Malwankar more tests for 'grep --diff'	2191	tree.commit('updated hello')
0.48.10 by Parth Malwankar more tests for 'grep --diff'	2192	out, err = self.run_bzr(['grep', '-p', '-r', '3', 'hello'])
6614.1.3 by Vincent Ladeuil Fix assertEquals being deprecated by using assertEqual.	2193	self.assertEqual(err, '')
0.48.10 by Parth Malwankar more tests for 'grep --diff'	2194	self.assertEqualDiff(subst_dates(out), '''\
	2195	=== revno:3 ===
	2196	=== modified file 'hello'
	2197	--- hello YYYY-MM-DD HH:MM:SS +ZZZZ
	2198	+++ hello YYYY-MM-DD HH:MM:SS +ZZZZ
	2199	+hello world!
	2200	''')
	2201
	2202	def test_grep_diff_revision_range(self):
	2203	"""grep -p revision range."""
	2204	tree = self.make_example_branch()
6855.4.1 by Jelmer Vernooĳ Yet more bees.	2205	self.build_tree_contents([('hello', b'hello world!1\n')]) # rev 3
0.48.10 by Parth Malwankar more tests for 'grep --diff'	2206	tree.commit('rev3')
6855.4.1 by Jelmer Vernooĳ Yet more bees.	2207	self.build_tree_contents([('blah', b'hello world!2\n')]) # rev 4
0.48.10 by Parth Malwankar more tests for 'grep --diff'	2208	tree.add('blah')
0.48.10 by Parth Malwankar more tests for 'grep --diff'	2209	tree.commit('rev4')
6973.12.11 by Jelmer Vernooĳ Fix some more tests.	2210	with open('hello', 'a') as f:
6973.12.11 by Jelmer Vernooĳ Fix some more tests.	2211	f.write('hello world!3\n')
0.48.10 by Parth Malwankar more tests for 'grep --diff'	2212	#self.build_tree_contents([('hello', 'hello world!3\n')]) # rev 5
	2213	tree.commit('rev5')
	2214	out, err = self.run_bzr(['grep', '-p', '-r', '2..5', 'hello'])
6614.1.3 by Vincent Ladeuil Fix assertEquals being deprecated by using assertEqual.	2215	self.assertEqual(err, '')
0.48.10 by Parth Malwankar more tests for 'grep --diff'	2216	self.assertEqualDiff(subst_dates(out), '''\
	2217	=== revno:5 ===
	2218	=== modified file 'hello'
	2219	--- hello YYYY-MM-DD HH:MM:SS +ZZZZ
	2220	+++ hello YYYY-MM-DD HH:MM:SS +ZZZZ
	2221	+hello world!3
	2222	=== revno:4 ===
	2223	=== added file 'blah'
	2224	+hello world!2
	2225	=== revno:3 ===
	2226	=== modified file 'hello'
	2227	--- hello YYYY-MM-DD HH:MM:SS +ZZZZ
	2228	+++ hello YYYY-MM-DD HH:MM:SS +ZZZZ
	2229	+hello world!1
	2230	''')
	2231
	2232	def test_grep_diff_color(self):
	2233	"""grep -p color test."""
	2234	tree = self.make_example_branch()
6855.4.1 by Jelmer Vernooĳ Yet more bees.	2235	self.build_tree_contents([('hello', b'hello world!\n')])
0.48.10 by Parth Malwankar more tests for 'grep --diff'	2236	tree.commit('updated hello')
	2237	out, err = self.run_bzr(['grep', '--diff', '-r', '3',
	2238	'--color', 'always', 'hello'])
6614.1.3 by Vincent Ladeuil Fix assertEquals being deprecated by using assertEqual.	2239	self.assertEqual(err, '')
0.48.10 by Parth Malwankar more tests for 'grep --diff'	2240	revno = color_string('=== revno:3 ===', fg=FG.BOLD_BLUE) + '\n'
	2241	filename = color_string(" === modified file 'hello'", fg=FG.BOLD_MAGENTA) + '\n'
	2242	redhello = color_string('hello', fg=FG.BOLD_RED)
	2243	diffstr = '''\
	2244	--- hello YYYY-MM-DD HH:MM:SS +ZZZZ
	2245	+++ hello YYYY-MM-DD HH:MM:SS +ZZZZ
	2246	+hello world!
	2247	'''
	2248	diffstr = diffstr.replace('hello', redhello)
	2249	self.assertEqualDiff(subst_dates(out), revno + filename + diffstr)
	2250
	2251	def test_grep_norevs(self):
	2252	"""grep -p with zero revisions."""
	2253	out, err = self.run_bzr(['init'])
	2254	out, err = self.run_bzr(['grep', '--diff', 'foo'], 3)
6614.1.3 by Vincent Ladeuil Fix assertEquals being deprecated by using assertEqual.	2255	self.assertEqual(out, '')
0.48.10 by Parth Malwankar more tests for 'grep --diff'	2256	self.assertContainsRe(err, "ERROR:.revision. does not exist in branch")
0.48.9 by Parth Malwankar added inital test for 'grep -p'	2257