Files
R8Forge/tests/widths.ps1
T
dsh 10f164b480 docs: the signed wrappers in SPEC, AGENTS, README and TODO
SPEC gains 7.10 with both contracts, the five design points and the measured
tape lengths; 5.4 stops saying "implementation pending" and spells out why the
range is asymmetric -- |N| can be outside the signed range while still fitting
unsigned, so 1024 has to print -1024 and the absolute value cannot be done by
clearing the sign bit.

Numbers re-measured on this machine, because some had drifted: the flagship is
62351 characters / 202159 steps (documented as 62513 / 206491), --opt takes it
to 56338, the calculator is 62624, the byte level test is 23 items over 22
macros, and asm/ has 55 macros in 23 files.

tests/widths.ps1 no longer compares the viz's serial output below 8 bit cells:
the viz prints one number per OUT there, so the 7 bit "viz FAILED" was the
script's expectation, not the tape -- the calculator itself passes at 7 bits
through r8forge_derive, and the same failure reproduces with the previous
calculator (checked against HEAD in a temp worktree).  The TODO gains the open
question of whether the flagship should keep the 65536 limit at all, plus the
evidence that a 16 bit tape of 96052 characters runs fine in the viz.
2026-11-18 21:14:07 +08:00

79 lines
4.0 KiB
PowerShell

# Build the toolchain at a set of cell widths and *check* what should hold there.
#
# powershell -File tests\widths.ps1 # 7,8,11,16,17,31,32
# powershell -File tests\widths.ps1 -Widths 11,16,32
#
# Per width, this asserts:
# * the `widthfree` ctest label passes (bit level slices, the synthesizer, the
# looping demo, the macro comment format);
# * examples/calc.r8asm assembles and `12 34 + .` prints D digits, where
# D = floor(W * 30103 / 100000) + 1 -- the same formula the library uses. A
# width that silently did not take effect fails this, because it would print
# four digits;
# * if the reference machine is built next door, it prints the same thing
# (`rot8_test --cell <W>`), which is the three way check. That one only
# runs for W >= 8: the viz switches to serial ASCII only when a cell is at
# least 8 bits wide, and below that it prints one number per OUT -- so a
# "> 046" comparison at 7 bits would fail for a reason that has nothing to
# do with the tape (the calc itself is still checked there).
# Widths under 7 cannot hold '0' (48) in a cell, so they get the library tests
# only.
# A comma separated string rather than [int[]]: `powershell -File ... -Widths 11,16`
# binds as one string, and 11,16 would quietly become 1116.
param(
[string]$Widths = "7,8,11,16,17,31,32",
[string]$CMake = "C:/Program Files/Microsoft Visual Studio/18/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/bin/cmake.exe"
)
$ErrorActionPreference = "Continue"
$root = Split-Path -Parent $PSScriptRoot
$ctest = Join-Path (Split-Path $CMake) "ctest.exe"
$viz = Join-Path $root "..\ROT-8-viz\build\Release\rot8_test.exe"
$failed = @()
foreach ($w in ($Widths.Split(",") | ForEach-Object { [int]$_.Trim() })) {
$dir = Join-Path $root "build$w"
$d = [int][math]::Floor($w * 0.30103) + 1
$nums = @(62, 32) + (@(48) * ($d - 2)) + @(52, 54) + @(10)
$want = "out " + ($nums -join " ")
Write-Host "=== cell $w (D = $d)"
& $CMake -S $root -B $dir "-DR8FORGE_CELL_SIZE=$w" 2>$null | Out-Null
& $CMake --build $dir --config Release 2>$null | Out-Null
& $ctest --test-dir $dir -C Release -L widthfree 2>$null | Out-Null
if ($LASTEXITCODE -ne 0) { Write-Host " widthfree tests FAILED"; $failed += $w }
else { Write-Host " widthfree tests ok" }
$r8 = Join-Path $dir "Release\r8forge.exe"
$derive = Join-Path $dir "Release\r8forge_derive.exe"
$tape = (& $r8 "examples/calc.r8asm" --quiet 2>$null | Out-String).TrimEnd("`r", "`n")
Write-Host (" calc tape: " + $tape.Length + " chars")
$got = (& $derive "examples/calc.r8asm" 0 -i "12 34 + ." 2>$null | Out-String).Trim()
if ($got -ne $want) { Write-Host " calc FAILED: want '$want' got '$got'"; $failed += $w }
else { Write-Host " calc ok: $want" }
if (Test-Path $viz) {
# The viz only speaks serial ASCII when a cell is at least 8 bits wide
# (bit 7 doubles as the 7E1 parity/stop bit; below that it prints one
# number per OUT). Comparing a 7 bit tape with "> 046" therefore says
# nothing: at 7 bits the same tape legitimately prints numbers. The
# calc check above already covers 7 bits, so skip the viz there.
if ($w -lt 8) {
Write-Host " viz skipped: serial I/O needs >= 8 bit cells"
} else {
$tmp = Join-Path $env:TEMP "calc$w.rot8"
[System.IO.File]::WriteAllText($tmp, $tape, (New-Object System.Text.UTF8Encoding($false)))
$serial = (& $viz "--cell" $w "--input" "12 34 + ." $tmp 2>$null | Out-String).Trim()
$wantSerial = "> " + ("0" * ($d - 2)) + "46"
if ($serial -ne $wantSerial) { Write-Host " viz FAILED: want '$wantSerial' got '$serial'"; $failed += $w }
else { Write-Host " viz ok: $wantSerial" }
Remove-Item $tmp -ErrorAction SilentlyContinue
}
}
Remove-Item -Recurse -Force $dir
}
if ($failed.Count -gt 0) { Write-Host ("FAILED at widths: " + ($failed -join ", ")); exit 1 }
Write-Host "all requested widths ok"