capture: name the render source in the exact-bounds refusal, and put its one-frame tolerance under test

The tolerance is unchanged and now derived, not assumed: frameCountFor lands in {floor(L), ceil(L)}, so a non-frame-aligned window can never miss by more than a frame. Naming the source is what tells a self-bounding render from a short one.

tests/test_render_window.cpp

@@ -1,10 +1,12 @@
 // 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) and the predicate that decides whether REAPER's selected-items render
-// source can express a requested window at all.
+// rate), the verdict the offline backend refuses a capture on, and the predicate
+// that decides whether REAPER's selected-items render source can express a
+// requested window at all.
 
 #include "../src/core/capture/render_window.h"
 
+#include <cmath>
 #include <cstdio>
 
 using namespace reasampler::capture;
@@ -42,6 +44,74 @@ static void testFrameCountRefusesEmptyInvertedAndUnknownRate() {
     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 testNonFrameAlignedWindowAcceptsEveryEdgeConvention() {
+    // 4.067797 s at 48 kHz is 195254.26 frames — not a frame boundary. A correct
+    // render lands on 195254, and the neighbours a different edge convention would
+    // produce 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 testNonAlignmentCanNeverExceedOneFrame() {
+    // The provable content of the one-frame tolerance: frameCountFor rounds each
+    // edge, so it lands within a frame of the window's real length — and so does a
+    // renderer that floors, ceils or rounds that same length. Sweep both edges over
+    // every eighth of a frame; no pairing may fall outside the gate. The renderer's
+    // count is derived from the length here, independently of frameCountFor.
+    const int rate = 48000;
+    for (int s = 0; s < 8; ++s) {
+        for (int e = 0; e < 8; ++e) {
+            const double start = 3.0 + s / (8.0 * rate);
+            const double end   = 7.5 + 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)));
+        }
+    }
+}
+
+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; the backend's
+    // own "did the file parse" guard is what keeps an unreadable render out of here.
+    CHECK(!renderHonoredBounds(48000, 0));
+}
+
 // --- itemExtentPrintsWindow: can the selected-items source express this? -----
 
 static void testRangeInsideItemCannotBeExpressed() {
@@ -106,6 +176,12 @@ int main() {
     testFrameCountIsExactNotRounded();
     testFrameCountIsADifferenceOfIndicesNotADuration();
     testFrameCountRefusesEmptyInvertedAndUnknownRate();
+    testWindowStartingAtExactlyZero();
+    testNonFrameAlignedWindowAcceptsEveryEdgeConvention();
+    testNonAlignmentCanNeverExceedOneFrame();
+    testWholeItemWideningIsStillRefused();
+    testLargeShortfallIsStillRefused();
+    testEmptyRenderIsRefusedAgainstARealWindow();
     testRangeInsideItemCannotBeExpressed();
     testRangeWiderThanItemCannotBeExpressedEither();
     testEachEdgeAloneDisqualifies();