Tests

Center Tests

\operatorname{Center}(\mathbf{x}) = \operatorname{median}_{1 \leq i \leq j \leq n} \frac{x_i + x_j}{2}

The $\operatorname{Center}$ test suite contains 38 correctness test cases stored in the repository (24 original + 14 unsorted), plus 1 performance test that should be implemented manually (see Test Framework).

Demo examples ( $n = 5$ ) — from manual introduction, validating properties:

demo-1: $\mathbf{x} = (0, 2, 4, 6, 8)$ , expected output: $4$ (base case)
demo-2: $\mathbf{x} = (10, 12, 14, 16, 18)$ (= demo-1 + 10), expected output: $14$ (location equivariance)
demo-3: $\mathbf{x} = (0, 6, 12, 18, 24)$ (= 3 × demo-1), expected output: $12$ (scale equivariance)

Natural sequences ( $n = 1, 2, 3, 4$ ) — canonical happy path examples:

natural-1: $\mathbf{x} = (1)$ , expected output: $1$
natural-2: $\mathbf{x} = (1, 2)$ , expected output: $1.5$
natural-3: $\mathbf{x} = (1, 2, 3)$ , expected output: $2$
natural-4: $\mathbf{x} = (1, 2, 3, 4)$ , expected output: $2.5$ (smallest even size with rich structure)

Negative values ( $n = 3$ ) — sign handling validation:

negative-3: $\mathbf{x} = (-3, -2, -1)$ , expected output: $-2$

Zero values ( $n = 1, 2$ ) — edge case testing with zeros:

zeros-1: $\mathbf{x} = (0)$ , expected output: $0$
zeros-2: $\mathbf{x} = (0, 0)$ , expected output: $0$

Additive distribution ( $n = 5, 10, 30$ ) — fuzzy testing with $\underline{\operatorname{Additive}}(10, 1)$ :

additive-5, additive-10, additive-30: random samples generated with seed 0

Uniform distribution ( $n = 5, 100$ ) — fuzzy testing with $\underline{\operatorname{Uniform}}(0, 1)$ :

uniform-5, uniform-100: random samples generated with seed 1

The random samples validate that $\operatorname{Center}$ performs correctly on realistic distributions at various sample sizes. The progression from small ( $n = 5$ ) to large ( $n = 100$ ) samples helps identify issues that only manifest at specific scales.

Algorithm stress tests — edge cases for fast algorithm implementation:

duplicates-5: $\mathbf{x} = (3, 3, 3, 3, 3)$ (all identical, stress stall handling)
duplicates-10: $\mathbf{x} = (1, 1, 1, 2, 2, 2, 3, 3, 3, 3)$ (many duplicates, stress tie-breaking)
parity-odd-7: $\mathbf{x} = (1, 2, 3, 4, 5, 6, 7)$ (odd sample size for odd total pairs)
parity-even-6: $\mathbf{x} = (1, 2, 3, 4, 5, 6)$ (even sample size for even total pairs)
parity-odd-49: 49-element sequence $(1, 2, \ldots, 49)$ (large odd, 1225 pairs)
parity-even-50: 50-element sequence $(1, 2, \ldots, 50)$ (large even, 1275 pairs)

Extreme values — numerical stability and range tests:

extreme-large-5: $\mathbf{x} = (10^8, 2 \cdot 10^8, 3 \cdot 10^8, 4 \cdot 10^8, 5 \cdot 10^8)$ (very large values)
extreme-small-5: $\mathbf{x} = (10^{-8}, 2 \cdot 10^{-8}, 3 \cdot 10^{-8}, 4 \cdot 10^{-8}, 5 \cdot 10^{-8})$ (very small positive values)
extreme-wide-5: $\mathbf{x} = (0.001, 1, 100, 1000, 1000000)$ (wide range, tests precision)

Unsorted tests — verify sorting correctness (14 tests):

unsorted-reverse-{n} for $n in {2, 3, 4, 5, 7}$ : reverse sorted natural sequences (5 tests)
unsorted-shuffle-3: $\mathbf{x} = (2, 1, 3)$ (middle element first)
unsorted-shuffle-4: $\mathbf{x} = (3, 1, 4, 2)$ (interleaved)
unsorted-shuffle-5: $\mathbf{x} = (5, 2, 4, 1, 3)$ (complex shuffle)
unsorted-last-first-5: $\mathbf{x} = (5, 1, 2, 3, 4)$ (last moved to first)
unsorted-first-last-5: $\mathbf{x} = (2, 3, 4, 5, 1)$ (first moved to last)
unsorted-duplicates-mixed-5: $\mathbf{x} = (3, 3, 3, 3, 3)$ (all identical, any order)
unsorted-duplicates-unsorted-10: $\mathbf{x} = (3, 1, 2, 3, 1, 3, 2, 1, 3, 2)$ (duplicates mixed)
unsorted-extreme-large-unsorted-5: $\mathbf{x} = (5 \cdot 10^8, 10^8, 4 \cdot 10^8, 2 \cdot 10^8, 3 \cdot 10^8)$ (large values unsorted)
unsorted-parity-odd-reverse-7: $\mathbf{x} = (7, 6, 5, 4, 3, 2, 1)$ (odd size reverse)

These tests ensure implementations correctly sort input data before computing pairwise averages. The variety of shuffle patterns (reverse, rotation, interleaving, single element displacement) catches common sorting bugs.

Performance test — validates the fast $O(n \log n)$ algorithm:

Input: $\mathbf{x} = (1, 2, 3, \ldots, 100000)$
Expected output: $50000.5$
Time constraint: Must complete in under 5 seconds
Purpose: Ensures that the implementation uses the efficient algorithm rather than materializing all $\binom{n+1}{2} \approx 5$ billion pairwise averages

This test case is not stored in the repository because it generates a large JSON file (approximately 1.5 MB). Each language implementation should manually implement this test with the hardcoded expected result.

Spread Tests

\operatorname{Spread}(\mathbf{x}) = \operatorname{median}_{1 \leq i < j \leq n} \lvert x_i - x_j \rvert

The $\operatorname{Spread}$ test suite contains 30 correctness test cases stored in the repository (20 original + 10 unsorted), plus 1 performance test that should be implemented manually (see Test Framework).

Demo examples ( $n = 5$ ) — from manual introduction, validating properties:

demo-1: $\mathbf{x} = (0, 2, 4, 6, 8)$ , expected output: $4$ (base case)
demo-2: $\mathbf{x} = (10, 12, 14, 16, 18)$ (= demo-1 + 10), expected output: $4$ (location invariance)
demo-3: $\mathbf{x} = (0, 4, 8, 12, 16)$ (= 2 × demo-1), expected output: $8$ (scale equivariance)

Natural sequences ( $n = 2, 3, 4$ ):

natural-2: $\mathbf{x} = (1, 2)$ , expected output: $1$
natural-3: $\mathbf{x} = (1, 2, 3)$ , expected output: $1$
natural-4: $\mathbf{x} = (1, 2, 3, 4)$ , expected output: $1.5$ (smallest even size with rich structure)

Negative values ( $n = 3$ ) — sign handling validation:

negative-3: $\mathbf{x} = (-3, -2, -1)$ , expected output: $1$

Additive distribution ( $n = 5, 10, 30$ ) — $\underline{\operatorname{Additive}}(10, 1)$ :

additive-5, additive-10, additive-30: random samples generated with seed 0

Uniform distribution ( $n = 5, 100$ ) — $\underline{\operatorname{Uniform}}(0, 1)$ :

uniform-5, uniform-100: random samples generated with seed 1

The natural sequence cases validate the basic pairwise difference calculation. Constant samples and $n = 1$ are excluded because $\operatorname{Spread}$ requires $\operatorname{Spread}(\mathbf{x}) > 0$ .

Algorithm stress tests — edge cases for fast algorithm implementation:

duplicates-10: $\mathbf{x} = (1, 1, 1, 2, 2, 2, 3, 3, 3, 3)$ (many duplicates, stress tie-breaking)
parity-odd-7: $\mathbf{x} = (1, 2, 3, 4, 5, 6, 7)$ (odd sample size, 21 differences)
parity-even-6: $\mathbf{x} = (1, 2, 3, 4, 5, 6)$ (even sample size, 15 differences)
parity-odd-49: 49-element sequence $(1, 2, \ldots, 49)$ (large odd, 1176 differences)
parity-even-50: 50-element sequence $(1, 2, \ldots, 50)$ (large even, 1225 differences)

Extreme values — numerical stability and range tests:

extreme-large-5: $\mathbf{x} = (10^8, 2 \cdot 10^8, 3 \cdot 10^8, 4 \cdot 10^8, 5 \cdot 10^8)$ (very large values)
extreme-small-5: $\mathbf{x} = (10^{-8}, 2 \cdot 10^{-8}, 3 \cdot 10^{-8}, 4 \cdot 10^{-8}, 5 \cdot 10^{-8})$ (very small positive values)
extreme-wide-5: $\mathbf{x} = (0.001, 1, 100, 1000, 1000000)$ (wide range, tests precision)

Unsorted tests — verify sorting correctness (10 tests):

unsorted-reverse-{n} for $n in {2, 3, 4, 5, 7}$ : reverse sorted natural sequences (5 tests)
unsorted-shuffle-3: $\mathbf{x} = (3, 1, 2)$ (rotated)
unsorted-shuffle-4: $\mathbf{x} = (4, 2, 1, 3)$ (mixed order)
unsorted-shuffle-5: $\mathbf{x} = (5, 1, 3, 2, 4)$ (partial shuffle)
unsorted-duplicates-unsorted-10: $\mathbf{x} = (2, 3, 1, 3, 2, 1, 2, 3, 1, 3)$ (duplicates mixed)
unsorted-extreme-wide-unsorted-5: $\mathbf{x} = (1000, 0.001, 1000000, 100, 1)$ (wide range unsorted)

These tests verify that implementations correctly sort input before computing pairwise differences. Since $\operatorname{Spread}$ uses absolute differences, order-dependent bugs would manifest differently than in $\operatorname{Center}$ .

Performance test — validates the fast $O(n \log n)$ algorithm:

Input: $\mathbf{x} = (1, 2, 3, \ldots, 100000)$
Expected output: $29290$
Time constraint: Must complete in under 5 seconds
Purpose: Ensures that the implementation uses the efficient algorithm rather than materializing all $\binom{n}{2} \approx 5$ billion pairwise differences

RelSpread Tests

\operatorname{RelSpread}(\mathbf{x}) = \frac{\operatorname{Spread}(\mathbf{x})}{\lvert \operatorname{Center}(\mathbf{x}) \rvert}

The $\operatorname{RelSpread}$ test suite contains 18 test cases (13 original + 5 unsorted) focusing on relative dispersion.

Demo examples ( $n = 5$ ) — from manual introduction, validating properties:

demo-1: $\mathbf{x} = (1, 3, 5, 7, 9)$ , expected output: $0.8$ (base case)
demo-2: $\mathbf{x} = (5, 15, 25, 35, 45)$ (= 5 × demo-1), expected output: $0.8$ (scale invariance)

Natural sequences ( $n = 2, 3, 4$ ):

natural-2: $\mathbf{x} = (1, 2)$ , expected output: $\approx 0.667$
natural-3: $\mathbf{x} = (1, 2, 3)$ , expected output: $0.5$
natural-4: $\mathbf{x} = (1, 2, 3, 4)$ , expected output: $0.6$ (validates composite with even size)

Uniform distribution ( $n = 5, 10, 20, 30, 100$ ) — $\underline{\operatorname{Uniform}}(0, 1)$ :

uniform-5, uniform-10, uniform-20, uniform-30, uniform-100: random samples generated with seed 0

The uniform distribution tests span multiple sample sizes to verify that $\operatorname{RelSpread}$ correctly normalizes dispersion. Zero and negative values are excluded because $\operatorname{RelSpread}$ requires strictly positive samples.

Composite estimator stress tests — edge cases specific to division operation:

composite-small-center: $\mathbf{x} = (0.001, 0.002, 0.003, 0.004, 0.005)$ (small center, tests division stability)
composite-large-spread: $\mathbf{x} = (1, 100, 200, 300, 1000)$ (large spread relative to center)
composite-extreme-ratio: $\mathbf{x} = (1, 1.0001, 1.0002, 1.0003, 1.0004)$ (tiny spread, tests precision)

Unsorted tests — verify sorting for composite estimator (5 tests):

unsorted-reverse-{n} for $n in {3, 4, 5}$ : reverse sorted natural sequences (3 tests)
unsorted-composite-small-unsorted: $\mathbf{x} = (0.005, 0.001, 0.003, 0.002, 0.004)$ (small center unsorted)
unsorted-composite-large-unsorted: $\mathbf{x} = (1000, 1, 300, 100, 200)$ (large spread unsorted)

Since $\operatorname{RelSpread}$ combines both $\operatorname{Center}$ and $\operatorname{Spread}$ , these tests verify that sorting works correctly for composite estimators.

Shift Tests

\operatorname{Shift}(\mathbf{x}, \mathbf{y}) = \operatorname{median}_{1 \leq i \leq n, 1 \leq j \leq m} (x_i - y_j)

The $\operatorname{Shift}$ test suite contains 60 correctness test cases stored in the repository (42 original + 18 unsorted), plus 1 performance test that should be implemented manually (see Test Framework).

Demo examples ( $n = m = 5$ ) — from manual introduction, validating properties:

demo-1: $\mathbf{x} = (0, 2, 4, 6, 8)$ , $\mathbf{y} = (10, 12, 14, 16, 18)$ , expected output: $-10$ (base case)
demo-2: $\mathbf{x} = (0, 2, 4, 6, 8)$ , $\mathbf{y} = (0, 2, 4, 6, 8)$ , expected output: $0$ (identity property)
demo-3: $\mathbf{x} = (7, 9, 11, 13, 15)$ , $\mathbf{y} = (13, 15, 17, 19, 21)$ (= demo-1 + [7,3]), expected output: $-6$ (location equivariance)
demo-4: $\mathbf{x} = (0, 4, 8, 12, 16)$ , $\mathbf{y} = (20, 24, 28, 32, 36)$ (= 2 × demo-1), expected output: $-20$ (scale equivariance)
demo-5: $\mathbf{x} = (10, 12, 14, 16, 18)$ , $\mathbf{y} = (0, 2, 4, 6, 8)$ (= reversed demo-1), expected output: $10$ (anti-symmetry)

Natural sequences ( $[n, m] in {1, 2, 3} \times {1, 2, 3}$ ) — 9 combinations:

natural-1-1: $\mathbf{x} = (1)$ , $\mathbf{y} = (1)$ , expected output: $0$
natural-1-2: $\mathbf{x} = (1)$ , $\mathbf{y} = (1, 2)$ , expected output: $-0.5$
natural-1-3: $\mathbf{x} = (1)$ , $\mathbf{y} = (1, 2, 3)$ , expected output: $-1$
natural-2-1: $\mathbf{x} = (1, 2)$ , $\mathbf{y} = (1)$ , expected output: $0.5$
natural-2-2: $\mathbf{x} = (1, 2)$ , $\mathbf{y} = (1, 2)$ , expected output: $0$
natural-2-3: $\mathbf{x} = (1, 2)$ , $\mathbf{y} = (1, 2, 3)$ , expected output: $-0.5$
natural-3-1: $\mathbf{x} = (1, 2, 3)$ , $\mathbf{y} = (1)$ , expected output: $1$
natural-3-2: $\mathbf{x} = (1, 2, 3)$ , $\mathbf{y} = (1, 2)$ , expected output: $0.5$
natural-3-3: $\mathbf{x} = (1, 2, 3)$ , $\mathbf{y} = (1, 2, 3)$ , expected output: $0$

Negative values ( $[n, m] = [2, 2]$ ) — sign handling validation:

negative-2-2: $\mathbf{x} = (-2, -1)$ , $\mathbf{y} = (-2, -1)$ , expected output: $0$

Mixed-sign values ( $[n, m] = [2, 2]$ ) — validates anti-symmetry across zero:

mixed-2-2: $\mathbf{x} = (-1, 1)$ , $\mathbf{y} = (-1, 1)$ , expected output: $0$

Zero values ( $[n, m] in {1, 2} \times {1, 2}$ ) — 4 combinations:

zeros-1-1, zeros-1-2, zeros-2-1, zeros-2-2: all produce output $0$

Additive distribution ( $[n, m] in {5, 10, 30} \times {5, 10, 30}$ ) — 9 combinations with $\underline{\operatorname{Additive}}(10, 1)$ :

additive-5-5, additive-5-10, additive-5-30
additive-10-5, additive-10-10, additive-10-30
additive-30-5, additive-30-10, additive-30-30
Random generation: $\mathbf{x}$ uses seed 0, $\mathbf{y}$ uses seed 1

Uniform distribution ( $[n, m] in {5, 100} \times {5, 100}$ ) — 4 combinations with $\underline{\operatorname{Uniform}}(0, 1)$ :

uniform-5-5, uniform-5-100, uniform-100-5, uniform-100-100
Random generation: $\mathbf{x}$ uses seed 2, $\mathbf{y}$ uses seed 3

The natural sequences validate anti-symmetry ( $\operatorname{Shift}(\mathbf{x}, \mathbf{y}) = -\operatorname{Shift}(\mathbf{y}, \mathbf{x})$ ) and the identity property ( $\operatorname{Shift}(\mathbf{x}, \mathbf{x}) = 0$ ). The asymmetric size combinations test the two-sample algorithm with unbalanced inputs.

Algorithm stress tests — edge cases for fast binary search algorithm:

duplicates-5-5: $\mathbf{x} = (3, 3, 3, 3, 3)$ , $\mathbf{y} = (3, 3, 3, 3, 3)$ (all identical, expected output: $0$ )
duplicates-10-10: $\mathbf{x} = (1, 1, 2, 2, 3, 3, 4, 4, 5, 5)$ , $\mathbf{y} = (1, 1, 2, 2, 3, 3, 4, 4, 5, 5)$ (many duplicates)
parity-odd-7-7: $\mathbf{x} = (1, 2, 3, 4, 5, 6, 7)$ , $\mathbf{y} = (1, 2, 3, 4, 5, 6, 7)$ (odd sizes, 49 differences, expected output: $0$ )
parity-even-6-6: $\mathbf{x} = (1, 2, 3, 4, 5, 6)$ , $\mathbf{y} = (1, 2, 3, 4, 5, 6)$ (even sizes, 36 differences, expected output: $0$ )
parity-asymmetric-7-6: $\mathbf{x} = (1, 2, 3, 4, 5, 6, 7)$ , $\mathbf{y} = (1, 2, 3, 4, 5, 6)$ (mixed parity, 42 differences)
parity-large-49-50: $\mathbf{x} = (1, 2, \ldots, 49)$ , $\mathbf{y} = (1, 2, \ldots, 50)$ (large asymmetric, 2450 differences)

Extreme asymmetry — tests with very unbalanced sample sizes:

asymmetry-1-100: $\mathbf{x} = (50)$ , $\mathbf{y} = (1, 2, \ldots, 100)$ (single vs many, 100 differences)
asymmetry-2-50: $\mathbf{x} = (10, 20)$ , $\mathbf{y} = (1, 2, \ldots, 50)$ (tiny vs medium, 100 differences)
asymmetry-constant-varied: $\mathbf{x} = (5, 5, 5, 5, 5)$ , $\mathbf{y} = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)$ (constant vs varied)

Unsorted tests — verify independent sorting of each sample (18 tests):

unsorted-x-natural-{n}-{m} for $(n,m) in {(3,3), (4,4), (5,5)}$ : X unsorted (reversed), Y sorted (3 tests)
unsorted-y-natural-{n}-{m} for $(n,m) in {(3,3), (4,4), (5,5)}$ : X sorted, Y unsorted (reversed) (3 tests)
unsorted-both-natural-{n}-{m} for $(n,m) in {(3,3), (4,4), (5,5)}$ : both unsorted (reversed) (3 tests)
unsorted-reverse-3-3: $\mathbf{x} = (3, 2, 1)$ , $\mathbf{y} = (3, 2, 1)$ (both reversed)
unsorted-x-shuffle-3-3: $\mathbf{x} = (2, 1, 3)$ , $\mathbf{y} = (1, 2, 3)$ (X shuffled, Y sorted)
unsorted-y-shuffle-3-3: $\mathbf{x} = (1, 2, 3)$ , $\mathbf{y} = (3, 1, 2)$ (X sorted, Y shuffled)
unsorted-both-shuffle-4-4: $\mathbf{x} = (3, 1, 4, 2)$ , $\mathbf{y} = (4, 2, 1, 3)$ (both shuffled)
unsorted-duplicates-mixed-5-5: $\mathbf{x} = (3, 3, 3, 3, 3)$ , $\mathbf{y} = (3, 3, 3, 3, 3)$ (all identical)
unsorted-x-unsorted-duplicates: $\mathbf{x} = (2, 1, 3, 2, 1)$ , $\mathbf{y} = (1, 1, 2, 2, 3)$ (X has unsorted duplicates)
unsorted-y-unsorted-duplicates: $\mathbf{x} = (1, 1, 2, 2, 3)$ , $\mathbf{y} = (3, 2, 1, 3, 2)$ (Y has unsorted duplicates)
unsorted-asymmetric-unsorted-2-5: $\mathbf{x} = (2, 1)$ , $\mathbf{y} = (5, 2, 4, 1, 3)$ (asymmetric sizes, both unsorted)
unsorted-negative-unsorted-3-3: $\mathbf{x} = (-1, -3, -2)$ , $\mathbf{y} = (-2, -3, -1)$ (negative unsorted)

These tests are critical for two-sample estimators because they verify that $\mathbf{x}$ and $\mathbf{y}$ are sorted independently. The variety includes cases where only one sample is unsorted, ensuring implementations dont incorrectly assume pre-sorted input or sort samples together.

Performance test — validates the fast $O((m+n) \log L)$ binary search algorithm:

Input: $\mathbf{x} = (1, 2, 3, \ldots, 100000)$ , $\mathbf{y} = (1, 2, 3, \ldots, 100000)$
Expected output: $0$
Time constraint: Must complete in under 5 seconds
Purpose: Ensures that the implementation uses the efficient algorithm rather than materializing all $m n = 10$ billion pairwise differences

Ratio Tests

\operatorname{Ratio}(\mathbf{x}, \mathbf{y}) = \exp(\operatorname{Shift}(\log \mathbf{x}, \log \mathbf{y}))

The $\operatorname{Ratio}$ test suite contains 37 test cases (25 original + 12 unsorted), excluding zero values due to division constraints. The new definition uses geometric interpolation (via log-space), which affects expected values for even $m \times n$ cases.

Demo examples ( $n = m = 5$ ) — from manual introduction, validating properties:

demo-1: $\mathbf{x} = (1, 2, 4, 8, 16)$ , $\mathbf{y} = (2, 4, 8, 16, 32)$ , expected output: $0.5$ (base case, odd $m \times n$ )
demo-2: $\mathbf{x} = (1, 2, 4, 8, 16)$ , $\mathbf{y} = (1, 2, 4, 8, 16)$ , expected output: $1$ (identity property)
demo-3: $\mathbf{x} = (2, 4, 8, 16, 32)$ , $\mathbf{y} = (10, 20, 40, 80, 160)$ (= [2×demo-1.x, 5×demo-1.y]), expected output: $0.2$ (scale property)

Natural sequences ( $[n, m] in {1, 2, 3} \times {1, 2, 3}$ ) — 9 combinations:

natural-1-1: $\mathbf{x} = (1)$ , $\mathbf{y} = (1)$ , expected output: $1$
natural-1-2: $\mathbf{x} = (1)$ , $\mathbf{y} = (1, 2)$ , expected output: $\approx 0.707$ ( $= \sqrt{0.5}$ , geometric interpolation)
natural-1-3: $\mathbf{x} = (1)$ , $\mathbf{y} = (1, 2, 3)$ , expected output: $0.5$
natural-2-1: $\mathbf{x} = (1, 2)$ , $\mathbf{y} = (1)$ , expected output: $\approx 1.414$ ( $= \sqrt{2}$ , geometric interpolation)
natural-2-2: $\mathbf{x} = (1, 2)$ , $\mathbf{y} = (1, 2)$ , expected output: $1$
natural-2-3: $\mathbf{x} = (1, 2)$ , $\mathbf{y} = (1, 2, 3)$ , expected output: $\approx 0.816$ (geometric interpolation)
natural-3-1: $\mathbf{x} = (1, 2, 3)$ , $\mathbf{y} = (1)$ , expected output: $2$
natural-3-2: $\mathbf{x} = (1, 2, 3)$ , $\mathbf{y} = (1, 2)$ , expected output: $\approx 1.225$ (geometric interpolation)
natural-3-3: $\mathbf{x} = (1, 2, 3)$ , $\mathbf{y} = (1, 2, 3)$ , expected output: $1$

Additive distribution ( $[n, m] in {5, 10, 30} \times {5, 10, 30}$ ) — 9 combinations with $\underline{\operatorname{Additive}}(10, 1)$ :

additive-5-5, additive-5-10, additive-5-30
additive-10-5, additive-10-10, additive-10-30
additive-30-5, additive-30-10, additive-30-30
Random generation: $\mathbf{x}$ uses seed 0, $\mathbf{y}$ uses seed 1

Uniform distribution ( $[n, m] in {5, 100} \times {5, 100}$ ) — 4 combinations with $\underline{\operatorname{Uniform}}(0, 1)$ :

uniform-5-5, uniform-5-100, uniform-100-5, uniform-100-100
Random generation: $\mathbf{x}$ uses seed 2, $\mathbf{y}$ uses seed 3
Note: all generated values are strictly positive (no zeros); values near zero test numerical stability of log-transformation

The natural sequences verify the identity property ( $\operatorname{Ratio}(\mathbf{x}, \mathbf{x}) = 1$ ) and validate ratio calculations with simple integer inputs. Note that implementations should handle the practical constraint of avoiding division by values near zero.

Unsorted tests — verify independent sorting for ratio calculation (12 tests):

unsorted-x-natural-{n}-{m} for $(n,m) in {(3,3), (4,4)}$ : X unsorted (reversed), Y sorted (2 tests)
unsorted-y-natural-{n}-{m} for $(n,m) in {(3,3), (4,4)}$ : X sorted, Y unsorted (reversed) (2 tests)
unsorted-both-natural-{n}-{m} for $(n,m) in {(3,3), (4,4)}$ : both unsorted (reversed) (2 tests)
unsorted-demo-unsorted-x: $\mathbf{x} = (16, 1, 8, 2, 4)$ , $\mathbf{y} = (2, 4, 8, 16, 32)$ (demo-1 with X unsorted)
unsorted-demo-unsorted-y: $\mathbf{x} = (1, 2, 4, 8, 16)$ , $\mathbf{y} = (32, 2, 16, 4, 8)$ (demo-1 with Y unsorted)
unsorted-demo-both-unsorted: $\mathbf{x} = (8, 1, 16, 4, 2)$ , $\mathbf{y} = (16, 32, 2, 8, 4)$ (demo-1 both unsorted)
unsorted-identity-unsorted: $\mathbf{x} = (4, 1, 8, 2, 16)$ , $\mathbf{y} = (16, 1, 8, 4, 2)$ (identity property, both unsorted)
unsorted-asymmetric-unsorted-2-3: $\mathbf{x} = (2, 1)$ , $\mathbf{y} = (3, 1, 2)$ (asymmetric, both unsorted)
unsorted-power-unsorted-5: $\mathbf{x} = (16, 2, 8, 1, 4)$ , $\mathbf{y} = (32, 4, 16, 2, 8)$ (powers of 2 unsorted)

AvgSpread Tests

\operatorname{AvgSpread}(\mathbf{x}, \mathbf{y}) = \frac{n \cdot \operatorname{Spread}(\mathbf{x}) + m \cdot \operatorname{Spread}(\mathbf{y})}{n + m}

The $\operatorname{AvgSpread}$ test suite contains 36 test cases (24 original + 12 unsorted). Since $\operatorname{AvgSpread}$ computes $\operatorname{Spread}(\mathbf{x})$ and $\operatorname{Spread}(\mathbf{y})$ independently, unsorted tests are critical to verify that both samples are sorted independently before computing their spreads.

Demo examples ( $n = m = 5$ ) — from manual introduction, validating properties:

demo-1: $\mathbf{x} = (0, 3, 6, 9, 12)$ , $\mathbf{y} = (0, 2, 4, 6, 8)$ , expected output: $5$ (base case: $\frac{5 \cdot 6 + 5 \cdot 4}{10}$ )
demo-2: $\mathbf{x} = (0, 3, 6, 9, 12)$ , $\mathbf{y} = (0, 3, 6, 9, 12)$ , expected output: $6$ (identity case)
demo-3: $\mathbf{x} = (0, 6, 12, 18, 24)$ , $\mathbf{y} = (0, 9, 18, 27, 36)$ (= [2×demo-1.x, 3×demo-1.y]), expected output: $15$ (scale equivariance)
demo-4: $\mathbf{x} = (0, 2, 4, 6, 8)$ , $\mathbf{y} = (0, 3, 6, 9, 12)$ (= reversed demo-1), expected output: $5$ (symmetry)
demo-5: $\mathbf{x} = (0, 6, 12, 18, 24)$ , $\mathbf{y} = (0, 4, 8, 12, 16)$ (= 2 × demo-1), expected output: $10$ (uniform scaling)

Natural sequences ( $[n, m] in {2, 3} \times {2, 3}$ ) — 4 combinations:

All combinations for two- and three-element samples, validating the weighted average calculation

Negative values ( $[n, m] = [2, 2]$ ) — validates spread calculation with negative values:

negative-2-2: $\mathbf{x} = (-2, -1)$ , $\mathbf{y} = (-2, -1)$ , expected output: $1$

Additive distribution ( $[n, m] in {5, 10, 30} \times {5, 10, 30}$ ) — 9 combinations with $\underline{\operatorname{Additive}}(10, 1)$ :

Tests pooled dispersion across different sample size combinations
Random generation: $\mathbf{x}$ uses seed 0, $\mathbf{y}$ uses seed 1

Uniform distribution ( $[n, m] in {5, 100} \times {5, 100}$ ) — 4 combinations with $\underline{\operatorname{Uniform}}(0, 1)$ :

Validates correct weighting when sample sizes differ substantially
Random generation: $\mathbf{x}$ uses seed 2, $\mathbf{y}$ uses seed 3

The asymmetric size combinations are particularly important for $\operatorname{AvgSpread}$ because the estimator must correctly weight each samples contribution by its size.

Composite estimator stress tests — edge cases for weighted averaging:

composite-asymmetric-weights: $\mathbf{x} = (1, 2)$ , $\mathbf{y} = (3, 4, 5, 6, 7, 8, 9, 10)$ (2 vs 8, tests weighting formula)

Unsorted tests — critical for verifying independent sorting (12 tests):

unsorted-x-natural-{n}-{m} for $(n,m) in {(3,3), (4,4)}$ : X unsorted (reversed), Y sorted (2 tests)
unsorted-y-natural-{n}-{m} for $(n,m) in {(3,3), (4,4)}$ : X sorted, Y unsorted (reversed) (2 tests)
unsorted-both-natural-{n}-{m} for $(n,m) in {(3,3), (4,4)}$ : both unsorted (reversed) (2 tests)
unsorted-demo-unsorted-x: $\mathbf{x} = (12, 0, 6, 3, 9)$ , $\mathbf{y} = (0, 2, 4, 6, 8)$ (demo-1 with X unsorted)
unsorted-demo-unsorted-y: $\mathbf{x} = (0, 3, 6, 9, 12)$ , $\mathbf{y} = (8, 0, 4, 2, 6)$ (demo-1 with Y unsorted)
unsorted-demo-both-unsorted: $\mathbf{x} = (9, 0, 12, 3, 6)$ , $\mathbf{y} = (6, 0, 8, 2, 4)$ (demo-1 both unsorted)
unsorted-identity-unsorted: $\mathbf{x} = (6, 0, 12, 3, 9)$ , $\mathbf{y} = (9, 0, 12, 6, 3)$ (demo-2 unsorted)
unsorted-negative-unsorted: $\mathbf{x} = (-1, -2)$ , $\mathbf{y} = (-1, -2)$ (negative unsorted)
unsorted-asymmetric-weights-unsorted: $\mathbf{x} = (2, 1)$ , $\mathbf{y} = (8, 3, 6, 4, 10, 5, 9, 7)$ (asymmetric unsorted)

These tests verify that implementations compute $\operatorname{Spread}(\mathbf{x})$ and $\operatorname{Spread}(\mathbf{y})$ with properly sorted samples.

Disparity Tests

\operatorname{Disparity}(\mathbf{x}, \mathbf{y}) = \operatorname{Shift}(\mathbf{x}, \mathbf{y}) / \operatorname{AvgSpread}(\mathbf{x}, \mathbf{y})

The $\operatorname{Disparity}$ test suite contains 28 test cases (16 original + 12 unsorted). Since $\operatorname{Disparity}$ combines $\operatorname{Shift}$ and $\operatorname{AvgSpread}$ , unsorted tests verify both components handle sorting correctly.

Demo examples ( $n = m = 5$ ) — from manual introduction, validating properties:

demo-1: $\mathbf{x} = (0, 3, 6, 9, 12)$ , $\mathbf{y} = (0, 2, 4, 6, 8)$ , expected output: $0.4$ (base case: $\frac{2}{5}$ )
demo-2: $\mathbf{x} = (5, 8, 11, 14, 17)$ , $\mathbf{y} = (5, 7, 9, 11, 13)$ (= demo-1 + 5), expected output: $0.4$ (location invariance)
demo-3: $\mathbf{x} = (0, 6, 12, 18, 24)$ , $\mathbf{y} = (0, 4, 8, 12, 16)$ (= 2 × demo-1), expected output: $0.4$ (scale invariance)
demo-4: $\mathbf{x} = (0, 2, 4, 6, 8)$ , $\mathbf{y} = (0, 3, 6, 9, 12)$ (= reversed demo-1), expected output: $-0.4$ (anti-symmetry)

Natural sequences ( $[n, m] in {2, 3} \times {2, 3}$ ) — 4 combinations:

natural-2-2, natural-2-3, natural-3-2, natural-3-3
Minimum size $n, m \geq 2$ required for meaningful dispersion calculations

Negative values ( $[n, m] = [2, 2]$ ) — end-to-end validation with negative values:

negative-2-2: $\mathbf{x} = (-2, -1)$ , $\mathbf{y} = (-2, -1)$ , expected output: $0$

Uniform distribution ( $[n, m] in {5, 100} \times {5, 100}$ ) — 4 combinations with $\underline{\operatorname{Uniform}}(0, 1)$ :

uniform-5-5, uniform-5-100, uniform-100-5, uniform-100-100
Random generation: $\mathbf{x}$ uses seed 0, $\mathbf{y}$ uses seed 1

The smaller test set for $\operatorname{Disparity}$ reflects implementation confidence. Since $\operatorname{Disparity}$ combines $\operatorname{Shift}$ and $\operatorname{AvgSpread}$ , correct implementation of those components ensures $\operatorname{Disparity}$ correctness. The test cases validate the division operation and confirm scale-free properties.

Composite estimator stress tests — edge cases for effect size calculation:

composite-small-avgspread: $\mathbf{x} = (10.001, 10.002, 10.003)$ , $\mathbf{y} = (10.004, 10.005, 10.006)$ (tiny spread, large shift)
composite-large-avgspread: $\mathbf{x} = (1, 100, 200)$ , $\mathbf{y} = (50, 150, 250)$ (large spread, small shift)
composite-extreme-disparity: $\mathbf{x} = (1, 1.001)$ , $\mathbf{y} = (100, 100.001)$ (extreme ratio, tests precision)

Unsorted tests — verify both Shift and AvgSpread handle sorting (12 tests):

unsorted-x-natural-{n}-{m} for $(n,m) in {(3,3), (4,4)}$ : X unsorted (reversed), Y sorted (2 tests)
unsorted-y-natural-{n}-{m} for $(n,m) in {(3,3), (4,4)}$ : X sorted, Y unsorted (reversed) (2 tests)
unsorted-both-natural-{n}-{m} for $(n,m) in {(3,3), (4,4)}$ : both unsorted (reversed) (2 tests)
unsorted-demo-unsorted-x: $\mathbf{x} = (12, 0, 6, 3, 9)$ , $\mathbf{y} = (0, 2, 4, 6, 8)$ (demo-1 with X unsorted)
unsorted-demo-unsorted-y: $\mathbf{x} = (0, 3, 6, 9, 12)$ , $\mathbf{y} = (8, 0, 4, 2, 6)$ (demo-1 with Y unsorted)
unsorted-demo-both-unsorted: $\mathbf{x} = (9, 0, 12, 3, 6)$ , $\mathbf{y} = (6, 0, 8, 2, 4)$ (demo-1 both unsorted)
unsorted-location-invariance-unsorted: $\mathbf{x} = (17, 5, 11, 8, 14)$ , $\mathbf{y} = (13, 5, 9, 7, 11)$ (demo-2 unsorted)
unsorted-scale-invariance-unsorted: $\mathbf{x} = (24, 0, 12, 6, 18)$ , $\mathbf{y} = (16, 0, 8, 4, 12)$ (demo-3 unsorted)
unsorted-anti-symmetry-unsorted: $\mathbf{x} = (8, 0, 4, 2, 6)$ , $\mathbf{y} = (12, 0, 6, 3, 9)$ (demo-4 reversed and unsorted)

As a composite estimator, $\operatorname{Disparity}$ tests both the numerator ( $\operatorname{Shift}$ ) and denominator ( $\operatorname{AvgSpread}$ ). Unsorted variants verify end-to-end correctness including invariance properties.

PairwiseMargin Tests

\operatorname{PairwiseMargin}(n, m, \mathrm{misrate})

The $\operatorname{PairwiseMargin}$ test suite contains 178 test cases (4 demo + 4 natural + 10 edge + 12 small grid + 148 large grid). The domain constraint $\mathrm{misrate} \geq \frac{2}{\binom{n+m}{n}}$ is enforced; inputs violating this return a domain error. Combinations where the requested misrate falls below the minimum achievable misrate are excluded from the grid.

Demo examples ( $n = m = 30$ ) — from manual introduction:

demo-1: $n=30$ , $m=30$ , $\mathrm{misrate}=10^{-6}$ , expected output: $276$
demo-2: $n=30$ , $m=30$ , $\mathrm{misrate}=10^{-5}$ , expected output: $328$
demo-3: $n=30$ , $m=30$ , $\mathrm{misrate}=10^{-4}$ , expected output: $390$
demo-4: $n=30$ , $m=30$ , $\mathrm{misrate}=10^{-3}$ , expected output: $464$

These demo cases match the reference values used throughout the manual to illustrate $\operatorname{ShiftBounds}$ construction.

Natural sequences ( $[n, m] in {1, 2, 3, 4} \times {1, 2, 3, 4}$ × 2 misrates, filtered by min misrate) — 4 tests:

Misrate values: $\mathrm{misrate} in {10^{-1}, 10^{-2}}$
After filtering by $\mathrm{misrate} \geq \frac{2}{\binom{n+m}{n}}$ , only 4 combinations survive:
natural-3-3-mr1: $n=3$ , $m=3$ , $\mathrm{misrate}=0.1$ , expected output: $0$
natural-3-4-mr1: $n=3$ , $m=4$ , $\mathrm{misrate}=0.1$
natural-4-3-mr1: $n=4$ , $m=3$ , $\mathrm{misrate}=0.1$
natural-4-4-mr1: $n=4$ , $m=4$ , $\mathrm{misrate}=0.1$

Edge cases — boundary condition validation (10 tests):

boundary-min: $n=1$ , $m=1$ , $\mathrm{misrate}=1.0$ (minimum samples with maximum misrate, expected output: $0$ )
boundary-zero-margin-small: $n=20$ , $m=20$ , $\mathrm{misrate}=10^{-6}$ (strict misrate with sufficient samples)
boundary-loose: $n=5$ , $m=5$ , $\mathrm{misrate}=0.9$ (very permissive misrate)
symmetry-2-5: $n=2$ , $m=5$ , $\mathrm{misrate}=0.1$ (tests symmetry property)
symmetry-5-2: $n=5$ , $m=2$ , $\mathrm{misrate}=0.1$ (symmetric counterpart, same output as above)
symmetry-3-7: $n=3$ , $m=7$ , $\mathrm{misrate}=0.05$ (asymmetric sizes)
symmetry-7-3: $n=7$ , $m=3$ , $\mathrm{misrate}=0.05$ (symmetric counterpart)
asymmetry-extreme-1-100: $n=1$ , $m=100$ , $\mathrm{misrate}=0.1$ (extreme size difference)
asymmetry-extreme-100-1: $n=100$ , $m=1$ , $\mathrm{misrate}=0.1$ (reversed extreme)
asymmetry-extreme-2-50: $n=2$ , $m=50$ , $\mathrm{misrate}=0.05$ (highly unbalanced)

These edge cases validate correct handling of boundary conditions, the symmetry property $\operatorname{PairwiseMargin}(n, m, \mathrm{misrate}) = \operatorname{PairwiseMargin}(m, n, \mathrm{misrate})$ , and extreme asymmetry in sample sizes.

Comprehensive grid — systematic coverage for thorough validation:

Small sample combinations ( $[n, m] in {1, 2, 3, 4, 5} \times {1, 2, 3, 4, 5}$ × 6 misrates, filtered) — 12 tests:

Misrate values: $\mathrm{misrate} in {10^{-1}, 10^{-2}, 10^{-3}, 10^{-4}, 10^{-5}, 10^{-6}}$
Combinations where $\mathrm{misrate} < \frac{2}{\binom{n+m}{n}}$ are excluded
Test naming: n{n}_m{m}_mr{k} where $k$ is the negative log10 of misrate
Examples:
n5_m5_mr1: $n=5$ , $m=5$ , $\mathrm{misrate}=0.1$ , expected output: $10$
n5_m5_mr2: $n=5$ , $m=5$ , $\mathrm{misrate}=0.01$

Large sample combinations ( $[n, m] in {10, 20, 30, 50, 100} \times {10, 20, 30, 50, 100}$ × 6 misrates, filtered) — 148 tests:

Misrate values: same as small samples
Combinations where $\mathrm{misrate} < \frac{2}{\binom{n+m}{n}}$ are excluded (affects $n = m = 10$ at misrates $10^{-5}$ and $10^{-6}$ )
Test naming: n{n}_m{m}_r{k} where $k$ is the negative log10 of misrate
Examples:
n10_m10_r1: $n=10$ , $m=10$ , $\mathrm{misrate}=0.1$ , expected output: $56$
n50_m50_r3: $n=50$ , $m=50$ , $\mathrm{misrate}=0.001$ , expected output: $1556$
n100_m100_r6: $n=100$ , $m=100$ , $\mathrm{misrate}=10^{-6}$ , expected output: $6060$

The comprehensive grid validates both symmetric ( $n = m$ ) and asymmetric sample size combinations across six orders of magnitude in misrate, ensuring robust coverage of the parameter space.

SignedRankMargin Tests

\operatorname{SignedRankMargin}(n, \mathrm{misrate})

The $\operatorname{SignedRankMargin}$ test suite contains 39 correctness test cases (4 demo + 6 boundary + 7 exact + 20 medium + 2 error).

Demo examples ( $n = 30$ ) — from manual introduction:

demo-1: $n=30$ , $\mathrm{misrate}=10^{-6}$ , expected output: $46$
demo-2: $n=30$ , $\mathrm{misrate}=10^{-5}$ , expected output: $74$
demo-3: $n=30$ , $\mathrm{misrate}=10^{-4}$ , expected output: $112$
demo-4: $n=30$ , $\mathrm{misrate}=10^{-3}$ , expected output: $158$

These demo cases match the reference values used throughout the manual to illustrate $\operatorname{CenterBounds}$ construction.

Boundary cases — minimum achievable misrate validation:

boundary-n2-min: $n=2$ , $\mathrm{misrate}=0.5$ (minimum misrate for $n=2$ , expected output: $0$ )
boundary-n3-min: $n=3$ , $\mathrm{misrate}=0.25$ (minimum misrate for $n=3$ )
boundary-n4-min: $n=4$ , $\mathrm{misrate}=0.125$ (minimum misrate for $n=4$ )
boundary-loose: $n=5$ , $\mathrm{misrate}=0.5$ (permissive misrate)
boundary-tight: $n=10$ , $\mathrm{misrate}=0.01$ (strict misrate)
boundary-very-tight: $n=20$ , $\mathrm{misrate}=0.001$ (very strict misrate)

These boundary cases validate correct handling of minimum achievable misrate (formula: $2^{1-n}$ ) and edge conditions.

Exact computation ( $n \leq 10$ ) — validates dynamic programming path:

exact-n5-mr1e1: $n=5$ , $\mathrm{misrate}=0.1$
exact-n6-mr1e1: $n=6$ , $\mathrm{misrate}=0.1$
exact-n6-mr5e2: $n=6$ , $\mathrm{misrate}=0.05$
exact-n10-mr1e1: $n=10$ , $\mathrm{misrate}=0.1$ , expected output: $22$
exact-n10-mr1e2: $n=10$ , $\mathrm{misrate}=0.01$
exact-n10-mr5e2: $n=10$ , $\mathrm{misrate}=0.05$
exact-n10-mr5e3: $n=10$ , $\mathrm{misrate}=0.005$

These cases exercise the exact Wilcoxon signed-rank CDF computation for small samples where dynamic programming is used.

Medium samples ( $n in {15, 20, 30, 50, 100}$ × 4 misrates) — 20 tests:

Misrate values: $\mathrm{misrate} in {10^{-1}, 10^{-2}, 10^{-3}, 10^{-4}}$
Test naming: medium-n{n}-mr{k} where $k$ encodes the misrate
Examples:
medium-n15-mr1e1: $n=15$ , $\mathrm{misrate}=0.1$
medium-n30-mr1e2: $n=30$ , $\mathrm{misrate}=0.01$ , expected output: $220$
medium-n50-mr1e3: $n=50$ , $\mathrm{misrate}=0.001$
medium-n100-mr1e4: $n=100$ , $\mathrm{misrate}=0.0001$

The medium sample tests validate the transition region between exact computation ( $n \leq 63$ ) and approximate computation, ensuring consistent results across sample sizes and misrate values.

Error case — domain violation:

error-n1: $n=1$ , $\mathrm{misrate}=0.5$ (invalid: misrate below minimum achievable $2^{1-1} = 1.0$ )
error-n0: $n=0$ , $\mathrm{misrate}=0.05$ (invalid: n must be positive)

This error case verifies that implementations correctly reject $n=1$ with $\mathrm{misrate}=0.5$ as invalid input, since the minimum achievable misrate for $n=1$ is $2^0 = 1.0$ .

ShiftBounds Tests

\operatorname{ShiftBounds}(\mathbf{x}, \mathbf{y}, \mathrm{misrate}) = [z_{(k_{\text{left}})}, z_{(k_{\text{right}})}]

where

\mathbf{z} = { x_i - y_j }_{1 \leq i \leq n, 1 \leq j \leq m} \quad (\text{sorted})

k_{\text{left}} = \lfloor \frac{\operatorname{PairwiseMargin}(n, m, \mathrm{misrate})}{2} \rfloor + 1

k_{\text{right}} = n m - \lfloor \frac{\operatorname{PairwiseMargin}(n, m, \mathrm{misrate})}{2} \rfloor

The $\operatorname{ShiftBounds}$ test suite contains 61 correctness test cases (3 demo + 9 natural + 6 property + 10 edge + 9 additive + 4 uniform + 5 misrate + 15 unsorted). Since $\operatorname{ShiftBounds}$ returns bounds rather than a point estimate, tests validate that the bounds contain $\operatorname{Shift}(\mathbf{x}, \mathbf{y})$ and satisfy equivariance properties. Each test case output is a JSON object with lower and upper fields representing the interval bounds. The domain constraint $\mathrm{misrate} \geq \frac{2}{\binom{n+m}{n}}$ is enforced; inputs violating this return a domain error.

Demo examples ( $n = m = 5$ ) — from manual introduction, validating basic bounds:

demo-1: $\mathbf{x} = (1, 2, 3, 4, 5)$ , $\mathbf{y} = (3, 4, 5, 6, 7)$ , $\mathrm{misrate} = 0.05$ , expected output: $[-4, 0]$
demo-2: $\mathbf{x} = (1, 2, 3, 4, 5)$ , $\mathbf{y} = (3, 4, 5, 6, 7)$ , $\mathrm{misrate} = 0.01$ , expected output: $[-5, 1]$
demo-3: $\mathbf{x} = (3, 4, 5, 6, 7)$ , $\mathbf{y} = (3, 4, 5, 6, 7)$ , $\mathrm{misrate} = 0.05$ , expected output: bounds containing $0$ (identity case)

These cases illustrate how tighter misrates produce wider bounds and validate the identity property where identical samples yield bounds containing zero.

Natural sequences ( $[n, m] in {5, 8, 10} \times {5, 8, 10}$ , $\mathrm{misrate} = 10^{-2}$ ) — 9 combinations:

natural-5-5: $\mathbf{x} = (1, \ldots, 5)$ , $\mathbf{y} = (1, \ldots, 5)$ , expected bounds containing $0$
natural-5-8: $\mathbf{x} = (1, \ldots, 5)$ , $\mathbf{y} = (1, \ldots, 8)$
natural-5-10: $\mathbf{x} = (1, \ldots, 5)$ , $\mathbf{y} = (1, \ldots, 10)$
natural-8-5: $\mathbf{x} = (1, \ldots, 8)$ , $\mathbf{y} = (1, \ldots, 5)$
natural-8-8: $\mathbf{x} = (1, \ldots, 8)$ , $\mathbf{y} = (1, \ldots, 8)$ , expected bounds containing $0$
natural-8-10: $\mathbf{x} = (1, \ldots, 8)$ , $\mathbf{y} = (1, \ldots, 10)$
natural-10-5: $\mathbf{x} = (1, \ldots, 10)$ , $\mathbf{y} = (1, \ldots, 5)$
natural-10-8: $\mathbf{x} = (1, \ldots, 10)$ , $\mathbf{y} = (1, \ldots, 8)$
natural-10-10: $\mathbf{x} = (1, \ldots, 10)$ , $\mathbf{y} = (1, \ldots, 10)$ , expected bounds containing $0$

These sizes are chosen to satisfy $\mathrm{misrate} \geq \frac{2}{\binom{n+m}{n}}$ for all combinations.

Property validation ( $n = m = 10$ , $\mathrm{misrate} = 10^{-3}$ ) — 6 tests:

property-identity: $\mathbf{x} = (0, 2, 4, \ldots, 18)$ , $\mathbf{y} = (0, 2, 4, \ldots, 18)$ , bounds must contain $0$
property-location-shift: $\mathbf{x} = (7, 9, 11, \ldots, 25)$ , $\mathbf{y} = (13, 15, 17, \ldots, 31)$
Must produce same bounds as base case (location invariance)
property-scale-2x: $\mathbf{x} = (2, 4, 6, \ldots, 20)$ , $\mathbf{y} = (6, 8, 10, \ldots, 24)$
Bounds must be 2× the base case bounds (scale equivariance)
property-antisymmetry: $\mathbf{x} = (3, 4, \ldots, 12)$ , $\mathbf{y} = (1, 2, \ldots, 10)$
Bounds must be negated: if original is $[a, b]$ , this yields $[-b, -a]$
property-negative: $\mathbf{x} = (-10, -9, \ldots, -1)$ , $\mathbf{y} = (-12, -11, \ldots, -3)$
Validates sign handling with all negative values
property-mixed-signs: $\mathbf{x} = (-4, -3, \ldots, 5)$ , $\mathbf{y} = (-3, -2, \ldots, 6)$
Validates bounds crossing zero with mixed-sign samples

Edge cases — boundary conditions and extreme scenarios (10 tests):

edge-min-samples: $\mathbf{x} = (1, 2, 3, 4, 5)$ , $\mathbf{y} = (6, 7, 8, 9, 10)$ , $\mathrm{misrate} = 0.05$
edge-permissive-misrate: $\mathbf{x} = (1, 2, 3, 4, 5)$ , $\mathbf{y} = (3, 4, 5, 6, 7)$ , $\mathrm{misrate} = 0.5$ (very wide bounds)
edge-strict-misrate: $n = m = 20$ , $\mathrm{misrate} = 10^{-6}$ (very narrow bounds)
edge-zero-shift: $n = m = 10$ , all values $= 5$ , $\mathrm{misrate} = 10^{-3}$ (bounds around 0)
edge-asymmetric-3-100: $n = 3$ , $m = 100$ , $\mathrm{misrate} = 10^{-2}$ (extreme size difference)
edge-asymmetric-5-50: $n = 5$ , $m = 50$ , $\mathrm{misrate} = 10^{-3}$ (highly unbalanced)
edge-duplicates: $\mathbf{x} = (3, 3, 3, 3, 3)$ , $\mathbf{y} = (5, 5, 5, 5, 5)$ , $\mathrm{misrate} = 10^{-2}$ (all duplicates, bounds around 2)
edge-wide-range: $n = m = 10$ , values spanning $10^{-3}$ to $10^8$ , $\mathrm{misrate} = 10^{-3}$ (extreme value range)
edge-tiny-values: $n = m = 10$ , values $\approx 10^{-8}$ , $\mathrm{misrate} = 10^{-3}$ (numerical precision)
edge-large-values: $n = m = 10$ , values $\approx 10^8$ , $\mathrm{misrate} = 10^{-3}$ (large magnitude)

These edge cases stress-test boundary conditions, numerical stability, and the margin calculation with extreme parameters.

Additive distribution ( $[n, m] in {10, 30, 50} \times {10, 30, 50}$ , $\mathrm{misrate} = 10^{-3}$ ) — 9 combinations with $\underline{\operatorname{Additive}}(10, 1)$ :

additive-10-10, additive-10-30, additive-10-50
additive-30-10, additive-30-30, additive-30-50
additive-50-10, additive-50-30, additive-50-50
Random generation: $\mathbf{x}$ uses seed 0, $\mathbf{y}$ uses seed 1

These fuzzy tests validate that bounds properly encompass the shift estimate for realistic normally-distributed data at various sample sizes.

Uniform distribution ( $[n, m] in {10, 100} \times {10, 100}$ , $\mathrm{misrate} = 10^{-4}$ ) — 4 combinations with $\underline{\operatorname{Uniform}}(0, 1)$ :

uniform-10-10, uniform-10-100, uniform-100-10, uniform-100-100
Random generation: $\mathbf{x}$ uses seed 2, $\mathbf{y}$ uses seed 3

The asymmetric size combinations are particularly important for testing margin calculation with unbalanced samples.

Misrate variation ( $n = m = 20$ , $\mathbf{x} = (0, 2, 4, \ldots, 38)$ , $\mathbf{y} = (10, 12, 14, \ldots, 48)$ ) — 5 tests with varying misrates:

misrate-1e-2: $\mathrm{misrate} = 10^{-2}$
misrate-1e-3: $\mathrm{misrate} = 10^{-3}$
misrate-1e-4: $\mathrm{misrate} = 10^{-4}$
misrate-1e-5: $\mathrm{misrate} = 10^{-5}$
misrate-1e-6: $\mathrm{misrate} = 10^{-6}$

These tests use identical samples with varying misrates to validate the monotonicity property: smaller misrates (higher confidence) produce wider bounds. The sequence demonstrates how bound width increases as misrate decreases, helping implementations verify correct margin calculation.

Unsorted tests — verify independent sorting of $\mathbf{x}$ and $\mathbf{y}$ (15 tests):

unsorted-x-natural-5-5: $\mathbf{x} = (5, 3, 1, 4, 2)$ , $\mathbf{y} = (1, 2, 3, 4, 5)$ , $\mathrm{misrate} = 10^{-2}$ (X reversed, Y sorted)
unsorted-y-natural-5-5: $\mathbf{x} = (1, 2, 3, 4, 5)$ , $\mathbf{y} = (5, 3, 1, 4, 2)$ , $\mathrm{misrate} = 10^{-2}$ (X sorted, Y reversed)
unsorted-both-natural-5-5: $\mathbf{x} = (5, 3, 1, 4, 2)$ , $\mathbf{y} = (5, 3, 1, 4, 2)$ , $\mathrm{misrate} = 10^{-2}$ (both reversed)
unsorted-x-shuffle-5-5: $\mathbf{x} = (3, 1, 5, 4, 2)$ , $\mathbf{y} = (1, 2, 3, 4, 5)$ , $\mathrm{misrate} = 10^{-2}$ (X shuffled)
unsorted-y-shuffle-5-5: $\mathbf{x} = (1, 2, 3, 4, 5)$ , $\mathbf{y} = (4, 2, 5, 1, 3)$ , $\mathrm{misrate} = 10^{-2}$ (Y shuffled)
unsorted-both-shuffle-5-5: $\mathbf{x} = (3, 1, 5, 4, 2)$ , $\mathbf{y} = (2, 4, 1, 5, 3)$ , $\mathrm{misrate} = 10^{-2}$ (both shuffled)
unsorted-demo-unsorted-x: $\mathbf{x} = (5, 1, 4, 2, 3)$ , $\mathbf{y} = (3, 4, 5, 6, 7)$ , $\mathrm{misrate} = 0.05$ (demo-1 X unsorted)
unsorted-demo-unsorted-y: $\mathbf{x} = (1, 2, 3, 4, 5)$ , $\mathbf{y} = (7, 3, 6, 4, 5)$ , $\mathrm{misrate} = 0.05$ (demo-1 Y unsorted)
unsorted-demo-both-unsorted: $\mathbf{x} = (4, 1, 5, 2, 3)$ , $\mathbf{y} = (6, 3, 7, 4, 5)$ , $\mathrm{misrate} = 0.05$ (demo-1 both unsorted)
unsorted-identity-unsorted: $\mathbf{x} = (4, 1, 5, 2, 3)$ , $\mathbf{y} = (5, 1, 4, 3, 2)$ , $\mathrm{misrate} = 10^{-2}$ (identity property, both unsorted)
unsorted-negative-unsorted: $\mathbf{x} = (-1, -5, -3, -2, -4)$ , $\mathbf{y} = (-2, -4, -3, -5, -1)$ , $\mathrm{misrate} = 10^{-2}$ (negative values unsorted)
unsorted-asymmetric-5-10: $\mathbf{x} = (2, 5, 1, 3, 4)$ , $\mathbf{y} = (10, 5, 2, 8, 4, 1, 9, 3, 7, 6)$ , $\mathrm{misrate} = 10^{-2}$ (asymmetric sizes, both unsorted)
unsorted-duplicates: $\mathbf{x} = (3, 3, 3, 3, 3)$ , $\mathbf{y} = (5, 5, 5, 5, 5)$ , $\mathrm{misrate} = 10^{-2}$ (all duplicates, any order)
unsorted-mixed-duplicates-x: $\mathbf{x} = (2, 1, 3, 2, 1)$ , $\mathbf{y} = (1, 1, 2, 2, 3)$ , $\mathrm{misrate} = 10^{-2}$ (X has unsorted duplicates)
unsorted-mixed-duplicates-y: $\mathbf{x} = (1, 1, 2, 2, 3)$ , $\mathbf{y} = (3, 2, 1, 3, 2)$ , $\mathrm{misrate} = 10^{-2}$ (Y has unsorted duplicates)

These unsorted tests are critical because $\operatorname{ShiftBounds}$ computes bounds from pairwise differences, requiring both samples to be sorted independently. The variety ensures implementations dont incorrectly assume pre-sorted input or sort samples together. Each test must produce identical output to its sorted counterpart, validating that the implementation correctly handles the sorting step.

No performance test — $\operatorname{ShiftBounds}$ uses the $\text{FastShift}$ algorithm internally, which is already validated by the $\operatorname{Shift}$ performance test. Since bounds computation involves only two quantile calculations from the pairwise differences (at positions determined by $\operatorname{PairwiseMargin}$ ), the performance characteristics are equivalent to computing two $\operatorname{Shift}$ estimates, which completes efficiently for large samples.

RatioBounds Tests

\operatorname{RatioBounds}(\mathbf{x}, \mathbf{y}, \mathrm{misrate}) = \exp(\operatorname{ShiftBounds}(\log \mathbf{x}, \log \mathbf{y}, \mathrm{misrate}))

The $\operatorname{RatioBounds}$ test suite contains 61 correctness test cases (3 demo + 9 natural + 6 property + 10 edge + 9 multiplic + 4 uniform + 5 misrate + 15 unsorted). Since $\operatorname{RatioBounds}$ returns bounds rather than a point estimate, tests validate that the bounds contain $\operatorname{Ratio}(\mathbf{x}, \mathbf{y})$ and satisfy equivariance properties. Each test case output is a JSON object with lower and upper fields representing the interval bounds. All samples must contain strictly positive values. The domain constraint $\mathrm{misrate} \geq \frac{2}{\binom{n+m}{n}}$ is enforced; inputs violating this return a domain error.

Demo examples ( $n = m = 5$ , positive samples) — 3 tests:

demo-1: $\mathbf{x} = (1, 2, 3, 4, 5)$ , $\mathbf{y} = (2, 3, 4, 5, 6)$ , $\mathrm{misrate} = 0.05$
demo-2: $\mathbf{x} = (1, 2, 3, 4, 5)$ , $\mathbf{y} = (2, 3, 4, 5, 6)$ , $\mathrm{misrate} = 0.01$ , expected: wider bounds than demo-1
demo-3: $\mathbf{x} = (2, 3, 4, 5, 6)$ , $\mathbf{y} = (2, 3, 4, 5, 6)$ , $\mathrm{misrate} = 0.05$ , expected: bounds containing $1$ (identity case)

These cases illustrate how tighter misrates produce wider bounds and validate the identity property where identical samples yield bounds containing one.

Natural sequences ( $[n, m] in {5, 8, 10} \times {5, 8, 10}$ , $\mathrm{misrate} = 10^{-2}$ ) — 9 combinations:

natural-5-5: $\mathbf{x} = (1, \ldots, 5)$ , $\mathbf{y} = (1, \ldots, 5)$ , expected bounds containing $1$
natural-5-8: $\mathbf{x} = (1, \ldots, 5)$ , $\mathbf{y} = (1, \ldots, 8)$
natural-5-10: $\mathbf{x} = (1, \ldots, 5)$ , $\mathbf{y} = (1, \ldots, 10)$
natural-8-5: $\mathbf{x} = (1, \ldots, 8)$ , $\mathbf{y} = (1, \ldots, 5)$
natural-8-8: $\mathbf{x} = (1, \ldots, 8)$ , $\mathbf{y} = (1, \ldots, 8)$ , expected bounds containing $1$
natural-8-10: $\mathbf{x} = (1, \ldots, 8)$ , $\mathbf{y} = (1, \ldots, 10)$
natural-10-5: $\mathbf{x} = (1, \ldots, 10)$ , $\mathbf{y} = (1, \ldots, 5)$
natural-10-8: $\mathbf{x} = (1, \ldots, 10)$ , $\mathbf{y} = (1, \ldots, 8)$
natural-10-10: $\mathbf{x} = (1, \ldots, 10)$ , $\mathbf{y} = (1, \ldots, 10)$ , expected bounds containing $1$

These sizes are chosen to satisfy $\mathrm{misrate} \geq \frac{2}{\binom{n+m}{n}}$ for all combinations.

Property validation ( $n = m = 10$ , $\mathrm{misrate} = 10^{-3}$ ) — 6 tests:

property-identity: $\mathbf{x} = (1, 2, \ldots, 10)$ , $\mathbf{y} = (1, 2, \ldots, 10)$ , bounds must contain $1$
property-scale-2x: $\mathbf{x} = (2, 4, \ldots, 20)$ , $\mathbf{y} = (1, 2, \ldots, 10)$ , bounds must contain $2$
property-reciprocal: $\mathbf{x} = (1, 2, \ldots, 10)$ , $\mathbf{y} = (2, 4, \ldots, 20)$ , bounds must contain $0.5$ (reciprocal of scale-2x)
property-common-scale: $\mathbf{x} = (10, 20, \ldots, 100)$ , $\mathbf{y} = (20, 40, \ldots, 200)$
Same ratio as property-reciprocal (common scale invariance)
property-small-values: $\mathbf{x} = (0.1, 0.2, \ldots, 1.0)$ , $\mathbf{y} = (0.2, 0.4, \ldots, 2.0)$
Same ratio as property-reciprocal (small value handling)
property-mixed-scales: $\mathbf{x} = (0.01, 0.1, 1, 10, 100, 1000, 0.5, 5, 50, 500)$ , $\mathbf{y} = (0.1, 1, 10, 100, 1000, 10000, 5, 50, 500, 5000)$
Wide range validation

Edge cases — boundary conditions and extreme scenarios (10 tests):

edge-min-samples: $\mathbf{x} = (2, 3, 4, 5, 6)$ , $\mathbf{y} = (3, 4, 5, 6, 7)$ , $\mathrm{misrate} = 0.05$
edge-permissive-misrate: $\mathbf{x} = (1, 2, 3, 4, 5)$ , $\mathbf{y} = (2, 3, 4, 5, 6)$ , $\mathrm{misrate} = 0.5$ (very wide bounds)
edge-strict-misrate: $n = m = 20$ , $\mathrm{misrate} = 10^{-6}$ (very narrow bounds)
edge-unity-ratio: $n = m = 10$ , all values $= 5$ , $\mathrm{misrate} = 10^{-3}$ (bounds around 1)
edge-asymmetric-3-100: $n = 3$ , $m = 100$ , $\mathrm{misrate} = 10^{-2}$ (extreme size difference)
edge-asymmetric-5-50: $n = 5$ , $m = 50$ , $\mathrm{misrate} = 10^{-3}$ (highly unbalanced)
edge-duplicates: $\mathbf{x} = (3, 3, 3, 3, 3)$ , $\mathbf{y} = (5, 5, 5, 5, 5)$ , $\mathrm{misrate} = 10^{-2}$ (all duplicates, bounds around 0.6)
edge-wide-range: $n = m = 10$ , values spanning $10^{-3}$ to $10^8$ , $\mathrm{misrate} = 10^{-3}$ (extreme value range)
edge-tiny-values: $n = m = 10$ , values $\approx 10^{-6}$ , $\mathrm{misrate} = 10^{-3}$ (numerical precision)
edge-large-values: $n = m = 10$ , values $\approx 10^8$ , $\mathrm{misrate} = 10^{-3}$ (large magnitude)

These edge cases stress-test boundary conditions, numerical stability, and the margin calculation with extreme parameters.

Multiplic distribution ( $[n, m] in {10, 30, 50} \times {10, 30, 50}$ , $\mathrm{misrate} = 10^{-3}$ ) — 9 combinations with $\underline{\operatorname{Multiplic}}(1, 0.5)$ :

multiplic-10-10, multiplic-10-30, multiplic-10-50
multiplic-30-10, multiplic-30-30, multiplic-30-50
multiplic-50-10, multiplic-50-30, multiplic-50-50
Random generation: $\mathbf{x}$ uses seed 0, $\mathbf{y}$ uses seed 1

These fuzzy tests validate that bounds properly encompass the ratio estimate for realistic log-normally-distributed data at various sample sizes.

Uniform distribution ( $[n, m] in {10, 100} \times {10, 100}$ , $\mathrm{misrate} = 10^{-4}$ ) — 4 combinations with $\underline{\operatorname{Uniform}}(1, 10)$ :

uniform-10-10, uniform-10-100, uniform-100-10, uniform-100-100
Random generation: $\mathbf{x}$ uses seed 2, $\mathbf{y}$ uses seed 3
Note: positive range $[1, 10)$ used for ratio compatibility

The asymmetric size combinations are particularly important for testing margin calculation with unbalanced samples.

Misrate variation ( $n = m = 20$ , $\mathbf{x} = (1, 2, \ldots, 20)$ , $\mathbf{y} = (2, 4, \ldots, 40)$ ) — 5 tests with varying misrates:

misrate-1e-2: $\mathrm{misrate} = 10^{-2}$
misrate-1e-3: $\mathrm{misrate} = 10^{-3}$
misrate-1e-4: $\mathrm{misrate} = 10^{-4}$
misrate-1e-5: $\mathrm{misrate} = 10^{-5}$
misrate-1e-6: $\mathrm{misrate} = 10^{-6}$

Unsorted tests — verify independent sorting of $\mathbf{x}$ and $\mathbf{y}$ (15 tests):

unsorted-x-natural-5-5: $\mathbf{x} = (5, 3, 1, 4, 2)$ , $\mathbf{y} = (1, 2, 3, 4, 5)$ , $\mathrm{misrate} = 10^{-2}$ (X reversed, Y sorted)
unsorted-y-natural-5-5: $\mathbf{x} = (1, 2, 3, 4, 5)$ , $\mathbf{y} = (5, 3, 1, 4, 2)$ , $\mathrm{misrate} = 10^{-2}$ (X sorted, Y reversed)
unsorted-both-natural-5-5: $\mathbf{x} = (5, 3, 1, 4, 2)$ , $\mathbf{y} = (5, 3, 1, 4, 2)$ , $\mathrm{misrate} = 10^{-2}$ (both reversed)
unsorted-x-shuffle-5-5: $\mathbf{x} = (3, 1, 5, 4, 2)$ , $\mathbf{y} = (1, 2, 3, 4, 5)$ , $\mathrm{misrate} = 10^{-2}$ (X shuffled)
unsorted-y-shuffle-5-5: $\mathbf{x} = (1, 2, 3, 4, 5)$ , $\mathbf{y} = (4, 2, 5, 1, 3)$ , $\mathrm{misrate} = 10^{-2}$ (Y shuffled)
unsorted-both-shuffle-5-5: $\mathbf{x} = (3, 1, 5, 4, 2)$ , $\mathbf{y} = (2, 4, 1, 5, 3)$ , $\mathrm{misrate} = 10^{-2}$ (both shuffled)
unsorted-demo-unsorted-x: $\mathbf{x} = (5, 1, 4, 2, 3)$ , $\mathbf{y} = (2, 3, 4, 5, 6)$ , $\mathrm{misrate} = 0.05$ (demo-1 X unsorted)
unsorted-demo-unsorted-y: $\mathbf{x} = (1, 2, 3, 4, 5)$ , $\mathbf{y} = (6, 2, 5, 3, 4)$ , $\mathrm{misrate} = 0.05$ (demo-1 Y unsorted)
unsorted-demo-both-unsorted: $\mathbf{x} = (4, 1, 5, 2, 3)$ , $\mathbf{y} = (5, 2, 6, 3, 4)$ , $\mathrm{misrate} = 0.05$ (demo-1 both unsorted)
unsorted-identity-unsorted: $\mathbf{x} = (4, 1, 5, 2, 3)$ , $\mathbf{y} = (5, 1, 4, 3, 2)$ , $\mathrm{misrate} = 10^{-2}$ (identity property, both unsorted)
unsorted-scale-unsorted: $\mathbf{x} = (10, 30, 20)$ , $\mathbf{y} = (15, 5, 10)$ , $\mathrm{misrate} = 0.5$ (scale relationship, both unsorted)
unsorted-asymmetric-5-10: $\mathbf{x} = (2, 5, 1, 3, 4)$ , $\mathbf{y} = (10, 5, 2, 8, 4, 1, 9, 3, 7, 6)$ , $\mathrm{misrate} = 10^{-2}$ (asymmetric sizes, both unsorted)
unsorted-duplicates: $\mathbf{x} = (3, 3, 3, 3, 3)$ , $\mathbf{y} = (5, 5, 5, 5, 5)$ , $\mathrm{misrate} = 10^{-2}$ (all duplicates, any order)
unsorted-mixed-duplicates-x: $\mathbf{x} = (2, 1, 3, 2, 1)$ , $\mathbf{y} = (1, 1, 2, 2, 3)$ , $\mathrm{misrate} = 10^{-2}$ (X has unsorted duplicates)
unsorted-mixed-duplicates-y: $\mathbf{x} = (1, 1, 2, 2, 3)$ , $\mathbf{y} = (3, 2, 1, 3, 2)$ , $\mathrm{misrate} = 10^{-2}$ (Y has unsorted duplicates)

These unsorted tests are critical because $\operatorname{RatioBounds}$ computes bounds from pairwise ratios, requiring both samples to be sorted independently. The variety ensures implementations dont incorrectly assume pre-sorted input or sort samples together. Each test must produce identical output to its sorted counterpart, validating that the implementation correctly handles the sorting step.

No performance test — $\operatorname{RatioBounds}$ uses the $\text{FastRatio}$ algorithm internally, which delegates to $\text{FastShift}$ in log-space. Since bounds computation involves only two quantile calculations from the pairwise differences (at positions determined by $\operatorname{PairwiseMargin}$ ), the performance characteristics are equivalent to computing two $\operatorname{Ratio}$ estimates, which completes efficiently for large samples.

CenterBounds Tests

\operatorname{CenterBounds}(\mathbf{x}, \mathrm{misrate}) = [w_{(k_{\text{left}})}, w_{(k_{\text{right}})}]

where $\mathbf{w} = { \frac{x_i + x_j}{2} }$ (pairwise averages, sorted) for $i \leq j$ , $k_{\text{left}} = \lfloor \operatorname{SignedRankMargin} / \rfloor2) + 1$ , $k_{\text{right}} = N - \lfloor \operatorname{SignedRankMargin} / \rfloor2)$ , and $N = \frac{n(n+1)}{2}$ .

The $\operatorname{CenterBounds}$ test suite contains 43 test cases (3 demo + 4 natural + 5 property + 7 edge + 4 symmetric + 4 asymmetric + 2 additive + 2 uniform + 4 misrate + 6 unsorted + 2 error cases). Since $\operatorname{CenterBounds}$ returns bounds rather than a point estimate, tests validate that bounds contain $\operatorname{Center}(\mathbf{x})$ and satisfy equivariance properties. Each test case output is a JSON object with lower and upper fields representing the interval bounds.

Demo examples — from manual introduction, validating basic bounds:

demo-1: $\mathbf{x} = (1, 2, 3, 4, 5)$ , $\mathrm{misrate} = 0.1$ , expected output: $[1.5, 4.5]$
demo-2: $\mathbf{x} = (1, \ldots, 10)$ , $\mathrm{misrate} = 0.01$ , expected output: $[2.5, 8.5]$
demo-3: $\mathbf{x} = (0, 2, 4, 6, 8)$ , $\mathrm{misrate} = 0.1$

These cases illustrate how tighter misrates produce wider bounds.

Natural sequences ( $n in {5, 7, 10, 20}$ , $\mathrm{misrate} = 0.01$ ) — 4 tests:

natural-5: $\mathbf{x} = (1, 2, 3, 4, 5)$ , bounds containing $\operatorname{Center} = 3$
natural-7: $\mathbf{x} = (1, \ldots, 7)$ , bounds containing $\operatorname{Center} = 4$
natural-10: $\mathbf{x} = (1, \ldots, 10)$ , expected output: $[2.5, 8.5]$
natural-20: $\mathbf{x} = (1, \ldots, 20)$ , bounds containing $\operatorname{Center} = 10.5$

Property validation ( $n = 5$ , $\mathrm{misrate} = 0.05$ ) — 5 tests:

property-identity: $\mathbf{x} = (1, 2, 3, 4, 5)$ , bounds must contain $\operatorname{Center} = 3$
property-centered: $\mathbf{x} = (-2, -1, 0, 1, 2)$ , bounds must contain $\operatorname{Center} = 0$
property-location-shift: $\mathbf{x} = (11, 12, 13, 14, 15)$ (= demo-1 + 10), bounds must be demo-1 bounds + 10
property-scale-2x: $\mathbf{x} = (2, 4, 6, 8, 10)$ (= 2 × demo-1), bounds must be 2× demo-1 bounds
property-mixed-signs: $\mathbf{x} = (-2, -1, 0, 1, 2)$ , validates bounds crossing zero

Edge cases — boundary conditions and extreme scenarios (7 tests):

edge-two-elements: $\mathbf{x} = (1, 2)$ , $\mathrm{misrate} = 0.5$ (minimum meaningful sample)
edge-three-elements: $\mathbf{x} = (1, 2, 3)$ , $\mathrm{misrate} = 0.25$ (small sample)
edge-loose-misrate: $\mathbf{x} = (1, 2, 3, 4, 5)$ , $\mathrm{misrate} = 0.5$ (permissive bounds)
edge-strict-misrate: $\mathbf{x} = (1, \ldots, 10)$ , $\mathrm{misrate} = 0.002$ (near-minimum misrate for $n=10$ )
edge-duplicates-10: $\mathbf{x} = (5, 5, 5, 5, 5, 5, 5, 5, 5, 5)$ , $\mathrm{misrate} = 0.01$ (all identical, bounds $= [5, 5]$ )
edge-negative: $\mathbf{x} = (-5, -4, -3, -2, -1)$ , $\mathrm{misrate} = 0.05$ (negative values)
edge-wide-range: $\mathbf{x} = (1, 10, 100, 1000, 10000)$ , $\mathrm{misrate} = 0.1$ (extreme value range)

Symmetric distributions ( $\mathrm{misrate} = 0.05$ ) — 4 tests with symmetric data:

symmetric-5: $\mathbf{x} = (-2, -1, 0, 1, 2)$ , bounds centered around $0$
symmetric-7: $\mathbf{x} = (-3, -2, -1, 0, 1, 2, 3)$ , bounds centered around $0$
symmetric-10: $n = 10$ symmetric around $0$
symmetric-15: $n = 15$ symmetric around $0$

These tests validate that symmetric data produces symmetric bounds around the center.

Asymmetric distributions ( $n = 5$ , $\mathrm{misrate} = 0.1$ ) — 4 tests validating bounds with asymmetric data:

asymmetric-left-skew: $\mathbf{x} = (1, 7, 8, 9, 10)$ , expected output: $[4, 9.5]$
asymmetric-right-skew: $\mathbf{x} = (1, 2, 3, 4, 10)$ , expected output: $[1.5, 7]$
asymmetric-bimodal: $\mathbf{x} = (1, 1, 5, 9, 9)$ , expected output: $[1, 9]$
asymmetric-outlier: $\mathbf{x} = (1, 2, 3, 4, 100)$ , expected output: $[1.5, 52]$

These tests validate that $\operatorname{CenterBounds}$ handles asymmetric data correctly, complementing the symmetric test cases.

Additive distribution ( $\mathrm{misrate} = 0.01$ ) — 2 tests with $\underline{\operatorname{Additive}}(10, 1)$ :

additive-10: $n = 10$ , seed 0
additive-20: $n = 20$ , seed 0

Uniform distribution ( $\mathrm{misrate} = 0.01$ ) — 2 tests with $\underline{\operatorname{Uniform}}(0, 1)$ :

uniform-10: $n = 10$ , seed 1
uniform-20: $n = 20$ , seed 1

Misrate variation ( $\mathbf{x} = (1, \ldots, 10)$ ) — 4 tests with varying misrates:

misrate-1e-1: $\mathrm{misrate} = 0.1$
misrate-5e-2: $\mathrm{misrate} = 0.05$
misrate-1e-2: $\mathrm{misrate} = 0.01$
misrate-5e-3: $\mathrm{misrate} = 0.005$

These tests validate monotonicity: smaller misrates produce wider bounds.

Unsorted tests — verify sorting independence (6 tests):

unsorted-reverse-5: $\mathbf{x} = (5, 4, 3, 2, 1)$ , must equal natural-5 output
unsorted-reverse-7: $\mathbf{x} = (7, 6, 5, 4, 3, 2, 1)$ , must equal natural-7 output
unsorted-shuffle-5: $\mathbf{x}$ shuffled, must equal sorted counterpart
unsorted-shuffle-7: $\mathbf{x}$ shuffled, must equal sorted counterpart
unsorted-negative-5: negative values unsorted
unsorted-mixed-signs-5: mixed signs unsorted

These tests validate that $\operatorname{CenterBounds}$ produces identical results regardless of input order.

Error cases — 2 tests validating input validation:

error-single-element: $\mathbf{x} = (1)$ , $\mathrm{misrate} = 0.5$ (minimum sample size violation)
error-invalid-misrate: $\mathbf{x} = (1, 2, 3, 4, 5)$ , $\mathrm{misrate} = 0.001$ (misrate below minimum achievable)

Test Framework

The reference test framework consists of three components:

Test generation — The C# implementation defines test inputs programmatically using builder patterns. For deterministic cases, inputs are explicitly specified. For random cases, the framework uses controlled seeds with System.Random to ensure reproducibility across all platforms.

The random generation mechanism works as follows:

Each test suite builder maintains a seed counter initialized to zero.
For one-sample estimators, each distribution type receives the next available seed. The same random generator produces all samples for all sizes within that distribution.
For two-sample estimators, each pair of distributions receives two consecutive seeds: one for the $\mathbf{x}$ sample generator and one for the $\mathbf{y}$ sample generator.
The seed counter increments with each random generator creation, ensuring deterministic test data generation.

For $\underline{\operatorname{Additive}}$ distributions, random values are generated using the Box-Müller transform, which converts pairs of uniform random values into normally distributed values. The transform applies the formula:

X = \mu + \sigma \sqrt{-2 \ln(U_1)} \sin(2 \pi U_2)

where $U_1, U_2$ are uniform random values from $\underline{\operatorname{Uniform}}(0, 1)$ , $\mu$ is the mean, and $\sigma$ is the standard deviation.

For $\underline{\operatorname{Uniform}}$ distributions, random values are generated directly using the quantile function:

X = \min + U \cdot (\max - \min)

where $U$ is a uniform random value from $\underline{\operatorname{Uniform}}(0, 1)$ .

The framework executes the reference implementation on all generated inputs and serializes input-output pairs to JSON format.

Test validation — Each language implementation loads the JSON test cases and executes them against its local estimator implementation. Assertions verify that outputs match expected values within a given numerical tolerance (typically $10^{-10}$ for relative error).

Test data format — Each test case is a JSON file containing input and output fields. For one-sample estimators, the input contains array x and optional parameters. For two-sample estimators, input contains arrays x and y. For bounds estimators ( $\operatorname{ShiftBounds}$ , $\operatorname{RatioBounds}$ ), input additionally contains misrate. Output is a single numeric value for point estimators, or an object with lower and upper fields for bounds estimators.

Performance testing — The toolkit provides $O(n \log n)$ fast algorithms for $\operatorname{Center}$ , $\operatorname{Spread}$ , and $\operatorname{Shift}$ estimators, dramatically more efficient than naive implementations that materialize all pairwise combinations. Performance tests use sample size $n = 100,000$ (for one-sample) or $n = m = 100,000$ (for two-sample). This specific size creates a clear performance distinction: fast implementations ( $O(n \log n)$ or $O((m+n) \log L)$ ) complete in under 5 seconds on modern hardware across all supported languages, while naive implementations ( $O(n^2 \log n)$ or $O(m n \log(m n))$ ) would be prohibitively slow (taking hours or failing due to memory exhaustion). With $n = 100,000$ , naive approaches would need to materialize approximately 5 billion pairwise values for $\operatorname{Center}$ / $\operatorname{Spread}$ or 10 billion for $\operatorname{Shift}$ , whereas fast algorithms require only $O(n)$ additional memory. Performance tests serve dual purposes: correctness validation at scale and performance regression detection, ensuring implementations use the efficient algorithms and remain practical for real-world datasets with hundreds of thousands of observations. Performance test specifications are provided in the respective estimator sections above.

This framework ensures that all seven language implementations maintain strict numerical agreement across the full test suite.