348 lines
19 KiB
Python
348 lines
19 KiB
Python
"""Exercise raw radio2 host KISS isolation and concrete modem protocol selection."""
|
|
from pathlib import Path
|
|
import os
|
|
import shutil
|
|
import subprocess
|
|
import tempfile
|
|
import unittest
|
|
|
|
from cpp_source import body
|
|
from test_meshtext_transport import HARNESS as FOREIGN_HARNESS
|
|
import test_meshtext_config as feature_config
|
|
import test_ethernet_radio as ethernet_test
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
|
|
|
|
class HostKissRadioTest(unittest.TestCase):
|
|
def run_cpp(self, source, *, dispatcher=False):
|
|
compiler = shutil.which("g++") or shutil.which("clang++")
|
|
self.assertIsNotNone(compiler)
|
|
with tempfile.TemporaryDirectory(prefix="meshcore-host-kiss-") as folder:
|
|
cpp, exe = Path(folder) / "test.cpp", Path(folder) / "test"
|
|
cpp.write_text(source, encoding="ascii")
|
|
args = [compiler, "-std=c++17", "-Wall", "-Wextra",
|
|
"-DMESH_ENABLE_HOST_KISS=1", "-DMESH_ENABLE_MESHTEXT_CHAT=0",
|
|
"-DMESH_ENABLE_MESHTEXT_WIRE=0", "-DMESH_ENABLE_ETHERNET_WIRE=0",
|
|
"-DMESH_ENABLE_TX_BEACONS=0", "-I", str(ROOT / "test/mocks"),
|
|
"-I", str(ROOT / "src")]
|
|
if os.name != "nt":
|
|
args += ["-fsanitize=address,undefined", "-fno-omit-frame-pointer", "-fno-pie", "-no-pie"]
|
|
if dispatcher:
|
|
args += [str(ROOT / "src" / name) for name in (
|
|
"Dispatcher.cpp", "Packet.cpp", "helpers/StaticPoolPacketManager.cpp")]
|
|
result = subprocess.run(args + [str(cpp), "-o", str(exe)], capture_output=True, text=True)
|
|
self.assertEqual(result.returncode, 0, result.stderr[-16000:])
|
|
env = dict(os.environ)
|
|
env["ASAN_OPTIONS"] = env.get("ASAN_OPTIONS", "") + ":detect_leaks=0"
|
|
result = subprocess.run([str(exe)], capture_output=True, text=True, env=env)
|
|
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
|
|
|
|
def test_actual_dispatcher_host_only_routing_and_scheduler_admission(self):
|
|
fixture = FOREIGN_HARNESS.split("int main()", 1)[0]
|
|
fixture = fixture.replace("RadioProfileProtocol::Meshtext", "RadioProfileProtocol::Kiss")
|
|
fixture = fixture.replace("bool supportsMeshtext() const override", "bool supportsHostKiss() const override")
|
|
fixture = fixture.replace("return queueForeignRadioFrame(b,n,1,_radio->profiles()->generation[1]);",
|
|
"return submitHostKissFrame(b,n,_radio->profiles()->generation[1]);")
|
|
hooks = r'''
|
|
namespace mesh { namespace hostkiss {
|
|
unsigned rx=0; std::vector<bool> completions;
|
|
void receive(const uint8_t* b,size_t n,uint8_t p,uint32_t g,float,float) {
|
|
assert(n==3 && b[0]==0x11 && p==1 && g); ++rx;
|
|
}
|
|
void sendComplete(bool success) { completions.push_back(success); }
|
|
} }
|
|
int main() {
|
|
using namespace mesh::hostkiss;
|
|
{ Fixture f;const auto done=completions.size();assert(f.d.queue(bytes));
|
|
assert(f.d.hostKissFramePending() && !f.d.queue(bytes));f.tick();
|
|
assert(f.radio.sends==1 && f.radio.active==1 && f.radio.sent==std::vector<uint8_t>(bytes,bytes+3));
|
|
assert(!f.d.cancelHostKissFrame());f.radio.complete=true;f.tick(20);
|
|
assert(completions.size()==done+1 && completions.back() && f.d.done.empty());
|
|
assert(!f.d.hostKissFramePending() && f.radio.p.tx_packets[1]==1);
|
|
assert(!f.d.getNumSentFlood() && !f.d.getNumSentDirect() && f.d.getTotalAirTime()==20);
|
|
}
|
|
{ Fixture f;auto before=rx;f.radio.active=1;f.radio.incoming=true;f.tick();
|
|
assert(rx==before+1 && !f.d.foreign_rx && !f.d.mc_rx && !f.d.raw_logs);
|
|
assert(!f.d.getNumRecvFlood() && !f.d.getNumRecvDirect() && !f.d.getLastMeshCoreRecvMillis());
|
|
assert(f.radio.processed==1 && f.radio.p.rx_packets[1]==1);
|
|
f.radio.p.secondary.mode=RadioProfileMode::Off;f.radio.incoming=true;f.tick();assert(rx==before+1);
|
|
f.radio.active=0;f.radio.p.primary.protocol=RadioProfileProtocol::Kiss;
|
|
f.radio.incoming=true;f.tick();assert(rx==before+1 && !f.d.foreign_rx && !f.d.raw_logs);
|
|
}
|
|
{ Fixture f;auto done=completions.size();assert(f.d.queue(bytes));assert(f.d.cancelHostKissFrame());
|
|
assert(completions.size()==done+1 && !completions.back() && !f.d.hostKissFramePending());
|
|
f.tick();assert(!f.radio.sends && f.d.done.empty());
|
|
}
|
|
{ Fixture f;auto done=completions.size();assert(f.d.queue(bytes));++f.radio.p.generation[1];f.tick();
|
|
assert(!f.radio.sends && !f.d.hostKissFramePending() && completions.size()==done+1 && !completions.back());
|
|
}
|
|
{ Fixture f;auto done=completions.size();assert(f.d.queue(bytes));f.tick();++f.radio.p.generation[1];
|
|
f.radio.complete=true;f.tick();assert(completions.size()==done+1 && !completions.back() && f.radio.finishes==1);
|
|
}
|
|
{ Fixture f;assert(!f.d.submitHostKissFrame(bytes,3,f.radio.p.generation[1]+1));
|
|
f.radio.supported=false;assert(!f.d.queue(bytes));f.radio.supported=true;
|
|
f.radio.p.secondary.mode=RadioProfileMode::Rx;assert(!f.d.queue(bytes));
|
|
f.radio.p.secondary.mode=RadioProfileMode::Off;assert(!f.d.queue(bytes));
|
|
f.radio.p.secondary.mode=RadioProfileMode::RxTx;f.radio.p.secondary.params.protocol=RadioProfileProtocol::MeshCore;
|
|
assert(!f.d.queue(bytes));f.radio.p.secondary.params.protocol=RadioProfileProtocol::Kiss;
|
|
assert(!f.d.queue(nullptr));assert(!f.d.queue(bytes,0));uint8_t full[256]={};assert(!f.d.queue(full,256));
|
|
f.radio.carrier=true;assert(!f.d.queue(bytes));f.radio.carrier=false;
|
|
f.d.allow_foreign=false;assert(!f.d.queue(bytes));
|
|
}
|
|
{ Fixture f;auto done=completions.size();f.radio.prepare=RadioParamApplyResult::BUSY;
|
|
assert(f.d.queue(bytes));f.tick();assert(!f.radio.sends && f.d.hostKissFramePending());
|
|
f.radio.prepare=RadioParamApplyResult::APPLIED;f.tick(11);assert(f.radio.sends==1 && f.radio.active==1);
|
|
f.d.setRadioAvailable(false);assert(completions.size()==done+1 && !completions.back());
|
|
}
|
|
{ Fixture f;auto done=completions.size();f.radio.start_ok=false;assert(f.d.queue(bytes));f.tick();f.tick(2000);
|
|
assert(f.radio.sends==1 && !f.d.hostKissFramePending() && completions.size()==done+1 && !completions.back());
|
|
}
|
|
{ Fixture f;auto done=completions.size();assert(f.d.queue(bytes));f.tick();f.tick(1151);
|
|
assert(f.radio.sends==1 && f.radio.finishes==1 && f.radio.recovery==1);
|
|
assert(completions.size()==done+1 && !completions.back());
|
|
}
|
|
{ Fixture f;f.radio.receiving=true;assert(f.d.queue(bytes));f.tick();f.tick(201);
|
|
assert(!f.radio.sends && f.d.hostKissFramePending());f.radio.receiving=false;f.tick(201);
|
|
assert(f.radio.sends==1 && f.radio.active==1);
|
|
}
|
|
{ Fixture f;f.d.duty_window=200;f.d.begin();assert(f.d.queue(bytes));f.tick();
|
|
f.clock.now+=100;f.radio.complete=true;f.d.loop();assert(f.d.getRemainingTxBudget()==0);
|
|
assert(f.d.queue(bytes));f.tick(100);assert(f.radio.sends==1);f.tick(101);assert(f.radio.sends==2);
|
|
}
|
|
{ Fixture f;assert(f.d.queue(bytes));f.tick();f.radio.complete=true;f.tick();assert(f.d.queue(bytes));
|
|
auto* p=newPacket(f.d,RADIO_TX_PRIMARY);assert(f.d.sendPacket(p,0));f.tick();
|
|
assert(f.radio.sends==2 && f.radio.active==0);f.radio.complete=true;f.tick();f.tick();
|
|
assert(f.radio.sends==3 && f.radio.active==1);
|
|
}
|
|
{ Fixture f;auto* p=newPacket(f.d);f.radio.p.cross=RadioCrossMode::On;
|
|
assert(!f.radio.p.canCross() && f.d.getTransmitProfileMask(p)==1);
|
|
assert(f.d.sendPacket(p,0));f.tick();assert(f.radio.sends==1 && f.radio.active==0);
|
|
auto* denied=newPacket(f.d,RADIO_TX_SECONDARY);assert(!f.d.sendPacket(denied,0));
|
|
}
|
|
}
|
|
'''
|
|
self.run_cpp(fixture + hooks, dispatcher=True)
|
|
|
|
def test_actual_protocol_selection_on_every_supported_wrapper(self):
|
|
for family in ("SX1262", "SX1268", "SX1276", "LLCC68", "STM32WLx", "LR1110", "LR1121", "LR2021"):
|
|
with self.subTest(family=family):
|
|
source = (ROOT / "src/helpers/radiolib" / ("Custom" + family + "Wrapper.h")).read_text()
|
|
select = body(source, "bool applyProtocol(mesh::RadioProfileProtocol protocol)")
|
|
select = select.replace(" override", "")
|
|
harness = r'''
|
|
#include <cassert>
|
|
#include <RadioProfiles.h>
|
|
#include <helpers/radiolib/LR2021ApplyStatus.h>
|
|
#define RADIOLIB_ERR_NONE 0
|
|
struct Driver {
|
|
unsigned calls=0; uint8_t sync=0; int status=0;
|
|
int setProfileProtocol(uint8_t s) { ++calls;sync=s;return status; }
|
|
};
|
|
using @CLASS@=Driver;
|
|
struct TestWrapper {
|
|
Driver driver; Driver* _radio=&driver;
|
|
bool supportsMeshtext() const { return false; }
|
|
bool supportsHostKiss() const { return true; }
|
|
int recordApply(mesh::lr2021::ApplyStatus::Stage,int code) { return code; }
|
|
@SELECT@
|
|
};
|
|
int main() {
|
|
using P=mesh::RadioProfileProtocol;
|
|
TestWrapper w;assert(w.applyProtocol(P::Kiss));assert(w.driver.sync==0x12 && w.driver.calls==1);
|
|
assert(w.applyProtocol(P::MeshCore));assert(w.driver.sync==0x12 && w.driver.calls==2);
|
|
assert(!w.applyProtocol(static_cast<P>(255)) && w.driver.calls==2);
|
|
w.driver.status=-17;assert(!w.applyProtocol(P::Kiss));
|
|
}
|
|
'''
|
|
self.run_cpp(harness.replace("@CLASS@", "Custom" + family).replace("@SELECT@", select))
|
|
|
|
def test_actual_cli_protocol_lease_preserves_saved_intent_and_other_owners(self):
|
|
code = r'''
|
|
#define main existing_cli_main
|
|
#include "test/fixtures/radio_profiles/cli_test.cpp"
|
|
#undef main
|
|
int main() {
|
|
using P=mesh::RadioProfileProtocol;
|
|
Fixture f;
|
|
f.cmd("set radio2 910.5,500,8,5,rxtx,80");f.advance(2000);
|
|
const auto saved=f.fs.files["/radio_profiles"];
|
|
const auto tuple=f.radio.p.secondary;
|
|
const auto intent=f.cli.secondaryIntentGeneration();
|
|
const auto generation=f.radio.p.generation[1];
|
|
assert(f.cli.manualSecondaryConfigured() && f.cli.secondaryRuntimeAvailable());
|
|
assert(f.cli.useSecondaryProtocol(P::Kiss));
|
|
assert(f.radio.p.secondary.params.protocol==P::Kiss && f.radio.p.generation[1]!=generation);
|
|
assert(f.radio.profilePreamble(1)==80 && f.fs.files["/radio_profiles"]==saved);
|
|
assert(f.cli.secondaryIntentGeneration()==intent && f.cli.savedSecondaryConfig().params==tuple.params);
|
|
const auto kiss_generation=f.radio.p.generation[1];
|
|
assert(f.cli.useSecondaryProtocol(P::Kiss) && f.radio.p.generation[1]==kiss_generation);
|
|
// A running host lease is not replaceable by another foreign service.
|
|
assert(!f.cli.useSecondaryProtocol(P::Meshtext));
|
|
assert(!f.cli.useSecondaryProtocol(P::Ethernet));
|
|
f.cli.clearSecondaryProtocol();
|
|
assert(f.radio.p.secondary.params==tuple.params && f.radio.p.secondary.mode==tuple.mode);
|
|
assert(f.fs.files["/radio_profiles"]==saved);
|
|
// Saved manual changes retire the host intent immediately, while preserving
|
|
// the two-second reply window before publishing the new running tuple.
|
|
assert(f.cli.useSecondaryProtocol(P::Kiss));
|
|
f.cmd("set radio2 912.5,500,9,5,rxtx,88");
|
|
assert(f.cli.secondaryIntentGeneration()!=intent && !f.cli.secondaryRuntimeAvailable());
|
|
assert(f.radio.p.secondary.params.protocol==P::Kiss && f.radio.p.secondary.params.freq==910.5f);
|
|
f.cli.clearSecondaryProtocol();f.advance(1999);
|
|
assert(f.radio.p.secondary.params.protocol==P::Kiss && f.radio.p.secondary.params.freq==910.5f);
|
|
f.advance(1);
|
|
assert(f.radio.p.secondary.params.protocol==P::MeshCore && f.radio.p.secondary.params.freq==912.5f);
|
|
assert(f.radio.profilePreamble(1)==88 && f.cli.secondaryRuntimeAvailable());
|
|
assert(f.cli.useSecondaryProtocol(P::Kiss));
|
|
// A direct outside owner wins even if the old host later releases its
|
|
// overlay. Old host cleanup must not restore the saved tuple over it.
|
|
auto foreign=f.radio.p.secondary;foreign.params.protocol=P::Meshtext;foreign.params.freq=913.5f;
|
|
f.radio.p.setSecondary(foreign,false);
|
|
f.cli.clearSecondaryProtocol();f.advance(1);
|
|
assert(f.radio.p.secondary.params==foreign.params && !f.cli.secondaryRuntimeAvailable());
|
|
f.cmd("set radio2 914.5,500,9,5,rxtx,88");f.advance(2000);
|
|
assert(f.cli.secondaryRuntimeAvailable() && f.cli.useSecondaryProtocol(P::Kiss));
|
|
#if MESH_ENABLE_MESHTEXT_CHAT
|
|
f.cli.clearSecondaryProtocol();assert(f.cli.useSecondaryProtocol(P::Meshtext));
|
|
const auto mt=f.radio.p.secondary;
|
|
assert(!f.cli.useSecondaryProtocol(P::Kiss) && f.radio.p.secondary.params==mt.params);
|
|
#endif
|
|
#if MESH_ENABLE_ETHERNET_TUNNEL
|
|
f.cli.clearSecondaryProtocol();assert(f.cli.useSecondaryProtocol(P::Ethernet));
|
|
const auto eth=f.radio.p.secondary;
|
|
assert(!f.cli.useSecondaryProtocol(P::Kiss) && f.radio.p.secondary.params==eth.params);
|
|
#endif
|
|
Fixture absent;assert(!absent.cli.useSecondaryProtocol(P::Kiss));
|
|
absent.cmd("set radio2 off");absent.advance(2000);
|
|
assert(!absent.cli.useSecondaryProtocol(P::Kiss));
|
|
}
|
|
'''
|
|
runner = ethernet_test.EthernetRadioTest()
|
|
runner.setUpClass()
|
|
for foreign in (0, 1):
|
|
with self.subTest(other_foreign_services=foreign):
|
|
runner.compile_run(code, ["-DMESH_ENABLE_HOST_KISS=1",
|
|
"-DMESH_ENABLE_MESHTEXT_CHAT=" + str(foreign),
|
|
"-DMESH_ENABLE_ETHERNET_TUNNEL=" + str(foreign)],
|
|
["src/helpers/RadioProfileCLI.cpp"], ["test/fixtures/radio_profiles/mocks"])
|
|
|
|
def test_actual_meshtext_refresh_never_revokes_host_kiss_protocol(self):
|
|
source = (ROOT / "examples/companion_radio/MeshtextCompanion.cpp").read_text()
|
|
refresh = body(source, "void MyMesh::refreshMeshtextProfile()")
|
|
code = r'''
|
|
#define main existing_cli_main
|
|
#include "test/fixtures/radio_profiles/cli_test.cpp"
|
|
#undef main
|
|
#include <helpers/CompanionChannelAlias.h>
|
|
#define MAX_GROUP_CHANNELS 4
|
|
struct ChannelDetails {char name[32]={};};
|
|
class BaseChatMesh {
|
|
public:
|
|
ChannelDetails channels[MAX_GROUP_CHANNELS];unsigned channel_reads=0;
|
|
bool getChannel(int n,ChannelDetails& out){++channel_reads;out=channels[n];return out.name[0];}
|
|
};
|
|
namespace mesh {namespace mt {
|
|
enum class Region{Unset,US};enum class Preset{LongFast,ShortFast};struct Channel{};
|
|
bool parsePreset(const char* name,Preset& preset){
|
|
if(!strcmp(name,"longfast")){preset=Preset::LongFast;return true;}
|
|
if(!strcmp(name,"shortfast")){preset=Preset::ShortFast;return true;}
|
|
return false;
|
|
}
|
|
bool modemConfig(Region,Preset,RadioProfileParams& out,uint32_t){
|
|
out={910.5f,500,16,8,5};out.protocol=RadioProfileProtocol::Meshtext;return true;
|
|
}
|
|
bool frequencyInRegion(Region region,const RadioProfileParams&){return region==Region::US;}
|
|
bool sameModulation(const RadioProfileParams&a,const RadioProfileParams&b){return a.bw==b.bw&&a.sf==b.sf&&a.cr==b.cr;}
|
|
}}
|
|
bool describe(const ChannelDetails&,mesh::mt::Channel&){return true;}
|
|
class MyMesh:public BaseChatMesh {
|
|
public:
|
|
struct RadioView {
|
|
Radio& radio;
|
|
mesh::RadioProfiles* profiles(){return radio.profiles();}
|
|
bool supportsMeshtext()const{return true;}
|
|
bool validateProfile(const mesh::RadioProfileParams& p)const{return radio.validateProfile(p);}
|
|
} view;
|
|
RadioView* _radio;mesh::RadioProfileCLI& _radio_profiles;
|
|
bool _mt_active=true,_mt_profile_dirty=true,_mt_last_radio_ready=false,_mt_last_secondary_ready=false;
|
|
bool _radio_available=true,_mt_settings_valid=true;
|
|
uint32_t _mt_primary_generation=0,_mt_secondary_generation=0,_mt_intent_generation=0,_mt_slot=0;
|
|
float _mt_primary_frequency=0;const char* _mt_status="";
|
|
struct {float freq=909.5f;} _prefs;
|
|
struct {bool enabled=false;} _ethernet_settings;
|
|
mesh::mt::Region region=mesh::mt::Region::US;
|
|
MyMesh(Radio& radio,mesh::RadioProfileCLI& profiles):view{radio},_radio(&view),_radio_profiles(profiles){}
|
|
mesh::mt::Region meshtextRegion()const{return region;}
|
|
void refreshMeshtextProfile();
|
|
};
|
|
@REFRESH@
|
|
int main(){
|
|
using P=mesh::RadioProfileProtocol;
|
|
for(unsigned scenario=0;scenario<10;++scenario){
|
|
Fixture f;f.cmd("set radio2 910.5,500,8,5,rxtx,80");f.advance(2000);
|
|
const auto saved=f.fs.files;const auto intent=f.cli.secondaryIntentGeneration();
|
|
assert(f.cli.useSecondaryProtocol(P::Kiss));
|
|
const auto generation=f.radio.p.generation[1];const auto params=f.radio.p.secondary.params;
|
|
MyMesh mesh(f.radio,f.cli);
|
|
if(scenario!=0)strcpy(mesh.channels[0].name,"#mt-longfast");
|
|
if(scenario==2)strcpy(mesh.channels[0].name,"#mt-custom");
|
|
if(scenario==3)strcpy(mesh.channels[1].name,"#mt-shortfast");
|
|
if(scenario==4)strcpy(mesh.channels[1].name,"#r2-public");
|
|
if(scenario==5)mesh._mt_settings_valid=false;
|
|
if(scenario==6)mesh._radio_available=false;
|
|
if(scenario==7)mesh.region=mesh::mt::Region::Unset;
|
|
if(scenario==8)mesh._prefs.freq=915;
|
|
if(scenario==9)mesh._ethernet_settings.enabled=true;
|
|
mesh.refreshMeshtextProfile();mesh.refreshMeshtextProfile();
|
|
assert(f.radio.p.secondary.params.protocol==P::Kiss && f.radio.p.secondary.params==params);
|
|
assert(f.radio.p.generation[1]==generation && f.cli.secondaryIntentGeneration()==intent && f.fs.files==saved);
|
|
assert(!mesh._mt_active && mesh._mt_profile_dirty && !strcmp(mesh._mt_status,"radio2 reserved for KISS"));
|
|
assert(!mesh.channel_reads);
|
|
if(scenario==1){
|
|
f.cli.clearSecondaryProtocol();mesh.refreshMeshtextProfile();
|
|
assert(mesh._mt_active && f.radio.p.secondary.params.protocol==P::Meshtext);
|
|
assert(f.fs.files==saved);
|
|
}
|
|
}
|
|
}
|
|
'''
|
|
runner = ethernet_test.EthernetRadioTest()
|
|
runner.setUpClass()
|
|
guard_start = refresh.index("#if MESH_ENABLE_HOST_KISS")
|
|
guard_end = refresh.index("#endif", guard_start) + len("#endif")
|
|
negative = refresh[:guard_start] + refresh[guard_end:]
|
|
for ethernet, remove_guard in ((0, False), (1, False), (0, True)):
|
|
with self.subTest(ethernet=ethernet, remove_guard=remove_guard):
|
|
candidate = negative if remove_guard else refresh
|
|
if remove_guard:
|
|
with self.assertRaises(AssertionError) as failure:
|
|
runner.compile_run(code.replace("@REFRESH@", candidate),
|
|
["-DMESH_ENABLE_HOST_KISS=1", "-DMESH_ENABLE_MESHTEXT_CHAT=1",
|
|
"-DMESH_ENABLE_ETHERNET_TUNNEL=" + str(ethernet)],
|
|
["src/helpers/RadioProfileCLI.cpp"], ["test/fixtures/radio_profiles/mocks"])
|
|
self.assertIn("f.radio.p.secondary.params.protocol==P::Kiss", str(failure.exception))
|
|
else:
|
|
runner.compile_run(code.replace("@REFRESH@", candidate),
|
|
["-DMESH_ENABLE_HOST_KISS=1", "-DMESH_ENABLE_MESHTEXT_CHAT=1",
|
|
"-DMESH_ENABLE_ETHERNET_TUNNEL=" + str(ethernet)],
|
|
["src/helpers/RadioProfileCLI.cpp"], ["test/fixtures/radio_profiles/mocks"])
|
|
|
|
def test_feature_layout_is_consistent_with_platform_and_explicit_overrides(self):
|
|
checker = feature_config.MeshtextConfigTest()
|
|
checker.setUp()
|
|
for platform in ("ESP32_PLATFORM", "NRF52_PLATFORM"):
|
|
checker.assert_orders([platform, "COMPANION_RADIO_FULL=1"], 1, feature="MESH_ENABLE_HOST_KISS")
|
|
checker.assert_orders([platform, "COMPANION_RADIO_FULL=0"], 0, feature="MESH_ENABLE_HOST_KISS")
|
|
checker.assert_orders([platform, "COMPANION_RADIO_FULL=1", "MESH_ENABLE_HOST_KISS=0"], 0,
|
|
feature="MESH_ENABLE_HOST_KISS")
|
|
checker.assert_orders([platform, "MESH_ENABLE_HOST_KISS=1"], 1, feature="MESH_ENABLE_FOREIGN_RADIO")
|
|
checker.assert_orders([], 0, feature="MESH_ENABLE_HOST_KISS")
|
|
checker.assert_orders(["RP2040_PLATFORM", "COMPANION_RADIO_FULL=1"], 0, feature="MESH_ENABLE_HOST_KISS")
|
|
checker.assert_orders(["MESH_PRIMARY_ESPNOW=1", "MESH_ENABLE_HOST_KISS=1"], 0,
|
|
feature="MESH_ENABLE_HOST_KISS")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|