Coverage for idle_test/test_searchengine.py: 97%

1"Test searchengine, coverage 99%." 

2 

3from idlelib import searchengine as se (empty)

4import unittest (empty)

5# from test.support import requires 

6from tkinter import BooleanVar, StringVar, TclError # ,Tk, Text (empty)

7from tkinter import messagebox (empty)

8from idlelib.idle_test.mock_tk import Var, Mbox (empty)

9from idlelib.idle_test.mock_tk import Text as mockText (empty)

10import re (empty)

11 

12# With mock replacements, the module does not use any gui widgets. 

13# The use of tk.Text is avoided (for now, until mock Text is improved) 

14# by patching instances with an index function returning what is needed. 

15# This works because mock Text.get does not use .index. 

16# The tkinter imports are used to restore searchengine. 

17 

18def setUpModule(): (empty)

19 # Replace s-e module tkinter imports other than non-gui TclError. 

20 se.BooleanVar = Var (empty)

21 se.StringVar = Var (empty)

22 se.messagebox = Mbox (empty)

23 

24def tearDownModule(): (empty)

25 # Restore 'just in case', though other tests should also replace. 

26 se.BooleanVar = BooleanVar (empty)

27 se.StringVar = StringVar (empty)

28 se.messagebox = messagebox (empty)

29 

30 

31class Mock: (empty)

32 def __init__(self, *args, **kwargs): pass 2 ctx1aj

33 

34class GetTest(unittest.TestCase): (empty)

35 # SearchEngine.get returns singleton created & saved on first call. 

36 def test_get(self): (empty)

37 saved_Engine = se.SearchEngine 1 ctx1j

38 se.SearchEngine = Mock # monkey-patch class 1 ctx1j

39 try: 1 ctx1j

40 root = Mock() 1 ctx1j

41 engine = se.get(root) 1 ctx1j

42 self.assertIsInstance(engine, se.SearchEngine) 1 ctx1j

43 self.assertIs(root._searchengine, engine) 1 ctx1j

44 self.assertIs(se.get(root), engine) 1 ctx1j

45 finally: 

46 se.SearchEngine = saved_Engine # restore class to module 1 ctx1j

47 

48class GetLineColTest(unittest.TestCase): (empty)

49 # Test simple text-independent helper function 

50 def test_get_line_col(self): (empty)

51 self.assertEqual(se.get_line_col('1.0'), (1, 0)) 1 ctx1m

52 self.assertEqual(se.get_line_col('1.11'), (1, 11)) 1 ctx1m

53 

54 self.assertRaises(ValueError, se.get_line_col, ('1.0 lineend')) 1 ctx1m

55 self.assertRaises(ValueError, se.get_line_col, ('end')) 1 ctx1m

56 

57class GetSelectionTest(unittest.TestCase): (empty)

58 # Test text-dependent helper function. 

59## # Need gui for text.index('sel.first/sel.last/insert'). 

60## @classmethod 

61## def setUpClass(cls): 

62## requires('gui') 

63## cls.root = Tk() 

64## 

65## @classmethod 

66## def tearDownClass(cls): 

67## cls.root.destroy() 

68## del cls.root 

69 

70 def test_get_selection(self): (empty)

71 # text = Text(master=self.root) 

72 text = mockText() 1 ctx1g

73 text.insert('1.0', 'Hello World!') 1 ctx1g

74 

75 # fix text.index result when called in get_selection 

76 def sel(s): 1 ctx1g

77 # select entire text, cursor irrelevant 

78 if s == 'sel.first': return '1.0' 1 ctx1g

79 if s == 'sel.last': return '1.12' 79 ↛ 80line 79 didn't jump to line 80, because the condition on line 79 was never false1 ctx1g

80 raise TclError 

81 text.index = sel # replaces .tag_add('sel', '1.0, '1.12') 1 ctx1g

82 self.assertEqual(se.get_selection(text), ('1.0', '1.12')) 1 ctx1g

83 

84 def mark(s): 1 ctx1g

85 # no selection, cursor after 'Hello' 

86 if s == 'insert': return '1.5' 1 ctx1g

87 raise TclError 1 ctx1g

88 text.index = mark # replaces .mark_set('insert', '1.5') 1 ctx1g

89 self.assertEqual(se.get_selection(text), ('1.5', '1.5')) 1 ctx1g

90 

91 

92class ReverseSearchTest(unittest.TestCase): (empty)

93 # Test helper function that searches backwards within a line. 

94 def test_search_reverse(self): (empty)

95 Equal = self.assertEqual 1 ctx1k

96 line = "Here is an 'is' test text." 1 ctx1k

97 prog = re.compile('is') 1 ctx1k

98 Equal(se.search_reverse(prog, line, len(line)).span(), (12, 14)) 1 ctx1k

99 Equal(se.search_reverse(prog, line, 14).span(), (12, 14)) 1 ctx1k

100 Equal(se.search_reverse(prog, line, 13).span(), (5, 7)) 1 ctx1k

101 Equal(se.search_reverse(prog, line, 7).span(), (5, 7)) 1 ctx1k

102 Equal(se.search_reverse(prog, line, 6), None) 1 ctx1k

103 

104 

105class SearchEngineTest(unittest.TestCase): (empty)

106 # Test class methods that do not use Text widget. 

107 

108 def setUp(self): (empty)

109 self.engine = se.SearchEngine(root=None) (empty)

110 # Engine.root is only used to create error message boxes. 

111 # The mock replacement ignores the root argument. 

112 

113 def test_is_get(self): (empty)

114 engine = self.engine 1 ctx1c

115 Equal = self.assertEqual 1 ctx1c

116 

117 Equal(engine.getpat(), '') 1 ctx1c

118 engine.setpat('hello') 1 ctx1c

119 Equal(engine.getpat(), 'hello') 1 ctx1c

120 

121 Equal(engine.isre(), False) 1 ctx1c

122 engine.revar.set(1) 1 ctx1c

123 Equal(engine.isre(), True) 1 ctx1c

124 

125 Equal(engine.iscase(), False) 1 ctx1c

126 engine.casevar.set(1) 1 ctx1c

127 Equal(engine.iscase(), True) 1 ctx1c

128 

129 Equal(engine.isword(), False) 1 ctx1c

130 engine.wordvar.set(1) 1 ctx1c

131 Equal(engine.isword(), True) 1 ctx1c

132 

133 Equal(engine.iswrap(), True) 1 ctx1c

134 engine.wrapvar.set(0) 1 ctx1c

135 Equal(engine.iswrap(), False) 1 ctx1c

136 

137 Equal(engine.isback(), False) 1 ctx1c

138 engine.backvar.set(1) 1 ctx1c

139 Equal(engine.isback(), True) 1 ctx1c

140 

141 def test_setcookedpat(self): (empty)

142 engine = self.engine 1 ctx1l

143 engine.setcookedpat(r'\s') 1 ctx1l

144 self.assertEqual(engine.getpat(), r'\s') 1 ctx1l

145 engine.revar.set(1) 1 ctx1l

146 engine.setcookedpat(r'\s') 1 ctx1l

147 self.assertEqual(engine.getpat(), r'\\s') 1 ctx1l

148 

149 def test_getcookedpat(self): (empty)

150 engine = self.engine 1 ctx1h

151 Equal = self.assertEqual 1 ctx1h

152 

153 Equal(engine.getcookedpat(), '') 1 ctx1h

154 engine.setpat('hello') 1 ctx1h

155 Equal(engine.getcookedpat(), 'hello') 1 ctx1h

156 engine.wordvar.set(True) 1 ctx1h

157 Equal(engine.getcookedpat(), r'\bhello\b') 1 ctx1h

158 engine.wordvar.set(False) 1 ctx1h

159 

160 engine.setpat(r'\s') 1 ctx1h

161 Equal(engine.getcookedpat(), r'\\s') 1 ctx1h

162 engine.revar.set(True) 1 ctx1h

163 Equal(engine.getcookedpat(), r'\s') 1 ctx1h

164 

165 def test_getprog(self): (empty)

166 engine = self.engine 1 ctx1d

167 Equal = self.assertEqual 1 ctx1d

168 

169 engine.setpat('Hello') 1 ctx1d

170 temppat = engine.getprog() 1 ctx1d

171 Equal(temppat.pattern, re.compile('Hello', re.IGNORECASE).pattern) 1 ctx1d

172 engine.casevar.set(1) 1 ctx1d

173 temppat = engine.getprog() 1 ctx1d

174 Equal(temppat.pattern, re.compile('Hello').pattern, 0) 1 ctx1d

175 

176 engine.setpat('') 1 ctx1d

177 Equal(engine.getprog(), None) 1 ctx1d

178 Equal(Mbox.showerror.message, 1 ctx1d

179 'Error: Empty regular expression') 

180 engine.setpat('+') 1 ctx1d

181 engine.revar.set(1) 1 ctx1d

182 Equal(engine.getprog(), None) 1 ctx1d

183 Equal(Mbox.showerror.message, 1 ctx1d

184 'Error: nothing to repeat\nPattern: +\nOffset: 0') 

185 

186 def test_report_error(self): (empty)

187 showerror = Mbox.showerror 1 ctx1i

188 Equal = self.assertEqual 1 ctx1i

189 pat = '[a-z' 1 ctx1i

190 msg = 'unexpected end of regular expression' 1 ctx1i

191 

192 Equal(self.engine.report_error(pat, msg), None) 1 ctx1i

193 Equal(showerror.title, 'Regular expression error') 1 ctx1i

194 expected_message = ("Error: " + msg + "\nPattern: [a-z") 1 ctx1i

195 Equal(showerror.message, expected_message) 1 ctx1i

196 

197 Equal(self.engine.report_error(pat, msg, 5), None) 1 ctx1i

198 Equal(showerror.title, 'Regular expression error') 1 ctx1i

199 expected_message += "\nOffset: 5" 1 ctx1i

200 Equal(showerror.message, expected_message) 1 ctx1i

201 

202 

203class SearchTest(unittest.TestCase): (empty)

204 # Test that search_text makes right call to right method. 

205 

206 @classmethod (empty)

207 def setUpClass(cls): (empty)

208## requires('gui') 

209## cls.root = Tk() 

210## cls.text = Text(master=cls.root) 

211 cls.text = mockText() (empty)

212 test_text = ( (empty)

213 'First line\n' 

214 'Line with target\n' 

215 'Last line\n') 

216 cls.text.insert('1.0', test_text) (empty)

217 cls.pat = re.compile('target') (empty)

218 

219 cls.engine = se.SearchEngine(None) (empty)

220 cls.engine.search_forward = lambda *args: ('f', args) 2 ctx1ab

221 cls.engine.search_backward = lambda *args: ('b', args) 2 ctx1ab

222 

223## @classmethod 

224## def tearDownClass(cls): 

225## cls.root.destroy() 

226## del cls.root 

227 

228 def test_search(self): (empty)

229 Equal = self.assertEqual 1 ctx1b

230 engine = self.engine 1 ctx1b

231 search = engine.search_text 1 ctx1b

232 text = self.text 1 ctx1b

233 pat = self.pat 1 ctx1b

234 

235 engine.patvar.set(None) 1 ctx1b

236 #engine.revar.set(pat) 

237 Equal(search(text), None) 1 ctx1b

238 

239 def mark(s): 1 ctx1b

240 # no selection, cursor after 'Hello' 

241 if s == 'insert': return '1.5' 1 ctx1b

242 raise TclError 1 ctx1b

243 text.index = mark 1 ctx1b

244 Equal(search(text, pat), ('f', (text, pat, 1, 5, True, False))) 1 ctx1b

245 engine.wrapvar.set(False) 1 ctx1b

246 Equal(search(text, pat), ('f', (text, pat, 1, 5, False, False))) 1 ctx1b

247 engine.wrapvar.set(True) 1 ctx1b

248 engine.backvar.set(True) 1 ctx1b

249 Equal(search(text, pat), ('b', (text, pat, 1, 5, True, False))) 1 ctx1b

250 engine.backvar.set(False) 1 ctx1b

251 

252 def sel(s): 1 ctx1b

253 if s == 'sel.first': return '2.10' 1 ctx1b

254 if s == 'sel.last': return '2.16' 254 ↛ 255line 254 didn't jump to line 255, because the condition on line 254 was never false1 ctx1b

255 raise TclError 

256 text.index = sel 1 ctx1b

257 Equal(search(text, pat), ('f', (text, pat, 2, 16, True, False))) 1 ctx1b

258 Equal(search(text, pat, True), ('f', (text, pat, 2, 10, True, True))) 1 ctx1b

259 engine.backvar.set(True) 1 ctx1b

260 Equal(search(text, pat), ('b', (text, pat, 2, 10, True, False))) 1 ctx1b

261 Equal(search(text, pat, True), ('b', (text, pat, 2, 16, True, True))) 1 ctx1b

262 

263 

264class ForwardBackwardTest(unittest.TestCase): (empty)

265 # Test that search_forward method finds the target. 

266## @classmethod 

267## def tearDownClass(cls): 

268## cls.root.destroy() 

269## del cls.root 

270 

271 @classmethod (empty)

272 def setUpClass(cls): (empty)

273 cls.engine = se.SearchEngine(None) (empty)

274## requires('gui') 

275## cls.root = Tk() 

276## cls.text = Text(master=cls.root) 

277 cls.text = mockText() (empty)

278 # search_backward calls index('end-1c') 

279 cls.text.index = lambda index: '4.0' 2 ctx1ae

280 test_text = ( (empty)

281 'First line\n' 

282 'Line with target\n' 

283 'Last line\n') 

284 cls.text.insert('1.0', test_text) (empty)

285 cls.pat = re.compile('target') (empty)

286 cls.res = (2, (10, 16)) # line, slice indexes of 'target' (empty)

287 cls.failpat = re.compile('xyz') # not in text (empty)

288 cls.emptypat = re.compile(r'\w*') # empty match possible (empty)

289 

290 def make_search(self, func): (empty)

291 def search(pat, line, col, wrap, ok=0): 2 ctx1ef

292 res = func(self.text, pat, line, col, wrap, ok) 2 ctx1ef

293 # res is (line, matchobject) or None 

294 return (res[0], res[1].span()) if res else res 2 ctx1ef

295 return search 2 ctx1ef

296 

297 def test_search_forward(self): (empty)

298 # search for non-empty match 

299 Equal = self.assertEqual 1 ctx1f

300 forward = self.make_search(self.engine.search_forward) 1 ctx1f

301 pat = self.pat 1 ctx1f

302 Equal(forward(pat, 1, 0, True), self.res) 1 ctx1f

303 Equal(forward(pat, 3, 0, True), self.res) # wrap 1 ctx1f

304 Equal(forward(pat, 3, 0, False), None) # no wrap 1 ctx1f

305 Equal(forward(pat, 2, 10, False), self.res) 1 ctx1f

306 

307 Equal(forward(self.failpat, 1, 0, True), None) 1 ctx1f

308 Equal(forward(self.emptypat, 2, 9, True, ok=True), (2, (9, 9))) 1 ctx1f

309 #Equal(forward(self.emptypat, 2, 9, True), self.res) 

310 # While the initial empty match is correctly ignored, skipping 

311 # the rest of the line and returning (3, (0,4)) seems buggy - tjr. 

312 Equal(forward(self.emptypat, 2, 10, True), self.res) 1 ctx1f

313 

314 def test_search_backward(self): (empty)

315 # search for non-empty match 

316 Equal = self.assertEqual 1 ctx1e

317 backward = self.make_search(self.engine.search_backward) 1 ctx1e

318 pat = self.pat 1 ctx1e

319 Equal(backward(pat, 3, 5, True), self.res) 1 ctx1e

320 Equal(backward(pat, 2, 0, True), self.res) # wrap 1 ctx1e

321 Equal(backward(pat, 2, 0, False), None) # no wrap 1 ctx1e

322 Equal(backward(pat, 2, 16, False), self.res) 1 ctx1e

323 

324 Equal(backward(self.failpat, 3, 9, True), None) 1 ctx1e

325 Equal(backward(self.emptypat, 2, 10, True, ok=True), (2, (9,9))) 1 ctx1e

326 # Accepted because 9 < 10, not because ok=True. 

327 # It is not clear that ok=True is useful going back - tjr 

328 Equal(backward(self.emptypat, 2, 9, True), (2, (5, 9))) 1 ctx1e

329 

330 

331if __name__ == '__main__': 331 ↛ 332line 331 didn't jump to line 332, because the condition on line 331 was never true(empty)

332 unittest.main(verbosity=2)