Store generated list of frozen modules for contrib/tools/python

a94357bf8071b16879eeabac1f52f54e278c03ed
author: thegeorg <thegeorg@yandex-team.com> 2024-03-15 23:28:02 +0300
committer: thegeorg <thegeorg@yandex-team.com> 2024-03-15 23:38:24 +0300
commit: 6635e51dd2fc4c8fbc3e510cd31c9c9102b7cfda (patch)
tree: d51d048d3eb5d7a24ec6e4302b589513a3b97de3 /contrib/tools/python/src/Lib/idlelib/idle_test
parent: e894914751eea93bb23102a533c8d481b80c2560 (diff)
download: ydb-6635e51dd2fc4c8fbc3e510cd31c9c9102b7cfda.tar.gz
24 files changed, 0 insertions, 3680 deletions
diff --git a/contrib/tools/python/src/Lib/idlelib/idle_test/__init__.py b/contrib/tools/python/src/Lib/idlelib/idle_test/__init__.py
deleted file mode 100644
index 845c92d372..0000000000
--- a/contrib/tools/python/src/Lib/idlelib/idle_test/__init__.py
+++ /dev/null
@@ -1,15 +0,0 @@
-'''idlelib.idle_test is a private implementation of test.test_idle,
-which tests the IDLE application as part of the stdlib test suite.
-Run IDLE tests alone with "python -m test.test_idle".
-This package and its contained modules are subject to change and
-any direct use is at your own risk.
-'''
-from os.path import dirname
-
-def load_tests(loader, standard_tests, pattern):
-    this_dir = dirname(__file__)
-    top_dir = dirname(dirname(this_dir))
-    package_tests = loader.discover(start_dir=this_dir, pattern='test*.py',
-                                    top_level_dir=top_dir)
-    standard_tests.addTests(package_tests)
-    return standard_tests
diff --git a/contrib/tools/python/src/Lib/idlelib/idle_test/htest.py b/contrib/tools/python/src/Lib/idlelib/idle_test/htest.py
deleted file mode 100644
index 9e2ddd2c19..0000000000
--- a/contrib/tools/python/src/Lib/idlelib/idle_test/htest.py
+++ /dev/null
@@ -1,403 +0,0 @@
-'''Run human tests of Idle's window, dialog, and popup widgets.
-
-run(*tests)
-Create a master Tk window.  Within that, run each callable in tests
-after finding the matching test spec in this file.  If tests is empty,
-run an htest for each spec dict in this file after finding the matching
-callable in the module named in the spec.  Close the window to skip or
-end the test.
-
-In a tested module, let X be a global name bound to a callable (class
-or function) whose .__name__ attrubute is also X (the usual situation).
-The first parameter of X must be 'parent'.  When called, the parent
-argument will be the root window.  X must create a child Toplevel
-window (or subclass thereof).  The Toplevel may be a test widget or
-dialog, in which case the callable is the corresonding class.  Or the
-Toplevel may contain the widget to be tested or set up a context in
-which a test widget is invoked.  In this latter case, the callable is a
-wrapper function that sets up the Toplevel and other objects.  Wrapper
-function names, such as _editor_window', should start with '_'.
-
-
-End the module with
-
-if __name__ == '__main__':
-    <unittest, if there is one>
-    from idlelib.idle_test.htest import run
-    run(X)
-
-To have wrapper functions and test invocation code ignored by coveragepy
-reports, put '# htest #' on the def statement header line.
-
-def _wrapper(parent):  # htest #
-
-Also make sure that the 'if __name__' line matches the above.  Then have
-make sure that .coveragerc includes the following.
-
-[report]
-exclude_lines =
-    .*# htest #
-    if __name__ == .__main__.:
-
-(The "." instead of "'" is intentional and necessary.)
-
-
-To run any X, this file must contain a matching instance of the
-following template, with X.__name__ prepended to '_spec'.
-When all tests are run, the prefix is use to get X.
-
-_spec = {
-    'file': '',
-    'kwds': {'title': ''},
-    'msg': ""
-    }
-
-file (no .py): run() imports file.py.
-kwds: augmented with {'parent':root} and passed to X as **kwds.
-title: an example kwd; some widgets need this, delete if not.
-msg: master window hints about testing the widget.
-
-
-Modules and classes not being tested at the moment:
-PyShell.PyShellEditorWindow
-Debugger.Debugger
-AutoCompleteWindow.AutoCompleteWindow
-OutputWindow.OutputWindow (indirectly being tested with grep test)
-'''
-
-from importlib import import_module
-from idlelib.macosxSupport import _initializeTkVariantTests
-import Tkinter as tk
-
-AboutDialog_spec = {
-    'file': 'aboutDialog',
-    'kwds': {'title': 'aboutDialog test',
-             '_htest': True,
-             },
-    'msg': "Test every button. Ensure Python, TK and IDLE versions "
-           "are correctly displayed.\n [Close] to exit.",
-    }
-
-_calltip_window_spec = {
-    'file': 'CallTipWindow',
-    'kwds': {},
-    'msg': "Typing '(' should display a calltip.\n"
-           "Typing ') should hide the calltip.\n"
-    }
-
-_class_browser_spec = {
-    'file': 'ClassBrowser',
-    'kwds': {},
-    'msg': "Inspect names of module, class(with superclass if "
-           "applicable), methods and functions.\nToggle nested items.\n"
-           "Double clicking on items prints a traceback for an exception "
-           "that is ignored."
-    }
-
-_color_delegator_spec = {
-    'file': 'ColorDelegator',
-    'kwds': {},
-    'msg': "The text is sample Python code.\n"
-           "Ensure components like comments, keywords, builtins,\n"
-           "string, definitions, and break are correctly colored.\n"
-           "The default color scheme is in idlelib/config-highlight.def"
-    }
-
-ConfigDialog_spec = {
-    'file': 'configDialog',
-    'kwds': {'title': 'ConfigDialogTest',
-             '_htest': True,},
-    'msg': "IDLE preferences dialog.\n"
-           "In the 'Fonts/Tabs' tab, changing font face, should update the "
-           "font face of the text in the area below it.\nIn the "
-           "'Highlighting' tab, try different color schemes. Clicking "
-           "items in the sample program should update the choices above it."
-           "\nIn the 'Keys', 'General' and 'Extensions' tabs, test settings "
-           "of interest."
-           "\n[Ok] to close the dialog.[Apply] to apply the settings and "
-           "and [Cancel] to revert all changes.\nRe-run the test to ensure "
-           "changes made have persisted."
-    }
-
-# TODO Improve message
-_dyn_option_menu_spec = {
-    'file': 'dynOptionMenuWidget',
-    'kwds': {},
-    'msg': "Select one of the many options in the 'old option set'.\n"
-           "Click the button to change the option set.\n"
-           "Select one of the many options in the 'new option set'."
-    }
-
-# TODO edit wrapper
-_editor_window_spec = {
-   'file': 'EditorWindow',
-    'kwds': {},
-    'msg': "Test editor functions of interest.\n"
-           "Best to close editor first."
-    }
-
-GetCfgSectionNameDialog_spec = {
-    'file': 'configSectionNameDialog',
-    'kwds': {'title':'Get Name',
-             'message':'Enter something',
-             'used_names': {'abc'},
-             '_htest': True},
-    'msg': "After the text entered with [Ok] is stripped, <nothing>, "
-           "'abc', or more that 30 chars are errors.\n"
-           "Close 'Get Name' with a valid entry (printed to Shell), "
-           "[Cancel], or [X]",
-    }
-
-GetHelpSourceDialog_spec = {
-    'file': 'configHelpSourceEdit',
-    'kwds': {'title': 'Get helpsource',
-             '_htest': True},
-    'msg': "Enter menu item name and help file path\n "
-           "<nothing> and more than 30 chars are invalid menu item names.\n"
-           "<nothing>, file does not exist are invalid path items.\n"
-           "Test for incomplete web address for help file path.\n"
-           "A valid entry will be printed to shell with [0k].\n"
-           "[Cancel] will print None to shell",
-    }
-
-# Update once issue21519 is resolved.
-GetKeysDialog_spec = {
-    'file': 'keybindingDialog',
-    'kwds': {'title': 'Test keybindings',
-             'action': 'find-again',
-             'currentKeySequences': [''] ,
-             '_htest': True,
-             },
-    'msg': "Test for different key modifier sequences.\n"
-           "<nothing> is invalid.\n"
-           "No modifier key is invalid.\n"
-           "Shift key with [a-z],[0-9], function key, move key, tab, space "
-           "is invalid.\nNo validitity checking if advanced key binding "
-           "entry is used."
-    }
-
-_grep_dialog_spec = {
-    'file': 'GrepDialog',
-    'kwds': {},
-    'msg': "Click the 'Show GrepDialog' button.\n"
-           "Test the various 'Find-in-files' functions.\n"
-           "The results should be displayed in a new '*Output*' window.\n"
-           "'Right-click'->'Goto file/line' anywhere in the search results "
-           "should open that file \nin a new EditorWindow."
-    }
-
-_io_binding_spec = {
-    'file': 'IOBinding',
-    'kwds': {},
-    'msg': "Test the following bindings.\n"
-           "<Control-o> to open file from dialog.\n"
-           "Edit the file.\n"
-           "<Control-p> to print the file.\n"
-           "<Control-s> to save the file.\n"
-           "<Alt-s> to save-as another file.\n"
-           "<Control-c> to save-copy-as another file.\n"
-           "Check that changes were saved by opening the file elsewhere."
-    }
-
-_multi_call_spec = {
-    'file': 'MultiCall',
-    'kwds': {},
-    'msg': "The following actions should trigger a print to console or IDLE"
-           " Shell.\nEntering and leaving the text area, key entry, "
-           "<Control-Key>,\n<Alt-Key-a>, <Control-Key-a>, "
-           "<Alt-Control-Key-a>, \n<Control-Button-1>, <Alt-Button-1> and "
-           "focusing out of the window\nare sequences to be tested."
-    }
-
-_multistatus_bar_spec = {
-    'file': 'MultiStatusBar',
-    'kwds': {},
-    'msg': "Ensure presence of multi-status bar below text area.\n"
-           "Click 'Update Status' to change the multi-status text"
-    }
-
-_object_browser_spec = {
-    'file': 'ObjectBrowser',
-    'kwds': {},
-    'msg': "Double click on items upto the lowest level.\n"
-           "Attributes of the objects and related information "
-           "will be displayed side-by-side at each level."
-    }
-
-_path_browser_spec = {
-    'file': 'PathBrowser',
-    'kwds': {},
-    'msg': "Test for correct display of all paths in sys.path.\n"
-           "Toggle nested items upto the lowest level.\n"
-           "Double clicking on an item prints a traceback\n"
-           "for an exception that is ignored."
-    }
-
-_percolator_spec = {
-    'file': 'Percolator',
-    'kwds': {},
-    'msg': "There are two tracers which can be toggled using a checkbox.\n"
-           "Toggling a tracer 'on' by checking it should print tracer "
-           "output to the console or to the IDLE shell.\n"
-           "If both the tracers are 'on', the output from the tracer which "
-           "was switched 'on' later, should be printed first\n"
-           "Test for actions like text entry, and removal."
-    }
-
-_replace_dialog_spec = {
-    'file': 'ReplaceDialog',
-    'kwds': {},
-    'msg': "Click the 'Replace' button.\n"
-           "Test various replace options in the 'Replace dialog'.\n"
-           "Click [Close] or [X] to close the 'Replace Dialog'."
-    }
-
-_search_dialog_spec = {
-    'file': 'SearchDialog',
-    'kwds': {},
-    'msg': "Click the 'Search' button.\n"
-           "Test various search options in the 'Search dialog'.\n"
-           "Click [Close] or [X] to close the 'Search Dialog'."
-    }
-
-_scrolled_list_spec = {
-    'file': 'ScrolledList',
-    'kwds': {},
-    'msg': "You should see a scrollable list of items\n"
-           "Selecting (clicking) or double clicking an item "
-           "prints the name to the console or Idle shell.\n"
-           "Right clicking an item will display a popup."
-    }
-
-show_idlehelp_spec = {
-    'file': 'help',
-    'kwds': {},
-    'msg': "If the help text displays, this works.\n"
-           "Text is selectable. Window is scrollable."
-    }
-
-_stack_viewer_spec = {
-    'file': 'StackViewer',
-    'kwds': {},
-    'msg': "A stacktrace for a NameError exception.\n"
-           "Expand 'idlelib ...' and '<locals>'.\n"
-           "Check that exc_value, exc_tb, and exc_type are correct.\n"
-    }
-
-_tabbed_pages_spec = {
-    'file': 'tabbedpages',
-    'kwds': {},
-    'msg': "Toggle between the two tabs 'foo' and 'bar'\n"
-           "Add a tab by entering a suitable name for it.\n"
-           "Remove an existing tab by entering its name.\n"
-           "Remove all existing tabs.\n"
-           "<nothing> is an invalid add page and remove page name.\n"
-    }
-
-TextViewer_spec = {
-    'file': 'textView',
-    'kwds': {'title': 'Test textView',
-             'text':'The quick brown fox jumps over the lazy dog.\n'*35,
-             '_htest': True},
-    'msg': "Test for read-only property of text.\n"
-           "Text is selectable. Window is scrollable.",
-     }
-
-_tooltip_spec = {
-    'file': 'ToolTip',
-    'kwds': {},
-    'msg': "Place mouse cursor over both the buttons\n"
-           "A tooltip should appear with some text."
-    }
-
-_tree_widget_spec = {
-    'file': 'TreeWidget',
-    'kwds': {},
-    'msg': "The canvas is scrollable.\n"
-           "Click on folders upto to the lowest level."
-    }
-
-_undo_delegator_spec = {
-    'file': 'UndoDelegator',
-    'kwds': {},
-    'msg': "Click [Undo] to undo any action.\n"
-           "Click [Redo] to redo any action.\n"
-           "Click [Dump] to dump the current state "
-           "by printing to the console or the IDLE shell.\n"
-    }
-
-_widget_redirector_spec = {
-    'file': 'WidgetRedirector',
-    'kwds': {},
-    'msg': "Every text insert should be printed to the console "
-           "or the IDLE shell."
-    }
-
-def run(*tests):
-    root = tk.Tk()
-    root.title('IDLE htest')
-    root.resizable(0, 0)
-    _initializeTkVariantTests(root)
-
-    # a scrollable Label like constant width text widget.
-    frameLabel = tk.Frame(root, padx=10)
-    frameLabel.pack()
-    text = tk.Text(frameLabel, wrap='word')
-    text.configure(bg=root.cget('bg'), relief='flat', height=4, width=70)
-    scrollbar = tk.Scrollbar(frameLabel, command=text.yview)
-    text.config(yscrollcommand=scrollbar.set)
-    scrollbar.pack(side='right', fill='y', expand=False)
-    text.pack(side='left', fill='both', expand=True)
-
-    test_list = [] # List of tuples of the form (spec, callable widget)
-    if tests:
-        for test in tests:
-            test_spec = globals()[test.__name__ + '_spec']
-            test_spec['name'] = test.__name__
-            test_list.append((test_spec,  test))
-    else:
-        for k, d in globals().items():
-            if k.endswith('_spec'):
-                test_name = k[:-5]
-                test_spec = d
-                test_spec['name'] = test_name
-                mod = import_module('idlelib.' + test_spec['file'])
-                test = getattr(mod, test_name)
-                test_list.append((test_spec, test))
-
-    test_name = [tk.StringVar('')]
-    callable_object = [None]
-    test_kwds = [None]
-
-
-    def next():
-        if len(test_list) == 1:
-            next_button.pack_forget()
-        test_spec, callable_object[0] = test_list.pop()
-        test_kwds[0] = test_spec['kwds']
-        test_kwds[0]['parent'] = root
-        test_name[0].set('Test ' + test_spec['name'])
-
-        text.configure(state='normal') # enable text editing
-        text.delete('1.0','end')
-        text.insert("1.0",test_spec['msg'])
-        text.configure(state='disabled') # preserve read-only property
-
-    def run_test():
-        widget = callable_object[0](**test_kwds[0])
-        try:
-            print(widget.result)
-        except AttributeError:
-            pass
-
-    button = tk.Button(root, textvariable=test_name[0], command=run_test)
-    button.pack()
-    next_button = tk.Button(root, text="Next", command=next)
-    next_button.pack()
-
-    next()
-
-    root.mainloop()
-
-if __name__ == '__main__':
-    run()
diff --git a/contrib/tools/python/src/Lib/idlelib/idle_test/mock_idle.py b/contrib/tools/python/src/Lib/idlelib/idle_test/mock_idle.py
deleted file mode 100644
index 7b09f836f0..0000000000
--- a/contrib/tools/python/src/Lib/idlelib/idle_test/mock_idle.py
+++ /dev/null
@@ -1,55 +0,0 @@
-'''Mock classes that imitate idlelib modules or classes.
-
-Attributes and methods will be added as needed for tests.
-'''
-
-from idlelib.idle_test.mock_tk import Text
-
-class Func(object):
-    '''Mock function captures args and returns result set by test.
-
-    Attributes:
-    self.called - records call even if no args, kwds passed.
-    self.result - set by init, returned by call.
-    self.args - captures positional arguments.
-    self.kwds - captures keyword arguments.
-
-    Most common use will probably be to mock methods.
-    Mock_tk.Var and Mbox_func are special variants of this.
-    '''
-    def __init__(self, result=None):
-        self.called = False
-        self.result = result
-        self.args = None
-        self.kwds = None
-    def __call__(self, *args, **kwds):
-        self.called = True
-        self.args = args
-        self.kwds = kwds
-        if isinstance(self.result, BaseException):
-            raise self.result
-        else:
-            return self.result
-
-
-class Editor(object):
-    '''Minimally imitate EditorWindow.EditorWindow class.
-    '''
-    def __init__(self, flist=None, filename=None, key=None, root=None):
-        self.text = Text()
-        self.undo = UndoDelegator()
-
-    def get_selection_indices(self):
-        first = self.text.index('1.0')
-        last = self.text.index('end')
-        return first, last
-
-
-class UndoDelegator(object):
-    '''Minimally imitate UndoDelegator,UndoDelegator class.
-    '''
-    # A real undo block is only needed for user interaction.
-    def undo_block_start(*args):
-        pass
-    def undo_block_stop(*args):
-        pass
diff --git a/contrib/tools/python/src/Lib/idlelib/idle_test/mock_tk.py b/contrib/tools/python/src/Lib/idlelib/idle_test/mock_tk.py
deleted file mode 100644
index 56ca87695a..0000000000
--- a/contrib/tools/python/src/Lib/idlelib/idle_test/mock_tk.py
+++ /dev/null
@@ -1,298 +0,0 @@
-"""Classes that replace tkinter gui objects used by an object being tested.
-
-A gui object is anything with a master or parent parameter, which is
-typically required in spite of what the doc strings say.
-"""
-
-class Event(object):
-    '''Minimal mock with attributes for testing event handlers.
-
-    This is not a gui object, but is used as an argument for callbacks
-    that access attributes of the event passed. If a callback ignores
-    the event, other than the fact that is happened, pass 'event'.
-
-    Keyboard, mouse, window, and other sources generate Event instances.
-    Event instances have the following attributes: serial (number of
-    event), time (of event), type (of event as number), widget (in which
-    event occurred), and x,y (position of mouse). There are other
-    attributes for specific events, such as keycode for key events.
-    tkinter.Event.__doc__ has more but is still not complete.
-    '''
-    def __init__(self, **kwds):
-        "Create event with attributes needed for test"
-        self.__dict__.update(kwds)
-
-class Var(object):
-    "Use for String/Int/BooleanVar: incomplete"
-    def __init__(self, master=None, value=None, name=None):
-        self.master = master
-        self.value = value
-        self.name = name
-    def set(self, value):
-        self.value = value
-    def get(self):
-        return self.value
-
-class Mbox_func(object):
-    """Generic mock for messagebox functions, which all have the same signature.
-
-    Instead of displaying a message box, the mock's call method saves the
-    arguments as instance attributes, which test functions can then examime.
-    The test can set the result returned to ask function
-    """
-    def __init__(self, result=None):
-        self.result = result  # Return None for all show funcs
-    def __call__(self, title, message, *args, **kwds):
-        # Save all args for possible examination by tester
-        self.title = title
-        self.message = message
-        self.args = args
-        self.kwds = kwds
-        return self.result  # Set by tester for ask functions
-
-class Mbox(object):
-    """Mock for tkinter.messagebox with an Mbox_func for each function.
-
-    This module was 'tkMessageBox' in 2.x; hence the 'import as' in  3.x.
-    Example usage in test_module.py for testing functions in module.py:
-    ---
-from idlelib.idle_test.mock_tk import Mbox
-import module
-
-orig_mbox = module.tkMessageBox
-showerror = Mbox.showerror  # example, for attribute access in test methods
-
-class Test(unittest.TestCase):
-
-    @classmethod
-    def setUpClass(cls):
-        module.tkMessageBox = Mbox
-
-    @classmethod
-    def tearDownClass(cls):
-        module.tkMessageBox = orig_mbox
-    ---
-    For 'ask' functions, set func.result return value before calling the method
-    that uses the message function. When tkMessageBox functions are the
-    only gui alls in a method, this replacement makes the method gui-free,
-    """
-    askokcancel = Mbox_func()     # True or False
-    askquestion = Mbox_func()     # 'yes' or 'no'
-    askretrycancel = Mbox_func()  # True or False
-    askyesno = Mbox_func()        # True or False
-    askyesnocancel = Mbox_func()  # True, False, or None
-    showerror = Mbox_func()    # None
-    showinfo = Mbox_func()     # None
-    showwarning = Mbox_func()  # None
-
-from _tkinter import TclError
-
-class Text(object):
-    """A semi-functional non-gui replacement for tkinter.Text text editors.
-
-    The mock's data model is that a text is a list of \n-terminated lines.
-    The mock adds an empty string at  the beginning of the list so that the
-    index of actual lines start at 1, as with Tk. The methods never see this.
-    Tk initializes files with a terminal \n that cannot be deleted. It is
-    invisible in the sense that one cannot move the cursor beyond it.
-
-    This class is only tested (and valid) with strings of ascii chars.
-    For testing, we are not concerned with Tk Text's treatment of,
-    for instance, 0-width characters or character + accent.
-   """
-    def __init__(self, master=None, cnf={}, **kw):
-        '''Initialize mock, non-gui, text-only Text widget.
-
-        At present, all args are ignored. Almost all affect visual behavior.
-        There are just a few Text-only options that affect text behavior.
-        '''
-        self.data = ['', '\n']
-
-    def index(self, index):
-        "Return string version of index decoded according to current text."
-        return "%s.%s" % self._decode(index, endflag=1)
-
-    def _decode(self, index, endflag=0):
-        """Return a (line, char) tuple of int indexes into self.data.
-
-        This implements .index without converting the result back to a string.
-        The result is contrained by the number of lines and linelengths of
-        self.data. For many indexes, the result is initially (1, 0).
-
-        The input index may have any of several possible forms:
-        * line.char float: converted to 'line.char' string;
-        * 'line.char' string, where line and char are decimal integers;
-        * 'line.char lineend', where lineend='lineend' (and char is ignored);
-        * 'line.end', where end='end' (same as above);
-        * 'insert', the positions before terminal \n;
-        * 'end', whose meaning depends on the endflag passed to ._endex.
-        * 'sel.first' or 'sel.last', where sel is a tag -- not implemented.
-        """
-        if isinstance(index, (float, bytes)):
-            index = str(index)
-        try:
-            index=index.lower()
-        except AttributeError:
-            raise TclError('bad text index "%s"' % index)
-
-        lastline =  len(self.data) - 1  # same as number of text lines
-        if index == 'insert':
-            return lastline, len(self.data[lastline]) - 1
-        elif index == 'end':
-            return self._endex(endflag)
-
-        line, char = index.split('.')
-        line = int(line)
-
-        # Out of bounds line becomes first or last ('end') index
-        if line < 1:
-            return 1, 0
-        elif line > lastline:
-            return self._endex(endflag)
-
-        linelength = len(self.data[line])  -1  # position before/at \n
-        if char.endswith(' lineend') or char == 'end':
-            return line, linelength
-            # Tk requires that ignored chars before ' lineend' be valid int
-
-        # Out of bounds char becomes first or last index of line
-        char = int(char)
-        if char < 0:
-            char = 0
-        elif char > linelength:
-            char = linelength
-        return line, char
-
-    def _endex(self, endflag):
-        '''Return position for 'end' or line overflow corresponding to endflag.
-
-       -1: position before terminal \n; for .insert(), .delete
-       0: position after terminal \n; for .get, .delete index 1
-       1: same viewed as beginning of non-existent next line (for .index)
-       '''
-        n = len(self.data)
-        if endflag == 1:
-            return n, 0
-        else:
-            n -= 1
-            return n, len(self.data[n]) + endflag
-
-
-    def insert(self, index, chars):
-        "Insert chars before the character at index."
-
-        if not chars:  # ''.splitlines() is [], not ['']
-            return
-        chars = chars.splitlines(True)
-        if chars[-1][-1] == '\n':
-            chars.append('')
-        line, char = self._decode(index, -1)
-        before = self.data[line][:char]
-        after = self.data[line][char:]
-        self.data[line] = before + chars[0]
-        self.data[line+1:line+1] = chars[1:]
-        self.data[line+len(chars)-1] += after
-
-
-    def get(self, index1, index2=None):
-        "Return slice from index1 to index2 (default is 'index1+1')."
-
-        startline, startchar = self._decode(index1)
-        if index2 is None:
-            endline, endchar = startline, startchar+1
-        else:
-            endline, endchar = self._decode(index2)
-
-        if startline == endline:
-            return self.data[startline][startchar:endchar]
-        else:
-            lines = [self.data[startline][startchar:]]
-            for i in range(startline+1, endline):
-                lines.append(self.data[i])
-            lines.append(self.data[endline][:endchar])
-            return ''.join(lines)
-
-
-    def delete(self, index1, index2=None):
-        '''Delete slice from index1 to index2 (default is 'index1+1').
-
-        Adjust default index2 ('index+1) for line ends.
-        Do not delete the terminal \n at the very end of self.data ([-1][-1]).
-        '''
-        startline, startchar = self._decode(index1, -1)
-        if index2 is None:
-            if startchar < len(self.data[startline])-1:
-                # not deleting \n
-                endline, endchar = startline, startchar+1
-            elif startline < len(self.data) - 1:
-                # deleting non-terminal \n, convert 'index1+1 to start of next line
-                endline, endchar = startline+1, 0
-            else:
-                # do not delete terminal \n if index1 == 'insert'
-                return
-        else:
-            endline, endchar = self._decode(index2, -1)
-            # restricting end position to insert position excludes terminal \n
-
-        if startline == endline and startchar < endchar:
-            self.data[startline] = self.data[startline][:startchar] + \
-                                             self.data[startline][endchar:]
-        elif startline < endline:
-            self.data[startline] = self.data[startline][:startchar] + \
-                                   self.data[endline][endchar:]
-            startline += 1
-            for i in range(startline, endline+1):
-                del self.data[startline]
-
-    def compare(self, index1, op, index2):
-        line1, char1 = self._decode(index1)
-        line2, char2 = self._decode(index2)
-        if op == '<':
-            return line1 < line2 or line1 == line2 and char1 < char2
-        elif op == '<=':
-            return line1 < line2 or line1 == line2 and char1 <= char2
-        elif op == '>':
-            return line1 > line2 or line1 == line2 and char1 > char2
-        elif op == '>=':
-            return line1 > line2 or line1 == line2 and char1 >= char2
-        elif op == '==':
-            return line1 == line2 and char1 == char2
-        elif op == '!=':
-            return line1 != line2 or  char1 != char2
-        else:
-            raise TclError('''bad comparison operator "%s": '''
-                                  '''must be <, <=, ==, >=, >, or !=''' % op)
-
-    # The following Text methods normally do something and return None.
-    # Whether doing nothing is sufficient for a test will depend on the test.
-
-    def mark_set(self, name, index):
-        "Set mark *name* before the character at index."
-        pass
-
-    def mark_unset(self, *markNames):
-        "Delete all marks in markNames."
-
-    def tag_remove(self, tagName, index1, index2=None):
-        "Remove tag tagName from all characters between index1 and index2."
-        pass
-
-    # The following Text methods affect the graphics screen and return None.
-    # Doing nothing should always be sufficient for tests.
-
-    def scan_dragto(self, x, y):
-        "Adjust the view of the text according to scan_mark"
-
-    def scan_mark(self, x, y):
-        "Remember the current X, Y coordinates."
-
-    def see(self, index):
-        "Scroll screen to make the character at INDEX is visible."
-        pass
-
-    #  The following is a Misc method inherited by Text.
-    # It should properly go in a Misc mock, but is included here for now.
-
-    def bind(sequence=None, func=None, add=None):
-        "Bind to this widget at event sequence a call to function func."
-        pass
diff --git a/contrib/tools/python/src/Lib/idlelib/idle_test/test_autocomplete.py b/contrib/tools/python/src/Lib/idlelib/idle_test/test_autocomplete.py
deleted file mode 100644
index 002751efcc..0000000000
--- a/contrib/tools/python/src/Lib/idlelib/idle_test/test_autocomplete.py
+++ /dev/null
@@ -1,140 +0,0 @@
-import unittest
-from test.test_support import requires
-from Tkinter import Tk, Text
-
-import idlelib.AutoComplete as ac
-import idlelib.AutoCompleteWindow as acw
-from idlelib.idle_test.mock_idle import Func
-from idlelib.idle_test.mock_tk import Event
-
-class AutoCompleteWindow:
-    def complete():
-        return
-
-class DummyEditwin:
-    def __init__(self, root, text):
-        self.root = root
-        self.text = text
-        self.indentwidth = 8
-        self.tabwidth = 8
-        self.context_use_ps1 = True
-
-
-class AutoCompleteTest(unittest.TestCase):
-
-    @classmethod
-    def setUpClass(cls):
-        requires('gui')
-        cls.root = Tk()
-        cls.text = Text(cls.root)
-        cls.editor = DummyEditwin(cls.root, cls.text)
-
-    @classmethod
-    def tearDownClass(cls):
-        del cls.editor, cls.text
-        cls.root.destroy()
-        del cls.root
-
-    def setUp(self):
-        self.editor.text.delete('1.0', 'end')
-        self.autocomplete = ac.AutoComplete(self.editor)
-
-    def test_init(self):
-        self.assertEqual(self.autocomplete.editwin, self.editor)
-
-    def test_make_autocomplete_window(self):
-        testwin = self.autocomplete._make_autocomplete_window()
-        self.assertIsInstance(testwin, acw.AutoCompleteWindow)
-
-    def test_remove_autocomplete_window(self):
-        self.autocomplete.autocompletewindow = (
-            self.autocomplete._make_autocomplete_window())
-        self.autocomplete._remove_autocomplete_window()
-        self.assertIsNone(self.autocomplete.autocompletewindow)
-
-    def test_force_open_completions_event(self):
-        # Test that force_open_completions_event calls _open_completions
-        o_cs = Func()
-        self.autocomplete.open_completions = o_cs
-        self.autocomplete.force_open_completions_event('event')
-        self.assertEqual(o_cs.args, (True, False, True))
-
-    def test_try_open_completions_event(self):
-        Equal = self.assertEqual
-        autocomplete = self.autocomplete
-        trycompletions = self.autocomplete.try_open_completions_event
-        o_c_l = Func()
-        autocomplete._open_completions_later = o_c_l
-
-        # _open_completions_later should not be called with no text in editor
-        trycompletions('event')
-        Equal(o_c_l.args, None)
-
-        # _open_completions_later should be called with COMPLETE_ATTRIBUTES (1)
-        self.text.insert('1.0', 're.')
-        trycompletions('event')
-        Equal(o_c_l.args, (False, False, False, 1))
-
-        # _open_completions_later should be called with COMPLETE_FILES (2)
-        self.text.delete('1.0', 'end')
-        self.text.insert('1.0', '"./Lib/')
-        trycompletions('event')
-        Equal(o_c_l.args, (False, False, False, 2))
-
-    def test_autocomplete_event(self):
-        Equal = self.assertEqual
-        autocomplete = self.autocomplete
-
-        # Test that the autocomplete event is ignored if user is pressing a
-        # modifier key in addition to the tab key
-        ev = Event(mc_state=True)
-        self.assertIsNone(autocomplete.autocomplete_event(ev))
-        del ev.mc_state
-
-        # If autocomplete window is open, complete() method is called
-        self.text.insert('1.0', 're.')
-        # This must call autocomplete._make_autocomplete_window()
-        Equal(self.autocomplete.autocomplete_event(ev), 'break')
-
-        # If autocomplete window is not active or does not exist,
-        # open_completions is called. Return depends on its return.
-        autocomplete._remove_autocomplete_window()
-        o_cs = Func()  # .result = None
-        autocomplete.open_completions = o_cs
-        Equal(self.autocomplete.autocomplete_event(ev), None)
-        Equal(o_cs.args, (False, True, True))
-        o_cs.result = True
-        Equal(self.autocomplete.autocomplete_event(ev), 'break')
-        Equal(o_cs.args, (False, True, True))
-
-    def test_open_completions_later(self):
-        # Test that autocomplete._delayed_completion_id is set
-        pass
-
-    def test_delayed_open_completions(self):
-        # Test that autocomplete._delayed_completion_id set to None and that
-        # open_completions only called if insertion index is the same as
-        # _delayed_completion_index
-        pass
-
-    def test_open_completions(self):
-        # Test completions of files and attributes as well as non-completion
-        # of errors
-        pass
-
-    def test_fetch_completions(self):
-        # Test that fetch_completions returns 2 lists:
-        # For attribute completion, a large list containing all variables, and
-        # a small list containing non-private variables.
-        # For file completion, a large list containing all files in the path,
-        # and a small list containing files that do not start with '.'
-        pass
-
-    def test_get_entity(self):
-        # Test that a name is in the namespace of sys.modules and
-        # __main__.__dict__
-        pass
-
-
-if __name__ == '__main__':
-    unittest.main(verbosity=2)
diff --git a/contrib/tools/python/src/Lib/idlelib/idle_test/test_autoexpand.py b/contrib/tools/python/src/Lib/idlelib/idle_test/test_autoexpand.py
deleted file mode 100644
index 6be4fbf861..0000000000
--- a/contrib/tools/python/src/Lib/idlelib/idle_test/test_autoexpand.py
+++ /dev/null
@@ -1,141 +0,0 @@
-"""Unit tests for idlelib.AutoExpand"""
-import unittest
-from test.test_support import requires
-from Tkinter import Text, Tk
-#from idlelib.idle_test.mock_tk import Text
-from idlelib.AutoExpand import AutoExpand
-
-
-class Dummy_Editwin:
-    # AutoExpand.__init__ only needs .text
-    def __init__(self, text):
-        self.text = text
-
-class AutoExpandTest(unittest.TestCase):
-
-    @classmethod
-    def setUpClass(cls):
-        if 'Tkinter' in str(Text):
-            requires('gui')
-            cls.tk = Tk()
-            cls.text = Text(cls.tk)
-        else:
-            cls.text = Text()
-        cls.auto_expand = AutoExpand(Dummy_Editwin(cls.text))
-
-    @classmethod
-    def tearDownClass(cls):
-        del cls.text, cls.auto_expand
-        if hasattr(cls, 'tk'):
-            cls.tk.destroy()
-            del cls.tk
-
-    def tearDown(self):
-        self.text.delete('1.0', 'end')
-
-    def test_get_prevword(self):
-        text = self.text
-        previous = self.auto_expand.getprevword
-        equal = self.assertEqual
-
-        equal(previous(), '')
-
-        text.insert('insert', 't')
-        equal(previous(), 't')
-
-        text.insert('insert', 'his')
-        equal(previous(), 'this')
-
-        text.insert('insert', ' ')
-        equal(previous(), '')
-
-        text.insert('insert', 'is')
-        equal(previous(), 'is')
-
-        text.insert('insert', '\nsample\nstring')
-        equal(previous(), 'string')
-
-        text.delete('3.0', 'insert')
-        equal(previous(), '')
-
-        text.delete('1.0', 'end')
-        equal(previous(), '')
-
-    def test_before_only(self):
-        previous = self.auto_expand.getprevword
-        expand = self.auto_expand.expand_word_event
-        equal = self.assertEqual
-
-        self.text.insert('insert', 'ab ac bx ad ab a')
-        equal(self.auto_expand.getwords(), ['ab', 'ad', 'ac', 'a'])
-        expand('event')
-        equal(previous(), 'ab')
-        expand('event')
-        equal(previous(), 'ad')
-        expand('event')
-        equal(previous(), 'ac')
-        expand('event')
-        equal(previous(), 'a')
-
-    def test_after_only(self):
-        # Also add punctuation 'noise' that shoud be ignored.
-        text = self.text
-        previous = self.auto_expand.getprevword
-        expand = self.auto_expand.expand_word_event
-        equal = self.assertEqual
-
-        text.insert('insert', 'a, [ab] ac: () bx"" cd ac= ad ya')
-        text.mark_set('insert', '1.1')
-        equal(self.auto_expand.getwords(), ['ab', 'ac', 'ad', 'a'])
-        expand('event')
-        equal(previous(), 'ab')
-        expand('event')
-        equal(previous(), 'ac')
-        expand('event')
-        equal(previous(), 'ad')
-        expand('event')
-        equal(previous(), 'a')
-
-    def test_both_before_after(self):
-        text = self.text
-        previous = self.auto_expand.getprevword
-        expand = self.auto_expand.expand_word_event
-        equal = self.assertEqual
-
-        text.insert('insert', 'ab xy yz\n')
-        text.insert('insert', 'a ac by ac')
-
-        text.mark_set('insert', '2.1')
-        equal(self.auto_expand.getwords(), ['ab', 'ac', 'a'])
-        expand('event')
-        equal(previous(), 'ab')
-        expand('event')
-        equal(previous(), 'ac')
-        expand('event')
-        equal(previous(), 'a')
-
-    def test_other_expand_cases(self):
-        text = self.text
-        expand = self.auto_expand.expand_word_event
-        equal = self.assertEqual
-
-        # no expansion candidate found
-        equal(self.auto_expand.getwords(), [])
-        equal(expand('event'), 'break')
-
-        text.insert('insert', 'bx cy dz a')
-        equal(self.auto_expand.getwords(), [])
-
-        # reset state by successfully expanding once
-        # move cursor to another position and expand again
-        text.insert('insert', 'ac xy a ac ad a')
-        text.mark_set('insert', '1.7')
-        expand('event')
-        initial_state = self.auto_expand.state
-        text.mark_set('insert', '1.end')
-        expand('event')
-        new_state = self.auto_expand.state
-        self.assertNotEqual(initial_state, new_state)
-
-if __name__ == '__main__':
-    unittest.main(verbosity=2)
diff --git a/contrib/tools/python/src/Lib/idlelib/idle_test/test_calltips.py b/contrib/tools/python/src/Lib/idlelib/idle_test/test_calltips.py
deleted file mode 100644
index 147119ce37..0000000000
--- a/contrib/tools/python/src/Lib/idlelib/idle_test/test_calltips.py
+++ /dev/null
@@ -1,185 +0,0 @@
-import unittest
-import idlelib.CallTips as ct
-CTi = ct.CallTips()  # needed for get_entity test in 2.7
-import textwrap
-import types
-import warnings
-
-default_tip = ''
-
-# Test Class TC is used in multiple get_argspec test methods
-class TC(object):
-    'doc'
-    tip = "(ai=None, *args)"
-    def __init__(self, ai=None, *b): 'doc'
-    __init__.tip = "(self, ai=None, *args)"
-    def t1(self): 'doc'
-    t1.tip = "(self)"
-    def t2(self, ai, b=None): 'doc'
-    t2.tip = "(self, ai, b=None)"
-    def t3(self, ai, *args): 'doc'
-    t3.tip = "(self, ai, *args)"
-    def t4(self, *args): 'doc'
-    t4.tip = "(self, *args)"
-    def t5(self, ai, b=None, *args, **kw): 'doc'
-    t5.tip = "(self, ai, b=None, *args, **kwargs)"
-    def t6(no, self): 'doc'
-    t6.tip = "(no, self)"
-    def __call__(self, ci): 'doc'
-    __call__.tip = "(self, ci)"
-    # attaching .tip to wrapped methods does not work
-    @classmethod
-    def cm(cls, a): 'doc'
-    @staticmethod
-    def sm(b): 'doc'
-
-tc = TC()
-
-signature = ct.get_arg_text  # 2.7 and 3.x use different functions
-class Get_signatureTest(unittest.TestCase):
-    # The signature function must return a string, even if blank.
-    # Test a variety of objects to be sure that none cause it to raise
-    # (quite aside from getting as correct an answer as possible).
-    # The tests of builtins may break if the docstrings change,
-    # but a red buildbot is better than a user crash (as has happened).
-    # For a simple mismatch, change the expected output to the actual.
-
-    def test_builtins(self):
-        # 2.7 puts '()\n' where 3.x does not, other minor differences
-
-        # Python class that inherits builtin methods
-        class List(list): "List() doc"
-        # Simulate builtin with no docstring for default argspec test
-        class SB:  __call__ = None
-
-        def gtest(obj, out):
-            self.assertEqual(signature(obj), out)
-
-        if List.__doc__ is not None:
-            gtest(List, '()\n' + List.__doc__)
-        gtest(list.__new__,
-               'T.__new__(S, ...) -> a new object with type S, a subtype of T')
-        gtest(list.__init__,
-               'x.__init__(...) initializes x; see help(type(x)) for signature')
-        append_doc =  "L.append(object) -- append object to end"
-        gtest(list.append, append_doc)
-        gtest([].append, append_doc)
-        gtest(List.append, append_doc)
-
-        gtest(types.MethodType, '()\ninstancemethod(function, instance, class)')
-        gtest(SB(), default_tip)
-
-    def test_signature_wrap(self):
-        # This is also a test of an old-style class
-        if textwrap.TextWrapper.__doc__ is not None:
-            self.assertEqual(signature(textwrap.TextWrapper), '''\
-(width=70, initial_indent='', subsequent_indent='', expand_tabs=True,
-    replace_whitespace=True, fix_sentence_endings=False, break_long_words=True,
-    drop_whitespace=True, break_on_hyphens=True)''')
-
-    def test_docline_truncation(self):
-        def f(): pass
-        f.__doc__ = 'a'*300
-        self.assertEqual(signature(f), '()\n' + 'a' * (ct._MAX_COLS-3) + '...')
-
-    def test_multiline_docstring(self):
-        # Test fewer lines than max.
-        self.assertEqual(signature(list),
-                "()\nlist() -> new empty list\n"
-                "list(iterable) -> new list initialized from iterable's items")
-
-        # Test max lines and line (currently) too long.
-        def f():
-            pass
-        s = 'a\nb\nc\nd\n'
-        f.__doc__ = s + 300 * 'e' + 'f'
-        self.assertEqual(signature(f),
-                         '()\n' + s + (ct._MAX_COLS - 3) * 'e' + '...')
-
-    def test_functions(self):
-        def t1(): 'doc'
-        t1.tip = "()"
-        def t2(a, b=None): 'doc'
-        t2.tip = "(a, b=None)"
-        def t3(a, *args): 'doc'
-        t3.tip = "(a, *args)"
-        def t4(*args): 'doc'
-        t4.tip = "(*args)"
-        def t5(a, b=None, *args, **kwds): 'doc'
-        t5.tip = "(a, b=None, *args, **kwargs)"
-
-        doc = '\ndoc' if t1.__doc__ is not None else ''
-        for func in (t1, t2, t3, t4, t5, TC):
-            self.assertEqual(signature(func), func.tip + doc)
-
-    def test_methods(self):
-        doc = '\ndoc' if TC.__doc__ is not None else ''
-        for meth in (TC.t1, TC.t2, TC.t3, TC.t4, TC.t5, TC.t6, TC.__call__):
-            self.assertEqual(signature(meth), meth.tip + doc)
-        self.assertEqual(signature(TC.cm), "(a)" + doc)
-        self.assertEqual(signature(TC.sm), "(b)" + doc)
-
-    def test_bound_methods(self):
-        # test that first parameter is correctly removed from argspec
-        doc = '\ndoc' if TC.__doc__ is not None else ''
-        for meth, mtip  in ((tc.t1, "()"), (tc.t4, "(*args)"), (tc.t6, "(self)"),
-                            (tc.__call__, '(ci)'), (tc, '(ci)'), (TC.cm, "(a)"),):
-            self.assertEqual(signature(meth), mtip + doc)
-
-    def test_starred_parameter(self):
-        # test that starred first parameter is *not* removed from argspec
-        class C:
-            def m1(*args): pass
-            def m2(**kwds): pass
-        def f1(args, kwargs, *a, **k): pass
-        def f2(args, kwargs, args1, kwargs1, *a, **k): pass
-        c = C()
-        self.assertEqual(signature(C.m1), '(*args)')
-        self.assertEqual(signature(c.m1), '(*args)')
-        self.assertEqual(signature(C.m2), '(**kwargs)')
-        self.assertEqual(signature(c.m2), '(**kwargs)')
-        self.assertEqual(signature(f1), '(args, kwargs, *args1, **kwargs1)')
-        self.assertEqual(signature(f2),
-                         '(args, kwargs, args1, kwargs1, *args2, **kwargs2)')
-
-    def test_no_docstring(self):
-        def nd(s): pass
-        TC.nd = nd
-        self.assertEqual(signature(nd), "(s)")
-        self.assertEqual(signature(TC.nd), "(s)")
-        self.assertEqual(signature(tc.nd), "()")
-
-    def test_attribute_exception(self):
-        class NoCall(object):
-            def __getattr__(self, name):
-                raise BaseException
-        class Call(NoCall):
-            def __call__(self, ci):
-                pass
-        for meth, mtip  in ((NoCall, '()'), (Call, '()'),
-                            (NoCall(), ''), (Call(), '(ci)')):
-            self.assertEqual(signature(meth), mtip)
-
-    def test_non_callables(self):
-        for obj in (0, 0.0, '0', b'0', [], {}):
-            self.assertEqual(signature(obj), '')
-
-class Get_entityTest(unittest.TestCase):
-    # In 3.x, get_entity changed from 'instance method' to module function
-    # since 'self' not used. Use dummy instance until change 2.7 also.
-    def test_bad_entity(self):
-        self.assertIsNone(CTi.get_entity('1//0'))
-    def test_good_entity(self):
-        self.assertIs(CTi.get_entity('int'), int)
-
-class Py2Test(unittest.TestCase):
-    def test_paramtuple_float(self):
-        # 18539: (a,b) becomes '.0' in code object; change that but not 0.0
-        with warnings.catch_warnings():
-            # Suppess message of py3 deprecation of parameter unpacking
-            warnings.simplefilter("ignore")
-            exec "def f((a,b), c=0.0): pass"
-        self.assertEqual(signature(f), '(<tuple>, c=0.0)')
-
-if __name__ == '__main__':
-    unittest.main(verbosity=2, exit=False)
diff --git a/contrib/tools/python/src/Lib/idlelib/idle_test/test_config_name.py b/contrib/tools/python/src/Lib/idlelib/idle_test/test_config_name.py
deleted file mode 100644
index 2a4df6a744..0000000000
--- a/contrib/tools/python/src/Lib/idlelib/idle_test/test_config_name.py
+++ /dev/null
@@ -1,77 +0,0 @@
-"""Unit tests for idlelib.configSectionNameDialog"""
-import unittest
-from idlelib.idle_test.mock_tk import Var, Mbox
-from idlelib import configSectionNameDialog as name_dialog_module
-
-name_dialog = name_dialog_module.GetCfgSectionNameDialog
-
-class Dummy_name_dialog(object):
-    # Mock for testing the following methods of name_dialog
-    name_ok = name_dialog.name_ok.im_func
-    Ok = name_dialog.Ok.im_func
-    Cancel = name_dialog.Cancel.im_func
-    # Attributes, constant or variable, needed for tests
-    used_names = ['used']
-    name = Var()
-    result = None
-    destroyed = False
-    def grab_release(self):
-        pass
-    def destroy(self):
-        self.destroyed = True
-
-# name_ok calls Mbox.showerror if name is not ok
-orig_mbox = name_dialog_module.tkMessageBox
-showerror = Mbox.showerror
-
-class ConfigNameTest(unittest.TestCase):
-    dialog = Dummy_name_dialog()
-
-    @classmethod
-    def setUpClass(cls):
-        name_dialog_module.tkMessageBox = Mbox
-
-    @classmethod
-    def tearDownClass(cls):
-        name_dialog_module.tkMessageBox = orig_mbox
-
-    def test_blank_name(self):
-        self.dialog.name.set(' ')
-        self.assertEqual(self.dialog.name_ok(), '')
-        self.assertEqual(showerror.title, 'Name Error')
-        self.assertIn('No', showerror.message)
-
-    def test_used_name(self):
-        self.dialog.name.set('used')
-        self.assertEqual(self.dialog.name_ok(), '')
-        self.assertEqual(showerror.title, 'Name Error')
-        self.assertIn('use', showerror.message)
-
-    def test_long_name(self):
-        self.dialog.name.set('good'*8)
-        self.assertEqual(self.dialog.name_ok(), '')
-        self.assertEqual(showerror.title, 'Name Error')
-        self.assertIn('too long', showerror.message)
-
-    def test_good_name(self):
-        self.dialog.name.set('  good ')
-        showerror.title = 'No Error'  # should not be called
-        self.assertEqual(self.dialog.name_ok(), 'good')
-        self.assertEqual(showerror.title, 'No Error')
-
-    def test_ok(self):
-        self.dialog.destroyed = False
-        self.dialog.name.set('good')
-        self.dialog.Ok()
-        self.assertEqual(self.dialog.result, 'good')
-        self.assertTrue(self.dialog.destroyed)
-
-    def test_cancel(self):
-        self.dialog.destroyed = False
-        self.dialog.Cancel()
-        self.assertEqual(self.dialog.result, '')
-        self.assertTrue(self.dialog.destroyed)
-
-
-if __name__ == '__main__':
-    unittest.main(verbosity=2, exit=False)
diff --git a/contrib/tools/python/src/Lib/idlelib/idle_test/test_configdialog.py b/contrib/tools/python/src/Lib/idlelib/idle_test/test_configdialog.py
deleted file mode 100644
index ba651005f0..0000000000
--- a/contrib/tools/python/src/Lib/idlelib/idle_test/test_configdialog.py
+++ /dev/null
@@ -1,33 +0,0 @@
-'''Unittests for idlelib/configHandler.py
-
-Coverage: 46% just by creating dialog. The other half is change code.
-
-'''
-import unittest
-from test.test_support import requires
-from Tkinter import Tk
-from idlelib.configDialog import ConfigDialog
-from idlelib.macosxSupport import _initializeTkVariantTests
-
-
-class ConfigDialogTest(unittest.TestCase):
-
-    @classmethod
-    def setUpClass(cls):
-        requires('gui')
-        cls.root = Tk()
-        cls.root.withdraw()
-        _initializeTkVariantTests(cls.root)
-
-    @classmethod
-    def tearDownClass(cls):
-        cls.root.destroy()
-        del cls.root
-
-    def test_dialog(self):
-        d = ConfigDialog(self.root, 'Test', _utest=True)
-        d.remove_var_callbacks()
-
-
-if __name__ == '__main__':
-    unittest.main(verbosity=2)
diff --git a/contrib/tools/python/src/Lib/idlelib/idle_test/test_delegator.py b/contrib/tools/python/src/Lib/idlelib/idle_test/test_delegator.py
deleted file mode 100644
index b8ae5eeefe..0000000000
--- a/contrib/tools/python/src/Lib/idlelib/idle_test/test_delegator.py
+++ /dev/null
@@ -1,37 +0,0 @@
-import unittest
-from idlelib.Delegator import Delegator
-
-class DelegatorTest(unittest.TestCase):
-
-    def test_mydel(self):
-        # test a simple use scenario
-
-        # initialize
-        mydel = Delegator(int)
-        self.assertIs(mydel.delegate, int)
-        self.assertEqual(mydel._Delegator__cache, set())
-
-        # add an attribute:
-        self.assertRaises(AttributeError, mydel.__getattr__, 'xyz')
-        bl = mydel.bit_length
-        self.assertIs(bl, int.bit_length)
-        self.assertIs(mydel.__dict__['bit_length'], int.bit_length)
-        self.assertEqual(mydel._Delegator__cache, {'bit_length'})
-
-        # add a second attribute
-        mydel.numerator
-        self.assertEqual(mydel._Delegator__cache, {'bit_length', 'numerator'})
-
-        # delete the second (which, however, leaves it in the name cache)
-        del mydel.numerator
-        self.assertNotIn('numerator', mydel.__dict__)
-        self.assertIn('numerator', mydel._Delegator__cache)
-
-        # reset by calling .setdelegate, which calls .resetcache
-        mydel.setdelegate(float)
-        self.assertIs(mydel.delegate, float)
-        self.assertNotIn('bit_length', mydel.__dict__)
-        self.assertEqual(mydel._Delegator__cache, set())
-
-if __name__ == '__main__':
-    unittest.main(verbosity=2, exit=2)
diff --git a/contrib/tools/python/src/Lib/idlelib/idle_test/test_formatparagraph.py b/contrib/tools/python/src/Lib/idlelib/idle_test/test_formatparagraph.py
deleted file mode 100644
index 068ae381c3..0000000000
--- a/contrib/tools/python/src/Lib/idlelib/idle_test/test_formatparagraph.py
+++ /dev/null
@@ -1,376 +0,0 @@
-# Test the functions and main class method of FormatParagraph.py
-import unittest
-from idlelib import FormatParagraph as fp
-from idlelib.EditorWindow import EditorWindow
-from Tkinter import Tk, Text
-from test.test_support import requires
-
-
-class Is_Get_Test(unittest.TestCase):
-    """Test the is_ and get_ functions"""
-    test_comment = '# This is a comment'
-    test_nocomment = 'This is not a comment'
-    trailingws_comment = '# This is a comment   '
-    leadingws_comment = '    # This is a comment'
-    leadingws_nocomment = '    This is not a comment'
-
-    def test_is_all_white(self):
-        self.assertTrue(fp.is_all_white(''))
-        self.assertTrue(fp.is_all_white('\t\n\r\f\v'))
-        self.assertFalse(fp.is_all_white(self.test_comment))
-
-    def test_get_indent(self):
-        Equal = self.assertEqual
-        Equal(fp.get_indent(self.test_comment), '')
-        Equal(fp.get_indent(self.trailingws_comment), '')
-        Equal(fp.get_indent(self.leadingws_comment), '    ')
-        Equal(fp.get_indent(self.leadingws_nocomment), '    ')
-
-    def test_get_comment_header(self):
-        Equal = self.assertEqual
-        # Test comment strings
-        Equal(fp.get_comment_header(self.test_comment), '#')
-        Equal(fp.get_comment_header(self.trailingws_comment), '#')
-        Equal(fp.get_comment_header(self.leadingws_comment), '    #')
-        # Test non-comment strings
-        Equal(fp.get_comment_header(self.leadingws_nocomment), '    ')
-        Equal(fp.get_comment_header(self.test_nocomment), '')
-
-
-class FindTest(unittest.TestCase):
-    """Test the find_paragraph function in FormatParagraph.
-
-    Using the runcase() function, find_paragraph() is called with 'mark' set at
-    multiple indexes before and inside the test paragraph.
-
-    It appears that code with the same indentation as a quoted string is grouped
-    as part of the same paragraph, which is probably incorrect behavior.
-    """
-
-    @classmethod
-    def setUpClass(cls):
-        from idlelib.idle_test.mock_tk import Text
-        cls.text = Text()
-
-    def runcase(self, inserttext, stopline, expected):
-        # Check that find_paragraph returns the expected paragraph when
-        # the mark index is set to beginning, middle, end of each line
-        # up to but not including the stop line
-        text = self.text
-        text.insert('1.0', inserttext)
-        for line in range(1, stopline):
-            linelength = int(text.index("%d.end" % line).split('.')[1])
-            for col in (0, linelength//2, linelength):
-                tempindex = "%d.%d" % (line, col)
-                self.assertEqual(fp.find_paragraph(text, tempindex), expected)
-        text.delete('1.0', 'end')
-
-    def test_find_comment(self):
-        comment = (
-            "# Comment block with no blank lines before\n"
-            "# Comment line\n"
-            "\n")
-        self.runcase(comment, 3, ('1.0', '3.0', '#', comment[0:58]))
-
-        comment = (
-            "\n"
-            "# Comment block with whitespace line before and after\n"
-            "# Comment line\n"
-            "\n")
-        self.runcase(comment, 4, ('2.0', '4.0', '#', comment[1:70]))
-
-        comment = (
-            "\n"
-            "    # Indented comment block with whitespace before and after\n"
-            "    # Comment line\n"
-            "\n")
-        self.runcase(comment, 4, ('2.0', '4.0', '    #', comment[1:82]))
-
-        comment = (
-            "\n"
-            "# Single line comment\n"
-            "\n")
-        self.runcase(comment, 3, ('2.0', '3.0', '#', comment[1:23]))
-
-        comment = (
-            "\n"
-            "    # Single line comment with leading whitespace\n"
-            "\n")
-        self.runcase(comment, 3, ('2.0', '3.0', '    #', comment[1:51]))
-
-        comment = (
-            "\n"
-            "# Comment immediately followed by code\n"
-            "x = 42\n"
-            "\n")
-        self.runcase(comment, 3, ('2.0', '3.0', '#', comment[1:40]))
-
-        comment = (
-            "\n"
-            "    # Indented comment immediately followed by code\n"
-            "x = 42\n"
-            "\n")
-        self.runcase(comment, 3, ('2.0', '3.0', '    #', comment[1:53]))
-
-        comment = (
-            "\n"
-            "# Comment immediately followed by indented code\n"
-            "    x = 42\n"
-            "\n")
-        self.runcase(comment, 3, ('2.0', '3.0', '#', comment[1:49]))
-
-    def test_find_paragraph(self):
-        teststring = (
-            '"""String with no blank lines before\n'
-            'String line\n'
-            '"""\n'
-            '\n')
-        self.runcase(teststring, 4, ('1.0', '4.0', '', teststring[0:53]))
-
-        teststring = (
-            "\n"
-            '"""String with whitespace line before and after\n'
-            'String line.\n'
-            '"""\n'
-            '\n')
-        self.runcase(teststring, 5, ('2.0', '5.0', '', teststring[1:66]))
-
-        teststring = (
-            '\n'
-            '    """Indented string with whitespace before and after\n'
-            '    Comment string.\n'
-            '    """\n'
-            '\n')
-        self.runcase(teststring, 5, ('2.0', '5.0', '    ', teststring[1:85]))
-
-        teststring = (
-            '\n'
-            '"""Single line string."""\n'
-            '\n')
-        self.runcase(teststring, 3, ('2.0', '3.0', '', teststring[1:27]))
-
-        teststring = (
-            '\n'
-            '    """Single line string with leading whitespace."""\n'
-            '\n')
-        self.runcase(teststring, 3, ('2.0', '3.0', '    ', teststring[1:55]))
-
-
-class ReformatFunctionTest(unittest.TestCase):
-    """Test the reformat_paragraph function without the editor window."""
-
-    def test_reformat_paragraph(self):
-        Equal = self.assertEqual
-        reform = fp.reformat_paragraph
-        hw = "O hello world"
-        Equal(reform(' ', 1), ' ')
-        Equal(reform("Hello    world", 20), "Hello  world")
-
-        # Test without leading newline
-        Equal(reform(hw, 1), "O\nhello\nworld")
-        Equal(reform(hw, 6), "O\nhello\nworld")
-        Equal(reform(hw, 7), "O hello\nworld")
-        Equal(reform(hw, 12), "O hello\nworld")
-        Equal(reform(hw, 13), "O hello world")
-
-        # Test with leading newline
-        hw = "\nO hello world"
-        Equal(reform(hw, 1), "\nO\nhello\nworld")
-        Equal(reform(hw, 6), "\nO\nhello\nworld")
-        Equal(reform(hw, 7), "\nO hello\nworld")
-        Equal(reform(hw, 12), "\nO hello\nworld")
-        Equal(reform(hw, 13), "\nO hello world")
-
-
-class ReformatCommentTest(unittest.TestCase):
-    """Test the reformat_comment function without the editor window."""
-
-    def test_reformat_comment(self):
-        Equal = self.assertEqual
-
-        # reformat_comment formats to a minimum of 20 characters
-        test_string = (
-            "    \"\"\"this is a test of a reformat for a triple quoted string"
-            " will it reformat to less than 70 characters for me?\"\"\"")
-        result = fp.reformat_comment(test_string, 70, "    ")
-        expected = (
-            "    \"\"\"this is a test of a reformat for a triple quoted string will it\n"
-            "    reformat to less than 70 characters for me?\"\"\"")
-        Equal(result, expected)
-
-        test_comment = (
-            "# this is a test of a reformat for a triple quoted string will "
-            "it reformat to less than 70 characters for me?")
-        result = fp.reformat_comment(test_comment, 70, "#")
-        expected = (
-            "# this is a test of a reformat for a triple quoted string will it\n"
-            "# reformat to less than 70 characters for me?")
-        Equal(result, expected)
-
-
-class FormatClassTest(unittest.TestCase):
-    def test_init_close(self):
-        instance = fp.FormatParagraph('editor')
-        self.assertEqual(instance.editwin, 'editor')
-        instance.close()
-        self.assertEqual(instance.editwin, None)
-
-
-# For testing format_paragraph_event, Initialize FormatParagraph with
-# a mock Editor with .text and  .get_selection_indices.  The text must
-# be a Text wrapper that adds two methods
-
-# A real EditorWindow creates unneeded, time-consuming baggage and
-# sometimes emits shutdown warnings like this:
-# "warning: callback failed in WindowList <class '_tkinter.TclError'>
-# : invalid command name ".55131368.windows".
-# Calling EditorWindow._close in tearDownClass prevents this but causes
-# other problems (windows left open).
-
-class TextWrapper:
-    def __init__(self, master):
-        self.text = Text(master=master)
-    def __getattr__(self, name):
-        return getattr(self.text, name)
-    def undo_block_start(self): pass
-    def undo_block_stop(self): pass
-
-class Editor:
-    def __init__(self, root):
-        self.text = TextWrapper(root)
-    get_selection_indices = EditorWindow. get_selection_indices.im_func
-
-class FormatEventTest(unittest.TestCase):
-    """Test the formatting of text inside a Text widget.
-
-    This is done with FormatParagraph.format.paragraph_event,
-    which calls functions in the module as appropriate.
-    """
-    test_string = (
-        "    '''this is a test of a reformat for a triple "
-        "quoted string will it reformat to less than 70 "
-        "characters for me?'''\n")
-    multiline_test_string = (
-        "    '''The first line is under the max width.\n"
-        "    The second line's length is way over the max width. It goes "
-        "on and on until it is over 100 characters long.\n"
-        "    Same thing with the third line. It is also way over the max "
-        "width, but FormatParagraph will fix it.\n"
-        "    '''\n")
-    multiline_test_comment = (
-        "# The first line is under the max width.\n"
-        "# The second line's length is way over the max width. It goes on "
-        "and on until it is over 100 characters long.\n"
-        "# Same thing with the third line. It is also way over the max "
-        "width, but FormatParagraph will fix it.\n"
-        "# The fourth line is short like the first line.")
-
-    @classmethod
-    def setUpClass(cls):
-        requires('gui')
-        cls.root = Tk()
-        editor = Editor(root=cls.root)
-        cls.text = editor.text.text  # Test code does not need the wrapper.
-        cls.formatter = fp.FormatParagraph(editor).format_paragraph_event
-        # Sets the insert mark just after the re-wrapped and inserted  text.
-
-    @classmethod
-    def tearDownClass(cls):
-        del cls.text, cls.formatter
-        cls.root.destroy()
-        del cls.root
-
-    def test_short_line(self):
-        self.text.insert('1.0', "Short line\n")
-        self.formatter("Dummy")
-        self.assertEqual(self.text.get('1.0', 'insert'), "Short line\n" )
-        self.text.delete('1.0', 'end')
-
-    def test_long_line(self):
-        text = self.text
-
-        # Set cursor ('insert' mark) to '1.0', within text.
-        text.insert('1.0', self.test_string)
-        text.mark_set('insert', '1.0')
-        self.formatter('ParameterDoesNothing', limit=70)
-        result = text.get('1.0', 'insert')
-        # find function includes \n
-        expected = (
-"    '''this is a test of a reformat for a triple quoted string will it\n"
-"    reformat to less than 70 characters for me?'''\n")  # yes
-        self.assertEqual(result, expected)
-        text.delete('1.0', 'end')
-
-        # Select from 1.11 to line end.
-        text.insert('1.0', self.test_string)
-        text.tag_add('sel', '1.11', '1.end')
-        self.formatter('ParameterDoesNothing', limit=70)
-        result = text.get('1.0', 'insert')
-        # selection excludes \n
-        expected = (
-"    '''this is a test of a reformat for a triple quoted string will it reformat\n"
-" to less than 70 characters for me?'''")  # no
-        self.assertEqual(result, expected)
-        text.delete('1.0', 'end')
-
-    def test_multiple_lines(self):
-        text = self.text
-        #  Select 2 long lines.
-        text.insert('1.0', self.multiline_test_string)
-        text.tag_add('sel', '2.0', '4.0')
-        self.formatter('ParameterDoesNothing', limit=70)
-        result = text.get('2.0', 'insert')
-        expected = (
-"    The second line's length is way over the max width. It goes on and\n"
-"    on until it is over 100 characters long. Same thing with the third\n"
-"    line. It is also way over the max width, but FormatParagraph will\n"
-"    fix it.\n")
-        self.assertEqual(result, expected)
-        text.delete('1.0', 'end')
-
-    def test_comment_block(self):
-        text = self.text
-
-        # Set cursor ('insert') to '1.0', within block.
-        text.insert('1.0', self.multiline_test_comment)
-        self.formatter('ParameterDoesNothing', limit=70)
-        result = text.get('1.0', 'insert')
-        expected = (
-"# The first line is under the max width. The second line's length is\n"
-"# way over the max width. It goes on and on until it is over 100\n"
-"# characters long. Same thing with the third line. It is also way over\n"
-"# the max width, but FormatParagraph will fix it. The fourth line is\n"
-"# short like the first line.\n")
-        self.assertEqual(result, expected)
-        text.delete('1.0', 'end')
-
-        # Select line 2, verify line 1 unaffected.
-        text.insert('1.0', self.multiline_test_comment)
-        text.tag_add('sel', '2.0', '3.0')
-        self.formatter('ParameterDoesNothing', limit=70)
-        result = text.get('1.0', 'insert')
-        expected = (
-"# The first line is under the max width.\n"
-"# The second line's length is way over the max width. It goes on and\n"
-"# on until it is over 100 characters long.\n")
-        self.assertEqual(result, expected)
-        text.delete('1.0', 'end')
-
-# The following block worked with EditorWindow but fails with the mock.
-# Lines 2 and 3 get pasted together even though the previous block left
-# the previous line alone. More investigation is needed.
-##        # Select lines 3 and 4
-##        text.insert('1.0', self.multiline_test_comment)
-##        text.tag_add('sel', '3.0', '5.0')
-##        self.formatter('ParameterDoesNothing')
-##        result = text.get('3.0', 'insert')
-##        expected = (
-##"# Same thing with the third line. It is also way over the max width,\n"
-##"# but FormatParagraph will fix it. The fourth line is short like the\n"
-##"# first line.\n")
-##        self.assertEqual(result, expected)
-##        text.delete('1.0', 'end')
-
-
-if __name__ == '__main__':
-    unittest.main(verbosity=2, exit=2)
diff --git a/contrib/tools/python/src/Lib/idlelib/idle_test/test_grep.py b/contrib/tools/python/src/Lib/idlelib/idle_test/test_grep.py
deleted file mode 100644
index e9f4f22ae6..0000000000
--- a/contrib/tools/python/src/Lib/idlelib/idle_test/test_grep.py
+++ /dev/null
@@ -1,82 +0,0 @@
-""" !Changing this line will break Test_findfile.test_found!
-Non-gui unit tests for idlelib.GrepDialog methods.
-dummy_command calls grep_it calls findfiles.
-An exception raised in one method will fail callers.
-Otherwise, tests are mostly independent.
-*** Currently only test grep_it.
-"""
-import unittest
-from test.test_support import captured_stdout, findfile
-from idlelib.idle_test.mock_tk import Var
-from idlelib.GrepDialog import GrepDialog
-import re
-
-__file__ = findfile('idlelib/idle_test') + '/test_grep.py'
-
-class Dummy_searchengine:
-    '''GrepDialog.__init__ calls parent SearchDiabolBase which attaches the
-    passed in SearchEngine instance as attribute 'engine'. Only a few of the
-    many possible self.engine.x attributes are needed here.
-    '''
-    def getpat(self):
-        return self._pat
-
-searchengine = Dummy_searchengine()
-
-class Dummy_grep:
-    # Methods tested
-    #default_command = GrepDialog.default_command
-    grep_it = GrepDialog.grep_it.im_func
-    findfiles = GrepDialog.findfiles.im_func
-    # Other stuff needed
-    recvar = Var(False)
-    engine = searchengine
-    def close(self):  # gui method
-        pass
-
-grep = Dummy_grep()
-
-class FindfilesTest(unittest.TestCase):
-    # findfiles is really a function, not a method, could be iterator
-    # test that filename return filename
-    # test that idlelib has many .py files
-    # test that recursive flag adds idle_test .py files
-    pass
-
-class Grep_itTest(unittest.TestCase):
-    # Test captured reports with 0 and some hits.
-    # Should test file names, but Windows reports have mixed / and \ separators
-    # from incomplete replacement, so 'later'.
-
-    def report(self, pat):
-        grep.engine._pat = pat
-        with captured_stdout() as s:
-            grep.grep_it(re.compile(pat), __file__)
-        lines = s.getvalue().split('\n')
-        lines.pop()  # remove bogus '' after last \n
-        return lines
-
-    def test_unfound(self):
-        pat = 'xyz*'*7
-        lines = self.report(pat)
-        self.assertEqual(len(lines), 2)
-        self.assertIn(pat, lines[0])
-        self.assertEqual(lines[1], 'No hits.')
-
-    def test_found(self):
-
-        pat = '""" !Changing this line will break Test_findfile.test_found!'
-        lines = self.report(pat)
-        self.assertEqual(len(lines), 5)
-        self.assertIn(pat, lines[0])
-        self.assertIn('py: 1:', lines[1])  # line number 1
-        self.assertIn('2', lines[3])  # hits found 2
-        self.assertTrue(lines[4].startswith('(Hint:'))
-
-class Default_commandTest(unittest.TestCase):
-    # To write this, mode OutputWindow import to top of GrepDialog
-    # so it can be replaced by captured_stdout in class setup/teardown.
-    pass
-
-if __name__ == '__main__':
-    unittest.main(verbosity=2, exit=False)
diff --git a/contrib/tools/python/src/Lib/idlelib/idle_test/test_hyperparser.py b/contrib/tools/python/src/Lib/idlelib/idle_test/test_hyperparser.py
deleted file mode 100644
index 0a1809d2f7..0000000000
--- a/contrib/tools/python/src/Lib/idlelib/idle_test/test_hyperparser.py
+++ /dev/null
@@ -1,192 +0,0 @@
-"""Unittest for idlelib.HyperParser"""
-import unittest
-from test.test_support import requires
-from Tkinter import Tk, Text
-from idlelib.EditorWindow import EditorWindow
-from idlelib.HyperParser import HyperParser
-
-class DummyEditwin:
-    def __init__(self, text):
-        self.text = text
-        self.indentwidth = 8
-        self.tabwidth = 8
-        self.context_use_ps1 = True
-        self.num_context_lines = 50, 500, 1000
-
-    _build_char_in_string_func = EditorWindow._build_char_in_string_func.im_func
-    is_char_in_string = EditorWindow.is_char_in_string.im_func
-
-
-class HyperParserTest(unittest.TestCase):
-    code = (
-            '"""This is a module docstring"""\n'
-            '# this line is a comment\n'
-            'x = "this is a string"\n'
-            "y = 'this is also a string'\n"
-            'l = [i for i in range(10)]\n'
-            'm = [py*py for # comment\n'
-            '       py in l]\n'
-            'x.__len__\n'
-            "z = ((r'asdf')+('a')))\n"
-            '[x for x in\n'
-            'for = False\n'
-            )
-
-    @classmethod
-    def setUpClass(cls):
-        requires('gui')
-        cls.root = Tk()
-        cls.root.withdraw()
-        cls.text = Text(cls.root)
-        cls.editwin = DummyEditwin(cls.text)
-
-    @classmethod
-    def tearDownClass(cls):
-        del cls.text, cls.editwin
-        cls.root.destroy()
-        del cls.root
-
-    def setUp(self):
-        self.text.insert('insert', self.code)
-
-    def tearDown(self):
-        self.text.delete('1.0', 'end')
-        self.editwin.context_use_ps1 = True
-
-    def get_parser(self, index):
-        """
-        Return a parser object with index at 'index'
-        """
-        return HyperParser(self.editwin, index)
-
-    def test_init(self):
-        """
-        test corner cases in the init method
-        """
-        with self.assertRaises(ValueError) as ve:
-            self.text.tag_add('console', '1.0', '1.end')
-            p = self.get_parser('1.5')
-        self.assertIn('precedes', str(ve.exception))
-
-        # test without ps1
-        self.editwin.context_use_ps1 = False
-
-        # number of lines lesser than 50
-        p = self.get_parser('end')
-        self.assertEqual(p.rawtext, self.text.get('1.0', 'end'))
-
-        # number of lines greater than 50
-        self.text.insert('end', self.text.get('1.0', 'end')*4)
-        p = self.get_parser('54.5')
-
-    def test_is_in_string(self):
-        get = self.get_parser
-
-        p = get('1.0')
-        self.assertFalse(p.is_in_string())
-        p = get('1.4')
-        self.assertTrue(p.is_in_string())
-        p = get('2.3')
-        self.assertFalse(p.is_in_string())
-        p = get('3.3')
-        self.assertFalse(p.is_in_string())
-        p = get('3.7')
-        self.assertTrue(p.is_in_string())
-        p = get('4.6')
-        self.assertTrue(p.is_in_string())
-
-    def test_is_in_code(self):
-        get = self.get_parser
-
-        p = get('1.0')
-        self.assertTrue(p.is_in_code())
-        p = get('1.1')
-        self.assertFalse(p.is_in_code())
-        p = get('2.5')
-        self.assertFalse(p.is_in_code())
-        p = get('3.4')
-        self.assertTrue(p.is_in_code())
-        p = get('3.6')
-        self.assertFalse(p.is_in_code())
-        p = get('4.14')
-        self.assertFalse(p.is_in_code())
-
-    def test_get_surrounding_bracket(self):
-        get = self.get_parser
-
-        def without_mustclose(parser):
-            # a utility function to get surrounding bracket
-            # with mustclose=False
-            return parser.get_surrounding_brackets(mustclose=False)
-
-        def with_mustclose(parser):
-            # a utility function to get surrounding bracket
-            # with mustclose=True
-            return parser.get_surrounding_brackets(mustclose=True)
-
-        p = get('3.2')
-        self.assertIsNone(with_mustclose(p))
-        self.assertIsNone(without_mustclose(p))
-
-        p = get('5.6')
-        self.assertTupleEqual(without_mustclose(p), ('5.4', '5.25'))
-        self.assertTupleEqual(without_mustclose(p), with_mustclose(p))
-
-        p = get('5.23')
-        self.assertTupleEqual(without_mustclose(p), ('5.21', '5.24'))
-        self.assertTupleEqual(without_mustclose(p), with_mustclose(p))
-
-        p = get('6.15')
-        self.assertTupleEqual(without_mustclose(p), ('6.4', '6.end'))
-        self.assertIsNone(with_mustclose(p))
-
-        p = get('9.end')
-        self.assertIsNone(with_mustclose(p))
-        self.assertIsNone(without_mustclose(p))
-
-    def test_get_expression(self):
-        get = self.get_parser
-
-        p = get('4.2')
-        self.assertEqual(p.get_expression(), 'y ')
-
-        p = get('4.7')
-        with self.assertRaises(ValueError) as ve:
-            p.get_expression()
-        self.assertIn('is inside a code', str(ve.exception))
-
-        p = get('5.25')
-        self.assertEqual(p.get_expression(), 'range(10)')
-
-        p = get('6.7')
-        self.assertEqual(p.get_expression(), 'py')
-
-        p = get('6.8')
-        self.assertEqual(p.get_expression(), '')
-
-        p = get('7.9')
-        self.assertEqual(p.get_expression(), 'py')
-
-        p = get('8.end')
-        self.assertEqual(p.get_expression(), 'x.__len__')
-
-        p = get('9.13')
-        self.assertEqual(p.get_expression(), "r'asdf'")
-
-        p = get('9.17')
-        with self.assertRaises(ValueError) as ve:
-            p.get_expression()
-        self.assertIn('is inside a code', str(ve.exception))
-
-        p = get('10.0')
-        self.assertEqual(p.get_expression(), '')
-
-        p = get('11.3')
-        self.assertEqual(p.get_expression(), '')
-
-        p = get('11.11')
-        self.assertEqual(p.get_expression(), 'False')
-
-
-if __name__ == '__main__':
-    unittest.main(verbosity=2)
diff --git a/contrib/tools/python/src/Lib/idlelib/idle_test/test_idlehistory.py b/contrib/tools/python/src/Lib/idlelib/idle_test/test_idlehistory.py
deleted file mode 100644
index b0767570fc..0000000000
--- a/contrib/tools/python/src/Lib/idlelib/idle_test/test_idlehistory.py
+++ /dev/null
@@ -1,168 +0,0 @@
-import unittest
-from test.test_support import requires
-
-import Tkinter as tk
-from Tkinter import Text as tkText
-from idlelib.idle_test.mock_tk import Text as mkText
-from idlelib.IdleHistory import History
-from idlelib.configHandler import idleConf
-
-line1 = 'a = 7'
-line2 = 'b = a'
-
-class StoreTest(unittest.TestCase):
-    '''Tests History.__init__ and History.store with mock Text'''
-
-    @classmethod
-    def setUpClass(cls):
-        cls.text = mkText()
-        cls.history = History(cls.text)
-
-    def tearDown(self):
-        self.text.delete('1.0', 'end')
-        self.history.history = []
-
-    def test_init(self):
-        self.assertIs(self.history.text, self.text)
-        self.assertEqual(self.history.history, [])
-        self.assertIsNone(self.history.prefix)
-        self.assertIsNone(self.history.pointer)
-        self.assertEqual(self.history.cyclic,
-                idleConf.GetOption("main", "History",  "cyclic", 1, "bool"))
-
-    def test_store_short(self):
-        self.history.store('a')
-        self.assertEqual(self.history.history, [])
-        self.history.store('  a  ')
-        self.assertEqual(self.history.history, [])
-
-    def test_store_dup(self):
-        self.history.store(line1)
-        self.assertEqual(self.history.history, [line1])
-        self.history.store(line2)
-        self.assertEqual(self.history.history, [line1, line2])
-        self.history.store(line1)
-        self.assertEqual(self.history.history, [line2, line1])
-
-    def test_store_reset(self):
-        self.history.prefix = line1
-        self.history.pointer = 0
-        self.history.store(line2)
-        self.assertIsNone(self.history.prefix)
-        self.assertIsNone(self.history.pointer)
-
-
-class TextWrapper:
-    def __init__(self, master):
-        self.text = tkText(master=master)
-        self._bell = False
-    def __getattr__(self, name):
-        return getattr(self.text, name)
-    def bell(self):
-        self._bell = True
-
-class FetchTest(unittest.TestCase):
-    '''Test History.fetch with wrapped tk.Text.
-    '''
-    @classmethod
-    def setUpClass(cls):
-        requires('gui')
-        cls.root = tk.Tk()
-        cls.root.withdraw()
-
-    def setUp(self):
-        self.text = text = TextWrapper(self.root)
-        text.insert('1.0', ">>> ")
-        text.mark_set('iomark', '1.4')
-        text.mark_gravity('iomark', 'left')
-        self.history = History(text)
-        self.history.history = [line1, line2]
-
-    @classmethod
-    def tearDownClass(cls):
-        cls.root.destroy()
-        del cls.root
-
-    def fetch_test(self, reverse, line, prefix, index, bell=False):
-        # Perform one fetch as invoked by Alt-N or Alt-P
-        # Test the result. The line test is the most important.
-        # The last two are diagnostic of fetch internals.
-        History = self.history
-        History.fetch(reverse)
-
-        Equal = self.assertEqual
-        Equal(self.text.get('iomark', 'end-1c'), line)
-        Equal(self.text._bell, bell)
-        if bell:
-            self.text._bell = False
-        Equal(History.prefix, prefix)
-        Equal(History.pointer, index)
-        Equal(self.text.compare("insert", '==', "end-1c"), 1)
-
-    def test_fetch_prev_cyclic(self):
-        prefix = ''
-        test = self.fetch_test
-        test(True, line2, prefix, 1)
-        test(True, line1, prefix, 0)
-        test(True, prefix, None, None, bell=True)
-
-    def test_fetch_next_cyclic(self):
-        prefix = ''
-        test  = self.fetch_test
-        test(False, line1, prefix, 0)
-        test(False, line2, prefix, 1)
-        test(False, prefix, None, None, bell=True)
-
-    # Prefix 'a' tests skip line2, which starts with 'b'
-    def test_fetch_prev_prefix(self):
-        prefix = 'a'
-        self.text.insert('iomark', prefix)
-        self.fetch_test(True, line1, prefix, 0)
-        self.fetch_test(True, prefix, None, None, bell=True)
-
-    def test_fetch_next_prefix(self):
-        prefix = 'a'
-        self.text.insert('iomark', prefix)
-        self.fetch_test(False, line1, prefix, 0)
-        self.fetch_test(False, prefix, None, None, bell=True)
-
-    def test_fetch_prev_noncyclic(self):
-        prefix = ''
-        self.history.cyclic = False
-        test = self.fetch_test
-        test(True, line2, prefix, 1)
-        test(True, line1, prefix, 0)
-        test(True, line1, prefix, 0, bell=True)
-
-    def test_fetch_next_noncyclic(self):
-        prefix = ''
-        self.history.cyclic = False
-        test  = self.fetch_test
-        test(False, prefix, None, None, bell=True)
-        test(True, line2, prefix, 1)
-        test(False, prefix, None, None, bell=True)
-        test(False, prefix, None, None, bell=True)
-
-    def test_fetch_cursor_move(self):
-        # Move cursor after fetch
-        self.history.fetch(reverse=True)  # initialization
-        self.text.mark_set('insert', 'iomark')
-        self.fetch_test(True, line2, None, None, bell=True)
-
-    def test_fetch_edit(self):
-        # Edit after fetch
-        self.history.fetch(reverse=True)  # initialization
-        self.text.delete('iomark', 'insert', )
-        self.text.insert('iomark', 'a =')
-        self.fetch_test(True, line1, 'a =', 0)  # prefix is reset
-
-    def test_history_prev_next(self):
-        # Minimally test functions bound to events
-        self.history.history_prev('dummy event')
-        self.assertEqual(self.history.pointer, 1)
-        self.history.history_next('dummy event')
-        self.assertEqual(self.history.pointer, None)
-
-
-if __name__ == '__main__':
-    unittest.main(verbosity=2, exit=2)
diff --git a/contrib/tools/python/src/Lib/idlelib/idle_test/test_io.py b/contrib/tools/python/src/Lib/idlelib/idle_test/test_io.py
deleted file mode 100644
index ee017bb8c6..0000000000
--- a/contrib/tools/python/src/Lib/idlelib/idle_test/test_io.py
+++ /dev/null
@@ -1,267 +0,0 @@
-import unittest
-import io
-from idlelib.PyShell import PseudoInputFile, PseudoOutputFile
-from test import test_support as support
-
-
-class Base(object):
-    def __str__(self):
-        return '%s:str' % type(self).__name__
-    def __unicode__(self):
-        return '%s:unicode' % type(self).__name__
-    def __len__(self):
-        return 3
-    def __iter__(self):
-        return iter('abc')
-    def __getitem__(self, *args):
-        return '%s:item' % type(self).__name__
-    def __getslice__(self, *args):
-        return '%s:slice' % type(self).__name__
-
-class S(Base, str):
-    pass
-
-class U(Base, unicode):
-    pass
-
-class BA(Base, bytearray):
-    pass
-
-class MockShell:
-    def __init__(self):
-        self.reset()
-
-    def write(self, *args):
-        self.written.append(args)
-
-    def readline(self):
-        return self.lines.pop()
-
-    def close(self):
-        pass
-
-    def reset(self):
-        self.written = []
-
-    def push(self, lines):
-        self.lines = list(lines)[::-1]
-
-
-class PseudeOutputFilesTest(unittest.TestCase):
-    def test_misc(self):
-        shell = MockShell()
-        f = PseudoOutputFile(shell, 'stdout', 'utf-8')
-        self.assertIsInstance(f, io.TextIOBase)
-        self.assertEqual(f.encoding, 'utf-8')
-        self.assertIsNone(f.errors)
-        self.assertIsNone(f.newlines)
-        self.assertEqual(f.name, '<stdout>')
-        self.assertFalse(f.closed)
-        self.assertTrue(f.isatty())
-        self.assertFalse(f.readable())
-        self.assertTrue(f.writable())
-        self.assertFalse(f.seekable())
-
-    def test_unsupported(self):
-        shell = MockShell()
-        f = PseudoOutputFile(shell, 'stdout', 'utf-8')
-        self.assertRaises(IOError, f.fileno)
-        self.assertRaises(IOError, f.tell)
-        self.assertRaises(IOError, f.seek, 0)
-        self.assertRaises(IOError, f.read, 0)
-        self.assertRaises(IOError, f.readline, 0)
-
-    def test_write(self):
-        shell = MockShell()
-        f = PseudoOutputFile(shell, 'stdout', 'utf-8')
-        f.write('test')
-        self.assertEqual(shell.written, [('test', 'stdout')])
-        shell.reset()
-        f.write('t\xe8st')
-        self.assertEqual(shell.written, [('t\xe8st', 'stdout')])
-        shell.reset()
-        f.write(u't\xe8st')
-        self.assertEqual(shell.written, [(u't\xe8st', 'stdout')])
-        shell.reset()
-
-        f.write(S('t\xe8st'))
-        self.assertEqual(shell.written, [('t\xe8st', 'stdout')])
-        self.assertEqual(type(shell.written[0][0]), str)
-        shell.reset()
-        f.write(BA('t\xe8st'))
-        self.assertEqual(shell.written, [('t\xe8st', 'stdout')])
-        self.assertEqual(type(shell.written[0][0]), str)
-        shell.reset()
-        f.write(U(u't\xe8st'))
-        self.assertEqual(shell.written, [(u't\xe8st', 'stdout')])
-        self.assertEqual(type(shell.written[0][0]), unicode)
-        shell.reset()
-
-        self.assertRaises(TypeError, f.write)
-        self.assertEqual(shell.written, [])
-        self.assertRaises(TypeError, f.write, 123)
-        self.assertEqual(shell.written, [])
-        self.assertRaises(TypeError, f.write, 'test', 'spam')
-        self.assertEqual(shell.written, [])
-
-    def test_writelines(self):
-        shell = MockShell()
-        f = PseudoOutputFile(shell, 'stdout', 'utf-8')
-        f.writelines([])
-        self.assertEqual(shell.written, [])
-        shell.reset()
-        f.writelines(['one\n', 'two'])
-        self.assertEqual(shell.written,
-                         [('one\n', 'stdout'), ('two', 'stdout')])
-        shell.reset()
-        f.writelines(['on\xe8\n', 'tw\xf2'])
-        self.assertEqual(shell.written,
-                         [('on\xe8\n', 'stdout'), ('tw\xf2', 'stdout')])
-        shell.reset()
-        f.writelines([u'on\xe8\n', u'tw\xf2'])
-        self.assertEqual(shell.written,
-                         [(u'on\xe8\n', 'stdout'), (u'tw\xf2', 'stdout')])
-        shell.reset()
-
-        f.writelines([S('t\xe8st')])
-        self.assertEqual(shell.written, [('t\xe8st', 'stdout')])
-        self.assertEqual(type(shell.written[0][0]), str)
-        shell.reset()
-        f.writelines([BA('t\xe8st')])
-        self.assertEqual(shell.written, [('t\xe8st', 'stdout')])
-        self.assertEqual(type(shell.written[0][0]), str)
-        shell.reset()
-        f.writelines([U(u't\xe8st')])
-        self.assertEqual(shell.written, [(u't\xe8st', 'stdout')])
-        self.assertEqual(type(shell.written[0][0]), unicode)
-        shell.reset()
-
-        self.assertRaises(TypeError, f.writelines)
-        self.assertEqual(shell.written, [])
-        self.assertRaises(TypeError, f.writelines, 123)
-        self.assertEqual(shell.written, [])
-        self.assertRaises(TypeError, f.writelines, [123])
-        self.assertEqual(shell.written, [])
-        self.assertRaises(TypeError, f.writelines, [], [])
-        self.assertEqual(shell.written, [])
-
-    def test_close(self):
-        shell = MockShell()
-        f = PseudoOutputFile(shell, 'stdout', 'utf-8')
-        self.assertFalse(f.closed)
-        f.write('test')
-        f.close()
-        self.assertTrue(f.closed)
-        self.assertRaises(ValueError, f.write, 'x')
-        self.assertEqual(shell.written, [('test', 'stdout')])
-        f.close()
-        self.assertRaises(TypeError, f.close, 1)
-
-
-class PseudeInputFilesTest(unittest.TestCase):
-    def test_misc(self):
-        shell = MockShell()
-        f = PseudoInputFile(shell, 'stdin', 'utf-8')
-        self.assertIsInstance(f, io.TextIOBase)
-        self.assertEqual(f.encoding, 'utf-8')
-        self.assertIsNone(f.errors)
-        self.assertIsNone(f.newlines)
-        self.assertEqual(f.name, '<stdin>')
-        self.assertFalse(f.closed)
-        self.assertTrue(f.isatty())
-        self.assertTrue(f.readable())
-        self.assertFalse(f.writable())
-        self.assertFalse(f.seekable())
-
-    def test_unsupported(self):
-        shell = MockShell()
-        f = PseudoInputFile(shell, 'stdin', 'utf-8')
-        self.assertRaises(IOError, f.fileno)
-        self.assertRaises(IOError, f.tell)
-        self.assertRaises(IOError, f.seek, 0)
-        self.assertRaises(IOError, f.write, 'x')
-        self.assertRaises(IOError, f.writelines, ['x'])
-
-    def test_read(self):
-        shell = MockShell()
-        f = PseudoInputFile(shell, 'stdin', 'utf-8')
-        shell.push(['one\n', 'two\n', ''])
-        self.assertEqual(f.read(), 'one\ntwo\n')
-        shell.push(['one\n', 'two\n', ''])
-        self.assertEqual(f.read(-1), 'one\ntwo\n')
-        shell.push(['one\n', 'two\n', ''])
-        self.assertEqual(f.read(None), 'one\ntwo\n')
-        shell.push(['one\n', 'two\n', 'three\n', ''])
-        self.assertEqual(f.read(2), 'on')
-        self.assertEqual(f.read(3), 'e\nt')
-        self.assertEqual(f.read(10), 'wo\nthree\n')
-
-        shell.push(['one\n', 'two\n'])
-        self.assertEqual(f.read(0), '')
-        self.assertRaises(TypeError, f.read, 1.5)
-        self.assertRaises(TypeError, f.read, '1')
-        self.assertRaises(TypeError, f.read, 1, 1)
-
-    def test_readline(self):
-        shell = MockShell()
-        f = PseudoInputFile(shell, 'stdin', 'utf-8')
-        shell.push(['one\n', 'two\n', 'three\n', 'four\n'])
-        self.assertEqual(f.readline(), 'one\n')
-        self.assertEqual(f.readline(-1), 'two\n')
-        self.assertEqual(f.readline(None), 'three\n')
-        shell.push(['one\ntwo\n'])
-        self.assertEqual(f.readline(), 'one\n')
-        self.assertEqual(f.readline(), 'two\n')
-        shell.push(['one', 'two', 'three'])
-        self.assertEqual(f.readline(), 'one')
-        self.assertEqual(f.readline(), 'two')
-        shell.push(['one\n', 'two\n', 'three\n'])
-        self.assertEqual(f.readline(2), 'on')
-        self.assertEqual(f.readline(1), 'e')
-        self.assertEqual(f.readline(1), '\n')
-        self.assertEqual(f.readline(10), 'two\n')
-
-        shell.push(['one\n', 'two\n'])
-        self.assertEqual(f.readline(0), '')
-        self.assertRaises(TypeError, f.readlines, 1.5)
-        self.assertRaises(TypeError, f.readlines, '1')
-        self.assertRaises(TypeError, f.readlines, 1, 1)
-
-    def test_readlines(self):
-        shell = MockShell()
-        f = PseudoInputFile(shell, 'stdin', 'utf-8')
-        shell.push(['one\n', 'two\n', ''])
-        self.assertEqual(f.readlines(), ['one\n', 'two\n'])
-        shell.push(['one\n', 'two\n', ''])
-        self.assertEqual(f.readlines(-1), ['one\n', 'two\n'])
-        shell.push(['one\n', 'two\n', ''])
-        self.assertEqual(f.readlines(None), ['one\n', 'two\n'])
-        shell.push(['one\n', 'two\n', ''])
-        self.assertEqual(f.readlines(0), ['one\n', 'two\n'])
-        shell.push(['one\n', 'two\n', ''])
-        self.assertEqual(f.readlines(3), ['one\n'])
-        shell.push(['one\n', 'two\n', ''])
-        self.assertEqual(f.readlines(4), ['one\n', 'two\n'])
-
-        shell.push(['one\n', 'two\n', ''])
-        self.assertRaises(TypeError, f.readlines, 1.5)
-        self.assertRaises(TypeError, f.readlines, '1')
-        self.assertRaises(TypeError, f.readlines, 1, 1)
-
-    def test_close(self):
-        shell = MockShell()
-        f = PseudoInputFile(shell, 'stdin', 'utf-8')
-        shell.push(['one\n', 'two\n', ''])
-        self.assertFalse(f.closed)
-        self.assertEqual(f.readline(), 'one\n')
-        f.close()
-        self.assertFalse(f.closed)
-        self.assertEqual(f.readline(), 'two\n')
-        self.assertRaises(TypeError, f.close, 1)
-
-
-def test_main():
-    support.run_unittest(PseudeOutputFilesTest, PseudeInputFilesTest)
-
-if __name__ == '__main__':
-    test_main()
diff --git a/contrib/tools/python/src/Lib/idlelib/idle_test/test_parenmatch.py b/contrib/tools/python/src/Lib/idlelib/idle_test/test_parenmatch.py
deleted file mode 100644
index 1621981540..0000000000
--- a/contrib/tools/python/src/Lib/idlelib/idle_test/test_parenmatch.py
+++ /dev/null
@@ -1,121 +0,0 @@
-"""Test idlelib.ParenMatch."""
-# This must currently be a gui test because ParenMatch methods use
-# several text methods not defined on idlelib.idle_test.mock_tk.Text.
-
-import unittest
-from test.test_support import requires
-from Tkinter import Tk, Text
-from idlelib.ParenMatch import ParenMatch
-
-class Mock:  # 2.7 does not have unittest.mock
-    def __init__(self, *args, **kwargs):
-        self.called = False
-
-    def __call__(self, *args, **kwargs):
-        self.called = True
-
-    def reset_mock(self, *args, **kwargs):
-        self.called = False
-
-    def after(self, *args, **kwargs):
-        pass
-
-class DummyEditwin:
-    def __init__(self, text):
-        self.text = text
-        self.indentwidth = 8
-        self.tabwidth = 8
-        self.context_use_ps1 = True
-
-
-class ParenMatchTest(unittest.TestCase):
-
-    @classmethod
-    def setUpClass(cls):
-        requires('gui')
-        cls.root = Tk()
-        cls.text = Text(cls.root)
-        cls.editwin = DummyEditwin(cls.text)
-        cls.editwin.text_frame = Mock()
-
-    @classmethod
-    def tearDownClass(cls):
-        del cls.text, cls.editwin
-        cls.root.destroy()
-        del cls.root
-
-    def tearDown(self):
-        self.text.delete('1.0', 'end')
-
-    def test_paren_expression(self):
-        """
-        Test ParenMatch with 'expression' style.
-        """
-        text = self.text
-        pm = ParenMatch(self.editwin)
-        pm.set_style('expression')
-
-        text.insert('insert', 'def foobar(a, b')
-        pm.flash_paren_event('event')
-        self.assertIn('<<parenmatch-check-restore>>', text.event_info())
-        self.assertTupleEqual(text.tag_prevrange('paren', 'end'),
-                             ('1.10', '1.15'))
-        text.insert('insert', ')')
-        pm.restore_event()
-        self.assertNotIn('<<parenmatch-check-restore>>', text.event_info())
-        self.assertEqual(text.tag_prevrange('paren', 'end'), ())
-
-        # paren_closed_event can only be tested as below
-        pm.paren_closed_event('event')
-        self.assertTupleEqual(text.tag_prevrange('paren', 'end'),
-                                                ('1.10', '1.16'))
-
-    def test_paren_default(self):
-        """
-        Test ParenMatch with 'default' style.
-        """
-        text = self.text
-        pm = ParenMatch(self.editwin)
-        pm.set_style('default')
-
-        text.insert('insert', 'def foobar(a, b')
-        pm.flash_paren_event('event')
-        self.assertIn('<<parenmatch-check-restore>>', text.event_info())
-        self.assertTupleEqual(text.tag_prevrange('paren', 'end'),
-                             ('1.10', '1.11'))
-        text.insert('insert', ')')
-        pm.restore_event()
-        self.assertNotIn('<<parenmatch-check-restore>>', text.event_info())
-        self.assertEqual(text.tag_prevrange('paren', 'end'), ())
-
-    def test_paren_corner(self):
-        """
-        Test corner cases in flash_paren_event and paren_closed_event.
-
-        These cases force conditional expression and alternate paths.
-        """
-        text = self.text
-        pm = ParenMatch(self.editwin)
-
-        text.insert('insert', '# this is a commen)')
-        self.assertIsNone(pm.paren_closed_event('event'))
-
-        text.insert('insert', '\ndef')
-        self.assertIsNone(pm.flash_paren_event('event'))
-        self.assertIsNone(pm.paren_closed_event('event'))
-
-        text.insert('insert', ' a, *arg)')
-        self.assertIsNone(pm.paren_closed_event('event'))
-
-    def test_handle_restore_timer(self):
-        pm = ParenMatch(self.editwin)
-        pm.restore_event = Mock()
-        pm.handle_restore_timer(0)
-        self.assertTrue(pm.restore_event.called)
-        pm.restore_event.reset_mock()
-        pm.handle_restore_timer(1)
-        self.assertFalse(pm.restore_event.called)
-
-
-if __name__ == '__main__':
-    unittest.main(verbosity=2)
diff --git a/contrib/tools/python/src/Lib/idlelib/idle_test/test_pathbrowser.py b/contrib/tools/python/src/Lib/idlelib/idle_test/test_pathbrowser.py
deleted file mode 100644
index f02841481b..0000000000
--- a/contrib/tools/python/src/Lib/idlelib/idle_test/test_pathbrowser.py
+++ /dev/null
@@ -1,28 +0,0 @@
-import unittest
-import os
-import sys
-import idlelib
-from idlelib import PathBrowser
-
-class PathBrowserTest(unittest.TestCase):
-
-    def test_DirBrowserTreeItem(self):
-        # Issue16226 - make sure that getting a sublist works
-        d = PathBrowser.DirBrowserTreeItem('')
-        d.GetSubList()
-        self.assertEqual('', d.GetText())
-
-        dir = os.path.split(os.path.abspath(idlelib.__file__))[0]
-        self.assertEqual(d.ispackagedir(dir), True)
-        self.assertEqual(d.ispackagedir(dir + '/Icons'), False)
-
-    def test_PathBrowserTreeItem(self):
-        p = PathBrowser.PathBrowserTreeItem()
-        self.assertEqual(p.GetText(), 'sys.path')
-        sub = p.GetSubList()
-        self.assertEqual(len(sub), len(sys.path))
-        # Following fails in 2.7 because old-style class
-        #self.assertEqual(type(sub[0]), PathBrowser.DirBrowserTreeItem)
-
-if __name__ == '__main__':
-    unittest.main(verbosity=2, exit=False)
diff --git a/contrib/tools/python/src/Lib/idlelib/idle_test/test_rstrip.py b/contrib/tools/python/src/Lib/idlelib/idle_test/test_rstrip.py
deleted file mode 100644
index 1c90b93d21..0000000000
--- a/contrib/tools/python/src/Lib/idlelib/idle_test/test_rstrip.py
+++ /dev/null
@@ -1,49 +0,0 @@
-import unittest
-import idlelib.RstripExtension as rs
-from idlelib.idle_test.mock_idle import Editor
-
-class rstripTest(unittest.TestCase):
-
-    def test_rstrip_line(self):
-        editor = Editor()
-        text = editor.text
-        do_rstrip = rs.RstripExtension(editor).do_rstrip
-
-        do_rstrip()
-        self.assertEqual(text.get('1.0', 'insert'), '')
-        text.insert('1.0', '     ')
-        do_rstrip()
-        self.assertEqual(text.get('1.0', 'insert'), '')
-        text.insert('1.0', '     \n')
-        do_rstrip()
-        self.assertEqual(text.get('1.0', 'insert'), '\n')
-
-    def test_rstrip_multiple(self):
-        editor = Editor()
-        #  Uncomment following to verify that test passes with real widgets.
-##        from idlelib.EditorWindow import EditorWindow as Editor
-##        from tkinter import Tk
-##        editor = Editor(root=Tk())
-        text = editor.text
-        do_rstrip = rs.RstripExtension(editor).do_rstrip
-
-        original = (
-            "Line with an ending tab    \n"
-            "Line ending in 5 spaces     \n"
-            "Linewithnospaces\n"
-            "    indented line\n"
-            "    indented line with trailing space \n"
-            "    ")
-        stripped = (
-            "Line with an ending tab\n"
-            "Line ending in 5 spaces\n"
-            "Linewithnospaces\n"
-            "    indented line\n"
-            "    indented line with trailing space\n")
-
-        text.insert('1.0', original)
-        do_rstrip()
-        self.assertEqual(text.get('1.0', 'insert'), stripped)
-
-if __name__ == '__main__':
-    unittest.main(verbosity=2, exit=False)
diff --git a/contrib/tools/python/src/Lib/idlelib/idle_test/test_searchdialogbase.py b/contrib/tools/python/src/Lib/idlelib/idle_test/test_searchdialogbase.py
deleted file mode 100644
index 32abfe6f79..0000000000
--- a/contrib/tools/python/src/Lib/idlelib/idle_test/test_searchdialogbase.py
+++ /dev/null
@@ -1,164 +0,0 @@
-'''Unittests for idlelib/SearchDialogBase.py
-
-Coverage: 99%. The only thing not covered is inconsequential --
-testing skipping of suite when self.needwrapbutton is false.
-
-'''
-import unittest
-from test.test_support import requires
-from Tkinter import Tk, Toplevel, Frame ## BooleanVar, StringVar
-from idlelib import SearchEngine as se
-from idlelib import SearchDialogBase as sdb
-from idlelib.idle_test.mock_idle import Func
-##from idlelib.idle_test.mock_tk import Var
-
-# The ## imports above & following could help make some tests gui-free.# However, they currently make radiobutton tests fail.
-##def setUpModule():
-##    # Replace tk objects used to initialize se.SearchEngine.
-##    se.BooleanVar = Var
-##    se.StringVar = Var
-##
-##def tearDownModule():
-##    se.BooleanVar = BooleanVar
-##    se.StringVar = StringVar
-
-class SearchDialogBaseTest(unittest.TestCase):
-
-    @classmethod
-    def setUpClass(cls):
-        requires('gui')
-        cls.root = Tk()
-
-    @classmethod
-    def tearDownClass(cls):
-        cls.root.destroy()
-        del cls.root
-
-    def setUp(self):
-        self.engine = se.SearchEngine(self.root)  # None also seems to work
-        self.dialog = sdb.SearchDialogBase(root=self.root, engine=self.engine)
-
-    def tearDown(self):
-        self.dialog.close()
-
-    def test_open_and_close(self):
-        # open calls create_widgets, which needs default_command
-        self.dialog.default_command = None
-
-        # Since text parameter of .open is not used in base class,
-        # pass dummy 'text' instead of tk.Text().
-        self.dialog.open('text')
-        self.assertEqual(self.dialog.top.state(), 'normal')
-        self.dialog.close()
-        self.assertEqual(self.dialog.top.state(), 'withdrawn')
-
-        self.dialog.open('text', searchphrase="hello")
-        self.assertEqual(self.dialog.ent.get(), 'hello')
-        self.dialog.close()
-
-    def test_create_widgets(self):
-        self.dialog.create_entries = Func()
-        self.dialog.create_option_buttons = Func()
-        self.dialog.create_other_buttons = Func()
-        self.dialog.create_command_buttons = Func()
-
-        self.dialog.default_command = None
-        self.dialog.create_widgets()
-
-        self.assertTrue(self.dialog.create_entries.called)
-        self.assertTrue(self.dialog.create_option_buttons.called)
-        self.assertTrue(self.dialog.create_other_buttons.called)
-        self.assertTrue(self.dialog.create_command_buttons.called)
-
-    def test_make_entry(self):
-        equal = self.assertEqual
-        self.dialog.row = 0
-        self.dialog.top = Toplevel(self.root)
-        entry, label = self.dialog.make_entry("Test:", 'hello')
-        equal(label['text'], 'Test:')
-
-        self.assertIn(entry.get(), 'hello')
-        egi = entry.grid_info()
-        equal(int(egi['row']), 0)
-        equal(int(egi['column']), 1)
-        equal(int(egi['rowspan']), 1)
-        equal(int(egi['columnspan']), 1)
-        equal(self.dialog.row, 1)
-
-    def test_create_entries(self):
-        self.dialog.row = 0
-        self.engine.setpat('hello')
-        self.dialog.create_entries()
-        self.assertIn(self.dialog.ent.get(), 'hello')
-
-    def test_make_frame(self):
-        self.dialog.row = 0
-        self.dialog.top = Toplevel(self.root)
-        frame, label = self.dialog.make_frame()
-        self.assertEqual(label, '')
-        self.assertIsInstance(frame, Frame)
-
-        frame, label = self.dialog.make_frame('testlabel')
-        self.assertEqual(label['text'], 'testlabel')
-        self.assertIsInstance(frame, Frame)
-
-    def btn_test_setup(self, meth):
-        self.dialog.top = Toplevel(self.root)
-        self.dialog.row = 0
-        return meth()
-
-    def test_create_option_buttons(self):
-        e = self.engine
-        for state in (0, 1):
-            for var in (e.revar, e.casevar, e.wordvar, e.wrapvar):
-                var.set(state)
-            frame, options = self.btn_test_setup(
-                    self.dialog.create_option_buttons)
-            for spec, button in zip (options, frame.pack_slaves()):
-                var, label = spec
-                self.assertEqual(button['text'], label)
-                self.assertEqual(var.get(), state)
-                if state == 1:
-                    button.deselect()
-                else:
-                    button.select()
-                self.assertEqual(var.get(), 1 - state)
-
-    def test_create_other_buttons(self):
-        for state in (False, True):
-            var = self.engine.backvar
-            var.set(state)
-            frame, others = self.btn_test_setup(
-                self.dialog.create_other_buttons)
-            buttons = frame.pack_slaves()
-            for spec, button in zip(others, buttons):
-                val, label = spec
-                self.assertEqual(button['text'], label)
-                if val == state:
-                    # hit other button, then this one
-                    # indexes depend on button order
-                    self.assertEqual(var.get(), state)
-                    buttons[val].select()
-                    self.assertEqual(var.get(), 1 - state)
-                    buttons[1-val].select()
-                    self.assertEqual(var.get(), state)
-
-    def test_make_button(self):
-        self.dialog.top = Toplevel(self.root)
-        self.dialog.buttonframe = Frame(self.dialog.top)
-        btn = self.dialog.make_button('Test', self.dialog.close)
-        self.assertEqual(btn['text'], 'Test')
-
-    def test_create_command_buttons(self):
-        self.dialog.create_command_buttons()
-        # Look for close button command in buttonframe
-        closebuttoncommand = ''
-        for child in self.dialog.buttonframe.winfo_children():
-            if child['text'] == 'close':
-                closebuttoncommand = child['command']
-        self.assertIn('close', closebuttoncommand)
-
-
-
-if __name__ == '__main__':
-    unittest.main(verbosity=2, exit=2)
diff --git a/contrib/tools/python/src/Lib/idlelib/idle_test/test_searchengine.py b/contrib/tools/python/src/Lib/idlelib/idle_test/test_searchengine.py
deleted file mode 100644
index 8bf9d4728a..0000000000
--- a/contrib/tools/python/src/Lib/idlelib/idle_test/test_searchengine.py
+++ /dev/null
@@ -1,329 +0,0 @@
-'''Test functions and SearchEngine class in SearchEngine.py.'''
-
-# With mock replacements, the module does not use any gui widgets.
-# The use of tk.Text is avoided (for now, until mock Text is improved)
-# by patching instances with an index function returning what is needed.
-# This works because mock Text.get does not use .index.
-
-import re
-import unittest
-#from test.test_support import requires
-from Tkinter import  BooleanVar, StringVar, TclError  # ,Tk, Text
-import tkMessageBox
-from idlelib import SearchEngine as se
-from idlelib.idle_test.mock_tk import Var, Mbox
-from idlelib.idle_test.mock_tk import Text as mockText
-
-def setUpModule():
-    # Replace s-e module tkinter imports other than non-gui TclError.
-    se.BooleanVar = Var
-    se.StringVar = Var
-    se.tkMessageBox = Mbox
-
-def tearDownModule():
-    # Restore 'just in case', though other tests should also replace.
-    se.BooleanVar = BooleanVar
-    se.StringVar = StringVar
-    se.tkMessageBox = tkMessageBox
-
-
-class Mock:
-    def __init__(self, *args, **kwargs): pass
-
-class GetTest(unittest.TestCase):
-    # SearchEngine.get returns singleton created & saved on first call.
-    def test_get(self):
-        saved_Engine = se.SearchEngine
-        se.SearchEngine = Mock  # monkey-patch class
-        try:
-            root = Mock()
-            engine = se.get(root)
-            self.assertIsInstance(engine, se.SearchEngine)
-            self.assertIs(root._searchengine, engine)
-            self.assertIs(se.get(root), engine)
-        finally:
-            se.SearchEngine = saved_Engine  # restore class to module
-
-class GetLineColTest(unittest.TestCase):
-    #  Test simple text-independent helper function
-    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 GetSelectionTest(unittest.TestCase):
-    # Test text-dependent helper function.
-##    # Need gui for text.index('sel.first/sel.last/insert').
-##    @classmethod
-##    def setUpClass(cls):
-##        requires('gui')
-##        cls.root = Tk()
-##
-##    @classmethod
-##    def tearDownClass(cls):
-##        cls.root.destroy()
-##        del cls.root
-
-    def test_get_selection(self):
-        # text = Text(master=self.root)
-        text = mockText()
-        text.insert('1.0',  'Hello World!')
-
-        # fix text.index result when called in get_selection
-        def sel(s):
-            # select entire text, cursor irrelevant
-            if s == 'sel.first': return '1.0'
-            if s == 'sel.last': return '1.12'
-            raise TclError
-        text.index = sel  # replaces .tag_add('sel', '1.0, '1.12')
-        self.assertEqual(se.get_selection(text), ('1.0', '1.12'))
-
-        def mark(s):
-            # no selection, cursor after 'Hello'
-            if s == 'insert': return '1.5'
-            raise TclError
-        text.index = mark  # replaces .mark_set('insert', '1.5')
-        self.assertEqual(se.get_selection(text), ('1.5', '1.5'))
-
-
-class ReverseSearchTest(unittest.TestCase):
-    # Test helper function that searches backwards within a line.
-    def test_search_reverse(self):
-        Equal = self.assertEqual
-        line = "Here is an 'is' test text."
-        prog = re.compile('is')
-        Equal(se.search_reverse(prog, line, len(line)).span(), (12, 14))
-        Equal(se.search_reverse(prog, line, 14).span(), (12, 14))
-        Equal(se.search_reverse(prog, line, 13).span(), (5, 7))
-        Equal(se.search_reverse(prog, line, 7).span(), (5, 7))
-        Equal(se.search_reverse(prog, line, 6), None)
-
-
-class SearchEngineTest(unittest.TestCase):
-    # Test class methods that do not use Text widget.
-
-    def setUp(self):
-        self.engine = se.SearchEngine(root=None)
-        # Engine.root is only used to create error message boxes.
-        # The mock replacement ignores the root argument.
-
-    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_setcookedpat(self):
-        engine = self.engine
-        engine.setcookedpat('\s')
-        self.assertEqual(engine.getpat(), '\s')
-        engine.revar.set(1)
-        engine.setcookedpat('\s')
-        self.assertEqual(engine.getpat(), r'\\s')
-
-    def test_getcookedpat(self):
-        engine = self.engine
-        Equal = self.assertEqual
-
-        Equal(engine.getcookedpat(), '')
-        engine.setpat('hello')
-        Equal(engine.getcookedpat(), 'hello')
-        engine.wordvar.set(True)
-        Equal(engine.getcookedpat(), r'\bhello\b')
-        engine.wordvar.set(False)
-
-        engine.setpat('\s')
-        Equal(engine.getcookedpat(), r'\\s')
-        engine.revar.set(True)
-        Equal(engine.getcookedpat(), '\s')
-
-    def test_getprog(self):
-        engine = self.engine
-        Equal = self.assertEqual
-
-        engine.setpat('Hello')
-        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)
-
-        engine.setpat('')
-        Equal(engine.getprog(), None)
-        engine.setpat('+')
-        engine.revar.set(1)
-        Equal(engine.getprog(), None)
-        self.assertEqual(Mbox.showerror.message,
-                          'Error: nothing to repeat\nPattern: +')
-
-    def test_report_error(self):
-        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: " + msg + "\nPattern: [a-z")
-        Equal(showerror.message, expected_message)
-
-        Equal(self.engine.report_error(pat, msg, 5), None)
-        Equal(showerror.title, 'Regular expression error')
-        expected_message += "\nOffset: 5"
-        Equal(showerror.message, expected_message)
-
-
-class SearchTest(unittest.TestCase):
-    # Test that search_text makes right call to right method.
-
-    @classmethod
-    def setUpClass(cls):
-##        requires('gui')
-##        cls.root = Tk()
-##        cls.text = Text(master=cls.root)
-        cls.text = mockText()
-        test_text = (
-            'First line\n'
-            'Line with target\n'
-            'Last line\n')
-        cls.text.insert('1.0', test_text)
-        cls.pat = re.compile('target')
-
-        cls.engine = se.SearchEngine(None)
-        cls.engine.search_forward = lambda *args: ('f', args)
-        cls.engine.search_backward = lambda *args: ('b', args)
-
-##    @classmethod
-##    def tearDownClass(cls):
-##        cls.root.destroy()
-##        del cls.root
-
-    def test_search(self):
-        Equal = self.assertEqual
-        engine = self.engine
-        search = engine.search_text
-        text = self.text
-        pat = self.pat
-
-        engine.patvar.set(None)
-        #engine.revar.set(pat)
-        Equal(search(text), None)
-
-        def mark(s):
-            # no selection, cursor after 'Hello'
-            if s == 'insert': return '1.5'
-            raise TclError
-        text.index = mark
-        Equal(search(text, pat), ('f', (text, pat, 1, 5, True, False)))
-        engine.wrapvar.set(False)
-        Equal(search(text, pat), ('f', (text, pat, 1, 5, False, False)))
-        engine.wrapvar.set(True)
-        engine.backvar.set(True)
-        Equal(search(text, pat), ('b', (text, pat, 1, 5, True, False)))
-        engine.backvar.set(False)
-
-        def sel(s):
-            if s == 'sel.first': return '2.10'
-            if s == 'sel.last': return '2.16'
-            raise TclError
-        text.index = sel
-        Equal(search(text, pat), ('f', (text, pat, 2, 16, True, False)))
-        Equal(search(text, pat, True), ('f', (text, pat, 2, 10, True, True)))
-        engine.backvar.set(True)
-        Equal(search(text, pat), ('b', (text, pat, 2, 10, True, False)))
-        Equal(search(text, pat, True), ('b', (text, pat, 2, 16, True, True)))
-
-
-class ForwardBackwardTest(unittest.TestCase):
-    # Test that search_forward method finds the target.
-##    @classmethod
-##    def tearDownClass(cls):
-##        cls.root.destroy()
-##        del cls.root
-
-    @classmethod
-    def setUpClass(cls):
-        cls.engine = se.SearchEngine(None)
-##        requires('gui')
-##        cls.root = Tk()
-##        cls.text = Text(master=cls.root)
-        cls.text = mockText()
-        # search_backward calls index('end-1c')
-        cls.text.index = lambda index: '4.0'
-        test_text = (
-            'First line\n'
-            'Line with target\n'
-            'Last line\n')
-        cls.text.insert('1.0', test_text)
-        cls.pat = re.compile('target')
-        cls.res = (2, (10, 16))  # line, slice indexes of 'target'
-        cls.failpat = re.compile('xyz')  # not in text
-        cls.emptypat = re.compile('\w*')  # empty match possible
-
-    def make_search(self, func):
-        def search(pat, line, col, wrap, ok=0):
-            res = func(self.text, pat, line, col, wrap, ok)
-            # res is (line, matchobject) or None
-            return (res[0], res[1].span()) if res else res
-        return search
-
-    def test_search_forward(self):
-        # search for non-empty match
-        Equal = self.assertEqual
-        forward = self.make_search(self.engine.search_forward)
-        pat = self.pat
-        Equal(forward(pat, 1, 0, True), self.res)
-        Equal(forward(pat, 3, 0, True), self.res)  # wrap
-        Equal(forward(pat, 3, 0, False), None)  # no wrap
-        Equal(forward(pat, 2, 10, False), self.res)
-
-        Equal(forward(self.failpat, 1, 0, True), None)
-        Equal(forward(self.emptypat, 2,  9, True, ok=True), (2, (9, 9)))
-        #Equal(forward(self.emptypat, 2, 9, True), self.res)
-        # While the initial empty match is correctly ignored, skipping
-        # the rest of the line and returning (3, (0,4)) seems buggy - tjr.
-        Equal(forward(self.emptypat, 2, 10, True), self.res)
-
-    def test_search_backward(self):
-        # search for non-empty match
-        Equal = self.assertEqual
-        backward = self.make_search(self.engine.search_backward)
-        pat = self.pat
-        Equal(backward(pat, 3, 5, True), self.res)
-        Equal(backward(pat, 2, 0, True), self.res)  # wrap
-        Equal(backward(pat, 2, 0, False), None)  # no wrap
-        Equal(backward(pat, 2, 16, False), self.res)
-
-        Equal(backward(self.failpat, 3, 9, True), None)
-        Equal(backward(self.emptypat, 2,  10, True, ok=True), (2, (9,9)))
-        # Accepted because 9 < 10, not because ok=True.
-        # It is not clear that ok=True is useful going back - tjr
-        Equal(backward(self.emptypat, 2, 9, True), (2, (5, 9)))
-
-
-if __name__ == '__main__':
-    unittest.main(verbosity=2, exit=2)
diff --git a/contrib/tools/python/src/Lib/idlelib/idle_test/test_text.py b/contrib/tools/python/src/Lib/idlelib/idle_test/test_text.py
deleted file mode 100644
index 50d3facec7..0000000000
--- a/contrib/tools/python/src/Lib/idlelib/idle_test/test_text.py
+++ /dev/null
@@ -1,227 +0,0 @@
-# Test mock_tk.Text class against tkinter.Text class by running same tests with both.
-import unittest
-from test.test_support import requires
-
-from _tkinter import TclError
-
-class TextTest(object):
-
-    hw = 'hello\nworld'  # usual initial insert after initialization
-    hwn = hw+'\n'  # \n present at initialization, before insert
-
-    Text = None
-    def setUp(self):
-        self.text = self.Text()
-
-    def test_init(self):
-        self.assertEqual(self.text.get('1.0'), '\n')
-        self.assertEqual(self.text.get('end'), '')
-
-    def test_index_empty(self):
-        index = self.text.index
-
-        for dex in (-1.0, 0.3, '1.-1', '1.0', '1.0 lineend', '1.end', '1.33',
-                'insert'):
-            self.assertEqual(index(dex), '1.0')
-
-        for dex in 'end', 2.0, '2.1', '33.44':
-            self.assertEqual(index(dex), '2.0')
-
-    def test_index_data(self):
-        index = self.text.index
-        self.text.insert('1.0', self.hw)
-
-        for dex in -1.0, 0.3, '1.-1', '1.0':
-            self.assertEqual(index(dex), '1.0')
-
-        for dex in '1.0 lineend', '1.end', '1.33':
-            self.assertEqual(index(dex), '1.5')
-
-        for dex in 'end',  '33.44':
-            self.assertEqual(index(dex), '3.0')
-
-    def test_get(self):
-        get = self.text.get
-        Equal = self.assertEqual
-        self.text.insert('1.0', self.hw)
-
-        Equal(get('end'), '')
-        Equal(get('end', 'end'), '')
-        Equal(get('1.0'), 'h')
-        Equal(get('1.0', '1.1'), 'h')
-        Equal(get('1.0', '1.3'), 'hel')
-        Equal(get('1.1', '1.3'), 'el')
-        Equal(get('1.0', '1.0 lineend'), 'hello')
-        Equal(get('1.0', '1.10'), 'hello')
-        Equal(get('1.0 lineend'), '\n')
-        Equal(get('1.1', '2.3'), 'ello\nwor')
-        Equal(get('1.0', '2.5'), self.hw)
-        Equal(get('1.0', 'end'), self.hwn)
-        Equal(get('0.0', '5.0'), self.hwn)
-
-    def test_insert(self):
-        insert = self.text.insert
-        get = self.text.get
-        Equal = self.assertEqual
-
-        insert('1.0', self.hw)
-        Equal(get('1.0', 'end'), self.hwn)
-
-        insert('1.0', '')  # nothing
-        Equal(get('1.0', 'end'), self.hwn)
-
-        insert('1.0', '*')
-        Equal(get('1.0', 'end'), '*hello\nworld\n')
-
-        insert('1.0 lineend', '*')
-        Equal(get('1.0', 'end'), '*hello*\nworld\n')
-
-        insert('2.3', '*')
-        Equal(get('1.0', 'end'), '*hello*\nwor*ld\n')
-
-        insert('end', 'x')
-        Equal(get('1.0', 'end'), '*hello*\nwor*ldx\n')
-
-        insert('1.4', 'x\n')
-        Equal(get('1.0', 'end'), '*helx\nlo*\nwor*ldx\n')
-
-    def test_no_delete(self):
-        # if index1 == 'insert' or 'end' or >= end, there is no deletion
-        delete = self.text.delete
-        get = self.text.get
-        Equal = self.assertEqual
-        self.text.insert('1.0', self.hw)
-
-        delete('insert')
-        Equal(get('1.0', 'end'), self.hwn)
-
-        delete('end')
-        Equal(get('1.0', 'end'), self.hwn)
-
-        delete('insert', 'end')
-        Equal(get('1.0', 'end'), self.hwn)
-
-        delete('insert', '5.5')
-        Equal(get('1.0', 'end'), self.hwn)
-
-        delete('1.4', '1.0')
-        Equal(get('1.0', 'end'), self.hwn)
-
-        delete('1.4', '1.4')
-        Equal(get('1.0', 'end'), self.hwn)
-
-    def test_delete_char(self):
-        delete = self.text.delete
-        get = self.text.get
-        Equal = self.assertEqual
-        self.text.insert('1.0', self.hw)
-
-        delete('1.0')
-        Equal(get('1.0', '1.end'), 'ello')
-
-        delete('1.0', '1.1')
-        Equal(get('1.0', '1.end'), 'llo')
-
-        # delete \n and combine 2 lines into 1
-        delete('1.end')
-        Equal(get('1.0', '1.end'), 'lloworld')
-
-        self.text.insert('1.3', '\n')
-        delete('1.10')
-        Equal(get('1.0', '1.end'), 'lloworld')
-
-        self.text.insert('1.3', '\n')
-        delete('1.3', '2.0')
-        Equal(get('1.0', '1.end'), 'lloworld')
-
-    def test_delete_slice(self):
-        delete = self.text.delete
-        get = self.text.get
-        Equal = self.assertEqual
-        self.text.insert('1.0', self.hw)
-
-        delete('1.0', '1.0 lineend')
-        Equal(get('1.0', 'end'), '\nworld\n')
-
-        delete('1.0', 'end')
-        Equal(get('1.0', 'end'), '\n')
-
-        self.text.insert('1.0', self.hw)
-        delete('1.0', '2.0')
-        Equal(get('1.0', 'end'), 'world\n')
-
-        delete('1.0', 'end')
-        Equal(get('1.0', 'end'), '\n')
-
-        self.text.insert('1.0', self.hw)
-        delete('1.2', '2.3')
-        Equal(get('1.0', 'end'), 'held\n')
-
-    def test_multiple_lines(self):  # insert and delete
-        self.text.insert('1.0', 'hello')
-
-        self.text.insert('1.3', '1\n2\n3\n4\n5')
-        self.assertEqual(self.text.get('1.0', 'end'), 'hel1\n2\n3\n4\n5lo\n')
-
-        self.text.delete('1.3', '5.1')
-        self.assertEqual(self.text.get('1.0', 'end'), 'hello\n')
-
-    def test_compare(self):
-        compare = self.text.compare
-        Equal = self.assertEqual
-        # need data so indexes not squished to 1,0
-        self.text.insert('1.0', 'First\nSecond\nThird\n')
-
-        self.assertRaises(TclError, compare, '2.2', 'op', '2.2')
-
-        for op, less1, less0, equal, greater0, greater1 in (
-                ('<', True, True, False, False, False),
-                ('<=', True, True, True, False, False),
-                ('>', False, False, False, True, True),
-                ('>=', False, False, True, True, True),
-                ('==', False, False, True, False, False),
-                ('!=', True, True, False, True, True),
-                ):
-            Equal(compare('1.1', op, '2.2'), less1, op)
-            Equal(compare('2.1', op, '2.2'), less0, op)
-            Equal(compare('2.2', op, '2.2'), equal, op)
-            Equal(compare('2.3', op, '2.2'), greater0, op)
-            Equal(compare('3.3', op, '2.2'), greater1, op)
-
-
-class MockTextTest(TextTest, unittest.TestCase):
-
-    @classmethod
-    def setUpClass(cls):
-        from idlelib.idle_test.mock_tk import Text
-        cls.Text = Text
-
-    def test_decode(self):
-        # test endflags (-1, 0) not tested by test_index (which uses +1)
-        decode = self.text._decode
-        Equal = self.assertEqual
-        self.text.insert('1.0', self.hw)
-
-        Equal(decode('end', -1), (2, 5))
-        Equal(decode('3.1', -1), (2, 5))
-        Equal(decode('end',  0), (2, 6))
-        Equal(decode('3.1', 0), (2, 6))
-
-
-class TkTextTest(TextTest, unittest.TestCase):
-
-    @classmethod
-    def setUpClass(cls):
-        requires('gui')
-        from Tkinter import Tk, Text
-        cls.Text = Text
-        cls.root = Tk()
-
-    @classmethod
-    def tearDownClass(cls):
-        cls.root.destroy()
-        del cls.root
-
-
-if __name__ == '__main__':
-    unittest.main(verbosity=2, exit=False)
diff --git a/contrib/tools/python/src/Lib/idlelib/idle_test/test_textview.py b/contrib/tools/python/src/Lib/idlelib/idle_test/test_textview.py
deleted file mode 100644
index fa437fcb6e..0000000000
--- a/contrib/tools/python/src/Lib/idlelib/idle_test/test_textview.py
+++ /dev/null
@@ -1,96 +0,0 @@
-'''Test the functions and main class method of textView.py.'''
-
-import unittest
-import os
-from test.test_support import requires
-from Tkinter import Tk
-from idlelib import textView as tv
-from idlelib.idle_test.mock_idle import Func
-from idlelib.idle_test.mock_tk import Mbox
-
-
-class TV(tv.TextViewer):  # Use in TextViewTest
-    transient = Func()
-    grab_set = Func()
-    wait_window = Func()
-
-class textviewClassTest(unittest.TestCase):
-
-    @classmethod
-    def setUpClass(cls):
-        requires('gui')
-        cls.root = Tk()
-        cls.root.withdraw()
-
-    @classmethod
-    def tearDownClass(cls):
-        cls.root.destroy()
-        del cls.root
-
-    def setUp(self):
-        TV.transient.__init__()
-        TV.grab_set.__init__()
-        TV.wait_window.__init__()
-
-    def test_init_modal(self):
-        view = TV(self.root, 'Title', 'test text')
-        self.assertTrue(TV.transient.called)
-        self.assertTrue(TV.grab_set.called)
-        self.assertTrue(TV.wait_window.called)
-        view.Ok()
-
-    def test_init_nonmodal(self):
-        view = TV(self.root, 'Title', 'test text', modal=False)
-        self.assertFalse(TV.transient.called)
-        self.assertFalse(TV.grab_set.called)
-        self.assertFalse(TV.wait_window.called)
-        view.Ok()
-
-    def test_ok(self):
-        view = TV(self.root, 'Title', 'test text', modal=False)
-        view.destroy = Func()
-        view.Ok()
-        self.assertTrue(view.destroy.called)
-        del view.destroy  # Unmask the real function.
-        view.destroy()
-
-
-class ViewFunctionTest(unittest.TestCase):
-
-    @classmethod
-    def setUpClass(cls):
-        requires('gui')
-        cls.root = Tk()
-        cls.root.withdraw()
-        cls.orig_mbox = tv.tkMessageBox
-        tv.tkMessageBox = Mbox
-
-    @classmethod
-    def tearDownClass(cls):
-        cls.root.destroy()
-        del cls.root
-        tv.tkMessageBox = cls.orig_mbox
-        del cls.orig_mbox
-
-    def test_view_text(self):
-        # If modal True, get tkinter error 'can't invoke "event" command'.
-        view = tv.view_text(self.root, 'Title', 'test text', modal=False)
-        self.assertIsInstance(view, tv.TextViewer)
-        view.Ok()
-
-    def test_view_file(self):
-        test_dir = os.path.dirname(__file__)
-        testfile = os.path.join(test_dir, 'test_textview.py')
-        view = tv.view_file(self.root, 'Title', testfile, modal=False)
-        self.assertIsInstance(view, tv.TextViewer)
-        self.assertIn('Test', view.textView.get('1.0', '1.end'))
-        view.Ok()
-
-        # Mock messagebox will be used; view_file will return None.
-        testfile = os.path.join(test_dir, '../notthere.py')
-        view = tv.view_file(self.root, 'Title', testfile, modal=False)
-        self.assertIsNone(view)
-
-
-if __name__ == '__main__':
-    unittest.main(verbosity=2)
diff --git a/contrib/tools/python/src/Lib/idlelib/idle_test/test_warning.py b/contrib/tools/python/src/Lib/idlelib/idle_test/test_warning.py
deleted file mode 100644
index da1d8a1d0a..0000000000
--- a/contrib/tools/python/src/Lib/idlelib/idle_test/test_warning.py
+++ /dev/null
@@ -1,73 +0,0 @@
-'''Test warnings replacement in PyShell.py and run.py.
-
-This file could be expanded to include traceback overrides
-(in same two modules). If so, change name.
-Revise if output destination changes (http://bugs.python.org/issue18318).
-Make sure warnings module is left unaltered (http://bugs.python.org/issue18081).
-'''
-
-import unittest
-from test.test_support import captured_stderr
-
-import warnings
-# Try to capture default showwarning before Idle modules are imported.
-showwarning = warnings.showwarning
-# But if we run this file within idle, we are in the middle of the run.main loop
-# and default showwarnings has already been replaced.
-running_in_idle = 'idle' in showwarning.__name__
-
-from idlelib import run
-from idlelib import PyShell as shell
-
-# The following was generated from PyShell.idle_formatwarning
-# and checked as matching expectation.
-idlemsg = '''
-Warning (from warnings module):
-  File "test_warning.py", line 99
-    Line of code
-UserWarning: Test
-'''
-shellmsg = idlemsg + ">>> "
-
-class RunWarnTest(unittest.TestCase):
-
-    @unittest.skipIf(running_in_idle, "Does not work when run within Idle.")
-    def test_showwarnings(self):
-        self.assertIs(warnings.showwarning, showwarning)
-        run.capture_warnings(True)
-        self.assertIs(warnings.showwarning, run.idle_showwarning_subproc)
-        run.capture_warnings(False)
-        self.assertIs(warnings.showwarning, showwarning)
-
-    def test_run_show(self):
-        with captured_stderr() as f:
-            run.idle_showwarning_subproc(
-                    'Test', UserWarning, 'test_warning.py', 99, f, 'Line of code')
-            # The following uses .splitlines to erase line-ending differences
-            self.assertEqual(idlemsg.splitlines(), f.getvalue().splitlines())
-
-class ShellWarnTest(unittest.TestCase):
-
-    @unittest.skipIf(running_in_idle, "Does not work when run within Idle.")
-    def test_showwarnings(self):
-        self.assertIs(warnings.showwarning, showwarning)
-        shell.capture_warnings(True)
-        self.assertIs(warnings.showwarning, shell.idle_showwarning)
-        shell.capture_warnings(False)
-        self.assertIs(warnings.showwarning, showwarning)
-
-    def test_idle_formatter(self):
-        # Will fail if format changed without regenerating idlemsg
-        s = shell.idle_formatwarning(
-                'Test', UserWarning, 'test_warning.py', 99, 'Line of code')
-        self.assertEqual(idlemsg, s)
-
-    def test_shell_show(self):
-        with captured_stderr() as f:
-            shell.idle_showwarning(
-                    'Test', UserWarning, 'test_warning.py', 99, f, 'Line of code')
-            self.assertEqual(shellmsg.splitlines(), f.getvalue().splitlines())
-
-
-if __name__ == '__main__':
-    unittest.main(verbosity=2, exit=False)
diff --git a/contrib/tools/python/src/Lib/idlelib/idle_test/test_widgetredir.py b/contrib/tools/python/src/Lib/idlelib/idle_test/test_widgetredir.py
deleted file mode 100644
index e35ea4174d..0000000000
--- a/contrib/tools/python/src/Lib/idlelib/idle_test/test_widgetredir.py
+++ /dev/null
@@ -1,124 +0,0 @@
-"""Unittest for idlelib.WidgetRedirector
-
-100% coverage
-"""
-from test.test_support import requires
-import unittest
-from idlelib.idle_test.mock_idle import Func
-from Tkinter import Tk, Text, TclError
-from idlelib.WidgetRedirector import WidgetRedirector
-
-
-class InitCloseTest(unittest.TestCase):
-
-    @classmethod
-    def setUpClass(cls):
-        requires('gui')
-        cls.root = Tk()
-        cls.root.withdraw()
-        cls.text = Text(cls.root)
-
-    @classmethod
-    def tearDownClass(cls):
-        del cls.text
-        cls.root.destroy()
-        del cls.root
-
-    def test_init(self):
-        redir = WidgetRedirector(self.text)
-        self.assertEqual(redir.widget, self.text)
-        self.assertEqual(redir.tk, self.text.tk)
-        self.assertRaises(TclError, WidgetRedirector, self.text)
-        redir.close()  # restore self.tk, self.text
-
-    def test_close(self):
-        redir = WidgetRedirector(self.text)
-        redir.register('insert', Func)
-        redir.close()
-        self.assertEqual(redir._operations, {})
-        self.assertFalse(hasattr(self.text, 'widget'))
-
-
-class WidgetRedirectorTest(unittest.TestCase):
-
-    @classmethod
-    def setUpClass(cls):
-        requires('gui')
-        cls.root = Tk()
-        cls.root.withdraw()
-        cls.text = Text(cls.root)
-
-    @classmethod
-    def tearDownClass(cls):
-        del cls.text
-        cls.root.destroy()
-        del cls.root
-
-    def setUp(self):
-        self.redir = WidgetRedirector(self.text)
-        self.func = Func()
-        self.orig_insert = self.redir.register('insert', self.func)
-        self.text.insert('insert', 'asdf')  # leaves self.text empty
-
-    def tearDown(self):
-        self.text.delete('1.0', 'end')
-        self.redir.close()
-
-    def test_repr(self):  # partly for 100% coverage
-        self.assertIn('Redirector', repr(self.redir))
-        self.assertIn('Original', repr(self.orig_insert))
-
-    def test_register(self):
-        self.assertEqual(self.text.get('1.0', 'end'), '\n')
-        self.assertEqual(self.func.args, ('insert', 'asdf'))
-        self.assertIn('insert', self.redir._operations)
-        self.assertIn('insert', self.text.__dict__)
-        self.assertEqual(self.text.insert, self.func)
-
-    def test_original_command(self):
-        self.assertEqual(self.orig_insert.operation, 'insert')
-        self.assertEqual(self.orig_insert.tk_call, self.text.tk.call)
-        self.orig_insert('insert', 'asdf')
-        self.assertEqual(self.text.get('1.0', 'end'), 'asdf\n')
-
-    def test_unregister(self):
-        self.assertIsNone(self.redir.unregister('invalid operation name'))
-        self.assertEqual(self.redir.unregister('insert'), self.func)
-        self.assertNotIn('insert', self.redir._operations)
-        self.assertNotIn('insert', self.text.__dict__)
-
-    def test_unregister_no_attribute(self):
-        del self.text.insert
-        self.assertEqual(self.redir.unregister('insert'), self.func)
-
-    def test_dispatch_intercept(self):
-        self.func.__init__(True)
-        self.assertTrue(self.redir.dispatch('insert', False))
-        self.assertFalse(self.func.args[0])
-
-    def test_dispatch_bypass(self):
-        self.orig_insert('insert', 'asdf')
-        # tk.call returns '' where Python would return None
-        self.assertEqual(self.redir.dispatch('delete', '1.0', 'end'), '')
-        self.assertEqual(self.text.get('1.0', 'end'), '\n')
-
-    def test_dispatch_error(self):
-        self.func.__init__(TclError())
-        self.assertEqual(self.redir.dispatch('insert', False), '')
-        self.assertEqual(self.redir.dispatch('invalid'), '')
-
-    def test_command_dispatch(self):
-        # Test that .__init__ causes redirection of tk calls
-        # through redir.dispatch
-        self.root.call(self.text._w, 'insert', 'hello')
-        self.assertEqual(self.func.args, ('hello',))
-        self.assertEqual(self.text.get('1.0', 'end'), '\n')
-        # Ensure that called through redir .dispatch and not through
-        # self.text.insert by having mock raise TclError.
-        self.func.__init__(TclError())
-        self.assertEqual(self.root.call(self.text._w, 'insert', 'boo'), '')
-
-
-
-if __name__ == '__main__':
-    unittest.main(verbosity=2)
author	thegeorg <thegeorg@yandex-team.com>	2024-03-15 23:28:02 +0300
committer	thegeorg <thegeorg@yandex-team.com>	2024-03-15 23:38:24 +0300
commit	6635e51dd2fc4c8fbc3e510cd31c9c9102b7cfda (patch)
tree	d51d048d3eb5d7a24ec6e4302b589513a3b97de3 /contrib/tools/python/src/Lib/idlelib/idle_test
parent	e894914751eea93bb23102a533c8d481b80c2560 (diff)
download	ydb-6635e51dd2fc4c8fbc3e510cd31c9c9102b7cfda.tar.gz