Extract elapsedAtLeast to core/util, dedupe the throttle rationale, and correct the alloc-count/PLAN citations

tests/test_elapsed_at_least.cpp

@@ -0,0 +1,65 @@
+// Standalone tests for reasampler::util::elapsedAtLeast — no VST3, no REAPER, no framework.
+// Same fast assert loop as the sibling pure tests.
+//
+// Covers: the ordinary in-range case; the exact boundary (elapsed == interval opens the
+// gate, elapsed == interval - 1 does not); the zero/zero first-call case; and the
+// GetTickCount() WRAPAROUND — the one property in this idiom a reader has to think about.
+// A `now` that has numerically wrapped past `since` must still open the gate once the true
+// forward elapsed time reaches `interval`, never wedge it shut.
+
+#include "../src/core/util/elapsed_at_least.h"
+
+#include <cstdio>
+#include <limits>
+
+using namespace reasampler::util;
+
+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 void testOrdinaryCase() {
+    CHECK(elapsedAtLeast(1000u, 0u, 500u));       // well past the interval
+    CHECK(!elapsedAtLeast(400u, 0u, 500u));        // not there yet
+}
+
+static void testExactBoundary() {
+    CHECK(elapsedAtLeast(500u, 0u, 500u));         // exactly the interval: gate opens
+    CHECK(!elapsedAtLeast(499u, 0u, 500u));        // one ms short: gate stays shut
+}
+
+static void testZeroZeroFirstCallOpensImmediately() {
+    // A zero-initialized "last fired" tick (lastDetectTick's documented default) must not
+    // block the very first call.
+    CHECK(elapsedAtLeast(0u, 0u, 0u));
+    CHECK(elapsedAtLeast(1u, 0u, 0u));
+}
+
+// GetTickCount() wraps every ~49.7 days (2^32 ms). `since` sits near the top of the range;
+// `now` has wrapped back around to a small value. Unsigned subtraction computes the correct
+// forward distance (the gap to UINT_MAX plus the distance past zero) rather than reading as
+// a huge negative gap that a signed/naive comparison would misinterpret as "not yet".
+static void testWraparoundOpensRatherThanWedgesShut() {
+    const unsigned int kMax = std::numeric_limits<unsigned int>::max();
+    const unsigned int since = kMax - 49u;  // 50 ms of headroom before the counter wraps
+    const unsigned int interval = 500u;
+
+    // 450 ms after the wrap: 51 ms (headroom to wrap) + 450 ms = 501 ms true elapsed -> open.
+    CHECK(elapsedAtLeast(450u, since, interval));
+    // 439 ms after the wrap: 51 + 439 = 490 ms true elapsed -> still shut.
+    CHECK(!elapsedAtLeast(439u, since, interval));
+    // Exactly at the wrap instant (now == 0): 51 ms true elapsed -> shut.
+    CHECK(!elapsedAtLeast(0u, since, interval));
+    // now == since (no time passed, mid-wrap-approach): never wedges into "always open".
+    CHECK(!elapsedAtLeast(since, since, interval));
+}
+
+int main() {
+    testOrdinaryCase();
+    testExactBoundary();
+    testZeroZeroFirstCallOpensImmediately();
+    testWraparoundOpensRatherThanWedgesShut();
+    if (g_fail == 0) std::printf("elapsed_at_least: all tests passed\n");
+    else std::printf("elapsed_at_least: %d FAILED\n", g_fail);
+    return g_fail == 0 ? 0 : 1;
+}