test: update assertions to match post-260512 production behavior

Four test assertions had silently drifted out of sync with intentional
production changes since the c5x / live-mode work landed in May:

- test_toolbar / suite/TestToolbar — testToolbarHasAllButtons asserted
  12 children, but 260512-hrn added a Follow uitoggletool to
  FastSenseToolbar between the Live and Metadata buttons. Bump to 13
  and update the inline button enumeration comment.

- test_time_range_selector — Case 5 asserted that setDataRange(0, 200)
  with a contained selection of [20, 80] would rescale to [40, 160].
  260512-live-mode-companion-adhoc-tail-spike inverted that contract:
  when the new range is a strict superset of the current selection
  (the live-tick growth path) the selection is preserved verbatim so
  the user's window doesn't drift on every 1 s data extension. Split
  Case 5 into 5a (preserve when contained) and 5b (rescale when range
  contracts to exclude selection); both branches now match the actual
  setDataRange logic.

- test_dashboard_preview_envelope — Case 6 expected
  numel(xCenters) == 200 for a 500-sample widget. minmax_core_mex's
  nb-bump (260512-live-mode-companion-adhoc-tail-spike) computes
  nb_eff = floor(n / bucketSize), so requesting 200 buckets on 500
  samples actually produces 250 envelope columns. Loosen to a range
  assertion [200, n] and update the FastSenseWidget.getPreviewSeries
  unpacker to derive the bucket count from the output length rather
  than rejecting any size that isn't exactly 2*nBucketsEff.

- test_mex_parity — local minmax_core_matlab helper was an old-style
  even-bucket reference that didn't include the nb-bump or the
  260512-c5x tail anchor. Mirror both into the helper so the MEX vs
  pure-MATLAB parity check actually compares apples to apples.

All four tests pass on both Octave 11.1 and MATLAB R2025a after these
changes; getPreviewSeries change is invisible on inputs where the MEX
output was already 2*nBucketsEff.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: HanSur94

tests/test_dashboard_preview_envelope.m

@@ -152,16 +152,22 @@ function case_threshold_boundary_at_101()
 end
 
 function case_large_dataset_unchanged()
-%CASE_LARGE_DATASET_UNCHANGED 500 samples -> nBuckets=200 (legacy behavior).
+%CASE_LARGE_DATASET_UNCHANGED 500 samples downsamples to the slider preview.
+%   minmax_core_mex internally bumps nb to floor(n / bucketSize) when
+%   bucketSize*nb < n (260512-live-mode-companion-adhoc-tail-spike), so
+%   requesting 200 buckets on a 500-sample widget actually produces
+%   nb_eff = floor(500/2) = 250 envelope columns. The contract is "less
+%   than n raw samples, at least the requested count" — so we assert a
+%   range rather than the legacy exact-200.
     n = 500;
     x = linspace(0, 100, n);
     y = sin(x * 0.1);
     w = FastSenseWidget('Title', 'wlarge', 'XData', x, 'YData', y);
     s = w.getPreviewSeries(200);
     assert(~isempty(s), 'Case 6: getPreviewSeries returned [] for 500-sample widget');
-    assert(numel(s.xCenters) == 200, ...
-        sprintf('Case 6: expected numel(xCenters)=200 (downsampled), got %d', ...
-                numel(s.xCenters)));
+    assert(numel(s.xCenters) >= 200 && numel(s.xCenters) <= n, ...
+        sprintf('Case 6: numel(xCenters) must be in [200, %d], got %d', ...
+                n, numel(s.xCenters)));
 end
 
 function case_small_with_nans()

tests/test_mex_parity.m

@@ -160,8 +160,25 @@ function test_mex_parity()
 end
 
 function [xOut, yOut] = minmax_core_matlab(segX, segY, nb)
+%MINMAX_CORE_MATLAB Pure-MATLAB reference matching the MEX kernel.
+%   Mirrors two non-obvious behaviours introduced after the original
+%   even-bucket implementation:
+%     - nb bump to floor(n / bucketSize) when bucketSize*nb < n
+%       (260512-live-mode-companion-adhoc-tail-spike) keeps every
+%       bucket the same width so the last bucket doesn't sprawl.
+%     - tail-anchor (260512-c5x) appends (segX(end), segY(end)) iff
+%       its X strictly exceeds the last emitted X — pins the rendered
+%       line to the data tail without breaking monotonicity. Output
+%       length is therefore 2*nb_eff or 2*nb_eff+1.
     segLen = numel(segY);
     bucketSize = floor(segLen / nb);
+    if bucketSize < 1
+        bucketSize = 1;
+    end
+    nb_eff = floor(segLen / bucketSize);
+    if nb_eff > nb
+        nb = nb_eff;
+    end
     usable = bucketSize * nb;
     yMat = reshape(segY(1:usable), bucketSize, nb);
     [yMinVals, iMin] = min(yMat, [], 1);
@@ -197,6 +214,10 @@ function test_mex_parity()
     yOut(odd(~minFirst))  = yMaxVals(~minFirst);
     xOut(even(~minFirst)) = xMinVals(~minFirst);
     yOut(even(~minFirst)) = yMinVals(~minFirst);
+    if segX(end) > xOut(end)
+        xOut(end + 1) = segX(end);
+        yOut(end + 1) = segY(end);
+    end
 end
 
 function [xOut, yOut] = lttb_core_matlab(x, y, numOut)

tests/test_time_range_selector.m

@@ -67,19 +67,35 @@ function test_time_range_selector()
         sprintf('Case 4 min width: width=%g expected >= 0.5', b - a));
     delete(s);
 
-    % --- Case 5: setDataRange rescales proportionally ------------------------
-    % Start with DR=[0,100] and Sel=[20,80] (20% offset + 60% width). After
-    % setDataRange(0, 200), selection must remain at the same fractional
-    % position => [40, 160].
+    % --- Case 5: setDataRange behaviour --------------------------------------
+    %  5a (preserve): when the new range is a strict superset of the current
+    %      selection — the live-mode growth path — the selection's absolute
+    %      time values are preserved verbatim, NOT rescaled. This was the
+    %      260512-live-mode-companion-adhoc-tail-spike change: every live
+    %      tick extends DataRange by ~1 s, and the user's selected window
+    %      must stay put across that growth.
+    %  5b (rescale): when the new range does NOT contain the current
+    %      selection (range contraction, or selection falls outside),
+    %      the selection rescales proportionally to keep its fractional
+    %      position.
     p5 = uipanel('Parent', f, 'Units', 'normalized', ...
                  'Position', [0 0 1 0.06]);
     s = TimeRangeSelector(p5);
     s.setDataRange(0, 100);
     s.setSelection(20, 80);
-    s.setDataRange(0, 200);
+    s.setDataRange(0, 200);   % strict superset — preserve verbatim
     [a, b] = s.getSelection();
-    assert(abs(a - 40) < 1e-6, sprintf('Case 5 rescale: a=%g expected 40', a));
-    assert(abs(b - 160) < 1e-6, sprintf('Case 5 rescale: b=%g expected 160', b));
+    assert(abs(a - 20) < 1e-6, sprintf('Case 5a preserve: a=%g expected 20', a));
+    assert(abs(b - 80) < 1e-6, sprintf('Case 5a preserve: b=%g expected 80', b));
+    % Now contract the range so the selection no longer fits — selection
+    % must rescale to keep its fractional position inside the OLD range,
+    % then project into the new range. After Case 5a the DataRange is
+    % [0,200] and Selection [20,80], so fractions are [0.1, 0.4]. After
+    % setDataRange(0, 50): selection = [0 + 0.1*50, 0 + 0.4*50] = [5, 20].
+    s.setDataRange(0, 50);
+    [a, b] = s.getSelection();
+    assert(abs(a - 5)  < 1e-6, sprintf('Case 5b rescale: a=%g expected 5', a));
+    assert(abs(b - 20) < 1e-6, sprintf('Case 5b rescale: b=%g expected 20', b));
     delete(s);
 
     % --- Case 6: OnRangeChanged fires once per call with final bounds --------

tests/test_toolbar.m

@@ -25,13 +25,14 @@ function test_toolbar()
     assert(~isempty(tb.hToolbar), 'testConstructorWithFPFigure: hToolbar');
     close(fig.hFigure);
 
-    % testToolbarHasAllButtons (cursor, crosshair, grid, legend, autoscale, export, refresh, live, metadata, theme)
+    % testToolbarHasAllButtons (cursor, crosshair, grid, legend, autoscale,
+    % exportPNG, exportData, refresh, live, follow, metadata, violations, theme)
     fp = FastSense();
     fp.addLine(1:100, rand(1,100));
     fp.render();
     tb = FastSenseToolbar(fp);
     children = get(tb.hToolbar, 'Children');
-    assert(numel(children) == 12, ...
+    assert(numel(children) == 13, ...
         sprintf('testToolbarHasAllButtons: got %d', numel(children)));
     close(fp.hFigure);