gh-55646: Fix the invalid key binding test on macOS

On macOS an invalid binding such as <Alt-Key-up> is not parsed into a
MultiCall triplet, so it falls back to Tk's event_add(), which was left
unguarded and still crashed.  Guard the fallback too, and test both the
parsed (bind()) and unparsed (event_add()) paths on every platform.

Author: serhiy-storchaka

Lib/idlelib/idle_test/test_multicall.py

@@ -1,11 +1,9 @@
 "Test multicall, coverage 33%."
 
 from idlelib import multicall
-import io
 import unittest
-from test.support import requires
+from test.support import requires, captured_stderr
 from tkinter import Tk, Text
-from unittest import mock
 
 
 class MultiCallTest(unittest.TestCase):
@@ -45,12 +43,29 @@ def test_yview(self):
         mctext = self.mc(self.root)
         self.assertIs(mctext.yview.__func__, Text.yview)
 
-    def test_invalid_binding(self):
-        # gh-55646: an invalid key binding must not crash IDLE.
+    def test_valid_binding(self):
+        # A valid key binding must bind without a warning (cf. gh-55646).
         mctext = self.mc(self.root)
-        # 'up' is not a keysym; it should be 'Up'.
-        mctext.event_add('<<test-bad>>', '<Alt-Key-up>')
-        with mock.patch('sys.stderr', new_callable=io.StringIO) as stderr:
+        with captured_stderr() as stderr:
+            mctext.event_add('<<test-good>>', '<Control-Key-Up>')
+            mctext.bind('<<test-good>>', lambda e: None)
+        self.assertEqual(stderr.getvalue(), '')
+
+    def test_invalid_triplet_binding(self):
+        # gh-55646: '<Control-Key-up>' parses into a triplet on every platform,
+        # so Tk rejects it in bind().
+        mctext = self.mc(self.root)
+        with captured_stderr() as stderr:
+            mctext.event_add('<<test-bad>>', '<Control-Key-up>')  # Must not raise.
+            mctext.bind('<<test-bad>>', lambda e: None)  # Must not raise.
+        self.assertIn('invalid key binding', stderr.getvalue())
+
+    def test_invalid_nontriplet_binding(self):
+        # gh-55646: '<Foo-Key-Up>' has no valid modifier, so MultiCall does not
+        # parse it and falls back to Tk's event_add, which rejects it.
+        mctext = self.mc(self.root)
+        with captured_stderr() as stderr:
+            mctext.event_add('<<test-bad>>', '<Foo-Key-Up>')  # Must not raise.
             mctext.bind('<<test-bad>>', lambda e: None)  # Must not raise.
         self.assertIn('invalid key binding', stderr.getvalue())
 

Lib/idlelib/multicall.py

@@ -311,11 +311,10 @@ def _triplet_to_sequence(triplet):
         return '<'+_state_names[triplet[0]]+_types[triplet[1]][0]+'>'
 
 
-def _warn_bad_binding(triplet, err):
-    # Ignore a key binding invalidated by a typo in the user's config
-    # instead of crashing IDLE (gh-55646).
-    print(f'Warning: ignoring invalid key binding '
-          f'{_triplet_to_sequence(triplet)!r}: {err}', file=sys.stderr)
+def _warn_bad_binding(sequence, err):
+    # gh-55646: warn instead of crashing on an invalid key binding.
+    print(f'Warning: ignoring invalid key binding {sequence!r}: {err}',
+          file=sys.stderr)
 
 
 _multicall_dict = {}
@@ -356,7 +355,8 @@ def bind(self, sequence=None, func=None, add=None):
                             try:
                                 self.__binders[triplet[1]].bind(triplet, func)
                             except tkinter.TclError as err:
-                                _warn_bad_binding(triplet, err)
+                                _warn_bad_binding(_triplet_to_sequence(triplet),
+                                                  err)
                                 bad.append(triplet)
                         for triplet in bad:  # Drop the invalid sequences.
                             ei[1].remove(triplet)
@@ -386,13 +386,17 @@ def event_add(self, virtual, *sequences):
                 triplet = _parse_sequence(seq)
                 if triplet is None:
                     #print("Tkinter event_add(%s)" % seq, file=sys.__stderr__)
-                    widget.event_add(self, virtual, seq)
+                    try:
+                        widget.event_add(self, virtual, seq)
+                    except tkinter.TclError as err:
+                        _warn_bad_binding(seq, err)
+                        continue  # Drop the invalid sequence.
                 else:
                     if func is not None:
                         try:
                             self.__binders[triplet[1]].bind(triplet, func)
                         except tkinter.TclError as err:
-                            _warn_bad_binding(triplet, err)
+                            _warn_bad_binding(_triplet_to_sequence(triplet), err)
                             continue  # Drop the invalid sequence.
                     triplets.append(triplet)