Fix stale post-widen deck-reflow figures (90/144/1190px) across docs and tests, and split test_deck_groups.cpp's width-budget fixtures into a new file.
This commit is contained in:
@@ -0,0 +1,399 @@
|
||||
// Layout-BUDGET tests for reasampler::instrument::ui::deck_groups, split from
|
||||
// test_deck_groups.cpp on the seam CMakeLists.txt already named: these fixtures need
|
||||
// sample_bands (the window-floor constants, computeSampleBands) and master_meter
|
||||
// (kMeterColumnW, MASTER's reserve), which test_deck_groups.cpp's WHICH-descriptors fixtures do
|
||||
// not. Pins the editor floor's derivation from the deck's width budget, the row/gutter
|
||||
// justification arithmetic at and above the floor, the pinned Gate group widths, and MASTER's
|
||||
// interior to the pixel. test_deck_groups.cpp pins WHICH descriptors the deck carries; this
|
||||
// file pins what the width budget MEASURES them at.
|
||||
|
||||
#include "../src/core/instrument/ui/deck_groups.h"
|
||||
#include "../src/core/instrument/ui/master_meter.h" // kMeterColumnW: MASTER's reserve IS this
|
||||
#include "../src/core/instrument/ui/sample_bands.h"
|
||||
|
||||
#include <cstdio>
|
||||
#include <vector>
|
||||
|
||||
using namespace reasampler;
|
||||
using namespace reasampler::instrument::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 editor's floor width, which is also its default (checkSizeConstraint clamps to it), less
|
||||
// the band allocator's kPad inset on each side.
|
||||
static constexpr int kAvailAtMinWidth = kEditorMinWidth - 2 * kPad;
|
||||
|
||||
static int indexOfGroup(const std::vector<DeckGroupDesc>& g, int id) {
|
||||
for (std::size_t i = 0; i < g.size(); ++i) {
|
||||
if (g[i].id == id) return static_cast<int>(i);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int cell(DeckParam p) { return static_cast<int>(p); }
|
||||
|
||||
// The guard the raised floor exists to provide: at the smallest window the host can produce,
|
||||
// the deck band still lands inside the client area AND the waveform still gets its two-lane
|
||||
// floor. Growing the deck past what the floor height can hold fails HERE instead of silently pushing
|
||||
// FILTER ENV / AMP / VOICE / MASTER off-screen, where there is no scroll to reach them.
|
||||
static void testDeckFitsInsideTheEnforcedMinimumWindow() {
|
||||
for (PlayMode mode : {PlayMode::Gate, PlayMode::Trigger}) {
|
||||
const std::vector<DeckGroupDesc> g = sampleDeckGroups(mode);
|
||||
const int h = deckHeight(g);
|
||||
const SampleBands b = computeSampleBands(kEditorMinWidth, kEditorMinHeight, h);
|
||||
CHECK(deckRowCount(g) == 2); // either face
|
||||
CHECK(b.decks.height == h);
|
||||
// The reflow's 112 px land in the waveform: at two rows the deck band is 216 and the
|
||||
// waveform 358, against 328/246 before. Pinned now that both are reached by
|
||||
// construction rather than by a pack outcome.
|
||||
CHECK(b.decks.height == 2 * kDeckGroupH + kDeckRowGap);
|
||||
CHECK(b.waveform.height == 358);
|
||||
// Bottom-anchored INSIDE the pad is the whole assertion: the degrade path pushes the
|
||||
// deck down until the waveform hits its floor, so any deck too tall to fit stops
|
||||
// landing on this exact line. A `<= kEditorMinHeight` bound would not catch it — the
|
||||
// degrade can still leave the deck ending at the window edge.
|
||||
CHECK(b.decks.bottom() == kEditorMinHeight - kPad);
|
||||
CHECK(b.waveform.height >= kWaveformMinHeight);
|
||||
}
|
||||
}
|
||||
|
||||
// The floor is a DERIVED number, and this is the one place the derivation is written down —
|
||||
// sample_bands stays independent of knob_deck, so neither header can hold it. This fixture is
|
||||
// the only one that includes both.
|
||||
static void testTheEditorFloorIsDerivedFromTheDeckWidthBudget() {
|
||||
CHECK(kDeckRowBlockW + kDeckGroupGap + kDeckSpanningW + 2 * kPad == kEditorMinWidth);
|
||||
// The budget: what is left between the derived floor and the hard ceiling, and it is spent
|
||||
// once. A cell costs 60 of it.
|
||||
CHECK(kEditorCeilingWidth - kEditorMinWidth == 82);
|
||||
// 82 still buys one more deck cell (60), which is the only purchase the ledger promises —
|
||||
// the widen below spent 8 px of slack, not the layout's purchasing power.
|
||||
CHECK(kEditorCeilingWidth - kEditorMinWidth >= kDeckCellW);
|
||||
// The reflow's 112 px goes entirely to the waveform, so the height does not move.
|
||||
CHECK(kEditorMinHeight == 680);
|
||||
// 1190 + 8: the row block was widened 1020 -> 1028 to put the two rows' filter edges on
|
||||
// one pixel, which is the only reason the floor moved off its originally specified value.
|
||||
CHECK(kEditorMinWidth == 1198);
|
||||
CHECK(kEditorMinWidth <= kEditorCeilingWidth);
|
||||
CHECK(kEditorMinHeight <= 720);
|
||||
// And the row block really is what the two rows justify inside — derived from the floor
|
||||
// and the spanning reserve, not restated.
|
||||
CHECK(kEditorMinWidth - 2 * kPad - kDeckSpanningW - kDeckGroupGap == kDeckRowBlockW);
|
||||
}
|
||||
|
||||
// Both rows now fit their block, in BOTH play modes. Row 1's fit is the one this track closes:
|
||||
// it was 1030, +42 from PITCH/RATE's third cell and −92 from FILTER's Band|Notch caption move
|
||||
// take it to 980. Row 2's 876 is mode-stable because FILTER ENV's and AMP's reserve slots hold
|
||||
// them at 312 in Trigger too — asserted here rather than assumed.
|
||||
static void testBothRowsAndTheSpanningDeckFitTheBudget() {
|
||||
for (PlayMode mode : {PlayMode::Gate, PlayMode::Trigger}) {
|
||||
const std::vector<DeckGroupDesc> g = sampleDeckGroups(mode);
|
||||
int width[3] = {0, 0, 0};
|
||||
int count[3] = {0, 0, 0};
|
||||
for (const DeckGroupDesc& d : g) {
|
||||
const int r = static_cast<int>(deckRowFor(static_cast<DeckGroupId>(d.id)));
|
||||
width[r] += deckGroupWidth(d);
|
||||
++count[r];
|
||||
}
|
||||
const int sound = static_cast<int>(DeckRow::Sound);
|
||||
const int contour = static_cast<int>(DeckRow::Contour);
|
||||
const int spanning = static_cast<int>(DeckRow::Spanning);
|
||||
|
||||
CHECK(count[sound] == 4);
|
||||
CHECK(width[sound] == 980); // 192 + 432 + 192 + 164
|
||||
CHECK(count[contour] == 3);
|
||||
CHECK(width[contour] == 876); // 252 + 312 + 312
|
||||
CHECK(count[spanning] == 1);
|
||||
CHECK(width[spanning] == kDeckSpanningW); // 142 exactly — the reserve is now spent
|
||||
|
||||
for (int r : {sound, contour}) {
|
||||
CHECK(width[r] <= kDeckRowBlockW);
|
||||
// Slack enough that no gutter in the row falls under the minimum.
|
||||
CHECK(kDeckRowBlockW - width[r] >= (count[r] - 1) * kDeckGroupGap);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// The gutters the justification law produces at the floor, and the alignment they buy.
|
||||
// At the 1028 block the justification law makes the tie-line exact by arithmetic rather than
|
||||
// by a special rule: row 1's slack is 48 over three gutters (16 each, no residue) and row 2's
|
||||
// is 152 over two (76 each), which lands both filter edges on 640. Only two of the three
|
||||
// properties §1.3 once claimed can hold at once — a smallest gutter of exactly kDeckGroupGap
|
||||
// needs a 1016 block — and 12 is a floor, not a target, so 16 satisfies the real rule.
|
||||
static void testGutterArithmeticAndTheFilterTieLineAtTheFloor() {
|
||||
const std::vector<DeckGroupDesc> g = sampleDeckGroups(PlayMode::Gate);
|
||||
const DeckLayout dl = layoutDeck(g, kPad, 0, kAvailAtMinWidth);
|
||||
|
||||
const auto box = [&](int id) {
|
||||
return dl.groups[static_cast<std::size_t>(indexOfGroup(g, id))].box;
|
||||
};
|
||||
// Row 1: flush left, flush right on the block, and three EQUAL gutters — 48 divides by 3
|
||||
// with no residue, so no gutter carries a leftover pixel.
|
||||
CHECK(box(kGroupPitch).x == kPad);
|
||||
CHECK(box(kGroupFilter).x - box(kGroupPitch).right() == 16);
|
||||
CHECK(box(kGroupVelocity).x - box(kGroupFilter).right() == 16);
|
||||
CHECK(box(kGroupVoice).x - box(kGroupVelocity).right() == 16);
|
||||
CHECK(box(kGroupVoice).right() == kPad + kDeckRowBlockW);
|
||||
|
||||
// Row 2: flush left, flush right, two gutters exactly equal.
|
||||
CHECK(box(kGroupPitchEnv).x == kPad);
|
||||
CHECK(box(kGroupFilterEnv).x - box(kGroupPitchEnv).right() == 76);
|
||||
CHECK(box(kGroupAmpEnv).x - box(kGroupFilterEnv).right() == 76);
|
||||
CHECK(box(kGroupAmpEnv).right() == kPad + kDeckRowBlockW);
|
||||
|
||||
// The tie-line, block-relative: both filter edges on ONE pixel, which is what the widen
|
||||
// bought. Pinned as an identity too, so a group-width change cannot pass by moving both.
|
||||
CHECK(box(kGroupFilterEnv).right() - kPad == 640);
|
||||
CHECK(box(kGroupFilter).right() - kPad == 640);
|
||||
CHECK(box(kGroupFilter).right() == box(kGroupFilterEnv).right());
|
||||
|
||||
// MASTER is right-anchored outside the block, one kDeckGroupGap clear of it.
|
||||
CHECK(box(kGroupMaster).x - box(kGroupVoice).right() == kDeckGroupGap);
|
||||
CHECK(box(kGroupMaster).right() == kPad + kAvailAtMinWidth);
|
||||
}
|
||||
|
||||
// No gutter is ever narrower than kDeckGroupGap at or above the floor, and both rows stay
|
||||
// flush at every width — the property the exact-at-the-floor numbers above are one point of.
|
||||
// Above the floor the tie-line DRIFTS, which is accepted and deliberate (§1.3): row 1 divides
|
||||
// its slack over three gutters and row 2 over two, so row 2's filter edge pulls right past
|
||||
// row 1's and the gap widens monotonically. Encoded as EXPECTED, not as a failure.
|
||||
//
|
||||
// Checked per ROW (tracking the last-seen box in each of the two categorical rows while
|
||||
// walking dl.groups in deck order), not just deck-order neighbours: two same-row groups can
|
||||
// sit apart in deck order with a different-row group between them, and a deck-order-only
|
||||
// check would silently skip that gutter.
|
||||
static void testGuttersHoldTheirMinimumAndTheTieLineDriftsAboveTheFloor() {
|
||||
for (PlayMode mode : {PlayMode::Gate, PlayMode::Trigger}) {
|
||||
const std::vector<DeckGroupDesc> g = sampleDeckGroups(mode);
|
||||
int lastDrift = 1 << 20; // sentinel above any real drift
|
||||
for (int avail = kAvailAtMinWidth; avail <= kAvailAtMinWidth + 600; avail += 37) {
|
||||
const DeckLayout dl = layoutDeck(g, kPad, 0, avail);
|
||||
const DeckGroupLayout* prevInRow[2] = {nullptr, nullptr};
|
||||
for (const DeckGroupLayout& gl : dl.groups) {
|
||||
const DeckRow row = deckRowFor(static_cast<DeckGroupId>(gl.id));
|
||||
if (row == DeckRow::Spanning) continue;
|
||||
const int r = row == DeckRow::Contour ? 1 : 0;
|
||||
if (prevInRow[r]) {
|
||||
CHECK(gl.box.x - prevInRow[r]->box.right() >= kDeckGroupGap);
|
||||
}
|
||||
prevInRow[r] = ≷
|
||||
}
|
||||
const auto right = [&](int id) {
|
||||
return dl.groups[static_cast<std::size_t>(indexOfGroup(g, id))].box.right();
|
||||
};
|
||||
// Flush right on the block at every width, both rows.
|
||||
CHECK(right(kGroupVoice) == right(kGroupAmpEnv));
|
||||
// Monotone in width rather than oscillating: row 2's two gutters absorb slack
|
||||
// faster than row 1's three, so the gap only ever opens.
|
||||
const int drift = right(kGroupFilter) - right(kGroupFilterEnv);
|
||||
CHECK(drift <= lastDrift);
|
||||
lastDrift = drift;
|
||||
}
|
||||
// It really does open up: the tie-line is exact AT the floor and separates above it,
|
||||
// which is the accepted outcome rather than a near-miss to be pinned back.
|
||||
CHECK(lastDrift < -50);
|
||||
}
|
||||
}
|
||||
|
||||
// MASTER's interior, exact to the pixel (§1.4). The two left slots sit on the two rows' own
|
||||
// knob baselines — that is what "stitched to both rows" means — and the meter is ONE rect
|
||||
// across both, never a readout per row.
|
||||
static void testTheMasterDeckInteriorLandsOnBothRowBaselines() {
|
||||
const std::vector<DeckGroupDesc> g = sampleDeckGroups(PlayMode::Gate);
|
||||
const DeckLayout dl = layoutDeck(g, kPad, 0, kAvailAtMinWidth);
|
||||
const DeckGroupLayout& m =
|
||||
dl.groups[static_cast<std::size_t>(indexOfGroup(g, kGroupMaster))];
|
||||
|
||||
CHECK(m.box.width == kDeckSpanningW);
|
||||
CHECK(m.box.height == 216);
|
||||
// 6 + 60 + 8 + 62 + 6 — the decomposition, not just the total, and the 62 is the meter
|
||||
// module's own kMeterColumnW rather than a copy of it. That link is the whole point: the
|
||||
// column is banked to GROW (§1.2), and a reserve that did not track it would leave the
|
||||
// interior underfilling or overrunning with every test still green.
|
||||
CHECK(kDeckGroupPadX + kDeckCellW + kDeckColumnGap + kMeterColumnW + kDeckGroupPadX ==
|
||||
kDeckSpanningW);
|
||||
CHECK(m.column.id == cell(DeckParam::kMasterMeter));
|
||||
CHECK(m.column.box.width == kMeterColumnW);
|
||||
|
||||
// One cell drawn (gain) and one slot RESERVED below it: the reserve is height at a fixed
|
||||
// position and draws nothing.
|
||||
CHECK(m.cells.size() == 1);
|
||||
CHECK(m.cells[0].id == cell(DeckParam::kMasterGain));
|
||||
CHECK(m.cells[0].cell.y - m.box.y == 26);
|
||||
const int reserveTop = m.cells[0].cell.y + kDeckGroupH + kDeckRowGap;
|
||||
CHECK(reserveTop - m.box.y == 138);
|
||||
|
||||
// The two baselines are row 1's and row 2's own.
|
||||
const DeckGroupLayout& filter =
|
||||
dl.groups[static_cast<std::size_t>(indexOfGroup(g, kGroupFilter))];
|
||||
const DeckGroupLayout& amp =
|
||||
dl.groups[static_cast<std::size_t>(indexOfGroup(g, kGroupAmpEnv))];
|
||||
CHECK(m.cells[0].cell.y == filter.cells[0].cell.y);
|
||||
CHECK(reserveTop == amp.cells[0].cell.y);
|
||||
|
||||
// The meter: one rect spanning both baselines, 62 x 186.
|
||||
CHECK(m.column.id == cell(DeckParam::kMasterMeter));
|
||||
CHECK(m.column.box.width == kMeterColumnW);
|
||||
CHECK(m.column.box.height == 186);
|
||||
CHECK(m.column.box.y == m.cells[0].cell.y);
|
||||
CHECK(m.column.box.bottom() - m.box.y == 212);
|
||||
}
|
||||
|
||||
// The regression guard for the rule most likely to be "generalised" wrongly: MASTER's left
|
||||
// column is FIXED slots at the two baselines, NOT knob_deck's horizontal run-division law
|
||||
// applied vertically — which would stretch the one gain knob over the whole 186 px.
|
||||
static void testTheMasterColumnDoesNotDivideItsRunVertically() {
|
||||
const std::vector<DeckGroupDesc> g = sampleDeckGroups(PlayMode::Gate);
|
||||
const DeckLayout dl = layoutDeck(g, kPad, 0, kAvailAtMinWidth);
|
||||
const DeckGroupLayout& m =
|
||||
dl.groups[static_cast<std::size_t>(indexOfGroup(g, kGroupMaster))];
|
||||
CHECK(m.cells[0].cell.height == kDeckCellH);
|
||||
CHECK(m.cells[0].cell.width == kDeckCellW);
|
||||
// Under the run-division law the lone present cell would take the whole two-slot run;
|
||||
// here it takes exactly one slot and leaves the rest empty.
|
||||
CHECK(m.cells[0].cell.height < m.column.box.height);
|
||||
CHECK(m.cells[0].cell.bottom() < m.column.box.bottom());
|
||||
CHECK(m.cells[0].knob.width == kDeckKnobSize && m.cells[0].knob.height == kDeckKnobSize);
|
||||
// And dropping the reserve does not move the gain knob or the meter — the slot below it is
|
||||
// reserved height, so nothing above it depends on whether it is there.
|
||||
std::vector<DeckGroupDesc> noReserve = g;
|
||||
for (DeckGroupDesc& d : noReserve) {
|
||||
if (d.id == kGroupMaster) d.cellIds = {cell(DeckParam::kMasterGain)};
|
||||
}
|
||||
const DeckLayout dl2 = layoutDeck(noReserve, kPad, 0, kAvailAtMinWidth);
|
||||
const DeckGroupLayout& m2 =
|
||||
dl2.groups[static_cast<std::size_t>(indexOfGroup(noReserve, kGroupMaster))];
|
||||
CHECK(m2.cells[0].cell == m.cells[0].cell);
|
||||
CHECK(m2.column.box == m.column.box);
|
||||
}
|
||||
|
||||
// MASTER's caption row and knob row measure exactly equal (130 == 130) today, so a column
|
||||
// derived from either edge lands in the same place — that balance is what let a left-derived
|
||||
// offset masquerade as right-anchored. Widen the caption reserve alone (as a wider caption or
|
||||
// a limiter-toggle change would) and the column must still land flush against the group's own
|
||||
// right padding, derived from innerRight rather than measured past the cell slots.
|
||||
static void testMasterColumnStaysRightAnchoredWhenCaptionRowOutgrowsTheKnobRow() {
|
||||
const std::vector<DeckGroupDesc> g = sampleDeckGroups(PlayMode::Gate);
|
||||
DeckGroupDesc probe = g[static_cast<std::size_t>(indexOfGroup(g, kGroupMaster))];
|
||||
probe.captionWidth += 40; // unbalances it: the caption row now measures past the knob row
|
||||
const std::vector<DeckGroupDesc> one = {probe};
|
||||
const DeckLayout dl = layoutDeck(one, kPad, 0, kAvailAtMinWidth);
|
||||
const DeckGroupLayout& m = dl.groups[0];
|
||||
CHECK(m.box.width > kDeckSpanningW); // the widen is real, not absorbed elsewhere
|
||||
CHECK(m.column.box.right() == m.box.right() - kDeckGroupPadX);
|
||||
}
|
||||
|
||||
// The three mode toggles ride each env group's caption slack, on the CONTOUR row: raising
|
||||
// their segment width past the caption headroom would widen that row and eat its gutters,
|
||||
// not add a row — row count is a property of the group inventory, not of width.
|
||||
static void testTheModeTogglesCostNoGroupWidth() {
|
||||
for (PlayMode mode : {PlayMode::Gate, PlayMode::Trigger}) {
|
||||
for (const DeckGroupDesc& g : sampleDeckGroups(mode)) {
|
||||
if (g.captionToggle2.id < 0) continue;
|
||||
DeckGroupDesc without = g;
|
||||
without.captionToggle2 = DeckToggleDesc{};
|
||||
CHECK(deckGroupWidth(g) == deckGroupWidth(without));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// PITCH/RATE carries three cells and measures exactly 192 — the KNOB row (3 x kDeckCellW plus
|
||||
// padding) is what it measures from, and the caption row must stay under that. The ceiling is
|
||||
// asserted by construction rather than as a comment: at a caption reserve of 80 the group is
|
||||
// still 192, and at 81 it is not, which is the whole content of "hard ceiling 80". Widening the
|
||||
// group is not the remedy if the caption text ever outgrows it — narrowing the mode toggle is.
|
||||
static void testThePitchRateGroupIsKnobRowDrivenAtExactlyOneNinetyTwo() {
|
||||
const std::vector<DeckGroupDesc> g = sampleDeckGroups(PlayMode::Gate);
|
||||
const DeckGroupDesc* pitch = nullptr;
|
||||
for (const DeckGroupDesc& d : g) if (d.id == kGroupPitch) pitch = &d;
|
||||
CHECK(pitch != nullptr);
|
||||
if (!pitch) return;
|
||||
CHECK(pitch->cellIds.size() == 3);
|
||||
CHECK(pitch->cellIds[0] == static_cast<int>(DeckParam::kKeyTrack));
|
||||
CHECK(pitch->cellIds[1] == static_cast<int>(DeckParam::kRate));
|
||||
CHECK(pitch->cellIds[2] == static_cast<int>(DeckParam::kPitch));
|
||||
CHECK(deckGroupWidth(*pitch) == 192);
|
||||
CHECK(3 * kDeckCellW + 2 * kDeckGroupPadX == 192); // the knob row IS the measurement
|
||||
|
||||
DeckGroupDesc probe = *pitch;
|
||||
probe.captionWidth = 80;
|
||||
CHECK(deckGroupWidth(probe) == 192); // at the ceiling the caption row still fits under it
|
||||
probe.captionWidth = 81;
|
||||
CHECK(deckGroupWidth(probe) > 192); // one past it, the caption row takes over
|
||||
}
|
||||
|
||||
// The kEnvModeSegW ceilings recorded in deck_groups.cpp's own comment (PITCH ENV binds at 47,
|
||||
// AMP at 55) pinned against the descriptors they derive from, the same way the Pitch/Rate
|
||||
// caption ceiling above is: a change to either group's caption width or its enable toggle
|
||||
// would otherwise invalidate the recorded numbers with nothing failing.
|
||||
static void testEnvModeSegWCeilingsArePinnedForPitchEnvAndAmp() {
|
||||
const std::vector<DeckGroupDesc> g = sampleDeckGroups(PlayMode::Gate);
|
||||
const DeckGroupDesc& penv = g[static_cast<std::size_t>(indexOfGroup(g, kGroupPitchEnv))];
|
||||
const DeckGroupDesc& amp = g[static_cast<std::size_t>(indexOfGroup(g, kGroupAmpEnv))];
|
||||
CHECK(deckGroupWidth(penv) == 252);
|
||||
CHECK(deckGroupWidth(amp) == 312);
|
||||
|
||||
DeckGroupDesc penvProbe = penv;
|
||||
penvProbe.captionToggle2.segWidth = 47;
|
||||
CHECK(deckGroupWidth(penvProbe) == 252); // at the ceiling, still knob-row-driven
|
||||
penvProbe.captionToggle2.segWidth = 48;
|
||||
CHECK(deckGroupWidth(penvProbe) > 252); // one past it, the caption row takes over
|
||||
|
||||
DeckGroupDesc ampProbe = amp;
|
||||
ampProbe.captionToggle2.segWidth = 55;
|
||||
CHECK(deckGroupWidth(ampProbe) == 312);
|
||||
ampProbe.captionToggle2.segWidth = 56;
|
||||
CHECK(deckGroupWidth(ampProbe) > 312);
|
||||
}
|
||||
|
||||
// Every group's width, in BOTH play modes, against the measured layout table
|
||||
// (instrument-control-surface.md §1.2). Mode-independence is the second half of the claim: the
|
||||
// reserve slots hold the two mode-dependent groups at 312 either way, which is what makes the
|
||||
// contour row's 876 a constant rather than a Gate-only fact.
|
||||
static void testEveryGroupWidthMatchesTheMeasuredLayout() {
|
||||
const struct { int id; int width; } want[] = {
|
||||
{kGroupPitch, 192}, {kGroupPitchEnv, 252}, {kGroupFilter, 432},
|
||||
{kGroupFilterEnv, 312}, {kGroupAmpEnv, 312}, {kGroupVelocity, 192},
|
||||
{kGroupVoice, 164}, {kGroupMaster, 142},
|
||||
};
|
||||
for (PlayMode mode : {PlayMode::Gate, PlayMode::Trigger}) {
|
||||
const std::vector<DeckGroupDesc> g = sampleDeckGroups(mode);
|
||||
CHECK(g.size() == sizeof(want) / sizeof(want[0]));
|
||||
const DeckLayout dl = layoutDeck(g, kPad, 0, kAvailAtMinWidth);
|
||||
for (const auto& w : want) {
|
||||
const int i = indexOfGroup(g, w.id);
|
||||
CHECK(i >= 0);
|
||||
if (i < 0) continue;
|
||||
CHECK(deckGroupWidth(g[static_cast<std::size_t>(i)]) == w.width);
|
||||
const DeckGroupLayout& lay =
|
||||
dl.groups[static_cast<std::size_t>(indexOfGroup(g, w.id))];
|
||||
CHECK(lay.box.width == w.width);
|
||||
}
|
||||
// Gate carries no reserves, so its cells are the deck's base size; Trigger's two
|
||||
// reduced faces divide the same reserved run between fewer cells and get wider ones.
|
||||
for (const DeckGroupLayout& lay : dl.groups) {
|
||||
for (const DeckCellLayout& c : lay.cells) {
|
||||
CHECK(c.cell.width >= kDeckCellW);
|
||||
if (mode == PlayMode::Gate) CHECK(c.cell.width == kDeckCellW);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int main() {
|
||||
testDeckFitsInsideTheEnforcedMinimumWindow();
|
||||
testTheEditorFloorIsDerivedFromTheDeckWidthBudget();
|
||||
testBothRowsAndTheSpanningDeckFitTheBudget();
|
||||
testGutterArithmeticAndTheFilterTieLineAtTheFloor();
|
||||
testGuttersHoldTheirMinimumAndTheTieLineDriftsAboveTheFloor();
|
||||
testTheMasterDeckInteriorLandsOnBothRowBaselines();
|
||||
testTheMasterColumnDoesNotDivideItsRunVertically();
|
||||
testMasterColumnStaysRightAnchoredWhenCaptionRowOutgrowsTheKnobRow();
|
||||
testTheModeTogglesCostNoGroupWidth();
|
||||
testThePitchRateGroupIsKnobRowDrivenAtExactlyOneNinetyTwo();
|
||||
testEnvModeSegWCeilingsArePinnedForPitchEnvAndAmp();
|
||||
testEveryGroupWidthMatchesTheMeasuredLayout();
|
||||
if (g_fail == 0) std::printf("deck_groups_measured: all tests passed\n");
|
||||
return g_fail == 0 ? 0 : 1;
|
||||
}
|
||||
Reference in New Issue
Block a user