Merge pull request #3810 from fdlamotte/revert_rak13302_tests

tests: revert rak13302 tests
This commit is contained in:
fdlamotte authored and GitHub committed 2026-11-11 07:30:25 -04:00
commit e7c6d079cc
7 files changed
+1 -215

No files matched your search

+1 -1
View File
@@ -20,7 +20,7 @@ jobs:
uses: ./.github/actions/setup-build-environment
- name: Run Unit Tests
run: pio test -e native -e native_kiss_modem -e native_rak3401_onboard_radio -vv
run: pio test -e native -e native_kiss_modem -vv
- name: Upload Test Results
# Upload test results even if the test step failed.
-10
View File
@@ -168,7 +168,6 @@ build_flags = -std=c++17
-I test/mocks
test_build_src = yes
test_ignore = test_kiss_modem
test_rak3401_board_startup
build_src_filter =
-<*>
+<../src/Utils.cpp>
@@ -179,15 +178,6 @@ build_src_filter =
lib_deps =
google/googletest @ 1.17.0
[env:native_rak3401_onboard_radio]
; Board startup needs isolated GPIO and power-management mocks.
extends = env:native
test_build_src = no
test_filter = test_rak3401_*
test_ignore =
build_flags = -I test/test_rak3401_board_startup/mocks
${env:native.build_flags}
[env:native_kiss_modem]
platform = native
test_framework = googletest
@@ -1,18 +0,0 @@
#pragma once
#include "../../mocks/Arduino.h"
#define NRF52_POWER_MANAGEMENT 1
#define PWRMGT_LPCOMP_AIN 3
#define PWRMGT_LPCOMP_REFSEL 4
#define PWRMGT_VOLTAGE_BOOTLOCK 3300
#define SX126X_POWER_EN 21
#define INPUT 0
#define OUTPUT 1
#define LOW 0
#define HIGH 1
void pinMode(uint32_t pin, uint32_t mode);
void digitalWrite(uint32_t pin, uint32_t value);
void analogReadResolution(uint32_t bits);
uint32_t analogRead(uint32_t pin);
@@ -1,6 +0,0 @@
#pragma once
struct StartupWire {
void begin() {}
};
inline StartupWire Wire;
@@ -1,44 +0,0 @@
#pragma once
#include <Arduino.h>
#include <string>
#include <vector>
#define SHUTDOWN_REASON_LOW_VOLTAGE 0x4C
#define SHUTDOWN_REASON_BOOT_PROTECT 0x42
struct PowerMgtConfig {
uint8_t lpcomp_ain_channel;
uint8_t lpcomp_refsel;
uint16_t voltage_bootlock;
};
namespace startup_test {
extern std::vector<std::string> events;
extern bool permitBoot;
struct SystemOff { uint8_t reason; };
}
class NRF52Board {
protected:
bool checkBootVoltage(const PowerMgtConfig*) {
startup_test::events.push_back("voltage");
if (!startup_test::permitBoot) initiateShutdown(SHUTDOWN_REASON_BOOT_PROTECT);
return true;
}
virtual void initiateShutdown(uint8_t reason) { enterSystemOff(reason); }
void configureVoltageWake(uint8_t, uint8_t) {}
void enterSystemOff(uint8_t reason) {
startup_test::events.push_back("off");
throw startup_test::SystemOff{reason};
}
public:
explicit NRF52Board(const char* = nullptr) {}
virtual uint16_t getBattMilliVolts() = 0;
virtual const char* getManufacturerName() const = 0;
};
class NRF52BoardDCDC : virtual public NRF52Board {
public:
void begin() {}
};
@@ -1,70 +0,0 @@
#include <gtest/gtest.h>
#include <array>
// Exercise the real startup code with a power-management stub that stops at SYSTEMOFF.
#include "../../variants/rak3401/RAK3401Board.cpp"
namespace startup_test {
std::vector<std::string> events;
bool permitBoot;
std::array<uint32_t, 48> outputs;
rak3401::OnboardRadioState radioState;
}
void pinMode(uint32_t, uint32_t) {}
void digitalWrite(uint32_t pin, uint32_t value) { startup_test::outputs.at(pin) = value; }
void analogReadResolution(uint32_t) {}
uint32_t analogRead(uint32_t) { return 2500; }
rak3401::OnboardRadioState rak3401::sleepOnboardRadio() {
startup_test::events.push_back("onboard");
return startup_test::radioState;
}
class RakBoardStartup : public testing::Test {
protected:
void SetUp() override {
startup_test::events.clear();
startup_test::outputs.fill(HIGH);
startup_test::permitBoot = true;
startup_test::radioState = rak3401::OnboardRadioState::Asleep;
}
};
TEST_F(RakBoardStartup, OnboardRadioHandledBeforeVoltageCheck) {
RAK3401Board board;
board.begin();
EXPECT_EQ(startup_test::events, (std::vector<std::string>{"onboard", "voltage"}));
EXPECT_EQ(startup_test::outputs.at(SX126X_POWER_EN), HIGH);
EXPECT_EQ(startup_test::outputs.at(PIN_3V3_EN), HIGH);
}
TEST_F(RakBoardStartup, LowVoltageExitStillHandlesOnboardRadio) {
startup_test::permitBoot = false;
RAK3401Board board;
try {
board.begin();
FAIL() << "Expected protective shutdown";
} catch (const startup_test::SystemOff& off) {
EXPECT_EQ(off.reason, SHUTDOWN_REASON_BOOT_PROTECT);
}
EXPECT_EQ(startup_test::events, (std::vector<std::string>{"onboard", "voltage", "off"}));
EXPECT_EQ(startup_test::outputs.at(SX126X_POWER_EN), LOW);
EXPECT_EQ(startup_test::outputs.at(PIN_3V3_EN), LOW);
}
TEST_F(RakBoardStartup, OptionalRadioFailuresDoNotBypassBootProtection) {
for (auto state : {rak3401::OnboardRadioState::Absent, rak3401::OnboardRadioState::BusyTimeout,
rak3401::OnboardRadioState::SleepFailed}) {
startup_test::events.clear();
startup_test::permitBoot = false;
startup_test::radioState = state;
RAK3401Board board;
EXPECT_THROW(board.begin(), startup_test::SystemOff);
EXPECT_EQ(startup_test::events, (std::vector<std::string>{"onboard", "voltage", "off"}));
}
}
int main(int argc, char** argv) {
testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
@@ -1,66 +0,0 @@
#include <gtest/gtest.h>
#include <array>
#include <string>
#include "../../variants/rak3401/OnboardRadioSleep.h"
namespace {
struct FakeRadioIO {
std::string version = "SX1261";
std::array<bool, 3> ready = {true, true, true};
std::string calls;
unsigned waits = 0;
bool probePulls = true;
void begin() { calls += "begin "; }
void reset() { calls += "reset "; }
bool waitBusy(bool high, unsigned timeout) {
calls += high ? "busy-high " : "busy-low ";
EXPECT_EQ(timeout, 20u);
if (high) EXPECT_FALSE(probePulls);
const bool result = ready.at(waits++);
return result;
}
void readVersion(char* out) { calls += "version "; memcpy(out, version.data(), 6); }
void releaseProbePulls() { calls += "release-pulls "; probePulls = false; }
void sleep() { EXPECT_FALSE(probePulls); calls += "sleep "; }
void end() { calls += "end "; }
};
}
TEST(RakOnboardRadio, PresentRadioSleepsBeforeBusRelease) {
FakeRadioIO io;
EXPECT_EQ(rak3401::sleepOnboardRadio(io, "SX1261"), rak3401::OnboardRadioState::Asleep);
EXPECT_EQ(io.calls, "begin reset busy-low version release-pulls busy-low sleep busy-high end ");
}
TEST(RakOnboardRadio, AbsentAndFloatingResponsesNeverReceiveSleep) {
for (const std::string version : {std::string(6, '\0'), std::string(6, '\xff'), std::string("SX126X")}) {
FakeRadioIO io;
io.version = version;
EXPECT_EQ(rak3401::sleepOnboardRadio(io, "SX1261"), rak3401::OnboardRadioState::Absent);
EXPECT_EQ(io.calls, "begin reset busy-low version end ");
}
}
TEST(RakOnboardRadio, BusyTimeoutsReleaseBusWithoutSleep) {
for (unsigned failure = 0; failure < 2; failure++) {
FakeRadioIO io;
io.ready[failure] = false;
EXPECT_EQ(rak3401::sleepOnboardRadio(io, "SX1261"), rak3401::OnboardRadioState::BusyTimeout);
EXPECT_EQ(io.calls.find("sleep "), std::string::npos);
EXPECT_EQ(io.calls, failure == 0 ? "begin reset busy-low end " :
"begin reset busy-low version release-pulls busy-low end ");
}
}
TEST(RakOnboardRadio, MissingSleepReadbackIsReportedAndBusReleased) {
FakeRadioIO io;
io.ready[2] = false;
EXPECT_EQ(rak3401::sleepOnboardRadio(io, "SX1261"), rak3401::OnboardRadioState::SleepFailed);
EXPECT_EQ(io.calls.substr(io.calls.size() - 4), "end ");
}
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}