113 lines
3.3 KiB
C++
113 lines
3.3 KiB
C++
#include "PersistenceWriter.h"
|
|
|
|
#include <filesystem>
|
|
#include <iostream>
|
|
#include <mutex>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
namespace
|
|
{
|
|
int gFailures = 0;
|
|
|
|
void Expect(bool condition, const char* message)
|
|
{
|
|
if (condition)
|
|
return;
|
|
|
|
std::cerr << "FAIL: " << message << "\n";
|
|
++gFailures;
|
|
}
|
|
|
|
PersistenceSnapshot MakeRuntimeSnapshot(const std::string& contents)
|
|
{
|
|
PersistenceSnapshot snapshot;
|
|
snapshot.targetKind = PersistenceTargetKind::RuntimeState;
|
|
snapshot.targetPath = std::filesystem::temp_directory_path() / "video-shader-persistence-writer-test.json";
|
|
snapshot.contents = contents;
|
|
snapshot.reason = "test";
|
|
snapshot.debounceKey = "runtime-state";
|
|
snapshot.debounceAllowed = true;
|
|
return snapshot;
|
|
}
|
|
|
|
void TestDebouncedRequestsCoalesceToNewestSnapshot()
|
|
{
|
|
std::mutex mutex;
|
|
std::vector<PersistenceSnapshot> writtenSnapshots;
|
|
PersistenceWriter writer(
|
|
std::chrono::milliseconds(1000),
|
|
[&](const PersistenceSnapshot& snapshot, std::string&) {
|
|
std::lock_guard<std::mutex> lock(mutex);
|
|
writtenSnapshots.push_back(snapshot);
|
|
return true;
|
|
});
|
|
|
|
std::string error;
|
|
Expect(writer.EnqueueSnapshot(MakeRuntimeSnapshot("first"), error), "first debounced snapshot enqueues");
|
|
Expect(writer.EnqueueSnapshot(MakeRuntimeSnapshot("second"), error), "second debounced snapshot enqueues");
|
|
|
|
PersistenceWriterMetrics metrics = writer.GetMetrics();
|
|
Expect(metrics.pendingCount == 1, "debounced snapshots share one pending slot");
|
|
Expect(metrics.enqueuedCount == 1, "first debounced snapshot counts as enqueue");
|
|
Expect(metrics.coalescedCount == 1, "second debounced snapshot counts as coalesced");
|
|
|
|
writer.StopAndFlush();
|
|
|
|
{
|
|
std::lock_guard<std::mutex> lock(mutex);
|
|
Expect(writtenSnapshots.size() == 1, "flush writes one coalesced snapshot");
|
|
Expect(!writtenSnapshots.empty() && writtenSnapshots[0].contents == "second", "coalesced writer keeps newest snapshot");
|
|
}
|
|
|
|
metrics = writer.GetMetrics();
|
|
Expect(metrics.pendingCount == 0, "flush drains pending debounced snapshot");
|
|
Expect(metrics.writtenCount == 1, "flush records one successful write");
|
|
}
|
|
|
|
void TestImmediateRequestsAreNotCoalesced()
|
|
{
|
|
std::mutex mutex;
|
|
std::vector<PersistenceSnapshot> writtenSnapshots;
|
|
PersistenceWriter writer(
|
|
std::chrono::milliseconds(1000),
|
|
[&](const PersistenceSnapshot& snapshot, std::string&) {
|
|
std::lock_guard<std::mutex> lock(mutex);
|
|
writtenSnapshots.push_back(snapshot);
|
|
return true;
|
|
});
|
|
|
|
PersistenceSnapshot first = MakeRuntimeSnapshot("first");
|
|
first.debounceAllowed = false;
|
|
PersistenceSnapshot second = MakeRuntimeSnapshot("second");
|
|
second.debounceAllowed = false;
|
|
|
|
std::string error;
|
|
Expect(writer.EnqueueSnapshot(first, error), "first immediate snapshot enqueues");
|
|
Expect(writer.EnqueueSnapshot(second, error), "second immediate snapshot enqueues");
|
|
writer.StopAndFlush();
|
|
|
|
{
|
|
std::lock_guard<std::mutex> lock(mutex);
|
|
Expect(writtenSnapshots.size() == 2, "immediate snapshots are written independently");
|
|
Expect(writtenSnapshots.size() == 2 && writtenSnapshots[0].contents == "first" && writtenSnapshots[1].contents == "second",
|
|
"immediate snapshots preserve order");
|
|
}
|
|
}
|
|
}
|
|
|
|
int main()
|
|
{
|
|
TestDebouncedRequestsCoalesceToNewestSnapshot();
|
|
TestImmediateRequestsAreNotCoalesced();
|
|
|
|
if (gFailures != 0)
|
|
{
|
|
std::cerr << gFailures << " persistence writer test(s) failed.\n";
|
|
return 1;
|
|
}
|
|
|
|
std::cout << "Persistence writer tests passed.\n";
|
|
return 0;
|
|
}
|