336 lines
13 KiB
C++
336 lines
13 KiB
C++
// Differential test of MplexCopyMode against tai.py's MplexCopyMode. Scenario file made by
|
|
// mplex_copy_gen.py (tmux 3.6 fixtures from test_tai.py, every default copy-mode binding, seeded fuzz);
|
|
// every step's full state line (cursor, scroll, selection, mark, search, copies, messages, render checksum)
|
|
// must match the Python oracle byte for byte. Fixture scenarios also carry the value tmux 3.6 produced.
|
|
//
|
|
// Every scenario runs against a real MplexServer (not listening, throwaway TAI_HOME) with one real session, window,
|
|
// pane and attached MplexClientConn; key presses go through the real run_binding and the real command set, and
|
|
// prompt answers through the real MplexPrompt. Linked against all real sources, no stubs.
|
|
// Build and run: tests/mplex_copy_run.sh (writes only under taicpp/build/).
|
|
#include <algorithm>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <filesystem>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <tuple>
|
|
#include <vector>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include "mplex_args.h"
|
|
#include "mplex_canvas.h"
|
|
#include "mplex_commands.h"
|
|
#include "mplex_clientconn.h"
|
|
#include "mplex_config.h"
|
|
#include "mplex_copymode.h"
|
|
#include "mplex_renderer.h"
|
|
#include "mplex_server.h"
|
|
|
|
using namespace detz::mplex;
|
|
|
|
|
|
namespace {
|
|
|
|
std::string esc(const std::string& text) {
|
|
std::string out;
|
|
for (char ch : text) {
|
|
if (ch == '%') out += "%25";
|
|
else if (ch == '\t') out += "%09";
|
|
else if (ch == '\n') out += "%0A";
|
|
else if (ch == '\r') out += "%0D";
|
|
else out += ch;
|
|
}
|
|
return out;
|
|
}
|
|
|
|
std::string unesc(const std::string& text) {
|
|
std::string out;
|
|
for (size_t i = 0; i < text.size(); ++i) {
|
|
if (text[i] == '%' && i + 2 < text.size()) {
|
|
out += static_cast<char>(std::stoi(text.substr(i + 1, 2), nullptr, 16));
|
|
i += 2;
|
|
} else {
|
|
out += text[i];
|
|
}
|
|
}
|
|
return out;
|
|
}
|
|
|
|
std::vector<std::string> split_tabs(const std::string& line) {
|
|
std::vector<std::string> out;
|
|
size_t start = 0;
|
|
while (true) {
|
|
size_t at = line.find('\t', start);
|
|
if (at == std::string::npos) {
|
|
out.push_back(line.substr(start));
|
|
break;
|
|
}
|
|
out.push_back(line.substr(start, at - start));
|
|
start = at + 1;
|
|
}
|
|
return out;
|
|
}
|
|
|
|
uint32_t crc32(const std::string& data) {
|
|
static uint32_t table[256];
|
|
static bool ready = false;
|
|
if (!ready) {
|
|
for (uint32_t n = 0; n < 256; ++n) {
|
|
uint32_t c = n;
|
|
for (int k = 0; k < 8; ++k) c = (c & 1) ? 0xEDB88320u ^ (c >> 1) : c >> 1;
|
|
table[n] = c;
|
|
}
|
|
ready = true;
|
|
}
|
|
uint32_t crc = 0xFFFFFFFFu;
|
|
for (unsigned char byte : data) crc = table[(crc ^ byte) & 0xFF] ^ (crc >> 8);
|
|
return crc ^ 0xFFFFFFFFu;
|
|
}
|
|
|
|
std::string hex8(uint32_t value) {
|
|
char buf[16];
|
|
std::snprintf(buf, sizeof buf, "%08x", value);
|
|
return buf;
|
|
}
|
|
|
|
std::string digest(MplexCopyMode& mode, MplexClientConn& client) {
|
|
ModeBlock block = mode.render(client);
|
|
std::string parts;
|
|
for (const Row& row : block.grid) {
|
|
for (const Cell& cell : row) {
|
|
parts += to_utf8(cell.ch);
|
|
parts += "|" + color_sgr(cell.fg) + "|" + color_sgr(cell.bg) + "|" + std::to_string(cell.attr) + ";";
|
|
}
|
|
parts += "\n";
|
|
}
|
|
if (block.cursor) parts += "(" + std::to_string(block.cursor->first) + ", " + std::to_string(block.cursor->second) + ")";
|
|
else parts += "None";
|
|
return hex8(crc32(parts));
|
|
}
|
|
|
|
std::string pair_text(const std::optional<MplexCopyMode::Point>& value) {
|
|
if (!value) return "-";
|
|
return std::to_string(value->first) + "," + std::to_string(value->second);
|
|
}
|
|
|
|
std::string search_text(const std::optional<MplexPane::SearchState>& value) {
|
|
if (!value) return "-";
|
|
return esc(value->text) + "," + (value->forward ? "1" : "0") + "," + (value->literal ? "1" : "0");
|
|
}
|
|
|
|
std::string state_line(MplexCopyMode& mode, const std::shared_ptr<MplexPane>& pane, MplexServer& server,
|
|
MplexClientConn& client, const std::string& err, bool closed) {
|
|
std::string top = server.buffers.empty() ? "" : server.buffers[0].data;
|
|
std::string shown = client.message ? esc(client.message->first) : "-";
|
|
std::string prompt = client.prompt ? esc(to_utf8(client.prompt->label + client.prompt->text)) : "-";
|
|
std::vector<std::string> f = {
|
|
"E", std::to_string(mode.cx), std::to_string(mode.cy), std::to_string(mode.oy), std::to_string(mode.hist()),
|
|
pair_text(mode.anchor), pair_text(mode.mark), mode.rect ? "1" : "0", mode.line_select ? "1" : "0",
|
|
search_text(mode.search), search_text(pane->last_search), mode.show_position ? "1" : "0", closed ? "1" : "0",
|
|
std::to_string(server.buffers.size()), esc(top), std::to_string(server.messages.size()),
|
|
server.messages.empty() ? "-" : esc(server.messages.back().second), std::to_string(mode.count),
|
|
std::to_string(mode.lastcx), std::to_string(mode.lastsx), esc(err), digest(mode, client),
|
|
std::to_string(pane->history_size()), std::to_string(pane->prefix_count), shown, prompt};
|
|
std::string out;
|
|
for (size_t i = 0; i < f.size(); ++i) out += (i ? "\t" : "") + f[i];
|
|
return out;
|
|
}
|
|
|
|
int failures = 0;
|
|
int shown = 0;
|
|
long checked_steps = 0;
|
|
long checked_scenarios = 0;
|
|
long tmux_checks = 0;
|
|
long live_total = 0;
|
|
long live_diff = 0;
|
|
|
|
void fail(const std::string& scenario, const std::string& what, const std::string& want, const std::string& got) {
|
|
++failures;
|
|
if (shown < 25) {
|
|
++shown;
|
|
std::cerr << "MISMATCH " << scenario << " " << what << "\n python: " << want << "\n c++ : " << got << "\n";
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
|
|
int main(int argc, char** argv) {
|
|
if (argc < 2) {
|
|
std::cerr << "usage: mplex_copy_test SCENARIOS\n";
|
|
return 2;
|
|
}
|
|
// throwaway TAI_HOME next to the scenario file (under taicpp/build/), removed at the end
|
|
std::string scenario_path = argv[1];
|
|
size_t slash = scenario_path.rfind('/');
|
|
std::string home_template = (slash == std::string::npos ? std::string(".") : scenario_path.substr(0, slash)) + "/home.XXXXXX";
|
|
if (mkdtemp(home_template.data()) == nullptr) {
|
|
std::cerr << "cannot create a throwaway TAI_HOME\n";
|
|
return 2;
|
|
}
|
|
const std::string home = home_template;
|
|
std::ifstream in(argv[1]);
|
|
std::vector<std::string> lines;
|
|
for (std::string line; std::getline(in, line);) lines.push_back(line);
|
|
size_t at = 0;
|
|
// command table
|
|
{
|
|
auto fields = split_tabs(lines.at(at++));
|
|
std::vector<std::string> want(fields.begin() + 1, fields.end());
|
|
if (want != MplexCopyMode::command_names()) {
|
|
std::cerr << "command_names() differs from the Python c_* methods\n";
|
|
++failures;
|
|
}
|
|
}
|
|
while (at < lines.size()) {
|
|
auto s = split_tabs(lines[at++]);
|
|
if (s.empty() || s[0] != "S") {
|
|
std::cerr << "scenario file out of step at line " << at << "\n";
|
|
return 2;
|
|
}
|
|
std::string name = unesc(s[1]);
|
|
int rows = std::stoi(s[2]), cols = std::stoi(s[3]), history = std::stoi(s[4]);
|
|
std::string keys = s[5];
|
|
std::string content = unesc(s[6]);
|
|
bool view = s[7] == "1";
|
|
bool exit_at_bottom = s[8] == "1";
|
|
MplexServer server(home);
|
|
server.options->set("mode-keys", keys);
|
|
auto pane = std::make_shared<MplexPane>(1, cols, rows, history, "/tmp");
|
|
std::vector<std::string> view_lines;
|
|
auto replace_nl = [](const std::string& text) {
|
|
std::string out;
|
|
for (char ch : text) {
|
|
if (ch == '\n') out += "\r\n";
|
|
else out += ch;
|
|
}
|
|
return out;
|
|
};
|
|
std::shared_ptr<MplexCopyMode> mode;
|
|
if (view) {
|
|
size_t start = 0;
|
|
while (true) {
|
|
size_t nl = content.find('\n', start);
|
|
if (nl == std::string::npos) {
|
|
view_lines.push_back(content.substr(start));
|
|
break;
|
|
}
|
|
view_lines.push_back(content.substr(start, nl - start));
|
|
start = nl + 1;
|
|
}
|
|
mode = std::make_shared<MplexCopyMode>(&server, pane, &view_lines);
|
|
} else {
|
|
pane->feed(replace_nl(content));
|
|
mode = std::make_shared<MplexCopyMode>(&server, pane, nullptr, false, exit_at_bottom);
|
|
}
|
|
pane->push_mode(mode);
|
|
// one real session and window holding the pane, one attached client (see make_fixture in the generator)
|
|
auto session = std::make_shared<MplexSession>(server.next_id("session"), "0", server.options, "/", MplexPane::EnvList{});
|
|
session->size = std::make_pair(pane->w, pane->h + 1);
|
|
server.sessions.set(session->id, session);
|
|
auto window = std::make_shared<MplexWindow>(server.next_id("window"), "w", pane->w, pane->h, &session->options);
|
|
window->root = std::make_shared<MplexLayoutNode>("pane", pane, pane->w, pane->h);
|
|
window->active = pane;
|
|
pane->set_window(window);
|
|
server.panes.set(pane->id, pane);
|
|
server.register_window(session, window, 0, true);
|
|
auto client = std::make_shared<MplexClientConn>(&server, -1, server.next_id("client"));
|
|
client->session = session;
|
|
client->attached = true;
|
|
server.clients.push_back(client);
|
|
++checked_scenarios;
|
|
{
|
|
auto e0 = split_tabs(lines[at++]);
|
|
std::string got = std::to_string(mode->cx) + " " + std::to_string(mode->cy) + " " + std::to_string(mode->oy) + " " +
|
|
std::to_string(mode->hist()) + " " + mode->name + " " + digest(*mode, *client);
|
|
std::string want = e0[1] + " " + e0[2] + " " + e0[3] + " " + e0[4] + " " + e0[5] + " " + e0[6];
|
|
if (got != want) fail(name, "initial", want, got);
|
|
}
|
|
std::string last_state_cursor;
|
|
std::vector<std::string> tmux_line;
|
|
while (lines[at] != "X") {
|
|
auto step = split_tabs(lines[at++]);
|
|
std::string err;
|
|
if (step[0] == "T") {
|
|
tmux_line = step;
|
|
continue;
|
|
}
|
|
if (step[0] == "C") {
|
|
int count = std::stoi(step[1]);
|
|
std::vector<std::string> words;
|
|
for (size_t i = 2; i < step.size(); ++i) words.push_back(unesc(step[i]));
|
|
pane->prefix_count = count;
|
|
try {
|
|
mode->command(words[0], std::vector<std::string>(words.begin() + 1, words.end()), nullptr);
|
|
} catch (const MplexError& exc) {
|
|
err = std::string("M:") + exc.what();
|
|
} catch (const std::exception& exc) {
|
|
err = std::string("X:") + exc.what();
|
|
}
|
|
} else if (step[0] == "K") {
|
|
try {
|
|
mode->key(unesc(step[1]), Bytes(), *client);
|
|
} catch (const MplexError& exc) {
|
|
err = std::string("M:") + exc.what();
|
|
} catch (const std::exception& exc) {
|
|
err = std::string("X:") + exc.what();
|
|
}
|
|
} else if (step[0] == "Y" || step[0] == "Z") {
|
|
try {
|
|
if (step[0] == "Z") {
|
|
if (client->prompt) client->prompt->key(server, *client, "Escape", "\x1b");
|
|
} else if (client->prompt) {
|
|
UStr typed = to_ustr(unesc(step[1]));
|
|
for (wchar_t ch : typed) {
|
|
if (!client->prompt) break;
|
|
client->prompt->key(server, *client, ch == L' ' ? std::string("Space") : to_utf8(ch), to_utf8(ch));
|
|
}
|
|
if (client->prompt) client->prompt->key(server, *client, "Enter", "\r");
|
|
}
|
|
} catch (const MplexError& exc) {
|
|
err = std::string("M:") + exc.what();
|
|
} catch (const std::exception& exc) {
|
|
err = std::string("X:") + exc.what();
|
|
}
|
|
} else if (step[0] == "F") {
|
|
pane->feed(replace_nl(unesc(step[1])));
|
|
} else if (step[0] == "R") {
|
|
pane->place(0, 0, std::stoi(step[2]), std::stoi(step[1]));
|
|
} else {
|
|
std::cerr << "bad step line " << lines[at - 1] << "\n";
|
|
return 2;
|
|
}
|
|
bool closed = std::find(pane->modes.begin(), pane->modes.end(), mode) == pane->modes.end();
|
|
std::string got = state_line(*mode, pane, server, *client, err, closed);
|
|
std::string want = lines[at++];
|
|
++checked_steps;
|
|
if (got != want) fail(name, "after step [" + lines[at - 2] + "]", want, got);
|
|
last_state_cursor = std::to_string(mode->cx) + " " + std::to_string(mode->cy) + " " + std::to_string(mode->oy);
|
|
}
|
|
++at; // "X"
|
|
if (!tmux_line.empty() && tmux_line[1] == "livecursor") {
|
|
++live_total;
|
|
if (last_state_cursor != tmux_line[2]) {
|
|
++live_diff;
|
|
if (live_diff <= 12)
|
|
std::cout << "tmux live differs: " << name << " tmux=" << tmux_line[2] << " mplex=" << last_state_cursor << "\n";
|
|
}
|
|
} else if (!tmux_line.empty()) {
|
|
auto& t = tmux_line;
|
|
++tmux_checks;
|
|
if (t[1] == "cursor") {
|
|
if (last_state_cursor != t[2]) fail(name, "tmux cursor", t[2], last_state_cursor);
|
|
} else {
|
|
std::string got = server.top_buffer_text();
|
|
if (got != unesc(t[2])) fail(name, "tmux copied text", unesc(t[2]), got);
|
|
}
|
|
}
|
|
}
|
|
std::cout << "scenarios=" << checked_scenarios << " steps=" << checked_steps << " tmux_fixture_checks=" << tmux_checks
|
|
<< " failures=" << failures << " tmux_live=" << live_total << " tmux_live_differ=" << live_diff << "\n";
|
|
std::filesystem::remove_all(home);
|
|
return failures ? 1 : 0;
|
|
}
|