reasampler/tests/test_editor_geometry.cpp

// Standalone tests for reasampler::instrument::ui::editor_geometry — no VST3, no REAPER, no test
// framework. Same fast assert loop as the sibling pure tests (mode_switch et al.):
// assert the IPlugView LICE editor's layout math + hit-testing directly.
//
// Covers: contains() half-open convention + degenerate rects; layoutEditor regions on a
// normal view (title band + button + canvas), a tiny view (button clamped to canvas,
// never overhanging), and a zero view (all rects empty, no inversion); hitTest hitting
// the button, missing on the title/canvas, missing outside the surface, and boundary
// pixels; layout<->hit-test agreement (a click on the drawn button rect hits it).

#include "../src/core/instrument/ui/editor_geometry.h"

#include <cstdio>

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)

// --- contains() ---------------------------------------------------------------

static void testContainsHalfOpen() {
    Rect r = Rect::ltrb(10, 20, 50, 40);  // [10,50) x [20,40)
    CHECK(contains(r, 10, 20));     // top-left inclusive
    CHECK(contains(r, 49, 39));     // bottom-right exclusive edge, inside
    CHECK(!contains(r, 50, 30));    // right edge excluded
    CHECK(!contains(r, 30, 40));    // bottom edge excluded
    CHECK(!contains(r, 9, 30));     // left of rect
    CHECK(!contains(r, 30, 19));    // above rect
}

static void testContainsDegenerate() {
    CHECK(!contains(Rect::ltrb(10, 10, 10, 20), 10, 15));  // zero width
    CHECK(!contains(Rect::ltrb(10, 10, 20, 10), 15, 10));  // zero height
    CHECK(!contains(Rect::ltrb(20, 10, 10, 20), 15, 15));  // inverted (right < left)
}

// --- layoutEditor: normal view ------------------------------------------------

static void testLayoutNormalView() {
    // A comfortable 400x260 view: title band spans the top full width; canvas is the
    // rest; button sits inside the canvas, inset by the margin.
    const EditorLayout L = layoutEditor(400, 260);

    CHECK(L.titleBar.x == 0 && L.titleBar.y == 0);
    CHECK(L.titleBar.right() == 400);
    CHECK(L.titleBar.height > 0 && L.titleBar.height <= 260);

    // Canvas begins right below the title bar and reaches the bottom-right.
    CHECK(L.canvas.y == L.titleBar.bottom());
    CHECK(L.canvas.right() == 400 && L.canvas.bottom() == 260);

    // Button is inside the canvas (does not overhang any edge).
    CHECK(L.button.x >= L.canvas.x);
    CHECK(L.button.y >= L.canvas.y);
    CHECK(L.button.right() <= L.canvas.right());
    CHECK(L.button.bottom() <= L.canvas.bottom());
    CHECK(L.button.width > 0 && L.button.height > 0);
}

// --- layoutEditor: tiny view (clamping) ---------------------------------------

static void testLayoutTinyViewClampsButton() {
    // A view narrower/shorter than the button's natural size: the button must clamp to
    // the canvas and never produce an inverted or overhanging rect.
    const EditorLayout L = layoutEditor(40, 40);
    CHECK(L.button.right() <= L.canvas.right());
    CHECK(L.button.bottom() <= L.canvas.bottom());
    CHECK(L.button.right() >= L.button.x);   // never inverted
    CHECK(L.button.bottom() >= L.button.y);
    // Title bar clamps to the client height when the view is shorter than its height.
    CHECK(L.titleBar.bottom() <= 40);
}

// --- layoutEditor: zero view (all empty, no inversion) ------------------------

static void testLayoutZeroView() {
    const EditorLayout L = layoutEditor(0, 0);
    CHECK(L.titleBar.width <= 0 || L.titleBar.height <= 0);
    CHECK(L.canvas.width <= 0 || L.canvas.height <= 0);
    // No rect is inverted.
    CHECK(L.button.right() >= L.button.x);
    CHECK(L.button.bottom() >= L.button.y);
    CHECK(L.canvas.right() >= L.canvas.x);
    CHECK(L.canvas.bottom() >= L.canvas.y);
    // A click anywhere on an empty layout hits nothing.
    CHECK(hitTest(L, 0, 0) == HitTarget::kNone);
    CHECK(hitTest(L, 5, 5) == HitTarget::kNone);
}

// --- hitTest ------------------------------------------------------------------

static void testHitTestButton() {
    const EditorLayout L = layoutEditor(400, 260);
    // Center of the button hits it.
    const int cx = (L.button.x + L.button.right()) / 2;
    const int cy = (L.button.y + L.button.bottom()) / 2;
    CHECK(hitTest(L, cx, cy) == HitTarget::kButton);
}

static void testHitTestMissesNonButton() {
    const EditorLayout L = layoutEditor(400, 260);
    // Title bar is inert in the spike.
    CHECK(hitTest(L, 200, L.titleBar.y + 1) == HitTarget::kNone);
    // Empty canvas away from the button.
    CHECK(hitTest(L, 380, 240) == HitTarget::kNone);
    // Outside the surface entirely.
    CHECK(hitTest(L, -5, -5) == HitTarget::kNone);
    CHECK(hitTest(L, 500, 500) == HitTarget::kNone);
}

static void testHitTestButtonBoundary() {
    const EditorLayout L = layoutEditor(400, 260);
    // Top-left corner of the button is inclusive; the right/bottom edges are excluded.
    CHECK(hitTest(L, L.button.x, L.button.y) == HitTarget::kButton);
    CHECK(hitTest(L, L.button.right(), L.button.y) == HitTarget::kNone);
    CHECK(hitTest(L, L.button.x, L.button.bottom()) == HitTarget::kNone);
}

// --- layout<->hit-test agreement ----------------------------------------------

// Every pixel inside the drawn button rect must hit the button; this is the
// load-bearing consistency invariant between what the shell draws and what it routes.
static void testHitTestMatchesDrawnButton() {
    const EditorLayout L = layoutEditor(320, 200);
    for (int y = L.button.y; y < L.button.bottom(); ++y) {
        for (int x = L.button.x; x < L.button.right(); ++x) {
            CHECK(hitTest(L, x, y) == HitTarget::kButton);
        }
    }
}

// --- sample list (S4) ---------------------------------------------------------

static void testSampleRowRectStacks() {
    const EditorLayout L = layoutEditor(400, 260);
    const Rect r0 = sampleRowRect(L, 0);
    const Rect r1 = sampleRowRect(L, 1);
    // Row 0 starts at the canvas top and spans its full width.
    CHECK(r0.y == L.canvas.y);
    CHECK(r0.x == L.canvas.x && r0.right() == L.canvas.right());
    CHECK(r0.height == kSampleRowHeight);
    // Row 1 sits directly below row 0 (no gap, no overlap).
    CHECK(r1.y == r0.bottom());
    CHECK(r1.height == kSampleRowHeight);
    // A negative index is an empty rect.
    CHECK(sampleRowRect(L, -1).width == 0 && sampleRowRect(L, -1).height == 0);
}

static void testSampleRowHitTestMapsClickToRow() {
    const EditorLayout L = layoutEditor(400, 260);
    const int rows = 5;
    // A click in the vertical middle of row 2 resolves to index 2.
    const Rect r2 = sampleRowRect(L, 2);
    const int midY = (r2.y + r2.bottom()) / 2;
    CHECK(sampleRowHitTest(L, rows, 200, midY) == 2);
    // Row 0's top-left corner hits row 0.
    const Rect r0 = sampleRowRect(L, 0);
    CHECK(sampleRowHitTest(L, rows, r0.x, r0.y) == 0);
}

static void testSampleRowHitTestMisses() {
    const EditorLayout L = layoutEditor(400, 260);
    const int rows = 3;
    // Above the first row (in the title bar) -> no row.
    CHECK(sampleRowHitTest(L, rows, 200, L.titleBar.y) == -1);
    // Below the last row -> no row.
    const Rect last = sampleRowRect(L, rows - 1);
    CHECK(sampleRowHitTest(L, rows, 200, last.bottom() + 1) == -1);
    // Left of the canvas -> no row.
    CHECK(sampleRowHitTest(L, rows, L.canvas.x - 1, last.y) == -1);
    // Zero rows -> always -1.
    CHECK(sampleRowHitTest(L, 0, 200, L.canvas.y + 1) == -1);
    // At or below canvas.bottom() -> always -1, even if rowCount would cover that y.
    // This guards paint<->hit-test agreement: sampleRowRect does not clamp to canvas,
    // so without this clip a row that extends past canvas.bottom() would hit-test but
    // never be drawn (or vice versa).
    CHECK(sampleRowHitTest(L, rows, 200, L.canvas.bottom()) == -1);
    // Use a large rowCount so index arithmetic would return a valid row without the
    // canvas.bottom() guard — proving the guard fires independently of rowCount.
    const int bigRows = 1000;
    CHECK(sampleRowHitTest(L, bigRows, 200, L.canvas.bottom()) == -1);
    CHECK(sampleRowHitTest(L, bigRows, 200, L.canvas.bottom() + 5) == -1);
}

// The drawn-row <-> hit-test agreement: every pixel inside a row rect must resolve to
// that row's index (the same load-bearing invariant as the button).
static void testSampleRowHitTestMatchesDrawnRows() {
    const EditorLayout L = layoutEditor(320, 200);
    const int rows = 4;
    for (int i = 0; i < rows; ++i) {
        const Rect r = sampleRowRect(L, i);
        if (r.y >= L.canvas.bottom()) break;  // clipped rows aren't clickable targets
        const int y = (r.y + r.bottom()) / 2;
        if (y >= L.canvas.bottom()) continue;
        CHECK(sampleRowHitTest(L, rows, r.x + 1, y) == i);
    }
}

// --- keymap editor (S5 Tier-1 UI) --------------------------------------------

static void testKeymapLayoutSplitsCanvas() {
    const KeymapEditorLayout L = layoutKeymapEditor(600, 300);
    // The left sample list and right zone panel partition the canvas with no overlap and
    // no gap: the list's right edge is the panel's left edge.
    CHECK(L.sampleList.x == L.base.canvas.x);
    CHECK(L.sampleList.right() == L.zonePanel.x);
    CHECK(L.zonePanel.right() == L.base.canvas.right());
    CHECK(L.sampleList.y == L.base.canvas.y);
    CHECK(L.zonePanel.y == L.base.canvas.y);
    CHECK(L.sampleList.bottom() == L.base.canvas.bottom());
    CHECK(L.zonePanel.bottom() == L.base.canvas.bottom());
    CHECK(L.sampleList.width > 0 && L.zonePanel.width > 0);
    // Add-Zone button caps the panel; zone rows stack below it.
    CHECK(L.addZoneButton.y == L.zonePanel.y);
    CHECK(L.addZoneButton.x == L.zonePanel.x && L.addZoneButton.right() == L.zonePanel.right());
    CHECK(L.zoneRowArea.y == L.addZoneButton.bottom());
    CHECK(L.zoneRowArea.bottom() == L.zonePanel.bottom());
}

static void checkNoInversion(const KeymapEditorLayout& L) {
    CHECK(L.sampleList.right() >= L.sampleList.x);
    CHECK(L.zonePanel.right() >= L.zonePanel.x);
    CHECK(L.addZoneButton.right() >= L.addZoneButton.x);
    CHECK(L.addZoneButton.bottom() >= L.addZoneButton.y);
    CHECK(L.zoneRowArea.right() >= L.zoneRowArea.x);
    CHECK(L.zoneRowArea.bottom() >= L.zoneRowArea.y);
    // Regions stay within the client area.
    CHECK(L.zonePanel.right() <= L.base.canvas.right());
}

static void testKeymapLayoutTinyAndZeroNoInversion() {
    checkNoInversion(layoutKeymapEditor(30, 30));
    checkNoInversion(layoutKeymapEditor(0, 0));
    // A click anywhere on a zero layout hits no zone and no Add button.
    const KeymapEditorLayout Z = layoutKeymapEditor(0, 0);
    CHECK(zoneHitTest(Z, 3, 0, 0).zoneIndex == -1);
    CHECK(!addZoneHitTest(Z, 0, 0));
}

static void testKeymapSampleRowInLeftColumn() {
    const KeymapEditorLayout L = layoutKeymapEditor(600, 300);
    const Rect r0 = keymapSampleRowRect(L, 0);
    // Rows live in the LEFT column (not the full canvas width).
    CHECK(r0.x == L.sampleList.x && r0.right() == L.sampleList.right());
    CHECK(r0.right() < L.base.canvas.right());  // strictly left of the zone panel
    CHECK(r0.y == L.sampleList.y && r0.height == kSampleRowHeight);
    // Hit-test maps a left-column click to the row and rejects a click in the zone panel.
    const int midY = (r0.y + r0.bottom()) / 2;
    CHECK(keymapSampleRowHitTest(L, 3, r0.x + 2, midY) == 0);
    CHECK(keymapSampleRowHitTest(L, 3, L.zonePanel.x + 2, midY) == -1);
}

static void testAddZoneHitTest() {
    const KeymapEditorLayout L = layoutKeymapEditor(600, 300);
    const int cx = (L.addZoneButton.x + L.addZoneButton.right()) / 2;
    const int cy = (L.addZoneButton.y + L.addZoneButton.bottom()) / 2;
    CHECK(addZoneHitTest(L, cx, cy));
    // A click in the zone-row area below the button is NOT the Add button.
    CHECK(!addZoneHitTest(L, cx, L.zoneRowArea.y + 2));
    // A click in the left list is NOT the Add button.
    CHECK(!addZoneHitTest(L, L.sampleList.x + 2, L.sampleList.y + 2));
}

static void testZoneRowStacksAndSelects() {
    const KeymapEditorLayout L = layoutKeymapEditor(600, 300);
    const Rect z0 = zoneRowRect(L, 0);
    const Rect z1 = zoneRowRect(L, 1);
    CHECK(z0.y == L.zoneRowArea.y && z0.height == kZoneRowHeight);
    CHECK(z1.y == z0.bottom());  // stacked, no gap
    CHECK(z0.x == L.zoneRowArea.x && z0.right() == L.zoneRowArea.right());
    // A click on the LABEL area (left part of a zone row) selects the zone with no field.
    const int labelX = z0.x + 2;  // far left = label, not a control
    const int midY = (z0.y + z0.bottom()) / 2;
    const ZoneHit h = zoneHitTest(L, 2, labelX, midY);
    CHECK(h.zoneIndex == 0 && h.field == ZoneField::kZoneNone);
}

static void testZoneRowControlsMapToFields() {
    const KeymapEditorLayout L = layoutKeymapEditor(600, 300);
    const Rect row = zoneRowRect(L, 0);
    const int midY = (row.y + row.bottom()) / 2;
    // The seven controls occupy the rightmost 7*kZoneCtrlWidth px, left-to-right:
    // low-, low+, high-, high+, root-, root+, delete.
    const int block = row.right() - 7 * kZoneCtrlWidth;
    const ZoneField expected[7] = {
        ZoneField::kLowDown, ZoneField::kLowUp,  ZoneField::kHighDown,
        ZoneField::kHighUp,  ZoneField::kRootDown, ZoneField::kRootUp,
        ZoneField::kDelete,
    };
    for (int s = 0; s < 7; ++s) {
        const int x = block + s * kZoneCtrlWidth + kZoneCtrlWidth / 2;  // center of slot s
        const ZoneHit h = zoneHitTest(L, 1, x, midY);
        CHECK(h.zoneIndex == 0);
        CHECK(h.zoneIndex == 0 && h.field == expected[s]);
    }
}

static void testZoneHitTestMisses() {
    const KeymapEditorLayout L = layoutKeymapEditor(600, 300);
    const Rect row = zoneRowRect(L, 0);
    const int midY = (row.y + row.bottom()) / 2;
    // Zero zones -> always miss.
    CHECK(zoneHitTest(L, 0, row.x + 2, midY).zoneIndex == -1);
    // Below the last zone row -> miss.
    const Rect last = zoneRowRect(L, 2);
    CHECK(zoneHitTest(L, 3, row.x + 2, last.bottom() + 1).zoneIndex == -1);
    // Left of the zone panel (in the sample list) -> miss.
    CHECK(zoneHitTest(L, 3, L.sampleList.x + 2, midY).zoneIndex == -1);
}

// --- r11 Sample / Zone face layout (Q-W2v hoist, T2-06) ----------------------

// The band stack at the default 840x620 with a 120px deck: title / hero / cluster /
// deck in order, hero elastic (absorbs the slack), deck bottom-anchored at kPad.
static void testSampleBandsStackAndElasticHero() {
    const SampleBands b = computeSampleBands(840, 620, 120);
    CHECK(b.title.y == 0 && b.title.height == kTitleHeight && b.title.width == 840);
    CHECK(b.hero.y == b.title.bottom());
    CHECK(b.hero.height >= 150);                       // above the hero floor
    CHECK(b.cluster.y > b.hero.bottom());              // cluster below the hero (+gap)
    CHECK(b.deck.bottom() == 620 - kPad);              // deck bottom-anchored
    CHECK(b.deck.height == 120);
    // Nav buttons right-anchored inside the title band, Browse left of Zone.
    CHECK(b.navZone.right() == 840 - kPad);
    CHECK(b.navBrowse.right() < b.navZone.x);
    CHECK(b.navZone.bottom() <= b.title.bottom());
    // A too-short window: the hero keeps its floor; the lower bands clip below.
    const SampleBands s = computeSampleBands(840, 200, 120);
    CHECK(s.hero.height == 150);
    CHECK(s.deck.bottom() > 200);  // clips past the window bottom (defensive case)
}

// The cluster's right-anchored run tiles left of the channel toggle without overlap:
// rootStrip | preview | velCell(velKnob+velLabel) | curveBtn | (toggle).
static void testClusterRectsRunAndKnobCentering() {
    const Rect cluster = Rect::ltrb(0, 500, 840, 552);
    const ChannelToggleRects chan = channelToggleRects(cluster);
    CHECK(chan.stereo.right() == 840 - kPad);
    CHECK(chan.mono.right() == chan.stereo.x);
    const ClusterRects cr = clusterRects(cluster, chan.mono, 28);
    CHECK(cr.curveBtn.right() == chan.mono.x - kPad);
    CHECK(cr.velCell.right() == cr.curveBtn.x - kPad);
    CHECK(cr.preview.right() == cr.velCell.x - kPad);
    CHECK(cr.rootStrip.x == cluster.x + kPad);
    CHECK(cr.rootStrip.right() == cr.preview.x - kPad);
    // The knob square centers in the cell and the label band sits beneath it.
    CHECK(cr.velKnob.width == 28);
    CHECK(cr.velKnob.x - cr.velCell.x == cr.velCell.right() - cr.velKnob.right());
    CHECK(cr.velLabel.y == cr.velKnob.bottom());
    CHECK(cr.velLabel.bottom() == cr.velCell.bottom());
}

// The Zone surface: content below the title; strip below the add/delete row; the note
// entry fields tile in three ordered segments; deck + curve button split the panel.
static void testZoneSurfaceLayoutAnchors() {
    const Rect content = zoneContentArea(840, 620);
    CHECK(content.y == kTitleHeight && content.bottom() == 620);
    const Rect back = zoneBackRect(840, 620);
    CHECK(back.right() == 840 - kPad && back.bottom() <= kTitleHeight);
    const Rect addR = zoneAddRect(content);
    const Rect delR = zoneDeleteRect(addR);
    CHECK(addR.y == content.y + 4);
    CHECK(delR.x == addR.right() + 8 && delR.y == addR.y);
    const Rect strip = zonesStripArea(content);
    CHECK(strip.y == addR.bottom() + 12);
    CHECK(strip.x == content.x + kPad && strip.right() == content.right() - kPad);
    const Rect fields = noteEntryFieldsArea(content);
    CHECK(fields.y == strip.bottom() + 8);
    const Rect f0 = noteEntryFieldRect(fields, 0);
    const Rect f1 = noteEntryFieldRect(fields, 1);
    const Rect f2 = noteEntryFieldRect(fields, 2);
    CHECK(f0.x < f1.x && f1.x < f2.x);
    CHECK(f2.right() == fields.right());
    CHECK(noteEntryFieldRect(fields, 3).width == 0);  // out-of-range -> empty
    const Rect panel = zonesControlPanel(content);
    const Rect deck = zonesDeckArea(content);
    const Rect curve = zonesCurveButton(content);
    CHECK(panel.y == strip.bottom() + 8 + 18 + 8);
    CHECK(deck.y == panel.y && deck.right() < curve.x);   // curve column reserved
    CHECK(curve.right() == panel.right() && curve.y == panel.y);
}

int main() {
    testContainsHalfOpen();
    testContainsDegenerate();
    testLayoutNormalView();
    testLayoutTinyViewClampsButton();
    testLayoutZeroView();
    testHitTestButton();
    testHitTestMissesNonButton();
    testHitTestButtonBoundary();
    testHitTestMatchesDrawnButton();
    testSampleRowRectStacks();
    testSampleRowHitTestMapsClickToRow();
    testSampleRowHitTestMisses();
    testSampleRowHitTestMatchesDrawnRows();
    testKeymapLayoutSplitsCanvas();
    testKeymapLayoutTinyAndZeroNoInversion();
    testKeymapSampleRowInLeftColumn();
    testAddZoneHitTest();
    testZoneRowStacksAndSelects();
    testZoneRowControlsMapToFields();
    testZoneHitTestMisses();
    testSampleBandsStackAndElasticHero();
    testClusterRectsRunAndKnobCentering();
    testZoneSurfaceLayoutAnchors();

    if (g_fail == 0) std::printf("editor_geometry: all tests passed\n");
    return g_fail != 0;
}