diff -r cfb510884a13 Lib/idlelib/idle_test/test_searchengine.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Lib/idlelib/idle_test/test_searchengine.py	Mon Aug 19 02:15:52 2013 -0400
@@ -0,0 +1,339 @@
+import re
+import unittest
+from test.support import requires
+from tkinter import Tk, Text
+from idlelib import SearchEngine as se
+from idlelib.idle_test.mock_tk import Mbox
+
+
+class GetTest(unittest.TestCase):
+    """Tests that SearchEngine is created and returned if it doesn't exist."""
+    def test_get(self):
+        root = Tk()
+        self.assertIsInstance(se.get(root), se.SearchEngine)
+        self.assertIsInstance(root._searchengine, se.SearchEngine)
+        root.destroy()
+
+
+class SearchReverseTest(unittest.TestCase):
+
+    def test_search_reverse(self):
+        Equal = self.assertEqual
+
+        text = 'Here is some test text.'
+        prog = re.compile('is')
+        col = 10
+        Equal(se.search_reverse(prog, text, col).span()[0], 5)
+
+        col = 3
+        Equal(se.search_reverse(prog, text, col), None)
+
+
+class GetSelectionTest(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        requires('gui')
+        cls.root = Tk()
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.root.destroy()
+
+    def test_get_selection(self):
+        self.text = Text(master=self.root)
+        Equal = self.assertEqual
+
+        # Test with no selection and cursor at 1.0
+        self.text.insert('1.0', 'hello world')
+        self.text.mark_set('insert', '1.0')
+        Equal(se.get_selection(self.text), ('1.0', '1.0'))
+
+        # Test with no selection and cursor at 1.8
+        self.text.mark_set('insert', '1.8')
+        Equal(se.get_selection(self.text), ('1.8', '1.8'))
+
+        # Test with 'Hello' selected
+        self.text.tag_add('sel', '1.0', '1.5')
+        Equal(se.get_selection(self.text), ('1.0', '1.5'))
+
+        # Test with ' world' selected
+        self.text.tag_remove('sel', '1.0', 'end')
+        self.text.tag_add('sel', '1.5', '1.0 lineend')
+        Equal(se.get_selection(self.text), ('1.5', '1.11'))
+
+
+class GetLineColTest(unittest.TestCase):
+
+    def test_get_line_col(self):
+        self.assertEqual(se.get_line_col('1.0'), (1, 0))
+        self.assertEqual(se.get_line_col('1.11'), (1, 11))
+
+        self.assertRaises(ValueError, se.get_line_col, ('1.0 lineend'))
+        self.assertRaises(ValueError, se.get_line_col, ('end'))
+
+
+class SearchEngineClassTest(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        requires('gui')
+        cls.root = Tk()
+        cls.engine = se.SearchEngine(cls.root)
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.root.destroy()
+
+    def setUp(self):
+        self.engine.__init__(self.root)
+        self.text = Text(master=self.root)
+
+    def test_is_get(self):
+        engine = self.engine
+        Equal = self.assertEqual
+
+        Equal(engine.getpat(), '')
+        engine.setpat('hello')
+        Equal(engine.getpat(), 'hello')
+
+        Equal(engine.isre(), False)
+        engine.revar.set(1)
+        Equal(engine.isre(), True)
+
+        Equal(engine.iscase(), False)
+        engine.casevar.set(1)
+        Equal(engine.iscase(), True)
+
+        Equal(engine.isword(), False)
+        engine.wordvar.set(1)
+        Equal(engine.isword(), True)
+
+        Equal(engine.iswrap(), True)
+        engine.wrapvar.set(0)
+        Equal(engine.iswrap(), False)
+
+        Equal(engine.isback(), False)
+        engine.backvar.set(1)
+        Equal(engine.isback(), True)
+
+    def test_getcookedpat(self):
+        engine = self.engine
+        Equal = self.assertEqual
+
+        Equal(engine.getcookedpat(), '')
+        engine.setpat('hello')
+        Equal(engine.getcookedpat(), 'hello')
+        engine.setpat('\s')
+        Equal(engine.getcookedpat(), '\\\\s')
+
+        engine.wordvar.set(1)
+        engine.setpat('hello')
+        Equal(engine.getcookedpat(), r'\bhello\b')
+
+    def test_getprog(self):
+        engine = self.engine
+        Equal = self.assertEqual
+        se.tkMessageBox = Mbox
+
+        # Test that empty regular expression causes error message
+        engine.setpat('')
+        Equal(engine.getprog(), None)
+
+        engine.setpat('Hello')
+        engine.casevar.set(0)
+        temppat = engine.getprog()
+        Equal(temppat.pattern, re.compile('Hello', re.IGNORECASE).pattern)
+
+        engine.casevar.set(1)
+        temppat = engine.getprog()
+        Equal(temppat.pattern, re.compile('Hello').pattern, 0)
+
+        # Test that incorrect regular expression causes error message
+        engine.casevar.set(0)
+        engine.revar.set(1)
+        engine.setpat('+')
+        Equal(engine.getprog(), None)
+
+    def test_report_error(self):
+        se.tkMessageBox = Mbox
+        showerror = Mbox.showerror
+        Equal = self.assertEqual
+
+        pat = '[a-z'
+        msg = 'unexpected end of regular expression'
+
+        Equal(self.engine.report_error(pat, msg), None)
+        Equal(showerror.title, 'Regular expression error')
+        expected_message = ("Error: unexpected end of regular expression\n"
+                            "p\Pattern: [a-z")
+        Equal(showerror.message, expected_message)
+
+        Equal(self.engine.report_error(pat, msg, 5), None)
+        Equal(showerror.title, 'Regular expression error')
+        expected_message = ("Error: unexpected end of regular expression\n"
+                            "p\Pattern: [a-z\n"
+                            "Offset: 5")
+        Equal(showerror.message, expected_message)
+
+    def test_setcookedpat(self):
+        engine = self.engine
+        Equal = self.assertEqual
+
+        engine.revar.set(0)
+        engine.setpat('\s')
+        Equal(engine.getpat(), '\s')
+
+        engine.revar.set(1)
+        engine.setpat('\s')
+        Equal(engine.getpat(), '\\s')
+
+    def test_search_text(self):
+        engine = self.engine
+        testtext = (
+            "from string import Template\n"
+            "s = Template('$who likes $what')\n"
+            "s.substitute(who='tim', what='kung pao')\n"
+            "d = dict(who='tim')\n"
+            "Template('Give $who $100').substitute(d)\n"
+            "Template('$who likes $what').substitute(d)\n"
+            "Template('$who likes $what').safe_substitute(d)\n")
+
+        self.text.insert('1.0', testtext)
+        pat = re.compile("substitute")
+
+        # Search forward from cursor at 1.0
+        self.text.mark_set('insert', '1.0')
+        searchresult = engine.search_text(self.text, pat)
+        # searchresult is a tuple in the form (lineno, matchobject)
+        self.assertEqual(searchresult[0], 3)            # test line match
+        self.assertEqual(searchresult[1].span()[0], 2)  # test column match
+
+        # Test that search wraps around to beginning of text
+        self.text.mark_set('insert', '7.38')
+        searchresult = engine.search_text(self.text, pat)
+        self.assertEqual(searchresult[0], 3)
+        self.assertEqual(searchresult[1].span()[0], 2)
+
+        # Test that search doesn't wrap forward when wrapvar set to 0
+        engine.wrapvar.set(0)
+        self.text.mark_set('insert', '7.38')
+        searchresult = engine.search_text(self.text, pat)
+        self.assertEqual(searchresult, None)
+
+        # Test that search doesn't wrap in reverse when wrapvar set to 0
+        engine.backvar.set(1)
+        self.text.mark_set('insert', '2.4')
+        searchresult = engine.search_text(self.text, pat)
+        self.assertEqual(searchresult, None)
+        engine.wrapvar.set(1)
+
+        # Test that search reverses when backvar is set to 1
+        self.text.mark_set('insert', '6.5')
+        searchresult = engine.search_text(self.text, pat)
+        self.assertEqual(searchresult[0], 5)
+        self.assertEqual(searchresult[1].span()[0], 27)
+
+        # Test that search wraps around backwards to end of text
+        self.text.mark_set('insert', '1.5')
+        searchresult = engine.search_text(self.text, pat)
+        self.assertEqual(searchresult[0], 7)
+        self.assertEqual(searchresult[1].span()[0], 34)
+        engine.backvar.set(0)
+
+        # Test empty match with 'ok' flag set and 'string' on line 1 selected
+        self.text.tag_add('sel', '1.5', '1.11')
+        engine.backvar.set(0)
+        pat = re.compile("\w+")
+        searchresult = engine.search_text(self.text, pat, 1)
+        self.assertEqual(searchresult[0], 1)
+        self.assertEqual(searchresult[1].span()[0], 5)
+
+        # Test match with 'ok' flag not set and 'string' selected
+        searchresult = engine.search_text(self.text, pat, 0)
+        self.assertEqual(searchresult[0], 1)
+        self.assertEqual(searchresult[1].span()[0], 12)
+
+    def test_search_forward(self):
+        engine = self.engine
+        testtext = (
+            "from string import Template\n"
+            "s = Template('$who likes $what')\n"
+            "s.substitute(who='tim', what='kung pao')\n"
+            "d = dict(who='tim')\n"
+            "Template('Give $who $100').substitute(d)\n"
+            "Template('$who likes $what').substitute(d)\n"
+            "Template('$who likes $what').safe_substitute(d)\n")
+
+        self.text.insert('1.0', testtext)
+        pat = re.compile("substitute")
+
+        # Search forward from cursor at 1.0
+        searchresult = engine.search_forward(self.text, pat, 1, 0, True)
+        self.assertEqual(searchresult[0], 3)            # test line match
+        self.assertEqual(searchresult[1].span()[0], 2)  # test column match
+
+        # Test that search wraps around to beginning of text
+        searchresult = engine.search_forward(self.text, pat, 7, 38, True)
+        self.assertEqual(searchresult[0], 3)
+        self.assertEqual(searchresult[1].span()[0], 2)
+
+        # Test that search doesn't wrap forward when wrapvar set to 0
+        searchresult = engine.search_forward(self.text, pat, 7, 38, False)
+        self.assertEqual(searchresult, None)
+
+        # Test empty match with 'ok' flag set and 'string' on line 1 selected
+        pat = re.compile("\w+")
+        searchresult = engine.search_forward(self.text, pat, 1, 5, 1, 1)
+        self.assertEqual(searchresult[0], 1)
+        self.assertEqual(searchresult[1].span()[0], 5)
+
+        # Test empty match with 'ok' flag not set and 'string' selected
+        searchresult = engine.search_forward(self.text, pat, 1, 11, 1)
+        self.assertEqual(searchresult[0], 1)
+        self.assertEqual(searchresult[1].span()[0], 12)
+
+    def test_search_backward(self):
+        engine = self.engine
+        testtext = (
+            "from string import Template\n"
+            "s = Template('$who likes $what')\n"
+            "s.substitute(who='tim', what='kung pao')\n"
+            "d = dict(who='tim')\n"
+            "Template('Give $who $100').substitute(d)\n"
+            "Template('$who likes $what').substitute(d)\n"
+            "Template('$who likes $what').safe_substitute(d)\n")
+
+        self.text.insert('1.0', testtext)
+        pat = re.compile("substitute")
+
+        # Test that search doesn't wrap in reverse when wrapvar set to 0
+        searchresult = engine.search_backward(self.text, pat, 2, 4, 0)
+        self.assertEqual(searchresult, None)
+
+        # Test that search reverses when backvar is set to 1
+        self.text.mark_set('insert', '6.5')
+        searchresult = engine.search_backward(self.text, pat, 6, 5, 1)
+        self.assertEqual(searchresult[0], 5)
+        self.assertEqual(searchresult[1].span()[0], 27)
+
+        # Test that search wraps around backwards to end of text
+        searchresult = engine.search_backward(self.text, pat, 1, 5, 1)
+        self.assertEqual(searchresult[0], 7)
+        self.assertEqual(searchresult[1].span()[0], 34)
+        engine.backvar.set(0)
+
+        # Test empty match with 'ok' flag set
+        pat = re.compile("\w+")
+        searchresult = engine.search_backward(self.text, pat, 1, 11, 1, 1)
+        self.assertEqual(searchresult[0], 1)
+        self.assertEqual(searchresult[1].span()[0], 5)
+
+        # Test empty match with 'ok' flag not set
+        searchresult = engine.search_backward(self.text, pat, 1, 5, 1, 0)
+        self.assertEqual(searchresult[0], 1)
+        self.assertEqual(searchresult[1].span()[0], 0)
+
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2, exit=2)