mirror of
https://github.com/SpeedBreakerProject/speedbreaker.git
synced 2026-10-17 23:01:20 +02:00
ad14799d14
Co-authored-by: love-gamer <340996855+love-gamer@users.noreply.github.com> Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
217 lines
13 KiB
C++
217 lines
13 KiB
C++
// Tests for the Key options (Settings > Controls, user/settings.h): the
|
|
// table, the [keys] names in settings.toml, and what the menu's Set accepts.
|
|
// Links user/settings.cpp (and toml++ from XenonRecomp's vendored copy); no
|
|
// SDL. From the repo root:
|
|
// clang++ -std=c++20 -O2 -Iruntime -Itools/XenonRecomp/thirdparty/tomlplusplus/include \
|
|
// tests/settings_keys_test.cpp runtime/user/settings.cpp -o build/settings_keys_test && build/settings_keys_test
|
|
#include <user/key_names.h>
|
|
#include <user/settings.h>
|
|
|
|
#include <cerrno>
|
|
#include <cmath>
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
#include <filesystem>
|
|
#include <fstream>
|
|
#include <set>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <string_view>
|
|
|
|
#include <unistd.h> // mkdtemp
|
|
|
|
static int g_failures = 0;
|
|
#define CHECK(cond, ...) do { if (!(cond)) { g_failures++; printf(" FAIL %s:%d: %s: ", __FILE__, __LINE__, #cond); printf(__VA_ARGS__); printf("\n"); } } while (0)
|
|
|
|
static std::string ReadAll(const std::filesystem::path& file)
|
|
{
|
|
std::ifstream f(file);
|
|
std::stringstream s;
|
|
s << f.rdbuf();
|
|
return s.str();
|
|
}
|
|
|
|
int main()
|
|
{
|
|
using namespace settings;
|
|
using keynames::Code;
|
|
|
|
// The table: 48 Key options, every one in [keys], on the Controls page,
|
|
// live, shown, with no environment variable and a default the key table
|
|
// knows (none included).
|
|
int keys = 0;
|
|
std::set<std::string> names;
|
|
for (const Option& o : Options())
|
|
{
|
|
if (o.type != Type::Key)
|
|
{
|
|
CHECK(std::string_view(o.table) != "keys", "%s.%s: only Key options live in [keys]", o.table, o.key);
|
|
CHECK(o.env != nullptr, "%s.%s: every other option has an environment variable", o.table, o.key);
|
|
continue;
|
|
}
|
|
keys++;
|
|
CHECK(std::string_view(o.table) == "keys", "%s.%s: a Key option lives in [keys]", o.table, o.key);
|
|
CHECK(o.category == Category::Controls, "%s: on the Controls page", o.key);
|
|
CHECK(o.apply == Apply::Live && !o.hidden, "%s: live and shown", o.key);
|
|
CHECK(o.env == nullptr, "%s: no environment variable", o.key);
|
|
CHECK(names.insert(o.key).second, "%s: one row per key", o.key);
|
|
CHECK(o.defaultValue >= 0 && o.defaultValue == std::floor(o.defaultValue) && keynames::Known(uint16_t(o.defaultValue)),
|
|
"%s: the default is a key, or none", o.key);
|
|
CHECK(o.min == 0 && o.max == 0 && o.step == 0 && o.entries.empty(), "%s: no range", o.key);
|
|
}
|
|
CHECK(keys == 48, "%d Key options", keys);
|
|
CHECK(std::string_view(CategoryName(Category::Controls)) == "Controls", "the category's name");
|
|
|
|
// The defaults: v0.1.4's keys (the arrows steer as well as A and D, and
|
|
// are the D-pad; O/L/K/; are the right stick), plus the left stick
|
|
// click, which had none. In page order, in pairs: the second key is the first's id +
|
|
// 1, named <key>_2, with the row's label.
|
|
struct Default { Id id; const char* key; const char* label; const char* first; const char* second; };
|
|
const Default defaults[] = {
|
|
{ Id::KeyRightTrigger, "right_trigger", "Right Trigger", "w", "none" },
|
|
{ Id::KeyLeftTrigger, "left_trigger", "Left Trigger", "s", "none" },
|
|
{ Id::KeyLeftStickLeft, "left_stick_left", "Left Stick Left", "a", "left" },
|
|
{ Id::KeyLeftStickRight, "left_stick_right", "Left Stick Right", "d", "right" },
|
|
{ Id::KeyLeftStickUp, "left_stick_up", "Left Stick Up", "up", "none" },
|
|
{ Id::KeyLeftStickDown, "left_stick_down", "Left Stick Down", "down", "none" },
|
|
{ Id::KeyA, "a", "A", "space", "none" },
|
|
{ Id::KeyB, "b", "B", "backspace", "none" },
|
|
{ Id::KeyX, "x", "X", "left_shift", "none" },
|
|
{ Id::KeyY, "y", "Y", "left_ctrl", "none" },
|
|
{ Id::KeyLB, "lb", "LB", "q", "none" },
|
|
{ Id::KeyRB, "rb", "RB", "e", "none" },
|
|
{ Id::KeyDpadUp, "dpad_up", "D-pad Up", "up", "none" },
|
|
{ Id::KeyDpadDown, "dpad_down", "D-pad Down", "down", "none" },
|
|
{ Id::KeyDpadLeft, "dpad_left", "D-pad Left", "left", "none" },
|
|
{ Id::KeyDpadRight, "dpad_right", "D-pad Right", "right", "none" },
|
|
{ Id::KeyStart, "start", "Start", "return", "none" },
|
|
{ Id::KeyBack, "back", "Back", "escape", "none" },
|
|
{ Id::KeyRightStickUp, "right_stick_up", "Right Stick Up", "o", "none" },
|
|
{ Id::KeyRightStickDown, "right_stick_down", "Right Stick Down", "l", "none" },
|
|
{ Id::KeyRightStickLeft, "right_stick_left", "Right Stick Left", "k", "none" },
|
|
{ Id::KeyRightStickRight, "right_stick_right", "Right Stick Right", "semicolon", "none" },
|
|
{ Id::KeyLeftStickClick, "left_stick_click", "Left Stick Click", "z", "none" },
|
|
{ Id::KeyRightStickClick, "right_stick_click", "Right Stick Click", "c", "none" },
|
|
};
|
|
size_t previous = size_t(Id::Vibration);
|
|
for (const Default& d : defaults)
|
|
{
|
|
const Option& o = Info(d.id);
|
|
const Option& o2 = Info(Id(size_t(d.id) + 1));
|
|
CHECK(std::string_view(o.key) == d.key, "%s is %s", o.key, d.key);
|
|
CHECK(std::string_view(o2.key) == std::string(d.key) + "_2", "%s: the second key is %s_2", o2.key, d.key);
|
|
CHECK(o2.type == Type::Key, "%s: the second key is a Key option", o2.key);
|
|
CHECK(std::string_view(o.label) == d.label && std::string_view(o2.label) == d.label, "%s: both keys carry the row's label", d.key);
|
|
CHECK(o.defaultValue == double(Code(d.first)), "%s defaults to %s, not %s", o.key, d.first, FormatValue(o.id, o.defaultValue).c_str());
|
|
CHECK(o2.defaultValue == double(Code(d.second)), "%s defaults to %s, not %s", o2.key, d.second, FormatValue(o2.id, o2.defaultValue).c_str());
|
|
CHECK(size_t(d.id) == previous + 1, "%s follows the row before it", o.key);
|
|
previous = size_t(d.id) + 1;
|
|
}
|
|
CHECK(size_t(Id::AsyncShaders) == previous + 1, "Advanced follows the keys");
|
|
CHECK(EnvOverride(Id::KeyA) == nullptr, "nothing overrides a key");
|
|
|
|
// A scratch folder of our own.
|
|
std::string pattern = (std::filesystem::temp_directory_path() / "speedbreaker-keys-XXXXXX").string();
|
|
if (!mkdtemp(pattern.data()))
|
|
{
|
|
printf("can't make a scratch folder: %s\n", strerror(errno));
|
|
return 2;
|
|
}
|
|
const std::filesystem::path dir = pattern;
|
|
const std::filesystem::path file = dir / "settings.toml";
|
|
|
|
// The file: names in, in any case; "none" empties a key; anything else
|
|
// keeps the default, SDL's spelling from the first build included.
|
|
{
|
|
std::ofstream f(file);
|
|
f << "[keys]\n"
|
|
"right_trigger = \"up\"\n"
|
|
"left_trigger = \"Keypad_1\"\n"
|
|
"left_stick_left_2 = \"none\"\n"
|
|
"right_stick_left = \"K\"\n"
|
|
"right_stick_up = \"LEFT_SHIFT\"\n"
|
|
"a = \"Left Shift\"\n"
|
|
"b = 42\n"
|
|
"x = true\n"
|
|
"y = \"\"\n"
|
|
"lb = \"f1\"\n"
|
|
"rb = \"left_gui\"\n";
|
|
}
|
|
CHECK(Load(file), "loads: %s", LastError().c_str());
|
|
CHECK(GetInt(Id::KeyRightTrigger) == Code("up"), "\"up\": %d", GetInt(Id::KeyRightTrigger));
|
|
CHECK(GetInt(Id::KeyLeftTrigger) == Code("keypad_1"), "a token in another case: %d", GetInt(Id::KeyLeftTrigger));
|
|
CHECK(GetInt(Id::KeyLeftStickLeft2) == keynames::kNone, "\"none\" is no key: %d", GetInt(Id::KeyLeftStickLeft2));
|
|
CHECK(GetInt(Id::KeyRightStickLeft) == Code("k"), "\"K\" is k: %d", GetInt(Id::KeyRightStickLeft));
|
|
CHECK(GetInt(Id::KeyRightStickUp) == Code("left_shift"), "\"LEFT_SHIFT\" is left_shift: %d", GetInt(Id::KeyRightStickUp));
|
|
CHECK(GetInt(Id::KeyA) == Code("space"), "SDL's spelling keeps the default");
|
|
CHECK(GetInt(Id::KeyB) == Code("backspace"), "a number keeps the default");
|
|
CHECK(GetInt(Id::KeyX) == Code("left_shift"), "a boolean keeps the default");
|
|
CHECK(GetInt(Id::KeyY) == Code("left_ctrl"), "an empty name keeps the default");
|
|
CHECK(GetInt(Id::KeyLB) == Code("q") && GetInt(Id::KeyRB) == Code("e"), "F1 and Cmd / Windows can't be bound from the file");
|
|
CHECK(GetInt(Id::KeyStart) == Code("return") && GetInt(Id::KeyLeftStickRight2) == Code("right"), "a missing key keeps the default");
|
|
CHECK(IsDefault(Id::KeyLB) && !IsDefault(Id::KeyRightTrigger) && !IsDefault(Id::KeyLeftStickLeft2), "IsDefault follows the file");
|
|
|
|
// Shown in the log and the bug report by name.
|
|
CHECK(FormatValue(Id::KeyRightTrigger, GetValue(Id::KeyRightTrigger)) == "up", "FormatValue: %s",
|
|
FormatValue(Id::KeyRightTrigger, GetValue(Id::KeyRightTrigger)).c_str());
|
|
CHECK(FormatValue(Id::KeyX, Code("left_shift")) == "left_shift" && FormatValue(Id::KeyX, 0) == "none", "a token, or none");
|
|
CHECK(FormatValue(Id::KeyA, 1) == "?" && FormatValue(Id::KeyA, 227) == "?" && FormatValue(Id::KeyA, 1e9) == "?" &&
|
|
FormatValue(Id::KeyA, NAN) == "?" && FormatValue(Id::KeyA, -1) == "?", "not a key: ?");
|
|
|
|
// Set: a key of the table, or none; anything else is Invalid.
|
|
CHECK(Set(Id::KeyA, Code("return")) == SetResult::Applied, "a key");
|
|
CHECK(Set(Id::KeyA, Code("return")) == SetResult::Unchanged, "the same key again");
|
|
CHECK(Set(Id::KeyA, keynames::kNone) == SetResult::Applied && GetInt(Id::KeyA) == 0, "none");
|
|
CHECK(Set(Id::KeyA2, Code("return")) == SetResult::Applied && Set(Id::KeyA, Code("return")) == SetResult::Applied,
|
|
"the same key in both cells of a row is allowed");
|
|
CHECK(Set(Id::KeyA2, keynames::kNone) == SetResult::Applied, "and so is none in both");
|
|
CHECK(Set(Id::KeyA, 1) == SetResult::Invalid, "1 is no key");
|
|
CHECK(Set(Id::KeyA, 58) == SetResult::Invalid, "F1 is no key");
|
|
CHECK(Set(Id::KeyA, 227) == SetResult::Invalid, "Left GUI is no key");
|
|
CHECK(Set(Id::KeyA, keynames::kUnknown) == SetResult::Invalid && Set(Id::KeyA, 1e9) == SetResult::Invalid &&
|
|
Set(Id::KeyA, -1) == SetResult::Invalid, "out of the table");
|
|
CHECK(Set(Id::KeyA, double(Code("return")) + 0.5) == SetResult::Invalid, "not a whole number");
|
|
CHECK(Set(Id::KeyA, NAN) == SetResult::Invalid, "NaN");
|
|
CHECK(GetInt(Id::KeyA) == Code("return"), "invalid sets change nothing: %d", GetInt(Id::KeyA));
|
|
CHECK(StepValue(Id::KeyA, Code("return"), 1) == double(Code("return")) && StepValue(Id::KeyA, Code("return"), -1) == double(Code("return")),
|
|
"Left and Right do nothing to a key");
|
|
CHECK(!IsDefault(Id::KeyA) && Reset(Id::KeyA) == SetResult::Applied && IsDefault(Id::KeyA) && GetInt(Id::KeyA) == Code("space"), "Reset");
|
|
|
|
// Save: every key by name, the comment, no environment variable; and
|
|
// what it wrote loads back.
|
|
CHECK(Save(file), "saves: %s", LastError().c_str());
|
|
std::string text = ReadAll(file);
|
|
size_t at = text.find("\n[keys]\n"), advanced = text.find("\n[advanced]\n");
|
|
CHECK(at != std::string::npos && advanced != std::string::npos && at < advanced, "[keys] before [advanced]");
|
|
std::string section = at == std::string::npos ? "" : text.substr(at, advanced == std::string::npos ? std::string::npos : advanced - at);
|
|
CHECK(section.find("right_trigger = \"up\"\n") != std::string::npos, "saved by name");
|
|
CHECK(section.find("left_trigger = \"keypad_1\"\n") != std::string::npos, "the table's case, not the file's");
|
|
CHECK(section.find("left_stick_left_2 = \"none\"\n") != std::string::npos, "an emptied key");
|
|
CHECK(section.find("right_stick_left = \"k\"\n") != std::string::npos, "lower case");
|
|
CHECK(section.find("right_stick_right = \"semicolon\"\n") != std::string::npos, "a symbol key by its name");
|
|
CHECK(section.find("right_stick_up = \"left_shift\"\n") != std::string::npos, "a modifier");
|
|
CHECK(section.find("left_stick_left = \"a\"\n") != std::string::npos && section.find("dpad_left_2 = \"none\"\n") != std::string::npos,
|
|
"defaults are written too, both keys");
|
|
CHECK(section.find("# A key name such as \"w\"") != std::string::npos, "the comment says what goes here");
|
|
CHECK(section.find("NFSMW_") == std::string::npos, "no environment variable on a key");
|
|
CHECK(text.find("(NFSMW_VIBRATION)") != std::string::npos, "the other options keep theirs");
|
|
CHECK(Load(file), "loads what it saved: %s", LastError().c_str());
|
|
CHECK(GetInt(Id::KeyRightTrigger) == Code("up") && GetInt(Id::KeyLeftTrigger) == Code("keypad_1") &&
|
|
GetInt(Id::KeyRightStickUp) == Code("left_shift") && GetInt(Id::KeyLeftStickLeft2) == 0, "round trip");
|
|
CHECK(!Dirty(), "nothing changed since the save");
|
|
|
|
// The keys SDL names by a symbol are words here: nothing to escape.
|
|
CHECK(Set(Id::KeyA, Code("backslash")) == SetResult::Applied && Set(Id::KeyB, Code("apostrophe")) == SetResult::Applied,
|
|
"the backslash and apostrophe keys are keys");
|
|
CHECK(Save(file), "saves them: %s", LastError().c_str());
|
|
text = ReadAll(file);
|
|
CHECK(text.find("\na = \"backslash\"\n") != std::string::npos && text.find("\nb = \"apostrophe\"\n") != std::string::npos, "by name");
|
|
CHECK(Load(file), "and the file still parses: %s", LastError().c_str());
|
|
CHECK(GetInt(Id::KeyA) == Code("backslash") && GetInt(Id::KeyB) == Code("apostrophe"), "round trip: %d %d", GetInt(Id::KeyA), GetInt(Id::KeyB));
|
|
CHECK(GetInt(Id::KeyRightTrigger) == Code("up") && GetInt(Id::MasterVolume) == 100, "and the rest of the file survived");
|
|
std::filesystem::remove_all(dir);
|
|
|
|
printf("%s (%d failures)\n", g_failures ? "FAILED" : "passed", g_failures);
|
|
return g_failures ? 1 : 0;
|
|
}
|