Persist Companion Bluetooth on-off preference across reboots

This commit is contained in:
mikecarper committed 2026-10-03 03:09:20 -07:00
1 parent 8519638367
commit 4ca66c2ebb
11 files changed
+528 -21

No files matched your search

+152 -4
View File
@@ -26,8 +26,8 @@ uint32_t companion_bluetooth_off_at=0;
bool companion_bluetooth_force_off=false;
struct Transport : BaseSerialInterface {
bool enabled=false,connected=false,busy=false,frame=false,enable_fails=false;
unsigned disabled=0;
void enable() override {enabled=!enable_fails;}
unsigned disabled=0,enables=0;
void enable() override {++enables;enabled=!enable_fails;}
void disable() override {enabled=false;connected=false;++disabled;}
bool isEnabled() const override{return enabled;}
bool isConnected() const override{return connected;}
@@ -43,6 +43,13 @@ MultiSerialInterface interface_manager;
bool isUsbTerminalDataConnected(){return usb_open;}
unsigned cancelled=0,logs=0;
struct {
bool bluetooth_preference=true,durable_bluetooth_preference=true,storage_accepts=true;
unsigned saves=0,fail_save_at=0;
bool isBluetoothEnabledPreference() const {return bluetooth_preference;}
bool setBluetoothEnabledPreference(bool enabled){
++saves;if(!storage_accepts||saves==fail_save_at)return false;
bluetooth_preference=durable_bluetooth_preference=enabled;return true;
}
bool isAnyNetworkTerminalMode(){return network_terminal;}
void cancelSerialOperationsForRoute(BaseSerialInterface* route){
assert(route==&bluetooth_interface);++cancelled;
@@ -80,6 +87,7 @@ int main(){
assert(!command("set ble.stealth on"));
assert(command("set bluetooth off")&&strstr(reply,"no other active"));
assert(usb_power&&bluetooth_interface.enabled&&!companion_bluetooth_off_at);
assert(the_mesh.saves==0&&the_mesh.durable_bluetooth_preference);
// A disabled TCP interface and a socket that is merely listening don't count.
wifi_interface.connected=true;wifi_interface.enabled=false;
assert(command("set ble off")&&strstr(reply,"Error:"));
@@ -89,9 +97,11 @@ int main(){
wifi_interface.connected=true;
assert(command("set ble off")&&strstr(reply,"requested"));
assert(command("get ble")&&strstr(reply,"off pending"));
assert(the_mesh.durable_bluetooth_preference); // Requested is not yet committed.
now_ms+=249;serviceCompanionBluetoothControl();assert(bluetooth_interface.enabled);
wifi_interface.connected=false;++now_ms;serviceCompanionBluetoothControl();
assert(bluetooth_interface.enabled&&!companion_bluetooth_off_at&&logs==1);
assert(the_mesh.saves==0&&the_mesh.durable_bluetooth_preference);
// Force may disconnect the sole client, but waits for queued notifications.
assert(command(" set ble\t off\tforce \t")&&strstr(reply,"requested"));
bluetooth_interface.busy=true;now_ms+=250;serviceCompanionBluetoothControl();
@@ -99,11 +109,13 @@ int main(){
now_ms+=1749;serviceCompanionBluetoothControl();assert(bluetooth_interface.enabled);
++now_ms;serviceCompanionBluetoothControl();
assert(!bluetooth_interface.enabled&&cancelled==1);
assert(!the_mesh.durable_bluetooth_preference);
assert(interface_manager.captureReplyRoute()==nullptr);
assert(command("set ble off")&&strstr(reply,"already off"));
assert(command("get ble")&&strcmp(reply,"bluetooth off")==0);
bluetooth_interface.busy=false;
assert(command("set bluetooth on")&&strstr(reply,"OK"));route(bluetooth_interface);
assert(the_mesh.durable_bluetooth_preference);
// Another native CDC session counts; HWCDC/bridge presence alone doesn't.
usb_open=true;usb_serial_interface.connected=true;
assert(command("set ble off"));
@@ -120,9 +132,18 @@ int main(){
usb_mota_mode=false;usb_open=false;
// An actual USB command proves that requester is present on every backend.
route(usb_serial_interface);
assert(command("set ble off")&&strstr(reply,"Bluetooth off (this boot)"));
assert(command("set ble off")&&strstr(reply,"Bluetooth off"));
assert(!bluetooth_interface.enabled&&interface_manager.captureReplyRoute()==&usb_serial_interface);
assert(!the_mesh.durable_bluetooth_preference);
assert(usb_serial_interface.enabled); // Persisting BLE off never disables USB.
const unsigned saved_off_enables=bluetooth_interface.enables;
interface_manager.disable();interface_manager.enable();
assert(!bluetooth_interface.enabled&&bluetooth_interface.enables==saved_off_enables);
assert(usb_serial_interface.enabled);route(usb_serial_interface);
assert(command("set ble on")&&bluetooth_interface.enabled);
assert(the_mesh.durable_bluetooth_preference);
interface_manager.disable();interface_manager.enable();
assert(bluetooth_interface.enabled); // Successful on also restores the aggregate boot policy.
// ASCII terminal commands cannot inherit the previous framed BLE route.
route(bluetooth_interface);
assert(command("set ble off",CompanionBluetoothCommandSource::Terminal));
@@ -137,6 +158,34 @@ int main(){
assert(command("set ble off")&&strstr(reply,"requested"));
now_ms+=250;serviceCompanionBluetoothControl();assert(!bluetooth_interface.enabled);
assert(command("set ble on"));route(bluetooth_interface);ethernet_interface.connected=false;
// Failed delayed saves leave the requesting BLE session alive and cancellable.
assert(command("set ble off force"));
const unsigned delayed_disabled=bluetooth_interface.disabled;
const uint32_t pending_off=companion_bluetooth_off_at;
the_mesh.storage_accepts=false;
assert(command("set ble on")&&strstr(reply,"Error:"));
assert(companion_bluetooth_off_at==pending_off); // Failed reversal does not cancel a prior request.
now_ms+=250;serviceCompanionBluetoothControl();
assert(bluetooth_interface.enabled&&the_mesh.durable_bluetooth_preference);
assert(!companion_bluetooth_off_at&&bluetooth_interface.disabled==delayed_disabled);
the_mesh.storage_accepts=true;
// Failed immediate off saves must not disconnect the USB recovery command.
route(usb_serial_interface);the_mesh.storage_accepts=false;
assert(command("set ble off")&&strstr(reply,"Error:"));
assert(bluetooth_interface.enabled&&the_mesh.durable_bluetooth_preference);
assert(interface_manager.captureReplyRoute()==&usb_serial_interface);
the_mesh.storage_accepts=true;
assert(command("set ble off")&&!bluetooth_interface.enabled);
assert(!the_mesh.durable_bluetooth_preference);
// Failed on saves restore the off runtime state as well as durable preference.
the_mesh.storage_accepts=false;
const unsigned failed_on_enables=bluetooth_interface.enables;
assert(command("set ble on")&&strstr(reply,"Error:"));
assert(!bluetooth_interface.enabled&&!the_mesh.durable_bluetooth_preference);
assert(bluetooth_interface.enables==failed_on_enables); // No transient advertising.
the_mesh.storage_accepts=true;
assert(command("set ble on")&&bluetooth_interface.enabled);
assert(the_mesh.durable_bluetooth_preference);route(bluetooth_interface);
// Pending deadlines work across millis() wrap, including the zero sentinel.
for(uint32_t start : {0xffffff00u,0xffffff06u}){
now_ms=start;assert(command("set ble off force"));
@@ -145,12 +194,28 @@ int main(){
assert(command("set ble on"));route(bluetooth_interface);
}
companion_bluetooth_initialized=false;
bluetooth_interface.enabled=false;
assert(command("get ble")&&strstr(reply,"bluetooth off"));
assert(command("set ble on")&&strstr(reply,"unavailable"));
assert(command("set ble off force")&&strstr(reply,"unavailable"));
assert(command("set ble off force")&&strstr(reply,"already off"));
assert(!the_mesh.durable_bluetooth_preference);
companion_bluetooth_initialized=true;
assert(command("set ble off",CompanionBluetoothCommandSource::Terminal));
bluetooth_interface.enable_fails=true;
assert(command("set ble on")&&strstr(reply,"enable failed"));
assert(!the_mesh.durable_bluetooth_preference&&!bluetooth_interface.enabled);
assert(command("get ble")&&strcmp(reply,"bluetooth off")==0);
bluetooth_interface.enable_fails=false;
interface_manager.disable();interface_manager.enable();
assert(!bluetooth_interface.enabled&&usb_serial_interface.enabled); // Policy rollback matches saved off.
// If both enable and its rollback save fail, report the durable on choice honestly.
bluetooth_interface.enable_fails=true;the_mesh.fail_save_at=the_mesh.saves+2;
assert(command("set ble on")&&strstr(reply,"rollback save failed"));
assert(the_mesh.durable_bluetooth_preference&&!bluetooth_interface.enabled);
assert(command("get ble")&&strcmp(reply,"bluetooth off")==0); // Status remains the live state.
the_mesh.fail_save_at=0;bluetooth_interface.enable_fails=false;
interface_manager.disable();interface_manager.enable();
assert(bluetooth_interface.enabled); // Aggregate policy remains consistent with the durable on value.
#else
assert(command("get ble")&&strstr(reply,"not supported"));
assert(command("set ble off force")&&strstr(reply,"not supported"));
@@ -200,6 +265,89 @@ class BluetoothControlTests(unittest.TestCase):
ran = subprocess.run([str(binary)],capture_output=True,text=True)
self.assertEqual(ran.returncode,0,ran.stderr)
def test_saved_off_policy_keeps_usb_recovery_and_explicit_runtime_on(self):
# Execute the actual multi-transport manager. A saved-off boot must
# not briefly advertise when the aggregate interface is enabled.
source_text = HARNESS.split('@METHODS@')[0] + r'''
int main(){
interface_manager.addInterface(InterfaceType::Bluetooth,&bluetooth_interface);
interface_manager.addInterface(InterfaceType::USB,&usb_serial_interface);
interface_manager.addInterface(InterfaceType::WiFi,&wifi_interface);
interface_manager.addInterface(InterfaceType::Ethernet,&ethernet_interface);
interface_manager.setBluetoothAutoEnable(false);
interface_manager.enable();
assert(!bluetooth_interface.enabled&&bluetooth_interface.enables==0);
assert(usb_serial_interface.enabled&&wifi_interface.enabled&&ethernet_interface.enabled);
interface_manager.disable();interface_manager.enable();
assert(!bluetooth_interface.enabled&&bluetooth_interface.enables==0);
// USB can explicitly enable an already-initialized stack while saved off.
interface_manager.enableBluetooth();assert(bluetooth_interface.enabled);
assert(bluetooth_interface.enables==1);
interface_manager.disable();interface_manager.enable();
assert(!bluetooth_interface.enabled&&bluetooth_interface.enables==1);
interface_manager.setBluetoothAutoEnable(true);
interface_manager.disable();interface_manager.enable();
assert(bluetooth_interface.enabled&&bluetooth_interface.enables==2);
// The legacy default remains automatic on.
MultiSerialInterface legacy;Transport ble;
legacy.addInterface(InterfaceType::Bluetooth,&ble);legacy.enable();
assert(ble.enabled&&ble.enables==1);
}
'''
with tempfile.TemporaryDirectory() as directory:
folder = Path(directory)
(folder/'Arduino.h').write_text('#pragma once\n#include <cstdint>\n#include <cstddef>\n')
source = folder/'startup_policy.cpp'
source.write_text(source_text)
binary = folder/'startup_policy'
built = subprocess.run([os.environ.get('CXX','g++'), '-std=c++17',
'-I',str(folder),'-I',str(ROOT),'-I',str(ROOT/'src'),
str(source),'-o',str(binary)],capture_output=True,text=True)
self.assertEqual(built.returncode,0,built.stderr)
ran = subprocess.run([str(binary)],capture_output=True,text=True)
self.assertEqual(ran.returncode,0,ran.stderr)
def test_wireless_restore_does_not_change_the_saved_bluetooth_choice(self):
adapter = method(MAIN, 'class CompanionWirelessBackend')+';\n'
source_text = HARNESS.split('@METHODS@')[0] + '\n' + method(
MAIN, 'static void disableCompanionBluetoothForCli(') + '\n' + adapter + r'''
int main(){
using namespace mesh::wireless;
interface_manager.addInterface(InterfaceType::Bluetooth,&bluetooth_interface);
interface_manager.addInterface(InterfaceType::USB,&usb_serial_interface);
the_mesh.bluetooth_preference=the_mesh.durable_bluetooth_preference=false;
interface_manager.setBluetoothAutoEnable(false);interface_manager.enable();
CompanionWirelessBackend backend;control().begin(backend);
assert(backend.available()==Bluetooth&&!bluetooth_interface.enabled);
char reply[160];
control().handle("set 2.4ghz off",reply,sizeof(reply),now_ms,Independent);
now_ms+=250;control().service(now_ms);
control().handle("set 2.4ghz on",reply,sizeof(reply),now_ms,Independent);
now_ms+=250;control().service(now_ms);
assert(!bluetooth_interface.enabled&&bluetooth_interface.enables==0);
assert(!the_mesh.durable_bluetooth_preference&&the_mesh.saves==0);
// Explicit all is a runtime-only override; the saved-off boot policy remains.
control().handle("set 2.4ghz on all",reply,sizeof(reply),now_ms,Independent);
now_ms+=250;control().service(now_ms);
assert(bluetooth_interface.enabled&&!the_mesh.durable_bluetooth_preference);
assert(the_mesh.saves==0);
interface_manager.disable();interface_manager.enable();
assert(!bluetooth_interface.enabled&&usb_serial_interface.enabled);
}
'''
with tempfile.TemporaryDirectory() as directory:
folder = Path(directory)
(folder/'Arduino.h').write_text('#pragma once\n#include <cstdint>\n#include <cstddef>\n')
source = folder/'wireless_policy.cpp'
source.write_text(source_text)
binary = folder/'wireless_policy'
built = subprocess.run([os.environ.get('CXX','g++'), '-std=c++17',
'-DBLE_PIN_CODE=123456','-I',str(folder),'-I',str(ROOT),'-I',str(ROOT/'src'),
str(source),'-o',str(binary)],capture_output=True,text=True)
self.assertEqual(built.returncode,0,built.stderr)
ran = subprocess.run([str(binary)],capture_output=True,text=True)
self.assertEqual(ran.returncode,0,ran.stderr)
def test_cli_entry_points_pass_the_current_source(self):
mesh = (ROOT/'examples/companion_radio/MyMesh.cpp').read_text()
terminal = method(mesh,'void MyMesh::handleTerminalCommand(')
@@ -0,0 +1,273 @@
"""Execute persistent Bluetooth preferences, storage faults, and boot gates."""
from pathlib import Path
import os
import subprocess
import tempfile
import unittest
from test_companion_preferences_transaction import HARNESS as STORE_HARNESS
from test_companion_preferences_transaction import esp_recovery_helpers
from test_radio_receive_contract import method
ROOT = Path(__file__).resolve().parents[1]
PREFERENCE_HARNESS = r'''
struct MyMesh {
CompanionNodePrefs _prefs;
DataStore store;
unsigned saves=0;
bool savePrefs(){++saves;return store.savePrefs(_prefs,47.1,-122.2);}
@SAVE_PREFERENCE@
bool setBluetoothEnabledPreference(bool);
bool isBluetoothEnabledPreference() const;
};
@PREFERENCE_METHODS@
int main(){
MyMesh mesh;
assert(mesh.isBluetoothEnabledPreference()); // New devices retain legacy-on behavior.
mesh._prefs.wifi_enabled=0;mesh._prefs.usb_logging_enabled=1;
strcpy(mesh._prefs.node_name,"durable node");mesh._prefs.freq=910.525f;
mesh._prefs.ble_pin=876543;mesh._prefs.bluetooth_stealth_mode=2;
mesh._prefs.one_key_dm_enabled=1;
assert(mesh.savePrefs());
const auto on_disk=mesh.store.fs.files["/new_prefs"];
#if defined(TBEAM_1W)
assert(on_disk.size()==239);
#elif defined(RP2040_PLATFORM) && defined(ENABLE_WIFI_INTERFACE)
assert(on_disk.size()==329);
#else
assert(on_disk.size()==232);
#endif
assert(on_disk.back()==1);
// Both choices survive a fresh instance reading the actual on-device image.
for(bool enabled : {false,true,false}){
assert(mesh.setBluetoothEnabledPreference(enabled));
DataStore reboot;reboot.fs=mesh.store.fs;
CompanionNodePrefs prefs;prefs.bluetooth_enabled=!enabled;
double lat=0,lon=0;assert(reboot.loadPrefs(prefs,lat,lon));
assert(prefs.bluetooth_enabled==enabled&&lat==47.1&&lon==-122.2);
assert(prefs.ble_pin==876543&&prefs.freq==910.525f);
assert(prefs.bluetooth_stealth_mode==2&&prefs.one_key_dm_enabled==1);
assert(prefs.wifi_enabled==0&&prefs.usb_logging_enabled==1);
assert(reboot.fs.files["/new_prefs"].back()==enabled);
}
const auto off_disk=mesh.store.fs.files["/new_prefs"];
// The public setter must roll live state back when the atomic save fails.
mesh.store.fs.fail_write_after=17;
assert(!mesh.setBluetoothEnabledPreference(true));
assert(!mesh.isBluetoothEnabledPreference());
assert(mesh.store.fs.files["/new_prefs"]==off_disk);
mesh.store.fs.fail_write_after=-1;
mesh.store.fs.fail_rename=1;
assert(!mesh.setBluetoothEnabledPreference(true));
assert(!mesh.isBluetoothEnabledPreference());
assert(mesh.store.fs.files["/new_prefs"]==off_disk);
mesh.store.fs.fail_rename=0;
assert(mesh.setBluetoothEnabledPreference(true));
mesh.store.fs.fail_write=true;
assert(!mesh.setBluetoothEnabledPreference(false));
assert(mesh.isBluetoothEnabledPreference());
mesh.store.fs.fail_write=false;
// Legacy images cannot accidentally inherit an off value from the caller.
for(unsigned size : {84u,156u,215u,226u,unsigned(on_disk.size()-1)}){
DataStore legacy;legacy.fs.files["/new_prefs"]=on_disk;
legacy.fs.files["/new_prefs"].resize(size);
CompanionNodePrefs prefs;prefs.bluetooth_enabled=0;
double lat=0,lon=0;assert(legacy.loadPrefs(prefs,lat,lon));
assert(prefs.bluetooth_enabled==1&&prefs.ble_pin==876543);
assert(legacy.fs.files["/new_prefs"].size()==size); // Read-only migration.
}
// Invalid new encoding rejects the transaction rather than partially loading.
for(uint8_t corrupt : {2,255}){
DataStore damaged;damaged.fs.files["/new_prefs"]=off_disk;
damaged.fs.files["/new_prefs"].back()=corrupt;
CompanionNodePrefs prefs;prefs.bluetooth_enabled=1;
strcpy(prefs.node_name,"unchanged");double lat=1,lon=2;
assert(!damaged.loadPrefsInt("/new_prefs",prefs,lat,lon));
assert(prefs.bluetooth_enabled==1&&!strcmp(prefs.node_name,"unchanged"));
assert(lat==1&&lon==2);
}
}
'''
STARTUP_HARNESS = r'''
#include <cassert>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <initializer_list>
#include <helpers/MultiSerialInterface.h>
#include <helpers/BluetoothMac.h>
#include "examples/companion_radio/BluetoothName.h"
#define BLE_NAME_PREFIX "MC-"
uint32_t now_ms=100;
uint32_t millis(){return now_ms;}
bool companion_bluetooth_initialized=false;
char companion_bluetooth_start_failure[96]={};
uint32_t companion_bluetooth_start_at=0;
constexpr uint32_t COMPANION_BLUETOOTH_RETRY_MS=5000;
uint8_t companion_bluetooth_session_stealth_mode=mesh::companion::BLUETOOTH_STEALTH_OFF;
struct CompanionNodePrefs {
char bluetooth_name[64]={},node_name[32]="durable node";
uint8_t bluetooth_stealth_peer_type=0,bluetooth_stealth_peer[6]={};
};
struct {
CompanionNodePrefs prefs;
bool preference=true;
CompanionNodePrefs* getNodePrefs(){return &prefs;}
bool isBluetoothEnabledPreference() const {return preference;}
uint32_t getBLEPin(){return 876543;}
} the_mesh;
namespace mesh {
struct Logger {void println(const char*){}};
Logger& usbLoggingPort(){static Logger logger;return logger;}
}
struct Transport : BaseSerialInterface {
bool enabled=false,begin_succeeds=true;
unsigned enables=0,begins=0;
template<class... T> bool begin(T...){++begins;return begin_succeeds;}
const char* beginFailure(){return "fixture startup failure";}
void enable() override{enabled=true;++enables;}
void disable() override{enabled=false;}
bool isEnabled() const override{return enabled;}
bool isConnected() const override{return false;}
bool isReadBusy() const override{return false;}
bool isWriteBusy() const override{return false;}
size_t writeFrame(const uint8_t*,size_t n) override{return n;}
size_t checkRecvFrame(uint8_t*) override{return 0;}
} bluetooth_interface,usb_serial_interface;
MultiSerialInterface interface_manager;
bool identity_accepts=true;
unsigned identity_preparations=0;
bool prepareCompanionBluetoothIdentity(CompanionNodePrefs*){
++identity_preparations;return identity_accepts;
}
const uint8_t* companionBluetoothAddress(const CompanionNodePrefs*,bool&){return nullptr;}
@METHODS@
void fresh(bool preference){
interface_manager=MultiSerialInterface();bluetooth_interface=Transport();
usb_serial_interface=Transport();companion_bluetooth_initialized=false;
companion_bluetooth_start_at=0;identity_accepts=true;identity_preparations=0;
the_mesh.preference=preference;
interface_manager.setBluetoothAutoEnable(preference);
assert(interface_manager.addInterface(InterfaceType::USB,&usb_serial_interface));
}
int main(){
// Both immediate and deferred stack registration must honor saved-off
// advertising while preserving an initialized stack for USB recovery.
for(bool manager_started : {false,true}){
fresh(false);
if(manager_started)interface_manager.enable();
startCompanionBluetooth();
assert(companion_bluetooth_initialized&&bluetooth_interface.begins==1);
assert(!bluetooth_interface.enabled&&bluetooth_interface.enables==0);
if(!manager_started)interface_manager.enable();
assert(usb_serial_interface.enabled&&!bluetooth_interface.enabled);
startCompanionBluetooth();serviceDeferredCompanionBluetooth();
assert(bluetooth_interface.begins==1&&bluetooth_interface.enables==0);
interface_manager.enableBluetooth();
assert(bluetooth_interface.enabled&&bluetooth_interface.begins==1);
}
// A scheduled identity/start retry may initialize, never enable a saved-off
// transport when the preference was changed before the retry became due.
fresh(true);interface_manager.enable();identity_accepts=false;
startCompanionBluetooth();assert(companion_bluetooth_start_at!=0);
assert(!companion_bluetooth_initialized&&bluetooth_interface.begins==0);
the_mesh.preference=false;interface_manager.setBluetoothAutoEnable(false);
identity_accepts=true;now_ms+=COMPANION_BLUETOOTH_RETRY_MS;
serviceDeferredCompanionBluetooth();
assert(companion_bluetooth_initialized&&bluetooth_interface.begins==1);
assert(bluetooth_interface.enables==0&&!bluetooth_interface.enabled&&usb_serial_interface.enabled);
// Existing on/default preference still starts normally in either order.
fresh(true);startCompanionBluetooth();interface_manager.enable();
assert(bluetooth_interface.enabled&&bluetooth_interface.enables==1);
fresh(true);interface_manager.enable();startCompanionBluetooth();
assert(bluetooth_interface.enabled&&bluetooth_interface.enables==1);
}
'''
class BluetoothPersistenceTests(unittest.TestCase):
def test_actual_startup_and_deferred_retry_do_not_advertise_saved_off(self):
main = (ROOT/'examples/companion_radio/main.cpp').read_text()
methods = '\n'.join(method(main, signature) for signature in (
'static void scheduleCompanionBluetoothRetry(',
'static void startCompanionBluetooth(',
'static void serviceDeferredCompanionBluetooth('))
with tempfile.TemporaryDirectory() as directory:
work = Path(directory)
(work/'Arduino.h').write_text('#pragma once\n#include <cstdint>\n#include <cstddef>\n')
source = work/'startup.cpp'
source.write_text(STARTUP_HARNESS.replace('@METHODS@', methods))
for platform in ('NRF52_PLATFORM', 'ESP32'):
with self.subTest(platform=platform):
binary = work/'startup'
built = subprocess.run([os.environ.get('CXX','g++'), '-std=c++17',
'-DBLE_PIN_CODE=123456','-D'+platform+'=1',
'-I',str(work),'-I',str(ROOT/'src'),'-I',str(ROOT),
str(source),'-o',str(binary)],capture_output=True,text=True)
self.assertEqual(built.returncode,0,built.stdout+built.stderr)
ran = subprocess.run([str(binary)],capture_output=True,text=True)
self.assertEqual(ran.returncode,0,ran.stdout+ran.stderr)
def test_boot_policy_is_applied_before_any_interface_can_start(self):
main = (ROOT/'examples/companion_radio/main.cpp').read_text()
setup = method(main, '\nvoid setup()')
policy = setup.index('interface_manager.setBluetoothAutoEnable(')
self.assertLess(policy, setup.index('startCompanionBluetooth();'))
self.assertLess(policy, setup.index('the_mesh.startInterface('))
def test_actual_preference_roundtrips_and_atomic_failure_rollback(self):
store = (ROOT/'examples/companion_radio/DataStore.cpp').read_text()
mesh = (ROOT/'examples/companion_radio/MyMesh.cpp').read_text()
header = (ROOT/'examples/companion_radio/MyMesh.h').read_text()
methods = esp_recovery_helpers(store) + '\n'.join(method(store, signature) for signature in (
'bool DataStore::loadPrefs(', 'bool DataStore::loadPrefsInt(',
'bool DataStore::savePrefs('))
prefix = STORE_HARNESS.split('int main(')[0].replace('@METHODS@', methods)
harness = PREFERENCE_HARNESS.replace('@SAVE_PREFERENCE@', method(
header, 'template <typename T> bool savePreference('))
harness = harness.replace('@PREFERENCE_METHODS@', '\n'.join(method(mesh, signature)
for signature in ('bool MyMesh::setBluetoothEnabledPreference(',
'bool MyMesh::isBluetoothEnabledPreference(')))
with tempfile.TemporaryDirectory() as directory:
work = Path(directory)
(work/'Utils.h').write_text('''#pragma once
#include <Arduino.h>
#include <cassert>
namespace mesh { struct Utils {
static void printHex(Stream&,const uint8_t*,size_t){assert(false);}
static void fromHex(uint8_t*,size_t,const char*){assert(false);}
}; }
''')
(work/'platform_shim.h').write_text('''#include <cstdlib>
#include <cstdio>
inline char* utoa(unsigned int value,char* output,int base){
if(base!=10)abort();sprintf(output,"%u",value);return output;
}
''')
transaction = (ROOT/'src/helpers/ContactFileTransaction.h').read_text()
(work/'ContactFileTransaction.h').write_text(transaction.replace(
'#include "IdentityStore.h"', '#include <helpers/IdentityStore.h>'))
source = work/'preferences.cpp'
source.write_text(prefix+harness)
for flags in ('NRF52_PLATFORM', 'ESP32_PLATFORM', 'RP2040_PLATFORM',
'ESP32_PLATFORM,TBEAM_1W', 'RP2040_PLATFORM,ENABLE_WIFI_INTERFACE'):
with self.subTest(platform=flags):
binary = work/'preferences'
built = subprocess.run([os.environ.get('CXX','g++'), '-std=c++17',
*['-D'+flag+'=1' for flag in flags.split(',')],
'-include',str(work/'platform_shim.h'),
'-I',str(work),'-I',str(ROOT/'test/fixtures/radio_profiles/mocks'),
'-I',str(ROOT/'test/mocks'),'-I',str(ROOT/'src'),
'-I',str(ROOT/'src/helpers'),'-I',str(ROOT), str(source),
*[str(ROOT/'src/helpers'/name) for name in ('ConfigSerializer.cpp',
'DynamicConfigSerializer.cpp','CommonRadioPrefs.cpp','TxtDataHelpers.cpp')],
'-o',str(binary)],capture_output=True,text=True)
self.assertEqual(built.returncode,0,built.stdout+built.stderr)
ran = subprocess.run([str(binary)],capture_output=True,text=True)
self.assertEqual(ran.returncode,0,ran.stdout+ran.stderr)
if __name__ == '__main__':
unittest.main()
@@ -194,7 +194,7 @@ int main(int argc,char** argv){
} else if(scenario==7){
// Pre-consent image: all earlier settings survive with default-off consent.
DataStore legacy;legacy.fs.files["/new_prefs"]=disk;
legacy.fs.files["/new_prefs"].resize(disk.size()-1);
legacy.fs.files["/new_prefs"].resize(disk.size()-2);
CompanionNodePrefs loaded;double lat=0,lon=0;
assert(legacy.loadPrefs(loaded,lat,lon));
assert(loaded.flood_retry_advert_enabled==0);