319 lines
14 KiB
C++
319 lines
14 KiB
C++
// Standalone tests for reasampler::action_bar — no REAPER, no test framework. Same fast loop
|
|
// as the sibling pure tests (mode_switch / prune_button): assert the
|
|
// task-grouped action-bar layout, overflow-on-narrow, and hit-testing directly.
|
|
//
|
|
// Covers (L2 brief §test cases, updated for L6 single-row face change):
|
|
// * Layout: correct rects for each action button across representative panel widths; buttons
|
|
// pack at a fixed width with intra-cluster + inter-cluster gaps.
|
|
// * Overflow/hiding when the bar is too narrow (whole trailing buttons dropped, never
|
|
// clipped; earlier frequent clusters survive).
|
|
// * Label sub-rect correct — spans full button height (L6: keybinding sub-row removed from
|
|
// the face; binding is in the hover tooltip instead).
|
|
// * Task grouping reflected STRUCTURALLY: each slot carries its cluster; the flat index runs
|
|
// across clusters; inter-cluster gaps are wider than intra-cluster gaps.
|
|
// * Hover hit-test: right element for in-bounds points, -1 outside bounds AND in the gaps;
|
|
// degenerate/too-narrow bar handled without crash or overlap.
|
|
// * Resize: no inventory item cut off or overlapping across a representative width range.
|
|
|
|
#include "../src/core/ui/action_bar.h"
|
|
|
|
#include <cstddef>
|
|
#include <cstdio>
|
|
#include <vector>
|
|
|
|
using namespace reasampler;
|
|
using namespace reasampler::ui;
|
|
|
|
static int g_fail = 0;
|
|
#define CHECK(cond) do { if(!(cond)) { \
|
|
std::printf("FAIL line %d: %s\n", __LINE__, #cond); ++g_fail; } } while(0)
|
|
|
|
// The panel's real inventory shape (L6): 2 capture, 1 maintenance (Re-capture), 2 placement = 5
|
|
// buttons. Cluster order: Capture -> Maintenance -> Placement (Re-capture sits between the two
|
|
// capture verbs and the placement verbs — the L6 bar ordering).
|
|
static std::vector<ClusterSpec> inventory() {
|
|
return {
|
|
{ActionCluster::Capture, 2},
|
|
{ActionCluster::Maintenance, 1},
|
|
{ActionCluster::Placement, 2},
|
|
};
|
|
}
|
|
|
|
// A spec with round numbers so expected pixels are hand-checkable.
|
|
static ActionBarSpec roundSpec() {
|
|
ActionBarSpec s;
|
|
s.buttonWidth = 100;
|
|
s.buttonGap = 4;
|
|
s.clusterGap = 16;
|
|
s.sidePad = 8;
|
|
s.verticalInset = 3;
|
|
return s;
|
|
}
|
|
|
|
// --- Layout: all fit, correct rects + gaps ------------------------------------
|
|
|
|
// A wide bar fits all 5 buttons. Verify the first few rects, the intra-cluster gap, and the
|
|
// (wider) inter-cluster gap between button 1 (last capture) and button 2 (maintenance).
|
|
//
|
|
// Pixel walk with roundSpec and bar at (0,40):
|
|
// btn0 (Capture): x=8, right=108
|
|
// btn1 (Capture): x=112, right=212 (intraGap = 4 after btn0's right)
|
|
// btn2 (Maintenance): x=228, right=328 (clusterGap = 16 after btn1's right)
|
|
// btn3 (Placement): x=344, right=444 (clusterGap = 16 after btn2's right)
|
|
// btn4 (Placement): x=448, right=548 (intraGap = 4 after btn3's right)
|
|
// Minimum bar width: 548 + sidePad(8) = 556. Give it 600.
|
|
static void testAllFitRectsAndGaps() {
|
|
const auto clusters = inventory();
|
|
const ActionBarSpec spec = roundSpec();
|
|
ActionBarRect bar{0, 40, 600, 34};
|
|
|
|
BarFit fit = computeBarFit(bar, clusters, spec);
|
|
CHECK(fit.visibleCount == 5);
|
|
CHECK(fit.hiddenCount == 0);
|
|
|
|
auto slots = computeBarSlots(bar, clusters, spec);
|
|
CHECK(slots.size() == 5);
|
|
|
|
// Button 0: at sidePad, top = y + verticalInset, height = barH - 2*inset.
|
|
CHECK(slots[0].x == 8);
|
|
CHECK(slots[0].y == 43);
|
|
CHECK(slots[0].width == 100);
|
|
CHECK(slots[0].height == 28);
|
|
CHECK(slots[0].cluster == ActionCluster::Capture);
|
|
CHECK(slots[0].index == 0);
|
|
|
|
// Button 1: intra-cluster gap of 4 after button 0's right edge (8+100=108) -> 112.
|
|
CHECK(slots[1].x == 112);
|
|
CHECK(slots[1].cluster == ActionCluster::Capture);
|
|
|
|
// Button 2 (maintenance / Re-capture): cluster gap of 16 after 212 -> 228.
|
|
CHECK(slots[2].x == 228);
|
|
CHECK(slots[2].cluster == ActionCluster::Maintenance);
|
|
CHECK(slots[2].index == 2);
|
|
|
|
// Button 3 (first placement): cluster gap of 16 after 328 -> 344.
|
|
CHECK(slots[3].x == 344);
|
|
CHECK(slots[3].cluster == ActionCluster::Placement);
|
|
CHECK(slots[3].index == 3);
|
|
|
|
// Button 4 (second placement): intra-cluster gap of 4 after 444 -> 448.
|
|
CHECK(slots[4].x == 448);
|
|
CHECK(slots[4].cluster == ActionCluster::Placement);
|
|
CHECK(slots[4].index == 4);
|
|
|
|
// Inter-cluster gap (slot[2].x - slot[1].right = 228 - 212 = 16) is wider than the
|
|
// intra-cluster gap (slot[1].x - slot[0].right = 112 - 108 = 4) — task grouping is
|
|
// structurally visible in the geometry.
|
|
const int interGap = slots[2].x - (slots[1].x + slots[1].width);
|
|
const int intraGap = slots[1].x - (slots[0].x + slots[0].width);
|
|
CHECK(interGap == 16);
|
|
CHECK(intraGap == 4);
|
|
CHECK(interGap > intraGap);
|
|
}
|
|
|
|
// --- Label sub-rect: full-height single row ------------------------------------
|
|
|
|
// L6: the label rect spans the full button height — no binding sub-row split. The label is
|
|
// inset horizontally by hpad(4) on each side; horizontally it shares the same inner band.
|
|
static void testLabelFullHeight() {
|
|
const auto clusters = inventory();
|
|
const ActionBarSpec spec = roundSpec();
|
|
ActionBarRect bar{0, 0, 600, 34};
|
|
auto slots = computeBarSlots(bar, clusters, spec);
|
|
CHECK(!slots.empty());
|
|
const ActionBarSlot& s = slots[0];
|
|
// Label spans the full button height.
|
|
CHECK(s.labelH == s.height);
|
|
CHECK(s.labelY == s.y);
|
|
// Inset horizontally.
|
|
CHECK(s.labelX > s.x);
|
|
CHECK(s.labelX + s.labelW < s.x + s.width);
|
|
}
|
|
|
|
// Short buttons also get the full-height label (no min-height split threshold anymore).
|
|
static void testLabelFullHeightWhenShort() {
|
|
const auto clusters = inventory();
|
|
const ActionBarSpec spec = roundSpec();
|
|
ActionBarRect bar{0, 0, 600, 18}; // btnH = 18 - 6 = 12 — very short
|
|
auto slots = computeBarSlots(bar, clusters, spec);
|
|
CHECK(!slots.empty());
|
|
const ActionBarSlot& s = slots[0];
|
|
CHECK(s.labelH == s.height);
|
|
CHECK(s.labelY == s.y);
|
|
}
|
|
|
|
// --- Overflow / hiding on a narrow panel --------------------------------------
|
|
|
|
// A bar wide enough for only the 2 capture buttons drops the rest WHOLE. The visible buttons
|
|
// keep their full width (never clipped), and the frequent capture cluster survives.
|
|
//
|
|
// Exact fit for 2 capture buttons: sidePad(8) + 2*100 + 1*4 + sidePad(8) = 220.
|
|
// A 3rd button (Maintenance) needs clusterGap(16)+100 = 116 more -> 336. So 220 fits exactly 2.
|
|
static void testOverflowDropsTrailingWhole() {
|
|
const auto clusters = inventory();
|
|
const ActionBarSpec spec = roundSpec();
|
|
ActionBarRect bar{0, 0, 220, 34};
|
|
BarFit fit = computeBarFit(bar, clusters, spec);
|
|
CHECK(fit.visibleCount == 2);
|
|
CHECK(fit.hiddenCount == 3);
|
|
|
|
auto slots = computeBarSlots(bar, clusters, spec);
|
|
CHECK(slots.size() == 2);
|
|
for (const auto& s : slots) {
|
|
CHECK(s.width == spec.buttonWidth); // never clipped below full width
|
|
CHECK(s.cluster == ActionCluster::Capture);// the surviving cluster is the frequent one
|
|
}
|
|
// The last visible button's right edge stays within the usable bound.
|
|
CHECK(slots.back().x + slots.back().width <= bar.x + bar.width - spec.sidePad);
|
|
}
|
|
|
|
// A bar too narrow for even one button lays out nothing (all hidden) — no sub-minimum clipped
|
|
// button; the shell draws an empty bar.
|
|
static void testTooNarrowForAny() {
|
|
const auto clusters = inventory();
|
|
const ActionBarSpec spec = roundSpec();
|
|
ActionBarRect bar{0, 0, 60, 34}; // sidePad*2 + one 100-wide button won't fit
|
|
BarFit fit = computeBarFit(bar, clusters, spec);
|
|
CHECK(fit.visibleCount == 0);
|
|
CHECK(fit.hiddenCount == 5);
|
|
CHECK(computeBarSlots(bar, clusters, spec).empty());
|
|
}
|
|
|
|
// --- Degenerate --------------------------------------------------------------
|
|
|
|
static void testDegenerate() {
|
|
const auto clusters = inventory();
|
|
const ActionBarSpec spec = roundSpec();
|
|
CHECK(computeBarSlots(ActionBarRect{0, 0, 0, 34}, clusters, spec).empty());
|
|
CHECK(computeBarSlots(ActionBarRect{0, 0, 600, 0}, clusters, spec).empty());
|
|
CHECK(computeBarSlots(ActionBarRect{0, 0, 600, 34}, {}, spec).empty());
|
|
ActionBarSpec badW = spec; badW.buttonWidth = 0;
|
|
CHECK(computeBarSlots(ActionBarRect{0, 0, 600, 34}, clusters, badW).empty());
|
|
|
|
// Empty clusters in the list contribute no buttons and no gaps.
|
|
std::vector<ClusterSpec> withEmpty = {
|
|
{ActionCluster::Capture, 2},
|
|
{ActionCluster::Placement, 0}, // empty — skipped
|
|
{ActionCluster::Maintenance, 1},
|
|
};
|
|
auto slots = computeBarSlots(ActionBarRect{0, 0, 600, 34}, withEmpty, spec);
|
|
CHECK(slots.size() == 3);
|
|
CHECK(slots[0].cluster == ActionCluster::Capture);
|
|
CHECK(slots[1].cluster == ActionCluster::Capture);
|
|
CHECK(slots[2].cluster == ActionCluster::Maintenance);
|
|
// The cluster gap sits between the Capture and Maintenance buttons (Placement emitted none).
|
|
const int gap = slots[2].x - (slots[1].x + slots[1].width);
|
|
CHECK(gap == spec.clusterGap);
|
|
}
|
|
|
|
// --- Hit-test: hits, gaps, and misses -----------------------------------------
|
|
|
|
static void testHitTestHitsButtons() {
|
|
const auto clusters = inventory();
|
|
const ActionBarSpec spec = roundSpec();
|
|
ActionBarRect bar{0, 40, 600, 34};
|
|
auto slots = computeBarSlots(bar, clusters, spec);
|
|
// A point in the middle of each button returns that button's flat index.
|
|
for (const auto& s : slots) {
|
|
const int cx = s.x + s.width / 2;
|
|
const int cy = s.y + s.height / 2;
|
|
CHECK(hitTestActionBar(cx, cy, bar, clusters, spec) == s.index);
|
|
}
|
|
}
|
|
|
|
// A point in an intra-cluster gap and a point in an inter-cluster gap are both clean misses
|
|
// (real gaps, unlike an equal-tiled strip — no nearest-button snapping).
|
|
static void testHitTestGapsAreMisses() {
|
|
const auto clusters = inventory();
|
|
const ActionBarSpec spec = roundSpec();
|
|
ActionBarRect bar{0, 40, 600, 34};
|
|
auto slots = computeBarSlots(bar, clusters, spec);
|
|
// Intra-cluster gap between button 0 (right edge 108) and button 1 (left 112): x in [108,112).
|
|
CHECK(hitTestActionBar(110, 50, bar, clusters, spec) == -1);
|
|
// Inter-cluster gap between button 1 (right 212) and button 2 (left 228): x in [212,228).
|
|
CHECK(hitTestActionBar(220, 50, bar, clusters, spec) == -1);
|
|
}
|
|
|
|
static void testHitTestMissesOutsideBand() {
|
|
const auto clusters = inventory();
|
|
const ActionBarSpec spec = roundSpec();
|
|
ActionBarRect bar{10, 40, 400, 34};
|
|
CHECK(hitTestActionBar(9, 50, bar, clusters, spec) == -1); // left of bar
|
|
CHECK(hitTestActionBar(410, 50, bar, clusters, spec) == -1); // right edge (excluded)
|
|
CHECK(hitTestActionBar(50, 39, bar, clusters, spec) == -1); // above the band
|
|
CHECK(hitTestActionBar(50, 74, bar, clusters, spec) == -1); // below the band
|
|
}
|
|
|
|
// On a narrow bar the point past the last visible button (in the overflow dead-zone) misses.
|
|
static void testHitTestOverflowDeadZone() {
|
|
const auto clusters = inventory();
|
|
const ActionBarSpec spec = roundSpec();
|
|
ActionBarRect bar{0, 0, 220, 34}; // only 2 capture buttons visible
|
|
// x well past the 2nd button's right edge but still inside the bar band.
|
|
CHECK(hitTestActionBar(215, 10, bar, clusters, spec) == -1);
|
|
}
|
|
|
|
static void testHitTestDegenerate() {
|
|
const auto clusters = inventory();
|
|
const ActionBarSpec spec = roundSpec();
|
|
CHECK(hitTestActionBar(5, 5, ActionBarRect{0, 0, 0, 34}, clusters, spec) == -1);
|
|
CHECK(hitTestActionBar(5, 5, ActionBarRect{0, 0, 600, 0}, clusters, spec) == -1);
|
|
CHECK(hitTestActionBar(5, 5, ActionBarRect{0, 0, 600, 34}, {}, spec) == -1);
|
|
}
|
|
|
|
// --- Resize sweep: no overlap, no cut-off, hit-test matches layout ------------
|
|
|
|
// Across a representative width range: every visible slot is fully inside the bar's usable
|
|
// area, no two slots overlap, and every point that hit-tests to a button lands inside that
|
|
// button's drawn rect (hit-test and layout agree — the load-bearing consistency invariant).
|
|
static void testResizeSweepNoOverlapNoCutoff() {
|
|
const auto clusters = inventory();
|
|
const ActionBarSpec spec = roundSpec();
|
|
for (int w = 60; w <= 1000; w += 7) {
|
|
ActionBarRect bar{0, 0, w, 34};
|
|
auto slots = computeBarSlots(bar, clusters, spec);
|
|
int prevRight = bar.x + spec.sidePad - 1;
|
|
for (const auto& s : slots) {
|
|
// Inside the bar band.
|
|
CHECK(s.x >= bar.x);
|
|
CHECK(s.x + s.width <= bar.x + bar.width - spec.sidePad);
|
|
CHECK(s.y >= bar.y);
|
|
CHECK(s.y + s.height <= bar.y + bar.height);
|
|
// No overlap with the previous slot (strictly increasing, non-overlapping).
|
|
CHECK(s.x > prevRight);
|
|
prevRight = s.x + s.width - 1;
|
|
// Label rect stays inside the box.
|
|
CHECK(s.labelX >= s.x && s.labelX + s.labelW <= s.x + s.width);
|
|
CHECK(s.labelY >= s.y && s.labelY + s.labelH <= s.y + s.height);
|
|
}
|
|
// Hit-test agrees with layout for a mid-height row across the whole band.
|
|
for (int px = bar.x; px < bar.x + bar.width; px += 3) {
|
|
const int hit = hitTestActionBar(px, bar.y + bar.height / 2, bar, clusters, spec);
|
|
if (hit >= 0) {
|
|
bool found = false;
|
|
for (const auto& s : slots)
|
|
if (s.index == hit && px >= s.x && px < s.x + s.width) found = true;
|
|
CHECK(found);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int main() {
|
|
testAllFitRectsAndGaps();
|
|
testLabelFullHeight();
|
|
testLabelFullHeightWhenShort();
|
|
testOverflowDropsTrailingWhole();
|
|
testTooNarrowForAny();
|
|
testDegenerate();
|
|
testHitTestHitsButtons();
|
|
testHitTestGapsAreMisses();
|
|
testHitTestMissesOutsideBand();
|
|
testHitTestOverflowDeadZone();
|
|
testHitTestDegenerate();
|
|
testResizeSweepNoOverlapNoCutoff();
|
|
|
|
if (g_fail == 0) std::printf("All tests passed.\n");
|
|
return g_fail ? 1 : 0;
|
|
}
|