// Standalone tests for reasampler::render_window — no REAPER, no framework.
// Covers the bounds-equality number (a window's exact frame count at the project
// rate), the verdict the offline backend refuses a capture on, the predicate
// that decides whether REAPER's selected-items render source can express a
// requested window at all, and the millisecond-floor shape a refusal quotes.

#include "../src/core/capture/render_window.h"

#include <cmath>
#include <cstdio>

using namespace reasampler::capture;

static int g_fail = 0;
#define CHECK(cond) do { if(!(cond)) { \
    std::printf("FAIL line %d: %s\n", __LINE__, #cond); ++g_fail; } } while(0)

// --- frameCountFor: the bounds equality, stated as a number ------------------

static void testFrameCountIsExactNotRounded() {
    // A 1.5 s window at 48 kHz is exactly 72000 frames — the number a capture of
    // that range must produce. No rounding slack in either direction.
    CHECK(frameCountFor(2.0, 3.5, 48000) == 72000);
    // The same duration at a different offset still counts the same frames when
    // both edges are frame-aligned.
    CHECK(frameCountFor(10.0, 11.5, 48000) == 72000);
    // 44.1 kHz: 0.5 s = 22050 frames.
    CHECK(frameCountFor(1.0, 1.5, 44100) == 22050);
}

static void testFrameCountIsADifferenceOfIndicesNotADuration() {
    // Both edges land mid-frame at 100 Hz (0.005 s = half a frame). Rounding the
    // DURATION would give 1 frame; rounding each EDGE gives 0.005 -> frame 1 and
    // 0.015 -> frame 2, i.e. 1 frame. Shift the window so the edges round apart
    // and the count changes — the property that makes this a window, not a length.
    CHECK(frameCountFor(0.005, 0.015, 100) == 1);
    CHECK(frameCountFor(0.004, 0.016, 100) == 2);
}

static void testFrameCountRefusesEmptyInvertedAndUnknownRate() {
    CHECK(frameCountFor(3.0, 3.0, 48000) == 0);   // empty
    CHECK(frameCountFor(3.0, 1.0, 48000) == 0);   // inverted
    CHECK(frameCountFor(1.0, 2.0, 0)     == 0);   // rate unknown
    CHECK(frameCountFor(1.0, 2.0, -1)    == 0);   // rate nonsensical
}

static void testWindowStartingAtExactlyZero() {
    CHECK(frameCountFor(0.0, 1.0, 48000) == 48000);
    // The window from the reported blocker: it starts at 0 and its end lands a
    // quarter of a frame off the grid at 48 kHz.
    CHECK(frameCountFor(0.0, 4.067797, 48000) == 195254);
}

// --- renderHonoredBounds: the gate's verdict ---------------------------------

static void testNonFrameAlignedWindowAcceptsItsAdjacentCounts() {
    // 4.067797 s at 48 kHz is 195254.26 frames — not a frame boundary. A correct
    // render lands on 195254, and both adjacent counts are inside the gate.
    const long long expected = frameCountFor(0.0, 4.067797, 48000);
    CHECK(expected == 195254);
    CHECK(renderHonoredBounds(expected, 195254));
    CHECK(renderHonoredBounds(expected, 195255));
    CHECK(renderHonoredBounds(expected, 195253));
    // The shortfall actually reported from the DAW is 38 frames — far outside any
    // alignment slack, so it is a render that missed the window, and is refused.
    CHECK(!renderHonoredBounds(expected, 195216));
}

static void testLengthDerivedAndSameConventionRenderersStayWithinOneFrame() {
    // What the one-frame tolerance is actually good for. Two families of renderer are
    // inside it at every offset swept here: one that derives its count from the
    // window's LENGTH (floor/ceil/round of (end-start)*rate), and one that resolves
    // each EDGE to a frame using the SAME convention on both edges. Every count below
    // is computed from the window, never from frameCountFor, so this compares two
    // derivations rather than restating one. Round-both-edges is omitted deliberately:
    // that IS frameCountFor's own convention, so asserting it would be tautological.
    //
    // 8192 is a power of two, so an eighth of a frame is exact in double there and the
    // .5 rounding ties are really hit; at 48000/44100 (the shipping rates) they are
    // only approached, which is why all three are swept.
    struct Window { double start; double end; };
    const int rates[] = {48000, 44100, 8192};
    const Window windows[] = {{3.0, 7.5}, {0.0, 4.067797}, {10.25, 10.75}};
    for (int rate : rates) {
        for (const Window& w : windows) {
            for (int s = 0; s < 8; ++s) {
                for (int e = 0; e < 8; ++e) {
                    const double start = w.start + s / (8.0 * rate);
                    const double end   = w.end   + e / (8.0 * rate);
                    const long long expected = frameCountFor(start, end, rate);

                    const double length = (end - start) * rate;
                    CHECK(renderHonoredBounds(expected,
                                              static_cast<long long>(std::floor(length))));
                    CHECK(renderHonoredBounds(expected,
                                              static_cast<long long>(std::ceil(length))));
                    CHECK(renderHonoredBounds(expected, std::llround(length)));

                    const double startFrames = start * rate;
                    const double endFrames   = end * rate;
                    CHECK(renderHonoredBounds(
                        expected, static_cast<long long>(std::floor(endFrames) -
                                                         std::floor(startFrames))));
                    CHECK(renderHonoredBounds(
                        expected, static_cast<long long>(std::ceil(endFrames) -
                                                         std::ceil(startFrames))));
                }
            }
        }
    }
}

static void testMixedEdgeConventionsCanMissByTwoAndAreRefused() {
    // The hole in that bound, stated rather than hidden. A renderer that resolves the
    // two edges by DIFFERENT conventions lands two frames from frameCountFor's answer
    // whenever the start sits past mid-frame and the end before it (resolved outward),
    // or the mirror image (resolved inward). The gate refuses both — correctly if
    // REAPER derives its count from the window's length, wrongly if it resolves edges
    // this way. No unit test can settle which; see render_window.h.
    const int rate = 8192;  // power of two: the eighth-frame offsets below are exact

    // Outward: start .625 into a frame, end .375 into one.
    const double start = 10.25 + 5.0 / (8.0 * rate);
    const double end   = 10.75 + 3.0 / (8.0 * rate);
    CHECK(start * rate == 83968.625);   // the premise, not an outcome — pinned so a
    CHECK(end   * rate == 88064.375);   // representability slip can't fake the result
    const long long expected = frameCountFor(start, end, rate);
    CHECK(expected == 4095);
    const long long outward = static_cast<long long>(std::ceil(end * rate) -
                                                     std::floor(start * rate));
    CHECK(outward == 4097);
    CHECK(!renderHonoredBounds(expected, outward));

    // Inward, mirrored fractions.
    const double start2 = 10.25 + 3.0 / (8.0 * rate);
    const double end2   = 10.75 + 5.0 / (8.0 * rate);
    const long long expected2 = frameCountFor(start2, end2, rate);
    CHECK(expected2 == 4097);
    const long long inward = static_cast<long long>(std::floor(end2 * rate) -
                                                    std::ceil(start2 * rate));
    CHECK(inward == 4095);
    CHECK(!renderHonoredBounds(expected2, inward));
}

static void testWholeItemWideningIsStillRefused() {
    // The defect the gate was built for: a 1 s window inside a 30 s item printing
    // the whole item.
    const long long expected = frameCountFor(5.0, 6.0, 48000);
    CHECK(expected == 48000);
    CHECK(!renderHonoredBounds(expected, 30 * 48000));
}

static void testLargeShortfallIsStillRefused() {
    const long long expected = frameCountFor(0.0, 4.067797, 48000);
    CHECK(!renderHonoredBounds(expected, 190000));
    // Two frames is the smallest miss outside the tolerance, in both directions —
    // the tolerance is one frame and stays one frame.
    CHECK(!renderHonoredBounds(expected, expected - 2));
    CHECK(!renderHonoredBounds(expected, expected + 2));
}

static void testEmptyRenderIsRefusedAgainstARealWindow() {
    // A render that produced nothing is a bounds miss like any other. A render whose
    // frames could not be MEASURED never reaches this predicate — shell/capture/
    // render_bounds_gate refuses it before the comparison.
    CHECK(!renderHonoredBounds(48000, 0));
}

// --- itemExtentPrintsWindow: can the selected-items source express this? -----

static void testRangeInsideItemCannotBeExpressed() {
    // The defect this whole module exists for: a 1 s selection inside a 30 s item.
    // The selected-items source would print the item's 30 s, not the 1 s asked for,
    // so the capture must NOT take that path.
    CHECK(!itemExtentPrintsWindow(5.0, 6.0, /*item*/ 0.0, 30.0, 48000));
}

static void testRangeWiderThanItemCannotBeExpressedEither() {
    // The same violation in the other direction: a 10 s selection over a 6 s item
    // would print 6 s. Under-printing is a bounds violation exactly as much as
    // over-printing is.
    CHECK(!itemExtentPrintsWindow(0.0, 10.0, /*item*/ 2.0, 8.0, 48000));
}

static void testEachEdgeAloneDisqualifies() {
    // Matching start, drifting end.
    CHECK(!itemExtentPrintsWindow(2.0, 8.0, 2.0, 9.0, 48000));
    // Matching end, drifting start.
    CHECK(!itemExtentPrintsWindow(2.0, 8.0, 1.0, 8.0, 48000));
}

static void testExtentEqualToWindowIsExpressible() {
    // The regression floor: a capture whose range IS the item's extent keeps the
    // selected-items render, byte-identical to what it produces today.
    CHECK(itemExtentPrintsWindow(2.0, 8.0, 2.0, 8.0, 48000));
}

static void testSubFrameDriftStillPrintsTheSameFrames() {
    // A time selection snapped a fraction of a sample off the item edge prints the
    // identical frames, so it must NOT be pushed onto the time-bounded path — that
    // would swap the render mechanism under a capture that was already exact.
    const double eighthOfAFrameAt48k = 1.0 / (48000.0 * 8.0);
    CHECK(itemExtentPrintsWindow(2.0 + eighthOfAFrameAt48k, 8.0 - eighthOfAFrameAt48k,
                                 2.0, 8.0, 48000));
    // A full frame of drift is a real difference and must disqualify.
    const double oneFrameAt48k = 1.0 / 48000.0;
    CHECK(!itemExtentPrintsWindow(2.0 + oneFrameAt48k, 8.0, 2.0, 8.0, 48000));
}

static void testUnknownRateFallsBackToExactEquality() {
    // With no project rate there is no frame grid to compare on. Exact equality
    // still recognizes the regression floor...
    CHECK(itemExtentPrintsWindow(2.0, 8.0, 2.0, 8.0, 0));
    // ...and anything else takes the time-bounded render, which honors the request
    // whatever the rate turns out to be.
    const double eighthOfAFrameAt48k = 1.0 / (48000.0 * 8.0);
    CHECK(!itemExtentPrintsWindow(2.0 + eighthOfAFrameAt48k, 8.0, 2.0, 8.0, 0));
    CHECK(!itemExtentPrintsWindow(5.0, 6.0, 0.0, 30.0, 0));
}

static void testMultiItemUnionExtent() {
    // Two items spanning 1..4 and 6..9 present a 1..9 union extent to the render.
    // A selection over the whole union is expressible; one over only the first
    // item's half is not.
    CHECK(itemExtentPrintsWindow(1.0, 9.0, 1.0, 9.0, 48000));
    CHECK(!itemExtentPrintsWindow(1.0, 4.0, 1.0, 9.0, 48000));
}

// --- msFlooredEndFrameCount: the shape both live short renders had ------------

static void testMillisecondFlooredEndReproducesBothShortRenders() {
    // Both DAW observations, as arithmetic. 48 kHz, TailMode::None, start at 0: the
    // requested window's count, and the count its end floored to the millisecond
    // holds — which is what each render actually printed.
    CHECK(frameCountFor(0.0, 4.067797, 48000) == 195254);
    CHECK(msFlooredEndFrameCount(0.0, 4.067797, 48000) == 195216);
    CHECK(frameCountFor(0.0, 4.067797, 48000) -
          msFlooredEndFrameCount(0.0, 4.067797, 48000) == 38);

    CHECK(frameCountFor(0.0, 1.655172, 48000) == 79448);
    CHECK(msFlooredEndFrameCount(0.0, 1.655172, 48000) == 79440);
    CHECK(frameCountFor(0.0, 1.655172, 48000) -
          msFlooredEndFrameCount(0.0, 1.655172, 48000) == 8);
}

static void testTheSixDecimalDisplayDidNotCreateTheEffect() {
    // Both reported ends were printed to six decimals by the refusal. Each is one 4/4
    // bar — at 59 BPM and at 145 BPM — so the full-precision doubles behind them are
    // 240/59 and 240/145. Same counts either way: the display rounding is not what
    // produces the shortfall.
    CHECK(frameCountFor(0.0, 240.0 / 59.0, 48000) == 195254);
    CHECK(msFlooredEndFrameCount(0.0, 240.0 / 59.0, 48000) == 195216);
    CHECK(frameCountFor(0.0, 240.0 / 145.0, 48000) == 79448);
    CHECK(msFlooredEndFrameCount(0.0, 240.0 / 145.0, 48000) == 79440);
}

static void testWindowAlreadyOnTheMillisecondGridLosesNothing() {
    // The "sometimes it works" case: a bar at 120 BPM is exactly 2 s.
    CHECK(msFlooredEndFrameCount(0.0, 2.0, 48000) == frameCountFor(0.0, 2.0, 48000));

    // The binary-representation trap a bare floor would fall into. The premise, not an
    // outcome: 1.007 s is a whole millisecond that really does land BELOW 1007 ms in
    // double, so flooring it without a tolerance drops a millisecond from a window
    // already on the grid.
    CHECK(1.007 * 1000.0 < 1007.0);
    CHECK(frameCountFor(0.0, 1.007, 48000) == 48336);
    CHECK(msFlooredEndFrameCount(0.0, 1.007, 48000) == 48336);
    // Same end reached from a non-zero start, so nothing here rests on the window
    // beginning at 0.
    CHECK(msFlooredEndFrameCount(0.5, 1.007, 48000) ==
          frameCountFor(0.5, 1.007, 48000));
}

static void testOneFrameOfRemainderStillFloors() {
    // The whole-millisecond tolerance must sit far below a frame, or it would swallow
    // the very remainder this diagnostic exists to find. A remainder JUST BELOW a
    // millisecond boundary is the discriminating case: one frame short of 1.0 s is
    // 999.979166 ms, only ~0.0208 ms off the next whole millisecond. The shipped
    // nanosecond tolerance still floors it down; a tolerance any wider than ~0.021 ms
    // would snap it up to the millisecond instead and this test would then see 48000,
    // not 47952 — which is what would fail if the tolerance regressed to something
    // that wide.
    const double oneFrame = 1.0 / 48000.0;
    CHECK(frameCountFor(0.0, 1.0 - oneFrame, 48000) == 47999);
    CHECK(msFlooredEndFrameCount(0.0, 1.0 - oneFrame, 48000) == 47952);
}

static void testMillisecondFloorAt44100WhereAMillisecondIsNotWholeFrames() {
    // 44.1 kHz: a millisecond is 44.1 frames, so a floored end cannot be described as
    // dropping a whole number of frames — the count still resolves exactly.
    CHECK(frameCountFor(0.0, 0.0105, 44100) == 463);
    CHECK(msFlooredEndFrameCount(0.0, 0.0105, 44100) == 441);
    // And a window that IS on the millisecond grid there is untouched, even though its
    // edge is not on a frame boundary.
    CHECK(frameCountFor(0.0, 0.010, 44100) == 441);
    CHECK(msFlooredEndFrameCount(0.0, 0.010, 44100) == 441);
}

static void testASubMillisecondStartWouldNotHideItself() {
    // Both observations started at 0.000000s, the one value that hides a start-side
    // truncation. A window whose START carries a sub-millisecond remainder counts from
    // that exact start...
    const double start = 1.0001724, end = 2.0001724;
    CHECK(frameCountFor(start, end, 48000) == 48000);
    // ...so a start floored to the millisecond would print a DIFFERENT count — 8 frames
    // more, the same remainder the second observation lost off its end. A start-side
    // truncation is therefore visible to the same frame-count gate, not silent.
    CHECK(frameCountFor(1.000, end, 48000) == 48008);
    CHECK(!renderHonoredBounds(frameCountFor(start, end, 48000),
                               frameCountFor(1.000, end, 48000)));
}

static void testTheTwoLiveShortRendersPinnedAtFullPrecision() {
    // 1.6551724137931001 is the console's own %.17g read-back. 4.0677966101694913 is
    // the double nearest the six-decimal value (4.067797) the earlier refusal actually
    // printed -- that refusal predates the %.17g printer (git history has no commit
    // introducing this literal as a console value), so it is a reconstruction, not a
    // captured one. 240/145 and 240/59 (testTheSixDecimalDisplayDidNotCreateTheEffect)
    // produce the SAME counts as the literals here, so this test cannot distinguish the
    // real value from the reconstruction either -- it pins the count regression (full
    // precision or six-decimal input, the frame counts agree), not which double REAPER
    // was really handed.
    CHECK(frameCountFor(0.0, 1.6551724137931001, 48000)        == 79448);
    CHECK(msFlooredEndFrameCount(0.0, 1.6551724137931001, 48000) == 79440);

    CHECK(frameCountFor(0.0, 4.0677966101694913, 48000)         == 195254);
    CHECK(msFlooredEndFrameCount(0.0, 4.0677966101694913, 48000) == 195216);

    // And the counts REAPER produced are outside the gate's tolerance in both cases —
    // the refusals were correct, not an artifact of the one-frame slack.
    CHECK(!renderHonoredBounds(79448, 79440));
    CHECK(!renderHonoredBounds(195254, 195216));
}

// --- isOnMillisecondGrid: whether an observation can speak to an edge ----------

static void testOnGridRecognizesWholeMillisecondsIncludingTheBinaryTrap() {
    CHECK(isOnMillisecondGrid(0.0));
    CHECK(isOnMillisecondGrid(2.0));
    CHECK(isOnMillisecondGrid(0.001));
    // 1.007 s does not multiply to exactly 1007.0 in double (pinned as the premise in
    // testWindowAlreadyOnTheMillisecondGridLosesNothing) and must still read as on-grid.
    CHECK(isOnMillisecondGrid(1.007));
    // A whole millisecond at 44.1 kHz is 44.1 frames — off the frame grid, on this one.
    CHECK(isOnMillisecondGrid(0.010));
}

static void testOffGridRecognizesASubMillisecondRemainder() {
    CHECK(!isOnMillisecondGrid(1.6551724137931001));
    CHECK(!isOnMillisecondGrid(1.0001724));
    // One frame short of a whole second at 48 kHz is ~0.0208 ms off the grid — the
    // tightest remainder this predicate has to keep seeing.
    CHECK(!isOnMillisecondGrid(1.0 - 1.0 / 48000.0));
}

// --- the settled time-selection observations, as pure arithmetic ---------------
//
// Two live 48 kHz TailMode::None renders on RENDER_BOUNDSFLAG=2 came back EXACT at
// 97627 frames. The console printed run TWO's start verbatim (2.0338983050847457s);
// run ONE started at 0s and its end was never printed, so the value below is a
// reconstruction from run two's own printed start — it pins the count, not which
// double REAPER was handed.

static void testTheSettledExactRenderOnTheOnGridStart() {
    CHECK(frameCountFor(0.0, 2.0338983050847457, 48000) == 97627);
    // Run one could not test the START: 0s is on the grid, which floor, ceil and round
    // all leave alone, so a start-flooring render prints the identical count.
    CHECK(isOnMillisecondGrid(0.0));
    // Its END, though, WAS under test — a floored end would have printed 43 frames fewer.
    CHECK(msFlooredEndFrameCount(0.0, 2.0338983050847457, 48000) == 97584);
    CHECK(!renderHonoredBounds(97627, 97584));
}

static void testTheSettledExactRenderTestedBothEdges() {
    // Run two: both edges carry a sub-millisecond remainder, and the render still
    // printed the window's exact count.
    const double start = 2.0338983050847457, end = 4.0677966101694913;
    CHECK(!isOnMillisecondGrid(start));
    CHECK(!isOnMillisecondGrid(end));
    CHECK(frameCountFor(start, end, 48000) == 97627);

    // What makes that EXACT proof rather than a coincidence: NO millisecond-floored
    // model of this window reproduces 97627, and every one of them sits outside the
    // gate's one-frame tolerance. This is the assertion the whole experiment rests on.
    const long long startAlone   = frameCountFor(2.033, end,   48000);
    const long long endAlone     = frameCountFor(start, 4.067, 48000);
    const long long bothTogether = frameCountFor(2.033, 4.067, 48000);
    CHECK(startAlone   == 97670);
    CHECK(endAlone     == 97589);
    CHECK(bothTogether == 97632);
    CHECK(!renderHonoredBounds(97627, startAlone));
    CHECK(!renderHonoredBounds(97627, endAlone));
    CHECK(!renderHonoredBounds(97627, bothTogether));
}

static void testOnAndOffGridWindowsAreHonoredIdentically() {
    // Nothing on the settled path may treat a grid-aligned window differently from one
    // carrying a remainder — the whole point of leaving the flooring channel behind.
    const double onStart  = 1.000,     onEnd  = 2.000;
    const double offStart = 1.0001724, offEnd = 2.0001724;
    CHECK(isOnMillisecondGrid(onStart));
    CHECK(isOnMillisecondGrid(onEnd));
    CHECK(!isOnMillisecondGrid(offStart));
    CHECK(!isOnMillisecondGrid(offEnd));

    const long long on  = frameCountFor(onStart,  onEnd,  48000);
    const long long off = frameCountFor(offStart, offEnd, 48000);
    CHECK(on  == 48000);
    CHECK(off == 48000);

    // The discriminating half: a render that landed the FLOORED count would be
    // refused on the off-grid window (47992 against the required 48000, an
    // 8-frame gap) but honored on the on-grid one, where flooring changes
    // nothing. If the floor ever came back on the settled path, this is what
    // would start failing.
    const long long offFloored = msFlooredEndFrameCount(offStart, offEnd, 48000);
    const long long onFloored  = msFlooredEndFrameCount(onStart,  onEnd,  48000);
    CHECK(offFloored == 47992);
    CHECK(onFloored  == on);
    CHECK(!renderHonoredBounds(off, offFloored));
    CHECK(renderHonoredBounds(on, onFloored));
}

static void testOnAndOffGridAt44100WhereAMillisecondIsNotWholeFrames() {
    // 44.1 kHz: a millisecond is 44.1 frames, so a grid-aligned window's edges are NOT
    // frame-aligned. The exact counts must still be exact and the two must still be
    // judged identically.
    const double onStart  = 1.000,     onEnd  = 2.000;
    const double offStart = 1.0001724, offEnd = 2.0001724;
    const long long on  = frameCountFor(onStart,  onEnd,  44100);
    const long long off = frameCountFor(offStart, offEnd, 44100);
    CHECK(on  == 44100);
    CHECK(off == 44100);
    const long long offFloored = msFlooredEndFrameCount(offStart, offEnd, 44100);
    const long long onFloored  = msFlooredEndFrameCount(onStart,  onEnd,  44100);
    CHECK(offFloored == 44092);
    CHECK(onFloored  == on);
    // Same discriminating pair as the 48 kHz case: the floor would be caught
    // off-grid and invisible on-grid, even where the grid itself isn't frame-aligned.
    CHECK(!renderHonoredBounds(off, offFloored));
    CHECK(renderHonoredBounds(on, onFloored));
}

int main() {
    testFrameCountIsExactNotRounded();
    testFrameCountIsADifferenceOfIndicesNotADuration();
    testFrameCountRefusesEmptyInvertedAndUnknownRate();
    testWindowStartingAtExactlyZero();
    testNonFrameAlignedWindowAcceptsItsAdjacentCounts();
    testLengthDerivedAndSameConventionRenderersStayWithinOneFrame();
    testMixedEdgeConventionsCanMissByTwoAndAreRefused();
    testWholeItemWideningIsStillRefused();
    testLargeShortfallIsStillRefused();
    testEmptyRenderIsRefusedAgainstARealWindow();
    testRangeInsideItemCannotBeExpressed();
    testRangeWiderThanItemCannotBeExpressedEither();
    testEachEdgeAloneDisqualifies();
    testExtentEqualToWindowIsExpressible();
    testSubFrameDriftStillPrintsTheSameFrames();
    testUnknownRateFallsBackToExactEquality();
    testMultiItemUnionExtent();
    testMillisecondFlooredEndReproducesBothShortRenders();
    testTheSixDecimalDisplayDidNotCreateTheEffect();
    testWindowAlreadyOnTheMillisecondGridLosesNothing();
    testOneFrameOfRemainderStillFloors();
    testMillisecondFloorAt44100WhereAMillisecondIsNotWholeFrames();
    testASubMillisecondStartWouldNotHideItself();
    testTheTwoLiveShortRendersPinnedAtFullPrecision();
    testOnGridRecognizesWholeMillisecondsIncludingTheBinaryTrap();
    testOffGridRecognizesASubMillisecondRemainder();
    testTheSettledExactRenderOnTheOnGridStart();
    testTheSettledExactRenderTestedBothEdges();
    testOnAndOffGridWindowsAreHonoredIdentically();
    testOnAndOffGridAt44100WhereAMillisecondIsNotWholeFrames();

    if (g_fail) { std::printf("%d check(s) FAILED\n", g_fail); return 1; }
    std::printf("render_window: all checks passed\n");
    return 0;
}