test: cover LED settings and Bluetooth sleep transition ordering

This commit is contained in:
mikecarper committed 2026-10-20 12:04:48 -07:00
1 parent 6f42d56008
commit b125806833
3 files changed
+150 -9

No files matched your search

+18 -1
View File
@@ -98,6 +98,9 @@ int main() {
DataStore image_store;
assert(image_store.savePrefs(saved, 47.125, -122.25));
auto image = image_store.fs.files["/new_prefs"];
#if defined(WIO_E5_MINI_HEADLESS_COMPANION_UI)
assert(image[79] == saved.leds_quiet);
#endif
// The frozen reference remains authoritative only for the historical
// prefix. Checked new-footer behavior has dedicated persistence tests.
image.resize(image.size()-mesh::companion::traffic::FooterSize);
@@ -158,6 +161,9 @@ int main() {
}
if(got)legacy.tx_media=legacy.tx_ssh=mesh::RADIO_TX_AUTO;
equalValues(actual, legacy);
#if defined(WIO_E5_MINI_HEADLESS_COMPANION_UI)
if (got) assert(actual.leds_quiet == disk[79]);
#endif
assert(!memcmp(&lat, &legacy_lat, sizeof(lat)));
assert(!memcmp(&lon, &legacy_lon, sizeof(lon)));
assert(actual_store.fs.files["/new_prefs"] == disk);
@@ -187,6 +193,15 @@ class CompanionPrefsValuesTests(unittest.TestCase):
# is the authority for all old/torn images and read failure traces.
legacy = (ROOT / 'test/fixtures/companion_prefs_storage/legacy_loader.inc').read_text()
self.assertNotIn('copyPersistedValuesFrom', legacy)
# The headless Mini assigns the existing reserved byte at 79 to LED
# policy. Keep the independent scalar read and every failure boundary;
# only this target stores its value instead of discarding it as padding.
reserved_byte = ' readField(pad, 1);'
self.assertEqual(legacy.count(reserved_byte), 1)
legacy = legacy.replace(reserved_byte,
'#if defined(WIO_E5_MINI_HEADLESS_COMPANION_UI)\n'
' readField(&loaded_prefs.leds_quiet, 1);\n'
'#else\n' + reserved_byte + '\n#endif')
# Keep the frozen scalar prefix independent of the new GNU table.
# The RAK-only checked tail was published later; add it explicitly
# to this test-local reference without rewriting the frozen fixture.
@@ -227,6 +242,7 @@ class CompanionPrefsValuesTests(unittest.TestCase):
'wifi_ssid': 'defined(RP2040_PLATFORM) && defined(ENABLE_WIFI_INTERFACE)',
'wifi_pwd': 'defined(RP2040_PLATFORM) && defined(ENABLE_WIFI_INTERFACE)',
'peripherals_shared': 'RAK_4631',
'leds_quiet': 'WIO_E5_MINI_HEADLESS_COMPANION_UI',
}
def fields(template):
@@ -281,7 +297,8 @@ inline char* utoa(unsigned int value,char* output,int base){
(work / 'helpers/IdentityStore.h').write_text(fs)
cpp = work / 'test.cpp'
cpp.write_text(code + tests)
for platform in ('STM32_PLATFORM', 'NRF52_PLATFORM', 'NRF52_PLATFORM,RAK_4631', 'ESP32_PLATFORM', 'RP2040_PLATFORM',
for platform in ('STM32_PLATFORM', 'STM32_PLATFORM,WIO_E5_MINI_HEADLESS_COMPANION_UI',
'NRF52_PLATFORM', 'NRF52_PLATFORM,RAK_4631', 'ESP32_PLATFORM', 'RP2040_PLATFORM',
'ESP32_PLATFORM,TBEAM_1W', 'RP2040_PLATFORM,ENABLE_WIFI_INTERFACE'):
with self.subTest(platform=platform):
binary = work / 'test'
+74 -6
View File
@@ -272,15 +272,83 @@ int main() {
self.execute(code)
def test_every_application_bluefruit_attempt_invalidates_before_call(self):
for filename, call in (
("src/helpers/NRF52Board.cpp", "if (!Bluefruit.begin(1, 0))"),
("src/helpers/nrf52/SerialBLEInterface.cpp", "if (!Bluefruit.begin())"),
for filename, signature, call in (
("src/helpers/NRF52Board.cpp", "bool NRF52Board::startOTAUpdate(",
"if (!Bluefruit.begin(1, 0))"),
("src/helpers/nrf52/SerialBLEInterface.cpp", "bool SerialBLEInterface::begin(",
"if (!Bluefruit.begin())"),
):
with self.subTest(filename=filename):
source = (ROOT / filename).read_text(encoding="ascii")
at = source.index(call)
self.assertTrue(source[:at].rstrip().endswith(
"mesh_nrf52::sleepCycleState().invalidate();"))
startup = extract_braced(source, signature)
self.assertEqual(startup.count(call), 1)
at = startup.index(call)
prelude = startup[startup.index("Bluefruit.configPrphConn("):at]
invalidate = "mesh_nrf52::sleepCycleState().invalidate();"
without_invalidation = prelude.replace(invalidate, "")
# Execute the real configuration/startup prelude, allowing LED
# setup between invalidation and begin. Observe the cache at
# begin itself, including when startup partially enables SD
# and then returns failure.
variants = (
(prelude, "", True),
(without_invalidation, "", False),
(without_invalidation, invalidate, False),
(prelude + "\nauto fresh = mesh_nrf52::sleepCycleState().begin();\n"
"mesh_nrf52::sleepCycleState().publish(fresh, false, 42);", "", False),
)
attempts = []
for index, (before, after, expected) in enumerate(variants):
attempts.append("static bool attempt_%d() {\n%s\n"
"const bool started = %s;\n%s\nreturn started;\n}" %
(index, before, call[len("if (!"):-1], after))
cases = ",\n".join("{attempt_%d, %s}" % (index, str(expected).lower())
for index, (_, _, expected) in enumerate(variants))
self.execute(r'''
#include <cassert>
#include <initializer_list>
#include <helpers/nrf52/SleepCycleState.h>
constexpr int BLE_GATT_ATT_MTU_DEFAULT = 23, BLE_GAP_EVENT_LENGTH_MIN = 3;
constexpr int COMPANION_BLE_PRPH_MTU = 247, COMPANION_BLE_PRPH_EVENT_LENGTH = 100;
constexpr int COMPANION_BLE_PRPH_HVN_QUEUE = 3, COMPANION_BLE_PRPH_WRCMD_QUEUE = 1;
static bool begin_succeeds, actual_sd, invalidated_at_begin;
static uint32_t before_start;
struct BluefruitStub {
unsigned starts = 0;
void configPrphConn(int, int, int, int) {}
template<class... Args> bool begin(Args...) {
++starts;
auto& state = mesh_nrf52::sleepCycleState();
mesh_nrf52::SleepCycleSnapshot snapshot;
invalidated_at_begin = !state.current(before_start) && !state.snapshot(snapshot);
actual_sd = true; // A failed begin can still partially enable SoftDevice.
return begin_succeeds;
}
} Bluefruit;
namespace mesh_nrf52 { void applyBluetoothLedPolicy() {} }
@ATTEMPTS@
int main() {
struct Case { bool (*attempt)(); bool invalidates_before_begin; };
const Case cases[] = {@CASES@};
for (const auto& test : cases) {
for (bool succeeds : {false, true}) {
auto& state = mesh_nrf52::sleepCycleState();
before_start = state.begin();
assert(state.publish(before_start, false, 42));
mesh_nrf52::SleepCycleSnapshot snapshot;
assert(state.snapshot(snapshot) && !snapshot.softdevice_enabled);
begin_succeeds = succeeds; actual_sd = false;
const auto starts = Bluefruit.starts;
assert(test.attempt() == succeeds);
assert(Bluefruit.starts == starts + 1 && actual_sd);
assert(invalidated_at_begin == test.invalidates_before_begin);
if (test.invalidates_before_begin) {
assert(!state.current(before_start) && !state.snapshot(snapshot));
}
}
}
}
'''.replace("@ATTEMPTS@", "\n".join(attempts)).replace("@CASES@", cases))
board = (ROOT / "src/helpers/NRF52Board.cpp").read_text(encoding="ascii")
late = extract_braced(board, "void NRF52Board::sleep(uint32_t secs)")
self.assertNotIn("softdeviceIsEnabled", late)
+58 -2
View File
@@ -126,16 +126,72 @@ class Nrf52SleepEventTests(unittest.TestCase):
def test_enabled_crypto_owner_and_other_pending_irqs_are_preserved(self):
self.run_case("irq_owner")
def test_all_sleeping_roles_prepare_before_any_work_or_policy_check(self):
entry = "\nvoid loop() {\n#if defined(NRF52_PLATFORM)\n board.prepareSleepCycle();\n#endif\n"
def test_all_sleeping_roles_prepare_after_transitions_before_work(self):
preparation = "#if defined(NRF52_PLATFORM)\n board.prepareSleepCycle();\n#endif\n"
priority = ("#if defined(BLE_PIN_CODE)\n"
" serviceCompanionUsbBluetoothPriority();\n#endif\n")
for role in ("simple_repeater", "simple_room_server", "simple_sensor",
"companion_radio"):
with self.subTest(role=role):
source = (ROOT / "examples" / role / "main.cpp").read_text(encoding="ascii")
actual = body(source, "\nvoid loop() {")
# Companion's transport transition may resume/start BLE and
# invalidate the prior cache. Query SDK state after it, with
# no other loop work before this single preparation.
entry = "\nvoid loop() {\n" + (priority if role == "companion_radio" else "") + preparation
self.assertTrue(actual.startswith(entry))
self.assertEqual(actual.count("board.prepareSleepCycle();"), 1)
def test_companion_transition_precedes_the_authoritative_sdk_snapshot(self):
source = (ROOT / "examples/companion_radio/main.cpp").read_text(encoding="ascii")
actual = body(source, "\nvoid loop() {")
end = actual.index("#endif\n", actual.index("board.prepareSleepCycle();")) + len("#endif\n")
entry = actual[:end].replace("void loop()", "static void companionLoopEntry()", 1) + "}\n"
harness = r'''
#define BLE_PIN_CODE 1
#define NRF52_PLATFORM 1
static NRF52Board board;
static bool next_softdevice;
static unsigned priority_calls = 0, queries_before_entry;
static void serviceCompanionUsbBluetoothPriority() {
++priority_calls;
assert(state_queries == queries_before_entry);
mesh_nrf52::sleepCycleState().invalidate();
softdevice_enabled = next_softdevice;
}
@ENTRY@
int main(int argc, char** argv) {
assert(argc == 2);
next_softdevice = !std::strcmp(argv[1], "enabled");
softdevice_enabled = !next_softdevice;
board.prepareSleepCycle(); // A cached snapshot from before the transition.
queries_before_entry = state_queries;
companionLoopEntry();
assert(priority_calls == 1 && state_queries == queries_before_entry + 1);
mesh_nrf52::SleepCycleSnapshot snapshot;
assert(mesh_nrf52::sleepCycleState().snapshot(snapshot));
assert(snapshot.softdevice_enabled == next_softdevice);
const unsigned before_sleep = state_queries;
board.sleep(0);
assert(state_queries == before_sleep && real_sleeps == 1);
}
'''
# Keep the production cache, board preparation and sleep methods; only
# model the transport transition's invalidation/SoftDevice effects.
fixture = self.cycle_source.replace("int main(", "void fixtureMain(", 1)
good = self.compile_cycle("companion-entry", fixture + harness.replace("@ENTRY@", entry))
late_entry = entry.replace(" serviceCompanionUsbBluetoothPriority();\n", "", 1).replace(
" board.prepareSleepCycle();\n",
" board.prepareSleepCycle();\n serviceCompanionUsbBluetoothPriority();\n", 1)
late = self.compile_cycle("companion-late-transition", fixture + harness.replace("@ENTRY@", late_entry))
for mode in ("enabled", "disabled"):
with self.subTest(mode=mode):
result = subprocess.run([str(good), mode], capture_output=True, text=True)
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
result = subprocess.run([str(late), mode], capture_output=True, text=True)
self.assertNotEqual(result.returncode, 0)
self.assertIn("Assertion", result.stderr)
def test_actual_cache_single_attempt_stale_publication_errors_and_recovery(self):
self.run_cycle_case("cache")