diff --git a/Lib/idlelib/idle_test/test_editor.py b/Lib/idlelib/idle_test/test_editor.py
index fdb47abf43fb77..912de3391b7d06 100644
--- a/Lib/idlelib/idle_test/test_editor.py
+++ b/Lib/idlelib/idle_test/test_editor.py
@@ -1,12 +1,37 @@
 "Test editor, coverage 35%."
 
 from idlelib import editor
-import unittest
 from collections import namedtuple
+from functools import partial
+import sys
 from test.support import requires
-from tkinter import Tk
+
+import unittest
+from unittest import mock
+import tkinter as tk
+from idlelib.multicall import MultiCallCreator
+from idlelib.idle_test.mock_idle import Func
 
 Editor = editor.EditorWindow
+root = None
+editwin = None
+
+
+def setUpModule():
+    global root, editwin
+    requires('gui')
+    root = tk.Tk()
+    root.withdraw()
+    editwin = editor.EditorWindow(root=root)
+
+
+def tearDownModule():
+    global root, editwin
+    editwin.close()
+    del editwin
+    root.update_idletasks()
+    root.destroy()
+    del root
 
 
 class EditorWindowTest(unittest.TestCase):
@@ -14,7 +39,7 @@ class EditorWindowTest(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         requires('gui')
-        cls.root = Tk()
+        cls.root = tk.Tk()
         cls.root.withdraw()
 
     @classmethod
@@ -103,7 +128,7 @@ class IndentAndNewlineTest(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         requires('gui')
-        cls.root = Tk()
+        cls.root = tk.Tk()
         cls.root.withdraw()
         cls.window = Editor(root=cls.root)
         cls.window.indentwidth = 2
@@ -178,7 +203,8 @@ def test_indent_and_newline_event(self):
         text.tag_add('sel', '1.17', '1.end')
         nl(None)
         # Deletes selected text before adding new line.
-        eq(get('1.0', 'end'), '  def f1(self, a,\n         \n    return a + b\n')
+        eq(get('1.0', 'end'),
+           '  def f1(self, a,\n         \n    return a + b\n')
 
 
 class RMenuTest(unittest.TestCase):
@@ -186,7 +212,7 @@ class RMenuTest(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         requires('gui')
-        cls.root = Tk()
+        cls.root = tk.Tk()
         cls.root.withdraw()
         cls.window = Editor(root=cls.root)
 
@@ -207,5 +233,389 @@ def test_rclick(self):
         pass
 
 
+class ModuleHelpersTest(unittest.TestCase):
+    """Test functions defined at the module level."""
+
+    def test_prepstr(self):
+        ps = editor.prepstr
+        eq = self.assertEqual
+        eq(ps('_spam'), (0, 'spam'))
+        eq(ps('spam'), (-1, 'spam'))
+        eq(ps('spam_'), (4, 'spam'))
+
+    @mock.patch.object(editor.macosx, 'isCocoaTk')
+    def test_get_accelerator(self, mock_cocoa):
+        ga = editor.get_accelerator
+        eq = self.assertEqual
+        keydefs = {'<<zoom-height>>': ['<Alt-Key-9>'],
+                   '<<open-module>>': ['<Control-Shift-O>'],
+                   '<<cancel>>': ['<Cancel>'],
+                   '<<indent>>': ['<Alt-bracketleft>'],
+                   '<<copy>>': ['<Control-j>', '<Control-c>']}
+
+        mock_cocoa.return_value = False
+        eq(ga(keydefs, '<<paste>>'), '')  # Not in keydefs.
+        eq(ga(keydefs, '<<copy>>'), 'Ctrl+J')  # Control to Ctrl and first only.
+        eq(ga(keydefs, '<<zoom-height>>'), 'Alt+9')  # Remove Key-.
+        eq(ga(keydefs, '<<indent>>'), 'Alt+[')  # bracketleft to [.
+        eq(ga(keydefs, '<<cancel>>'), 'Ctrl+Break')  # Cancel to Ctrl-Break.
+        eq(ga(keydefs, '<<open-module>>'), 'Ctrl+Shift+O')  # Shift doesn't change.
+
+        # Cocoa test: it skips open-module shortcut.
+        mock_cocoa.return_value = True
+        eq(ga(keydefs, '<<open-module>>'), '')
+
+
+class MenubarTest(unittest.TestCase):
+    """Test functions involved with creating the menubar."""
+
+    @classmethod
+    def setUpClass(cls):
+        # Test the functions called during the __init__ for
+        # EditorWindow that create the menubar and submenus.
+        # The class is mocked in order to prevent the functions
+        # from being called automatically.
+        w = cls.mock_editwin = mock.Mock(editor.EditorWindow)
+        w.menubar = tk.Menu(root, tearoff=False)
+        w.text = tk.Text(root)
+        w.tkinter_vars = {}
+
+    @classmethod
+    def tearDownClass(cls):
+        w = cls.mock_editwin
+        w.text.destroy()
+        w.menubar.destroy()
+        del w.menubar, w.text, w
+
+    @mock.patch.object(editor.macosx, 'isCarbonTk')
+    def test_createmenubar(self, mock_mac):
+        eq = self.assertEqual
+        ed = editor.EditorWindow
+        w = self.mock_editwin
+        # Call real function instead of mock.
+        cmb = partial(editor.EditorWindow.createmenubar, w)
+
+        # Load real editor menus.
+        w.menu_specs = ed.menu_specs
+
+        mock_mac.return_value = False
+        cmb()
+        eq(list(w.menudict.keys()),
+           [name[0] for name in w.menu_specs])
+        for index in range(w.menubar.index('end') + 1):
+            eq(w.menubar.type(index), tk.CASCADE)
+            eq(w.menubar.entrycget(index, 'label'),
+               editor.prepstr(w.menu_specs[index][1])[1])
+        # Recent Files added here and not fill_menus.
+        eq(w.menudict['file'].entrycget(3, 'label'), 'Recent Files')
+        # No items added to helpmenu, so the length has no value.
+        eq(w.base_helpmenu_length, None)
+        w.fill_menus.assert_called_with()
+        w.reset_help_menu_entries.assert_called_with()
+
+        # Carbon includes an application menu.
+        mock_mac.return_value = True
+        cmb()
+        eq(list(w.menudict.keys()),
+           [name[0] for name in w.menu_specs] + ['application'])
+
+    def test_fill_menus(self):
+        eq = self.assertEqual
+        ed = editor.EditorWindow
+        w = self.mock_editwin
+        # Call real functions instead of mock.
+        fm = partial(editor.EditorWindow.fill_menus, w)
+        w.get_var_obj = ed.get_var_obj.__get__(w)
+
+        # Initialize top level menubar.
+        w.menudict = {}
+        edit = w.menudict['edit'] = tk.Menu(w.menubar, name='edit', tearoff=False)
+        win = w.menudict['windows'] = tk.Menu(w.menubar, name='windows', tearoff=False)
+        form = w.menudict['format'] = tk.Menu(w.menubar, name='format', tearoff=False)
+
+        # Submenus.
+        menudefs = [('edit', [('_New', '<<open-new>>'),
+                              None,
+                              ('!Deb_ug', '<<debug>>')]),
+                    ('shell', [('_View', '<<view-restart>>'), ]),
+                    ('windows', [('Zoom Height', '<<zoom-height>>')]), ]
+        keydefs = {'<<zoom-height>>': ['<Alt-Key-9>']}
+
+        fm(menudefs, keydefs)
+        eq(edit.type(0), tk.COMMAND)
+        eq(edit.entrycget(0, 'label'), 'New')
+        eq(edit.entrycget(0, 'underline'), 0)
+        self.assertIsNotNone(edit.entrycget(0, 'command'))
+        with self.assertRaises(tk.TclError):
+            self.assertIsNone(edit.entrycget(0, 'var'))
+
+        eq(edit.type(1), tk.SEPARATOR)
+        with self.assertRaises(tk.TclError):
+            self.assertIsNone(edit.entrycget(1, 'label'))
+
+        eq(edit.type(2), tk.CHECKBUTTON)
+        eq(edit.entrycget(2, 'label'), 'Debug')  # Strip !.
+        eq(edit.entrycget(2, 'underline'), 3)  # Check that underline ignores !.
+        self.assertIsNotNone(edit.entrycget(2, 'var'))
+        self.assertIn('<<debug>>', w.tkinter_vars)
+
+        eq(win.entrycget(0, 'underline'), -1)
+        eq(win.entrycget(0, 'accelerator'), 'Alt+9')
+
+        self.assertNotIn('shell', w.menudict)
+
+        # Test defaults.
+        w.mainmenu.menudefs = ed.mainmenu.menudefs
+        w.mainmenu.default_keydefs = ed.mainmenu.default_keydefs
+        fm()
+        eq(form.index('end'), 9)  # Default Format menu has 10 items.
+        self.assertNotIn('run', w.menudict)
+
+    @mock.patch.object(editor.idleConf, 'GetAllExtraHelpSourcesList')
+    def test_reset_help_menu_entries(self, mock_extrahelp):
+        w = self.mock_editwin
+        mock_extrahelp.return_value = [('Python', 'https://python.org', '1')]
+        mock_callback = w._extra_help_callback
+
+        # Create help menu.
+        help = w.menudict['help'] = tk.Menu(w.menubar, name='help',
+                                            tearoff=False)
+        cmd = mock_callback.return_value = lambda e: 'break'
+        help.add_command(label='help1', command=cmd)
+        w.base_helpmenu_length = help.index('end')
+
+        # Add extra menu items that will be removed.
+        help.add_command(label='extra1', command=cmd)
+        help.add_command(label='extra2', command=cmd)
+        help.add_command(label='extra3', command=cmd)
+        help.add_command(label='extra4', command=cmd)
+
+        # Assert that there are extra help items.
+        self.assertTrue(help.index('end') - w.base_helpmenu_length >= 4)
+        self.assertNotEqual(help.index('end'), w.base_helpmenu_length)
+        editor.EditorWindow.reset_help_menu_entries(w)
+        # Count is 2 because of separator.
+        self.assertEqual(help.index('end') - w.base_helpmenu_length, 2)
+        mock_callback.assert_called_with('https://python.org')
+
+    def test_get_var_obj(self):
+        w = self.mock_editwin
+        gvo = partial(editor.EditorWindow.get_var_obj, w)
+        w.tkinter_vars = {}
+
+        # No vartype.
+        self.assertIsNone(gvo('<<spam>>'))
+        self.assertNotIn('<<spam>>', w.tkinter_vars)
+
+        # Create BooleanVar.
+        self.assertIsInstance(gvo('<<toggle-debugger>>', tk.BooleanVar),
+                              tk.BooleanVar)
+        self.assertIn('<<toggle-debugger>>', w.tkinter_vars)
+
+        # No vartype - check cache.
+        self.assertIsInstance(gvo('<<toggle-debugger>>'), tk.BooleanVar)
+
+    @mock.patch.object(editor.webbrowser, 'open')
+    @unittest.skipIf(sys.platform.startswith('win'), 'Unix only')
+    def test__extra_help_callback_not_windows(self, mock_openfile):
+        w = self.mock_editwin
+        ehc = partial(w._EditorWindow__extra_help_callback, w)
+
+        ehc('http://python.org')
+        mock_openfile.called_with('http://python.org')
+        ehc('www.python.org')
+        mock_openfile.called_with('www.python.org')
+        ehc('/foo/bar/baz/')
+        mock_openfile.called_with('/foo/bar/baz')
+
+    @mock.patch.object(editor.os, 'startfile')
+    @unittest.skipIf(not sys.platform.startswith('win'), 'Windows only')
+    def test_extra_help_callback_windows(self, mock_start):
+        # os.startfile doesn't exist on other platforms.
+        w = self.mock_editwin
+        w.showerror = mock.Mock()
+        def ehc(source):
+            return Editor._extra_help_callback(w, source)
+        ehc('http://python.org')
+        # 'called_with' requires spec tjr
+        #mock_start.called_with('http://python.org')
+        # Filename that doesn't open.
+        # But get '(X)' tk box 'Document Start Fa...' that needs OK click.
+        #mock_start.side_effect = OSError('boom')
+        ehc('/foo/bar/baz/')()
+        self.assertTrue(w.showerror.callargs.kwargs)
+
+
+class BindingsTest(unittest.TestCase):
+
+    def test_apply_bindings(self):
+        eq = self.assertEqual
+        w = editwin
+        # Save original text and recreate an empty version.  It is not
+        # actually empty because Text widgets are created with default
+        # events.
+        orig_text = w.text
+        # Multicall has its own versions of the event_* methods.
+        text = w.text = MultiCallCreator(tk.Text)(root)
+
+        keydefs = {'<<zoom-height>>': ['<Alt-Key-9>'],
+                   '<<open-module>>': ['<Control-Shift-O>'],
+                   '<<cancel>>': ['<Cancel>'],
+                   '<<empty>>': [],
+                   '<<indent>>': ['<Alt-bracketleft>'],
+                   '<<copy>>': ['<Control-j>', '<Control-c>']}
+
+        w.apply_bindings(keydefs)
+        eq(text.keydefs, keydefs)
+        # Multicall event_add() formats the key sequences.
+        eq(text.event_info('<<zoom-height>>'), ('<Alt-KeyPress-9>',))
+        eq(text.event_info('<<copy>>'), ('<Control-Key-j>', '<Control-Key-c>'))
+        eq(text.event_info('<<cancel>>'), ('<Key-Cancel>',))
+        # Although apply_bindings() skips events with no keys, Multicall
+        # event_info() just returns an empty tuple for undefined events.
+        eq(text.event_info('<<empty>>'), ())
+        # Not in keydefs.
+        eq(text.event_info('<<python-docs>>'), ())
+
+        # Cleanup.
+        for event, keylist in keydefs.items():
+            text.event_delete(event, *keylist)
+
+        # Use default.
+        w.apply_bindings()
+        eq(text.event_info('<<python-docs>>'), ('<KeyPress-F1>',))
+
+        del w.text
+        w.text = orig_text
+
+
+class ReloadTests(unittest.TestCase):
+    """Test functions called from configdialog for reloading attributes."""
+
+    @classmethod
+    def setUpClass(cls):
+        cls.keydefs = {'<<copy>>': ['<Control-c>', '<Control-C>'],
+                       '<<beginning-of-line>>': ['<Control-a>', '<Home>'],
+                       '<<close-window>>': ['<Alt-F4>'],
+                       '<<python-docs>>': ['<F15>'],
+                       '<<python-context-help>>': ['<Shift-F1>'], }
+        cls.extensions = {'<<zzdummy>>'}
+        cls.ext_keydefs = {'<<zzdummy>>': ['<Alt-Control-Shift-z>']}
+
+    @classmethod
+    def tearDownClass(cls):
+        del cls.keydefs, cls.extensions, cls.ext_keydefs
+
+    def setUp(self):
+        self.save_text = editwin.text
+        editwin.text = MultiCallCreator(tk.Text)(root)
+
+    def tearDown(self):
+        del editwin.text
+        editwin.text = self.save_text
+
+    @mock.patch.object(editor.idleConf, 'GetExtensionBindings')
+    @mock.patch.object(editor.idleConf, 'GetExtensions')
+    @mock.patch.object(editor.idleConf, 'GetCurrentKeySet')
+    def test_RemoveKeyBindings(self, mock_keyset, mock_ext, mock_ext_bindings):
+        eq = self.assertEqual
+        w = editwin
+        tei = w.text.event_info
+        keys = self.keydefs
+        extkeys = self.ext_keydefs
+
+        mock_keyset.return_value = keys
+        mock_ext.return_value = self.extensions
+        mock_ext_bindings.return_value = extkeys
+
+        w.apply_bindings(keys)
+        w.apply_bindings({'<<spam>>': ['<F18>']})
+        w.apply_bindings(extkeys)
+
+        # Bindings exist.
+        for event in keys:
+            self.assertNotEqual(tei(event), ())
+        self.assertNotEqual(tei('<<spam>>'), ())
+        # Extention bindings exist.
+        for event in extkeys:
+            self.assertNotEqual(tei(event), ())
+
+        w.RemoveKeybindings()
+        # Binding events have been deleted.
+        for event in keys:
+            eq(tei(event), ())
+        # Extention bindings have been removed.
+        for event in extkeys:
+            eq(tei(event), ())
+        # Extra keybindings are not removed - only removes those in idleConf.
+        self.assertNotEqual(tei('<<spam>>'), ())
+        # Remove it.
+        w.text.event_delete('<<spam>>', ['<F18>'])
+
+    @mock.patch.object(editor.idleConf, 'GetExtensionBindings')
+    @mock.patch.object(editor.idleConf, 'GetExtensions')
+    @mock.patch.object(editor.idleConf, 'GetCurrentKeySet')
+    def test_ApplyKeyBindings(self, mock_keyset, mock_ext, mock_ext_bindings):
+        eq = self.assertEqual
+        w = editwin
+        tei = w.text.event_info
+        keys = self.keydefs
+        extkeys = self.ext_keydefs
+
+        mock_keyset.return_value = keys
+        mock_ext.return_value = self.extensions
+        mock_ext_bindings.return_value = extkeys
+
+        # Bindings don't exist.
+        for event in keys:
+            eq(tei(event), ())
+        # Extention bindings don't exist.
+        for event in extkeys:
+            eq(tei(event), ())
+
+        w.ApplyKeybindings()
+        eq(tei('<<python-docs>>'), ('<Key-F15>',))
+        eq(tei('<<beginning-of-line>>'), ('<Control-Key-a>', '<Key-Home>'))
+        eq(tei('<<zzdummy>>'), ('<Control-Shift-Alt-Key-z>',))
+        # Check menu accelerator update.
+        eq(w.menudict['help'].entrycget(3, 'accelerator'), 'F15')
+
+        # Calling ApplyBindings is additive.
+        mock_keyset.return_value = {'<<python-docs>>': ['<Shift-F1>']}
+        w.ApplyKeybindings()
+        eq(tei('<<python-docs>>'), ('<Key-F15>', '<Shift-Key-F1>'))
+        w.text.event_delete('<<python-docs>>', ['<Shift-Key-F1>'])
+
+        mock_keyset.return_value = keys
+        w.RemoveKeybindings()
+
+    def test_ResetColorizer(self):
+        pass
+
+    @mock.patch.object(editor.idleConf, 'GetFont')
+    def test_ResetFont(self, mock_getfont):
+        mock_getfont.return_value = ('spam', 16, 'bold')
+        self.assertNotEqual(editwin.text['font'], 'spam 16 bold')
+        editwin.ResetFont()
+        self.assertEqual(editwin.text['font'], 'spam 16 bold')
+
+    @mock.patch.object(editor.idleConf, 'GetOption')
+    def test_set_notabs_indentwidth(self, mock_get_option):
+        save_usetabs = editwin.usetabs
+        save_indentwidth = editwin.indentwidth
+        mock_get_option.return_value = 11
+
+        editwin.usetabs = True
+        editwin.set_notabs_indentwidth()
+        self.assertNotEqual(editwin.indentwidth, 11)
+
+        editwin.usetabs = False
+        editwin.set_notabs_indentwidth()
+        self.assertEqual(editwin.indentwidth, 11)
+
+        editwin.usetabs = save_usetabs
+        editwin.indentwidth = save_indentwidth
+
+
 if __name__ == '__main__':
     unittest.main(verbosity=2)
diff --git a/Misc/NEWS.d/next/IDLE/2017-09-20-09-07-09.bpo-31529.w8ioyr.rst b/Misc/NEWS.d/next/IDLE/2017-09-20-09-07-09.bpo-31529.w8ioyr.rst
new file mode 100644
index 00000000000000..3fc798866fd2ec
--- /dev/null
+++ b/Misc/NEWS.d/next/IDLE/2017-09-20-09-07-09.bpo-31529.w8ioyr.rst
@@ -0,0 +1 @@
+IDLE: Add docstrings and unittests for some functions in editor.py.

<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'>
<html xmlns='http://www.w3.org/1999/xhtml'>
<head>
<title>pFad - Phonifier reborn</title>
<meta http-equiv='Content-Type' content='text/html; charset=utf-8' />
</head>
<body>
<h1>Pfad - The Proxy pFad of &#169; 2024 Garber Painting. All rights reserved.</h1>


<!-- Disclaimer -->
<p>Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.</p>
<br>
<p>Alternative Proxies:</p><p><a href="http://rainy.clevelandohioweatherforecast.com/php-proxy/index.php?q=https://patch-diff.githubusercontent.com/raw/python/cpython/pull/3669.diff" target="_blank">Alternative Proxy</a></p><p><a href="http://rainy.clevelandohioweatherforecast.com/pFad/index.php?u=https://patch-diff.githubusercontent.com/raw/python/cpython/pull/3669.diff" target="_blank">pFad Proxy</a></p><p><a href="http://rainy.clevelandohioweatherforecast.com/pFad/v3index.php?u=https://patch-diff.githubusercontent.com/raw/python/cpython/pull/3669.diff" target="_blank">pFad v3 Proxy</a></p><p><a href="http://rainy.clevelandohioweatherforecast.com/pFad/v4index.php?u=https://patch-diff.githubusercontent.com/raw/python/cpython/pull/3669.diff" target="_blank">pFad v4 Proxy</a></p></body>
</html>