124 lines
4.6 KiB
C++
124 lines
4.6 KiB
C++
// Standalone tests for shell/package/package_rollback — no REAPER, no framework.
|
|
// Pins the discriminator's mechanics: a file is recorded only when this journal's
|
|
// own write landed it, a pre-existing destination is refused untouched, and
|
|
// rollback deletes exactly the recorded set — a bystander file beside them stays,
|
|
// and a vanished file is tolerated rather than failed.
|
|
|
|
#include "../src/shell/package/package_rollback.h"
|
|
|
|
#include <cstdio>
|
|
#include <filesystem>
|
|
#include <fstream>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
using namespace reasampler;
|
|
namespace fs = std::filesystem;
|
|
|
|
static int g_fail = 0;
|
|
#define CHECK(cond) do { if(!(cond)) { \
|
|
std::printf("FAIL line %d: %s\n", __LINE__, #cond); ++g_fail; } } while(0)
|
|
|
|
static std::vector<std::uint8_t> patternBytes(std::size_t n, std::uint8_t seed) {
|
|
std::vector<std::uint8_t> v(n);
|
|
for (std::size_t i = 0; i < n; ++i)
|
|
v[i] = static_cast<std::uint8_t>(seed + i * 7u);
|
|
return v;
|
|
}
|
|
|
|
static void writeScratchFile(const std::string& path,
|
|
const std::vector<std::uint8_t>& bytes) {
|
|
std::ofstream f(path, std::ios::binary | std::ios::trunc);
|
|
f.write(reinterpret_cast<const char*>(bytes.data()),
|
|
static_cast<std::streamsize>(bytes.size()));
|
|
}
|
|
|
|
static std::vector<std::uint8_t> readAll(const std::string& path) {
|
|
std::ifstream f(path, std::ios::binary);
|
|
return std::vector<std::uint8_t>(std::istreambuf_iterator<char>(f),
|
|
std::istreambuf_iterator<char>());
|
|
}
|
|
|
|
static void testLandRecordsOnSuccessOnly() {
|
|
LandedFileJournal journal;
|
|
const std::string path = "rb_land.bin";
|
|
const std::vector<std::uint8_t> bytes = patternBytes(32, 1);
|
|
CHECK(journal.writeLandedFile(path, PayloadBuffer(bytes)));
|
|
CHECK(readAll(path) == bytes);
|
|
CHECK(journal.landedPaths() == (std::vector<std::string>{path}));
|
|
CHECK(!fs::exists(path + ".rsbanktmp"));
|
|
journal.rollback();
|
|
CHECK(!fs::exists(path));
|
|
}
|
|
|
|
static void testExistingDestinationRefusedUntouched() {
|
|
LandedFileJournal journal;
|
|
const std::string path = "rb_existing.bin";
|
|
const std::vector<std::uint8_t> original = patternBytes(16, 0x60);
|
|
writeScratchFile(path, original);
|
|
|
|
CHECK(!journal.writeLandedFile(path, PayloadBuffer(patternBytes(8, 1))));
|
|
CHECK(readAll(path) == original); // never overwritten
|
|
CHECK(journal.empty()); // a refused write is not recorded
|
|
|
|
const RollbackResult result = journal.rollback();
|
|
CHECK(result.deletedCount == 0);
|
|
CHECK(fs::exists(path)); // rollback cannot touch a file it did not write
|
|
std::error_code ec;
|
|
fs::remove(path, ec);
|
|
}
|
|
|
|
static void testEmptyPayloadRefused() {
|
|
LandedFileJournal journal;
|
|
CHECK(!journal.writeLandedFile("rb_empty.bin", PayloadBuffer{}));
|
|
CHECK(!fs::exists("rb_empty.bin"));
|
|
CHECK(journal.empty());
|
|
}
|
|
|
|
static void testRollbackDeletesExactlyTheRecordedSet() {
|
|
LandedFileJournal journal;
|
|
CHECK(journal.writeLandedFile("rb_a.bin", PayloadBuffer(patternBytes(8, 1))));
|
|
CHECK(journal.writeLandedFile("rb_c.bin", PayloadBuffer(patternBytes(8, 2))));
|
|
writeScratchFile("rb_bystander.bin", patternBytes(8, 3)); // not journal-written
|
|
|
|
const RollbackResult result = journal.rollback();
|
|
CHECK(result.deletedCount == 2);
|
|
CHECK(result.alreadyAbsentCount == 0);
|
|
CHECK(result.failedCount == 0);
|
|
CHECK(!fs::exists("rb_a.bin"));
|
|
CHECK(!fs::exists("rb_c.bin"));
|
|
CHECK(fs::exists("rb_bystander.bin")); // exactly the given files, nothing else
|
|
CHECK(journal.empty());
|
|
|
|
const RollbackResult second = journal.rollback(); // cleared: a no-op
|
|
CHECK(second.deletedCount == 0);
|
|
CHECK(fs::exists("rb_bystander.bin"));
|
|
std::error_code ec;
|
|
fs::remove("rb_bystander.bin", ec);
|
|
}
|
|
|
|
static void testVanishedFileIsToleratedNotFailed() {
|
|
LandedFileJournal journal;
|
|
CHECK(journal.writeLandedFile("rb_gone.bin", PayloadBuffer(patternBytes(8, 1))));
|
|
std::error_code ec;
|
|
fs::remove("rb_gone.bin", ec); // vanished between land and rollback
|
|
CHECK(!ec);
|
|
|
|
const RollbackResult result = journal.rollback();
|
|
CHECK(result.deletedCount == 0);
|
|
CHECK(result.alreadyAbsentCount == 1);
|
|
CHECK(result.failedCount == 0);
|
|
}
|
|
|
|
int main() {
|
|
testLandRecordsOnSuccessOnly();
|
|
testExistingDestinationRefusedUntouched();
|
|
testEmptyPayloadRefused();
|
|
testRollbackDeletesExactlyTheRecordedSet();
|
|
testVanishedFileIsToleratedNotFailed();
|
|
|
|
if (g_fail == 0) std::printf("package_rollback: all tests passed\n");
|
|
else std::printf("package_rollback: %d CHECK(s) FAILED\n", g_fail);
|
|
return g_fail == 0 ? 0 : 1;
|
|
}
|