From 9688d252d330b0b586760a121ee8c8f7215176e8 Mon Sep 17 00:00:00 2001
From: Cody Maloney <cmaloney@users.noreply.github.com>
Date: Thu, 18 Jun 2026 23:50:22 -0700
Subject: [PATCH 01/10] gh-101100: Document os.uname_result and
 os.statvfs_result with related constants (GH-151301)

---
 Doc/library/os.rst       | 251 +++++++++++++++++++++++++++++++--------
 Doc/tools/.nitignore     |   1 -
 Misc/NEWS.d/3.10.0a4.rst |   2 +-
 Misc/NEWS.d/3.12.0a3.rst |   4 +-
 4 files changed, 204 insertions(+), 54 deletions(-)

diff --git a/Doc/library/os.rst b/Doc/library/os.rst
index 9327d616ffa05d..5d69997d0868a3 100644
--- a/Doc/library/os.rst
+++ b/Doc/library/os.rst
@@ -800,29 +800,19 @@ process and user.
       single: gethostbyaddr() (in module socket)
 
    Returns information identifying the current operating system.
-   The return value is an object with five attributes:
-
-   * :attr:`sysname` - operating system name
-   * :attr:`nodename` - name of machine on network (implementation-defined)
-   * :attr:`release` - operating system release
-   * :attr:`version` - operating system version
-   * :attr:`machine` - hardware identifier
-
-   For backwards compatibility, this object is also iterable, behaving
-   like a five-tuple containing :attr:`sysname`, :attr:`nodename`,
-   :attr:`release`, :attr:`version`, and :attr:`machine`
-   in that order.
-
-   Some systems truncate :attr:`nodename` to 8 characters or to the
-   leading component; a better way to get the hostname is
-   :func:`socket.gethostname`  or even
-   ``socket.gethostbyaddr(socket.gethostname())``.
+   The return value is a :class:`uname_result`.
 
    On macOS, iOS and Android, this returns the *kernel* name and version (i.e.,
    ``'Darwin'`` on macOS and iOS; ``'Linux'`` on Android). :func:`platform.uname`
    can be used to get the user-facing operating system name and version on iOS and
    Android.
 
+   .. seealso::
+      :data:`sys.platform` which has finer granularity.
+
+      The :mod:`platform` module provides detailed checks for the
+      system's identity.
+
    .. availability:: Unix.
 
    .. versionchanged:: 3.3
@@ -830,6 +820,41 @@ process and user.
       with named attributes.
 
 
+.. class:: uname_result
+
+   Name and information about the system returned by :func:`os.uname`.
+   These attributes correspond to the members described in :manpage:`uname(2)`.
+
+   For backwards compatibility, this object is also iterable, behaving
+   like a five-tuple containing :attr:`~uname_result.sysname`,
+   :attr:`~uname_result.nodename`, :attr:`~uname_result.release`,
+   :attr:`~uname_result.version`, and :attr:`~uname_result.machine`
+   in that order.
+
+   .. attribute:: sysname
+
+      Operating system name.
+
+   .. attribute:: nodename
+
+      Name of machine on network. Some systems truncate
+      :attr:`~uname_result.nodename` to 8 characters or to the leading
+      component; a better way to get the hostname is :func:`socket.gethostname`
+      or even ``socket.gethostbyaddr(socket.gethostname())``.
+
+   .. attribute:: release
+
+      Operating system release.
+
+   .. attribute:: version
+
+      Operating system version.
+
+   .. attribute:: machine
+
+      Hardware identifier.
+
+
 .. function:: unsetenv(key, /)
 
    .. index:: single: environment variables; deleting
@@ -1112,8 +1137,8 @@ as internal buffering of data.
 .. function:: fstatvfs(fd, /)
 
    Return information about the filesystem containing the file associated with
-   file descriptor *fd*, like :func:`statvfs`.  As of Python 3.3, this is
-   equivalent to ``os.statvfs(fd)``.
+   file descriptor *fd* in a :class:`statvfs_result`, like :func:`statvfs`.
+   As of Python 3.3, this is equivalent to ``os.statvfs(fd)``.
 
    .. availability:: Unix.
 
@@ -3784,48 +3809,174 @@ features:
 
 .. function:: statvfs(path)
 
-   Perform a :c:func:`!statvfs` system call on the given path.  The return value is
-   an object whose attributes describe the filesystem on the given path, and
-   correspond to the members of the :c:struct:`statvfs` structure, namely:
-   :attr:`f_bsize`, :attr:`f_frsize`, :attr:`f_blocks`, :attr:`f_bfree`,
-   :attr:`f_bavail`, :attr:`f_files`, :attr:`f_ffree`, :attr:`f_favail`,
-   :attr:`f_flag`, :attr:`f_namemax`, :attr:`f_fsid`.
-
-   Two module-level constants are defined for the :attr:`f_flag` attribute's
-   bit-flags: if :const:`ST_RDONLY` is set, the filesystem is mounted
-   read-only, and if :const:`ST_NOSUID` is set, the semantics of
-   setuid/setgid bits are disabled or not supported.
-
-   Additional module-level constants are defined for GNU/glibc based systems.
-   These are :const:`ST_NODEV` (disallow access to device special files),
-   :const:`ST_NOEXEC` (disallow program execution), :const:`ST_SYNCHRONOUS`
-   (writes are synced at once), :const:`ST_MANDLOCK` (allow mandatory locks on an FS),
-   :const:`ST_WRITE` (write on file/directory/symlink), :const:`ST_APPEND`
-   (append-only file), :const:`ST_IMMUTABLE` (immutable file), :const:`ST_NOATIME`
-   (do not update access times), :const:`ST_NODIRATIME` (do not update directory access
-   times), :const:`ST_RELATIME` (update atime relative to mtime/ctime).
+   Perform a :manpage:`statvfs(3)` system call on the given path.  The return value
+   is a :class:`statvfs_result` whose attributes describe the filesystem
+   on the given path and correspond to the members of the :c:struct:`statvfs`
+   structure.
 
    This function can support :ref:`specifying a file descriptor <path_fd>`.
 
    .. availability:: Unix.
 
-   .. versionchanged:: 3.2
-      The :const:`ST_RDONLY` and :const:`ST_NOSUID` constants were added.
-
    .. versionchanged:: 3.3
       Added support for specifying *path* as an open file descriptor.
 
-   .. versionchanged:: 3.4
-      The :const:`ST_NODEV`, :const:`ST_NOEXEC`, :const:`ST_SYNCHRONOUS`,
-      :const:`ST_MANDLOCK`, :const:`ST_WRITE`, :const:`ST_APPEND`,
-      :const:`ST_IMMUTABLE`, :const:`ST_NOATIME`, :const:`ST_NODIRATIME`,
-      and :const:`ST_RELATIME` constants were added.
-
    .. versionchanged:: 3.6
       Accepts a :term:`path-like object`.
 
-   .. versionchanged:: 3.7
-      Added the :attr:`f_fsid` attribute.
+
+.. class:: statvfs_result
+
+   Filesystem statistics returned by :func:`os.statvfs` and :func:`os.fstatvfs`.
+   See :manpage:`statvfs(3)` for more details.
+
+   .. attribute:: f_bsize
+
+      Block size.
+
+   .. attribute:: f_frsize
+
+      Fragment size.
+
+   .. attribute:: f_blocks
+
+      Number of :attr:`~statvfs_result.f_frsize` sized blocks the filesystem
+      can contain.
+
+   .. attribute:: f_bfree
+
+      Number of free blocks.
+
+   .. attribute:: f_bavail
+
+      Number of free blocks for unprivileged users.
+
+   .. attribute:: f_files
+
+      Number of file entries, inodes, the filesystem can contain.
+
+   .. attribute:: f_ffree
+
+      Number of free files entries.
+
+   .. attribute:: f_favail
+
+      Number of free file entries for unprivileged users.
+
+   .. attribute:: f_flag
+
+      Bit-mask of mount flags.  The following flags are defined:
+      :data:`ST_RDONLY`, :data:`ST_NOSUID`, :data:`ST_NODEV`,
+      :data:`ST_NOEXEC`, :data:`ST_SYNCHRONOUS`, :data:`ST_MANDLOCK`,
+      :data:`ST_WRITE`, :data:`ST_APPEND`, :data:`ST_IMMUTABLE`,
+      :data:`ST_NOATIME`, :data:`ST_NODIRATIME`, and :data:`ST_RELATIME`.
+
+   .. attribute:: f_namemax
+
+      Filesystem max filename length. OS specific limitations such as
+      :ref:`Windows MAX_PATH <max-path>` and those described in Linux
+      :manpage:`pathname(7)` may exist.
+
+   .. attribute:: f_fsid
+
+      Filesystem ID.
+
+      .. versionadded:: 3.7
+
+
+The following flags are used in :attr:`statvfs_result.f_flag`.
+
+.. data:: ST_RDONLY
+
+   Read-only filesystem.
+
+   .. versionadded:: 3.2
+
+.. data:: ST_NOSUID
+
+   Setuid/setgid bits are disabled or not supported.
+
+   .. versionadded:: 3.2
+
+.. data:: ST_NODEV
+
+   Disallow access to device special files.
+
+   .. availability:: Linux.
+
+   .. versionadded:: 3.4
+
+.. data:: ST_NOEXEC
+
+   Disallow program execution.
+
+   .. availability:: Linux.
+
+   .. versionadded:: 3.4
+
+.. data:: ST_SYNCHRONOUS
+
+   Writes are synced at once.
+
+   .. availability:: Linux.
+
+   .. versionadded:: 3.4
+
+.. data:: ST_MANDLOCK
+
+   Allow mandatory locks on an FS.
+
+   .. availability:: Linux.
+
+   .. versionadded:: 3.4
+
+.. data:: ST_WRITE
+
+   Write on file/directory/symlink.
+
+   .. availability:: Linux.
+
+   .. versionadded:: 3.4
+
+.. data:: ST_APPEND
+
+   Append-only file.
+
+   .. availability:: Linux.
+
+   .. versionadded:: 3.4
+
+.. data:: ST_IMMUTABLE
+
+   Immutable file.
+
+   .. availability:: Linux.
+
+   .. versionadded:: 3.4
+
+.. data:: ST_NOATIME
+
+   Do not update access times.
+
+   .. availability:: Linux.
+
+   .. versionadded:: 3.4
+
+.. data:: ST_NODIRATIME
+
+   Do not update directory access times.
+
+   .. availability:: Linux.
+
+   .. versionadded:: 3.4
+
+.. data:: ST_RELATIME
+
+   Update atime relative to mtime/ctime.
+
+   .. availability:: Linux.
+
+   .. versionadded:: 3.4
 
 
 .. data:: supports_dir_fd
diff --git a/Doc/tools/.nitignore b/Doc/tools/.nitignore
index 51ce9b66fadc7f..2255c745c00383 100644
--- a/Doc/tools/.nitignore
+++ b/Doc/tools/.nitignore
@@ -18,7 +18,6 @@ Doc/library/lzma.rst
 Doc/library/mmap.rst
 Doc/library/multiprocessing.rst
 Doc/library/optparse.rst
-Doc/library/os.rst
 Doc/library/pickletools.rst
 Doc/library/pyexpat.rst
 Doc/library/select.rst
diff --git a/Misc/NEWS.d/3.10.0a4.rst b/Misc/NEWS.d/3.10.0a4.rst
index cd419dfaaee2e8..16eca7a55db746 100644
--- a/Misc/NEWS.d/3.10.0a4.rst
+++ b/Misc/NEWS.d/3.10.0a4.rst
@@ -622,7 +622,7 @@ Harmonized :func:`random.randrange` argument handling to match :func:`range`.
 .. nonce: O4VcCY
 .. section: Library
 
-Restore compatibility for ``uname_result`` around deepcopy and _replace.
+Restore compatibility for :class:`os.uname_result` around deepcopy and _replace.
 
 ..
 
diff --git a/Misc/NEWS.d/3.12.0a3.rst b/Misc/NEWS.d/3.12.0a3.rst
index d2c717afcb6e8d..c71a66757c6566 100644
--- a/Misc/NEWS.d/3.12.0a3.rst
+++ b/Misc/NEWS.d/3.12.0a3.rst
@@ -454,8 +454,8 @@ event loop but the current event loop was set.
 .. nonce: humlhz
 .. section: Library
 
-On ``uname_result``, restored expectation that ``_fields`` and ``_asdict``
-would include all six properties including ``processor``.
+On :class:`os.uname_result`, restored expectation that ``_fields`` and
+``_asdict`` would include all six properties including ``processor``.
 
 ..
 

From da69fcf98de500b1e10bdce41a05c904e345d89f Mon Sep 17 00:00:00 2001
From: Duprat <yduprat@gmail.com>
Date: Fri, 19 Jun 2026 10:08:53 +0200
Subject: [PATCH 02/10]  gh-151427: add  'not macOS' and 'not iOS' restrictions
 on availability state of some functions in `os` module. (#151537)

---
 Doc/library/os.rst | 21 +++++++++------------
 1 file changed, 9 insertions(+), 12 deletions(-)

diff --git a/Doc/library/os.rst b/Doc/library/os.rst
index 5d69997d0868a3..7b043f257ca0b5 100644
--- a/Doc/library/os.rst
+++ b/Doc/library/os.rst
@@ -541,7 +541,7 @@ process and user.
    Return a tuple (ruid, euid, suid) denoting the current process's
    real, effective, and saved user ids.
 
-   .. availability:: Unix, not WASI.
+   .. availability:: Unix, not WASI, not macOS, not iOS.
 
    .. versionadded:: 3.2
 
@@ -551,7 +551,7 @@ process and user.
    Return a tuple (rgid, egid, sgid) denoting the current process's
    real, effective, and saved group ids.
 
-   .. availability:: Unix, not WASI.
+   .. availability:: Unix, not WASI, not macOS, not iOS.
 
    .. versionadded:: 3.2
 
@@ -725,7 +725,7 @@ process and user.
 
    Set the current process's real, effective, and saved group ids.
 
-   .. availability:: Unix, not WASI, not Android.
+   .. availability:: Unix, not WASI, not Android, not macOS, not iOS.
 
    .. versionadded:: 3.2
 
@@ -734,7 +734,7 @@ process and user.
 
    Set the current process's real, effective, and saved user ids.
 
-   .. availability:: Unix, not WASI, not Android.
+   .. availability:: Unix, not WASI, not Android, not macOS, not iOS.
 
    .. versionadded:: 3.2
 
@@ -1096,10 +1096,7 @@ as internal buffering of data.
    Force write of file with filedescriptor *fd* to disk. Does not force update of
    metadata.
 
-   .. availability:: Unix.
-
-   .. note::
-      This function is not available on MacOS.
+   .. availability:: Unix, not macOS, not iOS.
 
 
 .. function:: fpathconf(fd, name, /)
@@ -1451,7 +1448,7 @@ or `the MSDN <https://msdn.microsoft.com/en-us/library/z0kc8e3z.aspx>`_ on Windo
    Return a pair of file descriptors ``(r, w)`` usable for reading and writing,
    respectively.
 
-   .. availability:: Unix, not WASI.
+   .. availability:: Unix, not WASI, not macOS, not iOS.
 
    .. versionadded:: 3.3
 
@@ -1461,7 +1458,7 @@ or `the MSDN <https://msdn.microsoft.com/en-us/library/z0kc8e3z.aspx>`_ on Windo
    Ensures that enough disk space is allocated for the file specified by *fd*
    starting from *offset* and continuing for *len* bytes.
 
-   .. availability:: Unix.
+   .. availability:: Unix, not macOS, not iOS.
 
    .. versionadded:: 3.3
 
@@ -1476,7 +1473,7 @@ or `the MSDN <https://msdn.microsoft.com/en-us/library/z0kc8e3z.aspx>`_ on Windo
    :data:`POSIX_FADV_RANDOM`, :data:`POSIX_FADV_NOREUSE`,
    :data:`POSIX_FADV_WILLNEED` or :data:`POSIX_FADV_DONTNEED`.
 
-   .. availability:: Unix.
+   .. availability:: Unix, not macOS, not iOS.
 
    .. versionadded:: 3.3
 
@@ -5258,7 +5255,7 @@ written in Python, such as a mail server's external command delivery program.
    Lock program segments into memory.  The value of *op* (defined in
    ``<sys/lock.h>``) determines which segments are locked.
 
-   .. availability:: Unix, not WASI, not iOS.
+   .. availability:: Unix, not WASI, not macOS, not iOS.
 
 
 .. function:: popen(cmd, mode='r', buffering=-1)

From 4ac809e10bdb413d7dd8c7bab7e365b2b618ad91 Mon Sep 17 00:00:00 2001
From: Serhiy Storchaka <storchaka@gmail.com>
Date: Fri, 19 Jun 2026 11:38:02 +0300
Subject: [PATCH 03/10] gh-151678: Add tests for tkinter.Text (GH-151681)

Cover previously-untested Text methods (indices, content, marks, tags,
undo/redo, dump, embedded images and windows, peers, and geometry) and
the tag, embedded-image and embedded-window configuration options.

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 Lib/test/test_tkinter/test_text.py | 579 +++++++++++++++++++++++++++--
 1 file changed, 558 insertions(+), 21 deletions(-)

diff --git a/Lib/test/test_tkinter/test_text.py b/Lib/test/test_tkinter/test_text.py
index 453a4505a0a4da..0303c2ac1ed1da 100644
--- a/Lib/test/test_tkinter/test_text.py
+++ b/Lib/test/test_tkinter/test_text.py
@@ -1,8 +1,9 @@
 import unittest
 import tkinter
+from tkinter import TclError
 from test.support import requires
 from test.test_tkinter.support import setUpModule  # noqa: F401
-from test.test_tkinter.support import AbstractTkTest
+from test.test_tkinter.support import AbstractTkTest, requires_tk
 
 requires('gui')
 
@@ -25,21 +26,557 @@ def test_debug(self):
             text.debug(olddebug)
             self.assertEqual(text.debug(), olddebug)
 
+    def test_index(self):
+        text = self.text
+        text.insert('1.0', 'Lorem ipsum\ndolor sit amet')
+        self.assertEqual(text.index('1.0'), '1.0')
+        self.assertEqual(text.index('1.end'), '1.11')
+        self.assertEqual(text.index('end'), '3.0')
+        self.assertEqual(text.index('2.5'), '2.5')
+        # Index past the end of a line is clamped to its end.
+        self.assertEqual(text.index('1.100'), '1.11')
+        self.assertRaises(TclError, text.index, 'invalid')
+        self.assertRaises(TypeError, text.index)
+        self.assertRaises(TypeError, text.index, '1.0', '2.5')
+
+    def test_compare(self):
+        text = self.text
+        text.insert('1.0', 'Lorem ipsum\ndolor sit amet')
+        self.assertIs(text.compare('1.0', '<', '2.0'), True)
+        self.assertIs(text.compare('2.0', '<', '1.0'), False)
+        self.assertIs(text.compare('1.5', '==', '1.5'), True)
+        self.assertIs(text.compare('1.5', '!=', '1.5'), False)
+        self.assertIs(text.compare('2.0', '>=', '2.0'), True)
+        self.assertIs(text.compare('1.0', '<=', 'end'), True)
+        self.assertRaises(TclError, text.compare, '1.0', 'invalid', '2.0')
+        self.assertRaises(TypeError, text.compare, '1.0', '<')
+        self.assertRaises(TypeError, text.compare, '1.0', '<', '2.0', '3.0')
+
+    def test_insert_get_delete(self):
+        text = self.text
+        text.insert('1.0', 'Lorem ipsum')
+        self.assertEqual(text.get('1.0', 'end'), 'Lorem ipsum\n')
+        self.assertEqual(text.get('1.0', '1.5'), 'Lorem')
+        self.assertEqual(text.get('1.6'), 'i')  # single character
+
+        # insert before an existing index
+        text.insert('1.0', '*** ')
+        self.assertEqual(text.get('1.0', 'end'), '*** Lorem ipsum\n')
+
+        text.delete('1.0', '1.4')
+        self.assertEqual(text.get('1.0', 'end'), 'Lorem ipsum\n')
+        text.delete('1.5')  # delete a single character
+        self.assertEqual(text.get('1.0', 'end'), 'Loremipsum\n')
+        self.assertRaises(TypeError, text.get)
+        self.assertRaises(TypeError, text.get, '1.0', '1.5', 'end')
+        self.assertRaises(TypeError, text.delete, '1.0', '1.5', 'end')
+
+    def test_insert_with_tags(self):
+        text = self.text
+        text.insert('1.0', 'hello', 'a', ' ', ('a', 'b'), 'world', 'b')
+        self.assertEqual(text.get('1.0', 'end'), 'hello world\n')
+        self.assertEqual([str(i) for i in text.tag_ranges('a')],
+                         ['1.0', '1.6'])
+        self.assertEqual([str(i) for i in text.tag_ranges('b')],
+                         ['1.5', '1.11'])
+
+    def test_replace(self):
+        text = self.text
+        text.insert('1.0', 'Lorem ipsum')
+        text.replace('1.0', '1.5', 'Hello')
+        self.assertEqual(text.get('1.0', 'end'), 'Hello ipsum\n')
+        text.replace('1.6', 'end - 1 char', 'world')
+        self.assertEqual(text.get('1.0', 'end'), 'Hello world\n')
+        self.assertRaises(TclError, text.replace, 'invalid', '1.5', 'x')
+        # The first index must not be after the second.
+        self.assertRaises(TclError, text.replace, '1.5', '1.0', 'x')
+        self.assertRaises(TypeError, text.replace, '1.0', '1.5')
+
+    def test_mark(self):
+        text = self.text
+        text.insert('1.0', 'Lorem ipsum\ndolor sit amet')
+        # 'insert' and 'current' marks always exist.
+        self.assertIn('insert', text.mark_names())
+        self.assertIn('current', text.mark_names())
+
+        text.mark_set('here', '1.5')
+        self.assertIn('here', text.mark_names())
+        self.assertEqual(text.index('here'), '1.5')
+        text.mark_set('here', '2.3')
+        self.assertEqual(text.index('here'), '2.3')
+
+        text.mark_unset('here')
+        self.assertNotIn('here', text.mark_names())
+
+        # Unsetting a non-existent mark is not an error.
+        text.mark_unset('nonexistent')
+        self.assertRaises(TclError, text.mark_set, 'm', 'invalid')
+        self.assertRaises(TypeError, text.mark_set, 'm')
+        self.assertRaises(TypeError, text.mark_set, 'm', '1.0', '2.0')
+
+    def test_mark_gravity(self):
+        text = self.text
+        text.insert('1.0', 'Lorem ipsum')
+        text.mark_set('here', '1.5')
+        # The default gravity is right.
+        self.assertEqual(text.mark_gravity('here'), 'right')
+        text.mark_gravity('here', 'left')
+        self.assertEqual(text.mark_gravity('here'), 'left')
+        # With left gravity the mark stays before inserted text.
+        text.insert('here', 'XXX')
+        self.assertEqual(text.index('here'), '1.5')
+        # With right gravity the mark moves after inserted text.
+        text.mark_gravity('here', 'right')
+        text.insert('here', 'YYY')
+        self.assertEqual(text.index('here'), '1.8')
+
+        self.assertRaises(TclError, text.mark_gravity, 'nonexistent')
+        self.assertRaises(TclError, text.mark_gravity, 'here', 'invalid')
+        self.assertRaises(TypeError, text.mark_gravity)
+        self.assertRaises(TypeError, text.mark_gravity, 'here', 'left', 'extra')
+
+    def test_mark_next_previous(self):
+        text = self.text
+        text.insert('1.0', 'Lorem ipsum')
+        # Keep the builtin 'insert' and 'current' marks at 1.0 so they do
+        # not interfere with the queries below.
+        text.mark_set('insert', '1.0')
+        text.mark_set('current', '1.0')
+        text.mark_set('m1', '1.3')
+        text.mark_set('m2', '1.7')
+        # mark_next finds a mark at a position at or after the index,
+        # mark_previous finds one at a position strictly before it.
+        self.assertEqual(text.mark_next('1.1'), 'm1')
+        self.assertEqual(text.mark_next('1.3'), 'm1')
+        self.assertEqual(text.mark_next('1.4'), 'm2')
+        self.assertIsNone(text.mark_next('1.8'))
+        self.assertEqual(text.mark_previous('1.4'), 'm1')
+        self.assertEqual(text.mark_previous('1.7'), 'm1')
+        self.assertEqual(text.mark_previous('end'), 'm2')
+        self.assertIsNone(text.mark_previous('1.0'))
+
+        self.assertRaises(TclError, text.mark_next, 'invalid')
+        self.assertRaises(TclError, text.mark_previous, 'invalid')
+        self.assertRaises(TypeError, text.mark_next)
+        self.assertRaises(TypeError, text.mark_previous)
+        self.assertRaises(TypeError, text.mark_next, '1.0', '2.0')
+        self.assertRaises(TypeError, text.mark_previous, '1.0', '2.0')
+
+    def test_tag_add_remove_ranges(self):
+        text = self.text
+        text.insert('1.0', 'Lorem ipsum\ndolor sit amet')
+        self.assertEqual(text.tag_ranges('sel'), ())
+
+        text.tag_add('big', '1.0', '1.5')
+        self.assertEqual([str(i) for i in text.tag_ranges('big')],
+                         ['1.0', '1.5'])
+        # Add a second, disjoint range.
+        text.tag_add('big', '2.0', '2.5')
+        self.assertEqual([str(i) for i in text.tag_ranges('big')],
+                         ['1.0', '1.5', '2.0', '2.5'])
+
+        text.tag_remove('big', '1.0', '1.3')
+        self.assertEqual([str(i) for i in text.tag_ranges('big')],
+                         ['1.3', '1.5', '2.0', '2.5'])
+
+        # tag_ranges of an undefined tag is empty, not an error.
+        self.assertEqual(text.tag_ranges('nonexistent'), ())
+        self.assertRaises(TclError, text.tag_add, 'big', 'invalid')
+        self.assertRaises(TypeError, text.tag_add, 'big')
+        self.assertRaises(TclError, text.tag_remove, 'big', 'invalid')
+        self.assertRaises(TypeError, text.tag_remove, 'big', '1.0', '2.0', '3.0')
+        self.assertRaises(TypeError, text.tag_ranges, 'big', 'extra')
+
+    def test_tag_names(self):
+        text = self.text
+        text.insert('1.0', 'Lorem ipsum')
+        text.tag_add('a', '1.0', '1.5')
+        text.tag_add('b', '1.3', '1.8')
+        # 'sel' always exists; order reflects priority (creation order).
+        self.assertEqual(set(text.tag_names()), {'sel', 'a', 'b'})
+        # Tags applied to the character at the given index.
+        self.assertEqual(set(text.tag_names('1.4')), {'a', 'b'})
+        self.assertEqual(set(text.tag_names('1.0')), {'a'})
+        self.assertEqual(set(text.tag_names('1.10')), set())
+        self.assertRaises(TclError, text.tag_names, 'invalid')
+        self.assertRaises(TypeError, text.tag_names, '1.0', '2.0')
+
+    def test_tag_nextrange_prevrange(self):
+        text = self.text
+        text.insert('1.0', 'Lorem ipsum dolor')
+        text.tag_add('a', '1.0', '1.5')
+        text.tag_add('a', '1.12', '1.17')
+
+        self.assertEqual([str(i) for i in text.tag_nextrange('a', '1.0')],
+                         ['1.0', '1.5'])
+        self.assertEqual([str(i) for i in text.tag_nextrange('a', '1.5')],
+                         ['1.12', '1.17'])
+        self.assertEqual(text.tag_nextrange('a', '1.17'), ())
+
+        self.assertEqual([str(i) for i in text.tag_prevrange('a', 'end')],
+                         ['1.12', '1.17'])
+        self.assertEqual([str(i) for i in text.tag_prevrange('a', '1.12')],
+                         ['1.0', '1.5'])
+        self.assertEqual(text.tag_prevrange('a', '1.0'), ())
+
+        # An undefined tag has no ranges, but the index must be valid.
+        self.assertEqual(text.tag_nextrange('nonexistent', '1.0'), ())
+        self.assertRaises(TclError, text.tag_nextrange, 'a', 'invalid')
+        self.assertRaises(TclError, text.tag_prevrange, 'a', 'invalid')
+        self.assertRaises(TypeError, text.tag_nextrange, 'a')
+        self.assertRaises(TypeError, text.tag_prevrange, 'a')
+        self.assertRaises(TypeError, text.tag_nextrange, 'a', '1.0', '2.0', '3.0')
+        self.assertRaises(TypeError, text.tag_prevrange, 'a', '1.0', '2.0', '3.0')
+
+    def test_tag_delete(self):
+        text = self.text
+        text.insert('1.0', 'Lorem ipsum')
+        text.tag_add('a', '1.0', '1.5')
+        text.tag_add('b', '1.6', '1.11')
+        self.assertEqual(set(text.tag_names()), {'sel', 'a', 'b'})
+        text.tag_delete('a', 'b')
+        self.assertEqual(set(text.tag_names()), {'sel'})
+        self.assertEqual(text.tag_ranges('a'), ())
+
+    def test_tag_raise_lower(self):
+        text = self.text
+        text.tag_configure('a', foreground='red')
+        text.tag_configure('b', foreground='green')
+        text.tag_configure('c', foreground='blue')
+        # Creation order is lowest-to-highest priority; tag_names lists
+        # them in increasing priority order.
+        self.assertEqual(text.tag_names(), ('sel', 'a', 'b', 'c'))
+        text.tag_raise('a')
+        self.assertEqual(text.tag_names(), ('sel', 'b', 'c', 'a'))
+        text.tag_lower('a')
+        self.assertEqual(text.tag_names(), ('a', 'sel', 'b', 'c'))
+        text.tag_raise('a', 'b')
+        self.assertEqual(text.tag_names(), ('sel', 'b', 'a', 'c'))
+        text.tag_lower('c', 'b')
+        self.assertEqual(text.tag_names(), ('sel', 'c', 'b', 'a'))
+
+        self.assertRaises(TclError, text.tag_raise, 'nonexistent')
+        self.assertRaises(TclError, text.tag_lower, 'nonexistent')
+        self.assertRaises(TclError, text.tag_raise, 'a', 'nonexistent')
+        self.assertRaises(TypeError, text.tag_raise)
+        self.assertRaises(TypeError, text.tag_raise, 'a', 'b', 'c')
+        self.assertRaises(TypeError, text.tag_lower, 'a', 'b', 'c')
+
+    def test_tag_cget_configure(self):
+        text = self.text
+        text.tag_configure('a', foreground='red', underline=True)
+        self.assertEqual(str(text.tag_cget('a', 'foreground')), 'red')
+        self.assertIn(text.tag_cget('a', 'underline'), (1, '1', True))
+        # tag_cget normalizes the option name (no leading hyphen needed).
+        self.assertEqual(str(text.tag_cget('a', '-foreground')), 'red')
+        # configure() query returns the full option spec.
+        self.assertEqual(text.tag_configure('a', 'foreground')[-1], 'red')
+        text.tag_configure('a', foreground='blue')
+        self.assertEqual(str(text.tag_cget('a', 'foreground')), 'blue')
+
+        self.assertRaises(TclError, text.tag_cget, 'nonexistent',
+                          'foreground')
+        self.assertRaises(TypeError, text.tag_cget, 'a')
+        self.assertRaises(TypeError, text.tag_cget, 'a', 'foreground', 'extra')
+
+    def test_edit_modified(self):
+        text = self.text
+        self.assertEqual(text.edit_modified(), 0)
+        text.insert('1.0', 'spam')
+        self.assertEqual(text.edit_modified(), 1)
+        text.edit_modified(False)
+        self.assertEqual(text.edit_modified(), 0)
+        text.edit_modified(True)
+        self.assertEqual(text.edit_modified(), 1)
+
+    def test_edit_undo_redo(self):
+        text = self.text
+        text.configure(undo=True)
+        text.insert('1.0', 'spam')
+        text.edit_separator()
+        text.insert('end', ' eggs')
+        self.assertEqual(text.get('1.0', 'end'), 'spam eggs\n')
+
+        text.edit_undo()
+        self.assertEqual(text.get('1.0', 'end'), 'spam\n')
+        text.edit_redo()
+        self.assertEqual(text.get('1.0', 'end'), 'spam eggs\n')
+
+        # An empty undo stack raises.
+        text.edit_reset()
+        self.assertRaises(TclError, text.edit_undo)
+
+    def test_dump(self):
+        text = self.text
+        text.insert('1.0', 'hello')
+        text.tag_add('a', '1.0', '1.3')
+        text.mark_set('here', '1.2')
+
+        dump = text.dump('1.0', 'end')
+        self.assertIsInstance(dump, list)
+        for item in dump:
+            self.assertIsInstance(item, tuple)
+            self.assertEqual(len(item), 3)
+        kinds = {item[0] for item in dump}
+        self.assertIn('text', kinds)
+        self.assertIn('tagon', kinds)
+        self.assertIn('mark', kinds)
+
+        # Filtering by kind.
+        text_only = text.dump('1.0', 'end', text=True)
+        self.assertEqual({item[0] for item in text_only}, {'text'})
+        self.assertEqual(''.join(item[1] for item in text_only), 'hello\n')
+
+        # The command callback receives each triple and suppresses the result.
+        collected = []
+        result = text.dump('1.0', 'end', text=True,
+                           command=lambda *a: collected.append(a))
+        self.assertIsNone(result)
+        self.assertEqual(''.join(key_value_index[1]
+                                 for key_value_index in collected), 'hello\n')
+
+        self.assertRaises(TclError, text.dump, 'invalid')
+        self.assertRaises(TypeError, text.dump)
+        self.assertRaises(TypeError, text.dump, '1.0', 'end', None, 'extra')
+
+    def test_image(self):
+        text = self.text
+        image = tkinter.PhotoImage(master=self.root, width=10, height=10)
+        text.insert('1.0', 'AB')
+        name = text.image_create('1.1', image=image)
+        self.assertIsInstance(name, str)
+        self.assertIn(name, self.root.splitlist(text.image_names()))
+        self.assertEqual(str(text.image_cget(name, 'image')), str(image))
+
+        text.image_configure(name, align='top')
+        self.assertEqual(str(text.image_cget(name, 'align')), 'top')
+
+        # An embedded image occupies a single index position.
+        self.assertEqual(text.index('end - 1 char'), '1.3')
+
+        # Either a name or an image is required, and the index must be valid.
+        self.assertRaises(TclError, text.image_create, '1.0')
+        self.assertRaises(TclError, text.image_create, 'invalid',
+                          image=image)
+        self.assertRaises(TypeError, text.image_cget, name)
+        self.assertRaises(TypeError, text.image_cget, name, 'image', 'extra')
+
+    def test_window(self):
+        text = self.text
+        button = tkinter.Button(text, text='ok')
+        text.insert('1.0', 'AB')
+        text.window_create('1.1', window=button)
+        self.assertEqual(self.root.splitlist(text.window_names()),
+                         (str(button),))
+        self.assertEqual(text.window_cget('1.1', 'window'), str(button))
+
+        text.window_configure('1.1', padx=5)
+        self.assertEqual(text.window_cget('1.1', 'padx'), 5)
+
+        # No embedded window at this index, and the index must be valid.
+        self.assertRaises(TclError, text.window_cget, '1.0', 'window')
+        self.assertRaises(TclError, text.window_cget, 'invalid', 'window')
+        self.assertRaises(TypeError, text.window_cget, '1.1')
+        self.assertRaises(TypeError, text.window_cget, '1.1', 'window', 'extra')
+        button.destroy()
+
+    def test_tag_configure(self):
+        text = self.text
+        tag = 'a'
+        getint = text.tk.getint
+        getboolean = text.tk.getboolean
+
+        # Color options.
+        for opt in ('foreground', 'background'):
+            text.tag_configure(tag, **{opt: '#ff0000'})
+            self.assertEqual(str(text.tag_cget(tag, opt)), '#ff0000')
+
+        # Stipple (bitmap) options.
+        for opt in ('bgstipple', 'fgstipple'):
+            text.tag_configure(tag, **{opt: 'gray50'})
+            self.assertEqual(str(text.tag_cget(tag, opt)), 'gray50')
+
+        # Enumerated options.
+        for opt, value in (('justify', 'center'), ('wrap', 'word'),
+                           ('relief', 'raised'), ('tabstyle', 'wordprocessor'),
+                           ('offset', '5')):
+            text.tag_configure(tag, **{opt: value})
+        self.assertEqual(str(text.tag_cget(tag, 'justify')), 'center')
+        self.assertEqual(str(text.tag_cget(tag, 'wrap')), 'word')
+        self.assertEqual(str(text.tag_cget(tag, 'relief')), 'raised')
+        self.assertEqual(str(text.tag_cget(tag, 'tabstyle')), 'wordprocessor')
+
+        # Boolean options.
+        for opt in ('underline', 'overstrike', 'elide'):
+            text.tag_configure(tag, **{opt: True})
+            self.assertIs(getboolean(text.tag_cget(tag, opt)), True)
+            text.tag_configure(tag, **{opt: False})
+            self.assertIs(getboolean(text.tag_cget(tag, opt)), False)
+
+        # Screen-distance (pixel) options.
+        for opt in ('borderwidth', 'lmargin1', 'lmargin2', 'rmargin',
+                    'spacing1', 'spacing2', 'spacing3'):
+            text.tag_configure(tag, **{opt: 7})
+            self.assertEqual(getint(text.tag_cget(tag, opt)), 7)
+
+        # Other options.
+        text.tag_configure(tag, font='Helvetica 12')
+        self.assertEqual(str(text.tag_cget(tag, 'font')), 'Helvetica 12')
+        text.tag_configure(tag, tabs=(10.2, '1i'))
+        self.assertEqual([str(x) for x in text.tag_ranges('sel')], [])
+
+        self.assertRaises(TclError, text.tag_cget, tag, 'spam')
+
+    @requires_tk(8, 6, 6)
+    def test_tag_configure_colors(self):
+        # Tag color options added in Tk 8.6.6.
+        text = self.text
+        tag = 'a'
+        for opt in ('selectforeground', 'selectbackground',
+                    'lmargincolor', 'rmargincolor',
+                    'underlinefg', 'overstrikefg'):
+            text.tag_configure(tag, **{opt: '#00ff00'})
+            self.assertEqual(str(text.tag_cget(tag, opt)), '#00ff00')
+
+    def test_tag_configure_query(self):
+        text = self.text
+        tag = 'a'
+        # Querying all options returns a dict keyed by option name.
+        cnf = text.tag_configure(tag)
+        self.assertIsInstance(cnf, dict)
+        self.assertIn('foreground', cnf)
+        # The value is the full 5-tuple option specification.
+        self.assertEqual(len(cnf['foreground']), 5)
+
+        # Querying a single option returns its specification.
+        spec = text.tag_configure(tag, 'foreground')
+        self.assertEqual(spec[0], 'foreground')
+        self.assertEqual(spec[-1], '')  # unset by default
+
+        # Setting via keyword arguments and via a dict are equivalent.
+        text.tag_configure(tag, foreground='red')
+        self.assertEqual(str(text.tag_configure(tag, 'foreground')[-1]), 'red')
+        text.tag_configure(tag, {'foreground': 'blue'})
+        self.assertEqual(str(text.tag_cget(tag, 'foreground')), 'blue')
+
+        # tag_config is an alias of tag_configure.
+        self.assertEqual(text.tag_config, text.tag_configure)
+
+    def test_image_configure(self):
+        text = self.text
+        image = tkinter.PhotoImage(master=self.root, width=10, height=10)
+        text.insert('1.0', 'AB')
+        name = text.image_create('1.1', image=image, name='img')
+        self.assertEqual(name, 'img')
+
+        self.assertEqual(str(text.image_cget(name, 'name')), 'img')
+        self.assertEqual(str(text.image_cget(name, 'image')), str(image))
+        for value in ('top', 'center', 'bottom', 'baseline'):
+            text.image_configure(name, align=value)
+            self.assertEqual(str(text.image_cget(name, 'align')), value)
+        text.image_configure(name, padx=3, pady=4)
+        self.assertEqual(text.tk.getint(text.image_cget(name, 'padx')), 3)
+        self.assertEqual(text.tk.getint(text.image_cget(name, 'pady')), 4)
+
+        # Querying returns the full option set.
+        cnf = text.image_configure(name)
+        self.assertIsInstance(cnf, dict)
+        self.assertIn('align', cnf)
+        self.assertRaises(TclError, text.image_cget, name, 'spam')
+
+    def test_window_configure(self):
+        text = self.text
+        button = tkinter.Button(text, text='ok')
+        text.insert('1.0', 'AB')
+        text.window_create('1.1', window=button)
+
+        self.assertEqual(text.window_cget('1.1', 'window'), str(button))
+        for value in ('top', 'center', 'bottom', 'baseline'):
+            text.window_configure('1.1', align=value)
+            self.assertEqual(str(text.window_cget('1.1', 'align')), value)
+        text.window_configure('1.1', padx=3, pady=4)
+        self.assertEqual(text.tk.getint(text.window_cget('1.1', 'padx')), 3)
+        self.assertEqual(text.tk.getint(text.window_cget('1.1', 'pady')), 4)
+        text.window_configure('1.1', stretch=True)
+        self.assertIs(text.tk.getboolean(text.window_cget('1.1', 'stretch')),
+                      True)
+
+        cnf = text.window_configure('1.1')
+        self.assertIsInstance(cnf, dict)
+        self.assertIn('stretch', cnf)
+        self.assertRaises(TclError, text.window_cget, '1.1', 'spam')
+        button.destroy()
+
+    def test_peer(self):
+        text = self.text
+        text.insert('1.0', 'Lorem ipsum')
+        self.assertEqual(text.peer_names(), ())
+
+        text.peer_create('.peer1')
+        names = self.root.splitlist(text.tk.call('winfo', 'children', '.'))
+        self.assertIn('.peer1', [str(n) for n in names])
+        self.assertEqual([str(p) for p in text.peer_names()], ['.peer1'])
+        # Peers share content.
+        self.assertEqual(text.tk.call('.peer1', 'get', '1.0', 'end'),
+                         'Lorem ipsum\n')
+        text.tk.call('destroy', '.peer1')
+
+    def test_bbox(self):
+        text = self.text
+        text.insert('1.0', 'hello')
+        text.update()
+        bbox = text.bbox('1.0')
+        self.assertIsInstance(bbox, tuple)
+        self.assertEqual(len(bbox), 4)
+        for v in bbox:
+            self.assertIsInstance(v, int)
+        # A character that is not displayed has no bounding box.
+        self.assertIsNone(text.bbox('end'))
+        self.assertRaises(TclError, text.bbox, 'invalid')
+        self.assertRaises(TypeError, text.bbox)
+        self.assertRaises(TypeError, text.bbox, '1.0', '2.0')
+
+    def test_dlineinfo(self):
+        text = self.text
+        text.insert('1.0', 'hello\nworld')
+        text.update()
+        info = text.dlineinfo('1.0')
+        self.assertIsInstance(info, tuple)
+        self.assertEqual(len(info), 5)
+        for v in info:
+            self.assertIsInstance(v, int)
+        self.assertRaises(TclError, text.dlineinfo, 'invalid')
+        self.assertRaises(TypeError, text.dlineinfo)
+        self.assertRaises(TypeError, text.dlineinfo, '1.0', '2.0')
+
+    def test_see(self):
+        text = self.text
+        text.insert('1.0', '\n'.join('line %d' % i for i in range(200)))
+        text.update()
+        # Initially the last line is not visible.
+        self.assertIsNone(text.bbox('200.0'))
+        text.see('200.0')
+        text.update()
+        self.assertIsNotNone(text.bbox('200.0'))
+        self.assertRaises(TclError, text.see, 'invalid')
+        self.assertRaises(TypeError, text.see)
+        self.assertRaises(TypeError, text.see, '1.0', '2.0')
+
     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)
+        self.assertRaises(TclError, text.search, None, '1.0')
+        self.assertRaises(TclError, text.search, 'a', None)
+        self.assertRaises(TclError, text.search, None, None)
 
         # Invalid text index.
-        self.assertRaises(tkinter.TclError, text.search, '', 0)
-        self.assertRaises(tkinter.TclError, text.search, '', '')
-        self.assertRaises(tkinter.TclError, text.search, '', 'invalid')
-        self.assertRaises(tkinter.TclError, text.search, '', '1.0', 0)
-        self.assertRaises(tkinter.TclError, text.search, '', '1.0', '')
-        self.assertRaises(tkinter.TclError, text.search, '', '1.0', 'invalid')
+        self.assertRaises(TclError, text.search, '', 0)
+        self.assertRaises(TclError, text.search, '', '')
+        self.assertRaises(TclError, text.search, '', 'invalid')
+        self.assertRaises(TclError, text.search, '', '1.0', 0)
+        self.assertRaises(TclError, text.search, '', '1.0', '')
+        self.assertRaises(TclError, text.search, '', '1.0', 'invalid')
 
         text.insert('1.0',
             'This is a test. This is only a test.\n'
@@ -88,20 +625,20 @@ def test_search_all(self):
         text = self.text
 
         # pattern and index are obligatory arguments.
-        self.assertRaises(tkinter.TclError, text.search_all, None, '1.0')
-        self.assertRaises(tkinter.TclError, text.search_all, 'a', None)
-        self.assertRaises(tkinter.TclError, text.search_all, None, None)
+        self.assertRaises(TclError, text.search_all, None, '1.0')
+        self.assertRaises(TclError, text.search_all, 'a', None)
+        self.assertRaises(TclError, text.search_all, None, None)
 
         # Keyword-only arguments
         self.assertRaises(TypeError, text.search_all, 'a', '1.0', 'end', None)
 
         # Invalid text index.
-        self.assertRaises(tkinter.TclError, text.search_all, '', 0)
-        self.assertRaises(tkinter.TclError, text.search_all, '', '')
-        self.assertRaises(tkinter.TclError, text.search_all, '', 'invalid')
-        self.assertRaises(tkinter.TclError, text.search_all, '', '1.0', 0)
-        self.assertRaises(tkinter.TclError, text.search_all, '', '1.0', '')
-        self.assertRaises(tkinter.TclError, text.search_all, '', '1.0', 'invalid')
+        self.assertRaises(TclError, text.search_all, '', 0)
+        self.assertRaises(TclError, text.search_all, '', '')
+        self.assertRaises(TclError, text.search_all, '', 'invalid')
+        self.assertRaises(TclError, text.search_all, '', '1.0', 0)
+        self.assertRaises(TclError, text.search_all, '', '1.0', '')
+        self.assertRaises(TclError, text.search_all, '', '1.0', 'invalid')
 
         def eq(res, expected):
             self.assertIsInstance(res, tuple)
@@ -181,8 +718,8 @@ def test_count(self):
         self.assertEqual(text.count('1.0', 'end'), (124,))
         self.assertEqual(text.count('1.0', 'end', 'indices', return_ints=True), 124)
         self.assertEqual(text.count('1.0', 'end', 'indices'), (124,))
-        self.assertRaises(tkinter.TclError, text.count, '1.0', 'end', 'spam')
-        self.assertRaises(tkinter.TclError, text.count, '1.0', 'end', '-lines')
+        self.assertRaises(TclError, text.count, '1.0', 'end', 'spam')
+        self.assertRaises(TclError, text.count, '1.0', 'end', '-lines')
 
         self.assertIsInstance(text.count('1.3', '1.5', 'ypixels', return_ints=True), int)
         self.assertIsInstance(text.count('1.3', '1.5', 'ypixels'), tuple)

From 551f8e16f8bb38a1e9c6df259a2a0969493de070 Mon Sep 17 00:00:00 2001
From: Serhiy Storchaka <storchaka@gmail.com>
Date: Fri, 19 Jun 2026 11:38:15 +0300
Subject: [PATCH 04/10] gh-151695: Fix use-after-free of the curses screen
 encoding (GH-151696)

The module-global curses_screen_encoding stored a borrowed pointer to the
encoding owned by the window returned by the first initscr() call.  That
window can be deallocated while unctrl() and ungetch(), which have no window
of their own, still use the pointer to encode non-ASCII characters.

Keep a private copy of the encoding instead.

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 ...-06-19-07-26-20.gh-issue-151695.IBDlkN.rst |  4 ++
 Modules/_cursesmodule.c                       | 38 +++++++++++++++++--
 2 files changed, 39 insertions(+), 3 deletions(-)
 create mode 100644 Misc/NEWS.d/next/Library/2026-06-19-07-26-20.gh-issue-151695.IBDlkN.rst

diff --git a/Misc/NEWS.d/next/Library/2026-06-19-07-26-20.gh-issue-151695.IBDlkN.rst b/Misc/NEWS.d/next/Library/2026-06-19-07-26-20.gh-issue-151695.IBDlkN.rst
new file mode 100644
index 00000000000000..f44cb6b9307165
--- /dev/null
+++ b/Misc/NEWS.d/next/Library/2026-06-19-07-26-20.gh-issue-151695.IBDlkN.rst
@@ -0,0 +1,4 @@
+Fix a use-after-free in the :mod:`curses` module.  The encoding of the initial
+screen, used by :func:`curses.unctrl` and :func:`curses.ungetch` to encode
+non-ASCII characters, is now kept as a private copy instead of a borrowed
+pointer to a window object that may be deallocated.
diff --git a/Modules/_cursesmodule.c b/Modules/_cursesmodule.c
index 01cb6786e88aec..02a8e2c1b1bc10 100644
--- a/Modules/_cursesmodule.c
+++ b/Modules/_cursesmodule.c
@@ -208,7 +208,11 @@ static int curses_initscr_called = FALSE;
 /* Tells whether start_color() has been called to initialise color usage. */
 static int curses_start_color_called = FALSE;
 
-static const char *curses_screen_encoding = NULL;
+/* Encoding of the initial screen, used by module-level functions that have
+   no window object to take it from (e.g. unctrl(), ungetch()).  This is a
+   private copy: the window object that initscr() returns may be deallocated
+   while these functions are still in use. */
+static char *curses_screen_encoding = NULL;
 
 /* Utility Error Procedures */
 
@@ -3799,6 +3803,21 @@ _curses_init_pair_impl(PyObject *module, int pair_number, int fg, int bg)
     Py_RETURN_NONE;
 }
 
+/* Refresh the private copy of the screen encoding from a freshly created
+   stdscr window object.  Returns 0 on success, -1 with an exception set. */
+static int
+curses_update_screen_encoding(PyObject *winobj)
+{
+    char *copy = _PyMem_Strdup(((PyCursesWindowObject *)winobj)->encoding);
+    if (copy == NULL) {
+        PyErr_NoMemory();
+        return -1;
+    }
+    PyMem_Free(curses_screen_encoding);
+    curses_screen_encoding = copy;
+    return 0;
+}
+
 /*[clinic input]
 _curses.initscr
 
@@ -3820,7 +3839,15 @@ _curses_initscr_impl(PyObject *module)
             _curses_set_null_error(state, "wrefresh", "initscr");
             return NULL;
         }
-        return PyCursesWindow_New(state, stdscr, NULL, NULL);
+        PyObject *winobj = PyCursesWindow_New(state, stdscr, NULL, NULL);
+        if (winobj == NULL) {
+            return NULL;
+        }
+        if (curses_update_screen_encoding(winobj) < 0) {
+            Py_DECREF(winobj);
+            return NULL;
+        }
+        return winobj;
     }
 
     win = initscr();
@@ -3927,7 +3954,10 @@ _curses_initscr_impl(PyObject *module)
     if (winobj == NULL) {
         return NULL;
     }
-    curses_screen_encoding = ((PyCursesWindowObject *)winobj)->encoding;
+    if (curses_update_screen_encoding(winobj) < 0) {
+        Py_DECREF(winobj);
+        return NULL;
+    }
     return winobj;
 }
 
@@ -5480,6 +5510,8 @@ static void
 cursesmodule_free(void *mod)
 {
     (void)cursesmodule_clear((PyObject *)mod);
+    PyMem_Free(curses_screen_encoding);
+    curses_screen_encoding = NULL;
     curses_module_loaded = 0;  // allow reloading once garbage-collected
 }
 

From a5568d0eb70f8ffbfc7815b58e24170787615931 Mon Sep 17 00:00:00 2001
From: da-woods <dw-git@d-woods.co.uk>
Date: Fri, 19 Jun 2026 09:41:00 +0100
Subject: [PATCH 05/10] gh-141510 Add frozendict fast paths to abstract.c
 (#150692)

Add frozendict to the fast paths of PyMapping_GetOptionalItem(),
PyMapping_Keys(), PyMapping_Values(), and PyMapping_Items().

Co-authored-by: blurb-it[bot] <43283697+blurb-it[bot]@users.noreply.github.com>
---
 Lib/test/test_capi/test_abstract.py                | 14 +++++++++++++-
 .../2026-06-18-18-24-11.gh-issue-141510.-EOHJ1.rst |  1 +
 Objects/abstract.c                                 |  8 ++++----
 3 files changed, 18 insertions(+), 5 deletions(-)
 create mode 100644 Misc/NEWS.d/next/C_API/2026-06-18-18-24-11.gh-issue-141510.-EOHJ1.rst

diff --git a/Lib/test/test_capi/test_abstract.py b/Lib/test/test_capi/test_abstract.py
index 3a2ed9f5db82f0..e455a863620924 100644
--- a/Lib/test/test_capi/test_abstract.py
+++ b/Lib/test/test_capi/test_abstract.py
@@ -411,6 +411,11 @@ def test_mapping_getoptionalitem(self):
         self.assertEqual(getitem(dct2, 'a'), 1)
         self.assertEqual(getitem(dct2, 'b'), KeyError)
 
+        frozendct = frozendict(dct)
+        self.assertEqual(getitem(frozendct, 'a'), 1)
+        self.assertEqual(getitem(frozendct, 'b'), KeyError)
+        self.assertEqual(getitem(frozendct, '\U0001f40d'), 2)
+
         self.assertEqual(getitem(['a', 'b', 'c'], 1), 'b')
 
         self.assertRaises(TypeError, getitem, 42, 'a')
@@ -431,6 +436,11 @@ def test_mapping_getoptionalitemstring(self):
         self.assertEqual(getitemstring(dct2, b'a'), 1)
         self.assertEqual(getitemstring(dct2, b'b'), KeyError)
 
+        frozendct = frozendict(dct)
+        self.assertEqual(getitemstring(frozendct, 'a'), 1)
+        self.assertEqual(getitemstring(frozendct, 'b'), KeyError)
+        self.assertEqual(getitemstring(frozendct, '\U0001f40d'.encode()), 2)
+
         self.assertRaises(TypeError, getitemstring, 42, b'a')
         self.assertRaises(UnicodeDecodeError, getitemstring, {}, b'\xff')
         self.assertRaises(SystemError, getitemstring, {}, NULL)
@@ -677,8 +687,10 @@ def items(self):
         dict_obj = {'foo': 1, 'bar': 2, 'spam': 3}
 
         for mapping in [{}, OrderedDict(), Mapping1(), Mapping2(),
+                        frozendict(),
                         dict_obj, OrderedDict(dict_obj),
-                        Mapping1(dict_obj), Mapping2(dict_obj)]:
+                        Mapping1(dict_obj), Mapping2(dict_obj),
+                        frozendict(dict_obj)]:
             self.assertListEqual(_testlimitedcapi.mapping_keys(mapping),
                                  list(mapping.keys()))
             self.assertListEqual(_testlimitedcapi.mapping_values(mapping),
diff --git a/Misc/NEWS.d/next/C_API/2026-06-18-18-24-11.gh-issue-141510.-EOHJ1.rst b/Misc/NEWS.d/next/C_API/2026-06-18-18-24-11.gh-issue-141510.-EOHJ1.rst
new file mode 100644
index 00000000000000..c77b462e97bdd1
--- /dev/null
+++ b/Misc/NEWS.d/next/C_API/2026-06-18-18-24-11.gh-issue-141510.-EOHJ1.rst
@@ -0,0 +1 @@
+Add :class:`frozendict` to the fast paths of :c:func:`PyMapping_GetOptionalItem`, :c:func:`PyMapping_Keys`, :c:func:`PyMapping_Values`, and :c:func:`PyMapping_Items`.
diff --git a/Objects/abstract.c b/Objects/abstract.c
index 48b3137152e7bf..28f751965f36b9 100644
--- a/Objects/abstract.c
+++ b/Objects/abstract.c
@@ -208,7 +208,7 @@ PyObject_GetItem(PyObject *o, PyObject *key)
 int
 PyMapping_GetOptionalItem(PyObject *obj, PyObject *key, PyObject **result)
 {
-    if (PyDict_CheckExact(obj)) {
+    if (PyAnyDict_CheckExact(obj)) {
         return PyDict_GetItemRef(obj, key, result);
     }
 
@@ -2462,7 +2462,7 @@ PyMapping_Keys(PyObject *o)
     if (o == NULL) {
         return null_error();
     }
-    if (PyDict_CheckExact(o)) {
+    if (PyAnyDict_CheckExact(o)) {
         return PyDict_Keys(o);
     }
     return method_output_as_list(o, &_Py_ID(keys));
@@ -2474,7 +2474,7 @@ PyMapping_Items(PyObject *o)
     if (o == NULL) {
         return null_error();
     }
-    if (PyDict_CheckExact(o)) {
+    if (PyAnyDict_CheckExact(o)) {
         return PyDict_Items(o);
     }
     return method_output_as_list(o, &_Py_ID(items));
@@ -2486,7 +2486,7 @@ PyMapping_Values(PyObject *o)
     if (o == NULL) {
         return null_error();
     }
-    if (PyDict_CheckExact(o)) {
+    if (PyAnyDict_CheckExact(o)) {
         return PyDict_Values(o);
     }
     return method_output_as_list(o, &_Py_ID(values));

From ef5c32a40be50a33a9b7ac39ee64e6893bc22f60 Mon Sep 17 00:00:00 2001
From: Serhiy Storchaka <storchaka@gmail.com>
Date: Fri, 19 Jun 2026 11:59:14 +0300
Subject: [PATCH 06/10] gh-151678: Add tests for tkinter.Menu (GH-151685)

Cover previously-untested Menu methods in MenuTest: adding, inserting and
deleting items of every type, index resolution, invoking items, entry x/y
positions, and post/unpost/tk_popup mapping.

Also test per-entry configuration options and the errors raised for
invalid indices, entry types, option names and option values.

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 Lib/test/test_tkinter/test_widgets.py | 186 ++++++++++++++++++++++++++
 1 file changed, 186 insertions(+)

diff --git a/Lib/test/test_tkinter/test_widgets.py b/Lib/test/test_tkinter/test_widgets.py
index 1c400e970eb02d..fd3c70c97c3d5b 100644
--- a/Lib/test/test_tkinter/test_widgets.py
+++ b/Lib/test/test_tkinter/test_widgets.py
@@ -1542,6 +1542,192 @@ def test_entryconfigure_variable(self):
         m1.entryconfigure(1, variable=v2)
         self.assertEqual(str(m1.entrycget(1, 'variable')), str(v2))
 
+    def test_add(self):
+        m = self.create(tearoff=False)
+        m.add_command(label='Command')
+        m.add_checkbutton(label='Checkbutton')
+        m.add_radiobutton(label='Radiobutton')
+        m.add_separator()
+        m.add_cascade(label='Cascade', menu=tkinter.Menu(m, tearoff=False))
+        self.assertEqual(m.index('end'), 4)
+        self.assertEqual([m.type(i) for i in range(5)],
+                         ['command', 'checkbutton', 'radiobutton',
+                          'separator', 'cascade'])
+        self.assertEqual(m.entrycget(0, 'label'), 'Command')
+        self.assertRaisesRegex(TclError, 'bad menu entry type "spam"',
+                               m.add, 'spam')
+
+    def test_insert(self):
+        m = self.create(tearoff=False)
+        m.add_command(label='A')
+        m.add_command(label='C')
+        m.insert_command(1, label='B')
+        m.insert_separator(0)
+        m.insert_checkbutton('end', label='D')
+        m.insert_radiobutton(0, label='top')
+        m.insert_cascade(2, label='sub',
+                         menu=tkinter.Menu(m, tearoff=False))
+        self.assertEqual(
+            [m.type(i) for i in range(m.index('end') + 1)],
+            ['radiobutton', 'separator', 'cascade', 'command',
+             'command', 'command', 'checkbutton'])
+        self.assertEqual(
+            [m.entrycget(i, 'label') for i in (3, 4, 5)],
+            ['A', 'B', 'C'])
+        self.assertRaisesRegex(TclError, 'bad menu entry type "spam"',
+                               m.insert, 0, 'spam')
+        self.assertRaisesRegex(TclError, 'bad menu entry index "spam"',
+                               m.insert_command, 'spam', label='z')
+
+    def test_delete(self):
+        m = self.create(tearoff=False)
+        commands = []
+        for label in 'ABCDE':
+            m.add_command(label=label,
+                          command=lambda label=label: commands.append(label))
+        # The Tcl command for a deleted item is cleaned up.
+        funcid = str(m.entrycget(2, 'command'))
+        self.assertEqual(
+            m.tk.splitlist(m.tk.call('info', 'commands', funcid)), (funcid,))
+
+        m.delete(2)  # Delete a single item ('C').
+        self.assertEqual([m.entrycget(i, 'label') for i in range(4)],
+                         ['A', 'B', 'D', 'E'])
+        self.assertEqual(
+            m.tk.splitlist(m.tk.call('info', 'commands', funcid)), ())
+
+        m.delete(1, 2)  # Delete a range ('B' and 'D').
+        self.assertEqual([m.entrycget(i, 'label') for i in range(2)],
+                         ['A', 'E'])
+        self.assertRaises(TypeError, m.delete)
+
+    def test_index(self):
+        m = self.create(tearoff=False)
+        self.assertIsNone(m.index('end'))
+        m.add_command(label='First')
+        m.add_command(label='Second')
+        self.assertEqual(m.index('end'), 1)
+        self.assertEqual(m.index('last'), 1)
+        self.assertEqual(m.index('Second'), 1)
+        self.assertEqual(m.index(0), 0)
+        # 'active' and 'none' map to None when no item is active.
+        self.assertIsNone(m.index('active'))
+        self.assertIsNone(m.index('none'))
+        self.assertRaisesRegex(TclError, 'bad menu entry index "spam"',
+                               m.index, 'spam')
+
+    def test_invoke(self):
+        m = self.create(tearoff=False)
+        commands = []
+        m.add_command(label='Command',
+                      command=lambda: commands.append('invoked'))
+        var = tkinter.IntVar(self.root)
+        m.add_checkbutton(label='Check', variable=var,
+                          onvalue=1, offvalue=0)
+        rvar = tkinter.StringVar(self.root)
+        m.add_radiobutton(label='Radio', variable=rvar, value='on')
+
+        m.invoke(0)
+        self.assertEqual(commands, ['invoked'])
+        m.invoke(1)
+        self.assertEqual(var.get(), 1)
+        m.invoke(1)
+        self.assertEqual(var.get(), 0)
+        m.invoke(2)
+        self.assertEqual(rvar.get(), 'on')
+        self.assertRaisesRegex(TclError, 'bad menu entry index "spam"',
+                               m.invoke, 'spam')
+
+    def test_xposition_yposition(self):
+        m = self.create(tearoff=False)
+        m.add_command(label='First')
+        m.add_command(label='Second')
+        m.update_idletasks()
+        self.assertIsInstance(m.xposition(0), int)
+        y0 = m.yposition(0)
+        y1 = m.yposition(1)
+        self.assertIsInstance(y0, int)
+        self.assertLess(y0, y1)
+        # An out-of-range index gives the position past the last item.
+        self.assertEqual(m.xposition('end'), m.xposition(1))
+        self.assertRaisesRegex(TclError, 'bad menu entry index "spam"',
+                               m.xposition, 'spam')
+        self.assertRaisesRegex(TclError, 'bad menu entry index "spam"',
+                               m.yposition, 'spam')
+
+    def test_post_unpost(self):
+        m = self.create(tearoff=False)
+        if m._windowingsystem != 'x11':
+            # Posting a menu is modal on Windows and uses a native, unmapped
+            # menu on Aqua, so it cannot be tested synchronously there.
+            self.skipTest('menu posting is not testable on this platform')
+        m.add_command(label='First')
+        m.add_command(label='Second')
+        self.assertFalse(m.winfo_ismapped())
+
+        m.post(0, 0)
+        m.update()
+        self.assertTrue(m.winfo_ismapped())
+        m.unpost()
+        m.update()
+        self.assertFalse(m.winfo_ismapped())
+
+        m.tk_popup(0, 0)
+        m.update()
+        self.assertTrue(m.winfo_ismapped())
+        m.unpost()
+        m.update()
+        self.assertFalse(m.winfo_ismapped())
+
+    def check_entry_option(self, m, index, option, value, expected=None):
+        if expected is None:
+            expected = value
+        m.entryconfigure(index, **{option: value})
+        self.assertEqual(str(m.entrycget(index, option)), str(expected))
+        self.assertEqual(str(m.entryconfigure(index, option)[4]), str(expected))
+
+    def test_entry_options(self):
+        m = self.create(tearoff=False)
+        m.add_command(label='Command')
+        self.check_entry_option(m, 0, 'accelerator', 'Ctrl+O')
+        self.check_entry_option(m, 0, 'underline', 2)
+        self.check_entry_option(m, 0, 'state', 'disabled')
+        self.check_entry_option(m, 0, 'background', 'red')
+        self.check_entry_option(m, 0, 'foreground', 'blue')
+        self.check_entry_option(m, 0, 'columnbreak', 1)
+        self.check_entry_option(m, 0, 'hidemargin', 1)
+
+        m.add_checkbutton(label='Checkbutton')
+        self.check_entry_option(m, 1, 'onvalue', 'Y')
+        self.check_entry_option(m, 1, 'offvalue', 'N')
+        self.check_entry_option(m, 1, 'indicatoron', 0)
+
+        m.add_radiobutton(label='Radiobutton')
+        self.check_entry_option(m, 2, 'value', 'V')
+        self.check_entry_option(m, 2, 'selectcolor', 'green')
+
+    def test_entry_options_invalid(self):
+        m = self.create(tearoff=False)
+        m.add_command(label='Command')
+        self.assertRaisesRegex(TclError, 'unknown option "-spam"',
+                               m.entrycget, 0, 'spam')
+        self.assertRaisesRegex(TclError, 'unknown option "-spam"',
+                               m.entryconfigure, 0, spam='x')
+        self.assertRaisesRegex(TclError, 'bad state "spam"',
+                               m.entryconfigure, 0, state='spam')
+        # Tk < 9 reports "expected integer but got ...", while Tk 9, where
+        # underline accepts an index, reports "bad index ...".
+        self.assertRaisesRegex(TclError,
+                               r'(expected integer but got|bad index) "spam"',
+                               m.entryconfigure, 0, underline='spam')
+        self.assertRaisesRegex(TclError, 'unknown color name "spam"',
+                               m.entryconfigure, 0, background='spam')
+        self.assertRaisesRegex(TclError, 'expected boolean value but got "spam"',
+                               m.entryconfigure, 0, columnbreak='spam')
+        # onvalue applies only to checkbutton and radiobutton entries.
+        self.assertRaisesRegex(TclError, 'unknown option "-onvalue"',
+                               m.entrycget, 0, 'onvalue')
+
 
 @add_configure_tests(PixelSizeTests, StandardOptionsTests)
 class MessageTest(AbstractWidgetTest, unittest.TestCase):

From cf3b3c11485a870d8e8c02579bed27a316838eb1 Mon Sep 17 00:00:00 2001
From: Serhiy Storchaka <storchaka@gmail.com>
Date: Fri, 19 Jun 2026 12:04:10 +0300
Subject: [PATCH 07/10] gh-151678: Add tests for tkinter.Listbox (GH-151686)

Cover previously-untested Listbox methods in ListboxTest: size, delete,
index resolution, nearest, see, activate, and the selection methods
(selection_set/clear/includes/anchor and their select_* aliases),
including the errors raised for invalid indices.

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 Lib/test/test_tkinter/test_widgets.py | 100 ++++++++++++++++++++++++++
 1 file changed, 100 insertions(+)

diff --git a/Lib/test/test_tkinter/test_widgets.py b/Lib/test/test_tkinter/test_widgets.py
index fd3c70c97c3d5b..3fea5773632ef5 100644
--- a/Lib/test/test_tkinter/test_widgets.py
+++ b/Lib/test/test_tkinter/test_widgets.py
@@ -1180,6 +1180,106 @@ def test_get(self):
         self.assertRaises(TypeError, lb.get, 1, 2, 3)
         self.assertRaises(TclError, lb.get, 2.4)
 
+    def test_size(self):
+        lb = self.create()
+        self.assertEqual(lb.size(), 0)
+        lb.insert(0, *('el%d' % i for i in range(8)))
+        self.assertEqual(lb.size(), 8)
+        lb.delete(0, 2)
+        self.assertEqual(lb.size(), 5)
+        self.assertRaises(TypeError, lb.size, 0)
+
+    def test_delete(self):
+        lb = self.create()
+        lb.insert(0, *('el%d' % i for i in range(8)))
+        lb.delete(0)
+        self.assertEqual(lb.get(0, 'end'),
+                         ('el1', 'el2', 'el3', 'el4', 'el5', 'el6', 'el7'))
+        lb.delete(2, 4)
+        self.assertEqual(lb.get(0, 'end'), ('el1', 'el2', 'el6', 'el7'))
+        lb.delete(0, 'end')
+        self.assertEqual(lb.size(), 0)
+        self.assertRaises(TclError, lb.delete, 'noindex')
+        self.assertRaises(TypeError, lb.delete)
+
+    def test_index(self):
+        lb = self.create()
+        lb.insert(0, *('el%d' % i for i in range(8)))
+        self.assertEqual(lb.index(3), 3)
+        self.assertEqual(lb.index('end'), 8)  # the number of elements
+        lb.activate(4)
+        self.assertEqual(lb.index('active'), 4)
+        lb.selection_anchor(2)
+        self.assertEqual(lb.index('anchor'), 2)
+        self.assertRaisesRegex(TclError, 'bad listbox index "spam"',
+                               lb.index, 'spam')
+
+    def test_nearest(self):
+        lb = self.create()
+        lb.insert(0, *('el%d' % i for i in range(8)))
+        lb.pack()
+        lb.wait_visibility()
+        lb.update()
+        # Derive the line height from the first item, which is always
+        # displayed (bbox() returns None for items that are not).
+        x, y, w, h = lb.bbox(0)
+        self.assertEqual(lb.nearest(y + h // 2), 0)
+        self.assertEqual(lb.nearest(y + 3 * h + h // 2), 3)
+        self.assertRaises(TclError, lb.nearest, 'spam')
+        self.assertRaises(TypeError, lb.nearest)
+
+    def test_see(self):
+        lb = self.create(height=5)
+        lb.insert(0, *('el%d' % i for i in range(20)))
+        lb.pack()
+        lb.update_idletasks()
+        lb.see('end')
+        lb.update_idletasks()
+        self.assertEqual(lb.yview()[1], 1.0)
+        lb.see(0)
+        lb.update_idletasks()
+        self.assertEqual(lb.yview()[0], 0.0)
+        self.assertRaises(TclError, lb.see, 'spam')
+
+    def test_activate(self):
+        lb = self.create()
+        lb.insert(0, *('el%d' % i for i in range(8)))
+        lb.activate(3)
+        self.assertEqual(lb.index('active'), 3)
+        lb.activate('end')
+        self.assertEqual(lb.index('active'), 7)
+        self.assertRaises(TclError, lb.activate, 'spam')
+        self.assertRaises(TypeError, lb.activate)
+
+    def test_selection(self):
+        lb = self.create()
+        lb.insert(0, *('el%d' % i for i in range(8)))
+        self.assertEqual(lb.curselection(), ())
+        self.assertFalse(lb.selection_includes(0))
+
+        lb.selection_set(2, 4)
+        lb.selection_set(6)
+        self.assertEqual(lb.curselection(), (2, 3, 4, 6))
+        self.assertTrue(lb.selection_includes(3))
+        self.assertFalse(lb.selection_includes(5))
+
+        lb.selection_clear(3, 4)
+        self.assertEqual(lb.curselection(), (2, 6))
+
+        lb.selection_anchor(5)
+        self.assertEqual(lb.index('anchor'), 5)
+
+        # select_* are aliases of the selection_* methods.
+        lb.select_clear(0, 'end')
+        self.assertEqual(lb.curselection(), ())
+        lb.select_set(1)
+        self.assertTrue(lb.select_includes(1))
+        lb.select_anchor(1)
+        self.assertEqual(lb.index('anchor'), 1)
+
+        self.assertRaisesRegex(TclError, 'bad listbox index "spam"',
+                               lb.selection_includes, 'spam')
+
 
 @add_configure_tests(PixelSizeTests, StandardOptionsTests)
 class ScaleTest(AbstractWidgetTest, unittest.TestCase):

From bb127c5a96a285f1f6b11261c1f0dc2b3c7f70ff Mon Sep 17 00:00:00 2001
From: Serhiy Storchaka <storchaka@gmail.com>
Date: Fri, 19 Jun 2026 12:13:41 +0300
Subject: [PATCH 08/10] gh-151678: Add tests for tkinter.Canvas (GH-151683)

Cover previously-untested Canvas methods in CanvasTest:

* item creation and types, bbox, coordinate conversion, move/scale,
  find and addtag queries, tags, item configuration, stacking order,
  text-item editing, selection, focus, scan and postscript;
* the create_arc, create_oval, create_bitmap, create_image,
  create_text and create_window item creation methods, checking
  coordinates, default and explicit options, valid enumerations and
  rejection of invalid values;
* tag_bind() and tag_unbind(), checking the returned function id and
  binding script, querying bound sequences, the add parameter, event
  delivery to items via a tag, and removal of a single binding by id
  or all bindings for a sequence.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 Lib/test/test_tkinter/test_widgets.py | 501 ++++++++++++++++++++++++++
 1 file changed, 501 insertions(+)

diff --git a/Lib/test/test_tkinter/test_widgets.py b/Lib/test/test_tkinter/test_widgets.py
index 3fea5773632ef5..ea53382bfa2ab9 100644
--- a/Lib/test/test_tkinter/test_widgets.py
+++ b/Lib/test/test_tkinter/test_widgets.py
@@ -978,6 +978,122 @@ def test_create_polygon(self):
         self._test_option_smooth(c,
                 lambda **kwargs: c.create_polygon(20, 30, 40, 50, 60, 10, **kwargs))
 
+    def test_create_arc(self):
+        c = self.create()
+        i = c.create_arc(10, 20, 30, 40)
+        self.assertEqual(c.coords(i), [10.0, 20.0, 30.0, 40.0])
+        self.assertEqual(c.itemcget(i, 'style'), 'pieslice')
+        self.assertEqual(float(c.itemcget(i, 'start')), 0.0)
+        self.assertEqual(float(c.itemcget(i, 'extent')), 90.0)
+
+        for style in 'pieslice', 'chord', 'arc':
+            i = c.create_arc(10, 20, 30, 40, style=style)
+            self.assertEqual(c.itemcget(i, 'style'), style)
+        self.assertRaises(TclError, c.create_arc, 10, 20, 30, 40, style='spam')
+
+        i = c.create_arc(10, 20, 30, 40, start=45, extent=120,
+                         outline='red', fill='blue', width=3)
+        self.assertEqual(float(c.itemcget(i, 'start')), 45.0)
+        self.assertEqual(float(c.itemcget(i, 'extent')), 120.0)
+        self.assertEqual(str(c.itemcget(i, 'outline')), 'red')
+        self.assertEqual(str(c.itemcget(i, 'fill')), 'blue')
+        self.assertEqual(float(c.itemcget(i, 'width')), 3.0)
+        self.assertRaises(TclError, c.create_arc, 10, 20, 30, 40, extent='spam')
+
+    def test_create_oval(self):
+        c = self.create()
+        i = c.create_oval(10, 20, 30, 40)
+        self.assertEqual(c.coords(i), [10.0, 20.0, 30.0, 40.0])
+        self.assertEqual(c.bbox(i), (9, 19, 31, 41))
+        self.assertEqual(c.itemcget(i, 'stipple'), '')
+
+        i = c.create_oval(10, 20, 30, 40, fill='red', outline='blue', width=2)
+        self.assertEqual(str(c.itemcget(i, 'fill')), 'red')
+        self.assertEqual(str(c.itemcget(i, 'outline')), 'blue')
+        self.assertEqual(float(c.itemcget(i, 'width')), 2.0)
+        self.assertRaises(TclError, c.create_oval, 10, 20, 30, 40, width='spam')
+
+    def test_create_bitmap(self):
+        c = self.create()
+        i = c.create_bitmap(10, 20, bitmap='gray50')
+        self.assertEqual(c.coords(i), [10.0, 20.0])
+        self.assertEqual(c.itemcget(i, 'bitmap'), 'gray50')
+        self.assertEqual(c.itemcget(i, 'anchor'), 'center')
+
+        for anchor in 'n', 'ne', 'e', 'se', 's', 'sw', 'w', 'nw', 'center':
+            i = c.create_bitmap(10, 20, bitmap='gray50', anchor=anchor)
+            self.assertEqual(c.itemcget(i, 'anchor'), anchor)
+        self.assertRaises(TclError, c.create_bitmap, 10, 20,
+                          bitmap='gray50', anchor='spam')
+
+        i = c.create_bitmap(10, 20, bitmap='gray50',
+                            foreground='red', background='blue')
+        self.assertEqual(str(c.itemcget(i, 'foreground')), 'red')
+        self.assertEqual(str(c.itemcget(i, 'background')), 'blue')
+        if c._windowingsystem != 'aqua':
+            # Aqua resolves bitmaps lazily and does not report a bad name here.
+            self.assertRaises(TclError, c.create_bitmap, 10, 20, bitmap='spam')
+
+    def test_create_image(self):
+        c = self.create()
+        image = tkinter.PhotoImage(master=self.root, width=10, height=10)
+        i = c.create_image(10, 20, image=image)
+        self.assertEqual(c.coords(i), [10.0, 20.0])
+        self.assertEqual(str(c.itemcget(i, 'image')), str(image))
+        self.assertEqual(c.itemcget(i, 'anchor'), 'center')
+
+        for anchor in 'n', 'ne', 'e', 'se', 's', 'sw', 'w', 'nw', 'center':
+            i = c.create_image(10, 20, image=image, anchor=anchor)
+            self.assertEqual(c.itemcget(i, 'anchor'), anchor)
+        self.assertRaises(TclError, c.create_image, 10, 20,
+                          image=image, anchor='spam')
+
+    def test_create_text(self):
+        c = self.create()
+        i = c.create_text(10, 20, text='Hello')
+        self.assertEqual(c.coords(i), [10.0, 20.0])
+        self.assertEqual(c.itemcget(i, 'text'), 'Hello')
+        self.assertEqual(c.itemcget(i, 'anchor'), 'center')
+        self.assertEqual(c.itemcget(i, 'justify'), 'left')
+
+        for justify in 'left', 'right', 'center':
+            i = c.create_text(10, 20, text='Hello', justify=justify)
+            self.assertEqual(c.itemcget(i, 'justify'), justify)
+        self.assertRaises(TclError, c.create_text, 10, 20, justify='spam')
+
+        for anchor in 'n', 'ne', 'e', 'se', 's', 'sw', 'w', 'nw', 'center':
+            i = c.create_text(10, 20, text='Hello', anchor=anchor)
+            self.assertEqual(c.itemcget(i, 'anchor'), anchor)
+        self.assertRaises(TclError, c.create_text, 10, 20, anchor='spam')
+
+        i = c.create_text(10, 20, text='Hello', fill='red', angle=45,
+                          font='TkFixedFont')
+        self.assertEqual(str(c.itemcget(i, 'fill')), 'red')
+        self.assertEqual(float(c.itemcget(i, 'angle')), 45.0)
+        self.assertEqual(str(c.itemcget(i, 'font')), 'TkFixedFont')
+        self.assertRaises(TclError, c.create_text, 10, 20, angle='spam')
+
+    def test_create_window(self):
+        c = self.create()
+        button = tkinter.Button(c, text='ok')
+        i = c.create_window(10, 20, window=button)
+        self.assertEqual(c.coords(i), [10.0, 20.0])
+        self.assertEqual(c.itemcget(i, 'window'), str(button))
+        self.assertEqual(c.itemcget(i, 'anchor'), 'center')
+
+        for anchor in 'n', 'ne', 'e', 'se', 's', 'sw', 'w', 'nw', 'center':
+            i = c.create_window(10, 20, window=tkinter.Button(c), anchor=anchor)
+            self.assertEqual(c.itemcget(i, 'anchor'), anchor)
+        self.assertRaises(TclError, c.create_window, 10, 20,
+                          window=button, anchor='spam')
+
+        i = c.create_window(10, 20, window=tkinter.Button(c),
+                            width=30, height=40)
+        self.assertEqual(int(c.itemcget(i, 'width')), 30)
+        self.assertEqual(int(c.itemcget(i, 'height')), 40)
+        self.assertRaises(TclError, c.create_window, 10, 20,
+                          window=button, width='spam')
+
     def test_coords(self):
         c = self.create()
         i = c.create_line(20, 30, 40, 50, 60, 10, tags='x')
@@ -1038,6 +1154,391 @@ def test_moveto(self):
         self.assertEqual(x2_2 - x1_2, x2_3 - x1_3)
         self.assertEqual(y2_2 - y1_2, y2_3 - y1_3)
 
+    def test_create_items(self):
+        c = self.create()
+        image = tkinter.PhotoImage(master=self.root, width=10, height=10)
+        button = tkinter.Button(c, text='ok')
+        items = {
+            'arc': c.create_arc(10, 20, 30, 40),
+            'bitmap': c.create_bitmap(10, 20, bitmap='gray50'),
+            'image': c.create_image(10, 20, image=image),
+            'line': c.create_line(10, 20, 30, 40),
+            'oval': c.create_oval(10, 20, 30, 40),
+            'polygon': c.create_polygon(10, 20, 30, 40, 50, 20),
+            'rectangle': c.create_rectangle(10, 20, 30, 40),
+            'text': c.create_text(10, 20, text='hello'),
+            'window': c.create_window(10, 20, window=button),
+        }
+        for itemtype, item in items.items():
+            self.assertIsInstance(item, int)
+            self.assertEqual(c.type(item), itemtype)
+        # All items are reported by find_all in creation (stacking) order.
+        self.assertEqual(c.find_all(), tuple(sorted(items.values())))
+
+        # No coordinates at all is an IndexError; a bad number is a TclError.
+        self.assertRaises(IndexError, c.create_arc)
+        self.assertRaises(TclError, c.create_arc, 1, 2, 3)
+        self.assertRaises(TclError, c.create_oval, 1, 2)
+
+    def test_type(self):
+        c = self.create()
+        rect = c.create_rectangle(10, 20, 30, 40)
+        self.assertEqual(c.type(rect), 'rectangle')
+        # An unmatched tag or id is not an error.
+        self.assertIsNone(c.type('nonexistent'))
+        self.assertIsNone(c.type(9999))
+        self.assertRaises(TypeError, c.type)
+        self.assertRaises(TypeError, c.type, rect, 'extra')
+
+    def test_bbox(self):
+        c = self.create()
+        rect = c.create_rectangle(10, 10, 30, 30)
+        bbox = c.bbox(rect)
+        self.assertIsInstance(bbox, tuple)
+        self.assertEqual(len(bbox), 4)
+        for v in bbox:
+            self.assertIsInstance(v, int)
+        # The bounding box encloses the item (with a small margin).
+        self.assertEqual(bbox, (9, 9, 31, 31))
+        # bbox over several items is their union.
+        rect2 = c.create_rectangle(50, 50, 70, 70)
+        self.assertEqual(c.bbox(rect, rect2), (9, 9, 71, 71))
+        # An unmatched tag has no bounding box.
+        self.assertIsNone(c.bbox('nonexistent'))
+        # At least one tag or id is required.
+        self.assertRaises(TclError, c.bbox)
+
+    def test_canvasx_canvasy(self):
+        c = self.create(borderwidth=0, highlightthickness=0)
+        self.assertEqual(c.canvasx(0), 0.0)
+        self.assertEqual(c.canvasx(10), 10.0)
+        self.assertIsInstance(c.canvasx(10), float)
+        # gridspacing rounds to the nearest multiple.
+        self.assertEqual(c.canvasx(13, 5), 15.0)
+        self.assertEqual(c.canvasy(0), 0.0)
+        self.assertEqual(c.canvasy(10), 10.0)
+        self.assertRaises(TypeError, c.canvasx)
+        self.assertRaises(TypeError, c.canvasx, 0, 5, 1)
+        self.assertRaises(TypeError, c.canvasy)
+        self.assertRaises(TypeError, c.canvasy, 0, 5, 1)
+        self.assertRaises(TclError, c.canvasx, 'spam')
+        self.assertRaises(TclError, c.canvasy, 'spam')
+
+    def test_move(self):
+        c = self.create()
+        rect = c.create_rectangle(10, 10, 30, 30)
+        c.move(rect, 5, 7)
+        self.assertEqual(c.coords(rect), [15.0, 17.0, 35.0, 37.0])
+        c.move(rect, -5, -7)
+        self.assertEqual(c.coords(rect), [10.0, 10.0, 30.0, 30.0])
+        # move() takes variable arguments; bad or missing values reach Tcl.
+        self.assertRaises(TclError, c.move, rect, 'spam', 0)
+        self.assertRaises(TclError, c.move, rect)
+
+    def test_scale(self):
+        c = self.create()
+        rect = c.create_rectangle(10, 10, 30, 30)
+        c.scale(rect, 0, 0, 2, 2)
+        self.assertEqual(c.coords(rect), [20.0, 20.0, 60.0, 60.0])
+        c.scale(rect, 0, 0, 0.5, 0.5)
+        self.assertEqual(c.coords(rect), [10.0, 10.0, 30.0, 30.0])
+        self.assertRaises(TclError, c.scale, rect, 0, 0, 'spam', 2)
+        self.assertRaises(TclError, c.scale, rect, 0, 0)  # missing factors
+
+    def test_delete(self):
+        c = self.create()
+        r1 = c.create_rectangle(10, 10, 30, 30)
+        r2 = c.create_rectangle(50, 50, 70, 70)
+        r3 = c.create_rectangle(90, 90, 110, 110)
+        self.assertEqual(c.find_all(), (r1, r2, r3))
+        c.delete(r2)
+        self.assertEqual(c.find_all(), (r1, r3))
+        # Deleting a non-existent item is not an error.
+        c.delete(9999)
+        c.delete('all')
+        self.assertEqual(c.find_all(), ())
+
+    def test_find(self):
+        c = self.create()
+        r1 = c.create_rectangle(10, 10, 30, 30)
+        r2 = c.create_rectangle(50, 50, 70, 70)
+        r3 = c.create_rectangle(100, 100, 120, 120)
+
+        self.assertEqual(c.find_all(), (r1, r2, r3))
+        # find_above/find_below return the single adjacent item.
+        self.assertEqual(c.find_above(r1), (r2,))
+        self.assertEqual(c.find_below(r3), (r2,))
+        self.assertEqual(c.find_above(r3), ())  # nothing above the top item
+        self.assertEqual(c.find_withtag(r2), (r2,))
+        self.assertEqual(c.find_closest(60, 60), (r2,))
+        self.assertEqual(c.find_enclosed(0, 0, 80, 80), (r1, r2))
+        self.assertEqual(c.find_overlapping(0, 0, 20, 20), (r1,))
+        # An unmatched query returns an empty tuple.
+        self.assertEqual(c.find_withtag('nonexistent'), ())
+        for result in (c.find_all(), c.find_withtag(r1)):
+            self.assertIsInstance(result, tuple)
+
+        self.assertRaises(TclError, c.find_closest, 'spam', 0)
+        self.assertRaises(TclError, c.find_enclosed, 0, 0, 'spam', 0)
+        self.assertRaises(TclError, c.find_overlapping, 0, 0, 'spam', 0)
+        self.assertRaises(TypeError, c.find_withtag)
+        self.assertRaises(TypeError, c.find_withtag, r1, 'extra')
+        self.assertRaises(TypeError, c.find_above)
+        self.assertRaises(TypeError, c.find_above, r1, 'extra')
+        self.assertRaises(TypeError, c.find_below)
+        self.assertRaises(TypeError, c.find_closest)
+        self.assertRaises(TypeError, c.find_closest, 0, 0, 1, 2, 3)
+        self.assertRaises(TypeError, c.find_enclosed, 0, 0, 1)
+        self.assertRaises(TypeError, c.find_enclosed, 0, 0, 1, 2, 3)
+
+    def test_addtag_gettags_dtag(self):
+        c = self.create()
+        r1 = c.create_rectangle(10, 10, 30, 30)
+        r2 = c.create_rectangle(50, 50, 70, 70)
+
+        self.assertEqual(c.gettags(r1), ())
+        c.addtag_withtag('spam', r1)
+        self.assertEqual(c.gettags(r1), ('spam',))
+        self.assertEqual(c.find_withtag('spam'), (r1,))
+
+        c.addtag_all('all')
+        self.assertIn('all', c.gettags(r1))
+        self.assertIn('all', c.gettags(r2))
+
+        c.addtag_above('above1', r1)
+        self.assertIn('above1', c.gettags(r2))
+        c.addtag_below('below2', r2)
+        self.assertIn('below2', c.gettags(r1))
+
+        c.addtag_enclosed('enc', 0, 0, 40, 40)
+        self.assertEqual(c.find_withtag('enc'), (r1,))
+        c.addtag_overlapping('ov', 0, 0, 20, 20)
+        self.assertEqual(c.find_withtag('ov'), (r1,))
+        c.addtag_closest('close', 60, 60)
+        self.assertEqual(c.find_withtag('close'), (r2,))
+
+        # gettags of an unmatched tag is empty.
+        self.assertEqual(c.gettags('nonexistent'), ())
+
+        # dtag removes a tag from an item.
+        c.dtag(r1, 'spam')
+        self.assertNotIn('spam', c.gettags(r1))
+
+        self.assertRaises(TypeError, c.addtag_withtag, 'tag')
+        self.assertRaises(TypeError, c.addtag_withtag, 'tag', r1, 'extra')
+        self.assertRaises(TypeError, c.addtag_all)
+        self.assertRaises(TypeError, c.addtag_enclosed, 'tag', 0, 0, 1)
+        self.assertRaises(TypeError, c.addtag_enclosed, 'tag', 0, 0, 1, 2, 3)
+        self.assertRaises(TclError, c.addtag_closest, 'tag', 'spam', 0)
+        self.assertRaises(TclError, c.addtag_enclosed, 'tag', 0, 0, 'spam', 0)
+        self.assertRaises(TclError, c.gettags)  # needs an item
+
+    def test_itemconfigure(self):
+        c = self.create()
+        rect = c.create_rectangle(10, 10, 30, 30)
+        c.itemconfigure(rect, fill='red', width=3)
+        self.assertEqual(str(c.itemcget(rect, 'fill')), 'red')
+        self.assertEqual(float(c.itemcget(rect, 'width')), 3.0)
+
+        # Querying all options returns a dict; a single one returns its spec.
+        cnf = c.itemconfigure(rect)
+        self.assertIsInstance(cnf, dict)
+        self.assertIn('fill', cnf)
+        self.assertEqual(c.itemconfigure(rect, 'fill')[-1], 'red')
+
+        # itemconfig is an alias of itemconfigure.
+        self.assertEqual(c.itemconfig, c.itemconfigure)
+
+        self.assertRaises(TclError, c.itemcget, rect, 'badoption')
+        self.assertRaises(TclError, c.itemconfigure, rect, badoption='x')
+        self.assertRaises(TypeError, c.itemcget, rect)
+        self.assertRaises(TypeError, c.itemcget, rect, 'fill', 'extra')
+
+    def test_tag_raise_lower(self):
+        c = self.create()
+        r1 = c.create_rectangle(10, 10, 30, 30)
+        r2 = c.create_rectangle(50, 50, 70, 70)
+        r3 = c.create_rectangle(90, 90, 110, 110)
+        self.assertEqual(c.find_all(), (r1, r2, r3))
+
+        c.tag_raise(r1)
+        self.assertEqual(c.find_all(), (r2, r3, r1))
+        c.tag_lower(r1)
+        self.assertEqual(c.find_all(), (r1, r2, r3))
+        # Raise above / lower below a specific item.
+        c.tag_raise(r1, r2)
+        self.assertEqual(c.find_all(), (r2, r1, r3))
+        c.tag_lower(r3, r2)
+        self.assertEqual(c.find_all(), (r3, r2, r1))
+
+        # lower/lift are aliases of tag_lower/tag_raise.
+        self.assertEqual(c.lower, c.tag_lower)
+        self.assertEqual(c.lift, c.tag_raise)
+
+        # raise/lower need at least an item; an unmatched tag is not an error.
+        self.assertRaises(TclError, c.tag_raise)
+        self.assertRaises(TclError, c.tag_lower)
+        self.assertIsNone(c.tag_raise('nonexistent'))
+
+    def test_text_item(self):
+        c = self.create()
+        item = c.create_text(10, 10, text='Hello')
+        self.assertEqual(c.index(item, 'end'), 5)
+        self.assertIsInstance(c.index(item, 'end'), int)
+
+        c.insert(item, 'end', ' world')
+        self.assertEqual(c.itemcget(item, 'text'), 'Hello world')
+        self.assertEqual(c.index(item, 'end'), 11)
+        c.insert(item, 0, '>> ')
+        self.assertEqual(c.itemcget(item, 'text'), '>> Hello world')
+
+        c.dchars(item, 0, 2)
+        self.assertEqual(c.itemcget(item, 'text'), 'Hello world')
+        c.icursor(item, 3)
+
+        # index requires an indexable (text) item and a valid index.
+        self.assertRaises(TclError, c.index, item, 'badspec')
+        self.assertRaises(TclError, c.index, item)  # missing index
+        self.assertRaises(TclError, c.dchars, item, 'badspec', 'end')
+        rect = c.create_rectangle(10, 10, 30, 30)
+        self.assertRaises(TclError, c.index, rect, 'end')
+
+    def test_select(self):
+        c = self.create()
+        item = c.create_text(10, 10, text='Hello world')
+        self.assertIsNone(c.select_item())
+
+        c.select_from(item, 0)
+        c.select_to(item, 4)
+        self.assertEqual(int(c.select_item()), item)
+        c.select_adjust(item, 6)
+
+        c.select_clear()
+        self.assertIsNone(c.select_item())
+        self.assertRaises(TypeError, c.select_from, item)
+        self.assertRaises(TypeError, c.select_from, item, 0, 'extra')
+        # A bad index reaches Tcl; selection applies only to text items.
+        self.assertRaises(TclError, c.select_from, item, 'badspec')
+        rect = c.create_rectangle(10, 10, 30, 30)
+        self.assertRaises(TclError, c.select_from, rect, 0)
+
+    def test_focus(self):
+        c = self.create()
+        item = c.create_text(10, 10, text='Hello')
+        # Only text items can take the focus.
+        c.focus(item)
+        self.assertEqual(int(c.focus()), item)
+        c.focus('')
+        self.assertIn(c.focus(), ('', None))
+
+    def test_scan(self):
+        c = self.create()
+        c.create_rectangle(10, 10, 300, 300)
+        c.scan_mark(0, 0)
+        c.scan_dragto(5, 5)  # default gain=10
+        c.scan_dragto(5, 5, 1)
+        self.assertRaises(TypeError, c.scan_mark)
+        self.assertRaises(TypeError, c.scan_mark, 0, 0, 0)
+        self.assertRaises(TclError, c.scan_mark, 'spam', 0)
+
+    def test_postscript(self):
+        c = self.create()
+        c.create_rectangle(10, 10, 30, 30, fill='black')
+        ps = c.postscript()
+        self.assertIsInstance(ps, str)
+        self.assertStartsWith(ps, '%!PS-Adobe')
+        self.assertRaises(TclError, c.postscript, badoption='spam')
+
+    def assertCommandExist(self, widget, funcid):
+        self.assertEqual(
+            widget.tk.splitlist(widget.tk.call('info', 'commands', funcid)),
+            (funcid,))
+
+    def assertCommandNotExist(self, widget, funcid):
+        self.assertEqual(
+            widget.tk.splitlist(widget.tk.call('info', 'commands', funcid)),
+            ())
+
+    def test_tag_bind(self):
+        c = self.create()
+        c.pack()
+        item = c.create_rectangle(20, 20, 100, 100, fill='red')
+        self.assertEqual(c.tag_bind(item), ())
+        self.assertEqual(c.tag_bind(item, '<Button-1>'), '')
+
+        events = []
+        def test1(e): events.append('a')
+        def test2(e): events.append('b')
+
+        funcid = c.tag_bind(item, '<Button-1>', test1)
+        self.assertEqual(c.tag_bind(item), ('<Button-1>',))
+        script = c.tag_bind(item, '<Button-1>')
+        self.assertIn(funcid, script)
+        self.assertCommandExist(c, funcid)
+
+        funcid2 = c.tag_bind(item, '<Button-1>', test2, add=True)
+        script = c.tag_bind(item, '<Button-1>')
+        self.assertIn(funcid, script)
+        self.assertIn(funcid2, script)
+        self.assertCommandExist(c, funcid)
+        self.assertCommandExist(c, funcid2)
+
+        c.wait_visibility()
+        c.focus_force()
+        c.update()
+        c.event_generate('<Button-1>', x=50, y=50)
+        c.update()
+        self.assertEqual(events, ['a', 'b'])
+
+        # Binding to a tag applies to all items carrying it.
+        c.addtag_withtag('spam', item)
+        events.clear()
+        c.tag_bind('spam', '<Button-3>', test1)
+        c.event_generate('<Button-3>', x=50, y=50)
+        c.update()
+        self.assertEqual(events, ['a'])
+
+    def test_tag_unbind(self):
+        c = self.create()
+        c.pack()
+        item = c.create_rectangle(20, 20, 100, 100, fill='red')
+
+        events = []
+        def test1(e): events.append('a')
+        def test2(e): events.append('b')
+
+        funcid = c.tag_bind(item, '<Button-1>', test1)
+        funcid2 = c.tag_bind(item, '<Button-1>', test2, add=True)
+        c.wait_visibility()
+        c.focus_force()
+        c.update()
+        c.event_generate('<Button-1>', x=50, y=50)
+        c.update()
+        self.assertEqual(events, ['a', 'b'])
+
+        # Removing one function leaves the other in place.
+        c.tag_unbind(item, '<Button-1>', funcid)
+        script = c.tag_bind(item, '<Button-1>')
+        self.assertNotIn(funcid, script)
+        self.assertIn(funcid2, script)
+        self.assertCommandNotExist(c, funcid)
+        self.assertCommandExist(c, funcid2)
+        events.clear()
+        c.event_generate('<Button-1>', x=50, y=50)
+        c.update()
+        self.assertEqual(events, ['b'])
+
+        # Without a funcid all bindings for the sequence are removed.
+        c.tag_unbind(item, '<Button-1>')
+        self.assertEqual(c.tag_bind(item, '<Button-1>'), '')
+        self.assertEqual(c.tag_bind(item), ())
+        events.clear()
+        c.event_generate('<Button-1>', x=50, y=50)
+        c.update()
+        self.assertEqual(events, [])
+
+        self.assertRaises(TypeError, c.tag_unbind, item)
+
 
 @add_configure_tests(IntegerSizeTests, StandardOptionsTests)
 class ListboxTest(AbstractWidgetTest, unittest.TestCase):

From b4cfb992ed3a28b8cd626f70e3550ac8dbec1758 Mon Sep 17 00:00:00 2001
From: Serhiy Storchaka <storchaka@gmail.com>
Date: Fri, 19 Jun 2026 12:35:36 +0300
Subject: [PATCH 09/10] gh-151693: Add curses tests for panels, textpad, and
 window behavior (GH-151694)

Add curses tests for panels, textpad, and window behavior

Extend test_curses with behavior-verifying tests that go beyond the
existing smoke tests:

* curses.panel stacking: new_panel/top/bottom/above/below ordering,
  hide/show/hidden, move, replace and userptr round-trip.
* Real-window curses.textpad.Textbox: gather(), edit(), stripspaces,
  insert mode and the Emacs-like editing commands (previously only
  exercised through a MagicMock).
* Window output: addstr cursor advance and addnstr truncation,
  insstr/insnstr shifting without cursor movement, and pad behavior
  (instr, subpad cell sharing, the required 6-argument refresh()).
* Error handling: out-of-range coordinates raising curses.error and
  bad character/string argument types.

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 Lib/test/test_curses.py | 278 +++++++++++++++++++++++++++++++++++++++-
 1 file changed, 277 insertions(+), 1 deletion(-)

diff --git a/Lib/test/test_curses.py b/Lib/test/test_curses.py
index d5ca7f2ca1ae65..647959146a792c 100644
--- a/Lib/test/test_curses.py
+++ b/Lib/test/test_curses.py
@@ -334,6 +334,63 @@ def test_output_string_embedded_null_chars(self):
                 self.assertRaises(ValueError, stdscr.insstr, arg)
                 self.assertRaises(ValueError, stdscr.insnstr, arg, 1)
 
+    def test_add_string_behavior(self):
+        # addstr() advances the cursor past the written text; addnstr()
+        # writes at most n characters.
+        win = curses.newwin(1, 10, 0, 0)
+        win.addstr(0, 0, 'abc')
+        self.assertEqual(win.getyx(), (0, 3))
+        win.erase()
+        win.addnstr(0, 0, 'abcdef', 3)
+        self.assertEqual(win.instr(0, 0), b'abc       ')
+
+    def test_insert_string_behavior(self):
+        # insstr()/insnstr() insert at the cursor, shift the rest of the
+        # line right (losing characters off the edge), and leave the cursor
+        # where it was.
+        win = curses.newwin(1, 10, 0, 0)
+        win.addstr(0, 0, 'abcde')
+        win.move(0, 1)
+        win.insstr('XY')
+        self.assertEqual(win.getyx(), (0, 1))   # cursor did not advance
+        self.assertEqual(win.instr(0, 0), b'aXYbcde   ')
+
+        win.erase()
+        win.addstr(0, 0, 'ZZZZZ')
+        win.move(0, 0)
+        win.insnstr('abcdef', 3)           # at most 3 characters
+        self.assertEqual(win.instr(0, 0), b'abcZZZZZ  ')
+
+    def test_insch(self):
+        # insch() inserts a single character at the cursor (or at y, x),
+        # shifting the rest of the line right.
+        win = curses.newwin(2, 10, 0, 0)
+        win.addstr(0, 0, 'abc')
+        win.move(0, 1)
+        win.insch(ord('X'))
+        self.assertEqual(win.instr(0, 0), b'aXbc      ')
+        win.insch(1, 0, 'Y', curses.A_BOLD)
+        self.assertEqual(win.inch(1, 0), b'Y'[0] | curses.A_BOLD)
+
+    def test_pad(self):
+        pad = curses.newpad(10, 20)
+        pad.addstr(0, 0, 'PADTEXT')
+        self.assertEqual(pad.instr(0, 0, 7), b'PADTEXT')
+
+        # subpad() shares the parent pad's character cells.
+        sub = pad.subpad(3, 5, 0, 0)
+        self.assertEqual(sub.getmaxyx(), (3, 5))
+        self.assertEqual(sub.instr(0, 0, 5), b'PADTE')
+
+        # A pad is refreshed onto an explicit screen rectangle; the
+        # 6-argument form is required (and rejected for ordinary windows).
+        pad.refresh(0, 0, 0, 0, 4, 10)
+        pad.noutrefresh(0, 0, 0, 0, 4, 10)
+        curses.doupdate()
+        self.assertRaises(TypeError, pad.refresh)
+        win = curses.newwin(5, 5, 0, 0)
+        self.assertRaises(TypeError, win.refresh, 0, 0, 0, 0, 4, 4)
+
     def test_read_from_window(self):
         stdscr = self.stdscr
         stdscr.addstr(0, 1, 'ABCD', curses.A_BOLD)
@@ -350,6 +407,26 @@ def test_read_from_window(self):
         self.assertRaises(ValueError, stdscr.instr, -2)
         self.assertRaises(ValueError, stdscr.instr, 0, 2, -2)
 
+    def test_coordinate_errors(self):
+        # Addressing a cell outside the window raises curses.error.
+        win = curses.newwin(5, 10, 0, 0)
+        self.assertRaises(curses.error, win.move, 100, 100)
+        self.assertRaises(curses.error, win.move, -1, -1)
+        self.assertRaises(curses.error, win.addch, 100, 100, ord('x'))
+        self.assertRaises(curses.error, win.inch, 100, 100)
+        self.assertRaises(curses.error, win.chgat, 100, 0, curses.A_BOLD)
+
+    def test_argument_errors(self):
+        win = curses.newwin(5, 10, 0, 0)
+        # A character argument must be an int, a byte or a one-element string.
+        self.assertRaises(TypeError, win.addch, [])
+        self.assertRaises(OverflowError, win.addch, 2**64)
+        # A string method rejects a non-string, non-bytes argument.
+        self.assertRaises(TypeError, win.addstr, 5)
+        self.assertRaises(TypeError, win.addstr)
+        # Wrong number of positional arguments.
+        self.assertRaises(TypeError, win.instr, 0, 0, 0, 0)
+
     def test_getch(self):
         win = curses.newwin(5, 12, 5, 2)
 
@@ -819,6 +896,10 @@ def test_prog_mode(self):
             self.skipTest('requires terminal')
         curses.def_prog_mode()
         curses.reset_prog_mode()
+        # def_shell_mode()/reset_shell_mode() are intentionally not exercised
+        # here: they capture and restore curses' "shell mode" terminal state,
+        # which is only meaningful before initscr().  Calling them mid-suite
+        # corrupts the modes that endwin() restores and breaks later tests.
 
     def test_beep(self):
         if (curses.tigetstr("bel") is not None
@@ -1031,7 +1112,8 @@ def test_keyname(self):
 
     @requires_curses_func('has_key')
     def test_has_key(self):
-        curses.has_key(13)
+        self.assertIsInstance(curses.has_key(13), bool)
+        self.assertIsInstance(curses.has_key(curses.KEY_LEFT), bool)
 
     @requires_curses_func('getmouse')
     def test_getmouse(self):
@@ -1083,6 +1165,200 @@ def test_disallow_instantiation(self):
         panel = curses.panel.new_panel(w)
         check_disallow_instantiation(self, type(panel))
 
+    @requires_curses_func('panel')
+    def test_panel_stack(self):
+        panel = curses.panel
+        # new_panel() puts the panel on top of the stack, so the three
+        # panels end up ordered bottom -> top as p1, p2, p3.
+        p1 = panel.new_panel(curses.newwin(3, 6, 0, 0))
+        p2 = panel.new_panel(curses.newwin(3, 6, 1, 1))
+        p3 = panel.new_panel(curses.newwin(3, 6, 2, 2))
+        self.addCleanup(self._delete_panels, p1, p2, p3)
+
+        # The most recently created panel is on top.
+        self.assertIs(panel.top_panel(), p3)
+        # window() returns the wrapped window.
+        self.assertEqual(p2.window().getbegyx(), (1, 1))
+
+        # above()/below() walk the stack one step at a time.
+        self.assertIs(p1.above(), p2)
+        self.assertIs(p2.above(), p3)
+        self.assertIsNone(p3.above())     # nothing above the top panel
+        self.assertIs(p3.below(), p2)
+        self.assertIs(p2.below(), p1)
+
+        # top() raises a panel to the top, bottom() lowers it to the bottom.
+        p1.top()
+        self.assertIs(panel.top_panel(), p1)
+        self.assertIsNone(p1.above())
+        p1.bottom()
+        self.assertIs(panel.bottom_panel(), p1)
+        self.assertIsNone(p1.below())
+
+        # update_panels() refreshes the virtual screen from the stack.
+        panel.update_panels()
+
+    @requires_curses_func('panel')
+    def test_panel_hide_show(self):
+        p = curses.panel.new_panel(curses.newwin(3, 6, 0, 0))
+        self.addCleanup(self._delete_panels, p)
+        self.assertIs(p.hidden(), False)
+        p.hide()
+        self.assertIs(p.hidden(), True)
+        p.show()
+        self.assertIs(p.hidden(), False)
+
+    @requires_curses_func('panel')
+    def test_panel_move(self):
+        win = curses.newwin(3, 6, 1, 2)
+        p = curses.panel.new_panel(win)
+        self.addCleanup(self._delete_panels, p)
+        self.assertEqual(win.getbegyx(), (1, 2))
+        p.move(4, 5)
+        self.assertEqual(win.getbegyx(), (4, 5))
+
+    @requires_curses_func('panel')
+    def test_panel_replace(self):
+        win1 = curses.newwin(3, 6, 0, 0)
+        win2 = curses.newwin(4, 8, 1, 1)
+        p = curses.panel.new_panel(win1)
+        self.addCleanup(self._delete_panels, p)
+        self.assertIs(p.window(), win1)
+        p.replace(win2)
+        self.assertIs(p.window(), win2)
+
+    @requires_curses_func('panel')
+    def test_panel_userptr(self):
+        p = curses.panel.new_panel(curses.newwin(3, 6, 0, 0))
+        self.addCleanup(self._delete_panels, p)
+        obj = ['userptr']
+        p.set_userptr(obj)
+        self.assertIs(p.userptr(), obj)
+
+    def _delete_panels(self, *panels):
+        # Drop the panels from the global stack so they do not leak into
+        # later tests that inspect top_panel()/bottom_panel().
+        for p in panels:
+            try:
+                p.bottom()
+            except curses.panel.error:
+                pass
+        del panels
+        gc_collect()
+
+    def _make_textbox(self, nlines, ncols, *, insert_mode=False, stripspaces=1):
+        win = curses.newwin(nlines, ncols, 0, 0)
+        box = curses.textpad.Textbox(win, insert_mode=insert_mode)
+        box.stripspaces = stripspaces
+        return box, win
+
+    def _type(self, box, text):
+        for ch in text:
+            box.do_command(ch if isinstance(ch, int) else ord(ch))
+
+    def test_textbox_gather(self):
+        # Typed text is read back by gather().  With stripspaces on (the
+        # default) gather() keeps a single trailing blank on a line and
+        # drops trailing empty lines.
+        box, win = self._make_textbox(3, 10)
+        self._type(box, 'Hello')
+        self.assertEqual(box.gather(), 'Hello \n')
+
+    def test_textbox_gather_multiline(self):
+        box, win = self._make_textbox(3, 10)
+        self._type(box, 'ab')
+        box.do_command(curses.ascii.NL)    # ^j -> start of next line
+        self._type(box, 'cd')
+        self.assertEqual(box.gather(), 'ab \ncd \n')
+
+    def test_textbox_stripspaces(self):
+        box, win = self._make_textbox(1, 8, stripspaces=1)
+        self._type(box, 'hi')
+        self.assertEqual(box.gather(), 'hi ')
+
+        box, win = self._make_textbox(1, 8, stripspaces=0)
+        self._type(box, 'hi')
+        self.assertEqual(box.gather(), 'hi      ')
+
+    def test_textbox_insert_mode(self):
+        # In insert mode a typed character shifts the rest of the line right.
+        box, win = self._make_textbox(1, 10, insert_mode=True)
+        self._type(box, 'aXc')
+        win.move(0, 1)
+        self._type(box, 'b')
+        self.assertEqual(box.gather(), 'abXc ')
+
+    def test_textbox_movement(self):
+        box, win = self._make_textbox(3, 10)
+        self._type(box, 'abc')
+        box.do_command(curses.ascii.SOH)   # ^a -> left edge
+        self.assertEqual(win.getyx(), (0, 0))
+        box.do_command(curses.ascii.ENQ)   # ^e -> end of line
+        self.assertEqual(win.getyx(), (0, 3))
+
+    def test_textbox_kill_to_eol(self):
+        box, win = self._make_textbox(1, 10)
+        self._type(box, 'abcdef')
+        win.move(0, 3)
+        box.do_command(curses.ascii.VT)    # ^k -> clear to end of line
+        self.assertEqual(box.gather(), 'abc ')
+
+    def test_textbox_backspace(self):
+        box, win = self._make_textbox(1, 10)
+        self._type(box, 'abc')
+        box.do_command(curses.ascii.BS)    # ^h -> delete backward
+        self.assertEqual(box.gather(), 'ab ')
+
+    def test_textbox_edit(self):
+        # edit() reads characters until Ctrl-G and returns the contents.
+        box, win = self._make_textbox(1, 10)
+        for ch in reversed('Hi' + chr(curses.ascii.BEL)):
+            curses.ungetch(ch)
+        self.assertEqual(box.edit(), 'Hi ')
+
+    def test_textbox_edit_validate(self):
+        # The validate hook can rewrite an incoming keystroke.
+        box, win = self._make_textbox(1, 10)
+        for ch in reversed('abc' + chr(curses.ascii.BEL)):
+            curses.ungetch(ch)
+        box.edit(lambda ch: ord('X') if ch == ord('b') else ch)
+        self.assertEqual(box.gather(), 'aXc ')
+
+    def test_textpad_rectangle(self):
+        # rectangle() draws a box with ACS line/corner characters.
+        win = curses.newwin(6, 12, 0, 0)
+        curses.textpad.rectangle(win, 0, 0, 4, 8)
+        chartext = curses.A_CHARTEXT
+        self.assertEqual(win.inch(0, 0) & chartext,
+                         curses.ACS_ULCORNER & chartext)
+        self.assertEqual(win.inch(0, 8) & chartext,
+                         curses.ACS_URCORNER & chartext)
+        self.assertEqual(win.inch(4, 0) & chartext,
+                         curses.ACS_LLCORNER & chartext)
+        self.assertEqual(win.inch(4, 8) & chartext,
+                         curses.ACS_LRCORNER & chartext)
+        self.assertEqual(win.inch(0, 1) & chartext,
+                         curses.ACS_HLINE & chartext)
+        self.assertEqual(win.inch(1, 0) & chartext,
+                         curses.ACS_VLINE & chartext)
+
+    def test_wrapper(self):
+        # wrapper() sets up curses, passes the screen to the callable along
+        # with extra arguments, returns its result and restores the terminal.
+        if not self.isatty:
+            self.skipTest('requires terminal')
+
+        def body(stdscr, a, b):
+            self.assertIsInstance(stdscr, type(self.stdscr))
+            self.assertIs(curses.isendwin(), False)
+            return a + b
+
+        self.assertEqual(curses.wrapper(body, 2, 3), 5)
+        self.assertIs(curses.isendwin(), True)
+        # wrapper() left the screen ended; revive it so the per-test
+        # endwin() cleanup does not fail with ERR.
+        curses.doupdate()
+
     @requires_curses_func('is_term_resized')
     def test_is_term_resized(self):
         lines, cols = curses.LINES, curses.COLS

From 93b9e7666f4337e3cacfed6993568e4bec575e9b Mon Sep 17 00:00:00 2001
From: Serhiy Storchaka <storchaka@gmail.com>
Date: Fri, 19 Jun 2026 13:23:38 +0300
Subject: [PATCH 10/10] gh-151678: Add tests for the remaining tkinter widgets
 (GH-151687)

Cover previously-untested methods of several widgets:

* Button, Checkbutton and Radiobutton: invoke, flash and toggle;
* Entry: delete, icursor and the select_* aliases;
* Spinbox: invoke, identify and scan;
* Scale and Scrollbar: identify, and Scrollbar fraction and delta;
* PanedWindow: panes, remove/forget, sash and proxy positioning,
  identify, and adding panes with configuration options.

Also test that invoke does nothing for a disabled button and the
errors raised for invalid indices, coordinates, option names and values.

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 Lib/test/test_tkinter/test_widgets.py | 250 ++++++++++++++++++++++++++
 1 file changed, 250 insertions(+)

diff --git a/Lib/test/test_tkinter/test_widgets.py b/Lib/test/test_tkinter/test_widgets.py
index ea53382bfa2ab9..8ce71bc37ca2e4 100644
--- a/Lib/test/test_tkinter/test_widgets.py
+++ b/Lib/test/test_tkinter/test_widgets.py
@@ -208,6 +208,23 @@ def test_configure_default(self):
         widget = self.create()
         self.checkEnumParam(widget, 'default', 'active', 'disabled', 'normal')
 
+    def test_invoke(self):
+        success = []
+        widget = self.create(command=lambda: success.append(1))
+        widget.pack()
+        widget.invoke()
+        self.assertEqual(success, [1])
+        # invoke does nothing for a disabled button.
+        widget.configure(state='disabled')
+        widget.invoke()
+        self.assertEqual(success, [1])
+
+    def test_flash(self):
+        widget = self.create()
+        widget.pack()
+        widget.update_idletasks()
+        widget.flash()  # No exception.
+
 
 @add_configure_tests(StandardOptionsTests)
 class CheckbuttonTest(AbstractLabelTest, unittest.TestCase):
@@ -263,6 +280,39 @@ def test_same_name(self):
         b2.deselect()
         self.assertEqual(v.get(), 0)
 
+    def test_invoke(self):
+        success = []
+        v = tkinter.IntVar(self.root)
+        widget = self.create(variable=v, onvalue=1, offvalue=0,
+                             command=lambda: success.append(v.get()))
+        widget.pack()
+        widget.invoke()
+        self.assertEqual(v.get(), 1)
+        self.assertEqual(success, [1])
+        widget.invoke()
+        self.assertEqual(v.get(), 0)
+        self.assertEqual(success, [1, 0])
+        # A disabled checkbutton is not toggled and its command is not called.
+        widget.configure(state='disabled')
+        widget.invoke()
+        self.assertEqual(v.get(), 0)
+        self.assertEqual(success, [1, 0])
+
+    def test_toggle(self):
+        v = tkinter.IntVar(self.root)
+        widget = self.create(variable=v, onvalue=1, offvalue=0)
+        self.assertEqual(v.get(), 0)
+        widget.toggle()
+        self.assertEqual(v.get(), 1)
+        widget.toggle()
+        self.assertEqual(v.get(), 0)
+
+    def test_flash(self):
+        widget = self.create()
+        widget.pack()
+        widget.update_idletasks()
+        widget.flash()  # No exception.
+
 @add_configure_tests(StandardOptionsTests)
 class RadiobuttonTest(AbstractLabelTest, unittest.TestCase):
     OPTIONS = (
@@ -285,6 +335,28 @@ def test_configure_value(self):
         widget = self.create()
         self.checkParams(widget, 'value', 1, 2.3, '', 'any string')
 
+    def test_invoke(self):
+        success = []
+        v = tkinter.StringVar(self.root)
+        widget = self.create(variable=v, value='on',
+                             command=lambda: success.append(v.get()))
+        widget.pack()
+        widget.invoke()
+        self.assertEqual(v.get(), 'on')
+        self.assertEqual(success, ['on'])
+        # invoke does nothing for a disabled radiobutton.
+        v.set('')
+        widget.configure(state='disabled')
+        widget.invoke()
+        self.assertEqual(v.get(), '')
+        self.assertEqual(success, ['on'])
+
+    def test_flash(self):
+        widget = self.create()
+        widget.pack()
+        widget.update_idletasks()
+        widget.flash()  # No exception.
+
 
 @add_configure_tests(StandardOptionsTests)
 class MenubuttonTest(AbstractLabelTest, unittest.TestCase):
@@ -476,6 +548,47 @@ def test_selection_methods(self):
         self.assertEqual(widget.selection_get(), '12345')
         widget.selection_adjust(0)
 
+    def test_delete(self):
+        widget = self.create()
+        widget.insert(0, 'abcdef')
+        widget.delete(1, 3)
+        self.assertEqual(widget.get(), 'adef')
+        widget.delete(1)
+        self.assertEqual(widget.get(), 'aef')
+        widget.delete(0, 'end')
+        self.assertEqual(widget.get(), '')
+        self.assertRaisesRegex(TclError, r'bad (entry|spinbox) index "xyz"',
+                               widget.delete, 'xyz')
+        self.assertRaises(TypeError, widget.delete)
+
+    def test_icursor(self):
+        widget = self.create()
+        widget.insert(0, 'abcdef')
+        widget.icursor(3)
+        widget.insert('insert', 'XYZ')
+        self.assertEqual(widget.get(), 'abcXYZdef')
+        self.assertRaisesRegex(TclError, r'bad (entry|spinbox) index "xyz"',
+                               widget.icursor, 'xyz')
+        self.assertRaises(TypeError, widget.icursor)
+
+    def test_select_aliases(self):
+        # The select_* methods are aliases of the selection_* methods.
+        widget = self.create()
+        widget.insert(0, '12345')
+        self.assertFalse(widget.select_present())
+        widget.select_range(0, 'end')
+        self.assertTrue(widget.select_present())
+        self.assertEqual(widget.selection_get(), '12345')
+        widget.select_from(1)
+        widget.select_to(3)
+        self.assertEqual(widget.selection_get(), '23')
+        widget.select_adjust(4)
+        self.assertEqual(widget.selection_get(), '234')
+        widget.select_clear()
+        self.assertFalse(widget.select_present())
+        self.assertRaisesRegex(TclError, 'bad entry index "xyz"',
+                               widget.select_range, 'xyz', 'end')
+
 
 @add_configure_tests(StandardOptionsTests)
 class SpinboxTest(EntryTest, unittest.TestCase):
@@ -624,6 +737,38 @@ def test_selection_element(self):
         widget.selection_element("buttondown")
         self.assertEqual(widget.selection_element(), "buttondown")
 
+    # Spinbox has no select_* aliases, unlike Entry.
+    test_select_aliases = None
+
+    def test_invoke(self):
+        widget = self.create(from_=0, to=10)
+        widget.delete(0, 'end')
+        widget.insert(0, '5')
+        widget.invoke('buttonup')
+        self.assertEqual(widget.get(), '6')
+        widget.invoke('buttondown')
+        self.assertEqual(widget.get(), '5')
+        self.assertRaisesRegex(TclError, 'bad element "spam"',
+                               widget.invoke, 'spam')
+
+    def test_identify(self):
+        widget = self.create()
+        widget.pack()
+        widget.update_idletasks()
+        # The empty string is returned for a point over no element.
+        self.assertIn(widget.identify(5, 5),
+                      ('entry', 'buttonup', 'buttondown', 'none', ''))
+        self.assertRaises(TclError, widget.identify, 'a', 'b')
+
+    def test_scan(self):
+        widget = self.create()
+        widget.insert(0, 'a' * 100)
+        widget.pack()
+        widget.update_idletasks()
+        self.assertEqual(widget.scan_mark(10), ())
+        self.assertEqual(widget.scan_dragto(0), ())
+        self.assertRaises(TypeError, widget.scan_mark)
+
 
 @add_configure_tests(StandardOptionsTests)
 class TextTest(AbstractWidgetTest, unittest.TestCase):
@@ -1850,6 +1995,14 @@ def test_configure_to(self):
         self.checkFloatParam(widget, 'to', 300, 14.9, 15.1, -10,
                              conv=float_round)
 
+    def test_identify(self):
+        widget = self.create()
+        widget.pack()
+        widget.update_idletasks()
+        self.assertIn(widget.identify(5, 5),
+                      ('slider', 'trough1', 'trough2', ''))
+        self.assertRaises(TclError, widget.identify, 'a', 'b')
+
 
 @add_configure_tests(PixelSizeTests, StandardOptionsTests)
 class ScrollbarTest(AbstractWidgetTest, unittest.TestCase):
@@ -1903,6 +2056,34 @@ def test_set(self):
         self.assertRaises(TypeError, sb.set, 0.6)
         self.assertRaises(TypeError, sb.set, 0.6, 0.7, 0.8)
 
+    def test_fraction(self):
+        sb = self.create()
+        sb.pack(fill='y', expand=True)
+        sb.update_idletasks()
+        self.assertIsInstance(sb.fraction(0, 0), float)
+        f = sb.fraction(0, 1000)
+        self.assertIsInstance(f, float)
+        self.assertGreaterEqual(f, 0.0)
+        self.assertLessEqual(f, 1.0)
+        self.assertRaises(TclError, sb.fraction, 'a', 'b')
+        self.assertRaises(TypeError, sb.fraction, 0)
+
+    def test_delta(self):
+        sb = self.create()
+        sb.pack(fill='y', expand=True)
+        sb.update_idletasks()
+        self.assertIsInstance(sb.delta(0, 10), float)
+        self.assertRaises(TclError, sb.delta, 'a', 'b')
+        self.assertRaises(TypeError, sb.delta, 0)
+
+    def test_identify(self):
+        sb = self.create()
+        sb.pack(fill='y', expand=True)
+        sb.update_idletasks()
+        self.assertIn(sb.identify(5, 5),
+                      ('arrow1', 'arrow2', 'slider', 'trough1', 'trough2', ''))
+        self.assertRaises(TclError, sb.identify, 'a', 'b')
+
 
 @add_configure_tests(PixelSizeTests, StandardOptionsTests)
 class PanedWindowTest(AbstractWidgetTest, unittest.TestCase):
@@ -1980,6 +2161,75 @@ def create2(self):
         p.add(c)
         return p, b, c
 
+    def test_panes(self):
+        p, b, c = self.create2()
+        self.assertEqual([str(x) for x in p.panes()], [str(b), str(c)])
+
+    def test_remove(self):
+        p, b, c = self.create2()
+        p.remove(b)
+        self.assertEqual([str(x) for x in p.panes()], [str(c)])
+        p.forget(c)  # forget is an alias of remove.
+        self.assertEqual(p.panes(), ())
+
+    def test_sash(self):
+        p, b, c = self.create2()
+        p.configure(width=200, height=50)
+        p.pack()
+        p.update()
+        x, y = p.sash_coord(0)
+        self.assertIsInstance(x, int)
+        self.assertIsInstance(y, int)
+        p.sash_place(0, 120, 0)
+        p.update()
+        self.assertEqual(p.sash_coord(0)[0], 120)
+        p.sash_mark(0)  # No exception.
+        self.assertRaises(TclError, p.sash_coord, 5)
+
+    def test_proxy(self):
+        p, b, c = self.create2()
+        p.configure(width=200, height=50)
+        p.pack()
+        p.update()
+        p.proxy_place(100, 10)
+        p.update()
+        self.assertEqual(p.proxy_coord()[0], 100)
+        p.proxy_forget()
+        p.update()
+
+    def test_identify(self):
+        p, b, c = self.create2()
+        p.configure(width=200, height=50)
+        p.pack()
+        p.update()
+        x, y = p.sash_coord(0)
+        # A point over the sash reports the sash.
+        self.assertIn('sash', p.identify(x + 1, y + 5))
+        # A point over a pane reports nothing.
+        self.assertFalse(p.identify(2, 2))
+        self.assertRaises(TclError, p.identify, 'a', 'b')
+
+    def test_add_options(self):
+        p = self.create()
+        b = tkinter.Button(p)
+        p.add(b, minsize=40, padx=3, sticky='ns')
+        self.assertEqual(p.panecget(b, 'minsize'),
+                         40 if self.wantobjects else '40')
+        self.assertEqual(p.panecget(b, 'padx'),
+                         3 if self.wantobjects else '3')
+        self.assertEqual(p.panecget(b, 'sticky'), 'ns')
+        self.assertRaisesRegex(TclError, 'unknown option "-spam"',
+                               p.add, tkinter.Button(p), spam='x')
+        self.assertRaisesRegex(TclError, 'bad window path name "spam"',
+                               p.add, 'spam')
+
+    def test_paneconfigure_errors(self):
+        p, b, c = self.create2()
+        self.assertRaisesRegex(TclError, 'unknown option "-spam"',
+                               p.paneconfigure, b, spam='x')
+        self.assertRaises(TclError, p.panecget, b, 'spam')
+        self.assertRaises(TclError, p.paneconfigure, 'spam')
+
     def test_paneconfigure(self):
         p, b, c = self.create2()
         self.assertRaises(TypeError, p.paneconfigure)