// M9.8d rebindable controls (ADR-0085): SDL-free binding contract, editor and file. #include "evo/client/bindings.hpp" #include #include #include #include #include #include namespace { using namespace evo::client; void check(bool ok, std::source_location at = std::source_location::current()) { if (!ok) throw std::runtime_error("client bindings line " + std::to_string(at.line())); } #define CHECK(...) check(static_cast(__VA_ARGS__)) KeyCode key(std::string_view name) { const auto k = key_from_name(name); if (!k) throw std::runtime_error("client bindings: unknown key name"); return *k; } bool refused(const auto& result, BindingError error) { return !result && result.error().error == error; } void names_and_defaults() { const auto d = Bindings::defaults(); CHECK(d.action(key("W")) == Action::move_up && d.action(key("A")) == Action::move_left); CHECK(d.action(key("Up")) == Action::pan_up && d.action(key("Tab")) == Action::toggle_capture); CHECK(!d.action(key("Q")) && !d.action(no_key)); CHECK(key_name(26) == "W" && key_name(82) == "Up" && key_name(0).empty() && key_name(224).empty()); CHECK(!bindable(escape_key) && !bindable(no_key) && !bindable(224) && !bindable(57)); CHECK(bindable(key("Keypad5")) && bindable(key("F12"))); CHECK(!key_from_name("w") && !key_from_name("") && !key_from_name("LeftShift")); for (std::size_t k = 0; k < action_count; ++k) { const auto a = static_cast(k); CHECK(action_from_id(action_id(a)) == a && !action_name(a).empty()); } CHECK(!action_from_id("jump")); // Defaults are themselves valid and round-trip through make(). const auto again = Bindings::make(d.slots()); CHECK(again && *again == d); } void validation() { auto slots = Bindings::defaults().slots(); slots[2].secondary = key("I"); CHECK(Bindings::make(slots)); auto conflict = slots; conflict[0].secondary = key("W"); // Move up's key. const auto c = Bindings::make(conflict); CHECK(refused(c, BindingError::conflict) && c.error().other == Action::move_left && c.error().action == Action::move_up && c.error().key == key("W")); CHECK(describe(c.error()) == "W is already bound to Move left."); auto same = slots; same[3].secondary = same[3].primary; CHECK(refused(Bindings::make(same), BindingError::conflict)); auto missing = slots; missing[8].primary = no_key; const auto m = Bindings::make(missing); CHECK(refused(m, BindingError::missing_primary) && m.error().action == Action::toggle_capture); auto reserved = slots; reserved[1].primary = escape_key; CHECK(refused(Bindings::make(reserved), BindingError::unbindable_key)); auto modifier = slots; modifier[1].secondary = 225; // Left Shift. CHECK(refused(Bindings::make(modifier), BindingError::unbindable_key)); } void editor() { BindingEditor e{Bindings::defaults()}; // A conflicting assignment is refused and leaves the draft unchanged. const auto before = e.draft(); const auto refused_assign = e.assign(Action::move_up, false, key("Left")); CHECK(!refused_assign && refused_assign.error().other == Action::pan_left); CHECK(e.draft() == before); CHECK(!e.assign(Action::move_up, true, escape_key)); CHECK(!e.assign(Action::move_up, true, key("W"))); // Its own primary. // Reassigning a slot to its current key is allowed (no-op). CHECK(e.assign(Action::move_up, false, key("W"))); CHECK(e.assign(Action::move_up, false, key("I")) && e.assign(Action::move_up, true, key("W"))); auto applied = e.apply(); CHECK(applied && applied->action(key("I")) == Action::move_up && applied->action(key("W")) == Action::move_up); e.clear_secondary(Action::move_up); CHECK(e.draft()[2].secondary == no_key); e.reset_defaults(); CHECK(e.apply() == Bindings::defaults()); } void file_format() { auto slots = Bindings::defaults().slots(); slots[8] = {key("F1"), key("Keypad0")}; const auto custom = Bindings::make(slots); CHECK(custom); const auto text = serialize(*custom); CHECK(text.starts_with("evo-controls 1\n") && text.find("toggle_capture F1 Keypad0\n") != std::string::npos); CHECK(parse_bindings(text) == *custom); // Comments, blank lines, CRLF and tabs are tolerated; order is free. std::string loose = "# mine\r\nevo-controls 1\r\n\r\n"; for (std::size_t k = action_count; k-- > 0;) { const auto a = static_cast(k); loose += " " + std::string{action_id(a)} + "\t" + std::string{key_name(slots[k].primary)}; if (slots[k].secondary != no_key) loose += " " + std::string{key_name(slots[k].secondary)}; loose += " # note\r\n"; } CHECK(parse_bindings(loose) == *custom); // Malformed inputs are rejected as a whole. const auto without = [&](std::string_view action) { std::string out; std::size_t at = 0; while (at < text.size()) { const auto end = text.find('\n', at); const auto line = text.substr(at, end - at + 1); if (!line.starts_with(std::string{action} + " ")) out += line; at = end + 1; } return out; }; CHECK(refused(parse_bindings(""), BindingError::malformed)); CHECK(refused(parse_bindings("move_up W\n"), BindingError::malformed)); CHECK(refused(parse_bindings("evo-controls 2\n"), BindingError::unsupported_version)); CHECK(refused(parse_bindings("evo-controls 1 extra\n"), BindingError::malformed)); CHECK(refused(parse_bindings(without("pan_down")), BindingError::missing_primary)); CHECK(refused(parse_bindings(text + "move_up W\n"), BindingError::malformed)); CHECK(refused(parse_bindings(text + "jump Space\n"), BindingError::malformed)); CHECK(refused(parse_bindings(without("move_up") + "move_up w\n"), BindingError::malformed)); CHECK(refused(parse_bindings(without("move_up") + "move_up W I O\n"), BindingError::malformed)); CHECK(refused(parse_bindings(without("move_up") + "move_up\n"), BindingError::malformed)); CHECK(refused(parse_bindings(without("move_up") + "move_up A\n"), BindingError::conflict)); CHECK(refused(parse_bindings(without("move_up") + "move_up Escape\n"), BindingError::unbindable_key)); CHECK(refused(parse_bindings(text + std::string{"\0", 1}), BindingError::malformed)); CHECK(refused(parse_bindings(text + "# \xC3\xA9\n"), BindingError::malformed)); CHECK( refused(parse_bindings(std::string(max_bindings_bytes + 1, ' ')), BindingError::too_large)); CHECK(parse_bindings(text + std::string(max_bindings_bytes - text.size(), '\n'))); } void files() { const auto dir = std::filesystem::temp_directory_path() / "evo-bindings-test"; std::filesystem::remove_all(dir); std::filesystem::create_directories(dir); const auto file = dir / "controls-v1.txt"; CHECK(refused(load_bindings(file), BindingError::unreadable)); CHECK(refused(load_bindings(dir), BindingError::unreadable)); auto slots = Bindings::defaults().slots(); slots[0].secondary = key("J"); const auto custom = Bindings::make(slots); CHECK(custom && save_bindings(*custom, file)); CHECK(load_bindings(file) == *custom && !std::filesystem::exists(dir / "controls-v1.txt.tmp")); // Saving again replaces the file. CHECK(save_bindings(Bindings::defaults(), file) && load_bindings(file) == Bindings::defaults()); { std::ofstream big{file, std::ios::binary | std::ios::trunc}; big << std::string(max_bindings_bytes + 1, '#'); } CHECK(refused(load_bindings(file), BindingError::too_large)); { std::ofstream bad{file, std::ios::binary | std::ios::trunc}; bad << "evo-controls 1\nmove_up W\n"; } CHECK(refused(load_bindings(file), BindingError::missing_primary)); CHECK(refused(save_bindings(Bindings::defaults(), dir / "missing" / "controls-v1.txt"), BindingError::write_failed)); std::filesystem::remove_all(dir); } } // namespace int main() try { names_and_defaults(); validation(); editor(); file_format(); files(); std::puts("client binding tests passed"); return 0; } catch (const std::exception& e) { std::fprintf(stderr, "%s\n", e.what()); return 1; }