cpython/Lib/test/test_tkinter/test_misc.py

792 lines
28 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

import functools
import unittest
import tkinter
from tkinter import TclError
import enum
from test import support
from test.test_tkinter.support import AbstractTkTest, AbstractDefaultRootTest, requires_tk
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))
@requires_tk(8, 6, 6)
def test_tk_busy(self):
root = self.root
f = tkinter.Frame(root, name='myframe')
f2 = tkinter.Frame(root)
f.pack()
f2.pack()
b = tkinter.Button(f)
b.pack()
f.tk_busy_hold()
with self.assertRaisesRegex(TclError, 'unknown option "-spam"'):
f.tk_busy_configure(spam='eggs')
with self.assertRaisesRegex(TclError, 'unknown option "-spam"'):
f.tk_busy_cget('spam')
with self.assertRaisesRegex(TclError, 'unknown option "-spam"'):
f.tk_busy_configure('spam')
self.assertIsInstance(f.tk_busy_configure(), dict)
self.assertTrue(f.tk_busy_status())
self.assertFalse(root.tk_busy_status())
self.assertFalse(f2.tk_busy_status())
self.assertFalse(b.tk_busy_status())
self.assertIn(f, f.tk_busy_current())
self.assertIn(f, f.tk_busy_current('*.m?f*me'))
self.assertNotIn(f, f.tk_busy_current('*spam'))
f.tk_busy_forget()
self.assertFalse(f.tk_busy_status())
self.assertFalse(f.tk_busy_current())
with self.assertRaisesRegex(TclError, "can't find busy window"):
f.tk_busy_configure()
with self.assertRaisesRegex(TclError, "can't find busy window"):
f.tk_busy_forget()
@requires_tk(8, 6, 6)
def test_tk_busy_with_cursor(self):
root = self.root
if root._windowingsystem == 'aqua':
self.skipTest('the cursor option is not supported on OSX/Aqua')
f = tkinter.Frame(root, name='myframe')
f.pack()
f.tk_busy_hold(cursor='gumby')
self.assertEqual(f.tk_busy_cget('cursor'), 'gumby')
f.tk_busy_configure(cursor='heart')
self.assertEqual(f.tk_busy_cget('cursor'), 'heart')
self.assertEqual(f.tk_busy_configure()['cursor'][4], 'heart')
self.assertEqual(f.tk_busy_configure('cursor')[4], 'heart')
f.tk_busy_forget()
with self.assertRaisesRegex(TclError, "can't find busy window"):
f.tk_busy_cget('cursor')
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 BindTest(AbstractTkTest, unittest.TestCase):
def setUp(self):
super().setUp()
root = self.root
self.frame = tkinter.Frame(self.root, class_='Test',
width=150, height=100)
self.frame.pack()
def assertCommandExist(self, funcid):
self.assertEqual(_info_commands(self.root, funcid), (funcid,))
def assertCommandNotExist(self, funcid):
self.assertEqual(_info_commands(self.root, funcid), ())
def test_bind(self):
event = '<Control-Alt-Key-a>'
f = self.frame
self.assertEqual(f.bind(), ())
self.assertEqual(f.bind(event), '')
def test1(e): pass
def test2(e): pass
funcid = f.bind(event, test1)
self.assertEqual(f.bind(), (event,))
script = f.bind(event)
self.assertIn(funcid, script)
self.assertCommandExist(funcid)
funcid2 = f.bind(event, test2, add=True)
script = f.bind(event)
self.assertIn(funcid, script)
self.assertIn(funcid2, script)
self.assertCommandExist(funcid)
self.assertCommandExist(funcid2)
def test_unbind(self):
event = '<Control-Alt-Key-b>'
f = self.frame
self.assertEqual(f.bind(), ())
self.assertEqual(f.bind(event), '')
def test1(e): pass
def test2(e): pass
funcid = f.bind(event, test1)
funcid2 = f.bind(event, test2, add=True)
self.assertRaises(TypeError, f.unbind)
f.unbind(event)
self.assertEqual(f.bind(event), '')
self.assertEqual(f.bind(), ())
def test_unbind2(self):
f = self.frame
event = '<Control-Alt-Key-c>'
self.assertEqual(f.bind(), ())
self.assertEqual(f.bind(event), '')
def test1(e): pass
def test2(e): pass
funcid = f.bind(event, test1)
funcid2 = f.bind(event, test2, add=True)
f.unbind(event, funcid)
script = f.bind(event)
self.assertNotIn(funcid, script)
self.assertCommandNotExist(funcid)
self.assertCommandExist(funcid2)
f.unbind(event, funcid2)
self.assertEqual(f.bind(event), '')
self.assertEqual(f.bind(), ())
self.assertCommandNotExist(funcid)
self.assertCommandNotExist(funcid2)
# non-idempotent
self.assertRaises(tkinter.TclError, f.unbind, event, funcid2)
def test_bind_rebind(self):
event = '<Control-Alt-Key-d>'
f = self.frame
self.assertEqual(f.bind(), ())
self.assertEqual(f.bind(event), '')
def test1(e): pass
def test2(e): pass
def test3(e): pass
funcid = f.bind(event, test1)
funcid2 = f.bind(event, test2, add=True)
script = f.bind(event)
self.assertIn(funcid2, script)
self.assertIn(funcid, script)
self.assertCommandExist(funcid)
self.assertCommandExist(funcid2)
funcid3 = f.bind(event, test3)
script = f.bind(event)
self.assertNotIn(funcid, script)
self.assertNotIn(funcid2, script)
self.assertIn(funcid3, script)
self.assertCommandExist(funcid3)
def test_bind_class(self):
event = '<Control-Alt-Key-e>'
bind_class = self.root.bind_class
unbind_class = self.root.unbind_class
self.assertRaises(TypeError, bind_class)
self.assertEqual(bind_class('Test'), ())
self.assertEqual(bind_class('Test', event), '')
self.addCleanup(unbind_class, 'Test', event)
def test1(e): pass
def test2(e): pass
funcid = bind_class('Test', event, test1)
self.assertEqual(bind_class('Test'), (event,))
script = bind_class('Test', event)
self.assertIn(funcid, script)
self.assertCommandExist(funcid)
funcid2 = bind_class('Test', event, test2, add=True)
script = bind_class('Test', event)
self.assertIn(funcid, script)
self.assertIn(funcid2, script)
self.assertCommandExist(funcid)
self.assertCommandExist(funcid2)
def test_unbind_class(self):
event = '<Control-Alt-Key-f>'
bind_class = self.root.bind_class
unbind_class = self.root.unbind_class
self.assertEqual(bind_class('Test'), ())
self.assertEqual(bind_class('Test', event), '')
self.addCleanup(unbind_class, 'Test', event)
def test1(e): pass
def test2(e): pass
funcid = bind_class('Test', event, test1)
funcid2 = bind_class('Test', event, test2, add=True)
self.assertRaises(TypeError, unbind_class)
self.assertRaises(TypeError, unbind_class, 'Test')
unbind_class('Test', event)
self.assertEqual(bind_class('Test', event), '')
self.assertEqual(bind_class('Test'), ())
self.assertCommandExist(funcid)
self.assertCommandExist(funcid2)
unbind_class('Test', event) # idempotent
def test_bind_class_rebind(self):
event = '<Control-Alt-Key-g>'
bind_class = self.root.bind_class
unbind_class = self.root.unbind_class
self.assertEqual(bind_class('Test'), ())
self.assertEqual(bind_class('Test', event), '')
self.addCleanup(unbind_class, 'Test', event)
def test1(e): pass
def test2(e): pass
def test3(e): pass
funcid = bind_class('Test', event, test1)
funcid2 = bind_class('Test', event, test2, add=True)
script = bind_class('Test', event)
self.assertIn(funcid2, script)
self.assertIn(funcid, script)
self.assertCommandExist(funcid)
self.assertCommandExist(funcid2)
funcid3 = bind_class('Test', event, test3)
script = bind_class('Test', event)
self.assertNotIn(funcid, script)
self.assertNotIn(funcid2, script)
self.assertIn(funcid3, script)
self.assertCommandExist(funcid)
self.assertCommandExist(funcid2)
self.assertCommandExist(funcid3)
def test_bind_all(self):
event = '<Control-Alt-Key-h>'
bind_all = self.root.bind_all
unbind_all = self.root.unbind_all
self.assertNotIn(event, bind_all())
self.assertEqual(bind_all(event), '')
self.addCleanup(unbind_all, event)
def test1(e): pass
def test2(e): pass
funcid = bind_all(event, test1)
self.assertIn(event, bind_all())
script = bind_all(event)
self.assertIn(funcid, script)
self.assertCommandExist(funcid)
funcid2 = bind_all(event, test2, add=True)
script = bind_all(event)
self.assertIn(funcid, script)
self.assertIn(funcid2, script)
self.assertCommandExist(funcid)
self.assertCommandExist(funcid2)
def test_unbind_all(self):
event = '<Control-Alt-Key-i>'
bind_all = self.root.bind_all
unbind_all = self.root.unbind_all
self.assertNotIn(event, bind_all())
self.assertEqual(bind_all(event), '')
self.addCleanup(unbind_all, event)
def test1(e): pass
def test2(e): pass
funcid = bind_all(event, test1)
funcid2 = bind_all(event, test2, add=True)
unbind_all(event)
self.assertEqual(bind_all(event), '')
self.assertNotIn(event, bind_all())
self.assertCommandExist(funcid)
self.assertCommandExist(funcid2)
unbind_all(event) # idempotent
def test_bind_all_rebind(self):
event = '<Control-Alt-Key-j>'
bind_all = self.root.bind_all
unbind_all = self.root.unbind_all
self.assertNotIn(event, bind_all())
self.assertEqual(bind_all(event), '')
self.addCleanup(unbind_all, event)
def test1(e): pass
def test2(e): pass
def test3(e): pass
funcid = bind_all(event, test1)
funcid2 = bind_all(event, test2, add=True)
script = bind_all(event)
self.assertIn(funcid2, script)
self.assertIn(funcid, script)
self.assertCommandExist(funcid)
self.assertCommandExist(funcid2)
funcid3 = bind_all(event, test3)
script = bind_all(event)
self.assertNotIn(funcid, script)
self.assertNotIn(funcid2, script)
self.assertIn(funcid3, script)
self.assertCommandExist(funcid)
self.assertCommandExist(funcid2)
self.assertCommandExist(funcid3)
def test_bindtags(self):
f = self.frame
self.assertEqual(self.root.bindtags(), ('.', 'Tk', 'all'))
self.assertEqual(f.bindtags(), (str(f), 'Test', '.', 'all'))
f.bindtags(('a', 'b c'))
self.assertEqual(f.bindtags(), ('a', 'b c'))
def test_bind_events(self):
event = '<Enter>'
root = self.root
t = tkinter.Toplevel(root)
f = tkinter.Frame(t, class_='Test', width=150, height=100)
f.pack()
root.wait_visibility() # needed on Windows
root.update_idletasks()
self.addCleanup(root.unbind_class, 'Test', event)
self.addCleanup(root.unbind_class, 'Toplevel', event)
self.addCleanup(root.unbind_class, 'tag', event)
self.addCleanup(root.unbind_class, 'tag2', event)
self.addCleanup(root.unbind_all, event)
def test(what):
return lambda e: events.append((what, e.widget))
root.bind_all(event, test('all'))
root.bind_class('Test', event, test('frame class'))
root.bind_class('Toplevel', event, test('toplevel class'))
root.bind_class('tag', event, test('tag'))
root.bind_class('tag2', event, test('tag2'))
f.bind(event, test('frame'))
t.bind(event, test('toplevel'))
events = []
f.event_generate(event)
self.assertEqual(events, [
('frame', f),
('frame class', f),
('toplevel', f),
('all', f),
])
events = []
t.event_generate(event)
self.assertEqual(events, [
('toplevel', t),
('toplevel class', t),
('all', t),
])
f.bindtags(('tag', 'tag3'))
events = []
f.event_generate(event)
self.assertEqual(events, [('tag', f)])
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)
def _info_commands(widget, pattern=None):
return widget.tk.splitlist(widget.tk.call('info', 'commands', pattern))
if __name__ == "__main__":
unittest.main()