local entry_path = "yazi-enter.yazi/main.lua" local file = assert(io.open(entry_path, "rb")) local source = assert(file:read("*a")) file:close() local capture = [[ capture_selection_session { run = run_selection_session, success = UPDATE_SUCCESS, failure = UPDATE_FAILURE, } ]] local instrumented_source, replacement_count = source:gsub( "\nreturn {\n\tentry = function", "\n" .. capture .. "\nreturn {\n\tentry = function", 1 ) assert(replacement_count == 1, "selection session capture point must occur once") local model local environment = { error = error, getmetatable = getmetatable, pairs = pairs, pcall = pcall, type = type, capture_selection_session = function(value) model = value end, ya = { sync = function(callback) return callback end }, } assert(load(instrumented_source, "@" .. entry_path, "t", environment))() local function assert_equal(actual, expected, label) assert(actual == expected, ("%s: expected %s, got %s"):format(label, tostring(expected), tostring(actual))) end local intent = { mode = "either", previous = false, smart = true, insensitive = false, direction = "forward", effective_case = "smart", } local function run_case(events, results) local calls = {} local receiver = { index = 0 } function receiver:recv() self.index = self.index + 1 local event = assert(events[self.index], "unexpected receive") calls[#calls + 1] = { "receive", event[1], event[2] } return event[1], event[2] end local boundaries = { prompt = function(prompt) calls[#calls + 1] = { "prompt", prompt } return receiver end, find_update = function(query, policy) calls[#calls + 1] = { "update", query, policy } local result = table.remove(results, 1) return result[1], result[2] end, commit = function(mode, query) calls[#calls + 1] = { "commit", mode, query } return 1 end, } return model.run(intent, boundaries), calls end local result, calls = run_case({ { "a", 3 }, { "alpha", 1 } }, { { model.success, false }, { model.success, false }, }) assert_equal(result, 1, "successful session result") assert_equal(calls[1][1], "prompt", "START to PROMPT") assert_equal(calls[2][1], "receive", "PROMPT receives Type") assert_equal(calls[3][1], "update", "Type enters UPDATE") assert_equal(calls[4][1], "receive", "UPDATE returns to PROMPT") assert_equal(calls[5][1], "update", "Submit enters FINALIZE") assert_equal(calls[6][1], "commit", "FINALIZE enters COMMIT") result, calls = run_case({ { "[", 3 }, { nil, 2 } }, { { model.failure, "malformed" }, }) assert_equal(result, 0, "recoverable update then cancel") assert_equal(calls[#calls][2], nil, "Cancel query") result, calls = run_case({ { "a", 3 }, { "ab", 3 }, { "abc", 3 }, { nil, 2 } }, { { model.success, false }, { model.success, false }, { model.success, false }, }) assert_equal(result, 0, "ordered Type session result") local update_queries = {} for _, call in ipairs(calls) do if call[1] == "update" then update_queries[#update_queries + 1] = call[2] end end assert_equal(table.concat(update_queries, ","), "a,ab,abc", "sequential Type update order") result, calls = run_case({ { "complete", 1 } }, { { model.success, false } }) assert_equal(result, 1, "rapid Submit result") assert_equal(calls[3][1], "update", "rapid Submit final update") assert_equal(calls[3][2], "complete", "rapid Submit complete query") assert_equal(calls[4][1], "commit", "rapid Submit commit") assert_equal(calls[4][3], "complete", "rapid Submit committed query") result, calls = run_case({ { "[", 3 }, { "valid", 3 }, { "valid", 1 } }, { { model.failure, "malformed" }, { model.success, false }, { model.success, false }, }) assert_equal(result, 1, "recovered Type session result") assert_equal(calls[3][2], "[", "malformed Type query") assert_equal(calls[5][2], "valid", "corrected Type query") assert_equal(calls[7][2], "valid", "corrected final query") assert_equal(calls[8][1], "commit", "commit after Type recovery") result, calls = run_case({ { "[", 1 } }, { { model.failure, "malformed" } }) assert_equal(result, 0, "failed finalization") assert_equal(calls[#calls][1], "update", "failed FINALIZE ends before COMMIT") for _, event in ipairs({ 2, 0, 99 }) do result, calls = run_case({ { nil, event } }, {}) assert_equal(result, 0, "passive terminal event " .. event) assert_equal(#calls, 2, "passive terminal call count " .. event) end for _, terminal_event in ipairs({ 2, 0 }) do local finder_state = "existing" local events = { { "latest", 3 }, { nil, terminal_event } } local receiver = { index = 0 } function receiver:recv() self.index = self.index + 1 return events[self.index][1], events[self.index][2] end local passive_boundaries = { prompt = function() return receiver end, find_update = function(query) finder_state = query return model.success, false end, commit = function() error("passive close must not commit") end, } assert_equal(model.run(intent, passive_boundaries), 0, "passive close result " .. terminal_event) assert_equal(finder_state, "latest", "finder state after passive close " .. terminal_event) end print("selection session transition checks passed")