[3.9] bpo-45229: Make tkinter tests discoverable (GH-28637) (GH-28929)

(cherry picked from commit f59ed3c310a7ceebf2a56a84ea969a7f75d95b64)

Co-authored-by: Serhiy Storchaka <storchaka@gmail.com>

17 files changed, 496 insertions, 600 deletions

diff --git a/Lib/test/test_tk.py b/Lib/test/test_tk.py
index 48cefd92e1..d45acbfc6e 100644
--- a/Lib/test/test_tk.py
+++ b/Lib/test/test_tk.py
@@ -5,11 +5,9 @@ support.import_module('_tkinter')
 # Skip test if tk cannot be initialized.
 support.requires('gui')
 
-from tkinter.test import runtktests
+def load_tests(loader, tests, pattern):
+    return loader.discover('tkinter.test.test_tkinter')
 
-def test_main():
-    support.run_unittest(
-            *runtktests.get_tests(text=False, packages=['test_tkinter']))
 
 if __name__ == '__main__':
-    test_main()
+    unittest.main()
diff --git a/Lib/test/test_ttk_guionly.py b/Lib/test/test_ttk_guionly.py
index 462665db5f..0b57d5a0d6 100644
--- a/Lib/test/test_ttk_guionly.py
+++ b/Lib/test/test_ttk_guionly.py
@@ -10,25 +10,26 @@ support.requires('gui')
 import tkinter
 from _tkinter import TclError
 from tkinter import ttk
-from tkinter.test import runtktests
-
-root = None
-try:
-    root = tkinter.Tk()
-    button = ttk.Button(root)
-    button.destroy()
-    del button
-except TclError as msg:
-    # assuming ttk is not available
-    raise unittest.SkipTest("ttk not available: %s" % msg)
-finally:
-    if root is not None:
-        root.destroy()
-    del root
-
-def test_main():
-    support.run_unittest(
-            *runtktests.get_tests(text=False, packages=['test_ttk']))
+
+
+def setUpModule():
+    root = None
+    try:
+        root = tkinter.Tk()
+        button = ttk.Button(root)
+        button.destroy()
+        del button
+    except TclError as msg:
+        # assuming ttk is not available
+        raise unittest.SkipTest("ttk not available: %s" % msg)
+    finally:
+        if root is not None:
+            root.destroy()
+        del root
+
+def load_tests(loader, tests, pattern):
+    return loader.discover('tkinter.test.test_ttk')
+
 
 if __name__ == '__main__':
-    test_main()
+    unittest.main()
diff --git a/Lib/test/test_ttk_textonly.py b/Lib/test/test_ttk_textonly.py
index 7540a43103..7a478398a9 100644
--- a/Lib/test/test_ttk_textonly.py
+++ b/Lib/test/test_ttk_textonly.py
@@ -3,11 +3,461 @@ from test import support
 # Skip this test if _tkinter does not exist.
 support.import_module('_tkinter')
 
-from tkinter.test import runtktests
+import unittest
+from tkinter import ttk
+
+
+class MockTkApp:
+
+    def splitlist(self, arg):
+        if isinstance(arg, tuple):
+            return arg
+        return arg.split(':')
+
+    def wantobjects(self):
+        return True
+
+
+class MockTclObj(object):
+    typename = 'test'
+
+    def __init__(self, val):
+        self.val = val
+
+    def __str__(self):
+        return str(self.val)
+
+
+class MockStateSpec(object):
+    typename = 'StateSpec'
+
+    def __init__(self, *args):
+        self.val = args
+
+    def __str__(self):
+        return ' '.join(self.val)
+
+
+class InternalFunctionsTest(unittest.TestCase):
+
+    def test_format_optdict(self):
+        def check_against(fmt_opts, result):
+            for i in range(0, len(fmt_opts), 2):
+                self.assertEqual(result.pop(fmt_opts[i]), fmt_opts[i + 1])
+            if result:
+                self.fail("result still got elements: %s" % result)
+
+        # passing an empty dict should return an empty object (tuple here)
+        self.assertFalse(ttk._format_optdict({}))
+
+        # check list formatting
+        check_against(
+            ttk._format_optdict({'fg': 'blue', 'padding': [1, 2, 3, 4]}),
+            {'-fg': 'blue', '-padding': '1 2 3 4'})
+
+        # check tuple formatting (same as list)
+        check_against(
+            ttk._format_optdict({'test': (1, 2, '', 0)}),
+            {'-test': '1 2 {} 0'})
+
+        # check untouched values
+        check_against(
+            ttk._format_optdict({'test': {'left': 'as is'}}),
+            {'-test': {'left': 'as is'}})
+
+        # check script formatting
+        check_against(
+            ttk._format_optdict(
+                {'test': [1, -1, '', '2m', 0], 'test2': 3,
+                 'test3': '', 'test4': 'abc def',
+                 'test5': '"abc"', 'test6': '{}',
+                 'test7': '} -spam {'}, script=True),
+            {'-test': '{1 -1 {} 2m 0}', '-test2': '3',
+             '-test3': '{}', '-test4': '{abc def}',
+             '-test5': '{"abc"}', '-test6': r'\{\}',
+             '-test7': r'\}\ -spam\ \{'})
+
+        opts = {'αβγ': True, 'á': False}
+        orig_opts = opts.copy()
+        # check if giving unicode keys is fine
+        check_against(ttk._format_optdict(opts), {'-αβγ': True, '-á': False})
+        # opts should remain unchanged
+        self.assertEqual(opts, orig_opts)
+
+        # passing values with spaces inside a tuple/list
+        check_against(
+            ttk._format_optdict(
+                {'option': ('one two', 'three')}),
+            {'-option': '{one two} three'})
+        check_against(
+            ttk._format_optdict(
+                {'option': ('one\ttwo', 'three')}),
+            {'-option': '{one\ttwo} three'})
+
+        # passing empty strings inside a tuple/list
+        check_against(
+            ttk._format_optdict(
+                {'option': ('', 'one')}),
+            {'-option': '{} one'})
+
+        # passing values with braces inside a tuple/list
+        check_against(
+            ttk._format_optdict(
+                {'option': ('one} {two', 'three')}),
+            {'-option': r'one\}\ \{two three'})
+
+        # passing quoted strings inside a tuple/list
+        check_against(
+            ttk._format_optdict(
+                {'option': ('"one"', 'two')}),
+            {'-option': '{"one"} two'})
+        check_against(
+            ttk._format_optdict(
+                {'option': ('{one}', 'two')}),
+            {'-option': r'\{one\} two'})
+
+        # ignore an option
+        amount_opts = len(ttk._format_optdict(opts, ignore=('á'))) / 2
+        self.assertEqual(amount_opts, len(opts) - 1)
+
+        # ignore non-existing options
+        amount_opts = len(ttk._format_optdict(opts, ignore=('á', 'b'))) / 2
+        self.assertEqual(amount_opts, len(opts) - 1)
+
+        # ignore every option
+        self.assertFalse(ttk._format_optdict(opts, ignore=list(opts.keys())))
+
+
+    def test_format_mapdict(self):
+        opts = {'a': [('b', 'c', 'val'), ('d', 'otherval'), ('', 'single')]}
+        result = ttk._format_mapdict(opts)
+        self.assertEqual(len(result), len(list(opts.keys())) * 2)
+        self.assertEqual(result, ('-a', '{b c} val d otherval {} single'))
+        self.assertEqual(ttk._format_mapdict(opts, script=True),
+            ('-a', '{{b c} val d otherval {} single}'))
+
+        self.assertEqual(ttk._format_mapdict({2: []}), ('-2', ''))
+
+        opts = {'üñíćódè': [('á', 'vãl')]}
+        result = ttk._format_mapdict(opts)
+        self.assertEqual(result, ('-üñíćódè', 'á vãl'))
+
+        self.assertEqual(ttk._format_mapdict({'opt': [('value',)]}),
+                         ('-opt', '{} value'))
+
+        # empty states
+        valid = {'opt': [('', '', 'hi')]}
+        self.assertEqual(ttk._format_mapdict(valid), ('-opt', '{ } hi'))
+
+        # when passing multiple states, they all must be strings
+        invalid = {'opt': [(1, 2, 'valid val')]}
+        self.assertRaises(TypeError, ttk._format_mapdict, invalid)
+        invalid = {'opt': [([1], '2', 'valid val')]}
+        self.assertRaises(TypeError, ttk._format_mapdict, invalid)
+        # but when passing a single state, it can be anything
+        valid = {'opt': [[1, 'value']]}
+        self.assertEqual(ttk._format_mapdict(valid), ('-opt', '1 value'))
+        # special attention to single states which evaluate to False
+        for stateval in (None, 0, False, '', set()): # just some samples
+            valid = {'opt': [(stateval, 'value')]}
+            self.assertEqual(ttk._format_mapdict(valid),
+                ('-opt', '{} value'))
+
+        # values must be iterable
+        opts = {'a': None}
+        self.assertRaises(TypeError, ttk._format_mapdict, opts)
+
+
+    def test_format_elemcreate(self):
+        self.assertTrue(ttk._format_elemcreate(None), (None, ()))
+
+        ## Testing type = image
+        # image type expects at least an image name, so this should raise
+        # IndexError since it tries to access the index 0 of an empty tuple
+        self.assertRaises(IndexError, ttk._format_elemcreate, 'image')
+
+        # don't format returned values as a tcl script
+        # minimum acceptable for image type
+        self.assertEqual(ttk._format_elemcreate('image', False, 'test'),
+            ("test ", ()))
+        # specifying a state spec
+        self.assertEqual(ttk._format_elemcreate('image', False, 'test',
+            ('', 'a')), ("test {} a", ()))
+        # state spec with multiple states
+        self.assertEqual(ttk._format_elemcreate('image', False, 'test',
+            ('a', 'b', 'c')), ("test {a b} c", ()))
+        # state spec and options
+        self.assertEqual(ttk._format_elemcreate('image', False, 'test',
+            ('a', 'b'), a='x'), ("test a b", ("-a", "x")))
+        # format returned values as a tcl script
+        # state spec with multiple states and an option with a multivalue
+        self.assertEqual(ttk._format_elemcreate('image', True, 'test',
+            ('a', 'b', 'c', 'd'), x=[2, 3]), ("{test {a b c} d}", "-x {2 3}"))
+
+        ## Testing type = vsapi
+        # vsapi type expects at least a class name and a part_id, so this
+        # should raise a ValueError since it tries to get two elements from
+        # an empty tuple
+        self.assertRaises(ValueError, ttk._format_elemcreate, 'vsapi')
+
+        # don't format returned values as a tcl script
+        # minimum acceptable for vsapi
+        self.assertEqual(ttk._format_elemcreate('vsapi', False, 'a', 'b'),
+            ("a b ", ()))
+        # now with a state spec with multiple states
+        self.assertEqual(ttk._format_elemcreate('vsapi', False, 'a', 'b',
+            ('a', 'b', 'c')), ("a b {a b} c", ()))
+        # state spec and option
+        self.assertEqual(ttk._format_elemcreate('vsapi', False, 'a', 'b',
+            ('a', 'b'), opt='x'), ("a b a b", ("-opt", "x")))
+        # format returned values as a tcl script
+        # state spec with a multivalue and an option
+        self.assertEqual(ttk._format_elemcreate('vsapi', True, 'a', 'b',
+            ('a', 'b', [1, 2]), opt='x'), ("{a b {a b} {1 2}}", "-opt x"))
+
+        # Testing type = from
+        # from type expects at least a type name
+        self.assertRaises(IndexError, ttk._format_elemcreate, 'from')
+
+        self.assertEqual(ttk._format_elemcreate('from', False, 'a'),
+            ('a', ()))
+        self.assertEqual(ttk._format_elemcreate('from', False, 'a', 'b'),
+            ('a', ('b', )))
+        self.assertEqual(ttk._format_elemcreate('from', True, 'a', 'b'),
+            ('{a}', 'b'))
+
+
+    def test_format_layoutlist(self):
+        def sample(indent=0, indent_size=2):
+            return ttk._format_layoutlist(
+            [('a', {'other': [1, 2, 3], 'children':
+                [('b', {'children':
+                    [('c', {'children':
+                        [('d', {'nice': 'opt'})], 'something': (1, 2)
+                    })]
+                })]
+            })], indent=indent, indent_size=indent_size)[0]
+
+        def sample_expected(indent=0, indent_size=2):
+            spaces = lambda amount=0: ' ' * (amount + indent)
+            return (
+                "%sa -other {1 2 3} -children {\n"
+                "%sb -children {\n"
+                "%sc -something {1 2} -children {\n"
+                "%sd -nice opt\n"
+                "%s}\n"
+                "%s}\n"
+                "%s}" % (spaces(), spaces(indent_size),
+                    spaces(2 * indent_size), spaces(3 * indent_size),
+                    spaces(2 * indent_size), spaces(indent_size), spaces()))
+
+        # empty layout
+        self.assertEqual(ttk._format_layoutlist([])[0], '')
+
+        # _format_layoutlist always expects the second item (in every item)
+        # to act like a dict (except when the value evaluates to False).
+        self.assertRaises(AttributeError,
+            ttk._format_layoutlist, [('a', 'b')])
+
+        smallest = ttk._format_layoutlist([('a', None)], indent=0)
+        self.assertEqual(smallest,
+            ttk._format_layoutlist([('a', '')], indent=0))
+        self.assertEqual(smallest[0], 'a')
+
+        # testing indentation levels
+        self.assertEqual(sample(), sample_expected())
+        for i in range(4):
+            self.assertEqual(sample(i), sample_expected(i))
+            self.assertEqual(sample(i, i), sample_expected(i, i))
+
+        # invalid layout format, different kind of exceptions will be
+        # raised by internal functions
+
+        # plain wrong format
+        self.assertRaises(ValueError, ttk._format_layoutlist,
+            ['bad', 'format'])
+        # will try to use iteritems in the 'bad' string
+        self.assertRaises(AttributeError, ttk._format_layoutlist,
+           [('name', 'bad')])
+        # bad children formatting
+        self.assertRaises(ValueError, ttk._format_layoutlist,
+            [('name', {'children': {'a': None}})])
+
+
+    def test_script_from_settings(self):
+        # empty options
+        self.assertFalse(ttk._script_from_settings({'name':
+            {'configure': None, 'map': None, 'element create': None}}))
+
+        # empty layout
+        self.assertEqual(
+            ttk._script_from_settings({'name': {'layout': None}}),
+            "ttk::style layout name {\nnull\n}")
+
+        configdict = {'αβγ': True, 'á': False}
+        self.assertTrue(
+            ttk._script_from_settings({'name': {'configure': configdict}}))
+
+        mapdict = {'üñíćódè': [('á', 'vãl')]}
+        self.assertTrue(
+            ttk._script_from_settings({'name': {'map': mapdict}}))
+
+        # invalid image element
+        self.assertRaises(IndexError,
+            ttk._script_from_settings, {'name': {'element create': ['image']}})
+
+        # minimal valid image
+        self.assertTrue(ttk._script_from_settings({'name':
+            {'element create': ['image', 'name']}}))
+
+        image = {'thing': {'element create':
+            ['image', 'name', ('state1', 'state2', 'val')]}}
+        self.assertEqual(ttk._script_from_settings(image),
+            "ttk::style element create thing image {name {state1 state2} val} ")
+
+        image['thing']['element create'].append({'opt': 30})
+        self.assertEqual(ttk._script_from_settings(image),
+            "ttk::style element create thing image {name {state1 state2} val} "
+            "-opt 30")
+
+        image['thing']['element create'][-1]['opt'] = [MockTclObj(3),
+            MockTclObj('2m')]
+        self.assertEqual(ttk._script_from_settings(image),
+            "ttk::style element create thing image {name {state1 state2} val} "
+            "-opt {3 2m}")
+
+
+    def test_tclobj_to_py(self):
+        self.assertEqual(
+            ttk._tclobj_to_py((MockStateSpec('a', 'b'), 'val')),
+            [('a', 'b', 'val')])
+        self.assertEqual(
+            ttk._tclobj_to_py([MockTclObj('1'), 2, MockTclObj('3m')]),
+            [1, 2, '3m'])
+
+
+    def test_list_from_statespec(self):
+        def test_it(sspec, value, res_value, states):
+            self.assertEqual(ttk._list_from_statespec(
+                (sspec, value)), [states + (res_value, )])
+
+        states_even = tuple('state%d' % i for i in range(6))
+        statespec = MockStateSpec(*states_even)
+        test_it(statespec, 'val', 'val', states_even)
+        test_it(statespec, MockTclObj('val'), 'val', states_even)
+
+        states_odd = tuple('state%d' % i for i in range(5))
+        statespec = MockStateSpec(*states_odd)
+        test_it(statespec, 'val', 'val', states_odd)
+
+        test_it(('a', 'b', 'c'), MockTclObj('val'), 'val', ('a', 'b', 'c'))
+
+
+    def test_list_from_layouttuple(self):
+        tk = MockTkApp()
+
+        # empty layout tuple
+        self.assertFalse(ttk._list_from_layouttuple(tk, ()))
+
+        # shortest layout tuple
+        self.assertEqual(ttk._list_from_layouttuple(tk, ('name', )),
+            [('name', {})])
+
+        # not so interesting ltuple
+        sample_ltuple = ('name', '-option', 'value')
+        self.assertEqual(ttk._list_from_layouttuple(tk, sample_ltuple),
+            [('name', {'option': 'value'})])
+
+        # empty children
+        self.assertEqual(ttk._list_from_layouttuple(tk,
+            ('something', '-children', ())),
+            [('something', {'children': []})]
+        )
+
+        # more interesting ltuple
+        ltuple = (
+            'name', '-option', 'niceone', '-children', (
+                ('otherone', '-children', (
+                    ('child', )), '-otheropt', 'othervalue'
+                )
+            )
+        )
+        self.assertEqual(ttk._list_from_layouttuple(tk, ltuple),
+            [('name', {'option': 'niceone', 'children':
+                [('otherone', {'otheropt': 'othervalue', 'children':
+                    [('child', {})]
+                })]
+            })]
+        )
+
+        # bad tuples
+        self.assertRaises(ValueError, ttk._list_from_layouttuple, tk,
+            ('name', 'no_minus'))
+        self.assertRaises(ValueError, ttk._list_from_layouttuple, tk,
+            ('name', 'no_minus', 'value'))
+        self.assertRaises(ValueError, ttk._list_from_layouttuple, tk,
+            ('something', '-children')) # no children
+
+
+    def test_val_or_dict(self):
+        def func(res, opt=None, val=None):
+            if opt is None:
+                return res
+            if val is None:
+                return "test val"
+            return (opt, val)
+
+        tk = MockTkApp()
+        tk.call = func
+
+        self.assertEqual(ttk._val_or_dict(tk, {}, '-test:3'),
+                         {'test': '3'})
+        self.assertEqual(ttk._val_or_dict(tk, {}, ('-test', 3)),
+                         {'test': 3})
+
+        self.assertEqual(ttk._val_or_dict(tk, {'test': None}, 'x:y'),
+                         'test val')
+
+        self.assertEqual(ttk._val_or_dict(tk, {'test': 3}, 'x:y'),
+                         {'test': 3})
+
+
+    def test_convert_stringval(self):
+        tests = (
+            (0, 0), ('09', 9), ('a', 'a'), ('áÚ', 'áÚ'), ([], '[]'),
+            (None, 'None')
+        )
+        for orig, expected in tests:
+            self.assertEqual(ttk._convert_stringval(orig), expected)
+
+
+class TclObjsToPyTest(unittest.TestCase):
+
+    def test_unicode(self):
+        adict = {'opt': 'välúè'}
+        self.assertEqual(ttk.tclobjs_to_py(adict), {'opt': 'välúè'})
+
+        adict['opt'] = MockTclObj(adict['opt'])
+        self.assertEqual(ttk.tclobjs_to_py(adict), {'opt': 'välúè'})
+
+    def test_multivalues(self):
+        adict = {'opt': [1, 2, 3, 4]}
+        self.assertEqual(ttk.tclobjs_to_py(adict), {'opt': [1, 2, 3, 4]})
+
+        adict['opt'] = [1, 'xm', 3]
+        self.assertEqual(ttk.tclobjs_to_py(adict), {'opt': [1, 'xm', 3]})
+
+        adict['opt'] = (MockStateSpec('a', 'b'), 'válũè')
+        self.assertEqual(ttk.tclobjs_to_py(adict),
+            {'opt': [('a', 'b', 'válũè')]})
+
+        self.assertEqual(ttk.tclobjs_to_py({'x': ['y z']}),
+            {'x': ['y z']})
+
+    def test_nosplit(self):
+        self.assertEqual(ttk.tclobjs_to_py({'text': 'some text'}),
+            {'text': 'some text'})
 
-def test_main():
-    support.run_unittest(
-            *runtktests.get_tests(gui=False, packages=['test_ttk']))
 
 if __name__ == '__main__':
-    test_main()
+    unittest.main()
diff --git a/Lib/tkinter/test/runtktests.py b/Lib/tkinter/test/runtktests.py
deleted file mode 100644
index 33dc54a137..0000000000
--- a/Lib/tkinter/test/runtktests.py
+++ /dev/null
@@ -1,69 +0,0 @@
-"""
-Use this module to get and run all tk tests.
-
-tkinter tests should live in a package inside the directory where this file
-lives, like test_tkinter.
-Extensions also should live in packages following the same rule as above.
-"""
-
-import os
-import importlib
-import test.support
-
-this_dir_path = os.path.abspath(os.path.dirname(__file__))
-
-def is_package(path):
-    for name in os.listdir(path):
-        if name in ('__init__.py', '__init__.pyc'):
-            return True
-    return False
-
-def get_tests_modules(basepath=this_dir_path, gui=True, packages=None):
-    """This will import and yield modules whose names start with test_
-    and are inside packages found in the path starting at basepath.
-
-    If packages is specified it should contain package names that
-    want their tests collected.
-    """
-    py_ext = '.py'
-
-    for dirpath, dirnames, filenames in os.walk(basepath):
-        for dirname in list(dirnames):
-            if dirname[0] == '.':
-                dirnames.remove(dirname)
-
-        if is_package(dirpath) and filenames:
-            pkg_name = dirpath[len(basepath) + len(os.sep):].replace('/', '.')
-            if packages and pkg_name not in packages:
-                continue
-
-            filenames = filter(
-                    lambda x: x.startswith('test_') and x.endswith(py_ext),
-                    filenames)
-
-            for name in filenames:
-                try:
-                    yield importlib.import_module(
-                        ".%s.%s" % (pkg_name, name[:-len(py_ext)]),
-                        "tkinter.test")
-                except test.support.ResourceDenied:
-                    if gui:
-                        raise
-
-def get_tests(text=True, gui=True, packages=None):
-    """Yield all the tests in the modules found by get_tests_modules.
-
-    If nogui is True, only tests that do not require a GUI will be
-    returned."""
-    attrs = []
-    if text:
-        attrs.append('tests_nogui')
-    if gui:
-        attrs.append('tests_gui')
-    for module in get_tests_modules(gui=gui, packages=packages):
-        for attr in attrs:
-            for test in getattr(module, attr, ()):
-                yield test
-
-if __name__ == "__main__":
-    test.support.run_unittest(*get_tests())
diff --git a/Lib/tkinter/test/test_tkinter/test_colorchooser.py b/Lib/tkinter/test/test_tkinter/test_colorchooser.py
index 4798bc9c26..ce6644af44 100644
--- a/Lib/tkinter/test/test_tkinter/test_colorchooser.py
+++ b/Lib/tkinter/test/test_tkinter/test_colorchooser.py
@@ -1,6 +1,6 @@
 import unittest
 import tkinter
-from test.support import requires, run_unittest, swap_attr
+from test.support import requires, swap_attr
 from tkinter.test.support import AbstractTkTest
 from tkinter import colorchooser
 
@@ -37,7 +37,5 @@ class ChooserTest(AbstractTkTest, unittest.TestCase):
                          ((74, 60, 140), '#4a3c8c'))
 
 
-tests_gui = (ChooserTest,)
-
 if __name__ == "__main__":
-    run_unittest(*tests_gui)
+    unittest.main()
diff --git a/Lib/tkinter/test/test_tkinter/test_font.py b/Lib/tkinter/test/test_tkinter/test_font.py
index 0ea7924f5d..9573d4c8a0 100644
--- a/Lib/tkinter/test/test_tkinter/test_font.py
+++ b/Lib/tkinter/test/test_tkinter/test_font.py
@@ -1,7 +1,7 @@
 import unittest
 import tkinter
 from tkinter import font
-from test.support import requires, run_unittest, gc_collect, ALWAYS_EQ
+from test.support import requires, gc_collect, ALWAYS_EQ
 from tkinter.test.support import AbstractTkTest, AbstractDefaultRootTest
 
 requires('gui')
@@ -139,7 +139,5 @@ class DefaultRootTest(AbstractDefaultRootTest, unittest.TestCase):
         self.assertRaises(RuntimeError, font.names)
 
 
-tests_gui = (FontTest, DefaultRootTest)
-
 if __name__ == "__main__":
-    run_unittest(*tests_gui)
+    unittest.main()
diff --git a/Lib/tkinter/test/test_tkinter/test_images.py b/Lib/tkinter/test/test_tkinter/test_images.py
index c798966e0b..9e57f02a69 100644
--- a/Lib/tkinter/test/test_tkinter/test_images.py
+++ b/Lib/tkinter/test/test_tkinter/test_images.py
@@ -375,7 +375,5 @@ class PhotoImageTest(AbstractTkTest, unittest.TestCase):
         self.assertEqual(image.transparency_get(4, 6), False)
 
 
-tests_gui = (MiscTest, DefaultRootTest, BitmapImageTest, PhotoImageTest,)
-
 if __name__ == "__main__":
-    support.run_unittest(*tests_gui)
+    unittest.main()
diff --git a/Lib/tkinter/test/test_tkinter/test_loadtk.py b/Lib/tkinter/test/test_tkinter/test_loadtk.py
index bab7bcd37c..d97ae6d456 100644
--- a/Lib/tkinter/test/test_tkinter/test_loadtk.py
+++ b/Lib/tkinter/test/test_tkinter/test_loadtk.py
@@ -40,7 +40,6 @@ class TkLoadTest(unittest.TestCase):
             self.assertRaises(TclError, tcl.winfo_geometry)
             self.assertRaises(TclError, tcl.loadtk)
 
-tests_gui = (TkLoadTest, )
 
 if __name__ == "__main__":
-    test_support.run_unittest(*tests_gui)
+    unittest.main()
diff --git a/Lib/tkinter/test/test_tkinter/test_misc.py b/Lib/tkinter/test/test_tkinter/test_misc.py
index f6e5b4db1a..554ae74d6b 100644
--- a/Lib/tkinter/test/test_tkinter/test_misc.py
+++ b/Lib/tkinter/test/test_tkinter/test_misc.py
@@ -339,7 +339,5 @@ class DefaultRootTest(AbstractDefaultRootTest, unittest.TestCase):
         self.assertRaises(RuntimeError, tkinter.mainloop)
 
 
-tests_gui = (MiscTest, DefaultRootTest)
-
 if __name__ == "__main__":
-    support.run_unittest(*tests_gui)
+    unittest.main()
diff --git a/Lib/tkinter/test/test_tkinter/test_simpledialog.py b/Lib/tkinter/test/test_tkinter/test_simpledialog.py
index 9119172588..6d77ea6331 100644
--- a/Lib/tkinter/test/test_tkinter/test_simpledialog.py
+++ b/Lib/tkinter/test/test_tkinter/test_simpledialog.py
@@ -1,6 +1,6 @@
 import unittest
 import tkinter
-from test.support import requires, run_unittest, swap_attr
+from test.support import requires, swap_attr
 from tkinter.test.support import AbstractDefaultRootTest
 from tkinter.simpledialog import Dialog, askinteger
 
@@ -19,7 +19,5 @@ class DefaultRootTest(AbstractDefaultRootTest, unittest.TestCase):
         self.assertRaises(RuntimeError, askinteger, "Go To Line", "Line number")
 
 
-tests_gui = (DefaultRootTest,)
-
 if __name__ == "__main__":
-    run_unittest(*tests_gui)
+    unittest.main()
diff --git a/Lib/tkinter/test/test_tkinter/test_text.py b/Lib/tkinter/test/test_tkinter/test_text.py
index 13b7c56a39..482f150df5 100644
--- a/Lib/tkinter/test/test_tkinter/test_text.py
+++ b/Lib/tkinter/test/test_tkinter/test_text.py
@@ -1,6 +1,6 @@
 import unittest
 import tkinter
-from test.support import requires, run_unittest
+from test.support import requires
 from tkinter.test.support import AbstractTkTest
 
 requires('gui')
@@ -41,7 +41,5 @@ class TextTest(AbstractTkTest, unittest.TestCase):
         self.assertEqual(text.search('test', '1.0', 'end'), '1.3')
 
 
-tests_gui = (TextTest, )
-
 if __name__ == "__main__":
-    run_unittest(*tests_gui)
+    unittest.main()
diff --git a/Lib/tkinter/test/test_tkinter/test_variables.py b/Lib/tkinter/test/test_tkinter/test_variables.py
index 0be5282a3a..427e168454 100644
--- a/Lib/tkinter/test/test_tkinter/test_variables.py
+++ b/Lib/tkinter/test/test_tkinter/test_variables.py
@@ -338,10 +338,5 @@ class DefaultRootTest(AbstractDefaultRootTest, unittest.TestCase):
         self.assertRaises(RuntimeError, Variable)
 
 
-tests_gui = (TestVariable, TestStringVar, TestIntVar,
-             TestDoubleVar, TestBooleanVar, DefaultRootTest)
-
-
 if __name__ == "__main__":
-    from test.support import run_unittest
-    run_unittest(*tests_gui)
+    unittest.main()
diff --git a/Lib/tkinter/test/test_ttk/test_extensions.py b/Lib/tkinter/test/test_ttk/test_extensions.py
index e6b3eccf7a..438d21d0b3 100644
--- a/Lib/tkinter/test/test_ttk/test_extensions.py
+++ b/Lib/tkinter/test/test_ttk/test_extensions.py
@@ -2,7 +2,7 @@ import sys
 import unittest
 import tkinter
 from tkinter import ttk
-from test.support import requires, run_unittest, gc_collect
+from test.support import requires, gc_collect
 from tkinter.test.support import AbstractTkTest, AbstractDefaultRootTest
 
 requires('gui')
@@ -308,7 +308,5 @@ class DefaultRootTest(AbstractDefaultRootTest, unittest.TestCase):
         self._test_widget(ttk.LabeledScale)
 
 
-tests_gui = (LabeledScaleTest, OptionMenuTest, DefaultRootTest)
-
 if __name__ == "__main__":
-    run_unittest(*tests_gui)
+    unittest.main()
diff --git a/Lib/tkinter/test/test_ttk/test_functions.py b/Lib/tkinter/test/test_ttk/test_functions.py
deleted file mode 100644
index 5c23d6fecf..0000000000
--- a/Lib/tkinter/test/test_ttk/test_functions.py
+++ /dev/null
@@ -1,460 +0,0 @@
-# -*- encoding: utf-8 -*-
-import unittest
-from tkinter import ttk
-
-class MockTkApp:
-
-    def splitlist(self, arg):
-        if isinstance(arg, tuple):
-            return arg
-        return arg.split(':')
-
-    def wantobjects(self):
-        return True
-
-
-class MockTclObj(object):
-    typename = 'test'
-
-    def __init__(self, val):
-        self.val = val
-
-    def __str__(self):
-        return str(self.val)
-
-
-class MockStateSpec(object):
-    typename = 'StateSpec'
-
-    def __init__(self, *args):
-        self.val = args
-
-    def __str__(self):
-        return ' '.join(self.val)
-
-
-class InternalFunctionsTest(unittest.TestCase):
-
-    def test_format_optdict(self):
-        def check_against(fmt_opts, result):
-            for i in range(0, len(fmt_opts), 2):
-                self.assertEqual(result.pop(fmt_opts[i]), fmt_opts[i + 1])
-            if result:
-                self.fail("result still got elements: %s" % result)
-
-        # passing an empty dict should return an empty object (tuple here)
-        self.assertFalse(ttk._format_optdict({}))
-
-        # check list formatting
-        check_against(
-            ttk._format_optdict({'fg': 'blue', 'padding': [1, 2, 3, 4]}),
-            {'-fg': 'blue', '-padding': '1 2 3 4'})
-
-        # check tuple formatting (same as list)
-        check_against(
-            ttk._format_optdict({'test': (1, 2, '', 0)}),
-            {'-test': '1 2 {} 0'})
-
-        # check untouched values
-        check_against(
-            ttk._format_optdict({'test': {'left': 'as is'}}),
-            {'-test': {'left': 'as is'}})
-
-        # check script formatting
-        check_against(
-            ttk._format_optdict(
-                {'test': [1, -1, '', '2m', 0], 'test2': 3,
-                 'test3': '', 'test4': 'abc def',
-                 'test5': '"abc"', 'test6': '{}',
-                 'test7': '} -spam {'}, script=True),
-            {'-test': '{1 -1 {} 2m 0}', '-test2': '3',
-             '-test3': '{}', '-test4': '{abc def}',
-             '-test5': '{"abc"}', '-test6': r'\{\}',
-             '-test7': r'\}\ -spam\ \{'})
-
-        opts = {'αβγ': True, 'á': False}
-        orig_opts = opts.copy()
-        # check if giving unicode keys is fine
-        check_against(ttk._format_optdict(opts), {'-αβγ': True, '-á': False})
-        # opts should remain unchanged
-        self.assertEqual(opts, orig_opts)
-
-        # passing values with spaces inside a tuple/list
-        check_against(
-            ttk._format_optdict(
-                {'option': ('one two', 'three')}),
-            {'-option': '{one two} three'})
-        check_against(
-            ttk._format_optdict(
-                {'option': ('one\ttwo', 'three')}),
-            {'-option': '{one\ttwo} three'})
-
-        # passing empty strings inside a tuple/list
-        check_against(
-            ttk._format_optdict(
-                {'option': ('', 'one')}),
-            {'-option': '{} one'})
-
-        # passing values with braces inside a tuple/list
-        check_against(
-            ttk._format_optdict(
-                {'option': ('one} {two', 'three')}),
-            {'-option': r'one\}\ \{two three'})
-
-        # passing quoted strings inside a tuple/list
-        check_against(
-            ttk._format_optdict(
-                {'option': ('"one"', 'two')}),
-            {'-option': '{"one"} two'})
-        check_against(
-            ttk._format_optdict(
-                {'option': ('{one}', 'two')}),
-            {'-option': r'\{one\} two'})
-
-        # ignore an option
-        amount_opts = len(ttk._format_optdict(opts, ignore=('á'))) / 2
-        self.assertEqual(amount_opts, len(opts) - 1)
-
-        # ignore non-existing options
-        amount_opts = len(ttk._format_optdict(opts, ignore=('á', 'b'))) / 2
-        self.assertEqual(amount_opts, len(opts) - 1)
-
-        # ignore every option
-        self.assertFalse(ttk._format_optdict(opts, ignore=list(opts.keys())))
-
-
-    def test_format_mapdict(self):
-        opts = {'a': [('b', 'c', 'val'), ('d', 'otherval'), ('', 'single')]}
-        result = ttk._format_mapdict(opts)
-        self.assertEqual(len(result), len(list(opts.keys())) * 2)
-        self.assertEqual(result, ('-a', '{b c} val d otherval {} single'))
-        self.assertEqual(ttk._format_mapdict(opts, script=True),
-            ('-a', '{{b c} val d otherval {} single}'))
-
-        self.assertEqual(ttk._format_mapdict({2: []}), ('-2', ''))
-
-        opts = {'üñíćódè': [('á', 'vãl')]}
-        result = ttk._format_mapdict(opts)
-        self.assertEqual(result, ('-üñíćódè', 'á vãl'))
-
-        self.assertEqual(ttk._format_mapdict({'opt': [('value',)]}),
-                         ('-opt', '{} value'))
-
-        # empty states
-        valid = {'opt': [('', '', 'hi')]}
-        self.assertEqual(ttk._format_mapdict(valid), ('-opt', '{ } hi'))
-
-        # when passing multiple states, they all must be strings
-        invalid = {'opt': [(1, 2, 'valid val')]}
-        self.assertRaises(TypeError, ttk._format_mapdict, invalid)
-        invalid = {'opt': [([1], '2', 'valid val')]}
-        self.assertRaises(TypeError, ttk._format_mapdict, invalid)
-        # but when passing a single state, it can be anything
-        valid = {'opt': [[1, 'value']]}
-        self.assertEqual(ttk._format_mapdict(valid), ('-opt', '1 value'))
-        # special attention to single states which evaluate to False
-        for stateval in (None, 0, False, '', set()): # just some samples
-            valid = {'opt': [(stateval, 'value')]}
-            self.assertEqual(ttk._format_mapdict(valid),
-                ('-opt', '{} value'))
-
-        # values must be iterable
-        opts = {'a': None}
-        self.assertRaises(TypeError, ttk._format_mapdict, opts)
-
-
-    def test_format_elemcreate(self):
-        self.assertTrue(ttk._format_elemcreate(None), (None, ()))
-
-        ## Testing type = image
-        # image type expects at least an image name, so this should raise
-        # IndexError since it tries to access the index 0 of an empty tuple
-        self.assertRaises(IndexError, ttk._format_elemcreate, 'image')
-
-        # don't format returned values as a tcl script
-        # minimum acceptable for image type
-        self.assertEqual(ttk._format_elemcreate('image', False, 'test'),
-            ("test ", ()))
-        # specifying a state spec
-        self.assertEqual(ttk._format_elemcreate('image', False, 'test',
-            ('', 'a')), ("test {} a", ()))
-        # state spec with multiple states
-        self.assertEqual(ttk._format_elemcreate('image', False, 'test',
-            ('a', 'b', 'c')), ("test {a b} c", ()))
-        # state spec and options
-        self.assertEqual(ttk._format_elemcreate('image', False, 'test',
-            ('a', 'b'), a='x'), ("test a b", ("-a", "x")))
-        # format returned values as a tcl script
-        # state spec with multiple states and an option with a multivalue
-        self.assertEqual(ttk._format_elemcreate('image', True, 'test',
-            ('a', 'b', 'c', 'd'), x=[2, 3]), ("{test {a b c} d}", "-x {2 3}"))
-
-        ## Testing type = vsapi
-        # vsapi type expects at least a class name and a part_id, so this
-        # should raise a ValueError since it tries to get two elements from
-        # an empty tuple
-        self.assertRaises(ValueError, ttk._format_elemcreate, 'vsapi')
-
-        # don't format returned values as a tcl script
-        # minimum acceptable for vsapi
-        self.assertEqual(ttk._format_elemcreate('vsapi', False, 'a', 'b'),
-            ("a b ", ()))
-        # now with a state spec with multiple states
-        self.assertEqual(ttk._format_elemcreate('vsapi', False, 'a', 'b',
-            ('a', 'b', 'c')), ("a b {a b} c", ()))
-        # state spec and option
-        self.assertEqual(ttk._format_elemcreate('vsapi', False, 'a', 'b',
-            ('a', 'b'), opt='x'), ("a b a b", ("-opt", "x")))
-        # format returned values as a tcl script
-        # state spec with a multivalue and an option
-        self.assertEqual(ttk._format_elemcreate('vsapi', True, 'a', 'b',
-            ('a', 'b', [1, 2]), opt='x'), ("{a b {a b} {1 2}}", "-opt x"))
-
-        # Testing type = from
-        # from type expects at least a type name
-        self.assertRaises(IndexError, ttk._format_elemcreate, 'from')
-
-        self.assertEqual(ttk._format_elemcreate('from', False, 'a'),
-            ('a', ()))
-        self.assertEqual(ttk._format_elemcreate('from', False, 'a', 'b'),
-            ('a', ('b', )))
-        self.assertEqual(ttk._format_elemcreate('from', True, 'a', 'b'),
-            ('{a}', 'b'))
-
-
-    def test_format_layoutlist(self):
-        def sample(indent=0, indent_size=2):
-            return ttk._format_layoutlist(
-            [('a', {'other': [1, 2, 3], 'children':
-                [('b', {'children':
-                    [('c', {'children':
-                        [('d', {'nice': 'opt'})], 'something': (1, 2)
-                    })]
-                })]
-            })], indent=indent, indent_size=indent_size)[0]
-
-        def sample_expected(indent=0, indent_size=2):
-            spaces = lambda amount=0: ' ' * (amount + indent)
-            return (
-                "%sa -other {1 2 3} -children {\n"
-                "%sb -children {\n"
-                "%sc -something {1 2} -children {\n"
-                "%sd -nice opt\n"
-                "%s}\n"
-                "%s}\n"
-                "%s}" % (spaces(), spaces(indent_size),
-                    spaces(2 * indent_size), spaces(3 * indent_size),
-                    spaces(2 * indent_size), spaces(indent_size), spaces()))
-
-        # empty layout
-        self.assertEqual(ttk._format_layoutlist([])[0], '')
-
-        # _format_layoutlist always expects the second item (in every item)
-        # to act like a dict (except when the value evaluates to False).
-        self.assertRaises(AttributeError,
-            ttk._format_layoutlist, [('a', 'b')])
-
-        smallest = ttk._format_layoutlist([('a', None)], indent=0)
-        self.assertEqual(smallest,
-            ttk._format_layoutlist([('a', '')], indent=0))
-        self.assertEqual(smallest[0], 'a')
-
-        # testing indentation levels
-        self.assertEqual(sample(), sample_expected())
-        for i in range(4):
-            self.assertEqual(sample(i), sample_expected(i))
-            self.assertEqual(sample(i, i), sample_expected(i, i))
-
-        # invalid layout format, different kind of exceptions will be
-        # raised by internal functions
-
-        # plain wrong format
-        self.assertRaises(ValueError, ttk._format_layoutlist,
-            ['bad', 'format'])
-        # will try to use iteritems in the 'bad' string
-        self.assertRaises(AttributeError, ttk._format_layoutlist,
-           [('name', 'bad')])
-        # bad children formatting
-        self.assertRaises(ValueError, ttk._format_layoutlist,
-            [('name', {'children': {'a': None}})])
-
-
-    def test_script_from_settings(self):
-        # empty options
-        self.assertFalse(ttk._script_from_settings({'name':
-            {'configure': None, 'map': None, 'element create': None}}))
-
-        # empty layout
-        self.assertEqual(
-            ttk._script_from_settings({'name': {'layout': None}}),
-            "ttk::style layout name {\nnull\n}")
-
-        configdict = {'αβγ': True, 'á': False}
-        self.assertTrue(
-            ttk._script_from_settings({'name': {'configure': configdict}}))
-
-        mapdict = {'üñíćódè': [('á', 'vãl')]}
-        self.assertTrue(
-            ttk._script_from_settings({'name': {'map': mapdict}}))
-
-        # invalid image element
-        self.assertRaises(IndexError,
-            ttk._script_from_settings, {'name': {'element create': ['image']}})
-
-        # minimal valid image
-        self.assertTrue(ttk._script_from_settings({'name':
-            {'element create': ['image', 'name']}}))
-
-        image = {'thing': {'element create':
-            ['image', 'name', ('state1', 'state2', 'val')]}}
-        self.assertEqual(ttk._script_from_settings(image),
-            "ttk::style element create thing image {name {state1 state2} val} ")
-
-        image['thing']['element create'].append({'opt': 30})
-        self.assertEqual(ttk._script_from_settings(image),
-            "ttk::style element create thing image {name {state1 state2} val} "
-            "-opt 30")
-
-        image['thing']['element create'][-1]['opt'] = [MockTclObj(3),
-            MockTclObj('2m')]
-        self.assertEqual(ttk._script_from_settings(image),
-            "ttk::style element create thing image {name {state1 state2} val} "
-            "-opt {3 2m}")
-
-
-    def test_tclobj_to_py(self):
-        self.assertEqual(
-            ttk._tclobj_to_py((MockStateSpec('a', 'b'), 'val')),
-            [('a', 'b', 'val')])
-        self.assertEqual(
-            ttk._tclobj_to_py([MockTclObj('1'), 2, MockTclObj('3m')]),
-            [1, 2, '3m'])
-
-
-    def test_list_from_statespec(self):
-        def test_it(sspec, value, res_value, states):
-            self.assertEqual(ttk._list_from_statespec(
-                (sspec, value)), [states + (res_value, )])
-
-        states_even = tuple('state%d' % i for i in range(6))
-        statespec = MockStateSpec(*states_even)
-        test_it(statespec, 'val', 'val', states_even)
-        test_it(statespec, MockTclObj('val'), 'val', states_even)
-
-        states_odd = tuple('state%d' % i for i in range(5))
-        statespec = MockStateSpec(*states_odd)
-        test_it(statespec, 'val', 'val', states_odd)
-
-        test_it(('a', 'b', 'c'), MockTclObj('val'), 'val', ('a', 'b', 'c'))
-
-
-    def test_list_from_layouttuple(self):
-        tk = MockTkApp()
-
-        # empty layout tuple
-        self.assertFalse(ttk._list_from_layouttuple(tk, ()))
-
-        # shortest layout tuple
-        self.assertEqual(ttk._list_from_layouttuple(tk, ('name', )),
-            [('name', {})])
-
-        # not so interesting ltuple
-        sample_ltuple = ('name', '-option', 'value')
-        self.assertEqual(ttk._list_from_layouttuple(tk, sample_ltuple),
-            [('name', {'option': 'value'})])
-
-        # empty children
-        self.assertEqual(ttk._list_from_layouttuple(tk,
-            ('something', '-children', ())),
-            [('something', {'children': []})]
-        )
-
-        # more interesting ltuple
-        ltuple = (
-            'name', '-option', 'niceone', '-children', (
-                ('otherone', '-children', (
-                    ('child', )), '-otheropt', 'othervalue'
-                )
-            )
-        )
-        self.assertEqual(ttk._list_from_layouttuple(tk, ltuple),
-            [('name', {'option': 'niceone', 'children':
-                [('otherone', {'otheropt': 'othervalue', 'children':
-                    [('child', {})]
-                })]
-            })]
-        )
-
-        # bad tuples
-        self.assertRaises(ValueError, ttk._list_from_layouttuple, tk,
-            ('name', 'no_minus'))
-        self.assertRaises(ValueError, ttk._list_from_layouttuple, tk,
-            ('name', 'no_minus', 'value'))
-        self.assertRaises(ValueError, ttk._list_from_layouttuple, tk,
-            ('something', '-children')) # no children
-
-
-    def test_val_or_dict(self):
-        def func(res, opt=None, val=None):
-            if opt is None:
-                return res
-            if val is None:
-                return "test val"
-            return (opt, val)
-
-        tk = MockTkApp()
-        tk.call = func
-
-        self.assertEqual(ttk._val_or_dict(tk, {}, '-test:3'),
-                         {'test': '3'})
-        self.assertEqual(ttk._val_or_dict(tk, {}, ('-test', 3)),
-                         {'test': 3})
-
-        self.assertEqual(ttk._val_or_dict(tk, {'test': None}, 'x:y'),
-                         'test val')
-
-        self.assertEqual(ttk._val_or_dict(tk, {'test': 3}, 'x:y'),
-                         {'test': 3})
-
-
-    def test_convert_stringval(self):
-        tests = (
-            (0, 0), ('09', 9), ('a', 'a'), ('áÚ', 'áÚ'), ([], '[]'),
-            (None, 'None')
-        )
-        for orig, expected in tests:
-            self.assertEqual(ttk._convert_stringval(orig), expected)
-
-
-class TclObjsToPyTest(unittest.TestCase):
-
-    def test_unicode(self):
-        adict = {'opt': 'välúè'}
-        self.assertEqual(ttk.tclobjs_to_py(adict), {'opt': 'välúè'})
-
-        adict['opt'] = MockTclObj(adict['opt'])
-        self.assertEqual(ttk.tclobjs_to_py(adict), {'opt': 'välúè'})
-
-    def test_multivalues(self):
-        adict = {'opt': [1, 2, 3, 4]}
-        self.assertEqual(ttk.tclobjs_to_py(adict), {'opt': [1, 2, 3, 4]})
-
-        adict['opt'] = [1, 'xm', 3]
-        self.assertEqual(ttk.tclobjs_to_py(adict), {'opt': [1, 'xm', 3]})
-
-        adict['opt'] = (MockStateSpec('a', 'b'), 'válũè')
-        self.assertEqual(ttk.tclobjs_to_py(adict),
-            {'opt': [('a', 'b', 'válũè')]})
-
-        self.assertEqual(ttk.tclobjs_to_py({'x': ['y z']}),
-            {'x': ['y z']})
-
-    def test_nosplit(self):
-        self.assertEqual(ttk.tclobjs_to_py({'text': 'some text'}),
-            {'text': 'some text'})
-
-tests_nogui = (InternalFunctionsTest, TclObjsToPyTest)
-
-if __name__ == "__main__":
-    from test.support import run_unittest
-    run_unittest(*tests_nogui)
diff --git a/Lib/tkinter/test/test_ttk/test_style.py b/Lib/tkinter/test/test_ttk/test_style.py
index 38d70d7a89..a33c24ac55 100644
--- a/Lib/tkinter/test/test_ttk/test_style.py
+++ b/Lib/tkinter/test/test_ttk/test_style.py
@@ -3,7 +3,7 @@ import sys
 import tkinter
 from tkinter import ttk
 from test import support
-from test.support import requires, run_unittest
+from test.support import requires
 from tkinter.test.support import AbstractTkTest
 
 requires('gui')
@@ -175,7 +175,5 @@ class StyleTest(AbstractTkTest, unittest.TestCase):
                         self.assertEqual(style.map(newname, key), value)
 
 
-tests_gui = (StyleTest, )
-
 if __name__ == "__main__":
-    run_unittest(*tests_gui)
+    unittest.main()
diff --git a/Lib/tkinter/test/test_ttk/test_widgets.py b/Lib/tkinter/test/test_ttk/test_widgets.py
index 082da5d0c1..a2a4de2e5c 100644
--- a/Lib/tkinter/test/test_ttk/test_widgets.py
+++ b/Lib/tkinter/test/test_ttk/test_widgets.py
@@ -4,7 +4,7 @@ from tkinter import ttk, TclError
 from test.support import requires, gc_collect
 import sys
 
-from tkinter.test.test_ttk.test_functions import MockTclObj
+from test.test_ttk_textonly import MockTclObj
 from tkinter.test.support import (AbstractTkTest, tcl_version, get_tk_patchlevel,
                                   simulate_mouse_click, AbstractDefaultRootTest)
 from tkinter.test.widget_tests import (add_standard_options, noconv,
diff --git a/PCbuild/lib.pyproj b/PCbuild/lib.pyproj
index f0c51edb9d..0fc2aa042d 100644
--- a/PCbuild/lib.pyproj
+++ b/PCbuild/lib.pyproj
@@ -1430,7 +1430,6 @@
     <Compile Include="tkinter\messagebox.py" />
     <Compile Include="tkinter\scrolledtext.py" />
     <Compile Include="tkinter\simpledialog.py" />
-    <Compile Include="tkinter\test\runtktests.py" />
     <Compile Include="tkinter\test\support.py" />
     <Compile Include="tkinter\test\test_tkinter\test_font.py" />
     <Compile Include="tkinter\test\test_tkinter\test_geometry_managers.py" />
@@ -1442,7 +1441,6 @@
     <Compile Include="tkinter\test\test_tkinter\test_widgets.py" />
     <Compile Include="tkinter\test\test_tkinter\__init__.py" />
     <Compile Include="tkinter\test\test_ttk\test_extensions.py" />
-    <Compile Include="tkinter\test\test_ttk\test_functions.py" />
     <Compile Include="tkinter\test\test_ttk\test_style.py" />
     <Compile Include="tkinter\test\test_ttk\test_widgets.py" />
     <Compile Include="tkinter\test\test_ttk\__init__.py" />