Removed the Requirement to Install Python and NodeJS (Now Bundled with Borealis)

Dependencies/Python/Lib/test/test_ttk/__init__.py

@@ -0,0 +1,39 @@
+import os.path
+import unittest
+from test import support
+from test.support import import_helper
+
+
+if support.check_sanitizer(address=True, memory=True):
+    raise unittest.SkipTest("Tests involving libX11 can SEGFAULT on ASAN/MSAN builds")
+
+# Skip this test if _tkinter wasn't built.
+import_helper.import_module('_tkinter')
+
+# Skip test if tk cannot be initialized.
+support.requires('gui')
+
+
+import tkinter
+from _tkinter import TclError
+from tkinter import 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(*args):
+    return support.load_package_tests(os.path.dirname(__file__), *args)

Dependencies/Python/Lib/test/test_ttk/__main__.py

@@ -0,0 +1,4 @@
+from . import load_tests
+import unittest
+
+unittest.main()

Dependencies/Python/Lib/test/test_ttk/test_extensions.py

@@ -0,0 +1,330 @@
+import sys
+import unittest
+import tkinter
+from tkinter import ttk
+from test.support import requires, gc_collect
+from test.test_tkinter.support import AbstractTkTest, AbstractDefaultRootTest
+
+requires('gui')
+
+class LabeledScaleTest(AbstractTkTest, unittest.TestCase):
+
+    def tearDown(self):
+        self.root.update_idletasks()
+        super().tearDown()
+
+    def test_widget_destroy(self):
+        # automatically created variable
+        x = ttk.LabeledScale(self.root)
+        var = x._variable._name
+        x.destroy()
+        gc_collect()  # For PyPy or other GCs.
+        self.assertRaises(tkinter.TclError, x.tk.globalgetvar, var)
+
+        # manually created variable
+        myvar = tkinter.DoubleVar(self.root)
+        name = myvar._name
+        x = ttk.LabeledScale(self.root, variable=myvar)
+        x.destroy()
+        if self.wantobjects:
+            self.assertEqual(x.tk.globalgetvar(name), myvar.get())
+        else:
+            self.assertEqual(float(x.tk.globalgetvar(name)), myvar.get())
+        del myvar
+        gc_collect()  # For PyPy or other GCs.
+        self.assertRaises(tkinter.TclError, x.tk.globalgetvar, name)
+
+        # checking that the tracing callback is properly removed
+        myvar = tkinter.IntVar(self.root)
+        # LabeledScale will start tracing myvar
+        x = ttk.LabeledScale(self.root, variable=myvar)
+        x.destroy()
+        # Unless the tracing callback was removed, creating a new
+        # LabeledScale with the same var will cause an error now. This
+        # happens because the variable will be set to (possibly) a new
+        # value which causes the tracing callback to be called and then
+        # it tries calling instance attributes not yet defined.
+        ttk.LabeledScale(self.root, variable=myvar)
+        if hasattr(sys, 'last_exc'):
+            self.assertNotEqual(type(sys.last_exc), tkinter.TclError)
+        elif hasattr(sys, 'last_type'):
+            self.assertNotEqual(sys.last_type, tkinter.TclError)
+
+    def test_initialization(self):
+        # master passing
+        master = tkinter.Frame(self.root)
+        x = ttk.LabeledScale(master)
+        self.assertEqual(x.master, master)
+        x.destroy()
+
+        # variable initialization/passing
+        passed_expected = (('0', 0), (0, 0), (10, 10),
+            (-1, -1), (sys.maxsize + 1, sys.maxsize + 1),
+            (2.5, 2), ('2.5', 2))
+        for pair in passed_expected:
+            x = ttk.LabeledScale(self.root, from_=pair[0])
+            self.assertEqual(x.value, pair[1])
+            x.destroy()
+        x = ttk.LabeledScale(self.root, from_=None)
+        self.assertRaises((ValueError, tkinter.TclError), x._variable.get)
+        x.destroy()
+        # variable should have its default value set to the from_ value
+        myvar = tkinter.DoubleVar(self.root, value=20)
+        x = ttk.LabeledScale(self.root, variable=myvar)
+        self.assertEqual(x.value, 0)
+        x.destroy()
+        # check that it is really using a DoubleVar
+        x = ttk.LabeledScale(self.root, variable=myvar, from_=0.5)
+        self.assertEqual(x.value, 0.5)
+        self.assertEqual(x._variable._name, myvar._name)
+        x.destroy()
+
+        # widget positionment
+        def check_positions(scale, scale_pos, label, label_pos):
+            self.assertEqual(scale.pack_info()['side'], scale_pos)
+            self.assertEqual(label.place_info()['anchor'], label_pos)
+        x = ttk.LabeledScale(self.root, compound='top')
+        check_positions(x.scale, 'bottom', x.label, 'n')
+        x.destroy()
+        x = ttk.LabeledScale(self.root, compound='bottom')
+        check_positions(x.scale, 'top', x.label, 's')
+        x.destroy()
+        # invert default positions
+        x = ttk.LabeledScale(self.root, compound='unknown')
+        check_positions(x.scale, 'top', x.label, 's')
+        x.destroy()
+        x = ttk.LabeledScale(self.root) # take default positions
+        check_positions(x.scale, 'bottom', x.label, 'n')
+        x.destroy()
+
+        # extra, and invalid, kwargs
+        self.assertRaises(tkinter.TclError, ttk.LabeledScale, master, a='b')
+
+
+    def test_horizontal_range(self):
+        lscale = ttk.LabeledScale(self.root, from_=0, to=10)
+        lscale.pack()
+        lscale.update()
+
+        linfo_1 = lscale.label.place_info()
+        prev_xcoord = lscale.scale.coords()[0]
+        self.assertEqual(prev_xcoord, int(linfo_1['x']))
+        # change range to: from -5 to 5. This should change the x coord of
+        # the scale widget, since 0 is at the middle of the new
+        # range.
+        lscale.scale.configure(from_=-5, to=5)
+        # The following update is needed since the test doesn't use mainloop,
+        # at the same time this shouldn't affect test outcome
+        lscale.update()
+        curr_xcoord = lscale.scale.coords()[0]
+        self.assertNotEqual(prev_xcoord, curr_xcoord)
+        # the label widget should have been repositioned too
+        linfo_2 = lscale.label.place_info()
+        self.assertEqual(lscale.label['text'], 0 if self.wantobjects else '0')
+        self.assertEqual(curr_xcoord, int(linfo_2['x']))
+        # change the range back
+        lscale.scale.configure(from_=0, to=10)
+        self.assertNotEqual(prev_xcoord, curr_xcoord)
+        self.assertEqual(prev_xcoord, int(linfo_1['x']))
+
+        lscale.destroy()
+
+
+    def test_variable_change(self):
+        x = ttk.LabeledScale(self.root)
+        x.pack()
+        x.update()
+
+        curr_xcoord = x.scale.coords()[0]
+        newval = x.value + 1
+        x.value = newval
+        # The following update is needed since the test doesn't use mainloop,
+        # at the same time this shouldn't affect test outcome
+        x.update()
+        self.assertEqual(x.value, newval)
+        self.assertEqual(x.label['text'],
+                         newval if self.wantobjects else str(newval))
+        self.assertEqual(float(x.scale.get()), newval)
+        self.assertGreater(x.scale.coords()[0], curr_xcoord)
+        self.assertEqual(x.scale.coords()[0],
+            int(x.label.place_info()['x']))
+
+        # value outside range
+        if self.wantobjects:
+            conv = lambda x: x
+        else:
+            conv = int
+        x.value = conv(x.scale['to']) + 1 # no changes shouldn't happen
+        x.update()
+        self.assertEqual(x.value, newval)
+        self.assertEqual(conv(x.label['text']), newval)
+        self.assertEqual(float(x.scale.get()), newval)
+        self.assertEqual(x.scale.coords()[0],
+            int(x.label.place_info()['x']))
+
+        # non-integer value
+        x.value = newval = newval + 1.5
+        x.update()
+        self.assertEqual(x.value, int(newval))
+        self.assertEqual(conv(x.label['text']), int(newval))
+        self.assertEqual(float(x.scale.get()), newval)
+
+        x.destroy()
+
+
+    def test_resize(self):
+        x = ttk.LabeledScale(self.root)
+        x.pack(expand=True, fill='both')
+        gc_collect()  # For PyPy or other GCs.
+        x.update()
+
+        width, height = x.master.winfo_width(), x.master.winfo_height()
+        width_new, height_new = width * 2, height * 2
+
+        x.value = 3
+        x.update()
+        x.master.wm_geometry("%dx%d" % (width_new, height_new))
+        self.assertEqual(int(x.label.place_info()['x']),
+            x.scale.coords()[0])
+
+        # Reset geometry
+        x.master.wm_geometry("%dx%d" % (width, height))
+        x.destroy()
+
+
+class OptionMenuTest(AbstractTkTest, unittest.TestCase):
+
+    def setUp(self):
+        super().setUp()
+        self.textvar = tkinter.StringVar(self.root)
+
+    def tearDown(self):
+        del self.textvar
+        super().tearDown()
+
+
+    def test_widget_destroy(self):
+        var = tkinter.StringVar(self.root)
+        optmenu = ttk.OptionMenu(self.root, var)
+        name = var._name
+        optmenu.update_idletasks()
+        optmenu.destroy()
+        self.assertEqual(optmenu.tk.globalgetvar(name), var.get())
+        del var
+        gc_collect()  # For PyPy or other GCs.
+        self.assertRaises(tkinter.TclError, optmenu.tk.globalgetvar, name)
+
+
+    def test_initialization(self):
+        self.assertRaises(tkinter.TclError,
+            ttk.OptionMenu, self.root, self.textvar, invalid='thing')
+
+        optmenu = ttk.OptionMenu(self.root, self.textvar, 'b', 'a', 'b')
+        self.assertEqual(optmenu._variable.get(), 'b')
+
+        self.assertTrue(optmenu['menu'])
+        self.assertTrue(optmenu['textvariable'])
+
+        optmenu.destroy()
+
+
+    def test_menu(self):
+        items = ('a', 'b', 'c')
+        default = 'a'
+        optmenu = ttk.OptionMenu(self.root, self.textvar, default, *items)
+        found_default = False
+        for i in range(len(items)):
+            value = optmenu['menu'].entrycget(i, 'value')
+            self.assertEqual(value, items[i])
+            if value == default:
+                found_default = True
+        self.assertTrue(found_default)
+        optmenu.destroy()
+
+        # default shouldn't be in menu if it is not part of values
+        default = 'd'
+        optmenu = ttk.OptionMenu(self.root, self.textvar, default, *items)
+        curr = None
+        i = 0
+        while True:
+            last, curr = curr, optmenu['menu'].entryconfigure(i, 'value')
+            if last == curr:
+                # no more menu entries
+                break
+            self.assertNotEqual(curr, default)
+            i += 1
+        self.assertEqual(i, len(items))
+
+        # check that variable is updated correctly
+        optmenu.pack()
+        gc_collect()  # For PyPy or other GCs.
+        optmenu['menu'].invoke(0)
+        self.assertEqual(optmenu._variable.get(), items[0])
+
+        # changing to an invalid index shouldn't change the variable
+        self.assertRaises(tkinter.TclError, optmenu['menu'].invoke, -1)
+        self.assertEqual(optmenu._variable.get(), items[0])
+
+        optmenu.destroy()
+
+        # specifying a callback
+        success = []
+        def cb_test(item):
+            self.assertEqual(item, items[1])
+            success.append(True)
+        optmenu = ttk.OptionMenu(self.root, self.textvar, 'a', command=cb_test,
+            *items)
+        optmenu['menu'].invoke(1)
+        if not success:
+            self.fail("Menu callback not invoked")
+
+        optmenu.destroy()
+
+    def test_unique_radiobuttons(self):
+        # check that radiobuttons are unique across instances (bpo25684)
+        items = ('a', 'b', 'c')
+        default = 'a'
+        optmenu = ttk.OptionMenu(self.root, self.textvar, default, *items)
+        textvar2 = tkinter.StringVar(self.root)
+        optmenu2 = ttk.OptionMenu(self.root, textvar2, default, *items)
+        optmenu.pack()
+        optmenu2.pack()
+        optmenu['menu'].invoke(1)
+        optmenu2['menu'].invoke(2)
+        optmenu_stringvar_name = optmenu['menu'].entrycget(0, 'variable')
+        optmenu2_stringvar_name = optmenu2['menu'].entrycget(0, 'variable')
+        self.assertNotEqual(optmenu_stringvar_name,
+                            optmenu2_stringvar_name)
+        self.assertEqual(self.root.tk.globalgetvar(optmenu_stringvar_name),
+                         items[1])
+        self.assertEqual(self.root.tk.globalgetvar(optmenu2_stringvar_name),
+                         items[2])
+
+        optmenu.destroy()
+        optmenu2.destroy()
+
+    def test_trace_variable(self):
+        # prior to bpo45160, tracing a variable would cause the callback to be made twice
+        success = []
+        items = ('a', 'b', 'c')
+        textvar = tkinter.StringVar(self.root)
+        def cb_test(*args):
+            success.append(textvar.get())
+        optmenu = ttk.OptionMenu(self.root, textvar, "a", *items)
+        optmenu.pack()
+        cb_name = textvar.trace_add("write", cb_test)
+        optmenu['menu'].invoke(1)
+        self.assertEqual(success, ['b'])
+        self.assertEqual(textvar.get(), 'b')
+        textvar.trace_remove("write", cb_name)
+        optmenu.destroy()
+
+
+class DefaultRootTest(AbstractDefaultRootTest, unittest.TestCase):
+
+    def test_labeledscale(self):
+        self._test_widget(ttk.LabeledScale)
+
+
+if __name__ == "__main__":
+    unittest.main()

Dependencies/Python/Lib/test/test_ttk/test_style.py

@@ -0,0 +1,445 @@
+import unittest
+import sys
+import tkinter
+from tkinter import ttk
+from tkinter import TclError
+from test import support
+from test.support import requires
+from test.test_tkinter.support import AbstractTkTest, get_tk_patchlevel
+
+requires('gui')
+
+CLASS_NAMES = [
+    '.', 'ComboboxPopdownFrame', 'Heading',
+    'Horizontal.TProgressbar', 'Horizontal.TScale', 'Item', 'Sash',
+    'TButton', 'TCheckbutton', 'TCombobox', 'TEntry',
+    'TLabelframe', 'TLabelframe.Label', 'TMenubutton',
+    'TNotebook', 'TNotebook.Tab', 'Toolbutton', 'TProgressbar',
+    'TRadiobutton', 'Treeview', 'TScale', 'TScrollbar', 'TSpinbox',
+    'Vertical.TProgressbar', 'Vertical.TScale'
+]
+
+class StyleTest(AbstractTkTest, unittest.TestCase):
+
+    def setUp(self):
+        super().setUp()
+        self.style = ttk.Style(self.root)
+
+
+    def test_configure(self):
+        style = self.style
+        style.configure('TButton', background='yellow')
+        self.assertEqual(style.configure('TButton', 'background'),
+            'yellow')
+        self.assertIsInstance(style.configure('TButton'), dict)
+
+
+    def test_map(self):
+        style = self.style
+
+        # Single state
+        for states in ['active'], [('active',)]:
+            with self.subTest(states=states):
+                style.map('TButton', background=[(*states, 'white')])
+                expected = [('active', 'white')]
+                self.assertEqual(style.map('TButton', 'background'), expected)
+                m = style.map('TButton')
+                self.assertIsInstance(m, dict)
+                self.assertEqual(m['background'], expected)
+
+        # Multiple states
+        for states in ['pressed', '!disabled'], ['pressed !disabled'], [('pressed', '!disabled')]:
+            with self.subTest(states=states):
+                style.map('TButton', background=[(*states, 'black')])
+                expected = [('pressed', '!disabled', 'black')]
+                self.assertEqual(style.map('TButton', 'background'), expected)
+                m = style.map('TButton')
+                self.assertIsInstance(m, dict)
+                self.assertEqual(m['background'], expected)
+
+        # Default state
+        for states in [], [''], [()]:
+            with self.subTest(states=states):
+                style.map('TButton', background=[(*states, 'grey')])
+                expected = [('grey',)]
+                self.assertEqual(style.map('TButton', 'background'), expected)
+                m = style.map('TButton')
+                self.assertIsInstance(m, dict)
+                self.assertEqual(m['background'], expected)
+
+
+    def test_lookup(self):
+        style = self.style
+        style.configure('TButton', background='yellow')
+        style.map('TButton', background=[('active', 'background', 'blue')])
+
+        self.assertEqual(style.lookup('TButton', 'background'), 'yellow')
+        self.assertEqual(style.lookup('TButton', 'background',
+            ['active', 'background']), 'blue')
+        self.assertEqual(style.lookup('TButton', 'optionnotdefined',
+            default='iknewit'), 'iknewit')
+
+
+    def test_layout(self):
+        style = self.style
+        self.assertRaises(tkinter.TclError, style.layout, 'NotALayout')
+        tv_style = style.layout('Treeview')
+
+        # "erase" Treeview layout
+        style.layout('Treeview', '')
+        self.assertEqual(style.layout('Treeview'),
+            [('null', {'sticky': 'nswe'})]
+        )
+
+        # restore layout
+        style.layout('Treeview', tv_style)
+        self.assertEqual(style.layout('Treeview'), tv_style)
+
+        # should return a list
+        self.assertIsInstance(style.layout('TButton'), list)
+
+        # correct layout, but "option" doesn't exist as option
+        self.assertRaises(tkinter.TclError, style.layout, 'Treeview',
+            [('name', {'option': 'inexistent'})])
+
+
+    def test_theme_use(self):
+        self.assertRaises(tkinter.TclError, self.style.theme_use,
+            'nonexistingname')
+
+        curr_theme = self.style.theme_use()
+        new_theme = None
+        for theme in self.style.theme_names():
+            if theme != curr_theme:
+                new_theme = theme
+                self.style.theme_use(theme)
+                break
+        else:
+            # just one theme available, can't go on with tests
+            return
+
+        self.assertFalse(curr_theme == new_theme)
+        self.assertFalse(new_theme != self.style.theme_use())
+
+        self.style.theme_use(curr_theme)
+
+    def test_configure_custom_copy(self):
+        style = self.style
+
+        curr_theme = self.style.theme_use()
+        self.addCleanup(self.style.theme_use, curr_theme)
+        for theme in self.style.theme_names():
+            self.style.theme_use(theme)
+            for name in CLASS_NAMES:
+                default = style.configure(name)
+                if not default:
+                    continue
+                with self.subTest(theme=theme, name=name):
+                    if support.verbose >= 2:
+                        print('configure', theme, name, default)
+                    if (theme in ('vista', 'xpnative')
+                            and sys.getwindowsversion()[:2] == (6, 1)):
+                        # Fails on the Windows 7 buildbot
+                        continue
+                    newname = f'C.{name}'
+                    self.assertEqual(style.configure(newname), None)
+                    style.configure(newname, **default)
+                    self.assertEqual(style.configure(newname), default)
+                    for key, value in default.items():
+                        self.assertEqual(style.configure(newname, key), value)
+
+
+    def test_map_custom_copy(self):
+        style = self.style
+
+        curr_theme = self.style.theme_use()
+        self.addCleanup(self.style.theme_use, curr_theme)
+        for theme in self.style.theme_names():
+            self.style.theme_use(theme)
+            for name in CLASS_NAMES:
+                default = style.map(name)
+                if not default:
+                    continue
+                with self.subTest(theme=theme, name=name):
+                    if support.verbose >= 2:
+                        print('map', theme, name, default)
+                    if (theme in ('vista', 'xpnative')
+                            and sys.getwindowsversion()[:2] == (6, 1)):
+                        # Fails on the Windows 7 buildbot
+                        continue
+                    newname = f'C.{name}'
+                    self.assertEqual(style.map(newname), {})
+                    style.map(newname, **default)
+                    if theme == 'alt' and name == '.' and get_tk_patchlevel(self.root) < (8, 6, 1):
+                        default['embossed'] = [('disabled', '1')]
+                    self.assertEqual(style.map(newname), default)
+                    for key, value in default.items():
+                        self.assertEqual(style.map(newname, key), value)
+
+    def test_element_options(self):
+        style = self.style
+        element_names = style.element_names()
+        self.assertNotIsInstance(element_names, str)
+        for name in element_names:
+            self.assertIsInstance(name, str)
+            element_options = style.element_options(name)
+            self.assertNotIsInstance(element_options, str)
+            for optname in element_options:
+                self.assertIsInstance(optname, str)
+
+    def test_element_create_errors(self):
+        style = self.style
+        with self.assertRaises(TypeError):
+            style.element_create('plain.newelem')
+        with self.assertRaisesRegex(TclError, 'No such element type spam'):
+            style.element_create('plain.newelem', 'spam')
+
+    def test_element_create_from(self):
+        style = self.style
+        style.element_create('plain.background', 'from', 'default')
+        self.assertIn('plain.background', style.element_names())
+        style.element_create('plain.arrow', 'from', 'default', 'rightarrow')
+        self.assertIn('plain.arrow', style.element_names())
+
+    def test_element_create_from_errors(self):
+        style = self.style
+        with self.assertRaises(IndexError):
+            style.element_create('plain.newelem', 'from')
+        with self.assertRaisesRegex(TclError, 'theme "spam" doesn\'t exist'):
+            style.element_create('plain.newelem', 'from', 'spam')
+
+    def test_element_create_image(self):
+        style = self.style
+        image = tkinter.PhotoImage(master=self.root, width=12, height=10)
+        style.element_create('block', 'image', image)
+        self.assertIn('block', style.element_names())
+
+        style.layout('TestLabel1', [('block', {'sticky': 'news'})])
+        a = ttk.Label(self.root, style='TestLabel1')
+        a.pack(expand=True, fill='both')
+        self.assertEqual(a.winfo_reqwidth(), 12)
+        self.assertEqual(a.winfo_reqheight(), 10)
+
+        imgfile = support.findfile('python.xbm', subdir='tkinterdata')
+        img1 = tkinter.BitmapImage(master=self.root, file=imgfile,
+                                   foreground='yellow', background='blue')
+        img2 = tkinter.BitmapImage(master=self.root, file=imgfile,
+                                   foreground='blue', background='yellow')
+        img3 = tkinter.BitmapImage(master=self.root, file=imgfile,
+                                   foreground='white', background='black')
+        style.element_create('TestButton.button', 'image',
+                             img1, ('pressed', img2), ('active', img3),
+                             border=(2, 4), sticky='we')
+        self.assertIn('TestButton.button', style.element_names())
+
+        style.layout('TestButton', [('TestButton.button', {'sticky': 'news'})])
+        b = ttk.Button(self.root, style='TestButton')
+        b.pack(expand=True, fill='both')
+        self.assertEqual(b.winfo_reqwidth(), 16)
+        self.assertEqual(b.winfo_reqheight(), 16)
+
+    def test_element_create_image_errors(self):
+        style = self.style
+        image = tkinter.PhotoImage(master=self.root, width=10, height=10)
+        with self.assertRaises(IndexError):
+            style.element_create('block2', 'image')
+        with self.assertRaises(TypeError):
+            style.element_create('block2', 'image', image, 1)
+        with self.assertRaises(ValueError):
+            style.element_create('block2', 'image', image, ())
+        with self.assertRaisesRegex(TclError, 'Invalid state name'):
+            style.element_create('block2', 'image', image, ('spam', image))
+        with self.assertRaisesRegex(TclError, 'Invalid state name'):
+            style.element_create('block2', 'image', image, (1, image))
+        with self.assertRaises(TypeError):
+            style.element_create('block2', 'image', image, ('pressed', 1, image))
+        with self.assertRaises(TypeError):
+            style.element_create('block2', 'image', image, (1, 'selected', image))
+        with self.assertRaisesRegex(TclError, 'bad option'):
+            style.element_create('block2', 'image', image, spam=1)
+
+    def test_element_create_vsapi_1(self):
+        style = self.style
+        if 'xpnative' not in style.theme_names():
+            self.skipTest("requires 'xpnative' theme")
+        style.element_create('smallclose', 'vsapi', 'WINDOW', 19, [
+                             ('disabled', 4),
+                             ('pressed', 3),
+                             ('active', 2),
+                             ('', 1)])
+        style.layout('CloseButton',
+                     [('CloseButton.smallclose', {'sticky': 'news'})])
+        b = ttk.Button(self.root, style='CloseButton')
+        b.pack(expand=True, fill='both')
+        self.assertEqual(b.winfo_reqwidth(), 13)
+        self.assertEqual(b.winfo_reqheight(), 13)
+
+    def test_element_create_vsapi_2(self):
+        style = self.style
+        if 'xpnative' not in style.theme_names():
+            self.skipTest("requires 'xpnative' theme")
+        style.element_create('pin', 'vsapi', 'EXPLORERBAR', 3, [
+                             ('pressed', '!selected', 3),
+                             ('active', '!selected', 2),
+                             ('pressed', 'selected', 6),
+                             ('active', 'selected', 5),
+                             ('selected', 4),
+                             ('', 1)])
+        style.layout('Explorer.Pin',
+                     [('Explorer.Pin.pin', {'sticky': 'news'})])
+        pin = ttk.Checkbutton(self.root, style='Explorer.Pin')
+        pin.pack(expand=True, fill='both')
+        self.assertEqual(pin.winfo_reqwidth(), 16)
+        self.assertEqual(pin.winfo_reqheight(), 16)
+
+    def test_element_create_vsapi_3(self):
+        style = self.style
+        if 'xpnative' not in style.theme_names():
+            self.skipTest("requires 'xpnative' theme")
+        style.element_create('headerclose', 'vsapi', 'EXPLORERBAR', 2, [
+                             ('pressed', 3),
+                             ('active', 2),
+                             ('', 1)])
+        style.layout('Explorer.CloseButton',
+                     [('Explorer.CloseButton.headerclose', {'sticky': 'news'})])
+        b = ttk.Button(self.root, style='Explorer.CloseButton')
+        b.pack(expand=True, fill='both')
+        self.assertEqual(b.winfo_reqwidth(), 16)
+        self.assertEqual(b.winfo_reqheight(), 16)
+
+    def test_theme_create(self):
+        style = self.style
+        curr_theme = style.theme_use()
+        curr_layout = style.layout('TLabel')
+        style.theme_create('testtheme1')
+        self.assertIn('testtheme1', style.theme_names())
+
+        style.theme_create('testtheme2', settings={
+            'elem' : {'element create': ['from', 'default'],},
+            'TLabel' : {
+                'configure': {'padding': 10},
+                'layout': [('elem', {'sticky': 'we'})],
+            },
+        })
+        self.assertIn('testtheme2', style.theme_names())
+
+        style.theme_create('testtheme3', 'testtheme2')
+        self.assertIn('testtheme3', style.theme_names())
+
+        style.theme_use('testtheme1')
+        self.assertEqual(style.element_names(), ())
+        self.assertEqual(style.layout('TLabel'), curr_layout)
+
+        style.theme_use('testtheme2')
+        self.assertEqual(style.element_names(), ('elem',))
+        self.assertEqual(style.lookup('TLabel', 'padding'), '10')
+        self.assertEqual(style.layout('TLabel'), [('elem', {'sticky': 'we'})])
+
+        style.theme_use('testtheme3')
+        self.assertEqual(style.element_names(), ())
+        self.assertEqual(style.lookup('TLabel', 'padding'), '')
+        self.assertEqual(style.layout('TLabel'), [('elem', {'sticky': 'we'})])
+
+        style.theme_use(curr_theme)
+
+    def test_theme_create_image(self):
+        style = self.style
+        curr_theme = style.theme_use()
+        image = tkinter.PhotoImage(master=self.root, width=10, height=10)
+        new_theme = 'testtheme4'
+        style.theme_create(new_theme, settings={
+            'block' : {
+                'element create': ['image', image, {'width': 120, 'height': 100}],
+            },
+            'TestWidget.block2' : {
+                'element create': ['image', image],
+            },
+            'TestWidget' : {
+                'configure': {
+                    'anchor': 'left',
+                    'padding': (3, 0, 0, 2),
+                    'foreground': 'yellow',
+                },
+                'map': {
+                    'foreground': [
+                        ('pressed', 'red'),
+                        ('active', 'disabled', 'blue'),
+                    ],
+                },
+                'layout': [
+                    ('TestWidget.block', {'sticky': 'we', 'side': 'left'}),
+                    ('TestWidget.border', {
+                        'sticky': 'nsw',
+                        'border': 1,
+                        'children': [
+                            ('TestWidget.block2', {'sticky': 'nswe'})
+                        ]
+                    })
+                ],
+            },
+        })
+
+        style.theme_use(new_theme)
+        self.assertIn('block', style.element_names())
+        self.assertEqual(style.lookup('TestWidget', 'anchor'), 'left')
+        self.assertEqual(style.lookup('TestWidget', 'padding'), '3 0 0 2')
+        self.assertEqual(style.lookup('TestWidget', 'foreground'), 'yellow')
+        self.assertEqual(style.lookup('TestWidget', 'foreground',
+                                      ['active']), 'yellow')
+        self.assertEqual(style.lookup('TestWidget', 'foreground',
+                                      ['active', 'pressed']), 'red')
+        self.assertEqual(style.lookup('TestWidget', 'foreground',
+                                      ['active', 'disabled']), 'blue')
+        self.assertEqual(style.layout('TestWidget'),
+            [
+                ('TestWidget.block', {'side': 'left', 'sticky': 'we'}),
+                ('TestWidget.border', {
+                    'sticky': 'nsw',
+                    'border': '1',
+                    'children': [('TestWidget.block2', {'sticky': 'nswe'})]
+                })
+            ])
+
+        b = ttk.Label(self.root, style='TestWidget')
+        b.pack(expand=True, fill='both')
+        self.assertEqual(b.winfo_reqwidth(), 134)
+        self.assertEqual(b.winfo_reqheight(), 100)
+
+        style.theme_use(curr_theme)
+
+    def test_theme_create_vsapi(self):
+        style = self.style
+        if 'xpnative' not in style.theme_names():
+            self.skipTest("requires 'xpnative' theme")
+        curr_theme = style.theme_use()
+        new_theme = 'testtheme5'
+        style.theme_create(new_theme, settings={
+            'pin' : {
+                'element create': ['vsapi', 'EXPLORERBAR', 3, [
+                                   ('pressed', '!selected', 3),
+                                   ('active', '!selected', 2),
+                                   ('pressed', 'selected', 6),
+                                   ('active', 'selected', 5),
+                                   ('selected', 4),
+                                   ('', 1)]],
+            },
+            'Explorer.Pin' : {
+                'layout': [('Explorer.Pin.pin', {'sticky': 'news'})],
+            },
+        })
+
+        style.theme_use(new_theme)
+        self.assertIn('pin', style.element_names())
+        self.assertEqual(style.layout('Explorer.Pin'),
+                         [('Explorer.Pin.pin', {'sticky': 'nswe'})])
+
+        pin = ttk.Checkbutton(self.root, style='Explorer.Pin')
+        pin.pack(expand=True, fill='both')
+        self.assertEqual(pin.winfo_reqwidth(), 16)
+        self.assertEqual(pin.winfo_reqheight(), 16)
+
+        style.theme_use(curr_theme)
+
+
+if __name__ == "__main__":
+    unittest.main()