Stage 1 rewrite

tests/RenderCadenceControllerTests.cpp

@@ -0,0 +1,172 @@
+#include "RenderCadenceController.h"
+
+#include <chrono>
+#include <iostream>
+#include <string>
+
+namespace
+{
+int gFailures = 0;
+
+using Clock = RenderCadenceController::Clock;
+using Duration = RenderCadenceController::Duration;
+using TimePoint = RenderCadenceController::TimePoint;
+
+void Expect(bool condition, const char* message)
+{
+	if (condition)
+		return;
+
+	std::cerr << "FAIL: " << message << "\n";
+	++gFailures;
+}
+
+Duration Ms(int64_t value)
+{
+	return std::chrono::duration_cast<Duration>(std::chrono::milliseconds(value));
+}
+
+void TestExactCadenceAdvancesFrameIndexAndNextTick()
+{
+	RenderCadenceController controller;
+	const TimePoint start = Clock::time_point(Ms(1000));
+	controller.Configure(Ms(20), start);
+
+	RenderCadenceDecision first = controller.Tick(start);
+	Expect(first.action == RenderCadenceAction::Render, "first exact tick renders");
+	Expect(first.frameIndex == 0, "first exact tick renders frame zero");
+	Expect(first.renderTargetTime == start, "first exact target is configured start");
+	Expect(first.nextRenderTime == start + Ms(20), "first exact tick advances next render time");
+	Expect(first.skippedTicks == 0, "first exact tick skips no ticks");
+	Expect(first.lateness == Duration::zero(), "first exact tick records no lateness");
+
+	RenderCadenceDecision second = controller.Tick(start + Ms(20));
+	Expect(second.action == RenderCadenceAction::Render, "second exact tick renders");
+	Expect(second.frameIndex == 1, "second exact tick renders frame one");
+	Expect(controller.NextFrameIndex() == 2, "controller tracks next frame index after exact ticks");
+	Expect(controller.Metrics().renderedFrameCount == 2, "metrics count exact rendered frames");
+}
+
+void TestEarlyTickWaitsWithoutAdvancing()
+{
+	RenderCadenceController controller;
+	const TimePoint start = Clock::time_point(Ms(0));
+	controller.Configure(Ms(20), start);
+	(void)controller.Tick(start);
+
+	RenderCadenceDecision decision = controller.Tick(start + Ms(10));
+	Expect(decision.action == RenderCadenceAction::Wait, "early tick waits");
+	Expect(decision.waitDuration == Ms(10), "early tick reports wait duration");
+	Expect(decision.frameIndex == 1, "early tick reports next pending frame");
+	Expect(controller.NextFrameIndex() == 1, "early tick does not advance frame index");
+	Expect(controller.NextRenderTime() == start + Ms(20), "early tick does not advance next render time");
+}
+
+void TestSlightLatenessRendersAndRecordsMetrics()
+{
+	RenderCadencePolicy policy;
+	policy.skipThresholdFrames = 3.0;
+
+	RenderCadenceController controller;
+	const TimePoint start = Clock::time_point(Ms(0));
+	controller.Configure(Ms(20), start, policy);
+
+	RenderCadenceDecision decision = controller.Tick(start + Ms(5));
+	Expect(decision.action == RenderCadenceAction::Render, "slightly late tick renders");
+	Expect(decision.frameIndex == 0, "slightly late tick keeps pending frame");
+	Expect(decision.skippedTicks == 0, "slightly late tick skips no ticks");
+	Expect(decision.lateness == Ms(5), "slightly late tick reports lateness");
+	Expect(controller.Metrics().lateFrameCount == 1, "metrics count late rendered frame");
+	Expect(controller.Metrics().lastLateness == Ms(5), "metrics keep last lateness");
+	Expect(controller.Metrics().maxLateness == Ms(5), "metrics keep max lateness");
+}
+
+void TestLargeLatenessSkipsTicksAccordingToPolicy()
+{
+	RenderCadencePolicy policy;
+	policy.skipLateTicks = true;
+	policy.skipThresholdFrames = 2.0;
+	policy.maxSkippedTicksPerDecision = 8;
+
+	RenderCadenceController controller;
+	const TimePoint start = Clock::time_point(Ms(0));
+	controller.Configure(Ms(20), start, policy);
+
+	RenderCadenceDecision decision = controller.Tick(start + Ms(70));
+	Expect(decision.action == RenderCadenceAction::Render, "large late tick renders newest allowed frame");
+	Expect(decision.skippedTicks == 3, "large late tick skips elapsed render ticks");
+	Expect(decision.frameIndex == 3, "large late tick renders skipped-to frame");
+	Expect(decision.renderTargetTime == start + Ms(60), "large late tick targets newest elapsed tick");
+	Expect(decision.lateness == Ms(10), "large late tick measures residual lateness");
+	Expect(controller.NextFrameIndex() == 4, "large late tick advances past rendered frame");
+	Expect(controller.NextRenderTime() == start + Ms(80), "large late tick advances to following cadence");
+	Expect(controller.Metrics().skippedTickCount == 3, "metrics count skipped ticks");
+}
+
+void TestSkipPolicyCanDisableOrCapSkippedTicks()
+{
+	const TimePoint start = Clock::time_point(Ms(0));
+
+	RenderCadencePolicy disabledPolicy;
+	disabledPolicy.skipLateTicks = false;
+	RenderCadenceController disabledController;
+	disabledController.Configure(Ms(20), start, disabledPolicy);
+	RenderCadenceDecision disabled = disabledController.Tick(start + Ms(90));
+	Expect(disabled.skippedTicks == 0, "disabled skip policy renders pending frame");
+	Expect(disabled.frameIndex == 0, "disabled skip policy preserves pending frame index");
+
+	RenderCadencePolicy cappedPolicy;
+	cappedPolicy.skipThresholdFrames = 1.0;
+	cappedPolicy.maxSkippedTicksPerDecision = 2;
+	RenderCadenceController cappedController;
+	cappedController.Configure(Ms(20), start, cappedPolicy);
+	RenderCadenceDecision capped = cappedController.Tick(start + Ms(90));
+	Expect(capped.skippedTicks == 2, "skip policy caps skipped ticks");
+	Expect(capped.frameIndex == 2, "capped skip renders capped frame index");
+}
+
+void TestResetRestartsCadenceAndMetrics()
+{
+	RenderCadenceController controller;
+	const TimePoint start = Clock::time_point(Ms(0));
+	controller.Configure(Ms(20), start);
+	(void)controller.Tick(start + Ms(50));
+
+	const TimePoint restarted = start + Ms(200);
+	controller.Reset(restarted);
+
+	Expect(controller.NextFrameIndex() == 0, "reset restarts frame index");
+	Expect(controller.NextRenderTime() == restarted, "reset restarts next render time");
+	Expect(controller.Metrics().renderedFrameCount == 0, "reset clears rendered metrics");
+
+	RenderCadenceDecision decision = controller.Tick(restarted);
+	Expect(decision.action == RenderCadenceAction::Render, "reset cadence renders at new start");
+	Expect(decision.frameIndex == 0, "reset cadence renders frame zero");
+}
+
+void TestActionNames()
+{
+	Expect(RenderCadenceActionName(RenderCadenceAction::Render) == std::string("Render"), "render action has name");
+	Expect(RenderCadenceActionName(RenderCadenceAction::Wait) == std::string("Wait"), "wait action has name");
+}
+}
+
+int main()
+{
+	TestExactCadenceAdvancesFrameIndexAndNextTick();
+	TestEarlyTickWaitsWithoutAdvancing();
+	TestSlightLatenessRendersAndRecordsMetrics();
+	TestLargeLatenessSkipsTicksAccordingToPolicy();
+	TestSkipPolicyCanDisableOrCapSkippedTicks();
+	TestResetRestartsCadenceAndMetrics();
+	TestActionNames();
+
+	if (gFailures != 0)
+	{
+		std::cerr << gFailures << " RenderCadenceController test failure(s).\n";
+		return 1;
+	}
+
+	std::cout << "RenderCadenceController tests passed.\n";
+	return 0;
+}