From 88c85108005a30a730fa7b78b2899b210754f3be Mon Sep 17 00:00:00 2001 From: mikecarper Date: Wed, 7 Oct 2026 05:21:43 -0700 Subject: [PATCH] Preserve enabled RX gain from compact 1.14.1 preferences --- .github/workflows/run-unit-tests.yml | 1 + src/helpers/CommonCLI.cpp | 10 +- test/README.md | 9 + .../common_prefs_rxgain/provenance.json | 17 ++ .../common_prefs_rxgain/v1.14.0-writer.inc | 45 +++ .../common_prefs_rxgain/v1.14.1-writer.inc | 45 +++ test/test_common_prefs_legacy_rxgain.py | 267 ++++++++++++++++++ 7 files changed, 393 insertions(+), 1 deletion(-) create mode 100644 test/fixtures/common_prefs_rxgain/provenance.json create mode 100644 test/fixtures/common_prefs_rxgain/v1.14.0-writer.inc create mode 100644 test/fixtures/common_prefs_rxgain/v1.14.1-writer.inc create mode 100644 test/test_common_prefs_legacy_rxgain.py diff --git a/.github/workflows/run-unit-tests.yml b/.github/workflows/run-unit-tests.yml index 359c01a6b..50d5313ed 100644 --- a/.github/workflows/run-unit-tests.yml +++ b/.github/workflows/run-unit-tests.yml @@ -171,6 +171,7 @@ jobs: python3 -B test/test_common_radio_persistence.py -v python3 -B test/test_common_cli_save_results.py -v python3 -B test/test_common_prefs_commit.py -v + python3 -B test/test_common_prefs_legacy_rxgain.py -v python3 -B test/test_flood_policy_capacity.py -v python3 -B test/test_mqtt_prefs_commit.py -v python3 -B test/test_identity_and_settings_recovery.py -v diff --git a/src/helpers/CommonCLI.cpp b/src/helpers/CommonCLI.cpp index a138df003..314a3fbe7 100644 --- a/src/helpers/CommonCLI.cpp +++ b/src/helpers/CommonCLI.cpp @@ -1071,7 +1071,15 @@ void CommonCLI::loadPrefsInt(FILESYSTEM* fs, const char* filename) { file.read((uint8_t *)&_prefs->tx_power_dbm, sizeof(_prefs->tx_power_dbm)); // 76 file.read((uint8_t *)&_prefs->disable_fwd, sizeof(_prefs->disable_fwd)); // 77 file.read((uint8_t *)&_prefs->advert_interval, sizeof(_prefs->advert_interval)); // 78 - file.read(pad, 1); // 79 : 1 byte unused (was rx_boosted_gain in v1.14.1, moved to end for upgrade compat) + uint8_t legacy_rx_boosted_gain = 0xFF; + file.read(&legacy_rx_boosted_gain, 1); // 79 : rx_boosted_gain in v1.14.1 + // v1.14.1 saved gain here in its 290-byte image. Earlier images of the + // same size wrote zero padding, so zero cannot safely override a board + // default. Only recover an unambiguous enabled value from that layout; + // longer images use their existing appended gain field below. + if (file.size() == 290 && legacy_rx_boosted_gain == 1) { + _prefs->rx_boosted_gain = 1; + } file.read((uint8_t *)&_prefs->rx_delay_base, sizeof(_prefs->rx_delay_base)); // 80 file.read((uint8_t *)&_prefs->tx_delay_factor, sizeof(_prefs->tx_delay_factor)); // 84 file.read((uint8_t *)&_prefs->guest_password[0], sizeof(_prefs->guest_password)); // 88 diff --git a/test/README.md b/test/README.md index 67063759a..763f77b39 100644 --- a/test/README.md +++ b/test/README.md @@ -28,6 +28,7 @@ python3 test/test_nimble_companion.py # real adapter, fixed/random PIN python3 test/test_companion_pairing_display.py # real OLED pairing wake, USB coexistence and button navigation python3 test/test_companion_identity_startup.py # real saved/missing/unreadable identity branch and truthful startup phases python3 test/test_startup_screen.py # early display ordering and cooperative entropy progress +python3 -B test/test_common_prefs_legacy_rxgain.py -v # compact stock gain, appended tails and truncation python3 test/test_companion_settings_persistence_contract.py # Atomic settings and appended Bluetooth fields python3 test/test_webconfig_ui.py # Web controls, reboot handling and generated-page consistency python3 test/test_webconfig_ui_runtime.py # Real Chromium, including independent stealth toggle @@ -62,6 +63,14 @@ With a sandboxed browser that cannot read `/tmp`, set `TMPDIR` to a writable directory visible to that browser before running it. The Bluetooth settings contracts and WebConfig suites also run in the unit-test GitHub workflow. +The common preference gain tests compile the current reader and writer sections +with unmodified, commit-bound stock 1.14.0 and 1.14.1 writer excerpts. They cover +the saved enabled gain in a compact 290-byte image, newer explicit on/off tails, +legacy MQTT gaps, truncation, and a reverted-code failure. Zero at the old offset +is indistinguishable from pre-1.14.1 padding, so the compact-image fallback keeps +the board default for zero or invalid values. These are host tests, not a +physical upgrade test. + ### Linux native Web Serial preflight After the last pyserial query, prepare the explicit radio TTY before a native diff --git a/test/fixtures/common_prefs_rxgain/provenance.json b/test/fixtures/common_prefs_rxgain/provenance.json new file mode 100644 index 000000000..a5d26b47e --- /dev/null +++ b/test/fixtures/common_prefs_rxgain/provenance.json @@ -0,0 +1,17 @@ +{ + "v1.14.0-writer.inc": { + "commit": "9f1a3eafcc04a1bb200e75ba8cd5921cc04ce203", + "excerpt_sha256": "14d7a3b41fba5e433db270d6ac3802435f26fd2440a027bef32229fa3768d3a6", + "path": "src/helpers/CommonCLI.cpp", + "scope": "Unmodified fixed-core serializer body from uint8_t pad[8] through owner_info at170; 290 bytes. No private radio data.", + "source_sha256": "c2b49cce5e9ee8590e33d0bb36d0a52e56e24f1be9ef25894b98f03f5720ffc3", + "tag_object": "fbd968bb7abe4d8ab9697919e72f6788a2bf9708" + }, + "v1.14.1-writer.inc": { + "commit": "467959cc3bfc884e5f3425caac89453a450151b6", + "excerpt_sha256": "0e85a4e0aa9ea1084cee2015450419fa40f6dfa9d7e2c8ce3cdcc99eb68957c1", + "path": "src/helpers/CommonCLI.cpp", + "scope": "Unmodified fixed-core serializer body from uint8_t pad[8] through owner_info at170; 290 bytes. No private radio data.", + "source_sha256": "e70d829b2773570cc655016406600230e4bb22333eedddce1697383d7557d72a" + } +} diff --git a/test/fixtures/common_prefs_rxgain/v1.14.0-writer.inc b/test/fixtures/common_prefs_rxgain/v1.14.0-writer.inc new file mode 100644 index 000000000..2f63ec1f3 --- /dev/null +++ b/test/fixtures/common_prefs_rxgain/v1.14.0-writer.inc @@ -0,0 +1,45 @@ + uint8_t pad[8]; + memset(pad, 0, sizeof(pad)); + + file.write((uint8_t *)&_prefs->airtime_factor, sizeof(_prefs->airtime_factor)); // 0 + file.write((uint8_t *)&_prefs->node_name, sizeof(_prefs->node_name)); // 4 + file.write(pad, 4); // 36 + file.write((uint8_t *)&_prefs->node_lat, sizeof(_prefs->node_lat)); // 40 + file.write((uint8_t *)&_prefs->node_lon, sizeof(_prefs->node_lon)); // 48 + file.write((uint8_t *)&_prefs->password[0], sizeof(_prefs->password)); // 56 + file.write((uint8_t *)&_prefs->freq, sizeof(_prefs->freq)); // 72 + file.write((uint8_t *)&_prefs->tx_power_dbm, sizeof(_prefs->tx_power_dbm)); // 76 + file.write((uint8_t *)&_prefs->disable_fwd, sizeof(_prefs->disable_fwd)); // 77 + file.write((uint8_t *)&_prefs->advert_interval, sizeof(_prefs->advert_interval)); // 78 + file.write((uint8_t *)pad, 1); // 79 was 'unused' + file.write((uint8_t *)&_prefs->rx_delay_base, sizeof(_prefs->rx_delay_base)); // 80 + file.write((uint8_t *)&_prefs->tx_delay_factor, sizeof(_prefs->tx_delay_factor)); // 84 + file.write((uint8_t *)&_prefs->guest_password[0], sizeof(_prefs->guest_password)); // 88 + file.write((uint8_t *)&_prefs->direct_tx_delay_factor, sizeof(_prefs->direct_tx_delay_factor)); // 104 + file.write(pad, 4); // 108 + file.write((uint8_t *)&_prefs->sf, sizeof(_prefs->sf)); // 112 + file.write((uint8_t *)&_prefs->cr, sizeof(_prefs->cr)); // 113 + file.write((uint8_t *)&_prefs->allow_read_only, sizeof(_prefs->allow_read_only)); // 114 + file.write((uint8_t *)&_prefs->multi_acks, sizeof(_prefs->multi_acks)); // 115 + file.write((uint8_t *)&_prefs->bw, sizeof(_prefs->bw)); // 116 + file.write((uint8_t *)&_prefs->agc_reset_interval, sizeof(_prefs->agc_reset_interval)); // 120 + file.write((uint8_t *)&_prefs->path_hash_mode, sizeof(_prefs->path_hash_mode)); // 121 + file.write((uint8_t *)&_prefs->loop_detect, sizeof(_prefs->loop_detect)); // 122 + file.write(pad, 1); // 123 + file.write((uint8_t *)&_prefs->flood_max, sizeof(_prefs->flood_max)); // 124 + file.write((uint8_t *)&_prefs->flood_advert_interval, sizeof(_prefs->flood_advert_interval)); // 125 + file.write((uint8_t *)&_prefs->interference_threshold, sizeof(_prefs->interference_threshold)); // 126 + file.write((uint8_t *)&_prefs->bridge_enabled, sizeof(_prefs->bridge_enabled)); // 127 + file.write((uint8_t *)&_prefs->bridge_delay, sizeof(_prefs->bridge_delay)); // 128 + file.write((uint8_t *)&_prefs->bridge_pkt_src, sizeof(_prefs->bridge_pkt_src)); // 130 + file.write((uint8_t *)&_prefs->bridge_baud, sizeof(_prefs->bridge_baud)); // 131 + file.write((uint8_t *)&_prefs->bridge_channel, sizeof(_prefs->bridge_channel)); // 135 + file.write((uint8_t *)&_prefs->bridge_secret, sizeof(_prefs->bridge_secret)); // 136 + file.write((uint8_t *)&_prefs->powersaving_enabled, sizeof(_prefs->powersaving_enabled)); // 152 + file.write(pad, 3); // 153 + file.write((uint8_t *)&_prefs->gps_enabled, sizeof(_prefs->gps_enabled)); // 156 + file.write((uint8_t *)&_prefs->gps_interval, sizeof(_prefs->gps_interval)); // 157 + file.write((uint8_t *)&_prefs->advert_loc_policy, sizeof(_prefs->advert_loc_policy)); // 161 + file.write((uint8_t *)&_prefs->discovery_mod_timestamp, sizeof(_prefs->discovery_mod_timestamp)); // 162 + file.write((uint8_t *)&_prefs->adc_multiplier, sizeof(_prefs->adc_multiplier)); // 166 + file.write((uint8_t *)_prefs->owner_info, sizeof(_prefs->owner_info)); // 170 diff --git a/test/fixtures/common_prefs_rxgain/v1.14.1-writer.inc b/test/fixtures/common_prefs_rxgain/v1.14.1-writer.inc new file mode 100644 index 000000000..c8c4520fb --- /dev/null +++ b/test/fixtures/common_prefs_rxgain/v1.14.1-writer.inc @@ -0,0 +1,45 @@ + uint8_t pad[8]; + memset(pad, 0, sizeof(pad)); + + file.write((uint8_t *)&_prefs->airtime_factor, sizeof(_prefs->airtime_factor)); // 0 + file.write((uint8_t *)&_prefs->node_name, sizeof(_prefs->node_name)); // 4 + file.write(pad, 4); // 36 + file.write((uint8_t *)&_prefs->node_lat, sizeof(_prefs->node_lat)); // 40 + file.write((uint8_t *)&_prefs->node_lon, sizeof(_prefs->node_lon)); // 48 + file.write((uint8_t *)&_prefs->password[0], sizeof(_prefs->password)); // 56 + file.write((uint8_t *)&_prefs->freq, sizeof(_prefs->freq)); // 72 + file.write((uint8_t *)&_prefs->tx_power_dbm, sizeof(_prefs->tx_power_dbm)); // 76 + file.write((uint8_t *)&_prefs->disable_fwd, sizeof(_prefs->disable_fwd)); // 77 + file.write((uint8_t *)&_prefs->advert_interval, sizeof(_prefs->advert_interval)); // 78 + file.write((uint8_t *)&_prefs->rx_boosted_gain, sizeof(_prefs->rx_boosted_gain)); // 79 + file.write((uint8_t *)&_prefs->rx_delay_base, sizeof(_prefs->rx_delay_base)); // 80 + file.write((uint8_t *)&_prefs->tx_delay_factor, sizeof(_prefs->tx_delay_factor)); // 84 + file.write((uint8_t *)&_prefs->guest_password[0], sizeof(_prefs->guest_password)); // 88 + file.write((uint8_t *)&_prefs->direct_tx_delay_factor, sizeof(_prefs->direct_tx_delay_factor)); // 104 + file.write(pad, 4); // 108 : 4 byte unused + file.write((uint8_t *)&_prefs->sf, sizeof(_prefs->sf)); // 112 + file.write((uint8_t *)&_prefs->cr, sizeof(_prefs->cr)); // 113 + file.write((uint8_t *)&_prefs->allow_read_only, sizeof(_prefs->allow_read_only)); // 114 + file.write((uint8_t *)&_prefs->multi_acks, sizeof(_prefs->multi_acks)); // 115 + file.write((uint8_t *)&_prefs->bw, sizeof(_prefs->bw)); // 116 + file.write((uint8_t *)&_prefs->agc_reset_interval, sizeof(_prefs->agc_reset_interval)); // 120 + file.write((uint8_t *)&_prefs->path_hash_mode, sizeof(_prefs->path_hash_mode)); // 121 + file.write((uint8_t *)&_prefs->loop_detect, sizeof(_prefs->loop_detect)); // 122 + file.write(pad, 1); // 123 + file.write((uint8_t *)&_prefs->flood_max, sizeof(_prefs->flood_max)); // 124 + file.write((uint8_t *)&_prefs->flood_advert_interval, sizeof(_prefs->flood_advert_interval)); // 125 + file.write((uint8_t *)&_prefs->interference_threshold, sizeof(_prefs->interference_threshold)); // 126 + file.write((uint8_t *)&_prefs->bridge_enabled, sizeof(_prefs->bridge_enabled)); // 127 + file.write((uint8_t *)&_prefs->bridge_delay, sizeof(_prefs->bridge_delay)); // 128 + file.write((uint8_t *)&_prefs->bridge_pkt_src, sizeof(_prefs->bridge_pkt_src)); // 130 + file.write((uint8_t *)&_prefs->bridge_baud, sizeof(_prefs->bridge_baud)); // 131 + file.write((uint8_t *)&_prefs->bridge_channel, sizeof(_prefs->bridge_channel)); // 135 + file.write((uint8_t *)&_prefs->bridge_secret, sizeof(_prefs->bridge_secret)); // 136 + file.write((uint8_t *)&_prefs->powersaving_enabled, sizeof(_prefs->powersaving_enabled)); // 152 + file.write(pad, 3); // 153 + file.write((uint8_t *)&_prefs->gps_enabled, sizeof(_prefs->gps_enabled)); // 156 + file.write((uint8_t *)&_prefs->gps_interval, sizeof(_prefs->gps_interval)); // 157 + file.write((uint8_t *)&_prefs->advert_loc_policy, sizeof(_prefs->advert_loc_policy)); // 161 + file.write((uint8_t *)&_prefs->discovery_mod_timestamp, sizeof(_prefs->discovery_mod_timestamp)); // 162 + file.write((uint8_t *)&_prefs->adc_multiplier, sizeof(_prefs->adc_multiplier)); // 166 + file.write((uint8_t *)_prefs->owner_info, sizeof(_prefs->owner_info)); // 170 diff --git a/test/test_common_prefs_legacy_rxgain.py b/test/test_common_prefs_legacy_rxgain.py new file mode 100644 index 000000000..247febb25 --- /dev/null +++ b/test/test_common_prefs_legacy_rxgain.py @@ -0,0 +1,267 @@ +"""Execute current common-prefs reads against genuine compact stock writers.""" +import hashlib +import json +import os +from pathlib import Path +import re +import subprocess +import tempfile +import unittest + +from test_replay_reset_integration import extract_braced + +ROOT = Path(__file__).resolve().parents[1] +FIXTURES = ROOT / "test/fixtures/common_prefs_rxgain" + +HARNESS = r''' +#include +#include +#include +#include +#include +#include +#define MESH_DEBUG_PRINTLN(...) ((void)0) +namespace mesh { void hilStartupTrace(const char*) {} } +template T constrain(T n, int lo, int hi) { + return std::max(T(lo), std::min(n, T(hi))); +} +struct NodePrefs { @FIELDS@ }; +struct File { + std::vector bytes; + size_t cursor = 0, reads = 0; + size_t size() const { return bytes.size(); } + size_t available() const { return bytes.size() - cursor; } + size_t read(uint8_t* out, size_t n) { + ++reads; + n = std::min(n, available()); + if (n) memcpy(out, bytes.data() + cursor, n); + cursor += n; + return n; + } + size_t write(const uint8_t* in, size_t n) { + bytes.insert(bytes.end(), in, in + n); + return n; + } + void close() {} +}; +@CONSTANTS@ +struct CommonCLI { + NodePrefs prefs{}; + NodePrefs* _prefs = &prefs; + bool _com_prefs_needs_upgrade = false; + void load(File& file) { + const char* filename = "/com_prefs"; + (void)filename; + @CORE_READER@ + @GAIN_TAIL@ + @GAIN_CONSTRAINT@ + } + File stock1141() { File file; @STOCK_1141@ return file; } + File stock1140() { File file; @STOCK_1140@ return file; } + File modern() { File file; @MODERN_WRITER@ return file; } +}; +CommonCLI stock(uint8_t gain) { + CommonCLI writer; + writer.prefs.rx_boosted_gain = gain; + writer.prefs.freq = 910.0f; + writer.prefs.bw = 62.5f; + writer.prefs.bridge_baud = 115200; + strcpy(writer.prefs.node_name, "synthetic legacy fixture"); + return writer; +} +void checkLoaded(File image, uint8_t board_default, uint8_t expected) { + CommonCLI reader; + reader.prefs.rx_boosted_gain = board_default; + reader.load(image); + assert(reader.prefs.rx_boosted_gain == expected); + assert(reader.prefs.freq == 910.0f && reader.prefs.bw == 62.5f); + assert(reader.prefs.bridge_baud == 115200); + assert(!strcmp(reader.prefs.node_name, "synthetic legacy fixture")); +} +int main(int argc, char** argv) { + assert(argc == 2); + const std::string scenario = argv[1]; + if (scenario == "stock-on") { + auto image = stock(1).stock1141(); + assert(image.size() == 290 && image.bytes[79] == 1); + checkLoaded(image, 0, 1); // G2's newer default must not discard saved on. + checkLoaded(image, 1, 1); + } else if (scenario == "stock-off-padding") { + auto off = stock(0).stock1141(); + auto padding = stock(1).stock1140(); + assert(off.size() == 290 && off.bytes[79] == 0); + assert(padding.bytes == off.bytes); // No marker distinguishes old padding. + checkLoaded(off, 0, 0); + checkLoaded(off, 1, 1); // Ambiguous zero retains the existing board default. + checkLoaded(padding, 0, 0); + checkLoaded(padding, 1, 1); + } else if (scenario == "malformed-truncated") { + for (uint8_t invalid : {2, 0xff}) { + auto image = stock(invalid).stock1141(); + for (uint8_t board_default : {0, 1}) + checkLoaded(image, board_default, board_default); + } + for (size_t length : {size_t(0), size_t(79), size_t(80), size_t(289)}) { + auto image = stock(1).stock1141(); + image.bytes.resize(length); + for (uint8_t board_default : {0, 1}) { + CommonCLI reader; + reader.prefs.rx_boosted_gain = board_default; + reader.prefs.freq = 123.0f; + reader.load(image); + assert(reader._com_prefs_needs_upgrade && image.reads == 0); + assert(reader.prefs.rx_boosted_gain == board_default); + assert(reader.prefs.freq == 123.0f); + } + } + } else if (scenario == "modern") { + for (uint8_t saved : {0, 1}) { + auto image = stock(saved).modern(); + assert(image.size() == 291 && image.bytes[79] == 0); + assert(image.bytes[290] == saved); + for (size_t length : {size_t(291), size_t(293), size_t(295), size_t(877)}) { + image.bytes.resize(length, 0); + image.bytes[79] = 1 - saved; // The appended field is authoritative. + for (uint8_t board_default : {0, 1}) + checkLoaded(image, board_default, saved); + } + } + } else if (scenario == "legacy-gaps") { + for (size_t gap : {LEGACY_MQTT_GAP_3SLOT, LEGACY_MQTT_GAP_6SLOT}) { + for (size_t tail : {size_t(1), LEGACY_OBS_TAIL_MAX}) { + for (uint8_t saved : {0, 1}) { + auto image = stock(1 - saved).stock1141(); + image.bytes.resize(290 + gap + tail, 0); + image.bytes[290 + gap] = saved; + for (uint8_t board_default : {0, 1}) + checkLoaded(image, board_default, saved); + } + } + } + // Unknown extended layouts must not be mistaken for compact stock gain. + for (size_t extra : {LEGACY_MQTT_GAP_3SLOT + LEGACY_OBS_TAIL_MAX + 1, + LEGACY_MQTT_GAP_6SLOT, + LEGACY_MQTT_GAP_6SLOT + LEGACY_OBS_TAIL_MAX + 1}) { + auto image = stock(1).stock1141(); + image.bytes.resize(290 + extra, 0); + for (uint8_t board_default : {0, 1}) + checkLoaded(image, board_default, board_default); + } + // At the existing normal/gap boundary, byte290 still wins over byte79. + auto normal = stock(1).stock1141(); + normal.bytes.resize(290 + LEGACY_MQTT_GAP_3SLOT, 0); + checkLoaded(normal, 1, 0); + } else if (scenario == "roundtrip") { + auto original = stock(1).stock1141(); + const auto unchanged = original.bytes; + CommonCLI reader; + reader.prefs.rx_boosted_gain = 0; + reader.load(original); + auto rewritten = reader.modern(); + assert(original.bytes == unchanged); // Loading does not mutate the file. + assert(rewritten.bytes[79] == 0 && rewritten.bytes[290] == 1); + checkLoaded(rewritten, 0, 1); + } else { + assert(false); + } +} +''' + + +def harness_source(source): + """Extract actual prefix, branch selection, first tail field, and writer.""" + load = extract_braced(source, "void CommonCLI::loadPrefsInt(") + core = load[load.index(" if (file.size() < 290)"): + load.index(' mesh::hilStartupTrace("prefs_image_core_ready");')] + gain_read = "file.read((uint8_t *)&_prefs->rx_boosted_gain, sizeof(_prefs->rx_boosted_gain));" + tail_start = load.index(" size_t extra = file.available();") + gap_read_end = load.index(gain_read, tail_start) + len(gain_read) + gap = load[tail_start:gap_read_end] + normal = extract_braced(load[gap_read_end:], + "if (file.available() >= (int)sizeof(_prefs->rx_boosted_gain))") + tail = gap + "\n }\n } else {\n" + normal + "\n }\n" + tail = tail.replace("bool has_flood_retry_prefs = false;", "[[maybe_unused]] bool has_flood_retry_prefs = false;") + constraint = re.search(r"^\s*_prefs->rx_boosted_gain = constrain[^\n]+", load, re.M).group() + save = extract_braced(source, "void CommonCLI::savePrefs(FILESYSTEM*") + writer_start = save.index(" uint8_t pad[8];") + gain_write = "file.write((uint8_t *)&_prefs->rx_boosted_gain, sizeof(_prefs->rx_boosted_gain));" + writer = save[writer_start:save.index(gain_write, writer_start) + len(gain_write)] + names = set(re.findall(r"_prefs->(\w+)", core + tail + writer)) + header = (ROOT / "src/helpers/CommonCLI.h").read_text() + declarations = re.findall(r"^\s*(?:float|double|char|u?int(?:8|16|32)_t)\s+[^;]+;", + header.split("class NodePrefs :", 1)[1].split("private:", 1)[0], re.M) + fields = "\n".join(d for d in declarations if any(re.search(r"\b" + n + r"\b", d) for n in names)) + fields = re.sub(r"\s*=\s*[^,;]+", "", fields) + constants = "\n".join(re.findall(r"^static const size_t LEGACY_(?:MQTT_GAP_\w+|OBS_TAIL_MAX)[^\n]+", source, re.M)) + provenance = json.loads((FIXTURES / "provenance.json").read_text()) + values = {"FIELDS": fields, "CORE_READER": core, "GAIN_TAIL": tail, + "GAIN_CONSTRAINT": constraint, "MODERN_WRITER": writer, "CONSTANTS": constants} + for version, marker in (("v1.14.1", "STOCK_1141"), ("v1.14.0", "STOCK_1140")): + filename = version + "-writer.inc" + data = (FIXTURES / filename).read_bytes() + if hashlib.sha256(data).hexdigest() != provenance[filename]["excerpt_sha256"]: + raise ValueError("historical source excerpt changed: " + filename) + values[marker] = data.decode() + result = HARNESS + for marker, value in values.items(): + result = result.replace("@" + marker + "@", value) + return result + + +class CommonPrefsLegacyRxGainTest(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.temp = tempfile.TemporaryDirectory(prefix="common-prefs-legacy-gain-") + cls.addClassCleanup(cls.temp.cleanup) + cls.work = Path(cls.temp.name) + cls.source = (ROOT / "src/helpers/CommonCLI.cpp").read_text() + cls.executable = cls.compile(harness_source(cls.source), "current") + + @classmethod + def compile(cls, code, name): + cpp = cls.work / (name + ".cpp") + executable = cls.work / name + cpp.write_text(code) + flags = [] if os.name == "nt" else ["-fsanitize=address,undefined", + "-fno-sanitize-recover=all", "-fno-pie", "-no-pie"] + built = subprocess.run([os.environ.get("CXX", "g++"), "-std=c++17", "-Wall", "-Wextra", + "-Werror", *flags, str(cpp), "-o", str(executable)], + capture_output=True, text=True, timeout=60) + if built.returncode: + raise RuntimeError(built.stderr) + return executable + + def scenario(self, name): + result = subprocess.run([str(self.executable), name], capture_output=True, text=True, timeout=10) + self.assertEqual(result.returncode, 0, result.stderr) + + def test_genuine_stock_enabled_survives_new_disabled_default(self): + self.scenario("stock-on") + + def test_stock_off_and_older_padding_keep_ambiguous_zero_default(self): + self.scenario("stock-off-padding") + + def test_invalid_byte_and_truncated_core_preserve_defaults(self): + self.scenario("malformed-truncated") + + def test_modern_explicit_gain_wins_including_off(self): + self.scenario("modern") + + def test_known_gap_gain_and_unknown_layout_defaults_remain_authoritative(self): + self.scenario("legacy-gaps") + + def test_next_normal_save_keeps_recovered_gain_without_moving_fields(self): + self.scenario("roundtrip") + + def test_reverting_compact_recovery_breaks_genuine_stock_on(self): + branch = extract_braced(self.source, + "if (file.size() == 290 && legacy_rx_boosted_gain == 1)") + reverted = self.source.replace(branch, "(void)legacy_rx_boosted_gain;", 1) + executable = self.compile(harness_source(reverted), "reverted") + result = subprocess.run([str(executable), "stock-on"], capture_output=True, text=True, timeout=10) + self.assertNotEqual(result.returncode, 0) + self.assertIn("reader.prefs.rx_boosted_gain == expected", result.stderr) + + +if __name__ == "__main__": + unittest.main()