diff options
Diffstat (limited to 'tests/unit/keyinput/test_keyutils.py')
| -rw-r--r-- | tests/unit/keyinput/test_keyutils.py | 314 |
1 files changed, 157 insertions, 157 deletions
diff --git a/tests/unit/keyinput/test_keyutils.py b/tests/unit/keyinput/test_keyutils.py index 6bfa098fc..700544150 100644 --- a/tests/unit/keyinput/test_keyutils.py +++ b/tests/unit/keyinput/test_keyutils.py @@ -73,7 +73,7 @@ def test_key_data_modifiers(): mod_names = {name[:-len("Modifier")] for name, value in sorted(vars(Qt).items()) if isinstance(value, Qt.KeyboardModifier) and - value not in [Qt.NoModifier, Qt.KeyboardModifierMask]} + value not in [Qt.KeyboardModifier.NoModifier, Qt.KeyboardModifier.KeyboardModifierMask]} mod_data_names = {mod.attribute for mod in sorted(key_data.MODIFIERS)} diff = mod_names - mod_data_names assert not diff @@ -106,7 +106,7 @@ class TestKeyInfoText: See key_data.py for inputs and expected values. """ - modifiers = Qt.ShiftModifier if upper else Qt.KeyboardModifiers() + modifiers = Qt.KeyboardModifier.ShiftModifier if upper else Qt.KeyboardModifiers() info = keyutils.KeyInfo(qt_key.member, modifiers=modifiers) expected = qt_key.uppertext if upper else qt_key.text assert info.text() == expected @@ -143,45 +143,45 @@ class TestKeyToString: monkeypatch.delattr(keyutils.Qt, 'Key_AltGr') # We don't want to test the key which is actually missing - we only # want to know if the mapping still behaves properly. - assert keyutils._key_to_string(Qt.Key_A) == 'A' + assert keyutils._key_to_string(Qt.Key.Key_A) == 'A' @pytest.mark.parametrize('key, modifiers, expected', [ - (Qt.Key_A, Qt.NoModifier, 'a'), - (Qt.Key_A, Qt.ShiftModifier, 'A'), - - (Qt.Key_Space, Qt.NoModifier, '<Space>'), - (Qt.Key_Space, Qt.ShiftModifier, '<Shift+Space>'), - (Qt.Key_Tab, Qt.ShiftModifier, '<Shift+Tab>'), - (Qt.Key_A, Qt.ControlModifier, '<Ctrl+a>'), - (Qt.Key_A, Qt.ControlModifier | Qt.ShiftModifier, '<Ctrl+Shift+a>'), - (Qt.Key_A, - Qt.ControlModifier | Qt.AltModifier | Qt.MetaModifier | Qt.ShiftModifier, + (Qt.Key.Key_A, Qt.KeyboardModifier.NoModifier, 'a'), + (Qt.Key.Key_A, Qt.KeyboardModifier.ShiftModifier, 'A'), + + (Qt.Key.Key_Space, Qt.KeyboardModifier.NoModifier, '<Space>'), + (Qt.Key.Key_Space, Qt.KeyboardModifier.ShiftModifier, '<Shift+Space>'), + (Qt.Key.Key_Tab, Qt.KeyboardModifier.ShiftModifier, '<Shift+Tab>'), + (Qt.Key.Key_A, Qt.KeyboardModifier.ControlModifier, '<Ctrl+a>'), + (Qt.Key.Key_A, Qt.KeyboardModifier.ControlModifier | Qt.KeyboardModifier.ShiftModifier, '<Ctrl+Shift+a>'), + (Qt.Key.Key_A, + Qt.KeyboardModifier.ControlModifier | Qt.KeyboardModifier.AltModifier | Qt.KeyboardModifier.MetaModifier | Qt.KeyboardModifier.ShiftModifier, '<Meta+Ctrl+Alt+Shift+a>'), - (ord('Œ'), Qt.NoModifier, '<Œ>'), - (ord('Œ'), Qt.ShiftModifier, '<Shift+Œ>'), - (ord('Œ'), Qt.GroupSwitchModifier, '<AltGr+Œ>'), - (ord('Œ'), Qt.GroupSwitchModifier | Qt.ShiftModifier, '<AltGr+Shift+Œ>'), - - (Qt.Key_Shift, Qt.ShiftModifier, '<Shift>'), - (Qt.Key_Shift, Qt.ShiftModifier | Qt.ControlModifier, '<Ctrl+Shift>'), - (Qt.Key_Alt, Qt.AltModifier, '<Alt>'), - (Qt.Key_Shift, Qt.GroupSwitchModifier | Qt.ShiftModifier, '<AltGr+Shift>'), - (Qt.Key_AltGr, Qt.GroupSwitchModifier, '<AltGr>'), + (ord('Œ'), Qt.KeyboardModifier.NoModifier, '<Œ>'), + (ord('Œ'), Qt.KeyboardModifier.ShiftModifier, '<Shift+Œ>'), + (ord('Œ'), Qt.KeyboardModifier.GroupSwitchModifier, '<AltGr+Œ>'), + (ord('Œ'), Qt.KeyboardModifier.GroupSwitchModifier | Qt.KeyboardModifier.ShiftModifier, '<AltGr+Shift+Œ>'), + + (Qt.Key.Key_Shift, Qt.KeyboardModifier.ShiftModifier, '<Shift>'), + (Qt.Key.Key_Shift, Qt.KeyboardModifier.ShiftModifier | Qt.KeyboardModifier.ControlModifier, '<Ctrl+Shift>'), + (Qt.Key.Key_Alt, Qt.KeyboardModifier.AltModifier, '<Alt>'), + (Qt.Key.Key_Shift, Qt.KeyboardModifier.GroupSwitchModifier | Qt.KeyboardModifier.ShiftModifier, '<AltGr+Shift>'), + (Qt.Key.Key_AltGr, Qt.KeyboardModifier.GroupSwitchModifier, '<AltGr>'), ]) def test_key_info_str(key, modifiers, expected): assert str(keyutils.KeyInfo(key, modifiers)) == expected @pytest.mark.parametrize('info1, info2, equal', [ - (keyutils.KeyInfo(Qt.Key_A, Qt.NoModifier), - keyutils.KeyInfo(Qt.Key_A, Qt.NoModifier), + (keyutils.KeyInfo(Qt.Key.Key_A, Qt.KeyboardModifier.NoModifier), + keyutils.KeyInfo(Qt.Key.Key_A, Qt.KeyboardModifier.NoModifier), True), - (keyutils.KeyInfo(Qt.Key_A, Qt.NoModifier), - keyutils.KeyInfo(Qt.Key_B, Qt.NoModifier), + (keyutils.KeyInfo(Qt.Key.Key_A, Qt.KeyboardModifier.NoModifier), + keyutils.KeyInfo(Qt.Key.Key_B, Qt.KeyboardModifier.NoModifier), False), - (keyutils.KeyInfo(Qt.Key_A, Qt.NoModifier), - keyutils.KeyInfo(Qt.Key_B, Qt.ControlModifier), + (keyutils.KeyInfo(Qt.Key.Key_A, Qt.KeyboardModifier.NoModifier), + keyutils.KeyInfo(Qt.Key.Key_B, Qt.KeyboardModifier.ControlModifier), False), ]) def test_hash(info1, info2, equal): @@ -189,9 +189,9 @@ def test_hash(info1, info2, equal): @pytest.mark.parametrize('key, modifiers, text, expected', [ - (0xd83c, Qt.NoModifier, '🏻', '<🏻>'), - (0xd867, Qt.NoModifier, '𩷶', '<𩷶>'), - (0xd867, Qt.ShiftModifier, '𩷶', '<Shift+𩷶>'), + (0xd83c, Qt.KeyboardModifier.NoModifier, '🏻', '<🏻>'), + (0xd867, Qt.KeyboardModifier.NoModifier, '𩷶', '<𩷶>'), + (0xd867, Qt.KeyboardModifier.ShiftModifier, '𩷶', '<Shift+𩷶>'), ]) def test_surrogates(key, modifiers, text, expected): evt = QKeyEvent(QKeyEvent.KeyPress, key, modifiers, text) @@ -201,7 +201,7 @@ def test_surrogates(key, modifiers, text, expected): @pytest.mark.parametrize('keys, expected', [ ([0x1f3fb], '<🏻>'), ([0x29df6], '<𩷶>'), - ([Qt.Key_Shift, 0x29df6], '<Shift><𩷶>'), + ([Qt.Key.Key_Shift, 0x29df6], '<Shift><𩷶>'), ([0x1f468, 0x200d, 0x1f468, 0x200d, 0x1f466], '<👨><><👨><><👦>'), ]) def test_surrogate_sequences(keys, expected): @@ -211,7 +211,7 @@ def test_surrogate_sequences(keys, expected): # This shouldn't happen, but if it does we should handle it well def test_surrogate_error(): - evt = QKeyEvent(QKeyEvent.KeyPress, 0xd83e, Qt.NoModifier, '🤞🏻') + evt = QKeyEvent(QKeyEvent.KeyPress, 0xd83e, Qt.KeyboardModifier.NoModifier, '🤞🏻') with pytest.raises(keyutils.KeyParseError): keyutils.KeyInfo.from_event(evt) @@ -246,8 +246,8 @@ def test_parse_keystr(keystr, parts): class TestKeySequence: def test_init(self): - seq = keyutils.KeySequence(Qt.Key_A, Qt.Key_B, Qt.Key_C, Qt.Key_D, - Qt.Key_E) + seq = keyutils.KeySequence(Qt.Key.Key_A, Qt.Key.Key_B, Qt.Key.Key_C, Qt.Key.Key_D, + Qt.Key.Key_E) assert len(seq._sequences) == 2 assert len(seq._sequences[0]) == 4 assert len(seq._sequences[1]) == 1 @@ -256,7 +256,7 @@ class TestKeySequence: seq = keyutils.KeySequence() assert not seq - @pytest.mark.parametrize('key', [Qt.Key_unknown, -1, 0]) + @pytest.mark.parametrize('key', [Qt.Key.Key_unknown, -1, 0]) def test_init_unknown(self, key): with pytest.raises(keyutils.KeyParseError): keyutils.KeySequence(key) @@ -283,21 +283,21 @@ class TestKeySequence: assert str(keyutils.KeySequence.parse(orig)) == normalized def test_iter(self): - seq = keyutils.KeySequence(Qt.Key_A | Qt.ControlModifier, - Qt.Key_B | Qt.ShiftModifier, - Qt.Key_C, - Qt.Key_D, - Qt.Key_E) - expected = [keyutils.KeyInfo(Qt.Key_A, Qt.ControlModifier), - keyutils.KeyInfo(Qt.Key_B, Qt.ShiftModifier), - keyutils.KeyInfo(Qt.Key_C, Qt.NoModifier), - keyutils.KeyInfo(Qt.Key_D, Qt.NoModifier), - keyutils.KeyInfo(Qt.Key_E, Qt.NoModifier)] + seq = keyutils.KeySequence(Qt.Key.Key_A | Qt.KeyboardModifier.ControlModifier, + Qt.Key.Key_B | Qt.KeyboardModifier.ShiftModifier, + Qt.Key.Key_C, + Qt.Key.Key_D, + Qt.Key.Key_E) + expected = [keyutils.KeyInfo(Qt.Key.Key_A, Qt.KeyboardModifier.ControlModifier), + keyutils.KeyInfo(Qt.Key.Key_B, Qt.KeyboardModifier.ShiftModifier), + keyutils.KeyInfo(Qt.Key.Key_C, Qt.KeyboardModifier.NoModifier), + keyutils.KeyInfo(Qt.Key.Key_D, Qt.KeyboardModifier.NoModifier), + keyutils.KeyInfo(Qt.Key.Key_E, Qt.KeyboardModifier.NoModifier)] assert list(seq) == expected def test_repr(self): - seq = keyutils.KeySequence(Qt.Key_A | Qt.ControlModifier, - Qt.Key_B | Qt.ShiftModifier) + seq = keyutils.KeySequence(Qt.Key.Key_A | Qt.KeyboardModifier.ControlModifier, + Qt.Key.Key_B | Qt.KeyboardModifier.ShiftModifier) assert repr(seq) == ("<qutebrowser.keyinput.keyutils.KeySequence " "keys='<Ctrl+a>B'>") @@ -369,7 +369,7 @@ class TestKeySequence: def test_getitem(self): seq = keyutils.KeySequence.parse('ab') - expected = keyutils.KeyInfo(Qt.Key_B, Qt.NoModifier) + expected = keyutils.KeyInfo(Qt.Key.Key_B, Qt.KeyboardModifier.NoModifier) assert seq[1] == expected def test_getitem_slice(self): @@ -382,27 +382,27 @@ class TestKeySequence: MATCH_TESTS = [ # config: abcd - ('abc', 'abcd', QKeySequence.PartialMatch), - ('abcd', 'abcd', QKeySequence.ExactMatch), - ('ax', 'abcd', QKeySequence.NoMatch), - ('abcdef', 'abcd', QKeySequence.NoMatch), + ('abc', 'abcd', QKeySequence.SequenceMatch.PartialMatch), + ('abcd', 'abcd', QKeySequence.SequenceMatch.ExactMatch), + ('ax', 'abcd', QKeySequence.SequenceMatch.NoMatch), + ('abcdef', 'abcd', QKeySequence.SequenceMatch.NoMatch), # config: abcd ef - ('abc', 'abcdef', QKeySequence.PartialMatch), - ('abcde', 'abcdef', QKeySequence.PartialMatch), - ('abcd', 'abcdef', QKeySequence.PartialMatch), - ('abcdx', 'abcdef', QKeySequence.NoMatch), - ('ax', 'abcdef', QKeySequence.NoMatch), - ('abcdefg', 'abcdef', QKeySequence.NoMatch), - ('abcdef', 'abcdef', QKeySequence.ExactMatch), + ('abc', 'abcdef', QKeySequence.SequenceMatch.PartialMatch), + ('abcde', 'abcdef', QKeySequence.SequenceMatch.PartialMatch), + ('abcd', 'abcdef', QKeySequence.SequenceMatch.PartialMatch), + ('abcdx', 'abcdef', QKeySequence.SequenceMatch.NoMatch), + ('ax', 'abcdef', QKeySequence.SequenceMatch.NoMatch), + ('abcdefg', 'abcdef', QKeySequence.SequenceMatch.NoMatch), + ('abcdef', 'abcdef', QKeySequence.SequenceMatch.ExactMatch), # other examples - ('ab', 'a', QKeySequence.NoMatch), + ('ab', 'a', QKeySequence.SequenceMatch.NoMatch), # empty strings - ('', '', QKeySequence.ExactMatch), - ('', 'a', QKeySequence.PartialMatch), - ('a', '', QKeySequence.NoMatch)] + ('', '', QKeySequence.SequenceMatch.ExactMatch), + ('', 'a', QKeySequence.SequenceMatch.PartialMatch), + ('a', '', QKeySequence.SequenceMatch.NoMatch)] @pytest.mark.parametrize('entered, configured, match_type', MATCH_TESTS) def test_matches(self, entered, configured, match_type): @@ -411,33 +411,33 @@ class TestKeySequence: assert entered.matches(configured) == match_type @pytest.mark.parametrize('old, key, modifiers, text, expected', [ - ('a', Qt.Key_B, Qt.NoModifier, 'b', 'ab'), - ('a', Qt.Key_B, Qt.ShiftModifier, 'B', 'aB'), - ('a', Qt.Key_B, Qt.AltModifier | Qt.ShiftModifier, 'B', + ('a', Qt.Key.Key_B, Qt.KeyboardModifier.NoModifier, 'b', 'ab'), + ('a', Qt.Key.Key_B, Qt.KeyboardModifier.ShiftModifier, 'B', 'aB'), + ('a', Qt.Key.Key_B, Qt.KeyboardModifier.AltModifier | Qt.KeyboardModifier.ShiftModifier, 'B', 'a<Alt+Shift+b>'), # Modifier stripping with symbols - ('', Qt.Key_Colon, Qt.NoModifier, ':', ':'), - ('', Qt.Key_Colon, Qt.ShiftModifier, ':', ':'), - ('', Qt.Key_Colon, Qt.AltModifier | Qt.ShiftModifier, ':', + ('', Qt.Key.Key_Colon, Qt.KeyboardModifier.NoModifier, ':', ':'), + ('', Qt.Key.Key_Colon, Qt.KeyboardModifier.ShiftModifier, ':', ':'), + ('', Qt.Key.Key_Colon, Qt.KeyboardModifier.AltModifier | Qt.KeyboardModifier.ShiftModifier, ':', '<Alt+Shift+:>'), # Swapping Control/Meta on macOS - ('', Qt.Key_A, Qt.ControlModifier, '', + ('', Qt.Key.Key_A, Qt.KeyboardModifier.ControlModifier, '', '<Meta+A>' if utils.is_mac else '<Ctrl+A>'), - ('', Qt.Key_A, Qt.ControlModifier | Qt.ShiftModifier, '', + ('', Qt.Key.Key_A, Qt.KeyboardModifier.ControlModifier | Qt.KeyboardModifier.ShiftModifier, '', '<Meta+Shift+A>' if utils.is_mac else '<Ctrl+Shift+A>'), - ('', Qt.Key_A, Qt.MetaModifier, '', + ('', Qt.Key.Key_A, Qt.KeyboardModifier.MetaModifier, '', '<Ctrl+A>' if utils.is_mac else '<Meta+A>'), # Handling of Backtab - ('', Qt.Key_Backtab, Qt.NoModifier, '', '<Backtab>'), - ('', Qt.Key_Backtab, Qt.ShiftModifier, '', '<Shift+Tab>'), - ('', Qt.Key_Backtab, Qt.AltModifier | Qt.ShiftModifier, '', + ('', Qt.Key.Key_Backtab, Qt.KeyboardModifier.NoModifier, '', '<Backtab>'), + ('', Qt.Key.Key_Backtab, Qt.KeyboardModifier.ShiftModifier, '', '<Shift+Tab>'), + ('', Qt.Key.Key_Backtab, Qt.KeyboardModifier.AltModifier | Qt.KeyboardModifier.ShiftModifier, '', '<Alt+Shift+Tab>'), - # Stripping of Qt.GroupSwitchModifier - ('', Qt.Key_A, Qt.GroupSwitchModifier, 'a', 'a'), + # Stripping of Qt.KeyboardModifier.GroupSwitchModifier + ('', Qt.Key.Key_A, Qt.KeyboardModifier.GroupSwitchModifier, 'a', 'a'), ]) def test_append_event(self, old, key, modifiers, text, expected): seq = keyutils.KeySequence.parse(old) @@ -447,39 +447,39 @@ class TestKeySequence: @pytest.mark.fake_os('mac') @pytest.mark.parametrize('modifiers, expected', [ - (Qt.ControlModifier, - Qt.MetaModifier), - (Qt.MetaModifier, - Qt.ControlModifier), - (Qt.ControlModifier | Qt.MetaModifier, - Qt.ControlModifier | Qt.MetaModifier), - (Qt.ControlModifier | Qt.ShiftModifier, - Qt.MetaModifier | Qt.ShiftModifier), - (Qt.MetaModifier | Qt.ShiftModifier, - Qt.ControlModifier | Qt.ShiftModifier), - (Qt.ShiftModifier, Qt.ShiftModifier), + (Qt.KeyboardModifier.ControlModifier, + Qt.KeyboardModifier.MetaModifier), + (Qt.KeyboardModifier.MetaModifier, + Qt.KeyboardModifier.ControlModifier), + (Qt.KeyboardModifier.ControlModifier | Qt.KeyboardModifier.MetaModifier, + Qt.KeyboardModifier.ControlModifier | Qt.KeyboardModifier.MetaModifier), + (Qt.KeyboardModifier.ControlModifier | Qt.KeyboardModifier.ShiftModifier, + Qt.KeyboardModifier.MetaModifier | Qt.KeyboardModifier.ShiftModifier), + (Qt.KeyboardModifier.MetaModifier | Qt.KeyboardModifier.ShiftModifier, + Qt.KeyboardModifier.ControlModifier | Qt.KeyboardModifier.ShiftModifier), + (Qt.KeyboardModifier.ShiftModifier, Qt.KeyboardModifier.ShiftModifier), ]) def test_fake_mac(self, modifiers, expected): """Make sure Control/Meta are swapped with a simulated Mac.""" seq = keyutils.KeySequence() - info = keyutils.KeyInfo(key=Qt.Key_A, modifiers=modifiers) + info = keyutils.KeyInfo(key=Qt.Key.Key_A, modifiers=modifiers) new = seq.append_event(info.to_event()) - assert new[0] == keyutils.KeyInfo(Qt.Key_A, expected) + assert new[0] == keyutils.KeyInfo(Qt.Key.Key_A, expected) - @pytest.mark.parametrize('key', [Qt.Key_unknown, 0x0]) + @pytest.mark.parametrize('key', [Qt.Key.Key_unknown, 0x0]) def test_append_event_invalid(self, key): seq = keyutils.KeySequence() - event = QKeyEvent(QKeyEvent.KeyPress, key, Qt.NoModifier, '') + event = QKeyEvent(QKeyEvent.KeyPress, key, Qt.KeyboardModifier.NoModifier, '') with pytest.raises(keyutils.KeyParseError): seq.append_event(event) def test_strip_modifiers(self): - seq = keyutils.KeySequence(Qt.Key_0, - Qt.Key_1 | Qt.KeypadModifier, - Qt.Key_A | Qt.ControlModifier) - expected = keyutils.KeySequence(Qt.Key_0, - Qt.Key_1, - Qt.Key_A | Qt.ControlModifier) + seq = keyutils.KeySequence(Qt.Key.Key_0, + Qt.Key.Key_1 | Qt.KeyboardModifier.KeypadModifier, + Qt.Key.Key_A | Qt.KeyboardModifier.ControlModifier) + expected = keyutils.KeySequence(Qt.Key.Key_0, + Qt.Key.Key_1, + Qt.Key.Key_A | Qt.KeyboardModifier.ControlModifier) assert seq.strip_modifiers() == expected @pytest.mark.parametrize('inp, mappings, expected', [ @@ -497,31 +497,31 @@ class TestKeySequence: @pytest.mark.parametrize('keystr, expected', [ ('<Ctrl-Alt-y>', - keyutils.KeySequence(Qt.ControlModifier | Qt.AltModifier | Qt.Key_Y)), - ('x', keyutils.KeySequence(Qt.Key_X)), - ('X', keyutils.KeySequence(Qt.ShiftModifier | Qt.Key_X)), - ('<Escape>', keyutils.KeySequence(Qt.Key_Escape)), - ('xyz', keyutils.KeySequence(Qt.Key_X, Qt.Key_Y, Qt.Key_Z)), + keyutils.KeySequence(Qt.KeyboardModifier.ControlModifier | Qt.KeyboardModifier.AltModifier | Qt.Key.Key_Y)), + ('x', keyutils.KeySequence(Qt.Key.Key_X)), + ('X', keyutils.KeySequence(Qt.KeyboardModifier.ShiftModifier | Qt.Key.Key_X)), + ('<Escape>', keyutils.KeySequence(Qt.Key.Key_Escape)), + ('xyz', keyutils.KeySequence(Qt.Key.Key_X, Qt.Key.Key_Y, Qt.Key.Key_Z)), ('<Control-x><Meta-y>', - keyutils.KeySequence(Qt.ControlModifier | Qt.Key_X, - Qt.MetaModifier | Qt.Key_Y)), - - ('<Shift-x>', keyutils.KeySequence(Qt.ShiftModifier | Qt.Key_X)), - ('<Alt-x>', keyutils.KeySequence(Qt.AltModifier | Qt.Key_X)), - ('<Control-x>', keyutils.KeySequence(Qt.ControlModifier | Qt.Key_X)), - ('<Meta-x>', keyutils.KeySequence(Qt.MetaModifier | Qt.Key_X)), - ('<Num-x>', keyutils.KeySequence(Qt.KeypadModifier | Qt.Key_X)), - - ('>', keyutils.KeySequence(Qt.Key_Greater)), - ('<', keyutils.KeySequence(Qt.Key_Less)), - ('a>', keyutils.KeySequence(Qt.Key_A, Qt.Key_Greater)), - ('a<', keyutils.KeySequence(Qt.Key_A, Qt.Key_Less)), - ('>a', keyutils.KeySequence(Qt.Key_Greater, Qt.Key_A)), - ('<a', keyutils.KeySequence(Qt.Key_Less, Qt.Key_A)), + keyutils.KeySequence(Qt.KeyboardModifier.ControlModifier | Qt.Key.Key_X, + Qt.KeyboardModifier.MetaModifier | Qt.Key.Key_Y)), + + ('<Shift-x>', keyutils.KeySequence(Qt.KeyboardModifier.ShiftModifier | Qt.Key.Key_X)), + ('<Alt-x>', keyutils.KeySequence(Qt.KeyboardModifier.AltModifier | Qt.Key.Key_X)), + ('<Control-x>', keyutils.KeySequence(Qt.KeyboardModifier.ControlModifier | Qt.Key.Key_X)), + ('<Meta-x>', keyutils.KeySequence(Qt.KeyboardModifier.MetaModifier | Qt.Key.Key_X)), + ('<Num-x>', keyutils.KeySequence(Qt.KeyboardModifier.KeypadModifier | Qt.Key.Key_X)), + + ('>', keyutils.KeySequence(Qt.Key.Key_Greater)), + ('<', keyutils.KeySequence(Qt.Key.Key_Less)), + ('a>', keyutils.KeySequence(Qt.Key.Key_A, Qt.Key.Key_Greater)), + ('a<', keyutils.KeySequence(Qt.Key.Key_A, Qt.Key.Key_Less)), + ('>a', keyutils.KeySequence(Qt.Key.Key_Greater, Qt.Key.Key_A)), + ('<a', keyutils.KeySequence(Qt.Key.Key_Less, Qt.Key.Key_A)), ('<alt+greater>', - keyutils.KeySequence(Qt.Key_Greater | Qt.AltModifier)), + keyutils.KeySequence(Qt.Key.Key_Greater | Qt.KeyboardModifier.AltModifier)), ('<alt+less>', - keyutils.KeySequence(Qt.Key_Less | Qt.AltModifier)), + keyutils.KeySequence(Qt.Key.Key_Less | Qt.KeyboardModifier.AltModifier)), ('<alt+<>', keyutils.KeyParseError), ('<alt+>>', keyutils.KeyParseError), @@ -547,66 +547,66 @@ class TestKeySequence: def test_key_info_from_event(): - ev = QKeyEvent(QEvent.KeyPress, Qt.Key_A, Qt.ShiftModifier, 'A') + ev = QKeyEvent(QEvent.Type.KeyPress, Qt.Key.Key_A, Qt.KeyboardModifier.ShiftModifier, 'A') info = keyutils.KeyInfo.from_event(ev) - assert info.key == Qt.Key_A - assert info.modifiers == Qt.ShiftModifier + assert info.key == Qt.Key.Key_A + assert info.modifiers == Qt.KeyboardModifier.ShiftModifier def test_key_info_to_event(): - info = keyutils.KeyInfo(Qt.Key_A, Qt.ShiftModifier) + info = keyutils.KeyInfo(Qt.Key.Key_A, Qt.KeyboardModifier.ShiftModifier) ev = info.to_event() - assert ev.key() == Qt.Key_A - assert ev.modifiers() == Qt.ShiftModifier + assert ev.key() == Qt.Key.Key_A + assert ev.modifiers() == Qt.KeyboardModifier.ShiftModifier assert ev.text() == 'A' def test_key_info_to_int(): - info = keyutils.KeyInfo(Qt.Key_A, Qt.ShiftModifier) - assert info.to_int() == Qt.Key_A | Qt.ShiftModifier + info = keyutils.KeyInfo(Qt.Key.Key_A, Qt.KeyboardModifier.ShiftModifier) + assert info.to_int() == Qt.Key.Key_A | Qt.KeyboardModifier.ShiftModifier @pytest.mark.parametrize('key, printable', [ - (Qt.Key_Control, False), - (Qt.Key_Escape, False), - (Qt.Key_Tab, False), - (Qt.Key_Backtab, False), - (Qt.Key_Backspace, False), - (Qt.Key_Return, False), - (Qt.Key_Enter, False), - (Qt.Key_Space, False), + (Qt.Key.Key_Control, False), + (Qt.Key.Key_Escape, False), + (Qt.Key.Key_Tab, False), + (Qt.Key.Key_Backtab, False), + (Qt.Key.Key_Backspace, False), + (Qt.Key.Key_Return, False), + (Qt.Key.Key_Enter, False), + (Qt.Key.Key_Space, False), (0x0, False), # Used by Qt for unknown keys - (Qt.Key_ydiaeresis, True), - (Qt.Key_X, True), + (Qt.Key.Key_ydiaeresis, True), + (Qt.Key.Key_X, True), ]) def test_is_printable(key, printable): assert keyutils._is_printable(key) == printable - assert keyutils.is_special(key, Qt.NoModifier) != printable + assert keyutils.is_special(key, Qt.KeyboardModifier.NoModifier) != printable @pytest.mark.parametrize('key, modifiers, special', [ - (Qt.Key_Escape, Qt.NoModifier, True), - (Qt.Key_Escape, Qt.ShiftModifier, True), - (Qt.Key_Escape, Qt.ControlModifier, True), - (Qt.Key_X, Qt.ControlModifier, True), - (Qt.Key_X, Qt.NoModifier, False), - (Qt.Key_2, Qt.KeypadModifier, True), - (Qt.Key_2, Qt.NoModifier, False), - (Qt.Key_Shift, Qt.ShiftModifier, True), - (Qt.Key_Control, Qt.ControlModifier, True), - (Qt.Key_Alt, Qt.AltModifier, True), - (Qt.Key_Meta, Qt.MetaModifier, True), - (Qt.Key_Mode_switch, Qt.GroupSwitchModifier, True), + (Qt.Key.Key_Escape, Qt.KeyboardModifier.NoModifier, True), + (Qt.Key.Key_Escape, Qt.KeyboardModifier.ShiftModifier, True), + (Qt.Key.Key_Escape, Qt.KeyboardModifier.ControlModifier, True), + (Qt.Key.Key_X, Qt.KeyboardModifier.ControlModifier, True), + (Qt.Key.Key_X, Qt.KeyboardModifier.NoModifier, False), + (Qt.Key.Key_2, Qt.KeyboardModifier.KeypadModifier, True), + (Qt.Key.Key_2, Qt.KeyboardModifier.NoModifier, False), + (Qt.Key.Key_Shift, Qt.KeyboardModifier.ShiftModifier, True), + (Qt.Key.Key_Control, Qt.KeyboardModifier.ControlModifier, True), + (Qt.Key.Key_Alt, Qt.KeyboardModifier.AltModifier, True), + (Qt.Key.Key_Meta, Qt.KeyboardModifier.MetaModifier, True), + (Qt.Key.Key_Mode_switch, Qt.KeyboardModifier.GroupSwitchModifier, True), ]) def test_is_special(key, modifiers, special): assert keyutils.is_special(key, modifiers) == special @pytest.mark.parametrize('key, ismodifier', [ - (Qt.Key_Control, True), - (Qt.Key_X, False), - (Qt.Key_Super_L, False), # Modifier but not in _MODIFIER_MAP + (Qt.Key.Key_Control, True), + (Qt.Key.Key_X, False), + (Qt.Key.Key_Super_L, False), # Modifier but not in _MODIFIER_MAP ]) def test_is_modifier_key(key, ismodifier): assert keyutils.is_modifier_key(key) == ismodifier @@ -622,4 +622,4 @@ def test_is_modifier_key(key, ismodifier): ]) def test_non_plain(func): with pytest.raises(AssertionError): - func(Qt.Key_X | Qt.ControlModifier) + func(Qt.Key.Key_X | Qt.KeyboardModifier.ControlModifier) |