daniel
36bdef742a
New pure action_buttons module (strip layout/hit-test + label format, CTest-covered). Panel strip fires capture/insert/provenance actions via NamedCommandLookup + Main_OnCommand; labels from kbd_getTextFromCmd.
237 lines
9.8 KiB
C++
237 lines
9.8 KiB
C++
// Standalone tests for reasampler::action_buttons — no REAPER, no test framework.
|
|
// Same fast loop as the sibling pure tests (mode_switch / tab_strip et al.): assert the
|
|
// action-button strip layout + hit-testing and the label-format logic directly.
|
|
//
|
|
// Covers (M11 brief §test cases):
|
|
// * Layout: N buttons in a strip — all fit (exact equal tiling), overflow on a narrow
|
|
// panel (only the fitting count laid out, rest hidden, never clipped), zero-width edge.
|
|
// * Hit-test: inside each button, outside the band, half-open boundary, the narrow-panel
|
|
// overflow dead-zone, hit/layout agreement.
|
|
// * Label format: bound ("name binding"), unbound marker, empty / whitespace-only SDK
|
|
// return -> unbound, over-long binding truncation.
|
|
|
|
#include "../src/action_buttons.h"
|
|
|
|
#include <cstddef>
|
|
#include <cstdio>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
using namespace reasampler;
|
|
|
|
static int g_fail = 0;
|
|
#define CHECK(cond) do { if(!(cond)) { \
|
|
std::printf("FAIL line %d: %s\n", __LINE__, #cond); ++g_fail; } } while(0)
|
|
|
|
// --- Layout: all fit ----------------------------------------------------------
|
|
|
|
// Strip 300 wide at origin (0, 40), height 24, 3 buttons at min width 80: all fit
|
|
// (300/80 = 3), tiled equally -> boundaries floor(i*300/3) = 0,100,200,300, widths 100.
|
|
static void testAllButtonsFitEqualTiling() {
|
|
ButtonStripRect s{0, 40, 300, 24};
|
|
ButtonFit fit = computeButtonFit(s, 3, 80);
|
|
CHECK(fit.visibleCount == 3);
|
|
CHECK(fit.hiddenCount == 0);
|
|
|
|
auto rects = computeButtonRects(s, 3, 80);
|
|
CHECK(rects.size() == 3);
|
|
CHECK((rects[0] == ActionButtonRect{0, 0, 40, 100, 24}));
|
|
CHECK((rects[1] == ActionButtonRect{1, 100, 40, 100, 24}));
|
|
CHECK((rects[2] == ActionButtonRect{2, 200, 40, 100, 24}));
|
|
// Abut exactly; last reaches strip right edge.
|
|
CHECK(rects[1].x == rects[0].x + rects[0].width);
|
|
CHECK(rects[2].x + rects[2].width == s.x + s.width);
|
|
}
|
|
|
|
// Uneven width absorbed at boundaries: 100 wide / 3 -> edges 0,33,66,100 -> 33,33,34.
|
|
static void testUnevenWidthTilesExactly() {
|
|
ButtonStripRect s{7, 3, 100, 16};
|
|
auto rects = computeButtonRects(s, 3, 30); // 100/30 = 3 fit
|
|
CHECK(rects.size() == 3);
|
|
CHECK(rects[0].width == 33);
|
|
CHECK(rects[1].width == 33);
|
|
CHECK(rects[2].width == 34);
|
|
CHECK(rects.front().x == s.x);
|
|
CHECK(rects.back().x + rects.back().width == s.x + s.width);
|
|
}
|
|
|
|
// --- Layout: overflow on a narrow panel ---------------------------------------
|
|
|
|
// 5 buttons at min width 80 into a 200-wide strip: only 2 fit (200/80 = 2). The two
|
|
// visible buttons share the FULL strip (100 each — never clipped, never below min), and
|
|
// 3 are hidden (the overflow the shell degrades, not clipped garbage).
|
|
static void testOverflowHidesExcessNotClipped() {
|
|
ButtonStripRect s{0, 0, 200, 24};
|
|
ButtonFit fit = computeButtonFit(s, 5, 80);
|
|
CHECK(fit.visibleCount == 2);
|
|
CHECK(fit.hiddenCount == 3);
|
|
|
|
auto rects = computeButtonRects(s, 5, 80);
|
|
CHECK(rects.size() == 2);
|
|
CHECK(rects[0].width == 100); // >= min width 80, shares full strip
|
|
CHECK(rects[1].width == 100);
|
|
CHECK(rects[1].x + rects[1].width == s.x + s.width);
|
|
}
|
|
|
|
// A strip too narrow for even one min-width button lays out nothing (all hidden). The
|
|
// shell draws an empty strip rather than a sub-minimum clipped button.
|
|
static void testStripTooNarrowForAny() {
|
|
ButtonStripRect s{0, 0, 50, 24};
|
|
ButtonFit fit = computeButtonFit(s, 3, 80);
|
|
CHECK(fit.visibleCount == 0);
|
|
CHECK(fit.hiddenCount == 3);
|
|
CHECK(computeButtonRects(s, 3, 80).empty());
|
|
}
|
|
|
|
// --- Layout: degenerate --------------------------------------------------------
|
|
|
|
static void testLayoutDegenerate() {
|
|
CHECK(computeButtonRects(ButtonStripRect{0, 0, 300, 24}, 0, 80).empty());
|
|
CHECK(computeButtonRects(ButtonStripRect{0, 0, 300, 24}, -2, 80).empty());
|
|
CHECK(computeButtonRects(ButtonStripRect{0, 0, 0, 24}, 3, 80).empty());
|
|
CHECK(computeButtonRects(ButtonStripRect{0, 0, -5, 24}, 3, 80).empty());
|
|
CHECK(computeButtonRects(ButtonStripRect{0, 0, 300, 24}, 3, 0).empty());
|
|
CHECK(computeButtonRects(ButtonStripRect{0, 0, 300, 24}, 3, -10).empty());
|
|
|
|
ButtonFit fit = computeButtonFit(ButtonStripRect{0, 0, 0, 24}, 3, 80);
|
|
CHECK(fit.visibleCount == 0 && fit.hiddenCount == 0);
|
|
}
|
|
|
|
// A single button fills the whole strip.
|
|
static void testSingleButtonFillsStrip() {
|
|
ButtonStripRect s{5, 5, 120, 24};
|
|
auto rects = computeButtonRects(s, 1, 80);
|
|
CHECK(rects.size() == 1);
|
|
CHECK((rects[0] == ActionButtonRect{0, 5, 5, 120, 24}));
|
|
}
|
|
|
|
// --- Hit-test: hits -----------------------------------------------------------
|
|
|
|
static void testHitTestHitsEachButton() {
|
|
ButtonStripRect s{0, 40, 300, 24}; // 3 buttons, 100 wide each
|
|
CHECK(hitTestButton(0, 40, s, 3, 80) == 0); // top-left of button 0
|
|
CHECK(hitTestButton(50, 51, s, 3, 80) == 0); // middle of button 0
|
|
CHECK(hitTestButton(99, 63, s, 3, 80) == 0); // last pixel of button 0
|
|
CHECK(hitTestButton(100, 50, s, 3, 80) == 1); // first pixel of button 1
|
|
CHECK(hitTestButton(299, 40, s, 3, 80) == 2); // last column of button 2
|
|
}
|
|
|
|
// The boundary pixel belongs to exactly ONE button (half-open): px==100 starts button 1.
|
|
static void testHitTestBoundaryHalfOpen() {
|
|
ButtonStripRect s{0, 0, 300, 24};
|
|
CHECK(hitTestButton(99, 10, s, 3, 80) == 0);
|
|
CHECK(hitTestButton(100, 10, s, 3, 80) == 1);
|
|
CHECK(hitTestButton(199, 10, s, 3, 80) == 1);
|
|
CHECK(hitTestButton(200, 10, s, 3, 80) == 2);
|
|
}
|
|
|
|
// --- Hit-test: misses ---------------------------------------------------------
|
|
|
|
static void testHitTestMissesOutsideBand() {
|
|
ButtonStripRect s{10, 40, 200, 24};
|
|
CHECK(hitTestButton(9, 50, s, 3, 60) == -1); // left of strip
|
|
CHECK(hitTestButton(210, 50, s, 3, 60) == -1); // right edge (== x+width, excluded)
|
|
CHECK(hitTestButton(50, 39, s, 3, 60) == -1); // above the band
|
|
CHECK(hitTestButton(50, 64, s, 3, 60) == -1); // below the band
|
|
}
|
|
|
|
// On a narrow panel the visible buttons fill the whole strip, so there is no in-band
|
|
// dead-zone; but when buttonCount is 0 or the strip too narrow, every in-band point
|
|
// misses (the shell draws nothing and ignores the click).
|
|
static void testHitTestOverflowDeadZone() {
|
|
ButtonStripRect s{0, 0, 50, 24}; // too narrow for any 80-min button
|
|
CHECK(hitTestButton(25, 10, s, 3, 80) == -1);
|
|
CHECK(hitTestButton(0, 0, s, 0, 80) == -1); // no buttons
|
|
}
|
|
|
|
static void testHitTestDegenerate() {
|
|
ButtonStripRect s{0, 0, 300, 24};
|
|
CHECK(hitTestButton(50, 10, s, 0, 80) == -1);
|
|
CHECK(hitTestButton(50, 10, s, -2, 80) == -1);
|
|
CHECK(hitTestButton(50, 10, ButtonStripRect{0, 0, 0, 24}, 3, 80) == -1);
|
|
CHECK(hitTestButton(50, 10, ButtonStripRect{0, 0, 300, 0}, 3, 80) == -1);
|
|
}
|
|
|
|
// Every point in the strip hit-tests to the button that DREW it (hit-test and layout
|
|
// agree — the load-bearing consistency invariant), across an awkward width and count.
|
|
static void testHitTestMatchesLayout() {
|
|
ButtonStripRect s{4, 2, 173, 22};
|
|
const int count = 4, minW = 40; // 173/40 = 4 fit
|
|
auto rects = computeButtonRects(s, count, minW);
|
|
for (int px = s.x; px < s.x + s.width; ++px) {
|
|
const int b = hitTestButton(px, s.y + 1, s, count, minW);
|
|
CHECK(b >= 0);
|
|
const ActionButtonRect& r = rects[static_cast<std::size_t>(b)];
|
|
CHECK(px >= r.x && px < r.x + r.width);
|
|
}
|
|
}
|
|
|
|
// --- Label format -------------------------------------------------------------
|
|
|
|
static void testLabelBound() {
|
|
CHECK(formatButtonLabel("Capture Item", "Ctrl+Shift+C") ==
|
|
"Capture Item Ctrl+Shift+C");
|
|
CHECK(formatButtonLabel("Insert", "F3") == "Insert F3");
|
|
}
|
|
|
|
static void testLabelUnboundEmpty() {
|
|
CHECK(formatButtonLabel("Capture Item", "") == "Capture Item (unbound)");
|
|
}
|
|
|
|
// Whitespace-only SDK returns (spaces, tabs) collapse to the unbound marker — the
|
|
// explicit blank-return handling the brief requires.
|
|
static void testLabelUnboundBlank() {
|
|
CHECK(formatButtonLabel("Capture Track", " ") == "Capture Track (unbound)");
|
|
CHECK(formatButtonLabel("Insert", "\t") == "Insert (unbound)");
|
|
CHECK(formatButtonLabel("Insert", " \t ") == "Insert (unbound)");
|
|
}
|
|
|
|
// Leading/trailing whitespace on a real binding is trimmed before formatting.
|
|
static void testLabelTrimsSurroundingBlanks() {
|
|
CHECK(formatButtonLabel("Insert", " F3 ") == "Insert F3");
|
|
}
|
|
|
|
// An over-long binding is truncated to kMaxBindingChars-1 chars + "~" so the label stays
|
|
// bounded (a pathological multi-chord custom binding never blows the button budget).
|
|
static void testLabelTruncatesLongBinding() {
|
|
const std::string longB(40, 'X'); // 40 > kMaxBindingChars (24)
|
|
const std::string label = formatButtonLabel("Cancel", longB);
|
|
// "Cancel " (8) + 23 'X' + "~" (kMaxBindingChars total in the binding portion).
|
|
const std::string expectedBinding =
|
|
std::string(kMaxBindingChars - 1, 'X') + "~";
|
|
CHECK(label == "Cancel " + expectedBinding);
|
|
CHECK(static_cast<int>(expectedBinding.size()) == kMaxBindingChars);
|
|
}
|
|
|
|
// A binding exactly at the limit is NOT truncated (boundary: <= kMaxBindingChars kept).
|
|
static void testLabelAtLimitNotTruncated() {
|
|
const std::string atLimit(kMaxBindingChars, 'Y');
|
|
CHECK(formatButtonLabel("X", atLimit) == "X " + atLimit);
|
|
}
|
|
|
|
int main() {
|
|
testAllButtonsFitEqualTiling();
|
|
testUnevenWidthTilesExactly();
|
|
testOverflowHidesExcessNotClipped();
|
|
testStripTooNarrowForAny();
|
|
testLayoutDegenerate();
|
|
testSingleButtonFillsStrip();
|
|
|
|
testHitTestHitsEachButton();
|
|
testHitTestBoundaryHalfOpen();
|
|
testHitTestMissesOutsideBand();
|
|
testHitTestOverflowDeadZone();
|
|
testHitTestDegenerate();
|
|
testHitTestMatchesLayout();
|
|
|
|
testLabelBound();
|
|
testLabelUnboundEmpty();
|
|
testLabelUnboundBlank();
|
|
testLabelTrimsSurroundingBlanks();
|
|
testLabelTruncatesLongBinding();
|
|
testLabelAtLimitNotTruncated();
|
|
|
|
if (g_fail == 0) std::printf("All tests passed.\n");
|
|
return g_fail ? 1 : 0;
|
|
}
|