add padding function to imgScalePadding()
This commit is contained in:
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -1,68 +0,0 @@
|
||||
import unittest
|
||||
import tkinter
|
||||
from test.support import requires, swap_attr
|
||||
from tkinter.test.support import AbstractDefaultRootTest, AbstractTkTest
|
||||
from tkinter import colorchooser
|
||||
from tkinter.colorchooser import askcolor
|
||||
from tkinter.commondialog import Dialog
|
||||
|
||||
requires('gui')
|
||||
|
||||
|
||||
class ChooserTest(AbstractTkTest, unittest.TestCase):
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
AbstractTkTest.setUpClass.__func__(cls)
|
||||
cls.cc = colorchooser.Chooser(initialcolor='dark blue slate')
|
||||
|
||||
def test_fixoptions(self):
|
||||
cc = self.cc
|
||||
cc._fixoptions()
|
||||
self.assertEqual(cc.options['initialcolor'], 'dark blue slate')
|
||||
|
||||
cc.options['initialcolor'] = '#D2D269691E1E'
|
||||
cc._fixoptions()
|
||||
self.assertEqual(cc.options['initialcolor'], '#D2D269691E1E')
|
||||
|
||||
cc.options['initialcolor'] = (210, 105, 30)
|
||||
cc._fixoptions()
|
||||
self.assertEqual(cc.options['initialcolor'], '#d2691e')
|
||||
|
||||
def test_fixresult(self):
|
||||
cc = self.cc
|
||||
self.assertEqual(cc._fixresult(self.root, ()), (None, None))
|
||||
self.assertEqual(cc._fixresult(self.root, ''), (None, None))
|
||||
self.assertEqual(cc._fixresult(self.root, 'chocolate'),
|
||||
((210, 105, 30), 'chocolate'))
|
||||
self.assertEqual(cc._fixresult(self.root, '#4a3c8c'),
|
||||
((74, 60, 140), '#4a3c8c'))
|
||||
|
||||
|
||||
class DefaultRootTest(AbstractDefaultRootTest, unittest.TestCase):
|
||||
|
||||
def test_askcolor(self):
|
||||
def test_callback(dialog, master):
|
||||
nonlocal ismapped
|
||||
master.update()
|
||||
ismapped = master.winfo_ismapped()
|
||||
raise ZeroDivisionError
|
||||
|
||||
with swap_attr(Dialog, '_test_callback', test_callback):
|
||||
ismapped = None
|
||||
self.assertRaises(ZeroDivisionError, askcolor)
|
||||
#askcolor()
|
||||
self.assertEqual(ismapped, False)
|
||||
|
||||
root = tkinter.Tk()
|
||||
ismapped = None
|
||||
self.assertRaises(ZeroDivisionError, askcolor)
|
||||
self.assertEqual(ismapped, True)
|
||||
root.destroy()
|
||||
|
||||
tkinter.NoDefaultRoot()
|
||||
self.assertRaises(RuntimeError, askcolor)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -1,163 +0,0 @@
|
||||
import unittest
|
||||
import tkinter
|
||||
from tkinter import font
|
||||
from test.support import requires, gc_collect, ALWAYS_EQ
|
||||
from tkinter.test.support import AbstractTkTest, AbstractDefaultRootTest
|
||||
|
||||
requires('gui')
|
||||
|
||||
fontname = "TkDefaultFont"
|
||||
|
||||
class FontTest(AbstractTkTest, unittest.TestCase):
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
AbstractTkTest.setUpClass.__func__(cls)
|
||||
try:
|
||||
cls.font = font.Font(root=cls.root, name=fontname, exists=True)
|
||||
except tkinter.TclError:
|
||||
cls.font = font.Font(root=cls.root, name=fontname, exists=False)
|
||||
|
||||
def test_configure(self):
|
||||
options = self.font.configure()
|
||||
self.assertGreaterEqual(set(options),
|
||||
{'family', 'size', 'weight', 'slant', 'underline', 'overstrike'})
|
||||
for key in options:
|
||||
self.assertEqual(self.font.cget(key), options[key])
|
||||
self.assertEqual(self.font[key], options[key])
|
||||
for key in 'family', 'weight', 'slant':
|
||||
self.assertIsInstance(options[key], str)
|
||||
self.assertIsInstance(self.font.cget(key), str)
|
||||
self.assertIsInstance(self.font[key], str)
|
||||
sizetype = int if self.wantobjects else str
|
||||
for key in 'size', 'underline', 'overstrike':
|
||||
self.assertIsInstance(options[key], sizetype)
|
||||
self.assertIsInstance(self.font.cget(key), sizetype)
|
||||
self.assertIsInstance(self.font[key], sizetype)
|
||||
|
||||
def test_unicode_family(self):
|
||||
family = 'MS \u30b4\u30b7\u30c3\u30af'
|
||||
try:
|
||||
f = font.Font(root=self.root, family=family, exists=True)
|
||||
except tkinter.TclError:
|
||||
f = font.Font(root=self.root, family=family, exists=False)
|
||||
self.assertEqual(f.cget('family'), family)
|
||||
del f
|
||||
gc_collect()
|
||||
|
||||
def test_actual(self):
|
||||
options = self.font.actual()
|
||||
self.assertGreaterEqual(set(options),
|
||||
{'family', 'size', 'weight', 'slant', 'underline', 'overstrike'})
|
||||
for key in options:
|
||||
self.assertEqual(self.font.actual(key), options[key])
|
||||
for key in 'family', 'weight', 'slant':
|
||||
self.assertIsInstance(options[key], str)
|
||||
self.assertIsInstance(self.font.actual(key), str)
|
||||
sizetype = int if self.wantobjects else str
|
||||
for key in 'size', 'underline', 'overstrike':
|
||||
self.assertIsInstance(options[key], sizetype)
|
||||
self.assertIsInstance(self.font.actual(key), sizetype)
|
||||
|
||||
def test_name(self):
|
||||
self.assertEqual(self.font.name, fontname)
|
||||
self.assertEqual(str(self.font), fontname)
|
||||
|
||||
def test_equality(self):
|
||||
font1 = font.Font(root=self.root, name=fontname, exists=True)
|
||||
font2 = font.Font(root=self.root, name=fontname, exists=True)
|
||||
self.assertIsNot(font1, font2)
|
||||
self.assertEqual(font1, font2)
|
||||
self.assertNotEqual(font1, font1.copy())
|
||||
|
||||
self.assertNotEqual(font1, 0)
|
||||
self.assertEqual(font1, ALWAYS_EQ)
|
||||
|
||||
root2 = tkinter.Tk()
|
||||
self.addCleanup(root2.destroy)
|
||||
font3 = font.Font(root=root2, name=fontname, exists=True)
|
||||
self.assertEqual(str(font1), str(font3))
|
||||
self.assertNotEqual(font1, font3)
|
||||
|
||||
def test_measure(self):
|
||||
self.assertIsInstance(self.font.measure('abc'), int)
|
||||
|
||||
def test_metrics(self):
|
||||
metrics = self.font.metrics()
|
||||
self.assertGreaterEqual(set(metrics),
|
||||
{'ascent', 'descent', 'linespace', 'fixed'})
|
||||
for key in metrics:
|
||||
self.assertEqual(self.font.metrics(key), metrics[key])
|
||||
self.assertIsInstance(metrics[key], int)
|
||||
self.assertIsInstance(self.font.metrics(key), int)
|
||||
|
||||
def test_families(self):
|
||||
families = font.families(self.root)
|
||||
self.assertIsInstance(families, tuple)
|
||||
self.assertTrue(families)
|
||||
for family in families:
|
||||
self.assertIsInstance(family, str)
|
||||
self.assertTrue(family)
|
||||
|
||||
def test_names(self):
|
||||
names = font.names(self.root)
|
||||
self.assertIsInstance(names, tuple)
|
||||
self.assertTrue(names)
|
||||
for name in names:
|
||||
self.assertIsInstance(name, str)
|
||||
self.assertTrue(name)
|
||||
self.assertIn(fontname, names)
|
||||
|
||||
def test_nametofont(self):
|
||||
testfont = font.nametofont(fontname, root=self.root)
|
||||
self.assertIsInstance(testfont, font.Font)
|
||||
self.assertEqual(testfont.name, fontname)
|
||||
|
||||
def test_repr(self):
|
||||
self.assertEqual(
|
||||
repr(self.font), f'<tkinter.font.Font object {fontname!r}>'
|
||||
)
|
||||
|
||||
|
||||
class DefaultRootTest(AbstractDefaultRootTest, unittest.TestCase):
|
||||
|
||||
def test_families(self):
|
||||
self.assertRaises(RuntimeError, font.families)
|
||||
root = tkinter.Tk()
|
||||
families = font.families()
|
||||
self.assertIsInstance(families, tuple)
|
||||
self.assertTrue(families)
|
||||
for family in families:
|
||||
self.assertIsInstance(family, str)
|
||||
self.assertTrue(family)
|
||||
root.destroy()
|
||||
tkinter.NoDefaultRoot()
|
||||
self.assertRaises(RuntimeError, font.families)
|
||||
|
||||
def test_names(self):
|
||||
self.assertRaises(RuntimeError, font.names)
|
||||
root = tkinter.Tk()
|
||||
names = font.names()
|
||||
self.assertIsInstance(names, tuple)
|
||||
self.assertTrue(names)
|
||||
for name in names:
|
||||
self.assertIsInstance(name, str)
|
||||
self.assertTrue(name)
|
||||
self.assertIn(fontname, names)
|
||||
root.destroy()
|
||||
tkinter.NoDefaultRoot()
|
||||
self.assertRaises(RuntimeError, font.names)
|
||||
|
||||
def test_nametofont(self):
|
||||
self.assertRaises(RuntimeError, font.nametofont, fontname)
|
||||
root = tkinter.Tk()
|
||||
testfont = font.nametofont(fontname)
|
||||
self.assertIsInstance(testfont, font.Font)
|
||||
self.assertEqual(testfont.name, fontname)
|
||||
root.destroy()
|
||||
tkinter.NoDefaultRoot()
|
||||
self.assertRaises(RuntimeError, font.nametofont, fontname)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -1,899 +0,0 @@
|
||||
import unittest
|
||||
import re
|
||||
import tkinter
|
||||
from tkinter import TclError
|
||||
from test.support import requires
|
||||
|
||||
from tkinter.test.support import pixels_conv
|
||||
from tkinter.test.widget_tests import AbstractWidgetTest
|
||||
|
||||
requires('gui')
|
||||
|
||||
|
||||
class PackTest(AbstractWidgetTest, unittest.TestCase):
|
||||
|
||||
test_keys = None
|
||||
|
||||
def create2(self):
|
||||
pack = tkinter.Toplevel(self.root, name='pack')
|
||||
pack.wm_geometry('300x200+0+0')
|
||||
pack.wm_minsize(1, 1)
|
||||
a = tkinter.Frame(pack, name='a', width=20, height=40, bg='red')
|
||||
b = tkinter.Frame(pack, name='b', width=50, height=30, bg='blue')
|
||||
c = tkinter.Frame(pack, name='c', width=80, height=80, bg='green')
|
||||
d = tkinter.Frame(pack, name='d', width=40, height=30, bg='yellow')
|
||||
return pack, a, b, c, d
|
||||
|
||||
def test_pack_configure_after(self):
|
||||
pack, a, b, c, d = self.create2()
|
||||
with self.assertRaisesRegex(TclError, 'window "%s" isn\'t packed' % b):
|
||||
a.pack_configure(after=b)
|
||||
with self.assertRaisesRegex(TclError, 'bad window path name ".foo"'):
|
||||
a.pack_configure(after='.foo')
|
||||
a.pack_configure(side='top')
|
||||
b.pack_configure(side='top')
|
||||
c.pack_configure(side='top')
|
||||
d.pack_configure(side='top')
|
||||
self.assertEqual(pack.pack_slaves(), [a, b, c, d])
|
||||
a.pack_configure(after=b)
|
||||
self.assertEqual(pack.pack_slaves(), [b, a, c, d])
|
||||
a.pack_configure(after=a)
|
||||
self.assertEqual(pack.pack_slaves(), [b, a, c, d])
|
||||
|
||||
def test_pack_configure_anchor(self):
|
||||
pack, a, b, c, d = self.create2()
|
||||
def check(anchor, geom):
|
||||
a.pack_configure(side='top', ipadx=5, padx=10, ipady=15, pady=20,
|
||||
expand=True, anchor=anchor)
|
||||
self.root.update()
|
||||
self.assertEqual(a.winfo_geometry(), geom)
|
||||
check('n', '30x70+135+20')
|
||||
check('ne', '30x70+260+20')
|
||||
check('e', '30x70+260+65')
|
||||
check('se', '30x70+260+110')
|
||||
check('s', '30x70+135+110')
|
||||
check('sw', '30x70+10+110')
|
||||
check('w', '30x70+10+65')
|
||||
check('nw', '30x70+10+20')
|
||||
check('center', '30x70+135+65')
|
||||
|
||||
def test_pack_configure_before(self):
|
||||
pack, a, b, c, d = self.create2()
|
||||
with self.assertRaisesRegex(TclError, 'window "%s" isn\'t packed' % b):
|
||||
a.pack_configure(before=b)
|
||||
with self.assertRaisesRegex(TclError, 'bad window path name ".foo"'):
|
||||
a.pack_configure(before='.foo')
|
||||
a.pack_configure(side='top')
|
||||
b.pack_configure(side='top')
|
||||
c.pack_configure(side='top')
|
||||
d.pack_configure(side='top')
|
||||
self.assertEqual(pack.pack_slaves(), [a, b, c, d])
|
||||
a.pack_configure(before=d)
|
||||
self.assertEqual(pack.pack_slaves(), [b, c, a, d])
|
||||
a.pack_configure(before=a)
|
||||
self.assertEqual(pack.pack_slaves(), [b, c, a, d])
|
||||
|
||||
def test_pack_configure_expand(self):
|
||||
pack, a, b, c, d = self.create2()
|
||||
def check(*geoms):
|
||||
self.root.update()
|
||||
self.assertEqual(a.winfo_geometry(), geoms[0])
|
||||
self.assertEqual(b.winfo_geometry(), geoms[1])
|
||||
self.assertEqual(c.winfo_geometry(), geoms[2])
|
||||
self.assertEqual(d.winfo_geometry(), geoms[3])
|
||||
a.pack_configure(side='left')
|
||||
b.pack_configure(side='top')
|
||||
c.pack_configure(side='right')
|
||||
d.pack_configure(side='bottom')
|
||||
check('20x40+0+80', '50x30+135+0', '80x80+220+75', '40x30+100+170')
|
||||
a.pack_configure(side='left', expand='yes')
|
||||
b.pack_configure(side='top', expand='on')
|
||||
c.pack_configure(side='right', expand=True)
|
||||
d.pack_configure(side='bottom', expand=1)
|
||||
check('20x40+40+80', '50x30+175+35', '80x80+180+110', '40x30+100+135')
|
||||
a.pack_configure(side='left', expand='yes', fill='both')
|
||||
b.pack_configure(side='top', expand='on', fill='both')
|
||||
c.pack_configure(side='right', expand=True, fill='both')
|
||||
d.pack_configure(side='bottom', expand=1, fill='both')
|
||||
check('100x200+0+0', '200x100+100+0', '160x100+140+100', '40x100+100+100')
|
||||
|
||||
def test_pack_configure_in(self):
|
||||
pack, a, b, c, d = self.create2()
|
||||
a.pack_configure(side='top')
|
||||
b.pack_configure(side='top')
|
||||
c.pack_configure(side='top')
|
||||
d.pack_configure(side='top')
|
||||
a.pack_configure(in_=pack)
|
||||
self.assertEqual(pack.pack_slaves(), [b, c, d, a])
|
||||
a.pack_configure(in_=c)
|
||||
self.assertEqual(pack.pack_slaves(), [b, c, d])
|
||||
self.assertEqual(c.pack_slaves(), [a])
|
||||
with self.assertRaisesRegex(TclError,
|
||||
'can\'t pack %s inside itself' % (a,)):
|
||||
a.pack_configure(in_=a)
|
||||
with self.assertRaisesRegex(TclError, 'bad window path name ".foo"'):
|
||||
a.pack_configure(in_='.foo')
|
||||
|
||||
def test_pack_configure_padx_ipadx_fill(self):
|
||||
pack, a, b, c, d = self.create2()
|
||||
def check(geom1, geom2, **kwargs):
|
||||
a.pack_forget()
|
||||
b.pack_forget()
|
||||
a.pack_configure(**kwargs)
|
||||
b.pack_configure(expand=True, fill='both')
|
||||
self.root.update()
|
||||
self.assertEqual(a.winfo_geometry(), geom1)
|
||||
self.assertEqual(b.winfo_geometry(), geom2)
|
||||
check('20x40+260+80', '240x200+0+0', side='right', padx=20)
|
||||
check('20x40+250+80', '240x200+0+0', side='right', padx=(10, 30))
|
||||
check('60x40+240+80', '240x200+0+0', side='right', ipadx=20)
|
||||
check('30x40+260+80', '250x200+0+0', side='right', ipadx=5, padx=10)
|
||||
check('20x40+260+80', '240x200+0+0', side='right', padx=20, fill='x')
|
||||
check('20x40+249+80', '240x200+0+0',
|
||||
side='right', padx=(9, 31), fill='x')
|
||||
check('60x40+240+80', '240x200+0+0', side='right', ipadx=20, fill='x')
|
||||
check('30x40+260+80', '250x200+0+0',
|
||||
side='right', ipadx=5, padx=10, fill='x')
|
||||
check('30x40+255+80', '250x200+0+0',
|
||||
side='right', ipadx=5, padx=(5, 15), fill='x')
|
||||
check('20x40+140+0', '300x160+0+40', side='top', padx=20)
|
||||
check('20x40+120+0', '300x160+0+40', side='top', padx=(0, 40))
|
||||
check('60x40+120+0', '300x160+0+40', side='top', ipadx=20)
|
||||
check('30x40+135+0', '300x160+0+40', side='top', ipadx=5, padx=10)
|
||||
check('30x40+130+0', '300x160+0+40', side='top', ipadx=5, padx=(5, 15))
|
||||
check('260x40+20+0', '300x160+0+40', side='top', padx=20, fill='x')
|
||||
check('260x40+25+0', '300x160+0+40',
|
||||
side='top', padx=(25, 15), fill='x')
|
||||
check('300x40+0+0', '300x160+0+40', side='top', ipadx=20, fill='x')
|
||||
check('280x40+10+0', '300x160+0+40',
|
||||
side='top', ipadx=5, padx=10, fill='x')
|
||||
check('280x40+5+0', '300x160+0+40',
|
||||
side='top', ipadx=5, padx=(5, 15), fill='x')
|
||||
a.pack_configure(padx='1c')
|
||||
self.assertEqual(a.pack_info()['padx'],
|
||||
self._str(pack.winfo_pixels('1c')))
|
||||
a.pack_configure(ipadx='1c')
|
||||
self.assertEqual(a.pack_info()['ipadx'],
|
||||
self._str(pack.winfo_pixels('1c')))
|
||||
|
||||
def test_pack_configure_pady_ipady_fill(self):
|
||||
pack, a, b, c, d = self.create2()
|
||||
def check(geom1, geom2, **kwargs):
|
||||
a.pack_forget()
|
||||
b.pack_forget()
|
||||
a.pack_configure(**kwargs)
|
||||
b.pack_configure(expand=True, fill='both')
|
||||
self.root.update()
|
||||
self.assertEqual(a.winfo_geometry(), geom1)
|
||||
self.assertEqual(b.winfo_geometry(), geom2)
|
||||
check('20x40+280+80', '280x200+0+0', side='right', pady=20)
|
||||
check('20x40+280+70', '280x200+0+0', side='right', pady=(10, 30))
|
||||
check('20x80+280+60', '280x200+0+0', side='right', ipady=20)
|
||||
check('20x50+280+75', '280x200+0+0', side='right', ipady=5, pady=10)
|
||||
check('20x40+280+80', '280x200+0+0', side='right', pady=20, fill='x')
|
||||
check('20x40+280+69', '280x200+0+0',
|
||||
side='right', pady=(9, 31), fill='x')
|
||||
check('20x80+280+60', '280x200+0+0', side='right', ipady=20, fill='x')
|
||||
check('20x50+280+75', '280x200+0+0',
|
||||
side='right', ipady=5, pady=10, fill='x')
|
||||
check('20x50+280+70', '280x200+0+0',
|
||||
side='right', ipady=5, pady=(5, 15), fill='x')
|
||||
check('20x40+140+20', '300x120+0+80', side='top', pady=20)
|
||||
check('20x40+140+0', '300x120+0+80', side='top', pady=(0, 40))
|
||||
check('20x80+140+0', '300x120+0+80', side='top', ipady=20)
|
||||
check('20x50+140+10', '300x130+0+70', side='top', ipady=5, pady=10)
|
||||
check('20x50+140+5', '300x130+0+70', side='top', ipady=5, pady=(5, 15))
|
||||
check('300x40+0+20', '300x120+0+80', side='top', pady=20, fill='x')
|
||||
check('300x40+0+25', '300x120+0+80',
|
||||
side='top', pady=(25, 15), fill='x')
|
||||
check('300x80+0+0', '300x120+0+80', side='top', ipady=20, fill='x')
|
||||
check('300x50+0+10', '300x130+0+70',
|
||||
side='top', ipady=5, pady=10, fill='x')
|
||||
check('300x50+0+5', '300x130+0+70',
|
||||
side='top', ipady=5, pady=(5, 15), fill='x')
|
||||
a.pack_configure(pady='1c')
|
||||
self.assertEqual(a.pack_info()['pady'],
|
||||
self._str(pack.winfo_pixels('1c')))
|
||||
a.pack_configure(ipady='1c')
|
||||
self.assertEqual(a.pack_info()['ipady'],
|
||||
self._str(pack.winfo_pixels('1c')))
|
||||
|
||||
def test_pack_configure_side(self):
|
||||
pack, a, b, c, d = self.create2()
|
||||
def check(side, geom1, geom2):
|
||||
a.pack_configure(side=side)
|
||||
self.assertEqual(a.pack_info()['side'], side)
|
||||
b.pack_configure(expand=True, fill='both')
|
||||
self.root.update()
|
||||
self.assertEqual(a.winfo_geometry(), geom1)
|
||||
self.assertEqual(b.winfo_geometry(), geom2)
|
||||
check('top', '20x40+140+0', '300x160+0+40')
|
||||
check('bottom', '20x40+140+160', '300x160+0+0')
|
||||
check('left', '20x40+0+80', '280x200+20+0')
|
||||
check('right', '20x40+280+80', '280x200+0+0')
|
||||
|
||||
def test_pack_forget(self):
|
||||
pack, a, b, c, d = self.create2()
|
||||
a.pack_configure()
|
||||
b.pack_configure()
|
||||
c.pack_configure()
|
||||
self.assertEqual(pack.pack_slaves(), [a, b, c])
|
||||
b.pack_forget()
|
||||
self.assertEqual(pack.pack_slaves(), [a, c])
|
||||
b.pack_forget()
|
||||
self.assertEqual(pack.pack_slaves(), [a, c])
|
||||
d.pack_forget()
|
||||
|
||||
def test_pack_info(self):
|
||||
pack, a, b, c, d = self.create2()
|
||||
with self.assertRaisesRegex(TclError, 'window "%s" isn\'t packed' % a):
|
||||
a.pack_info()
|
||||
a.pack_configure()
|
||||
b.pack_configure(side='right', in_=a, anchor='s', expand=True, fill='x',
|
||||
ipadx=5, padx=10, ipady=2, pady=(5, 15))
|
||||
info = a.pack_info()
|
||||
self.assertIsInstance(info, dict)
|
||||
self.assertEqual(info['anchor'], 'center')
|
||||
self.assertEqual(info['expand'], self._str(0))
|
||||
self.assertEqual(info['fill'], 'none')
|
||||
self.assertEqual(info['in'], pack)
|
||||
self.assertEqual(info['ipadx'], self._str(0))
|
||||
self.assertEqual(info['ipady'], self._str(0))
|
||||
self.assertEqual(info['padx'], self._str(0))
|
||||
self.assertEqual(info['pady'], self._str(0))
|
||||
self.assertEqual(info['side'], 'top')
|
||||
info = b.pack_info()
|
||||
self.assertIsInstance(info, dict)
|
||||
self.assertEqual(info['anchor'], 's')
|
||||
self.assertEqual(info['expand'], self._str(1))
|
||||
self.assertEqual(info['fill'], 'x')
|
||||
self.assertEqual(info['in'], a)
|
||||
self.assertEqual(info['ipadx'], self._str(5))
|
||||
self.assertEqual(info['ipady'], self._str(2))
|
||||
self.assertEqual(info['padx'], self._str(10))
|
||||
self.assertEqual(info['pady'], self._str((5, 15)))
|
||||
self.assertEqual(info['side'], 'right')
|
||||
|
||||
def test_pack_propagate(self):
|
||||
pack, a, b, c, d = self.create2()
|
||||
pack.configure(width=300, height=200)
|
||||
a.pack_configure()
|
||||
pack.pack_propagate(False)
|
||||
self.root.update()
|
||||
self.assertEqual(pack.winfo_reqwidth(), 300)
|
||||
self.assertEqual(pack.winfo_reqheight(), 200)
|
||||
pack.pack_propagate(True)
|
||||
self.root.update()
|
||||
self.assertEqual(pack.winfo_reqwidth(), 20)
|
||||
self.assertEqual(pack.winfo_reqheight(), 40)
|
||||
|
||||
def test_pack_slaves(self):
|
||||
pack, a, b, c, d = self.create2()
|
||||
self.assertEqual(pack.pack_slaves(), [])
|
||||
a.pack_configure()
|
||||
self.assertEqual(pack.pack_slaves(), [a])
|
||||
b.pack_configure()
|
||||
self.assertEqual(pack.pack_slaves(), [a, b])
|
||||
|
||||
|
||||
class PlaceTest(AbstractWidgetTest, unittest.TestCase):
|
||||
|
||||
test_keys = None
|
||||
|
||||
def create2(self):
|
||||
t = tkinter.Toplevel(self.root, width=300, height=200, bd=0)
|
||||
t.wm_geometry('300x200+0+0')
|
||||
f = tkinter.Frame(t, width=154, height=84, bd=2, relief='raised')
|
||||
f.place_configure(x=48, y=38)
|
||||
f2 = tkinter.Frame(t, width=30, height=60, bd=2, relief='raised')
|
||||
self.root.update()
|
||||
return t, f, f2
|
||||
|
||||
def test_place_configure_in(self):
|
||||
t, f, f2 = self.create2()
|
||||
self.assertEqual(f2.winfo_manager(), '')
|
||||
with self.assertRaisesRegex(TclError, "can't place %s relative to "
|
||||
"itself" % re.escape(str(f2))):
|
||||
f2.place_configure(in_=f2)
|
||||
self.assertEqual(f2.winfo_manager(), '')
|
||||
with self.assertRaisesRegex(TclError, 'bad window path name'):
|
||||
f2.place_configure(in_='spam')
|
||||
f2.place_configure(in_=f)
|
||||
self.assertEqual(f2.winfo_manager(), 'place')
|
||||
|
||||
def test_place_configure_x(self):
|
||||
t, f, f2 = self.create2()
|
||||
f2.place_configure(in_=f)
|
||||
self.assertEqual(f2.place_info()['x'], '0')
|
||||
self.root.update()
|
||||
self.assertEqual(f2.winfo_x(), 50)
|
||||
f2.place_configure(x=100)
|
||||
self.assertEqual(f2.place_info()['x'], '100')
|
||||
self.root.update()
|
||||
self.assertEqual(f2.winfo_x(), 150)
|
||||
f2.place_configure(x=-10, relx=1)
|
||||
self.assertEqual(f2.place_info()['x'], '-10')
|
||||
self.root.update()
|
||||
self.assertEqual(f2.winfo_x(), 190)
|
||||
with self.assertRaisesRegex(TclError, 'bad screen distance "spam"'):
|
||||
f2.place_configure(in_=f, x='spam')
|
||||
|
||||
def test_place_configure_y(self):
|
||||
t, f, f2 = self.create2()
|
||||
f2.place_configure(in_=f)
|
||||
self.assertEqual(f2.place_info()['y'], '0')
|
||||
self.root.update()
|
||||
self.assertEqual(f2.winfo_y(), 40)
|
||||
f2.place_configure(y=50)
|
||||
self.assertEqual(f2.place_info()['y'], '50')
|
||||
self.root.update()
|
||||
self.assertEqual(f2.winfo_y(), 90)
|
||||
f2.place_configure(y=-10, rely=1)
|
||||
self.assertEqual(f2.place_info()['y'], '-10')
|
||||
self.root.update()
|
||||
self.assertEqual(f2.winfo_y(), 110)
|
||||
with self.assertRaisesRegex(TclError, 'bad screen distance "spam"'):
|
||||
f2.place_configure(in_=f, y='spam')
|
||||
|
||||
def test_place_configure_relx(self):
|
||||
t, f, f2 = self.create2()
|
||||
f2.place_configure(in_=f)
|
||||
self.assertEqual(f2.place_info()['relx'], '0')
|
||||
self.root.update()
|
||||
self.assertEqual(f2.winfo_x(), 50)
|
||||
f2.place_configure(relx=0.5)
|
||||
self.assertEqual(f2.place_info()['relx'], '0.5')
|
||||
self.root.update()
|
||||
self.assertEqual(f2.winfo_x(), 125)
|
||||
f2.place_configure(relx=1)
|
||||
self.assertEqual(f2.place_info()['relx'], '1')
|
||||
self.root.update()
|
||||
self.assertEqual(f2.winfo_x(), 200)
|
||||
with self.assertRaisesRegex(TclError, 'expected floating-point number '
|
||||
'but got "spam"'):
|
||||
f2.place_configure(in_=f, relx='spam')
|
||||
|
||||
def test_place_configure_rely(self):
|
||||
t, f, f2 = self.create2()
|
||||
f2.place_configure(in_=f)
|
||||
self.assertEqual(f2.place_info()['rely'], '0')
|
||||
self.root.update()
|
||||
self.assertEqual(f2.winfo_y(), 40)
|
||||
f2.place_configure(rely=0.5)
|
||||
self.assertEqual(f2.place_info()['rely'], '0.5')
|
||||
self.root.update()
|
||||
self.assertEqual(f2.winfo_y(), 80)
|
||||
f2.place_configure(rely=1)
|
||||
self.assertEqual(f2.place_info()['rely'], '1')
|
||||
self.root.update()
|
||||
self.assertEqual(f2.winfo_y(), 120)
|
||||
with self.assertRaisesRegex(TclError, 'expected floating-point number '
|
||||
'but got "spam"'):
|
||||
f2.place_configure(in_=f, rely='spam')
|
||||
|
||||
def test_place_configure_anchor(self):
|
||||
f = tkinter.Frame(self.root)
|
||||
with self.assertRaisesRegex(TclError, 'bad anchor "j"'):
|
||||
f.place_configure(anchor='j')
|
||||
with self.assertRaisesRegex(TclError, 'ambiguous anchor ""'):
|
||||
f.place_configure(anchor='')
|
||||
for value in 'n', 'ne', 'e', 'se', 's', 'sw', 'w', 'nw', 'center':
|
||||
f.place_configure(anchor=value)
|
||||
self.assertEqual(f.place_info()['anchor'], value)
|
||||
|
||||
def test_place_configure_width(self):
|
||||
t, f, f2 = self.create2()
|
||||
f2.place_configure(in_=f, width=120)
|
||||
self.root.update()
|
||||
self.assertEqual(f2.winfo_width(), 120)
|
||||
f2.place_configure(width='')
|
||||
self.root.update()
|
||||
self.assertEqual(f2.winfo_width(), 30)
|
||||
with self.assertRaisesRegex(TclError, 'bad screen distance "abcd"'):
|
||||
f2.place_configure(width='abcd')
|
||||
|
||||
def test_place_configure_height(self):
|
||||
t, f, f2 = self.create2()
|
||||
f2.place_configure(in_=f, height=120)
|
||||
self.root.update()
|
||||
self.assertEqual(f2.winfo_height(), 120)
|
||||
f2.place_configure(height='')
|
||||
self.root.update()
|
||||
self.assertEqual(f2.winfo_height(), 60)
|
||||
with self.assertRaisesRegex(TclError, 'bad screen distance "abcd"'):
|
||||
f2.place_configure(height='abcd')
|
||||
|
||||
def test_place_configure_relwidth(self):
|
||||
t, f, f2 = self.create2()
|
||||
f2.place_configure(in_=f, relwidth=0.5)
|
||||
self.root.update()
|
||||
self.assertEqual(f2.winfo_width(), 75)
|
||||
f2.place_configure(relwidth='')
|
||||
self.root.update()
|
||||
self.assertEqual(f2.winfo_width(), 30)
|
||||
with self.assertRaisesRegex(TclError, 'expected floating-point number '
|
||||
'but got "abcd"'):
|
||||
f2.place_configure(relwidth='abcd')
|
||||
|
||||
def test_place_configure_relheight(self):
|
||||
t, f, f2 = self.create2()
|
||||
f2.place_configure(in_=f, relheight=0.5)
|
||||
self.root.update()
|
||||
self.assertEqual(f2.winfo_height(), 40)
|
||||
f2.place_configure(relheight='')
|
||||
self.root.update()
|
||||
self.assertEqual(f2.winfo_height(), 60)
|
||||
with self.assertRaisesRegex(TclError, 'expected floating-point number '
|
||||
'but got "abcd"'):
|
||||
f2.place_configure(relheight='abcd')
|
||||
|
||||
def test_place_configure_bordermode(self):
|
||||
f = tkinter.Frame(self.root)
|
||||
with self.assertRaisesRegex(TclError, 'bad bordermode "j"'):
|
||||
f.place_configure(bordermode='j')
|
||||
with self.assertRaisesRegex(TclError, 'ambiguous bordermode ""'):
|
||||
f.place_configure(bordermode='')
|
||||
for value in 'inside', 'outside', 'ignore':
|
||||
f.place_configure(bordermode=value)
|
||||
self.assertEqual(f.place_info()['bordermode'], value)
|
||||
|
||||
def test_place_forget(self):
|
||||
foo = tkinter.Frame(self.root)
|
||||
foo.place_configure(width=50, height=50)
|
||||
self.root.update()
|
||||
foo.place_forget()
|
||||
self.root.update()
|
||||
self.assertFalse(foo.winfo_ismapped())
|
||||
with self.assertRaises(TypeError):
|
||||
foo.place_forget(0)
|
||||
|
||||
def test_place_info(self):
|
||||
t, f, f2 = self.create2()
|
||||
f2.place_configure(in_=f, x=1, y=2, width=3, height=4,
|
||||
relx=0.1, rely=0.2, relwidth=0.3, relheight=0.4,
|
||||
anchor='se', bordermode='outside')
|
||||
info = f2.place_info()
|
||||
self.assertIsInstance(info, dict)
|
||||
self.assertEqual(info['x'], '1')
|
||||
self.assertEqual(info['y'], '2')
|
||||
self.assertEqual(info['width'], '3')
|
||||
self.assertEqual(info['height'], '4')
|
||||
self.assertEqual(info['relx'], '0.1')
|
||||
self.assertEqual(info['rely'], '0.2')
|
||||
self.assertEqual(info['relwidth'], '0.3')
|
||||
self.assertEqual(info['relheight'], '0.4')
|
||||
self.assertEqual(info['anchor'], 'se')
|
||||
self.assertEqual(info['bordermode'], 'outside')
|
||||
self.assertEqual(info['x'], '1')
|
||||
self.assertEqual(info['x'], '1')
|
||||
with self.assertRaises(TypeError):
|
||||
f2.place_info(0)
|
||||
|
||||
def test_place_slaves(self):
|
||||
foo = tkinter.Frame(self.root)
|
||||
bar = tkinter.Frame(self.root)
|
||||
self.assertEqual(foo.place_slaves(), [])
|
||||
bar.place_configure(in_=foo)
|
||||
self.assertEqual(foo.place_slaves(), [bar])
|
||||
with self.assertRaises(TypeError):
|
||||
foo.place_slaves(0)
|
||||
|
||||
|
||||
class GridTest(AbstractWidgetTest, unittest.TestCase):
|
||||
|
||||
test_keys = None
|
||||
|
||||
def tearDown(self):
|
||||
cols, rows = self.root.grid_size()
|
||||
for i in range(cols + 1):
|
||||
self.root.grid_columnconfigure(i, weight=0, minsize=0, pad=0, uniform='')
|
||||
for i in range(rows + 1):
|
||||
self.root.grid_rowconfigure(i, weight=0, minsize=0, pad=0, uniform='')
|
||||
self.root.grid_propagate(1)
|
||||
self.root.grid_anchor('nw')
|
||||
super().tearDown()
|
||||
|
||||
def test_grid_configure(self):
|
||||
b = tkinter.Button(self.root)
|
||||
self.assertEqual(b.grid_info(), {})
|
||||
b.grid_configure()
|
||||
self.assertEqual(b.grid_info()['in'], self.root)
|
||||
self.assertEqual(b.grid_info()['column'], self._str(0))
|
||||
self.assertEqual(b.grid_info()['row'], self._str(0))
|
||||
b.grid_configure({'column': 1}, row=2)
|
||||
self.assertEqual(b.grid_info()['column'], self._str(1))
|
||||
self.assertEqual(b.grid_info()['row'], self._str(2))
|
||||
|
||||
def test_grid_configure_column(self):
|
||||
b = tkinter.Button(self.root)
|
||||
with self.assertRaisesRegex(TclError, 'bad column value "-1": '
|
||||
'must be a non-negative integer'):
|
||||
b.grid_configure(column=-1)
|
||||
b.grid_configure(column=2)
|
||||
self.assertEqual(b.grid_info()['column'], self._str(2))
|
||||
|
||||
def test_grid_configure_columnspan(self):
|
||||
b = tkinter.Button(self.root)
|
||||
with self.assertRaisesRegex(TclError, 'bad columnspan value "0": '
|
||||
'must be a positive integer'):
|
||||
b.grid_configure(columnspan=0)
|
||||
b.grid_configure(columnspan=2)
|
||||
self.assertEqual(b.grid_info()['columnspan'], self._str(2))
|
||||
|
||||
def test_grid_configure_in(self):
|
||||
f = tkinter.Frame(self.root)
|
||||
b = tkinter.Button(self.root)
|
||||
self.assertEqual(b.grid_info(), {})
|
||||
b.grid_configure()
|
||||
self.assertEqual(b.grid_info()['in'], self.root)
|
||||
b.grid_configure(in_=f)
|
||||
self.assertEqual(b.grid_info()['in'], f)
|
||||
b.grid_configure({'in': self.root})
|
||||
self.assertEqual(b.grid_info()['in'], self.root)
|
||||
|
||||
def test_grid_configure_ipadx(self):
|
||||
b = tkinter.Button(self.root)
|
||||
with self.assertRaisesRegex(TclError, 'bad ipadx value "-1": '
|
||||
'must be positive screen distance'):
|
||||
b.grid_configure(ipadx=-1)
|
||||
b.grid_configure(ipadx=1)
|
||||
self.assertEqual(b.grid_info()['ipadx'], self._str(1))
|
||||
b.grid_configure(ipadx='.5c')
|
||||
self.assertEqual(b.grid_info()['ipadx'],
|
||||
self._str(round(pixels_conv('.5c') * self.scaling)))
|
||||
|
||||
def test_grid_configure_ipady(self):
|
||||
b = tkinter.Button(self.root)
|
||||
with self.assertRaisesRegex(TclError, 'bad ipady value "-1": '
|
||||
'must be positive screen distance'):
|
||||
b.grid_configure(ipady=-1)
|
||||
b.grid_configure(ipady=1)
|
||||
self.assertEqual(b.grid_info()['ipady'], self._str(1))
|
||||
b.grid_configure(ipady='.5c')
|
||||
self.assertEqual(b.grid_info()['ipady'],
|
||||
self._str(round(pixels_conv('.5c') * self.scaling)))
|
||||
|
||||
def test_grid_configure_padx(self):
|
||||
b = tkinter.Button(self.root)
|
||||
with self.assertRaisesRegex(TclError, 'bad pad value "-1": '
|
||||
'must be positive screen distance'):
|
||||
b.grid_configure(padx=-1)
|
||||
b.grid_configure(padx=1)
|
||||
self.assertEqual(b.grid_info()['padx'], self._str(1))
|
||||
b.grid_configure(padx=(10, 5))
|
||||
self.assertEqual(b.grid_info()['padx'], self._str((10, 5)))
|
||||
b.grid_configure(padx='.5c')
|
||||
self.assertEqual(b.grid_info()['padx'],
|
||||
self._str(round(pixels_conv('.5c') * self.scaling)))
|
||||
|
||||
def test_grid_configure_pady(self):
|
||||
b = tkinter.Button(self.root)
|
||||
with self.assertRaisesRegex(TclError, 'bad pad value "-1": '
|
||||
'must be positive screen distance'):
|
||||
b.grid_configure(pady=-1)
|
||||
b.grid_configure(pady=1)
|
||||
self.assertEqual(b.grid_info()['pady'], self._str(1))
|
||||
b.grid_configure(pady=(10, 5))
|
||||
self.assertEqual(b.grid_info()['pady'], self._str((10, 5)))
|
||||
b.grid_configure(pady='.5c')
|
||||
self.assertEqual(b.grid_info()['pady'],
|
||||
self._str(round(pixels_conv('.5c') * self.scaling)))
|
||||
|
||||
def test_grid_configure_row(self):
|
||||
b = tkinter.Button(self.root)
|
||||
with self.assertRaisesRegex(TclError, 'bad (row|grid) value "-1": '
|
||||
'must be a non-negative integer'):
|
||||
b.grid_configure(row=-1)
|
||||
b.grid_configure(row=2)
|
||||
self.assertEqual(b.grid_info()['row'], self._str(2))
|
||||
|
||||
def test_grid_configure_rownspan(self):
|
||||
b = tkinter.Button(self.root)
|
||||
with self.assertRaisesRegex(TclError, 'bad rowspan value "0": '
|
||||
'must be a positive integer'):
|
||||
b.grid_configure(rowspan=0)
|
||||
b.grid_configure(rowspan=2)
|
||||
self.assertEqual(b.grid_info()['rowspan'], self._str(2))
|
||||
|
||||
def test_grid_configure_sticky(self):
|
||||
f = tkinter.Frame(self.root, bg='red')
|
||||
with self.assertRaisesRegex(TclError, 'bad stickyness value "glue"'):
|
||||
f.grid_configure(sticky='glue')
|
||||
f.grid_configure(sticky='ne')
|
||||
self.assertEqual(f.grid_info()['sticky'], 'ne')
|
||||
f.grid_configure(sticky='n,s,e,w')
|
||||
self.assertEqual(f.grid_info()['sticky'], 'nesw')
|
||||
|
||||
def test_grid_columnconfigure(self):
|
||||
with self.assertRaises(TypeError):
|
||||
self.root.grid_columnconfigure()
|
||||
self.assertEqual(self.root.grid_columnconfigure(0),
|
||||
{'minsize': 0, 'pad': 0, 'uniform': None, 'weight': 0})
|
||||
with self.assertRaisesRegex(TclError, 'bad option "-foo"'):
|
||||
self.root.grid_columnconfigure(0, 'foo')
|
||||
self.root.grid_columnconfigure((0, 3), weight=2)
|
||||
with self.assertRaisesRegex(TclError,
|
||||
'must specify a single element on retrieval'):
|
||||
self.root.grid_columnconfigure((0, 3))
|
||||
b = tkinter.Button(self.root)
|
||||
b.grid_configure(column=0, row=0)
|
||||
self.root.grid_columnconfigure('all', weight=3)
|
||||
with self.assertRaisesRegex(TclError, 'expected integer but got "all"'):
|
||||
self.root.grid_columnconfigure('all')
|
||||
self.assertEqual(self.root.grid_columnconfigure(0, 'weight'), 3)
|
||||
self.assertEqual(self.root.grid_columnconfigure(3, 'weight'), 2)
|
||||
self.assertEqual(self.root.grid_columnconfigure(265, 'weight'), 0)
|
||||
self.root.grid_columnconfigure(b, weight=4)
|
||||
self.assertEqual(self.root.grid_columnconfigure(0, 'weight'), 4)
|
||||
|
||||
def test_grid_columnconfigure_minsize(self):
|
||||
with self.assertRaisesRegex(TclError, 'bad screen distance "foo"'):
|
||||
self.root.grid_columnconfigure(0, minsize='foo')
|
||||
self.root.grid_columnconfigure(0, minsize=10)
|
||||
self.assertEqual(self.root.grid_columnconfigure(0, 'minsize'), 10)
|
||||
self.assertEqual(self.root.grid_columnconfigure(0)['minsize'], 10)
|
||||
|
||||
def test_grid_columnconfigure_weight(self):
|
||||
with self.assertRaisesRegex(TclError, 'expected integer but got "bad"'):
|
||||
self.root.grid_columnconfigure(0, weight='bad')
|
||||
with self.assertRaisesRegex(TclError, 'invalid arg "-weight": '
|
||||
'should be non-negative'):
|
||||
self.root.grid_columnconfigure(0, weight=-3)
|
||||
self.root.grid_columnconfigure(0, weight=3)
|
||||
self.assertEqual(self.root.grid_columnconfigure(0, 'weight'), 3)
|
||||
self.assertEqual(self.root.grid_columnconfigure(0)['weight'], 3)
|
||||
|
||||
def test_grid_columnconfigure_pad(self):
|
||||
with self.assertRaisesRegex(TclError, 'bad screen distance "foo"'):
|
||||
self.root.grid_columnconfigure(0, pad='foo')
|
||||
with self.assertRaisesRegex(TclError, 'invalid arg "-pad": '
|
||||
'should be non-negative'):
|
||||
self.root.grid_columnconfigure(0, pad=-3)
|
||||
self.root.grid_columnconfigure(0, pad=3)
|
||||
self.assertEqual(self.root.grid_columnconfigure(0, 'pad'), 3)
|
||||
self.assertEqual(self.root.grid_columnconfigure(0)['pad'], 3)
|
||||
|
||||
def test_grid_columnconfigure_uniform(self):
|
||||
self.root.grid_columnconfigure(0, uniform='foo')
|
||||
self.assertEqual(self.root.grid_columnconfigure(0, 'uniform'), 'foo')
|
||||
self.assertEqual(self.root.grid_columnconfigure(0)['uniform'], 'foo')
|
||||
|
||||
def test_grid_rowconfigure(self):
|
||||
with self.assertRaises(TypeError):
|
||||
self.root.grid_rowconfigure()
|
||||
self.assertEqual(self.root.grid_rowconfigure(0),
|
||||
{'minsize': 0, 'pad': 0, 'uniform': None, 'weight': 0})
|
||||
with self.assertRaisesRegex(TclError, 'bad option "-foo"'):
|
||||
self.root.grid_rowconfigure(0, 'foo')
|
||||
self.root.grid_rowconfigure((0, 3), weight=2)
|
||||
with self.assertRaisesRegex(TclError,
|
||||
'must specify a single element on retrieval'):
|
||||
self.root.grid_rowconfigure((0, 3))
|
||||
b = tkinter.Button(self.root)
|
||||
b.grid_configure(column=0, row=0)
|
||||
self.root.grid_rowconfigure('all', weight=3)
|
||||
with self.assertRaisesRegex(TclError, 'expected integer but got "all"'):
|
||||
self.root.grid_rowconfigure('all')
|
||||
self.assertEqual(self.root.grid_rowconfigure(0, 'weight'), 3)
|
||||
self.assertEqual(self.root.grid_rowconfigure(3, 'weight'), 2)
|
||||
self.assertEqual(self.root.grid_rowconfigure(265, 'weight'), 0)
|
||||
self.root.grid_rowconfigure(b, weight=4)
|
||||
self.assertEqual(self.root.grid_rowconfigure(0, 'weight'), 4)
|
||||
|
||||
def test_grid_rowconfigure_minsize(self):
|
||||
with self.assertRaisesRegex(TclError, 'bad screen distance "foo"'):
|
||||
self.root.grid_rowconfigure(0, minsize='foo')
|
||||
self.root.grid_rowconfigure(0, minsize=10)
|
||||
self.assertEqual(self.root.grid_rowconfigure(0, 'minsize'), 10)
|
||||
self.assertEqual(self.root.grid_rowconfigure(0)['minsize'], 10)
|
||||
|
||||
def test_grid_rowconfigure_weight(self):
|
||||
with self.assertRaisesRegex(TclError, 'expected integer but got "bad"'):
|
||||
self.root.grid_rowconfigure(0, weight='bad')
|
||||
with self.assertRaisesRegex(TclError, 'invalid arg "-weight": '
|
||||
'should be non-negative'):
|
||||
self.root.grid_rowconfigure(0, weight=-3)
|
||||
self.root.grid_rowconfigure(0, weight=3)
|
||||
self.assertEqual(self.root.grid_rowconfigure(0, 'weight'), 3)
|
||||
self.assertEqual(self.root.grid_rowconfigure(0)['weight'], 3)
|
||||
|
||||
def test_grid_rowconfigure_pad(self):
|
||||
with self.assertRaisesRegex(TclError, 'bad screen distance "foo"'):
|
||||
self.root.grid_rowconfigure(0, pad='foo')
|
||||
with self.assertRaisesRegex(TclError, 'invalid arg "-pad": '
|
||||
'should be non-negative'):
|
||||
self.root.grid_rowconfigure(0, pad=-3)
|
||||
self.root.grid_rowconfigure(0, pad=3)
|
||||
self.assertEqual(self.root.grid_rowconfigure(0, 'pad'), 3)
|
||||
self.assertEqual(self.root.grid_rowconfigure(0)['pad'], 3)
|
||||
|
||||
def test_grid_rowconfigure_uniform(self):
|
||||
self.root.grid_rowconfigure(0, uniform='foo')
|
||||
self.assertEqual(self.root.grid_rowconfigure(0, 'uniform'), 'foo')
|
||||
self.assertEqual(self.root.grid_rowconfigure(0)['uniform'], 'foo')
|
||||
|
||||
def test_grid_forget(self):
|
||||
b = tkinter.Button(self.root)
|
||||
c = tkinter.Button(self.root)
|
||||
b.grid_configure(row=2, column=2, rowspan=2, columnspan=2,
|
||||
padx=3, pady=4, sticky='ns')
|
||||
self.assertEqual(self.root.grid_slaves(), [b])
|
||||
b.grid_forget()
|
||||
c.grid_forget()
|
||||
self.assertEqual(self.root.grid_slaves(), [])
|
||||
self.assertEqual(b.grid_info(), {})
|
||||
b.grid_configure(row=0, column=0)
|
||||
info = b.grid_info()
|
||||
self.assertEqual(info['row'], self._str(0))
|
||||
self.assertEqual(info['column'], self._str(0))
|
||||
self.assertEqual(info['rowspan'], self._str(1))
|
||||
self.assertEqual(info['columnspan'], self._str(1))
|
||||
self.assertEqual(info['padx'], self._str(0))
|
||||
self.assertEqual(info['pady'], self._str(0))
|
||||
self.assertEqual(info['sticky'], '')
|
||||
|
||||
def test_grid_remove(self):
|
||||
b = tkinter.Button(self.root)
|
||||
c = tkinter.Button(self.root)
|
||||
b.grid_configure(row=2, column=2, rowspan=2, columnspan=2,
|
||||
padx=3, pady=4, sticky='ns')
|
||||
self.assertEqual(self.root.grid_slaves(), [b])
|
||||
b.grid_remove()
|
||||
c.grid_remove()
|
||||
self.assertEqual(self.root.grid_slaves(), [])
|
||||
self.assertEqual(b.grid_info(), {})
|
||||
b.grid_configure(row=0, column=0)
|
||||
info = b.grid_info()
|
||||
self.assertEqual(info['row'], self._str(0))
|
||||
self.assertEqual(info['column'], self._str(0))
|
||||
self.assertEqual(info['rowspan'], self._str(2))
|
||||
self.assertEqual(info['columnspan'], self._str(2))
|
||||
self.assertEqual(info['padx'], self._str(3))
|
||||
self.assertEqual(info['pady'], self._str(4))
|
||||
self.assertEqual(info['sticky'], 'ns')
|
||||
|
||||
def test_grid_info(self):
|
||||
b = tkinter.Button(self.root)
|
||||
self.assertEqual(b.grid_info(), {})
|
||||
b.grid_configure(row=2, column=2, rowspan=2, columnspan=2,
|
||||
padx=3, pady=4, sticky='ns')
|
||||
info = b.grid_info()
|
||||
self.assertIsInstance(info, dict)
|
||||
self.assertEqual(info['in'], self.root)
|
||||
self.assertEqual(info['row'], self._str(2))
|
||||
self.assertEqual(info['column'], self._str(2))
|
||||
self.assertEqual(info['rowspan'], self._str(2))
|
||||
self.assertEqual(info['columnspan'], self._str(2))
|
||||
self.assertEqual(info['padx'], self._str(3))
|
||||
self.assertEqual(info['pady'], self._str(4))
|
||||
self.assertEqual(info['sticky'], 'ns')
|
||||
|
||||
def test_grid_anchor(self):
|
||||
with self.assertRaisesRegex(TclError, 'bad anchor "x"'):
|
||||
self.root.grid_anchor('x')
|
||||
with self.assertRaisesRegex(TclError, 'ambiguous anchor ""'):
|
||||
self.root.grid_anchor('')
|
||||
with self.assertRaises(TypeError):
|
||||
self.root.grid_anchor('se', 'nw')
|
||||
self.root.grid_anchor('se')
|
||||
self.assertEqual(self.root.tk.call('grid', 'anchor', self.root), 'se')
|
||||
|
||||
def test_grid_bbox(self):
|
||||
self.assertEqual(self.root.grid_bbox(), (0, 0, 0, 0))
|
||||
self.assertEqual(self.root.grid_bbox(0, 0), (0, 0, 0, 0))
|
||||
self.assertEqual(self.root.grid_bbox(0, 0, 1, 1), (0, 0, 0, 0))
|
||||
with self.assertRaisesRegex(TclError, 'expected integer but got "x"'):
|
||||
self.root.grid_bbox('x', 0)
|
||||
with self.assertRaisesRegex(TclError, 'expected integer but got "x"'):
|
||||
self.root.grid_bbox(0, 'x')
|
||||
with self.assertRaisesRegex(TclError, 'expected integer but got "x"'):
|
||||
self.root.grid_bbox(0, 0, 'x', 0)
|
||||
with self.assertRaisesRegex(TclError, 'expected integer but got "x"'):
|
||||
self.root.grid_bbox(0, 0, 0, 'x')
|
||||
with self.assertRaises(TypeError):
|
||||
self.root.grid_bbox(0, 0, 0, 0, 0)
|
||||
t = self.root
|
||||
# de-maximize
|
||||
t.wm_geometry('1x1+0+0')
|
||||
t.wm_geometry('')
|
||||
f1 = tkinter.Frame(t, width=75, height=75, bg='red')
|
||||
f2 = tkinter.Frame(t, width=90, height=90, bg='blue')
|
||||
f1.grid_configure(row=0, column=0)
|
||||
f2.grid_configure(row=1, column=1)
|
||||
self.root.update()
|
||||
self.assertEqual(t.grid_bbox(), (0, 0, 165, 165))
|
||||
self.assertEqual(t.grid_bbox(0, 0), (0, 0, 75, 75))
|
||||
self.assertEqual(t.grid_bbox(0, 0, 1, 1), (0, 0, 165, 165))
|
||||
self.assertEqual(t.grid_bbox(1, 1), (75, 75, 90, 90))
|
||||
self.assertEqual(t.grid_bbox(10, 10, 0, 0), (0, 0, 165, 165))
|
||||
self.assertEqual(t.grid_bbox(-2, -2, -1, -1), (0, 0, 0, 0))
|
||||
self.assertEqual(t.grid_bbox(10, 10, 12, 12), (165, 165, 0, 0))
|
||||
|
||||
def test_grid_location(self):
|
||||
with self.assertRaises(TypeError):
|
||||
self.root.grid_location()
|
||||
with self.assertRaises(TypeError):
|
||||
self.root.grid_location(0)
|
||||
with self.assertRaises(TypeError):
|
||||
self.root.grid_location(0, 0, 0)
|
||||
with self.assertRaisesRegex(TclError, 'bad screen distance "x"'):
|
||||
self.root.grid_location('x', 'y')
|
||||
with self.assertRaisesRegex(TclError, 'bad screen distance "y"'):
|
||||
self.root.grid_location('1c', 'y')
|
||||
t = self.root
|
||||
# de-maximize
|
||||
t.wm_geometry('1x1+0+0')
|
||||
t.wm_geometry('')
|
||||
f = tkinter.Frame(t, width=200, height=100,
|
||||
highlightthickness=0, bg='red')
|
||||
self.assertEqual(f.grid_location(10, 10), (-1, -1))
|
||||
f.grid_configure()
|
||||
self.root.update()
|
||||
self.assertEqual(t.grid_location(-10, -10), (-1, -1))
|
||||
self.assertEqual(t.grid_location(-10, 0), (-1, 0))
|
||||
self.assertEqual(t.grid_location(-1, 0), (-1, 0))
|
||||
self.assertEqual(t.grid_location(0, -10), (0, -1))
|
||||
self.assertEqual(t.grid_location(0, -1), (0, -1))
|
||||
self.assertEqual(t.grid_location(0, 0), (0, 0))
|
||||
self.assertEqual(t.grid_location(200, 0), (0, 0))
|
||||
self.assertEqual(t.grid_location(201, 0), (1, 0))
|
||||
self.assertEqual(t.grid_location(0, 100), (0, 0))
|
||||
self.assertEqual(t.grid_location(0, 101), (0, 1))
|
||||
self.assertEqual(t.grid_location(201, 101), (1, 1))
|
||||
|
||||
def test_grid_propagate(self):
|
||||
self.assertEqual(self.root.grid_propagate(), True)
|
||||
with self.assertRaises(TypeError):
|
||||
self.root.grid_propagate(False, False)
|
||||
self.root.grid_propagate(False)
|
||||
self.assertFalse(self.root.grid_propagate())
|
||||
f = tkinter.Frame(self.root, width=100, height=100, bg='red')
|
||||
f.grid_configure(row=0, column=0)
|
||||
self.root.update()
|
||||
self.assertEqual(f.winfo_width(), 100)
|
||||
self.assertEqual(f.winfo_height(), 100)
|
||||
f.grid_propagate(False)
|
||||
g = tkinter.Frame(self.root, width=75, height=85, bg='green')
|
||||
g.grid_configure(in_=f, row=0, column=0)
|
||||
self.root.update()
|
||||
self.assertEqual(f.winfo_width(), 100)
|
||||
self.assertEqual(f.winfo_height(), 100)
|
||||
f.grid_propagate(True)
|
||||
self.root.update()
|
||||
self.assertEqual(f.winfo_width(), 75)
|
||||
self.assertEqual(f.winfo_height(), 85)
|
||||
|
||||
def test_grid_size(self):
|
||||
with self.assertRaises(TypeError):
|
||||
self.root.grid_size(0)
|
||||
self.assertEqual(self.root.grid_size(), (0, 0))
|
||||
f = tkinter.Scale(self.root)
|
||||
f.grid_configure(row=0, column=0)
|
||||
self.assertEqual(self.root.grid_size(), (1, 1))
|
||||
f.grid_configure(row=4, column=5)
|
||||
self.assertEqual(self.root.grid_size(), (6, 5))
|
||||
|
||||
def test_grid_slaves(self):
|
||||
self.assertEqual(self.root.grid_slaves(), [])
|
||||
a = tkinter.Label(self.root)
|
||||
a.grid_configure(row=0, column=1)
|
||||
b = tkinter.Label(self.root)
|
||||
b.grid_configure(row=1, column=0)
|
||||
c = tkinter.Label(self.root)
|
||||
c.grid_configure(row=1, column=1)
|
||||
d = tkinter.Label(self.root)
|
||||
d.grid_configure(row=1, column=1)
|
||||
self.assertEqual(self.root.grid_slaves(), [d, c, b, a])
|
||||
self.assertEqual(self.root.grid_slaves(row=0), [a])
|
||||
self.assertEqual(self.root.grid_slaves(row=1), [d, c, b])
|
||||
self.assertEqual(self.root.grid_slaves(column=0), [b])
|
||||
self.assertEqual(self.root.grid_slaves(column=1), [d, c, a])
|
||||
self.assertEqual(self.root.grid_slaves(row=1, column=1), [d, c])
|
||||
|
||||
|
||||
tests_gui = (
|
||||
PackTest, PlaceTest, GridTest,
|
||||
)
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -1,380 +0,0 @@
|
||||
import unittest
|
||||
import tkinter
|
||||
from test import support
|
||||
from test.support import os_helper
|
||||
from tkinter.test.support import AbstractTkTest, AbstractDefaultRootTest, requires_tcl
|
||||
|
||||
support.requires('gui')
|
||||
|
||||
|
||||
class MiscTest(AbstractTkTest, unittest.TestCase):
|
||||
|
||||
def test_image_types(self):
|
||||
image_types = self.root.image_types()
|
||||
self.assertIsInstance(image_types, tuple)
|
||||
self.assertIn('photo', image_types)
|
||||
self.assertIn('bitmap', image_types)
|
||||
|
||||
def test_image_names(self):
|
||||
image_names = self.root.image_names()
|
||||
self.assertIsInstance(image_names, tuple)
|
||||
|
||||
|
||||
class DefaultRootTest(AbstractDefaultRootTest, unittest.TestCase):
|
||||
|
||||
def test_image_types(self):
|
||||
self.assertRaises(RuntimeError, tkinter.image_types)
|
||||
root = tkinter.Tk()
|
||||
image_types = tkinter.image_types()
|
||||
self.assertIsInstance(image_types, tuple)
|
||||
self.assertIn('photo', image_types)
|
||||
self.assertIn('bitmap', image_types)
|
||||
root.destroy()
|
||||
tkinter.NoDefaultRoot()
|
||||
self.assertRaises(RuntimeError, tkinter.image_types)
|
||||
|
||||
def test_image_names(self):
|
||||
self.assertRaises(RuntimeError, tkinter.image_names)
|
||||
root = tkinter.Tk()
|
||||
image_names = tkinter.image_names()
|
||||
self.assertIsInstance(image_names, tuple)
|
||||
root.destroy()
|
||||
tkinter.NoDefaultRoot()
|
||||
self.assertRaises(RuntimeError, tkinter.image_names)
|
||||
|
||||
def test_image_create_bitmap(self):
|
||||
self.assertRaises(RuntimeError, tkinter.BitmapImage)
|
||||
root = tkinter.Tk()
|
||||
image = tkinter.BitmapImage()
|
||||
self.assertIn(image.name, tkinter.image_names())
|
||||
root.destroy()
|
||||
tkinter.NoDefaultRoot()
|
||||
self.assertRaises(RuntimeError, tkinter.BitmapImage)
|
||||
|
||||
def test_image_create_photo(self):
|
||||
self.assertRaises(RuntimeError, tkinter.PhotoImage)
|
||||
root = tkinter.Tk()
|
||||
image = tkinter.PhotoImage()
|
||||
self.assertIn(image.name, tkinter.image_names())
|
||||
root.destroy()
|
||||
tkinter.NoDefaultRoot()
|
||||
self.assertRaises(RuntimeError, tkinter.PhotoImage)
|
||||
|
||||
|
||||
class BitmapImageTest(AbstractTkTest, unittest.TestCase):
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
AbstractTkTest.setUpClass.__func__(cls)
|
||||
cls.testfile = support.findfile('python.xbm', subdir='imghdrdata')
|
||||
|
||||
def test_create_from_file(self):
|
||||
image = tkinter.BitmapImage('::img::test', master=self.root,
|
||||
foreground='yellow', background='blue',
|
||||
file=self.testfile)
|
||||
self.assertEqual(str(image), '::img::test')
|
||||
self.assertEqual(image.type(), 'bitmap')
|
||||
self.assertEqual(image.width(), 16)
|
||||
self.assertEqual(image.height(), 16)
|
||||
self.assertIn('::img::test', self.root.image_names())
|
||||
del image
|
||||
support.gc_collect() # For PyPy or other GCs.
|
||||
self.assertNotIn('::img::test', self.root.image_names())
|
||||
|
||||
def test_create_from_data(self):
|
||||
with open(self.testfile, 'rb') as f:
|
||||
data = f.read()
|
||||
image = tkinter.BitmapImage('::img::test', master=self.root,
|
||||
foreground='yellow', background='blue',
|
||||
data=data)
|
||||
self.assertEqual(str(image), '::img::test')
|
||||
self.assertEqual(image.type(), 'bitmap')
|
||||
self.assertEqual(image.width(), 16)
|
||||
self.assertEqual(image.height(), 16)
|
||||
self.assertIn('::img::test', self.root.image_names())
|
||||
del image
|
||||
support.gc_collect() # For PyPy or other GCs.
|
||||
self.assertNotIn('::img::test', self.root.image_names())
|
||||
|
||||
def assertEqualStrList(self, actual, expected):
|
||||
self.assertIsInstance(actual, str)
|
||||
self.assertEqual(self.root.splitlist(actual), expected)
|
||||
|
||||
def test_configure_data(self):
|
||||
image = tkinter.BitmapImage('::img::test', master=self.root)
|
||||
self.assertEqual(image['data'], '-data {} {} {} {}')
|
||||
with open(self.testfile, 'rb') as f:
|
||||
data = f.read()
|
||||
image.configure(data=data)
|
||||
self.assertEqualStrList(image['data'],
|
||||
('-data', '', '', '', data.decode('ascii')))
|
||||
self.assertEqual(image.width(), 16)
|
||||
self.assertEqual(image.height(), 16)
|
||||
|
||||
self.assertEqual(image['maskdata'], '-maskdata {} {} {} {}')
|
||||
image.configure(maskdata=data)
|
||||
self.assertEqualStrList(image['maskdata'],
|
||||
('-maskdata', '', '', '', data.decode('ascii')))
|
||||
|
||||
def test_configure_file(self):
|
||||
image = tkinter.BitmapImage('::img::test', master=self.root)
|
||||
self.assertEqual(image['file'], '-file {} {} {} {}')
|
||||
image.configure(file=self.testfile)
|
||||
self.assertEqualStrList(image['file'],
|
||||
('-file', '', '', '',self.testfile))
|
||||
self.assertEqual(image.width(), 16)
|
||||
self.assertEqual(image.height(), 16)
|
||||
|
||||
self.assertEqual(image['maskfile'], '-maskfile {} {} {} {}')
|
||||
image.configure(maskfile=self.testfile)
|
||||
self.assertEqualStrList(image['maskfile'],
|
||||
('-maskfile', '', '', '', self.testfile))
|
||||
|
||||
def test_configure_background(self):
|
||||
image = tkinter.BitmapImage('::img::test', master=self.root)
|
||||
self.assertEqual(image['background'], '-background {} {} {} {}')
|
||||
image.configure(background='blue')
|
||||
self.assertEqual(image['background'], '-background {} {} {} blue')
|
||||
|
||||
def test_configure_foreground(self):
|
||||
image = tkinter.BitmapImage('::img::test', master=self.root)
|
||||
self.assertEqual(image['foreground'],
|
||||
'-foreground {} {} #000000 #000000')
|
||||
image.configure(foreground='yellow')
|
||||
self.assertEqual(image['foreground'],
|
||||
'-foreground {} {} #000000 yellow')
|
||||
|
||||
|
||||
class PhotoImageTest(AbstractTkTest, unittest.TestCase):
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
AbstractTkTest.setUpClass.__func__(cls)
|
||||
cls.testfile = support.findfile('python.gif', subdir='imghdrdata')
|
||||
|
||||
def create(self):
|
||||
return tkinter.PhotoImage('::img::test', master=self.root,
|
||||
file=self.testfile)
|
||||
|
||||
def colorlist(self, *args):
|
||||
if tkinter.TkVersion >= 8.6 and self.wantobjects:
|
||||
return args
|
||||
else:
|
||||
return tkinter._join(args)
|
||||
|
||||
def check_create_from_file(self, ext):
|
||||
testfile = support.findfile('python.' + ext, subdir='imghdrdata')
|
||||
image = tkinter.PhotoImage('::img::test', master=self.root,
|
||||
file=testfile)
|
||||
self.assertEqual(str(image), '::img::test')
|
||||
self.assertEqual(image.type(), 'photo')
|
||||
self.assertEqual(image.width(), 16)
|
||||
self.assertEqual(image.height(), 16)
|
||||
self.assertEqual(image['data'], '')
|
||||
self.assertEqual(image['file'], testfile)
|
||||
self.assertIn('::img::test', self.root.image_names())
|
||||
del image
|
||||
support.gc_collect() # For PyPy or other GCs.
|
||||
self.assertNotIn('::img::test', self.root.image_names())
|
||||
|
||||
def check_create_from_data(self, ext):
|
||||
testfile = support.findfile('python.' + ext, subdir='imghdrdata')
|
||||
with open(testfile, 'rb') as f:
|
||||
data = f.read()
|
||||
image = tkinter.PhotoImage('::img::test', master=self.root,
|
||||
data=data)
|
||||
self.assertEqual(str(image), '::img::test')
|
||||
self.assertEqual(image.type(), 'photo')
|
||||
self.assertEqual(image.width(), 16)
|
||||
self.assertEqual(image.height(), 16)
|
||||
self.assertEqual(image['data'], data if self.wantobjects
|
||||
else data.decode('latin1'))
|
||||
self.assertEqual(image['file'], '')
|
||||
self.assertIn('::img::test', self.root.image_names())
|
||||
del image
|
||||
support.gc_collect() # For PyPy or other GCs.
|
||||
self.assertNotIn('::img::test', self.root.image_names())
|
||||
|
||||
def test_create_from_ppm_file(self):
|
||||
self.check_create_from_file('ppm')
|
||||
|
||||
def test_create_from_ppm_data(self):
|
||||
self.check_create_from_data('ppm')
|
||||
|
||||
def test_create_from_pgm_file(self):
|
||||
self.check_create_from_file('pgm')
|
||||
|
||||
def test_create_from_pgm_data(self):
|
||||
self.check_create_from_data('pgm')
|
||||
|
||||
def test_create_from_gif_file(self):
|
||||
self.check_create_from_file('gif')
|
||||
|
||||
def test_create_from_gif_data(self):
|
||||
self.check_create_from_data('gif')
|
||||
|
||||
@requires_tcl(8, 6)
|
||||
def test_create_from_png_file(self):
|
||||
self.check_create_from_file('png')
|
||||
|
||||
@requires_tcl(8, 6)
|
||||
def test_create_from_png_data(self):
|
||||
self.check_create_from_data('png')
|
||||
|
||||
def test_configure_data(self):
|
||||
image = tkinter.PhotoImage('::img::test', master=self.root)
|
||||
self.assertEqual(image['data'], '')
|
||||
with open(self.testfile, 'rb') as f:
|
||||
data = f.read()
|
||||
image.configure(data=data)
|
||||
self.assertEqual(image['data'], data if self.wantobjects
|
||||
else data.decode('latin1'))
|
||||
self.assertEqual(image.width(), 16)
|
||||
self.assertEqual(image.height(), 16)
|
||||
|
||||
def test_configure_format(self):
|
||||
image = tkinter.PhotoImage('::img::test', master=self.root)
|
||||
self.assertEqual(image['format'], '')
|
||||
image.configure(file=self.testfile, format='gif')
|
||||
self.assertEqual(image['format'], ('gif',) if self.wantobjects
|
||||
else 'gif')
|
||||
self.assertEqual(image.width(), 16)
|
||||
self.assertEqual(image.height(), 16)
|
||||
|
||||
def test_configure_file(self):
|
||||
image = tkinter.PhotoImage('::img::test', master=self.root)
|
||||
self.assertEqual(image['file'], '')
|
||||
image.configure(file=self.testfile)
|
||||
self.assertEqual(image['file'], self.testfile)
|
||||
self.assertEqual(image.width(), 16)
|
||||
self.assertEqual(image.height(), 16)
|
||||
|
||||
def test_configure_gamma(self):
|
||||
image = tkinter.PhotoImage('::img::test', master=self.root)
|
||||
self.assertEqual(image['gamma'], '1.0')
|
||||
image.configure(gamma=2.0)
|
||||
self.assertEqual(image['gamma'], '2.0')
|
||||
|
||||
def test_configure_width_height(self):
|
||||
image = tkinter.PhotoImage('::img::test', master=self.root)
|
||||
self.assertEqual(image['width'], '0')
|
||||
self.assertEqual(image['height'], '0')
|
||||
image.configure(width=20)
|
||||
image.configure(height=10)
|
||||
self.assertEqual(image['width'], '20')
|
||||
self.assertEqual(image['height'], '10')
|
||||
self.assertEqual(image.width(), 20)
|
||||
self.assertEqual(image.height(), 10)
|
||||
|
||||
def test_configure_palette(self):
|
||||
image = tkinter.PhotoImage('::img::test', master=self.root)
|
||||
self.assertEqual(image['palette'], '')
|
||||
image.configure(palette=256)
|
||||
self.assertEqual(image['palette'], '256')
|
||||
image.configure(palette='3/4/2')
|
||||
self.assertEqual(image['palette'], '3/4/2')
|
||||
|
||||
def test_blank(self):
|
||||
image = self.create()
|
||||
image.blank()
|
||||
self.assertEqual(image.width(), 16)
|
||||
self.assertEqual(image.height(), 16)
|
||||
self.assertEqual(image.get(4, 6), self.colorlist(0, 0, 0))
|
||||
|
||||
def test_copy(self):
|
||||
image = self.create()
|
||||
image2 = image.copy()
|
||||
self.assertEqual(image2.width(), 16)
|
||||
self.assertEqual(image2.height(), 16)
|
||||
self.assertEqual(image.get(4, 6), image.get(4, 6))
|
||||
|
||||
def test_subsample(self):
|
||||
image = self.create()
|
||||
image2 = image.subsample(2, 3)
|
||||
self.assertEqual(image2.width(), 8)
|
||||
self.assertEqual(image2.height(), 6)
|
||||
self.assertEqual(image2.get(2, 2), image.get(4, 6))
|
||||
|
||||
image2 = image.subsample(2)
|
||||
self.assertEqual(image2.width(), 8)
|
||||
self.assertEqual(image2.height(), 8)
|
||||
self.assertEqual(image2.get(2, 3), image.get(4, 6))
|
||||
|
||||
def test_zoom(self):
|
||||
image = self.create()
|
||||
image2 = image.zoom(2, 3)
|
||||
self.assertEqual(image2.width(), 32)
|
||||
self.assertEqual(image2.height(), 48)
|
||||
self.assertEqual(image2.get(8, 18), image.get(4, 6))
|
||||
self.assertEqual(image2.get(9, 20), image.get(4, 6))
|
||||
|
||||
image2 = image.zoom(2)
|
||||
self.assertEqual(image2.width(), 32)
|
||||
self.assertEqual(image2.height(), 32)
|
||||
self.assertEqual(image2.get(8, 12), image.get(4, 6))
|
||||
self.assertEqual(image2.get(9, 13), image.get(4, 6))
|
||||
|
||||
def test_put(self):
|
||||
image = self.create()
|
||||
image.put('{red green} {blue yellow}', to=(4, 6))
|
||||
self.assertEqual(image.get(4, 6), self.colorlist(255, 0, 0))
|
||||
self.assertEqual(image.get(5, 6),
|
||||
self.colorlist(0, 128 if tkinter.TkVersion >= 8.6
|
||||
else 255, 0))
|
||||
self.assertEqual(image.get(4, 7), self.colorlist(0, 0, 255))
|
||||
self.assertEqual(image.get(5, 7), self.colorlist(255, 255, 0))
|
||||
|
||||
image.put((('#f00', '#00ff00'), ('#000000fff', '#ffffffff0000')))
|
||||
self.assertEqual(image.get(0, 0), self.colorlist(255, 0, 0))
|
||||
self.assertEqual(image.get(1, 0), self.colorlist(0, 255, 0))
|
||||
self.assertEqual(image.get(0, 1), self.colorlist(0, 0, 255))
|
||||
self.assertEqual(image.get(1, 1), self.colorlist(255, 255, 0))
|
||||
|
||||
def test_get(self):
|
||||
image = self.create()
|
||||
self.assertEqual(image.get(4, 6), self.colorlist(62, 116, 162))
|
||||
self.assertEqual(image.get(0, 0), self.colorlist(0, 0, 0))
|
||||
self.assertEqual(image.get(15, 15), self.colorlist(0, 0, 0))
|
||||
self.assertRaises(tkinter.TclError, image.get, -1, 0)
|
||||
self.assertRaises(tkinter.TclError, image.get, 0, -1)
|
||||
self.assertRaises(tkinter.TclError, image.get, 16, 15)
|
||||
self.assertRaises(tkinter.TclError, image.get, 15, 16)
|
||||
|
||||
def test_write(self):
|
||||
image = self.create()
|
||||
self.addCleanup(os_helper.unlink, os_helper.TESTFN)
|
||||
|
||||
image.write(os_helper.TESTFN)
|
||||
image2 = tkinter.PhotoImage('::img::test2', master=self.root,
|
||||
format='ppm',
|
||||
file=os_helper.TESTFN)
|
||||
self.assertEqual(str(image2), '::img::test2')
|
||||
self.assertEqual(image2.type(), 'photo')
|
||||
self.assertEqual(image2.width(), 16)
|
||||
self.assertEqual(image2.height(), 16)
|
||||
self.assertEqual(image2.get(0, 0), image.get(0, 0))
|
||||
self.assertEqual(image2.get(15, 8), image.get(15, 8))
|
||||
|
||||
image.write(os_helper.TESTFN, format='gif', from_coords=(4, 6, 6, 9))
|
||||
image3 = tkinter.PhotoImage('::img::test3', master=self.root,
|
||||
format='gif',
|
||||
file=os_helper.TESTFN)
|
||||
self.assertEqual(str(image3), '::img::test3')
|
||||
self.assertEqual(image3.type(), 'photo')
|
||||
self.assertEqual(image3.width(), 2)
|
||||
self.assertEqual(image3.height(), 3)
|
||||
self.assertEqual(image3.get(0, 0), image.get(4, 6))
|
||||
self.assertEqual(image3.get(1, 2), image.get(5, 8))
|
||||
|
||||
def test_transparency(self):
|
||||
image = self.create()
|
||||
self.assertEqual(image.transparency_get(0, 0), True)
|
||||
self.assertEqual(image.transparency_get(4, 6), False)
|
||||
image.transparency_set(4, 6, True)
|
||||
self.assertEqual(image.transparency_get(4, 6), True)
|
||||
image.transparency_set(4, 6, False)
|
||||
self.assertEqual(image.transparency_get(4, 6), False)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -1,46 +0,0 @@
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
import test.support as test_support
|
||||
from test.support import os_helper
|
||||
from tkinter import Tcl, TclError
|
||||
|
||||
test_support.requires('gui')
|
||||
|
||||
class TkLoadTest(unittest.TestCase):
|
||||
|
||||
@unittest.skipIf('DISPLAY' not in os.environ, 'No $DISPLAY set.')
|
||||
def testLoadTk(self):
|
||||
tcl = Tcl()
|
||||
self.assertRaises(TclError,tcl.winfo_geometry)
|
||||
tcl.loadtk()
|
||||
self.assertEqual('1x1+0+0', tcl.winfo_geometry())
|
||||
tcl.destroy()
|
||||
|
||||
def testLoadTkFailure(self):
|
||||
old_display = None
|
||||
if sys.platform.startswith(('win', 'darwin', 'cygwin')):
|
||||
# no failure possible on windows?
|
||||
|
||||
# XXX Maybe on tk older than 8.4.13 it would be possible,
|
||||
# see tkinter.h.
|
||||
return
|
||||
with os_helper.EnvironmentVarGuard() as env:
|
||||
if 'DISPLAY' in os.environ:
|
||||
del env['DISPLAY']
|
||||
# on some platforms, deleting environment variables
|
||||
# doesn't actually carry through to the process level
|
||||
# because they don't support unsetenv
|
||||
# If that's the case, abort.
|
||||
with os.popen('echo $DISPLAY') as pipe:
|
||||
display = pipe.read().strip()
|
||||
if display:
|
||||
return
|
||||
|
||||
tcl = Tcl()
|
||||
self.assertRaises(TclError, tcl.winfo_geometry)
|
||||
self.assertRaises(TclError, tcl.loadtk)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -1,36 +0,0 @@
|
||||
import unittest
|
||||
import tkinter
|
||||
from test.support import requires, swap_attr
|
||||
from tkinter.test.support import AbstractDefaultRootTest
|
||||
from tkinter.commondialog import Dialog
|
||||
from tkinter.messagebox import showinfo
|
||||
|
||||
requires('gui')
|
||||
|
||||
|
||||
class DefaultRootTest(AbstractDefaultRootTest, unittest.TestCase):
|
||||
|
||||
def test_showinfo(self):
|
||||
def test_callback(dialog, master):
|
||||
nonlocal ismapped
|
||||
master.update()
|
||||
ismapped = master.winfo_ismapped()
|
||||
raise ZeroDivisionError
|
||||
|
||||
with swap_attr(Dialog, '_test_callback', test_callback):
|
||||
ismapped = None
|
||||
self.assertRaises(ZeroDivisionError, showinfo, "Spam", "Egg Information")
|
||||
self.assertEqual(ismapped, False)
|
||||
|
||||
root = tkinter.Tk()
|
||||
ismapped = None
|
||||
self.assertRaises(ZeroDivisionError, showinfo, "Spam", "Egg Information")
|
||||
self.assertEqual(ismapped, True)
|
||||
root.destroy()
|
||||
|
||||
tkinter.NoDefaultRoot()
|
||||
self.assertRaises(RuntimeError, showinfo, "Spam", "Egg Information")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -1,430 +0,0 @@
|
||||
import functools
|
||||
import unittest
|
||||
import tkinter
|
||||
import enum
|
||||
from test import support
|
||||
from tkinter.test.support import AbstractTkTest, AbstractDefaultRootTest
|
||||
|
||||
support.requires('gui')
|
||||
|
||||
class MiscTest(AbstractTkTest, unittest.TestCase):
|
||||
|
||||
def test_all(self):
|
||||
self.assertIn("Widget", tkinter.__all__)
|
||||
# Check that variables from tkinter.constants are also in tkinter.__all__
|
||||
self.assertIn("CASCADE", tkinter.__all__)
|
||||
self.assertIsNotNone(tkinter.CASCADE)
|
||||
# Check that sys, re, and constants are not in tkinter.__all__
|
||||
self.assertNotIn("re", tkinter.__all__)
|
||||
self.assertNotIn("sys", tkinter.__all__)
|
||||
self.assertNotIn("constants", tkinter.__all__)
|
||||
# Check that an underscored functions is not in tkinter.__all__
|
||||
self.assertNotIn("_tkerror", tkinter.__all__)
|
||||
# Check that wantobjects is not in tkinter.__all__
|
||||
self.assertNotIn("wantobjects", tkinter.__all__)
|
||||
|
||||
def test_repr(self):
|
||||
t = tkinter.Toplevel(self.root, name='top')
|
||||
f = tkinter.Frame(t, name='child')
|
||||
self.assertEqual(repr(f), '<tkinter.Frame object .top.child>')
|
||||
|
||||
def test_generated_names(self):
|
||||
t = tkinter.Toplevel(self.root)
|
||||
f = tkinter.Frame(t)
|
||||
f2 = tkinter.Frame(t)
|
||||
b = tkinter.Button(f2)
|
||||
for name in str(b).split('.'):
|
||||
self.assertFalse(name.isidentifier(), msg=repr(name))
|
||||
|
||||
def test_tk_setPalette(self):
|
||||
root = self.root
|
||||
root.tk_setPalette('black')
|
||||
self.assertEqual(root['background'], 'black')
|
||||
root.tk_setPalette('white')
|
||||
self.assertEqual(root['background'], 'white')
|
||||
self.assertRaisesRegex(tkinter.TclError,
|
||||
'^unknown color name "spam"$',
|
||||
root.tk_setPalette, 'spam')
|
||||
|
||||
root.tk_setPalette(background='black')
|
||||
self.assertEqual(root['background'], 'black')
|
||||
root.tk_setPalette(background='blue', highlightColor='yellow')
|
||||
self.assertEqual(root['background'], 'blue')
|
||||
self.assertEqual(root['highlightcolor'], 'yellow')
|
||||
root.tk_setPalette(background='yellow', highlightColor='blue')
|
||||
self.assertEqual(root['background'], 'yellow')
|
||||
self.assertEqual(root['highlightcolor'], 'blue')
|
||||
self.assertRaisesRegex(tkinter.TclError,
|
||||
'^unknown color name "spam"$',
|
||||
root.tk_setPalette, background='spam')
|
||||
self.assertRaisesRegex(tkinter.TclError,
|
||||
'^must specify a background color$',
|
||||
root.tk_setPalette, spam='white')
|
||||
self.assertRaisesRegex(tkinter.TclError,
|
||||
'^must specify a background color$',
|
||||
root.tk_setPalette, highlightColor='blue')
|
||||
|
||||
def test_after(self):
|
||||
root = self.root
|
||||
|
||||
def callback(start=0, step=1):
|
||||
nonlocal count
|
||||
count = start + step
|
||||
|
||||
# Without function, sleeps for ms.
|
||||
self.assertIsNone(root.after(1))
|
||||
|
||||
# Set up with callback with no args.
|
||||
count = 0
|
||||
timer1 = root.after(0, callback)
|
||||
self.assertIn(timer1, root.tk.call('after', 'info'))
|
||||
(script, _) = root.tk.splitlist(root.tk.call('after', 'info', timer1))
|
||||
root.update() # Process all pending events.
|
||||
self.assertEqual(count, 1)
|
||||
with self.assertRaises(tkinter.TclError):
|
||||
root.tk.call(script)
|
||||
|
||||
# Set up with callback with args.
|
||||
count = 0
|
||||
timer1 = root.after(0, callback, 42, 11)
|
||||
root.update() # Process all pending events.
|
||||
self.assertEqual(count, 53)
|
||||
|
||||
# Cancel before called.
|
||||
timer1 = root.after(1000, callback)
|
||||
self.assertIn(timer1, root.tk.call('after', 'info'))
|
||||
(script, _) = root.tk.splitlist(root.tk.call('after', 'info', timer1))
|
||||
root.after_cancel(timer1) # Cancel this event.
|
||||
self.assertEqual(count, 53)
|
||||
with self.assertRaises(tkinter.TclError):
|
||||
root.tk.call(script)
|
||||
|
||||
# Call with a callable class
|
||||
count = 0
|
||||
timer1 = root.after(0, functools.partial(callback, 42, 11))
|
||||
root.update() # Process all pending events.
|
||||
self.assertEqual(count, 53)
|
||||
|
||||
def test_after_idle(self):
|
||||
root = self.root
|
||||
|
||||
def callback(start=0, step=1):
|
||||
nonlocal count
|
||||
count = start + step
|
||||
|
||||
# Set up with callback with no args.
|
||||
count = 0
|
||||
idle1 = root.after_idle(callback)
|
||||
self.assertIn(idle1, root.tk.call('after', 'info'))
|
||||
(script, _) = root.tk.splitlist(root.tk.call('after', 'info', idle1))
|
||||
root.update_idletasks() # Process all pending events.
|
||||
self.assertEqual(count, 1)
|
||||
with self.assertRaises(tkinter.TclError):
|
||||
root.tk.call(script)
|
||||
|
||||
# Set up with callback with args.
|
||||
count = 0
|
||||
idle1 = root.after_idle(callback, 42, 11)
|
||||
root.update_idletasks() # Process all pending events.
|
||||
self.assertEqual(count, 53)
|
||||
|
||||
# Cancel before called.
|
||||
idle1 = root.after_idle(callback)
|
||||
self.assertIn(idle1, root.tk.call('after', 'info'))
|
||||
(script, _) = root.tk.splitlist(root.tk.call('after', 'info', idle1))
|
||||
root.after_cancel(idle1) # Cancel this event.
|
||||
self.assertEqual(count, 53)
|
||||
with self.assertRaises(tkinter.TclError):
|
||||
root.tk.call(script)
|
||||
|
||||
def test_after_cancel(self):
|
||||
root = self.root
|
||||
|
||||
def callback():
|
||||
nonlocal count
|
||||
count += 1
|
||||
|
||||
timer1 = root.after(5000, callback)
|
||||
idle1 = root.after_idle(callback)
|
||||
|
||||
# No value for id raises a ValueError.
|
||||
with self.assertRaises(ValueError):
|
||||
root.after_cancel(None)
|
||||
|
||||
# Cancel timer event.
|
||||
count = 0
|
||||
(script, _) = root.tk.splitlist(root.tk.call('after', 'info', timer1))
|
||||
root.tk.call(script)
|
||||
self.assertEqual(count, 1)
|
||||
root.after_cancel(timer1)
|
||||
with self.assertRaises(tkinter.TclError):
|
||||
root.tk.call(script)
|
||||
self.assertEqual(count, 1)
|
||||
with self.assertRaises(tkinter.TclError):
|
||||
root.tk.call('after', 'info', timer1)
|
||||
|
||||
# Cancel same event - nothing happens.
|
||||
root.after_cancel(timer1)
|
||||
|
||||
# Cancel idle event.
|
||||
count = 0
|
||||
(script, _) = root.tk.splitlist(root.tk.call('after', 'info', idle1))
|
||||
root.tk.call(script)
|
||||
self.assertEqual(count, 1)
|
||||
root.after_cancel(idle1)
|
||||
with self.assertRaises(tkinter.TclError):
|
||||
root.tk.call(script)
|
||||
self.assertEqual(count, 1)
|
||||
with self.assertRaises(tkinter.TclError):
|
||||
root.tk.call('after', 'info', idle1)
|
||||
|
||||
def test_clipboard(self):
|
||||
root = self.root
|
||||
root.clipboard_clear()
|
||||
root.clipboard_append('Ùñî')
|
||||
self.assertEqual(root.clipboard_get(), 'Ùñî')
|
||||
root.clipboard_append('çōđě')
|
||||
self.assertEqual(root.clipboard_get(), 'Ùñîçōđě')
|
||||
root.clipboard_clear()
|
||||
with self.assertRaises(tkinter.TclError):
|
||||
root.clipboard_get()
|
||||
|
||||
def test_clipboard_astral(self):
|
||||
root = self.root
|
||||
root.clipboard_clear()
|
||||
root.clipboard_append('𝔘𝔫𝔦')
|
||||
self.assertEqual(root.clipboard_get(), '𝔘𝔫𝔦')
|
||||
root.clipboard_append('𝔠𝔬𝔡𝔢')
|
||||
self.assertEqual(root.clipboard_get(), '𝔘𝔫𝔦𝔠𝔬𝔡𝔢')
|
||||
root.clipboard_clear()
|
||||
with self.assertRaises(tkinter.TclError):
|
||||
root.clipboard_get()
|
||||
|
||||
def test_winfo_rgb(self):
|
||||
|
||||
def assertApprox(col1, col2):
|
||||
# A small amount of flexibility is required (bpo-45496)
|
||||
# 33 is ~0.05% of 65535, which is a reasonable margin
|
||||
for col1_channel, col2_channel in zip(col1, col2):
|
||||
self.assertAlmostEqual(col1_channel, col2_channel, delta=33)
|
||||
|
||||
root = self.root
|
||||
rgb = root.winfo_rgb
|
||||
|
||||
# Color name.
|
||||
self.assertEqual(rgb('red'), (65535, 0, 0))
|
||||
self.assertEqual(rgb('dark slate blue'), (18504, 15677, 35723))
|
||||
# #RGB - extends each 4-bit hex value to be 16-bit.
|
||||
self.assertEqual(rgb('#F0F'), (0xFFFF, 0x0000, 0xFFFF))
|
||||
# #RRGGBB - extends each 8-bit hex value to be 16-bit.
|
||||
assertApprox(rgb('#4a3c8c'), (0x4a4a, 0x3c3c, 0x8c8c))
|
||||
# #RRRRGGGGBBBB
|
||||
assertApprox(rgb('#dede14143939'), (0xdede, 0x1414, 0x3939))
|
||||
# Invalid string.
|
||||
with self.assertRaises(tkinter.TclError):
|
||||
rgb('#123456789a')
|
||||
# RGB triplet is invalid input.
|
||||
with self.assertRaises(tkinter.TclError):
|
||||
rgb((111, 78, 55))
|
||||
|
||||
def test_event_repr_defaults(self):
|
||||
e = tkinter.Event()
|
||||
e.serial = 12345
|
||||
e.num = '??'
|
||||
e.height = '??'
|
||||
e.keycode = '??'
|
||||
e.state = 0
|
||||
e.time = 123456789
|
||||
e.width = '??'
|
||||
e.x = '??'
|
||||
e.y = '??'
|
||||
e.char = ''
|
||||
e.keysym = '??'
|
||||
e.keysym_num = '??'
|
||||
e.type = '100'
|
||||
e.widget = '??'
|
||||
e.x_root = '??'
|
||||
e.y_root = '??'
|
||||
e.delta = 0
|
||||
self.assertEqual(repr(e), '<100 event>')
|
||||
|
||||
def test_event_repr(self):
|
||||
e = tkinter.Event()
|
||||
e.serial = 12345
|
||||
e.num = 3
|
||||
e.focus = True
|
||||
e.height = 200
|
||||
e.keycode = 65
|
||||
e.state = 0x30405
|
||||
e.time = 123456789
|
||||
e.width = 300
|
||||
e.x = 10
|
||||
e.y = 20
|
||||
e.char = 'A'
|
||||
e.send_event = True
|
||||
e.keysym = 'Key-A'
|
||||
e.keysym_num = ord('A')
|
||||
e.type = tkinter.EventType.Configure
|
||||
e.widget = '.text'
|
||||
e.x_root = 1010
|
||||
e.y_root = 1020
|
||||
e.delta = -1
|
||||
self.assertEqual(repr(e),
|
||||
"<Configure event send_event=True"
|
||||
" state=Shift|Control|Button3|0x30000"
|
||||
" keysym=Key-A keycode=65 char='A'"
|
||||
" num=3 delta=-1 focus=True"
|
||||
" x=10 y=20 width=300 height=200>")
|
||||
|
||||
def test_eventtype_enum(self):
|
||||
class CheckedEventType(enum.StrEnum):
|
||||
KeyPress = '2'
|
||||
Key = KeyPress
|
||||
KeyRelease = '3'
|
||||
ButtonPress = '4'
|
||||
Button = ButtonPress
|
||||
ButtonRelease = '5'
|
||||
Motion = '6'
|
||||
Enter = '7'
|
||||
Leave = '8'
|
||||
FocusIn = '9'
|
||||
FocusOut = '10'
|
||||
Keymap = '11' # undocumented
|
||||
Expose = '12'
|
||||
GraphicsExpose = '13' # undocumented
|
||||
NoExpose = '14' # undocumented
|
||||
Visibility = '15'
|
||||
Create = '16'
|
||||
Destroy = '17'
|
||||
Unmap = '18'
|
||||
Map = '19'
|
||||
MapRequest = '20'
|
||||
Reparent = '21'
|
||||
Configure = '22'
|
||||
ConfigureRequest = '23'
|
||||
Gravity = '24'
|
||||
ResizeRequest = '25'
|
||||
Circulate = '26'
|
||||
CirculateRequest = '27'
|
||||
Property = '28'
|
||||
SelectionClear = '29' # undocumented
|
||||
SelectionRequest = '30' # undocumented
|
||||
Selection = '31' # undocumented
|
||||
Colormap = '32'
|
||||
ClientMessage = '33' # undocumented
|
||||
Mapping = '34' # undocumented
|
||||
VirtualEvent = '35' # undocumented
|
||||
Activate = '36'
|
||||
Deactivate = '37'
|
||||
MouseWheel = '38'
|
||||
enum._test_simple_enum(CheckedEventType, tkinter.EventType)
|
||||
|
||||
def test_getboolean(self):
|
||||
for v in 'true', 'yes', 'on', '1', 't', 'y', 1, True:
|
||||
self.assertIs(self.root.getboolean(v), True)
|
||||
for v in 'false', 'no', 'off', '0', 'f', 'n', 0, False:
|
||||
self.assertIs(self.root.getboolean(v), False)
|
||||
self.assertRaises(ValueError, self.root.getboolean, 'yea')
|
||||
self.assertRaises(ValueError, self.root.getboolean, '')
|
||||
self.assertRaises(TypeError, self.root.getboolean, None)
|
||||
self.assertRaises(TypeError, self.root.getboolean, ())
|
||||
|
||||
def test_mainloop(self):
|
||||
log = []
|
||||
def callback():
|
||||
log.append(1)
|
||||
self.root.after(100, self.root.quit)
|
||||
self.root.after(100, callback)
|
||||
self.root.mainloop(1)
|
||||
self.assertEqual(log, [])
|
||||
self.root.mainloop(0)
|
||||
self.assertEqual(log, [1])
|
||||
self.assertTrue(self.root.winfo_exists())
|
||||
|
||||
def test_info_patchlevel(self):
|
||||
vi = self.root.info_patchlevel()
|
||||
f = tkinter.Frame(self.root)
|
||||
self.assertEqual(f.info_patchlevel(), vi)
|
||||
# The following is almost a copy of tests for sys.version_info.
|
||||
self.assertIsInstance(vi[:], tuple)
|
||||
self.assertEqual(len(vi), 5)
|
||||
self.assertIsInstance(vi[0], int)
|
||||
self.assertIsInstance(vi[1], int)
|
||||
self.assertIsInstance(vi[2], int)
|
||||
self.assertIn(vi[3], ("alpha", "beta", "candidate", "final"))
|
||||
self.assertIsInstance(vi[4], int)
|
||||
self.assertIsInstance(vi.major, int)
|
||||
self.assertIsInstance(vi.minor, int)
|
||||
self.assertIsInstance(vi.micro, int)
|
||||
self.assertIn(vi.releaselevel, ("alpha", "beta", "final"))
|
||||
self.assertIsInstance(vi.serial, int)
|
||||
self.assertEqual(vi[0], vi.major)
|
||||
self.assertEqual(vi[1], vi.minor)
|
||||
self.assertEqual(vi[2], vi.micro)
|
||||
self.assertEqual(vi[3], vi.releaselevel)
|
||||
self.assertEqual(vi[4], vi.serial)
|
||||
self.assertTrue(vi > (1,0,0))
|
||||
if vi.releaselevel == 'final':
|
||||
self.assertEqual(vi.serial, 0)
|
||||
else:
|
||||
self.assertEqual(vi.micro, 0)
|
||||
self.assertTrue(str(vi).startswith(f'{vi.major}.{vi.minor}'))
|
||||
|
||||
|
||||
class DefaultRootTest(AbstractDefaultRootTest, unittest.TestCase):
|
||||
|
||||
def test_default_root(self):
|
||||
self.assertIs(tkinter._support_default_root, True)
|
||||
self.assertIsNone(tkinter._default_root)
|
||||
root = tkinter.Tk()
|
||||
root2 = tkinter.Tk()
|
||||
root3 = tkinter.Tk()
|
||||
self.assertIs(tkinter._default_root, root)
|
||||
root2.destroy()
|
||||
self.assertIs(tkinter._default_root, root)
|
||||
root.destroy()
|
||||
self.assertIsNone(tkinter._default_root)
|
||||
root3.destroy()
|
||||
self.assertIsNone(tkinter._default_root)
|
||||
|
||||
def test_no_default_root(self):
|
||||
self.assertIs(tkinter._support_default_root, True)
|
||||
self.assertIsNone(tkinter._default_root)
|
||||
root = tkinter.Tk()
|
||||
self.assertIs(tkinter._default_root, root)
|
||||
tkinter.NoDefaultRoot()
|
||||
self.assertIs(tkinter._support_default_root, False)
|
||||
self.assertFalse(hasattr(tkinter, '_default_root'))
|
||||
# repeated call is no-op
|
||||
tkinter.NoDefaultRoot()
|
||||
self.assertIs(tkinter._support_default_root, False)
|
||||
self.assertFalse(hasattr(tkinter, '_default_root'))
|
||||
root.destroy()
|
||||
self.assertIs(tkinter._support_default_root, False)
|
||||
self.assertFalse(hasattr(tkinter, '_default_root'))
|
||||
root = tkinter.Tk()
|
||||
self.assertIs(tkinter._support_default_root, False)
|
||||
self.assertFalse(hasattr(tkinter, '_default_root'))
|
||||
root.destroy()
|
||||
|
||||
def test_getboolean(self):
|
||||
self.assertRaises(RuntimeError, tkinter.getboolean, '1')
|
||||
root = tkinter.Tk()
|
||||
self.assertIs(tkinter.getboolean('1'), True)
|
||||
self.assertRaises(ValueError, tkinter.getboolean, 'yea')
|
||||
root.destroy()
|
||||
tkinter.NoDefaultRoot()
|
||||
self.assertRaises(RuntimeError, tkinter.getboolean, '1')
|
||||
|
||||
def test_mainloop(self):
|
||||
self.assertRaises(RuntimeError, tkinter.mainloop)
|
||||
root = tkinter.Tk()
|
||||
root.after_idle(root.quit)
|
||||
tkinter.mainloop()
|
||||
root.destroy()
|
||||
tkinter.NoDefaultRoot()
|
||||
self.assertRaises(RuntimeError, tkinter.mainloop)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -1,35 +0,0 @@
|
||||
import unittest
|
||||
import tkinter
|
||||
from test.support import requires, swap_attr
|
||||
from tkinter.test.support import AbstractDefaultRootTest
|
||||
from tkinter.simpledialog import Dialog, askinteger
|
||||
|
||||
requires('gui')
|
||||
|
||||
|
||||
class DefaultRootTest(AbstractDefaultRootTest, unittest.TestCase):
|
||||
|
||||
def test_askinteger(self):
|
||||
@staticmethod
|
||||
def mock_wait_window(w):
|
||||
nonlocal ismapped
|
||||
ismapped = w.master.winfo_ismapped()
|
||||
w.destroy()
|
||||
|
||||
with swap_attr(Dialog, 'wait_window', mock_wait_window):
|
||||
ismapped = None
|
||||
askinteger("Go To Line", "Line number")
|
||||
self.assertEqual(ismapped, False)
|
||||
|
||||
root = tkinter.Tk()
|
||||
ismapped = None
|
||||
askinteger("Go To Line", "Line number")
|
||||
self.assertEqual(ismapped, True)
|
||||
root.destroy()
|
||||
|
||||
tkinter.NoDefaultRoot()
|
||||
self.assertRaises(RuntimeError, askinteger, "Go To Line", "Line number")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -1,97 +0,0 @@
|
||||
import unittest
|
||||
import tkinter
|
||||
from test.support import requires
|
||||
from tkinter.test.support import AbstractTkTest
|
||||
|
||||
requires('gui')
|
||||
|
||||
class TextTest(AbstractTkTest, unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
super().setUp()
|
||||
self.text = tkinter.Text(self.root)
|
||||
|
||||
def test_debug(self):
|
||||
text = self.text
|
||||
olddebug = text.debug()
|
||||
try:
|
||||
text.debug(0)
|
||||
self.assertEqual(text.debug(), 0)
|
||||
text.debug(1)
|
||||
self.assertEqual(text.debug(), 1)
|
||||
finally:
|
||||
text.debug(olddebug)
|
||||
self.assertEqual(text.debug(), olddebug)
|
||||
|
||||
def test_search(self):
|
||||
text = self.text
|
||||
|
||||
# pattern and index are obligatory arguments.
|
||||
self.assertRaises(tkinter.TclError, text.search, None, '1.0')
|
||||
self.assertRaises(tkinter.TclError, text.search, 'a', None)
|
||||
self.assertRaises(tkinter.TclError, text.search, None, None)
|
||||
|
||||
# Invalid text index.
|
||||
self.assertRaises(tkinter.TclError, text.search, '', 0)
|
||||
|
||||
# Check if we are getting the indices as strings -- you are likely
|
||||
# to get Tcl_Obj under Tk 8.5 if Tkinter doesn't convert it.
|
||||
text.insert('1.0', 'hi-test')
|
||||
self.assertEqual(text.search('-test', '1.0', 'end'), '1.2')
|
||||
self.assertEqual(text.search('test', '1.0', 'end'), '1.3')
|
||||
|
||||
def test_count(self):
|
||||
# XXX Some assertions do not check against the intended result,
|
||||
# but instead check the current result to prevent regression.
|
||||
text = self.text
|
||||
text.insert('1.0',
|
||||
'Lorem ipsum dolor sit amet,\n'
|
||||
'consectetur adipiscing elit,\n'
|
||||
'sed do eiusmod tempor incididunt\n'
|
||||
'ut labore et dolore magna aliqua.')
|
||||
|
||||
options = ('chars', 'indices', 'lines',
|
||||
'displaychars', 'displayindices', 'displaylines',
|
||||
'xpixels', 'ypixels')
|
||||
if self.wantobjects:
|
||||
self.assertEqual(len(text.count('1.0', 'end', *options)), 8)
|
||||
else:
|
||||
text.count('1.0', 'end', *options)
|
||||
self.assertEqual(text.count('1.0', 'end', 'chars', 'lines'), (124, 4)
|
||||
if self.wantobjects else '124 4')
|
||||
self.assertEqual(text.count('1.3', '4.5', 'chars', 'lines'), (92, 3)
|
||||
if self.wantobjects else '92 3')
|
||||
self.assertEqual(text.count('4.5', '1.3', 'chars', 'lines'), (-92, -3)
|
||||
if self.wantobjects else '-92 -3')
|
||||
self.assertEqual(text.count('1.3', '1.3', 'chars', 'lines'), (0, 0)
|
||||
if self.wantobjects else '0 0')
|
||||
self.assertEqual(text.count('1.0', 'end', 'lines'), (4,)
|
||||
if self.wantobjects else ('4',))
|
||||
self.assertEqual(text.count('end', '1.0', 'lines'), (-4,)
|
||||
if self.wantobjects else ('-4',))
|
||||
self.assertEqual(text.count('1.3', '1.5', 'lines'), None
|
||||
if self.wantobjects else ('0',))
|
||||
self.assertEqual(text.count('1.3', '1.3', 'lines'), None
|
||||
if self.wantobjects else ('0',))
|
||||
self.assertEqual(text.count('1.0', 'end'), (124,) # 'indices' by default
|
||||
if self.wantobjects else ('124',))
|
||||
self.assertRaises(tkinter.TclError, text.count, '1.0', 'end', 'spam')
|
||||
self.assertRaises(tkinter.TclError, text.count, '1.0', 'end', '-lines')
|
||||
|
||||
self.assertIsInstance(text.count('1.3', '1.5', 'ypixels'), tuple)
|
||||
self.assertIsInstance(text.count('1.3', '1.5', 'update', 'ypixels'), int
|
||||
if self.wantobjects else str)
|
||||
self.assertEqual(text.count('1.3', '1.3', 'update', 'ypixels'), None
|
||||
if self.wantobjects else '0')
|
||||
self.assertEqual(text.count('1.3', '1.5', 'update', 'indices'), 2
|
||||
if self.wantobjects else '2')
|
||||
self.assertEqual(text.count('1.3', '1.3', 'update', 'indices'), None
|
||||
if self.wantobjects else '0')
|
||||
self.assertEqual(text.count('1.3', '1.5', 'update'), (2,)
|
||||
if self.wantobjects else ('2',))
|
||||
self.assertEqual(text.count('1.3', '1.3', 'update'), None
|
||||
if self.wantobjects else ('0',))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -1,342 +0,0 @@
|
||||
import unittest
|
||||
from test import support
|
||||
|
||||
import gc
|
||||
import tkinter
|
||||
from tkinter import (Variable, StringVar, IntVar, DoubleVar, BooleanVar, Tcl,
|
||||
TclError)
|
||||
from test.support import ALWAYS_EQ
|
||||
from tkinter.test.support import AbstractDefaultRootTest
|
||||
|
||||
|
||||
class Var(Variable):
|
||||
|
||||
_default = "default"
|
||||
side_effect = False
|
||||
|
||||
def set(self, value):
|
||||
self.side_effect = True
|
||||
super().set(value)
|
||||
|
||||
|
||||
class TestBase(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.root = Tcl()
|
||||
|
||||
def tearDown(self):
|
||||
del self.root
|
||||
|
||||
|
||||
class TestVariable(TestBase):
|
||||
|
||||
def info_exists(self, *args):
|
||||
return self.root.getboolean(self.root.call("info", "exists", *args))
|
||||
|
||||
def test_default(self):
|
||||
v = Variable(self.root)
|
||||
self.assertEqual("", v.get())
|
||||
self.assertRegex(str(v), r"^PY_VAR(\d+)$")
|
||||
|
||||
def test_name_and_value(self):
|
||||
v = Variable(self.root, "sample string", "varname")
|
||||
self.assertEqual("sample string", v.get())
|
||||
self.assertEqual("varname", str(v))
|
||||
|
||||
def test___del__(self):
|
||||
self.assertFalse(self.info_exists("varname"))
|
||||
v = Variable(self.root, "sample string", "varname")
|
||||
self.assertTrue(self.info_exists("varname"))
|
||||
del v
|
||||
support.gc_collect() # For PyPy or other GCs.
|
||||
self.assertFalse(self.info_exists("varname"))
|
||||
|
||||
def test_dont_unset_not_existing(self):
|
||||
self.assertFalse(self.info_exists("varname"))
|
||||
v1 = Variable(self.root, name="name")
|
||||
v2 = Variable(self.root, name="name")
|
||||
del v1
|
||||
support.gc_collect() # For PyPy or other GCs.
|
||||
self.assertFalse(self.info_exists("name"))
|
||||
# shouldn't raise exception
|
||||
del v2
|
||||
support.gc_collect() # For PyPy or other GCs.
|
||||
self.assertFalse(self.info_exists("name"))
|
||||
|
||||
def test_equality(self):
|
||||
# values doesn't matter, only class and name are checked
|
||||
v1 = Variable(self.root, name="abc")
|
||||
v2 = Variable(self.root, name="abc")
|
||||
self.assertIsNot(v1, v2)
|
||||
self.assertEqual(v1, v2)
|
||||
|
||||
v3 = Variable(self.root, name="cba")
|
||||
self.assertNotEqual(v1, v3)
|
||||
|
||||
v4 = StringVar(self.root, name="abc")
|
||||
self.assertEqual(str(v1), str(v4))
|
||||
self.assertNotEqual(v1, v4)
|
||||
|
||||
V = type('Variable', (), {})
|
||||
self.assertNotEqual(v1, V())
|
||||
|
||||
self.assertNotEqual(v1, object())
|
||||
self.assertEqual(v1, ALWAYS_EQ)
|
||||
|
||||
root2 = tkinter.Tk()
|
||||
self.addCleanup(root2.destroy)
|
||||
v5 = Variable(root2, name="abc")
|
||||
self.assertEqual(str(v1), str(v5))
|
||||
self.assertNotEqual(v1, v5)
|
||||
|
||||
def test_invalid_name(self):
|
||||
with self.assertRaises(TypeError):
|
||||
Variable(self.root, name=123)
|
||||
|
||||
def test_null_in_name(self):
|
||||
with self.assertRaises(ValueError):
|
||||
Variable(self.root, name='var\x00name')
|
||||
with self.assertRaises(ValueError):
|
||||
self.root.globalsetvar('var\x00name', "value")
|
||||
with self.assertRaises(ValueError):
|
||||
self.root.globalsetvar(b'var\x00name', "value")
|
||||
with self.assertRaises(ValueError):
|
||||
self.root.setvar('var\x00name', "value")
|
||||
with self.assertRaises(ValueError):
|
||||
self.root.setvar(b'var\x00name', "value")
|
||||
|
||||
def test_initialize(self):
|
||||
v = Var(self.root)
|
||||
self.assertFalse(v.side_effect)
|
||||
v.set("value")
|
||||
self.assertTrue(v.side_effect)
|
||||
|
||||
def test_trace_old(self):
|
||||
# Old interface
|
||||
v = Variable(self.root)
|
||||
vname = str(v)
|
||||
trace = []
|
||||
def read_tracer(*args):
|
||||
trace.append(('read',) + args)
|
||||
def write_tracer(*args):
|
||||
trace.append(('write',) + args)
|
||||
cb1 = v.trace_variable('r', read_tracer)
|
||||
cb2 = v.trace_variable('wu', write_tracer)
|
||||
self.assertEqual(sorted(v.trace_vinfo()), [('r', cb1), ('wu', cb2)])
|
||||
self.assertEqual(trace, [])
|
||||
|
||||
v.set('spam')
|
||||
self.assertEqual(trace, [('write', vname, '', 'w')])
|
||||
|
||||
trace = []
|
||||
v.get()
|
||||
self.assertEqual(trace, [('read', vname, '', 'r')])
|
||||
|
||||
trace = []
|
||||
info = sorted(v.trace_vinfo())
|
||||
v.trace_vdelete('w', cb1) # Wrong mode
|
||||
self.assertEqual(sorted(v.trace_vinfo()), info)
|
||||
with self.assertRaises(TclError):
|
||||
v.trace_vdelete('r', 'spam') # Wrong command name
|
||||
self.assertEqual(sorted(v.trace_vinfo()), info)
|
||||
v.trace_vdelete('r', (cb1, 43)) # Wrong arguments
|
||||
self.assertEqual(sorted(v.trace_vinfo()), info)
|
||||
v.get()
|
||||
self.assertEqual(trace, [('read', vname, '', 'r')])
|
||||
|
||||
trace = []
|
||||
v.trace_vdelete('r', cb1)
|
||||
self.assertEqual(v.trace_vinfo(), [('wu', cb2)])
|
||||
v.get()
|
||||
self.assertEqual(trace, [])
|
||||
|
||||
trace = []
|
||||
del write_tracer
|
||||
gc.collect()
|
||||
v.set('eggs')
|
||||
self.assertEqual(trace, [('write', vname, '', 'w')])
|
||||
|
||||
trace = []
|
||||
del v
|
||||
gc.collect()
|
||||
self.assertEqual(trace, [('write', vname, '', 'u')])
|
||||
|
||||
def test_trace(self):
|
||||
v = Variable(self.root)
|
||||
vname = str(v)
|
||||
trace = []
|
||||
def read_tracer(*args):
|
||||
trace.append(('read',) + args)
|
||||
def write_tracer(*args):
|
||||
trace.append(('write',) + args)
|
||||
tr1 = v.trace_add('read', read_tracer)
|
||||
tr2 = v.trace_add(['write', 'unset'], write_tracer)
|
||||
self.assertEqual(sorted(v.trace_info()), [
|
||||
(('read',), tr1),
|
||||
(('write', 'unset'), tr2)])
|
||||
self.assertEqual(trace, [])
|
||||
|
||||
v.set('spam')
|
||||
self.assertEqual(trace, [('write', vname, '', 'write')])
|
||||
|
||||
trace = []
|
||||
v.get()
|
||||
self.assertEqual(trace, [('read', vname, '', 'read')])
|
||||
|
||||
trace = []
|
||||
info = sorted(v.trace_info())
|
||||
v.trace_remove('write', tr1) # Wrong mode
|
||||
self.assertEqual(sorted(v.trace_info()), info)
|
||||
with self.assertRaises(TclError):
|
||||
v.trace_remove('read', 'spam') # Wrong command name
|
||||
self.assertEqual(sorted(v.trace_info()), info)
|
||||
v.get()
|
||||
self.assertEqual(trace, [('read', vname, '', 'read')])
|
||||
|
||||
trace = []
|
||||
v.trace_remove('read', tr1)
|
||||
self.assertEqual(v.trace_info(), [(('write', 'unset'), tr2)])
|
||||
v.get()
|
||||
self.assertEqual(trace, [])
|
||||
|
||||
trace = []
|
||||
del write_tracer
|
||||
gc.collect()
|
||||
v.set('eggs')
|
||||
self.assertEqual(trace, [('write', vname, '', 'write')])
|
||||
|
||||
trace = []
|
||||
del v
|
||||
gc.collect()
|
||||
self.assertEqual(trace, [('write', vname, '', 'unset')])
|
||||
|
||||
|
||||
class TestStringVar(TestBase):
|
||||
|
||||
def test_default(self):
|
||||
v = StringVar(self.root)
|
||||
self.assertEqual("", v.get())
|
||||
|
||||
def test_get(self):
|
||||
v = StringVar(self.root, "abc", "name")
|
||||
self.assertEqual("abc", v.get())
|
||||
self.root.globalsetvar("name", "value")
|
||||
self.assertEqual("value", v.get())
|
||||
|
||||
def test_get_null(self):
|
||||
v = StringVar(self.root, "abc\x00def", "name")
|
||||
self.assertEqual("abc\x00def", v.get())
|
||||
self.root.globalsetvar("name", "val\x00ue")
|
||||
self.assertEqual("val\x00ue", v.get())
|
||||
|
||||
|
||||
class TestIntVar(TestBase):
|
||||
|
||||
def test_default(self):
|
||||
v = IntVar(self.root)
|
||||
self.assertEqual(0, v.get())
|
||||
|
||||
def test_get(self):
|
||||
v = IntVar(self.root, 123, "name")
|
||||
self.assertEqual(123, v.get())
|
||||
self.root.globalsetvar("name", "345")
|
||||
self.assertEqual(345, v.get())
|
||||
self.root.globalsetvar("name", "876.5")
|
||||
self.assertEqual(876, v.get())
|
||||
|
||||
def test_invalid_value(self):
|
||||
v = IntVar(self.root, name="name")
|
||||
self.root.globalsetvar("name", "value")
|
||||
with self.assertRaises((ValueError, TclError)):
|
||||
v.get()
|
||||
|
||||
|
||||
class TestDoubleVar(TestBase):
|
||||
|
||||
def test_default(self):
|
||||
v = DoubleVar(self.root)
|
||||
self.assertEqual(0.0, v.get())
|
||||
|
||||
def test_get(self):
|
||||
v = DoubleVar(self.root, 1.23, "name")
|
||||
self.assertAlmostEqual(1.23, v.get())
|
||||
self.root.globalsetvar("name", "3.45")
|
||||
self.assertAlmostEqual(3.45, v.get())
|
||||
|
||||
def test_get_from_int(self):
|
||||
v = DoubleVar(self.root, 1.23, "name")
|
||||
self.assertAlmostEqual(1.23, v.get())
|
||||
self.root.globalsetvar("name", "3.45")
|
||||
self.assertAlmostEqual(3.45, v.get())
|
||||
self.root.globalsetvar("name", "456")
|
||||
self.assertAlmostEqual(456, v.get())
|
||||
|
||||
def test_invalid_value(self):
|
||||
v = DoubleVar(self.root, name="name")
|
||||
self.root.globalsetvar("name", "value")
|
||||
with self.assertRaises((ValueError, TclError)):
|
||||
v.get()
|
||||
|
||||
|
||||
class TestBooleanVar(TestBase):
|
||||
|
||||
def test_default(self):
|
||||
v = BooleanVar(self.root)
|
||||
self.assertIs(v.get(), False)
|
||||
|
||||
def test_get(self):
|
||||
v = BooleanVar(self.root, True, "name")
|
||||
self.assertIs(v.get(), True)
|
||||
self.root.globalsetvar("name", "0")
|
||||
self.assertIs(v.get(), False)
|
||||
self.root.globalsetvar("name", 42 if self.root.wantobjects() else 1)
|
||||
self.assertIs(v.get(), True)
|
||||
self.root.globalsetvar("name", 0)
|
||||
self.assertIs(v.get(), False)
|
||||
self.root.globalsetvar("name", "on")
|
||||
self.assertIs(v.get(), True)
|
||||
|
||||
def test_set(self):
|
||||
true = 1 if self.root.wantobjects() else "1"
|
||||
false = 0 if self.root.wantobjects() else "0"
|
||||
v = BooleanVar(self.root, name="name")
|
||||
v.set(True)
|
||||
self.assertEqual(self.root.globalgetvar("name"), true)
|
||||
v.set("0")
|
||||
self.assertEqual(self.root.globalgetvar("name"), false)
|
||||
v.set(42)
|
||||
self.assertEqual(self.root.globalgetvar("name"), true)
|
||||
v.set(0)
|
||||
self.assertEqual(self.root.globalgetvar("name"), false)
|
||||
v.set("on")
|
||||
self.assertEqual(self.root.globalgetvar("name"), true)
|
||||
|
||||
def test_invalid_value_domain(self):
|
||||
false = 0 if self.root.wantobjects() else "0"
|
||||
v = BooleanVar(self.root, name="name")
|
||||
with self.assertRaises(TclError):
|
||||
v.set("value")
|
||||
self.assertEqual(self.root.globalgetvar("name"), false)
|
||||
self.root.globalsetvar("name", "value")
|
||||
with self.assertRaises(ValueError):
|
||||
v.get()
|
||||
self.root.globalsetvar("name", "1.0")
|
||||
with self.assertRaises(ValueError):
|
||||
v.get()
|
||||
|
||||
|
||||
class DefaultRootTest(AbstractDefaultRootTest, unittest.TestCase):
|
||||
|
||||
def test_variable(self):
|
||||
self.assertRaises(RuntimeError, Variable)
|
||||
root = tkinter.Tk()
|
||||
v = Variable()
|
||||
v.set("value")
|
||||
self.assertEqual(v.get(), "value")
|
||||
root.destroy()
|
||||
tkinter.NoDefaultRoot()
|
||||
self.assertRaises(RuntimeError, Variable)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user