feat(mqtt): refactor message building to use MQTTPayloadBuilder
Replace direct JSON construction in MQTTMessageBuilder with calls to MQTTPayloadBuilder for building status, packet, and raw messages. This change improves code maintainability and reduces duplication by centralizing message formatting logic. Additionally, update platformio.ini to include ArduinoJson dependency for JSON handling.
This commit is contained in:
1 parent
b7b3b4dcf1
commit
26a8a3cb58
27 files changed
+1514
-293
No files matched your search
@@ -27,6 +27,10 @@ does not reflect the GoogleTest count — run the built binary directly
|
||||
| `test_observer_validation` | `src/helpers/MQTTObserverValidation.h` | IATA (exactly 3 alphanumerics), owner key (64 hex), NTP hostname, and the buffer-fit check behind the #17 length validation — including boundaries and nulls |
|
||||
| `test_webconfig_keys` | `src/helpers/WebConfigKeys.h` | POST-key allowlist, secret detection, slot-index bounds, and the short-key out-of-bounds guard (attacker-supplied keys) |
|
||||
| `test_topic_template` | `src/helpers/MQTTTopicTemplate.h` | `{iata}/{device}/{token}/{type}` expansion, overflow/NUL-termination, and a buffer-size fuzz |
|
||||
| `test_mqtt_topic_router` | `src/helpers/MQTTTopicRouter.h` | complete preset/custom topic-routing contract; MeshRank packets-only behavior; required identifiers; invalid inputs/slots; exact buffer boundaries |
|
||||
| `test_mqtt_connection_policy` | `src/helpers/MQTTConnectionPolicy.h` | reconnect guard/backoff/stagger and breaker transitions; stable reset; JWT lifetime/renewal policy; exact timing boundaries and 32-bit `millis()` rollover |
|
||||
| `test_mqtt_packet_queue_policy` | `src/helpers/MQTTPacketQueuePolicy.h` | queue-full eviction; stale-disconnect flush; adaptive drain limits; bounded QoS0 retries; exact timing boundaries and 32-bit `millis()` rollover |
|
||||
| `test_mqtt_payload_builder` | `src/helpers/MQTTPayloadBuilder.cpp` | status/packet/raw JSON contracts; optional fields; escaping; RX metrics and path; score handling; exact buffer bounds; maximum representative payloads |
|
||||
| `test_utils` | `src/Utils.cpp` | `Utils::toHex` (upstream) |
|
||||
|
||||
## Conventions (and how to add a suite)
|
||||
|
||||
@@ -0,0 +1,158 @@
|
||||
#include <gtest/gtest.h>
|
||||
#include <stdint.h>
|
||||
#include <limits>
|
||||
|
||||
#include "helpers/MQTTConnectionPolicy.h"
|
||||
|
||||
namespace Policy = MQTTConnectionPolicy;
|
||||
|
||||
TEST(MQTTConnectionPolicy, ElapsedTimeHandlesNormalAndWrappedClocks) {
|
||||
EXPECT_EQ(4000U, Policy::elapsedMs(5000U, 1000U));
|
||||
|
||||
const uint32_t before_wrap = std::numeric_limits<uint32_t>::max() - 99U;
|
||||
EXPECT_EQ(150U, Policy::elapsedMs(50U, before_wrap));
|
||||
}
|
||||
|
||||
TEST(MQTTConnectionPolicy, CrossSlotReconnectGuardHasExactBoundary) {
|
||||
EXPECT_TRUE(Policy::reconnectGuardActive(14999U, 0U));
|
||||
EXPECT_FALSE(Policy::reconnectGuardActive(15000U, 0U));
|
||||
|
||||
const uint32_t last = std::numeric_limits<uint32_t>::max() - 9999U;
|
||||
EXPECT_TRUE(Policy::reconnectGuardActive(4999U, last));
|
||||
EXPECT_FALSE(Policy::reconnectGuardActive(5000U, last));
|
||||
}
|
||||
|
||||
TEST(MQTTConnectionPolicy, StableResetRequiresARealStartAndFullWindow) {
|
||||
EXPECT_FALSE(Policy::stableConnection(500000U, 0U));
|
||||
EXPECT_FALSE(Policy::stableConnection(120999U, 1000U));
|
||||
EXPECT_TRUE(Policy::stableConnection(121000U, 1000U));
|
||||
}
|
||||
|
||||
TEST(MQTTConnectionPolicy, StableResetWindowSurvivesMillisRollover) {
|
||||
const uint32_t connected_at = std::numeric_limits<uint32_t>::max() - 59999U;
|
||||
EXPECT_FALSE(Policy::stableConnection(59999U, connected_at));
|
||||
EXPECT_TRUE(Policy::stableConnection(60000U, connected_at));
|
||||
}
|
||||
|
||||
TEST(MQTTConnectionPolicy, BackoffLadderSaturatesAtFiveMinutes) {
|
||||
EXPECT_EQ(10000U, Policy::reconnectBackoffMs(0));
|
||||
EXPECT_EQ(30000U, Policy::reconnectBackoffMs(1));
|
||||
EXPECT_EQ(60000U, Policy::reconnectBackoffMs(2));
|
||||
EXPECT_EQ(120000U, Policy::reconnectBackoffMs(3));
|
||||
EXPECT_EQ(300000U, Policy::reconnectBackoffMs(4));
|
||||
EXPECT_EQ(300000U, Policy::reconnectBackoffMs(5));
|
||||
EXPECT_EQ(300000U, Policy::reconnectBackoffMs(255));
|
||||
}
|
||||
|
||||
TEST(MQTTConnectionPolicy, LaterSlotsReceiveThreeSecondStagger) {
|
||||
EXPECT_EQ(10000U, Policy::reconnectDelayMs(0, 0));
|
||||
EXPECT_EQ(13000U, Policy::reconnectDelayMs(0, 1));
|
||||
EXPECT_EQ(315000U, Policy::reconnectDelayMs(5, 5));
|
||||
}
|
||||
|
||||
TEST(MQTTConnectionPolicy, ReconnectDueUsesDelayBoundaryAndWrapSafeElapsedTime) {
|
||||
EXPECT_FALSE(Policy::reconnectDue(12999U, 0U, 0, 1));
|
||||
EXPECT_TRUE(Policy::reconnectDue(13000U, 0U, 0, 1));
|
||||
|
||||
const uint32_t last = std::numeric_limits<uint32_t>::max() - 4999U;
|
||||
EXPECT_FALSE(Policy::reconnectDue(4999U, last, 0, 0));
|
||||
EXPECT_TRUE(Policy::reconnectDue(5000U, last, 0, 0));
|
||||
}
|
||||
|
||||
TEST(MQTTConnectionPolicy, BackoffAdvanceClimbsThenCountsFailuresAtMaximum) {
|
||||
Policy::BackoffAdvance first = Policy::advanceBackoff(0, 0);
|
||||
EXPECT_EQ(1, first.reconnect_backoff);
|
||||
EXPECT_EQ(0, first.max_backoff_failures);
|
||||
EXPECT_FALSE(first.circuit_breaker_tripped);
|
||||
EXPECT_TRUE(first.should_reconnect);
|
||||
|
||||
Policy::BackoffAdvance enters_maximum = Policy::advanceBackoff(4, 0);
|
||||
EXPECT_EQ(5, enters_maximum.reconnect_backoff);
|
||||
EXPECT_EQ(0, enters_maximum.max_backoff_failures);
|
||||
EXPECT_FALSE(enters_maximum.circuit_breaker_tripped);
|
||||
EXPECT_TRUE(enters_maximum.should_reconnect);
|
||||
|
||||
Policy::BackoffAdvance first_max_failure = Policy::advanceBackoff(5, 0);
|
||||
EXPECT_EQ(5, first_max_failure.reconnect_backoff);
|
||||
EXPECT_EQ(1, first_max_failure.max_backoff_failures);
|
||||
EXPECT_FALSE(first_max_failure.circuit_breaker_tripped);
|
||||
EXPECT_TRUE(first_max_failure.should_reconnect);
|
||||
}
|
||||
|
||||
TEST(MQTTConnectionPolicy, ThirdFailureAtMaximumTripsWithoutAnotherHandshake) {
|
||||
Policy::BackoffAdvance result = Policy::advanceBackoff(5, 2);
|
||||
EXPECT_EQ(5, result.reconnect_backoff);
|
||||
EXPECT_EQ(3, result.max_backoff_failures);
|
||||
EXPECT_TRUE(result.circuit_breaker_tripped);
|
||||
EXPECT_FALSE(result.should_reconnect);
|
||||
}
|
||||
|
||||
TEST(MQTTConnectionPolicy, CircuitBreakerProbeHasExactThirtyMinuteBoundary) {
|
||||
EXPECT_FALSE(Policy::circuitBreakerProbeDue(1799999U, 0U));
|
||||
EXPECT_TRUE(Policy::circuitBreakerProbeDue(1800000U, 0U));
|
||||
|
||||
const uint32_t last = std::numeric_limits<uint32_t>::max() - 899999U;
|
||||
EXPECT_FALSE(Policy::circuitBreakerProbeDue(899999U, last));
|
||||
EXPECT_TRUE(Policy::circuitBreakerProbeDue(900000U, last));
|
||||
}
|
||||
|
||||
TEST(MQTTConnectionPolicy, JwtLifetimeUsesCappedPerSlotStagger) {
|
||||
EXPECT_EQ(86400U, Policy::jwtLifetimeSecs(86400U, 0));
|
||||
EXPECT_EQ(86100U, Policy::jwtLifetimeSecs(86400U, 1));
|
||||
EXPECT_EQ(84900U, Policy::jwtLifetimeSecs(86400U, 5));
|
||||
}
|
||||
|
||||
TEST(MQTTConnectionPolicy, ShortJwtLifetimeUsesFivePercentPerSlot) {
|
||||
EXPECT_EQ(3300U, Policy::jwtLifetimeSecs(3300U, 0));
|
||||
EXPECT_EQ(3135U, Policy::jwtLifetimeSecs(3300U, 1));
|
||||
EXPECT_EQ(2970U, Policy::jwtLifetimeSecs(3300U, 2));
|
||||
EXPECT_EQ(85U, Policy::jwtLifetimeSecs(100U, 3));
|
||||
}
|
||||
|
||||
TEST(MQTTConnectionPolicy, JwtLifetimeCannotUnderflowForUnexpectedSlotInput) {
|
||||
EXPECT_EQ(0U, Policy::jwtLifetimeSecs(100U, 255));
|
||||
}
|
||||
|
||||
TEST(MQTTConnectionPolicy, RenewalBufferHasOneMinuteFloorAndFiveMinuteCap) {
|
||||
EXPECT_EQ(60U, Policy::renewalBufferSecs(0U));
|
||||
EXPECT_EQ(60U, Policy::renewalBufferSecs(599U));
|
||||
EXPECT_EQ(60U, Policy::renewalBufferSecs(600U));
|
||||
EXPECT_EQ(299U, Policy::renewalBufferSecs(2999U));
|
||||
EXPECT_EQ(300U, Policy::renewalBufferSecs(3000U));
|
||||
EXPECT_EQ(300U, Policy::renewalBufferSecs(86400U));
|
||||
}
|
||||
|
||||
TEST(MQTTConnectionPolicy, UnsynchronizedClockOnlyCreatesAMissingToken) {
|
||||
EXPECT_TRUE(Policy::tokenNeedsRenewal(false, 0U, 0U, 300U));
|
||||
EXPECT_FALSE(Policy::tokenNeedsRenewal(false, 0U, 1735693200U, 300U));
|
||||
}
|
||||
|
||||
TEST(MQTTConnectionPolicy, SyncedClockRenewsInvalidExpiredOrImminentTokens) {
|
||||
const uint32_t expires = 1735693200U;
|
||||
EXPECT_TRUE(Policy::tokenNeedsRenewal(true, 1735689000U, 0U, 300U));
|
||||
EXPECT_TRUE(Policy::tokenNeedsRenewal(true, 1735689000U, 999999999U, 300U));
|
||||
EXPECT_FALSE(Policy::tokenNeedsRenewal(true, expires - 301U, expires, 300U));
|
||||
EXPECT_TRUE(Policy::tokenNeedsRenewal(true, expires - 300U, expires, 300U));
|
||||
EXPECT_TRUE(Policy::tokenNeedsRenewal(true, expires, expires, 300U));
|
||||
EXPECT_TRUE(Policy::tokenNeedsRenewal(true, expires + 1U, expires, 300U));
|
||||
}
|
||||
|
||||
TEST(MQTTConnectionPolicy, RenewalThrottleHasExactBoundaryAndHandlesRollover) {
|
||||
EXPECT_FALSE(Policy::renewalAttemptAllowed(59999U, 0U));
|
||||
EXPECT_TRUE(Policy::renewalAttemptAllowed(60000U, 0U));
|
||||
|
||||
const uint32_t last = std::numeric_limits<uint32_t>::max() - 29999U;
|
||||
EXPECT_FALSE(Policy::renewalAttemptAllowed(29999U, last));
|
||||
EXPECT_TRUE(Policy::renewalAttemptAllowed(30000U, last));
|
||||
}
|
||||
|
||||
TEST(MQTTConnectionPolicy, JwtClockNeedsNtpOrAReasonableWallClock) {
|
||||
EXPECT_FALSE(Policy::jwtClockAvailable(false, Policy::kJwtClockThreshold - 1U));
|
||||
EXPECT_TRUE(Policy::jwtClockAvailable(false, Policy::kJwtClockThreshold));
|
||||
EXPECT_TRUE(Policy::jwtClockAvailable(true, 0U));
|
||||
}
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
::testing::InitGoogleTest(&argc, argv);
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
||||
@@ -0,0 +1,157 @@
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#include "helpers/MQTTPacketQueuePolicy.h"
|
||||
|
||||
namespace QueuePolicy = MQTTPacketQueuePolicy;
|
||||
|
||||
TEST(MQTTPacketQueuePolicy, EnqueuesWhileCapacityRemains) {
|
||||
EXPECT_EQ(QueuePolicy::EnqueueAction::Enqueue,
|
||||
QueuePolicy::enqueueAction(0, 6));
|
||||
EXPECT_EQ(QueuePolicy::EnqueueAction::Enqueue,
|
||||
QueuePolicy::enqueueAction(5, 6));
|
||||
}
|
||||
|
||||
TEST(MQTTPacketQueuePolicy, EvictsOldestAtOrAboveCapacity) {
|
||||
EXPECT_EQ(QueuePolicy::EnqueueAction::EvictOldestThenEnqueue,
|
||||
QueuePolicy::enqueueAction(6, 6));
|
||||
EXPECT_EQ(QueuePolicy::EnqueueAction::EvictOldestThenEnqueue,
|
||||
QueuePolicy::enqueueAction(7, 6));
|
||||
}
|
||||
|
||||
TEST(MQTTPacketQueuePolicy, RejectsQueueWithZeroCapacity) {
|
||||
EXPECT_EQ(QueuePolicy::EnqueueAction::Reject,
|
||||
QueuePolicy::enqueueAction(0, 0));
|
||||
}
|
||||
|
||||
TEST(MQTTPacketQueuePolicy, DisconnectedQueueFlushesAtExactStaleBoundary) {
|
||||
const uint32_t started = 1000;
|
||||
EXPECT_FALSE(QueuePolicy::shouldFlushDisconnected(
|
||||
started + QueuePolicy::kDisconnectedStaleMs - 1, started));
|
||||
EXPECT_TRUE(QueuePolicy::shouldFlushDisconnected(
|
||||
started + QueuePolicy::kDisconnectedStaleMs, started));
|
||||
EXPECT_TRUE(QueuePolicy::shouldFlushDisconnected(
|
||||
started + QueuePolicy::kDisconnectedStaleMs + 1, started));
|
||||
}
|
||||
|
||||
TEST(MQTTPacketQueuePolicy, ZeroDisconnectedTimestampMeansNotStarted) {
|
||||
EXPECT_FALSE(QueuePolicy::shouldFlushDisconnected(UINT32_MAX, 0));
|
||||
}
|
||||
|
||||
TEST(MQTTPacketQueuePolicy, DisconnectedStaleTimerSurvivesMillisWrap) {
|
||||
const uint32_t started = UINT32_MAX - 100;
|
||||
EXPECT_FALSE(QueuePolicy::shouldFlushDisconnected(198, started, 300));
|
||||
EXPECT_TRUE(QueuePolicy::shouldFlushDisconnected(199, started, 300));
|
||||
}
|
||||
|
||||
TEST(MQTTPacketQueuePolicy, DrainIsGentleThroughFivePackets) {
|
||||
for (size_t count = 0; count <= QueuePolicy::kBacklogThreshold; ++count) {
|
||||
const QueuePolicy::DrainBudget budget = QueuePolicy::drainBudget(count);
|
||||
EXPECT_EQ(QueuePolicy::kGentleDrainCount, budget.max_packets) << count;
|
||||
EXPECT_EQ(QueuePolicy::kGentleDrainBudgetMs, budget.max_time_ms) << count;
|
||||
}
|
||||
}
|
||||
|
||||
TEST(MQTTPacketQueuePolicy, DrainBurstsAboveFivePackets) {
|
||||
const QueuePolicy::DrainBudget budget =
|
||||
QueuePolicy::drainBudget(QueuePolicy::kBacklogThreshold + 1);
|
||||
EXPECT_EQ(QueuePolicy::kBurstDrainCount, budget.max_packets);
|
||||
EXPECT_EQ(QueuePolicy::kBurstDrainBudgetMs, budget.max_time_ms);
|
||||
}
|
||||
|
||||
TEST(MQTTPacketQueuePolicy, DrainTimeBudgetUsesInclusiveBoundary) {
|
||||
EXPECT_TRUE(QueuePolicy::drainTimeAvailable(129, 100, 30));
|
||||
EXPECT_TRUE(QueuePolicy::drainTimeAvailable(130, 100, 30));
|
||||
EXPECT_FALSE(QueuePolicy::drainTimeAvailable(131, 100, 30));
|
||||
}
|
||||
|
||||
TEST(MQTTPacketQueuePolicy, DrainTimeBudgetSurvivesMillisWrap) {
|
||||
const uint32_t started = UINT32_MAX - 10;
|
||||
EXPECT_TRUE(QueuePolicy::drainTimeAvailable(19, started, 30));
|
||||
EXPECT_FALSE(QueuePolicy::drainTimeAvailable(20, started, 30));
|
||||
}
|
||||
|
||||
TEST(MQTTPacketQueuePolicy, NewPacketIsReadyWithoutRetryDeadline) {
|
||||
EXPECT_TRUE(QueuePolicy::retryReady(100, 0, 0));
|
||||
EXPECT_TRUE(QueuePolicy::retryReady(100, 500, 0));
|
||||
}
|
||||
|
||||
TEST(MQTTPacketQueuePolicy, RetryBecomesReadyAtExactDeadline) {
|
||||
EXPECT_FALSE(QueuePolicy::retryReady(499, 500, 1));
|
||||
EXPECT_TRUE(QueuePolicy::retryReady(500, 500, 1));
|
||||
EXPECT_TRUE(QueuePolicy::retryReady(501, 500, 1));
|
||||
}
|
||||
|
||||
TEST(MQTTPacketQueuePolicy, RetryDeadlineSurvivesMillisWrap) {
|
||||
const uint32_t deadline = 100;
|
||||
EXPECT_FALSE(QueuePolicy::retryReady(UINT32_MAX - 50, deadline, 1));
|
||||
EXPECT_FALSE(QueuePolicy::retryReady(99, deadline, 1));
|
||||
EXPECT_TRUE(QueuePolicy::retryReady(100, deadline, 1));
|
||||
}
|
||||
|
||||
TEST(MQTTPacketQueuePolicy, WrappedZeroIsARealRetryDeadline) {
|
||||
EXPECT_FALSE(QueuePolicy::retryReady(UINT32_MAX, 0, 1));
|
||||
EXPECT_TRUE(QueuePolicy::retryReady(0, 0, 1));
|
||||
}
|
||||
|
||||
TEST(MQTTPacketQueuePolicy, SuccessfulPublishCompletesWithoutChangingAttempts) {
|
||||
const QueuePolicy::RetryDecision decision =
|
||||
QueuePolicy::retryDecision(true, 2, 1234);
|
||||
EXPECT_EQ(QueuePolicy::RetryAction::Complete, decision.action);
|
||||
EXPECT_EQ(2, decision.retry_attempts);
|
||||
EXPECT_EQ(0U, decision.delay_ms);
|
||||
EXPECT_EQ(0U, decision.next_retry_ms);
|
||||
}
|
||||
|
||||
TEST(MQTTPacketQueuePolicy, FailedPublishSchedulesBoundedRetry) {
|
||||
const QueuePolicy::RetryDecision minimum =
|
||||
QueuePolicy::retryDecision(false, 0, 400);
|
||||
EXPECT_EQ(QueuePolicy::RetryAction::Schedule, minimum.action);
|
||||
EXPECT_EQ(1, minimum.retry_attempts);
|
||||
EXPECT_EQ(300U, minimum.delay_ms);
|
||||
EXPECT_EQ(700U, minimum.next_retry_ms);
|
||||
|
||||
const QueuePolicy::RetryDecision maximum =
|
||||
QueuePolicy::retryDecision(false, 1, 599);
|
||||
EXPECT_EQ(QueuePolicy::RetryAction::Schedule, maximum.action);
|
||||
EXPECT_EQ(2, maximum.retry_attempts);
|
||||
EXPECT_EQ(499U, maximum.delay_ms);
|
||||
EXPECT_EQ(1098U, maximum.next_retry_ms);
|
||||
}
|
||||
|
||||
TEST(MQTTPacketQueuePolicy, ThirdFailedPublishSchedulesFinalRetry) {
|
||||
const QueuePolicy::RetryDecision decision =
|
||||
QueuePolicy::retryDecision(false, 2, 1000);
|
||||
EXPECT_EQ(QueuePolicy::RetryAction::Schedule, decision.action);
|
||||
EXPECT_EQ(QueuePolicy::kMaxQos0RetryAttempts, decision.retry_attempts);
|
||||
}
|
||||
|
||||
TEST(MQTTPacketQueuePolicy, FailureAfterFinalRetryDropsPacket) {
|
||||
const QueuePolicy::RetryDecision decision =
|
||||
QueuePolicy::retryDecision(false, QueuePolicy::kMaxQos0RetryAttempts, 1000);
|
||||
EXPECT_EQ(QueuePolicy::RetryAction::Drop, decision.action);
|
||||
EXPECT_EQ(QueuePolicy::kMaxQos0RetryAttempts, decision.retry_attempts);
|
||||
EXPECT_EQ(0U, decision.delay_ms);
|
||||
EXPECT_EQ(0U, decision.next_retry_ms);
|
||||
}
|
||||
|
||||
TEST(MQTTPacketQueuePolicy, RetrySchedulingDeadlineMayWrapToZero) {
|
||||
// This timestamp has jitter 98, so its 398 ms delay wraps to exactly zero.
|
||||
const uint32_t now = UINT32_MAX - 397;
|
||||
ASSERT_EQ(98U, now % QueuePolicy::kRetryDelayJitterMs);
|
||||
const QueuePolicy::RetryDecision decision =
|
||||
QueuePolicy::retryDecision(false, 0, now);
|
||||
EXPECT_EQ(QueuePolicy::RetryAction::Schedule, decision.action);
|
||||
EXPECT_EQ(398U, decision.delay_ms);
|
||||
EXPECT_EQ(0U, decision.next_retry_ms);
|
||||
EXPECT_FALSE(QueuePolicy::retryReady(UINT32_MAX, decision.next_retry_ms,
|
||||
decision.retry_attempts));
|
||||
EXPECT_TRUE(QueuePolicy::retryReady(0, decision.next_retry_ms,
|
||||
decision.retry_attempts));
|
||||
}
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
::testing::InitGoogleTest(&argc, argv);
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
||||
@@ -0,0 +1,236 @@
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include <ArduinoJson.h>
|
||||
#include <cmath>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "helpers/MQTTPayloadBuilder.h"
|
||||
|
||||
namespace {
|
||||
|
||||
constexpr const char* kTimestamp = "2026-07-18T12:34:56.123456+00:00";
|
||||
|
||||
static int buildMinimalStatus(JsonDocument& scratch, char* buffer, size_t buffer_size) {
|
||||
return MQTTPayloadBuilder::buildStatusMessage(
|
||||
scratch, "DEN Repeater", "0123456789ABCDEF", "Heltec V3", "v1.16.0",
|
||||
"915.000000,62.5,7,5", "MeshCore", "online", kTimestamp,
|
||||
buffer, buffer_size);
|
||||
}
|
||||
|
||||
static int buildRepresentativePacket(JsonDocument& scratch, const char* direction,
|
||||
float score, const uint8_t* path, int path_hops,
|
||||
int path_hash_size, const char* raw,
|
||||
char* buffer, size_t buffer_size) {
|
||||
return MQTTPayloadBuilder::buildPacketMessage(
|
||||
scratch, "DEN Repeater", "0123456789ABCDEF", kTimestamp, direction,
|
||||
"12:34:56", "18/07/2026", 42, 4, "D", 20, raw,
|
||||
10.26f, -87, score, "89ABCDEF01234567", path, path_hops,
|
||||
path_hash_size, 64, buffer, buffer_size);
|
||||
}
|
||||
|
||||
TEST(MQTTPayloadBuilder, MinimalStatusHasExactRequiredContract) {
|
||||
JsonDocument scratch;
|
||||
char buffer[768];
|
||||
int len = buildMinimalStatus(scratch, buffer, sizeof(buffer));
|
||||
|
||||
ASSERT_GT(len, 0);
|
||||
EXPECT_EQ(static_cast<size_t>(len), strlen(buffer));
|
||||
EXPECT_STREQ(
|
||||
"{\"status\":\"online\",\"timestamp\":\"2026-07-18T12:34:56.123456+00:00\","
|
||||
"\"origin\":\"DEN Repeater\",\"origin_id\":\"0123456789ABCDEF\","
|
||||
"\"model\":\"Heltec V3\",\"firmware_version\":\"v1.16.0\","
|
||||
"\"radio\":\"915.000000,62.5,7,5\",\"client_version\":\"MeshCore\"}",
|
||||
buffer);
|
||||
|
||||
JsonDocument parsed;
|
||||
ASSERT_FALSE(deserializeJson(parsed, buffer));
|
||||
EXPECT_FALSE(parsed["repeat"].is<JsonVariant>());
|
||||
EXPECT_FALSE(parsed["stats"].is<JsonVariant>());
|
||||
}
|
||||
|
||||
TEST(MQTTPayloadBuilder, StatusIncludesRepeatAndEveryRequestedStatistic) {
|
||||
JsonDocument scratch;
|
||||
char buffer[1024];
|
||||
int len = MQTTPayloadBuilder::buildStatusMessage(
|
||||
scratch, "node", "id", "model", "firmware", "radio", "client", "online",
|
||||
kTimestamp, buffer, sizeof(buffer), 4200, 86400, 3, 6, -112,
|
||||
11, 22, 4, 180864, 31, 47, "on");
|
||||
|
||||
ASSERT_GT(len, 0);
|
||||
JsonDocument parsed;
|
||||
ASSERT_FALSE(deserializeJson(parsed, buffer));
|
||||
EXPECT_STREQ("on", parsed["repeat"].as<const char*>());
|
||||
JsonObject stats = parsed["stats"].as<JsonObject>();
|
||||
ASSERT_FALSE(stats.isNull());
|
||||
EXPECT_EQ(4200, stats["battery_mv"].as<int>());
|
||||
EXPECT_EQ(86400, stats["uptime_secs"].as<int>());
|
||||
EXPECT_EQ(3, stats["errors"].as<int>());
|
||||
EXPECT_EQ(6, stats["queue_len"].as<int>());
|
||||
EXPECT_EQ(-112, stats["noise_floor"].as<int>());
|
||||
EXPECT_EQ(11, stats["tx_air_secs"].as<int>());
|
||||
EXPECT_EQ(22, stats["rx_air_secs"].as<int>());
|
||||
EXPECT_EQ(4, stats["recv_errors"].as<int>());
|
||||
EXPECT_EQ(180864, stats["internal_heap"].as<int>());
|
||||
EXPECT_EQ(31, stats["packets_sent"].as<int>());
|
||||
EXPECT_EQ(47, stats["packets_received"].as<int>());
|
||||
}
|
||||
|
||||
TEST(MQTTPayloadBuilder, StatusOmissionSentinelsRemainOmitted) {
|
||||
JsonDocument scratch;
|
||||
char buffer[768];
|
||||
int len = MQTTPayloadBuilder::buildStatusMessage(
|
||||
scratch, "node", "id", "model", "firmware", "radio", "client", "online",
|
||||
kTimestamp, buffer, sizeof(buffer), -1, -1, -1, -1, -999,
|
||||
-1, -1, -1, -1, -1, -1, nullptr);
|
||||
|
||||
ASSERT_GT(len, 0);
|
||||
JsonDocument parsed;
|
||||
ASSERT_FALSE(deserializeJson(parsed, buffer));
|
||||
EXPECT_FALSE(parsed["stats"].is<JsonVariant>());
|
||||
EXPECT_FALSE(parsed["repeat"].is<JsonVariant>());
|
||||
}
|
||||
|
||||
TEST(MQTTPayloadBuilder, StringsAreEscapedAndRoundTrip) {
|
||||
const char* origin = "node \"north\"\\rack\nline";
|
||||
const char* model = "Heltec\tV3";
|
||||
JsonDocument scratch;
|
||||
char buffer[1024];
|
||||
int len = MQTTPayloadBuilder::buildStatusMessage(
|
||||
scratch, origin, "id", model, "v1", "radio", "client", "online",
|
||||
kTimestamp, buffer, sizeof(buffer));
|
||||
|
||||
ASSERT_GT(len, 0);
|
||||
EXPECT_NE(std::string::npos, std::string(buffer).find("\\\"north\\\""));
|
||||
EXPECT_NE(std::string::npos, std::string(buffer).find("\\\\rack\\nline"));
|
||||
JsonDocument parsed;
|
||||
ASSERT_FALSE(deserializeJson(parsed, buffer));
|
||||
EXPECT_STREQ(origin, parsed["origin"].as<const char*>());
|
||||
EXPECT_STREQ(model, parsed["model"].as<const char*>());
|
||||
}
|
||||
|
||||
TEST(MQTTPayloadBuilder, RxPacketIncludesMetricsScaledScoreAndPath) {
|
||||
const uint8_t path[] = {0xAA, 0xBB, 0x01, 0x2F};
|
||||
JsonDocument scratch;
|
||||
char buffer[2048];
|
||||
int len = buildRepresentativePacket(
|
||||
scratch, "rx", 0.125f, path, 2, 2, "A0B1C2D3", buffer, sizeof(buffer));
|
||||
|
||||
ASSERT_GT(len, 0);
|
||||
JsonDocument parsed;
|
||||
ASSERT_FALSE(deserializeJson(parsed, buffer));
|
||||
EXPECT_STREQ("PACKET", parsed["type"].as<const char*>());
|
||||
EXPECT_STREQ("rx", parsed["direction"].as<const char*>());
|
||||
EXPECT_STREQ("42", parsed["len"].as<const char*>());
|
||||
EXPECT_STREQ("4", parsed["packet_type"].as<const char*>());
|
||||
EXPECT_STREQ("20", parsed["payload_len"].as<const char*>());
|
||||
EXPECT_STREQ("10.3", parsed["SNR"].as<const char*>());
|
||||
EXPECT_STREQ("-87", parsed["RSSI"].as<const char*>());
|
||||
EXPECT_STREQ("125", parsed["score"].as<const char*>());
|
||||
JsonArray parsed_path = parsed["path"].as<JsonArray>();
|
||||
ASSERT_EQ(2U, parsed_path.size());
|
||||
EXPECT_STREQ("aabb", parsed_path[0].as<const char*>());
|
||||
EXPECT_STREQ("012f", parsed_path[1].as<const char*>());
|
||||
}
|
||||
|
||||
TEST(MQTTPayloadBuilder, TxPacketOmitsReceiveOnlyMetricsAndAbsentPath) {
|
||||
JsonDocument scratch;
|
||||
char buffer[2048];
|
||||
int len = buildRepresentativePacket(
|
||||
scratch, "tx", 0.5f, nullptr, 0, 0, "A0B1", buffer, sizeof(buffer));
|
||||
|
||||
ASSERT_GT(len, 0);
|
||||
JsonDocument parsed;
|
||||
ASSERT_FALSE(deserializeJson(parsed, buffer));
|
||||
EXPECT_FALSE(parsed["SNR"].is<JsonVariant>());
|
||||
EXPECT_FALSE(parsed["RSSI"].is<JsonVariant>());
|
||||
EXPECT_FALSE(parsed["score"].is<JsonVariant>());
|
||||
EXPECT_FALSE(parsed["path"].is<JsonVariant>());
|
||||
}
|
||||
|
||||
TEST(MQTTPayloadBuilder, RxPacketOmitsUnknownNanScore) {
|
||||
JsonDocument scratch;
|
||||
char buffer[2048];
|
||||
int len = buildRepresentativePacket(
|
||||
scratch, "rx", std::nanf(""), nullptr, 0, 0, "A0B1", buffer, sizeof(buffer));
|
||||
|
||||
ASSERT_GT(len, 0);
|
||||
JsonDocument parsed;
|
||||
ASSERT_FALSE(deserializeJson(parsed, buffer));
|
||||
EXPECT_TRUE(parsed["SNR"].is<const char*>());
|
||||
EXPECT_TRUE(parsed["RSSI"].is<const char*>());
|
||||
EXPECT_FALSE(parsed["score"].is<JsonVariant>());
|
||||
}
|
||||
|
||||
TEST(MQTTPayloadBuilder, RawMessageHasExactContractAndEscapesData) {
|
||||
char buffer[512];
|
||||
int len = MQTTPayloadBuilder::buildRawMessage(
|
||||
"node \"A\"", "id\\1", kTimestamp, "AA\nBB", buffer, sizeof(buffer));
|
||||
|
||||
ASSERT_GT(len, 0);
|
||||
EXPECT_EQ(static_cast<size_t>(len), strlen(buffer));
|
||||
EXPECT_STREQ(
|
||||
"{\"origin\":\"node \\\"A\\\"\",\"origin_id\":\"id\\\\1\","
|
||||
"\"timestamp\":\"2026-07-18T12:34:56.123456+00:00\","
|
||||
"\"type\":\"RAW\",\"data\":\"AA\\nBB\"}",
|
||||
buffer);
|
||||
JsonDocument parsed;
|
||||
ASSERT_FALSE(deserializeJson(parsed, buffer));
|
||||
EXPECT_STREQ("AA\nBB", parsed["data"].as<const char*>());
|
||||
}
|
||||
|
||||
TEST(MQTTPayloadBuilder, ExactOutputSizeSucceedsAndOneByteShortFailsCleanly) {
|
||||
JsonDocument scratch;
|
||||
char reference[768];
|
||||
int reference_len = buildMinimalStatus(scratch, reference, sizeof(reference));
|
||||
ASSERT_GT(reference_len, 0);
|
||||
|
||||
std::vector<char> exact(static_cast<size_t>(reference_len) + 1);
|
||||
EXPECT_EQ(reference_len, buildMinimalStatus(scratch, exact.data(), exact.size()));
|
||||
EXPECT_STREQ(reference, exact.data());
|
||||
|
||||
std::vector<char> short_buffer(static_cast<size_t>(reference_len), 'x');
|
||||
EXPECT_EQ(0, buildMinimalStatus(scratch, short_buffer.data(), short_buffer.size()));
|
||||
EXPECT_EQ('\0', short_buffer[0]);
|
||||
EXPECT_EQ(0, buildMinimalStatus(scratch, short_buffer.data(), 1));
|
||||
EXPECT_EQ('\0', short_buffer[0]);
|
||||
EXPECT_EQ(0, buildMinimalStatus(scratch, nullptr, exact.size()));
|
||||
}
|
||||
|
||||
TEST(MQTTPayloadBuilder, MaximumRepresentativePacketAndRawPayloadsRemainValid) {
|
||||
uint8_t path[64];
|
||||
for (size_t i = 0; i < sizeof(path); ++i) path[i] = static_cast<uint8_t>(i);
|
||||
std::string raw(510, 'A');
|
||||
|
||||
JsonDocument scratch;
|
||||
char packet_buffer[2048];
|
||||
int packet_len = buildRepresentativePacket(
|
||||
scratch, "rx", 1.0f, path, 16, 4, raw.c_str(),
|
||||
packet_buffer, sizeof(packet_buffer));
|
||||
ASSERT_GT(packet_len, 0);
|
||||
JsonDocument packet;
|
||||
ASSERT_FALSE(deserializeJson(packet, packet_buffer));
|
||||
EXPECT_EQ(510U, strlen(packet["raw"].as<const char*>()));
|
||||
JsonArray parsed_path = packet["path"].as<JsonArray>();
|
||||
ASSERT_EQ(16U, parsed_path.size());
|
||||
EXPECT_STREQ("00010203", parsed_path[0].as<const char*>());
|
||||
EXPECT_STREQ("3c3d3e3f", parsed_path[15].as<const char*>());
|
||||
|
||||
char raw_buffer[1024];
|
||||
int raw_len = MQTTPayloadBuilder::buildRawMessage(
|
||||
"node", "0123456789ABCDEF", kTimestamp, raw.c_str(),
|
||||
raw_buffer, sizeof(raw_buffer));
|
||||
ASSERT_GT(raw_len, 0);
|
||||
JsonDocument parsed_raw;
|
||||
ASSERT_FALSE(deserializeJson(parsed_raw, raw_buffer));
|
||||
EXPECT_EQ(510U, strlen(parsed_raw["data"].as<const char*>()));
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
::testing::InitGoogleTest(&argc, argv);
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
||||
|
||||
@@ -0,0 +1,179 @@
|
||||
// Host contract tests for the complete MQTT publication-topic routing policy.
|
||||
#define WITH_MQTT_BRIDGE 1
|
||||
#define PROGMEM
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
|
||||
#include "helpers/MQTTPresets.h"
|
||||
#include "helpers/MQTTTopicRouter.h"
|
||||
|
||||
namespace {
|
||||
|
||||
constexpr const char* IATA = "DEN";
|
||||
constexpr const char* DEVICE = "0123456789ABCDEF";
|
||||
constexpr const char* TOKEN = "account-token";
|
||||
|
||||
struct TypeCase {
|
||||
int type;
|
||||
const char* name;
|
||||
};
|
||||
|
||||
const TypeCase kTypes[] = {
|
||||
{MQTT_PUBLICATION_STATUS, "status"},
|
||||
{MQTT_PUBLICATION_PACKETS, "packets"},
|
||||
{MQTT_PUBLICATION_RAW, "raw"},
|
||||
};
|
||||
|
||||
TEST(MQTTTopicRouter, EveryMeshCorePresetSupportsEveryPublicationType) {
|
||||
for (int preset_index = 0; preset_index < MQTT_PRESET_COUNT; ++preset_index) {
|
||||
const MQTTPresetDef& preset = MQTT_PRESETS[preset_index];
|
||||
if (preset.topic_style != MQTT_TOPIC_MESHCORE) continue;
|
||||
|
||||
for (const TypeCase& type : kTypes) {
|
||||
char topic[128];
|
||||
ASSERT_TRUE(mqttBuildPublicationTopic(MQTT_ROUTE_MESHCORE, type.type, nullptr,
|
||||
IATA, DEVICE, TOKEN, topic, sizeof(topic)))
|
||||
<< preset.name << " / " << type.name;
|
||||
EXPECT_EQ(std::string("meshcore/DEN/0123456789ABCDEF/") + type.name, topic)
|
||||
<< preset.name;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(MQTTTopicRouter, MeshRankContractIsPacketsOnly) {
|
||||
const MQTTPresetDef* preset = findMQTTPreset("meshrank");
|
||||
ASSERT_NE(nullptr, preset);
|
||||
ASSERT_EQ(MQTT_TOPIC_MESHRANK, preset->topic_style);
|
||||
|
||||
char topic[128];
|
||||
EXPECT_FALSE(mqttBuildPublicationTopic(MQTT_ROUTE_MESHRANK, MQTT_PUBLICATION_STATUS,
|
||||
nullptr, IATA, DEVICE, TOKEN, topic, sizeof(topic)));
|
||||
EXPECT_STREQ("", topic);
|
||||
ASSERT_TRUE(mqttBuildPublicationTopic(MQTT_ROUTE_MESHRANK, MQTT_PUBLICATION_PACKETS,
|
||||
nullptr, IATA, DEVICE, TOKEN, topic, sizeof(topic)));
|
||||
EXPECT_STREQ("meshrank/uplink/account-token/0123456789ABCDEF/packets", topic);
|
||||
EXPECT_FALSE(mqttBuildPublicationTopic(MQTT_ROUTE_MESHRANK, MQTT_PUBLICATION_RAW,
|
||||
nullptr, IATA, DEVICE, TOKEN, topic, sizeof(topic)));
|
||||
EXPECT_STREQ("", topic);
|
||||
}
|
||||
|
||||
TEST(MQTTTopicRouter, MeshCoreRequiresUsableIataAndDevice) {
|
||||
char topic[64];
|
||||
const char* invalid_iatas[] = {nullptr, "", "XX", "XXXX", "X/X", "XXX"};
|
||||
for (const char* iata : invalid_iatas) {
|
||||
EXPECT_FALSE(mqttBuildPublicationTopic(MQTT_ROUTE_MESHCORE, MQTT_PUBLICATION_STATUS,
|
||||
nullptr, iata, DEVICE, TOKEN, topic, sizeof(topic)));
|
||||
EXPECT_STREQ("", topic);
|
||||
}
|
||||
EXPECT_FALSE(mqttBuildPublicationTopic(MQTT_ROUTE_MESHCORE, MQTT_PUBLICATION_STATUS,
|
||||
nullptr, IATA, nullptr, TOKEN, topic, sizeof(topic)));
|
||||
EXPECT_FALSE(mqttBuildPublicationTopic(MQTT_ROUTE_MESHCORE, MQTT_PUBLICATION_STATUS,
|
||||
nullptr, IATA, "", TOKEN, topic, sizeof(topic)));
|
||||
}
|
||||
|
||||
TEST(MQTTTopicRouter, MeshRankRequiresTokenAndDeviceButNotIata) {
|
||||
char topic[128];
|
||||
const char* missing_tokens[] = {nullptr, ""};
|
||||
for (const char* token : missing_tokens) {
|
||||
EXPECT_FALSE(mqttBuildPublicationTopic(MQTT_ROUTE_MESHRANK, MQTT_PUBLICATION_PACKETS,
|
||||
nullptr, nullptr, DEVICE, token, topic, sizeof(topic)));
|
||||
EXPECT_STREQ("", topic);
|
||||
}
|
||||
EXPECT_FALSE(mqttBuildPublicationTopic(MQTT_ROUTE_MESHRANK, MQTT_PUBLICATION_PACKETS,
|
||||
nullptr, nullptr, nullptr, TOKEN, topic, sizeof(topic)));
|
||||
EXPECT_TRUE(mqttBuildPublicationTopic(MQTT_ROUTE_MESHRANK, MQTT_PUBLICATION_PACKETS,
|
||||
nullptr, nullptr, DEVICE, TOKEN, topic, sizeof(topic)));
|
||||
}
|
||||
|
||||
TEST(MQTTTopicRouter, CustomTemplateExpandsEveryType) {
|
||||
for (const TypeCase& type : kTypes) {
|
||||
char topic[128];
|
||||
ASSERT_TRUE(mqttBuildPublicationTopic(
|
||||
MQTT_ROUTE_CUSTOM, type.type, "custom/{iata}/{token}/{device}/{type}",
|
||||
IATA, DEVICE, TOKEN, topic, sizeof(topic)));
|
||||
EXPECT_EQ(std::string("custom/DEN/account-token/0123456789ABCDEF/") + type.name, topic);
|
||||
}
|
||||
}
|
||||
|
||||
TEST(MQTTTopicRouter, CustomLiteralDoesNotRequireIataTokenOrDevice) {
|
||||
char topic[32];
|
||||
ASSERT_TRUE(mqttBuildPublicationTopic(MQTT_ROUTE_CUSTOM, MQTT_PUBLICATION_RAW,
|
||||
"private/raw", nullptr, nullptr, nullptr,
|
||||
topic, sizeof(topic)));
|
||||
EXPECT_STREQ("private/raw", topic);
|
||||
}
|
||||
|
||||
TEST(MQTTTopicRouter, EmptyCustomTemplateFailsRatherThanFallingBackImplicitly) {
|
||||
char topic[64];
|
||||
EXPECT_FALSE(mqttBuildPublicationTopic(MQTT_ROUTE_CUSTOM, MQTT_PUBLICATION_STATUS,
|
||||
"", IATA, DEVICE, TOKEN, topic, sizeof(topic)));
|
||||
EXPECT_STREQ("", topic);
|
||||
|
||||
// MQTTBridge selects the MeshCore style explicitly for a custom slot whose
|
||||
// template is empty; make that default contract visible here.
|
||||
EXPECT_TRUE(mqttBuildPublicationTopic(MQTT_ROUTE_MESHCORE, MQTT_PUBLICATION_STATUS,
|
||||
nullptr, IATA, DEVICE, TOKEN, topic, sizeof(topic)));
|
||||
EXPECT_STREQ("meshcore/DEN/0123456789ABCDEF/status", topic);
|
||||
}
|
||||
|
||||
TEST(MQTTTopicRouter, FormattedTopicsRequireRoomForTerminator) {
|
||||
const char* expected = "meshcore/DEN/0123456789ABCDEF/status";
|
||||
const size_t exact_size = strlen(expected) + 1;
|
||||
char exact[64];
|
||||
ASSERT_LE(exact_size, sizeof(exact));
|
||||
EXPECT_TRUE(mqttBuildPublicationTopic(MQTT_ROUTE_MESHCORE, MQTT_PUBLICATION_STATUS,
|
||||
nullptr, IATA, DEVICE, TOKEN, exact, exact_size));
|
||||
EXPECT_STREQ(expected, exact);
|
||||
|
||||
char short_buf[64];
|
||||
memset(short_buf, 0x7f, sizeof(short_buf));
|
||||
EXPECT_FALSE(mqttBuildPublicationTopic(MQTT_ROUTE_MESHCORE, MQTT_PUBLICATION_STATUS,
|
||||
nullptr, IATA, DEVICE, TOKEN,
|
||||
short_buf, exact_size - 1));
|
||||
EXPECT_EQ('\0', short_buf[exact_size - 2]);
|
||||
}
|
||||
|
||||
TEST(MQTTTopicRouter, CustomTopicHonorsExactBoundary) {
|
||||
const char* expected = "custom/DEN/raw";
|
||||
char exact[15];
|
||||
static_assert(sizeof(exact) == 15, "fixture includes the terminator");
|
||||
EXPECT_TRUE(mqttBuildPublicationTopic(MQTT_ROUTE_CUSTOM, MQTT_PUBLICATION_RAW,
|
||||
"custom/{iata}/{type}", IATA, DEVICE, TOKEN,
|
||||
exact, sizeof(exact)));
|
||||
EXPECT_STREQ(expected, exact);
|
||||
|
||||
char short_buf[14];
|
||||
EXPECT_FALSE(mqttBuildPublicationTopic(MQTT_ROUTE_CUSTOM, MQTT_PUBLICATION_RAW,
|
||||
"custom/{iata}/{type}", IATA, DEVICE, TOKEN,
|
||||
short_buf, sizeof(short_buf)));
|
||||
EXPECT_LT(strlen(short_buf), sizeof(short_buf));
|
||||
}
|
||||
|
||||
TEST(MQTTTopicRouter, RejectsInvalidStyleTypeSlotAndOutput) {
|
||||
char topic[64] = "dirty";
|
||||
EXPECT_FALSE(mqttBuildPublicationTopic(MQTT_ROUTE_MESHCORE, 99, nullptr,
|
||||
IATA, DEVICE, TOKEN, topic, sizeof(topic)));
|
||||
EXPECT_STREQ("", topic);
|
||||
EXPECT_FALSE(mqttBuildPublicationTopic(static_cast<MQTTTopicRouteStyle>(99),
|
||||
MQTT_PUBLICATION_STATUS, nullptr,
|
||||
IATA, DEVICE, TOKEN, topic, sizeof(topic)));
|
||||
EXPECT_FALSE(mqttBuildPublicationTopic(MQTT_ROUTE_MESHCORE, MQTT_PUBLICATION_STATUS,
|
||||
nullptr, IATA, DEVICE, TOKEN, nullptr, 64));
|
||||
EXPECT_FALSE(mqttBuildPublicationTopic(MQTT_ROUTE_MESHCORE, MQTT_PUBLICATION_STATUS,
|
||||
nullptr, IATA, DEVICE, TOKEN, topic, 0));
|
||||
|
||||
EXPECT_FALSE(mqttTopicSlotIndexValid(-1, RUNTIME_MQTT_SLOTS));
|
||||
EXPECT_TRUE(mqttTopicSlotIndexValid(0, RUNTIME_MQTT_SLOTS));
|
||||
EXPECT_TRUE(mqttTopicSlotIndexValid(RUNTIME_MQTT_SLOTS - 1, RUNTIME_MQTT_SLOTS));
|
||||
EXPECT_FALSE(mqttTopicSlotIndexValid(RUNTIME_MQTT_SLOTS, RUNTIME_MQTT_SLOTS));
|
||||
EXPECT_FALSE(mqttTopicSlotIndexValid(0, 0));
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
::testing::InitGoogleTest(&argc, argv);
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
||||
Reference in new issue
Block a user