mirror of
https://github.com/python/cpython.git
synced 2026-06-28 11:50:50 +00:00
a30acf2495
* font: copy(), the config alias, the displayof argument of measure and
metrics, and the errors raised for invalid options and a wrong number
of arguments;
* image: the cget method and the config alias, and the errors raised by
transparency_get and transparency_set;
* variable: that initialize is an alias of set and the deprecated trace
is an alias of trace_variable;
* Misc: tk_focusNext, tk_focusPrev, tk_strictMotif, tk_bisque and
option_readfile;
* Wm: wm_iconphoto.
(cherry picked from commit 66cc048551)
Co-authored-by: Serhiy Storchaka <storchaka@gmail.com>
Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
218 lines
8.5 KiB
Python
218 lines
8.5 KiB
Python
import collections.abc
|
|
import unittest
|
|
import tkinter
|
|
from tkinter import font
|
|
from test.support import requires, gc_collect, ALWAYS_EQ
|
|
from test.test_tkinter.support import setUpModule # noqa: F401
|
|
from test.test_tkinter.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):
|
|
self.assertEqual(self.font.config, self.font.configure)
|
|
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)
|
|
self.assertRaisesRegex(tkinter.TclError, 'bad option "-spam"',
|
|
self.font.cget, 'spam')
|
|
self.assertRaisesRegex(tkinter.TclError, 'bad option "-spam"',
|
|
self.font.configure, spam='x')
|
|
self.assertRaises(TypeError, self.font.cget)
|
|
self.assertRaises(TypeError, self.font.cget, 'size', 'weight')
|
|
|
|
def test_copy(self):
|
|
f = font.Font(root=self.root, family='Times', size=10, weight='bold')
|
|
copied = f.copy()
|
|
self.assertIsInstance(copied, font.Font)
|
|
self.assertIsNot(copied, f)
|
|
self.assertNotEqual(copied.name, f.name)
|
|
self.assertEqual(copied.actual(), f.actual())
|
|
# The copy is independent of the original.
|
|
sizetype = int if self.wantobjects else str
|
|
copied.configure(size=20)
|
|
self.assertEqual(f.cget('size'), sizetype(10))
|
|
self.assertEqual(copied.cget('size'), sizetype(20))
|
|
self.assertRaises(TypeError, f.copy, 'x')
|
|
|
|
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)
|
|
self.assertRaisesRegex(tkinter.TclError, 'bad option "-spam"',
|
|
self.font.actual, 'spam')
|
|
self.assertRaises(TypeError, self.font.actual, 'size', 'weight', 'slant')
|
|
|
|
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)
|
|
self.assertEqual(self.font.measure(''), 0)
|
|
self.assertIsInstance(
|
|
self.font.measure('abc', displayof=self.root), int)
|
|
self.assertRaises(TypeError, self.font.measure)
|
|
self.assertRaises(TypeError, self.font.measure, 'a', 'b', 'c')
|
|
|
|
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.assertEqual(self.font.metrics(key, displayof=self.root),
|
|
metrics[key])
|
|
self.assertIsInstance(metrics[key], int)
|
|
self.assertIsInstance(self.font.metrics(key), int)
|
|
self.assertRaisesRegex(tkinter.TclError, 'bad metric "-spam"',
|
|
self.font.metrics, 'spam')
|
|
|
|
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}>'
|
|
)
|
|
|
|
def test_iterable_protocol(self):
|
|
self.assertNotIsSubclass(font.Font, collections.abc.Iterable)
|
|
self.assertNotIsSubclass(font.Font, collections.abc.Container)
|
|
self.assertNotIsInstance(self.font, collections.abc.Iterable)
|
|
self.assertNotIsInstance(self.font, collections.abc.Container)
|
|
with self.assertRaisesRegex(TypeError, 'is not iterable'):
|
|
iter(self.font)
|
|
with self.assertRaisesRegex(TypeError, 'is not a container or iterable'):
|
|
self.font in self.font
|
|
|
|
|
|
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)
|
|
|
|
|
|
class TestModule(unittest.TestCase):
|
|
def test_deprecated__version__(self):
|
|
with self.assertWarnsRegex(
|
|
DeprecationWarning,
|
|
"'__version__' is deprecated and slated for removal in Python 3.20",
|
|
) as cm:
|
|
getattr(font, "__version__")
|
|
self.assertEqual(cm.filename, __file__)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|