def test_delete_motion(mock, sequence, count, errmsg):
setMode(Mode.normal)
result = handleSequence(sequence)
# Left as plus to make it easier to move the count.
expected = count * ([Operator.visualStart] + [Motion.goWordNext] + \
[Operator.visualPause]) + [Operator.delete]
assert result == expected, errmsg + " ({})".format(sequence)
def test_basic_nmap(caplog):
caplog.set_level(logging.DEBUG)
setMode(Mode.normal)
expected = Motion.right.value
assert handleInput("l") == expected
nmap("x", "l")
assert handleInput("x") == expected, "basic nmap doesn't work"
def test_multichar_nmap(caplog):
caplog.set_level(logging.DEBUG)
setMode(Mode.normal)
expected = Motion.right.value * 2
assert handleInput("ll") == expected
nmap("x", "ll")
assert handleInput("x") == expected, "multichar nmap doesn't work"
def test_double_operator(mock, key, operator):
setMode(Mode.normal)
result = handleSequence(key * 2)
expected = [
Motion.goLineStart, Operator.visualStart, Motion.goLineEnd,
Operator.visualPause
] + [operator]
assert result == expected, "double {} fails".format(key)
def test_imap_to_esc_one_at_a_time(caplog):
caplog.set_level(logging.DEBUG)
setMode(Mode.insert)
expected = "<bs>"
imap("jk", "<esc>")
handleInput("j")
assert handleInput("k") == expected, "one key at a time doesn't trigger map"
assert isMode(Mode.normal)
imap("jk")
def test_imap(caplog, maps, test, expected, error_msg):
caplog.set_level(logging.DEBUG)
setMode(Mode.insert)
for m in maps:
imap(m, maps[m])
assert translate_keys(test) == expected, error_msg
# Remove imaps again
for m in maps:
imap(m)
def test_set_current_maps_for_mode(mode):
remap.maps = {
Mode.insert: {'ins': 'ert'},
Mode.normal: {'nor': 'mal'},
Mode.visual: {'vis': 'ual'},
Mode.command: {'com': 'mand'},
}
setMode(mode)
remap.set_current_maps_for_mode()
assert remap.current_maps == remap.maps[mode]
def test_map_with_joinchar(caplog, maps, test, expected, error_msg):
caplog.set_level(logging.DEBUG)
univisal.adapter_maps.adapter_maps = {Keys.multikey_join_char.value: "+"}
assert univisal.adapter_maps.getJoinChar() != ""
setMode(Mode.insert)
for m in maps:
imap(m, maps[m])
assert translate_keys(test) == expected, error_msg
# Remove imaps again
for m in maps:
imap(m)
def test_basic_motion_with_count(count):
motion = 'l'
motionVal = Motion.right.value
inpt = str(count) + motion
expected = motionVal * count
setMode(Mode.normal)
result = translate_keys(inpt)
print("number of repeats in result: {}".format(result.count(motionVal)))
print("current repeat count: {}".format(univisal.model.getRepeatCount()))
assert result == expected, "motion with count {} returns wrong thing".format(
count)
def test_swallow_unused_normal(opt, expected, msg):
from tests.mock_setup import init_univisal
from univisal.handleInput import handleInput
from univisal.handleKey import handleVimInputKey
init_univisal()
config.configStore = {"swallow_unused_normal_keys": opt}
setMode(Mode.normal)
# Test handling the single key, then the whole input to confirm.
result = handleVimInputKey("m")
assert result == expected, msg + " after handleSingleInputKey"
result = handleInput("m")
assert result == expected, msg + " after handleInput"
def test_mode_change_clears_maps_in_progress(caplog):
caplog.set_level(logging.DEBUG)
iLhs="savag"
iRhs="role"
imap(iLhs, iRhs)
nmap("g", "l")
setMode(Mode.insert)
# maps_in_progress should be iLhs minus end char (sava)
insertExpected = (iLhs[:-1])
assert translate_keys(insertExpected) == insertExpected
assert not maps_in_progress_is_blank()
setMode(Mode.normal)
# Need to send one more key to trigger the map check.
translate_keys("l")
assert maps_in_progress_is_blank()
def test_mode_change_not_affects_remaps(caplog):
caplog.set_level(logging.DEBUG)
iLhs="savag"
iRhs="role"
imap(iLhs, iRhs)
nmap("g", "l")
setMode(Mode.insert)
# maps_in_progress should be iLhs minus end char (sava)
insertExpected = (iLhs[:-1])
assert translate_keys(insertExpected) == insertExpected
assert not maps_in_progress_is_blank()
setMode(Mode.normal)
assert translate_keys("g") == Motion.right.value
setMode(Mode.insert)
assert translate_keys("g") == "g"
assert translate_keys(iLhs) == iRhs
def test_handleInput_while_disabled():
test = "input key"
errMsg = "HandleInput doesn't return input when univisal disabled"
setMode(Mode.disabled)
assert handleInput.handleInput(test) == test, errMsg
def test_getMode(mode, expected):
setMode(mode)
error_msg = "getMode doesn't return mode in {} mode".format(expected)
def test_basic_motions(motion, expected):
setMode(Mode.normal)
result = handleInput(motion)
assert result == expected.value, "{} returns wrong thing".format(motion)
def test_setMode_normal_clears_pending():
model._pending_motion = "l"
setMode(Mode.normal)
assert model._pending_motion is None
def test_escape():
setMode(Mode.insert)
assert getMode() == Mode.insert
result = handleInput(Keys.esc.value)
assert getMode() == Mode.normal
assert result == Keys.nop.value
def test_setMode_nonnormal_not_clears_pending(mode):
pending = "l"
model._pending_motion = pending
setMode(mode)
assert model._pending_motion == pending
def test_imap_esc_followup(caplog):
imap("jk", Keys.esc.value)
setMode(Mode.insert)
result = translate_keys("jkl")
assert getMode() == Mode.normal
assert result == Motion.right.value
def test_updateCurrentMode(mode):
setMode(mode)
remap.updateCurrentMode()
assert remap.current_mode == mode
def test_setMode(mode):
setMode(mode)
assert getMode() == mode
