Files
MeshCore/test/test_nrf52_gnss_version_trim.py
T
mikecarper 08b1c8826c Save RAK repeater flash while retaining fast field arithmetic
Use compact scalar crypto, reviewed GNSS version parsing and shared CLI reply copies for RAK3401/RAK4631 repeaters. Preserve keys, protocols, commands and configured capacities.

Both Reduced images save 11,580 bytes. SWD measurements on the RAK3401 found scalar-only signing still near 50.9 ms and key exchange near 38 ms. Keep compact field arithmetic off: its extra 4.3 KiB saving adds about a quarter second and delays radio servicing.

Validate Full and Reduced production OTA packages on both boards, focused crypto/GPS/CLI tests, and linked ARM crypto outputs. Include the RAM benchmark harness and scoped results. No live RF packet-loss qualification is claimed.
2026-10-27 11:41:32 -07:00

205 lines
10 KiB
Python

"""Qualify the private GNSS transform and native scanf replacement behavior."""
import contextlib
import importlib.util
import io
import os
from pathlib import Path
import shutil
import subprocess
import tempfile
import unittest
from unittest.mock import patch
from test_ota_cli_listing import function
ROOT = Path(__file__).resolve().parents[1]
SPEC = importlib.util.spec_from_file_location("gnss_trim", ROOT / "scripts/nrf52_gnss_version_trim.py")
TRIM = importlib.util.module_from_spec(SPEC)
SPEC.loader.exec_module(TRIM)
SOURCE = TRIM.INCLUDE + "\nvoid version(const char* ptr) {\n" + TRIM.ORIGINAL_CONVERSION + "\n}\n"
HEADERS = {name: "// fixture: " + name + "\n" for name in TRIM.HEADERS}
class Node:
def __init__(self, path):
self.path = Path(path)
def srcnode(self):
return self
def get_abspath(self):
return str(self.path)
class BuildEnv:
def __init__(self, path):
self.path = Path(path)
self.registrations = []
def subst(self, value):
assert value == "$BUILD_DIR"
return str(self.path)
def File(self, path):
return Path(path)
def AddBuildMiddleware(self, callback, pattern):
self.registrations.append((callback, pattern))
class GnssVersionTrimTests(unittest.TestCase):
def test_both_reviewed_revisions_use_the_same_bounded_transform(self):
for hash_name in ("SOURCE_SHA256", "SOURCE_2_2_28_SHA256"):
with self.subTest(revision=hash_name), patch.object(TRIM, hash_name, TRIM.digest(SOURCE)):
patched = TRIM.patched_source(SOURCE)
self.assertNotIn(TRIM.ORIGINAL_CONVERSION, patched)
self.assertIn(TRIM.VERSION_CONVERSION, patched)
def test_private_copy_checks_source_and_all_headers_and_preserves_downloads(self):
# Small synthetic dependencies test the transform mechanics; production
# fingerprints remain fixed to the complete reviewed library files.
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
source = root / "libdeps/gnss/src" / TRIM.SOURCE_NAME
source.parent.mkdir(parents=True)
source.write_bytes(SOURCE.replace("\n", "\r\n").encode())
for name, text in HEADERS.items():
(source.parent / name).write_text(text)
original = {path.name: path.read_bytes() for path in source.parent.iterdir()}
env = BuildEnv(root / "build")
with patch.object(TRIM, "SOURCE_SHA256", TRIM.digest(SOURCE)), patch.object(
TRIM, "HEADERS", {name: TRIM.digest(text) for name, text in HEADERS.items()}):
destination = TRIM.replace_gnss_source(env, Node(source))
self.assertEqual(destination, env.path / "trimmed-nrf52-gnss" / TRIM.SOURCE_NAME)
output = destination.read_text()
self.assertNotIn("sscanf", output)
self.assertIn(TRIM.VERSION_CONVERSION, output)
times = {path.name: path.stat().st_mtime_ns for path in destination.parent.iterdir()}
self.assertEqual(TRIM.replace_gnss_source(env, Node(source)), destination)
self.assertEqual(times, {path.name: path.stat().st_mtime_ns for path in destination.parent.iterdir()})
self.assertEqual(original, {path.name: path.read_bytes() for path in source.parent.iterdir()})
for name, text in HEADERS.items():
self.assertEqual((destination.parent / name).read_text(), text)
for change in ("source", *HEADERS):
with self.subTest(change=change), patch.object(TRIM, "SOURCE_SHA256", TRIM.digest(SOURCE)), patch.object(
TRIM, "HEADERS", {name: TRIM.digest(text) for name, text in HEADERS.items()}):
target = source if change == "source" else source.parent / change
before = target.read_bytes()
target.write_bytes(before + b"// unreviewed\n")
other_env = BuildEnv(root / ("unknown-" + change))
notice = io.StringIO()
node = Node(source)
with contextlib.redirect_stdout(notice):
self.assertIs(TRIM.replace_gnss_source(other_env, node), node)
self.assertIn("ordinary source retained", notice.getvalue())
self.assertFalse(other_env.path.exists())
target.write_bytes(before)
def test_only_qualified_roles_install_middleware_and_opt_out_is_preserved(self):
spec = importlib.util.spec_from_file_location("flash_trim", ROOT / "scripts/nrf52_flash_trim.py")
policy = importlib.util.module_from_spec(spec)
spec.loader.exec_module(policy)
class Env(dict):
def PioPlatform(self):
class Platform:
name = "nordicnrf52"
def get_package_dir(self, _name): return ""
return Platform()
def BoardConfig(self): return {"build.mcu": "nrf52840"}
def AppendUnique(self, **kwargs):
for name, value in kwargs.items(): self.setdefault(name, []).extend(value)
def subst(self, value): return value.replace("$PROJECT_DIR", str(ROOT))
def AddBuildMiddleware(self, callback, pattern): self.setdefault("middleware", []).append(pattern)
for role, flags, expected, shared_replies in (("companion_radio", "", True, False),
("companion_radio", "-DMESH_NRF52_COMPANION_TRIM=0", False, False),
("simple_repeater", "", False, False), ("custom", "", False, False),
("simple_repeater", "-DRAK_3401", True, True),
("simple_repeater", "-DRAK_4631", True, True),
("simple_room_server", "-DRAK_4631", False, False),
("simple_sensor", "-DRAK_3401", False, False),
("simple_repeater", "-DRAK_4631 -DMESH_NRF52_GNSS_VERSION_TRIM=0", False, True),
("simple_repeater", "-DRAK_4631 -DMESH_CLI_SHARE_REPLIES=0", True, False),
("simple_repeater", "-DRAK_3401 -DMESH_NRF52_FLASH_TRIM=0", False, False)):
with self.subTest(role=role, flags=flags):
env = Env(BUILD_FLAGS=flags, CPPDEFINES=[], PIOENV="custom",
SRC_FILTER="+<../examples/" + role + ">")
policy.install(env)
self.assertEqual("*" + TRIM.SOURCE_NAME in env.get("middleware", []), expected)
self.assertEqual("*CommonCLI.cpp" in env.get("middleware", []), shared_replies)
def test_native_gnss_conversion_parity_and_bounded_cli_tokens(self):
compiler = shutil.which("g++") or shutil.which("clang++")
if not compiler:
self.skipTest("a native C++ compiler is required")
cli = (ROOT / "src/helpers/ota/OtaCli.cpp").read_text()
native = r'''
#include <cassert>
#include <climits>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
struct Version { bool valid; uint8_t high, low; };
static Version original(const char* ptr) {
int protHi = 0, protLo = 0;
@ORIGINAL@
return {scanned == 2, uint8_t(protHi), uint8_t(protLo)};
}
static Version trimmed(const char* ptr) {
int protHi = 0, protLo = 0;
@CONVERSION@
return {scanned == 2, uint8_t(protHi), uint8_t(protLo)};
}
static void parity(const char* text) {
const Version before = original(text), after = trimmed(text);
assert(before.valid == after.valid);
if (before.valid) assert(before.high == after.high && before.low == after.low);
}
@TOKENS@
int main() {
for (const char* text : {"18.00", "27.12", "0.0", "255.255", "256.256",
" +27.\t+12 extra", "\t\r\n-1.\v\f-2 trailing", "0018.0000",
"", " ", "18", "18.", ".12", "18 .12", "18.x", "x18.12",
"+.12", "18.+", "18.12.34", "18.0x20", "0x18.12",
"2147483647.2147483647", "-2147483648.-2147483648",
"2147483648.2147483648", "-2147483649.-2147483649",
"9999999999999999999999999999999.12",
"18.-9999999999999999999999999999999"}) parity(text);
uint32_t random = 0xB43A1123;
for (unsigned n = 0; n < 3000; ++n) {
random = random * 1664525U + 1013904223U;
char text[96];
snprintf(text, sizeof(text), "\t%ld. %ld extra", long(int32_t(random)), long(int32_t(random ^ 0x91D43AA5U)));
parity(text);
}
struct { char first[8]; uint8_t guard1; char second[10]; uint8_t guard2; } words = {};
words.guard1 = words.guard2 = 0xA5;
assert(parse_two_words("\t1234567\v\fabcdefghi\r\n", words.first, sizeof(words.first), words.second, sizeof(words.second)) == 2);
assert(!strcmp(words.first, "1234567") && !strcmp(words.second, "abcdefghi"));
for (const char* text : {"12345678 x", "x abcdefghij", "x y z"})
assert(parse_two_words(text, words.first, sizeof(words.first), words.second, sizeof(words.second)) == 3);
assert(words.guard1 == 0xA5 && words.guard2 == 0xA5);
assert(parse_two_words(" \t\r\n", words.first, sizeof(words.first), words.second, sizeof(words.second)) == 0);
}
'''.replace("@ORIGINAL@", TRIM.ORIGINAL_CONVERSION).replace("@CONVERSION@", TRIM.VERSION_CONVERSION).replace(
"@TOKENS@", function(cli, "parse_two_words"))
native = "#include <initializer_list>\n" + native
sanitizers = [] if os.name == "nt" else ["-fsanitize=address,undefined", "-fno-sanitize-recover=all", "-fno-pie", "-no-pie"]
with tempfile.TemporaryDirectory() as directory:
source = Path(directory) / "parity.cpp"
source.write_text(native)
binary = Path(directory) / ("parity.exe" if os.name == "nt" else "parity")
built = subprocess.run([compiler, "-std=c++11", "-O1", "-Wall", "-Wextra", "-Werror",
*sanitizers, str(source), "-o", str(binary)], capture_output=True, text=True, timeout=60)
self.assertEqual(built.returncode, 0, built.stdout + built.stderr)
tested = subprocess.run([str(binary)], capture_output=True, text=True, timeout=30)
self.assertEqual(tested.returncode, 0, tested.stdout + tested.stderr)
if __name__ == "__main__":
unittest.main()