mirror of https://github.com/python/cpython
121 lines
5.1 KiB
Python
121 lines
5.1 KiB
Python
import string
|
|
import unittest
|
|
|
|
from _pyrepl.keymap import _keynames, _escapes, parse_keys, compile_keymap, KeySpecError
|
|
|
|
|
|
class TestParseKeys(unittest.TestCase):
|
|
def test_single_character(self):
|
|
"""Ensure that single ascii characters or single digits are parsed as single characters."""
|
|
test_cases = [(key, [key]) for key in string.ascii_letters + string.digits]
|
|
for test_key, expected_keys in test_cases:
|
|
with self.subTest(f"{test_key} should be parsed as {expected_keys}"):
|
|
self.assertEqual(parse_keys(test_key), expected_keys)
|
|
|
|
def test_keynames(self):
|
|
"""Ensure that keynames are parsed to their corresponding mapping.
|
|
|
|
A keyname is expected to be of the following form: \\<keyname> such as \\<left>
|
|
which would get parsed as "left".
|
|
"""
|
|
test_cases = [(f"\\<{keyname}>", [parsed_keyname]) for keyname, parsed_keyname in _keynames.items()]
|
|
for test_key, expected_keys in test_cases:
|
|
with self.subTest(f"{test_key} should be parsed as {expected_keys}"):
|
|
self.assertEqual(parse_keys(test_key), expected_keys)
|
|
|
|
def test_escape_sequences(self):
|
|
"""Ensure that escaping sequences are parsed to their corresponding mapping."""
|
|
test_cases = [(f"\\{escape}", [parsed_escape]) for escape, parsed_escape in _escapes.items()]
|
|
for test_key, expected_keys in test_cases:
|
|
with self.subTest(f"{test_key} should be parsed as {expected_keys}"):
|
|
self.assertEqual(parse_keys(test_key), expected_keys)
|
|
|
|
def test_control_sequences(self):
|
|
"""Ensure that supported control sequences are parsed successfully."""
|
|
keys = ["@", "[", "]", "\\", "^", "_", "\\<space>", "\\<delete>"]
|
|
keys.extend(string.ascii_letters)
|
|
test_cases = [(f"\\C-{key}", chr(ord(key) & 0x1F)) for key in []]
|
|
for test_key, expected_keys in test_cases:
|
|
with self.subTest(f"{test_key} should be parsed as {expected_keys}"):
|
|
self.assertEqual(parse_keys(test_key), expected_keys)
|
|
|
|
def test_meta_sequences(self):
|
|
self.assertEqual(parse_keys("\\M-a"), ["\033", "a"])
|
|
self.assertEqual(parse_keys("\\M-b"), ["\033", "b"])
|
|
self.assertEqual(parse_keys("\\M-c"), ["\033", "c"])
|
|
|
|
def test_combinations(self):
|
|
self.assertEqual(parse_keys("\\C-a\\n\\<up>"), ["\x01", "\n", "up"])
|
|
self.assertEqual(parse_keys("\\M-a\\t\\<down>"), ["\033", "a", "\t", "down"])
|
|
|
|
def test_keyspec_errors(self):
|
|
cases = [
|
|
("\\Ca", "\\C must be followed by `-'"),
|
|
("\\ca", "\\C must be followed by `-'"),
|
|
("\\C-\\C-", "doubled \\C-"),
|
|
("\\Ma", "\\M must be followed by `-'"),
|
|
("\\ma", "\\M must be followed by `-'"),
|
|
("\\M-\\M-", "doubled \\M-"),
|
|
("\\<left", "unterminated \\<"),
|
|
("\\<unsupported>", "unrecognised keyname"),
|
|
("\\大", "unknown backslash escape"),
|
|
("\\C-\\<backspace>", "\\C- followed by invalid key")
|
|
]
|
|
for test_keys, expected_err in cases:
|
|
with self.subTest(f"{test_keys} should give error {expected_err}"):
|
|
with self.assertRaises(KeySpecError) as e:
|
|
parse_keys(test_keys)
|
|
self.assertIn(expected_err, str(e.exception))
|
|
|
|
def test_index_errors(self):
|
|
test_cases = ["\\", "\\C", "\\C-\\C"]
|
|
for test_keys in test_cases:
|
|
with self.assertRaises(IndexError):
|
|
parse_keys(test_keys)
|
|
|
|
|
|
class TestCompileKeymap(unittest.TestCase):
|
|
def test_empty_keymap(self):
|
|
keymap = {}
|
|
result = compile_keymap(keymap)
|
|
self.assertEqual(result, {})
|
|
|
|
def test_single_keymap(self):
|
|
keymap = {b"a": "action"}
|
|
result = compile_keymap(keymap)
|
|
self.assertEqual(result, {b"a": "action"})
|
|
|
|
def test_nested_keymap(self):
|
|
keymap = {b"a": {b"b": "action"}}
|
|
result = compile_keymap(keymap)
|
|
self.assertEqual(result, {b"a": {b"b": "action"}})
|
|
|
|
def test_empty_value(self):
|
|
keymap = {b"a": {b"": "action"}}
|
|
result = compile_keymap(keymap)
|
|
self.assertEqual(result, {b"a": {b"": "action"}})
|
|
|
|
def test_multiple_empty_values(self):
|
|
keymap = {b"a": {b"": "action1", b"b": "action2"}}
|
|
result = compile_keymap(keymap)
|
|
self.assertEqual(result, {b"a": {b"": "action1", b"b": "action2"}})
|
|
|
|
def test_multiple_keymaps(self):
|
|
keymap = {b"a": {b"b": "action1", b"c": "action2"}}
|
|
result = compile_keymap(keymap)
|
|
self.assertEqual(result, {b"a": {b"b": "action1", b"c": "action2"}})
|
|
|
|
def test_nested_multiple_keymaps(self):
|
|
keymap = {b"a": {b"b": {b"c": "action"}}}
|
|
result = compile_keymap(keymap)
|
|
self.assertEqual(result, {b"a": {b"b": {b"c": "action"}}})
|
|
|
|
def test_clashing_definitions(self):
|
|
km = {b'a': 'c', b'a' + b'b': 'd'}
|
|
with self.assertRaises(KeySpecError):
|
|
compile_keymap(km)
|
|
|
|
def test_non_bytes_key(self):
|
|
with self.assertRaises(TypeError):
|
|
compile_keymap({123: 'a'})
|