mirror of
https://github.com/torlando-tech/pyxis.git
synced 2026-08-16 15:50:11 +00:00
300 lines
14 KiB
C++
300 lines
14 KiB
C++
#include <cstddef>
|
|
#include <cstdint>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <iostream>
|
|
#include <limits>
|
|
|
|
#include "Telemetry/LocationMessagePolicy.h"
|
|
|
|
namespace {
|
|
|
|
int passed = 0;
|
|
int failures = 0;
|
|
|
|
#define CHECK(expr) do { if (expr) { ++passed; } else { ++failures; std::cerr << "FAIL line " << __LINE__ << ": " #expr << '\n'; } } while (false)
|
|
|
|
Telemetry::PeerId peer(uint8_t seed) {
|
|
Telemetry::PeerId id{};
|
|
for (std::size_t i = 0; i < Telemetry::PEER_ID_SIZE; ++i) {
|
|
id.bytes[i] = static_cast<uint8_t>(seed + static_cast<uint8_t>(i));
|
|
}
|
|
return id;
|
|
}
|
|
|
|
struct Fields {
|
|
uint8_t inner[128]{};
|
|
uint8_t telemetry[132]{};
|
|
uint8_t meta[128]{};
|
|
std::size_t telemetry_size = 0;
|
|
std::size_t meta_size = 0;
|
|
};
|
|
|
|
Fields validFields(uint64_t timestamp, bool with_meta = false, bool cease = false) {
|
|
Fields fields{};
|
|
Telemetry::LocationTelemetry location{};
|
|
location.latitude_e6 = 12345678;
|
|
location.longitude_e6 = -87654321;
|
|
location.altitude_cm = 1234;
|
|
location.speed_centi_kmh = 560;
|
|
location.bearing_cdeg = 9000;
|
|
location.accuracy_cm = 50;
|
|
location.timestamp_seconds = timestamp;
|
|
location.sensor_timestamp_seconds = timestamp + 1U;
|
|
std::size_t inner_size = 0;
|
|
CHECK(Telemetry::encodeLocationTelemetry(location, fields.inner, sizeof(fields.inner), inner_size) == Telemetry::EncodeResult::OK);
|
|
CHECK(Telemetry::wrapLxmfBinaryFieldValue(fields.inner, inner_size, fields.telemetry, sizeof(fields.telemetry), fields.telemetry_size) == Telemetry::FieldValueResult::OK);
|
|
if (with_meta) {
|
|
Telemetry::CustomLocationMeta meta{};
|
|
meta.has_cease = true;
|
|
meta.cease = cease;
|
|
meta.has_timestamp = true;
|
|
meta.timestamp_millis = static_cast<int64_t>(timestamp * 1000U);
|
|
uint8_t encoded_meta[96]{};
|
|
std::size_t encoded_meta_size = 0;
|
|
CHECK(Telemetry::encodeCustomLocationMeta(
|
|
meta, encoded_meta, sizeof(encoded_meta), encoded_meta_size) ==
|
|
Telemetry::CustomMetaResult::OK);
|
|
CHECK(Telemetry::wrapLxmfBinaryFieldValue(
|
|
encoded_meta, encoded_meta_size,
|
|
fields.meta, sizeof(fields.meta), fields.meta_size) ==
|
|
Telemetry::FieldValueResult::OK);
|
|
}
|
|
return fields;
|
|
}
|
|
|
|
Telemetry::InboundLocationMessage input(const Telemetry::PeerId& sender, const Fields& fields) {
|
|
Telemetry::InboundLocationMessage value{};
|
|
value.authenticated_sender = sender;
|
|
value.telemetry.present = true;
|
|
value.telemetry.raw_value = Telemetry::BinaryView(fields.telemetry, fields.telemetry_size);
|
|
value.received_at_millis = 50000;
|
|
return value;
|
|
}
|
|
|
|
class FakeEffects : public Telemetry::LocationMessageEffects {
|
|
public:
|
|
Telemetry::PeerLocationStore store{};
|
|
char calls[256]{};
|
|
std::size_t count = 0;
|
|
bool persist_ok = true;
|
|
Telemetry::PeerId applied_sender{};
|
|
|
|
Telemetry::PeerLocationResult applyLocation(const Telemetry::PeerId& sender,
|
|
const Telemetry::LocationTelemetry& location,
|
|
const Telemetry::CustomLocationMeta& meta,
|
|
uint64_t received_at_millis) override {
|
|
calls[count++] = 'L';
|
|
applied_sender = sender;
|
|
return store.apply(sender, location, meta, received_at_millis);
|
|
}
|
|
bool persistMessage() override { calls[count++] = 'P'; return persist_ok; }
|
|
void routeMessage() override { calls[count++] = 'R'; }
|
|
void notifyMessage() override { calls[count++] = 'N'; }
|
|
void logMalformedLocation() override { calls[count++] = 'E'; }
|
|
};
|
|
|
|
bool samePeer(const Telemetry::PeerId& a, const Telemetry::PeerId& b) {
|
|
return std::memcmp(a.bytes, b.bytes, Telemetry::PEER_ID_SIZE) == 0;
|
|
}
|
|
|
|
void validTelemetryPolicyMatrixAndOrdering() {
|
|
const Telemetry::PeerId sender = peer(1);
|
|
Fields fields = validFields(10);
|
|
Telemetry::InboundLocationMessage message = input(sender, fields);
|
|
|
|
Telemetry::LocationMessageDecision decision = Telemetry::classifyInboundLocationMessage(message);
|
|
CHECK(decision.kind == Telemetry::LocationMessageKind::VALID_LOCATION);
|
|
CHECK(decision.apply_location && !decision.persist && !decision.route && !decision.notify);
|
|
CHECK(!decision.drop && !decision.log_malformed);
|
|
CHECK(samePeer(decision.authenticated_sender, sender));
|
|
|
|
FakeEffects effects;
|
|
Telemetry::LocationMessageExecution result = Telemetry::executeLocationMessageDecision(decision, effects);
|
|
CHECK(result.location_result == Telemetry::PeerLocationResult::INSERTED);
|
|
CHECK(effects.count == 1 && effects.calls[0] == 'L');
|
|
|
|
message.title = Telemetry::TextField(true, nullptr, 0); // present but empty
|
|
message.content = Telemetry::TextField(true, reinterpret_cast<const uint8_t*>("hello"), 5);
|
|
decision = Telemetry::classifyInboundLocationMessage(message);
|
|
CHECK(decision.apply_location && decision.persist && decision.route && decision.notify);
|
|
FakeEffects mixed;
|
|
result = Telemetry::executeLocationMessageDecision(decision, mixed);
|
|
CHECK(result.persisted);
|
|
CHECK(mixed.count == 4 && std::memcmp(mixed.calls, "LPRN", 4) == 0);
|
|
|
|
message.content = Telemetry::TextField(false, nullptr, 0);
|
|
message.title = Telemetry::TextField(true, reinterpret_cast<const uint8_t*>("title"), 5);
|
|
decision = Telemetry::classifyInboundLocationMessage(message);
|
|
CHECK(decision.apply_location && decision.persist && decision.route && decision.notify);
|
|
}
|
|
|
|
void absenceEmptyAndNonLocationCases() {
|
|
Telemetry::InboundLocationMessage message{};
|
|
message.authenticated_sender = peer(2);
|
|
Telemetry::LocationMessageDecision decision = Telemetry::classifyInboundLocationMessage(message);
|
|
CHECK(decision.kind == Telemetry::LocationMessageKind::NOT_LOCATION);
|
|
CHECK(!decision.apply_location && decision.persist && decision.route && decision.notify);
|
|
|
|
message.title = Telemetry::TextField(true, nullptr, 0);
|
|
message.content = Telemetry::TextField(true, nullptr, 0);
|
|
decision = Telemetry::classifyInboundLocationMessage(message);
|
|
CHECK(decision.kind == Telemetry::LocationMessageKind::NOT_LOCATION);
|
|
CHECK(decision.persist && decision.notify);
|
|
|
|
const uint8_t malformed_meta[] = {0x81U};
|
|
message.custom_meta.present = true;
|
|
message.custom_meta.raw_value = Telemetry::BinaryView(malformed_meta, sizeof(malformed_meta));
|
|
decision = Telemetry::classifyInboundLocationMessage(message);
|
|
CHECK(decision.kind == Telemetry::LocationMessageKind::NOT_LOCATION);
|
|
CHECK(decision.persist && !decision.log_malformed);
|
|
}
|
|
|
|
void malformedLocationFailsClosedButTextSurvives() {
|
|
Telemetry::InboundLocationMessage empty_field{};
|
|
empty_field.authenticated_sender = peer(3);
|
|
empty_field.telemetry.present = true;
|
|
Telemetry::LocationMessageDecision empty_decision =
|
|
Telemetry::classifyInboundLocationMessage(empty_field);
|
|
CHECK(empty_decision.kind == Telemetry::LocationMessageKind::MALFORMED_LOCATION);
|
|
CHECK(empty_decision.drop && empty_decision.log_malformed);
|
|
|
|
const uint8_t non_bin[] = {0x80U};
|
|
Telemetry::InboundLocationMessage message{};
|
|
message.authenticated_sender = peer(3);
|
|
message.telemetry.present = true;
|
|
message.telemetry.raw_value = Telemetry::BinaryView(non_bin, sizeof(non_bin));
|
|
Telemetry::LocationMessageDecision decision = Telemetry::classifyInboundLocationMessage(message);
|
|
CHECK(decision.kind == Telemetry::LocationMessageKind::MALFORMED_LOCATION);
|
|
CHECK(!decision.apply_location && !decision.persist && !decision.notify);
|
|
CHECK(decision.drop && decision.log_malformed);
|
|
FakeEffects empty;
|
|
Telemetry::executeLocationMessageDecision(decision, empty);
|
|
CHECK(empty.count == 1 && empty.calls[0] == 'E');
|
|
|
|
message.content = Telemetry::TextField(true, reinterpret_cast<const uint8_t*>("x"), 1);
|
|
decision = Telemetry::classifyInboundLocationMessage(message);
|
|
CHECK(!decision.apply_location && decision.persist && decision.route && decision.notify);
|
|
CHECK(!decision.drop && decision.log_malformed);
|
|
FakeEffects text;
|
|
Telemetry::executeLocationMessageDecision(decision, text);
|
|
CHECK(text.count == 4 && std::memcmp(text.calls, "EPRN", 4) == 0);
|
|
|
|
Fields fields = validFields(12);
|
|
message = input(peer(3), fields);
|
|
const uint8_t malformed_meta[] = {0x81U, 0xa5U, 'c', 'e', 'a', 's', 'e'};
|
|
message.custom_meta.present = true;
|
|
message.custom_meta.raw_value = Telemetry::BinaryView(malformed_meta, sizeof(malformed_meta));
|
|
decision = Telemetry::classifyInboundLocationMessage(message);
|
|
CHECK(decision.kind == Telemetry::LocationMessageKind::MALFORMED_LOCATION);
|
|
CHECK(!decision.apply_location && decision.drop && decision.log_malformed);
|
|
|
|
message.telemetry.raw_value = Telemetry::BinaryView(nullptr, 1);
|
|
decision = Telemetry::classifyInboundLocationMessage(message);
|
|
CHECK(decision.kind == Telemetry::LocationMessageKind::MALFORMED_LOCATION);
|
|
CHECK(!decision.apply_location);
|
|
|
|
Fields unusable_timestamp =
|
|
validFields(std::numeric_limits<uint64_t>::max());
|
|
message = input(peer(3), unusable_timestamp);
|
|
decision = Telemetry::classifyInboundLocationMessage(message);
|
|
CHECK(decision.kind == Telemetry::LocationMessageKind::MALFORMED_LOCATION);
|
|
CHECK(!decision.apply_location && decision.drop && decision.log_malformed);
|
|
}
|
|
|
|
void ceaseAndAuthenticatedSenderIsolation() {
|
|
const Telemetry::PeerId first = peer(10);
|
|
const Telemetry::PeerId second = peer(40);
|
|
Fields ordinary = validFields(20);
|
|
FakeEffects effects;
|
|
Telemetry::executeLocationMessageDecision(Telemetry::classifyInboundLocationMessage(input(first, ordinary)), effects);
|
|
Telemetry::executeLocationMessageDecision(Telemetry::classifyInboundLocationMessage(input(second, ordinary)), effects);
|
|
CHECK(effects.store.size() == 2);
|
|
|
|
Fields cease = validFields(20, true, true);
|
|
Telemetry::InboundLocationMessage cease_message = input(first, cease);
|
|
cease_message.custom_meta.present = true;
|
|
cease_message.custom_meta.raw_value = Telemetry::BinaryView(cease.meta, cease.meta_size);
|
|
Telemetry::LocationMessageDecision decision = Telemetry::classifyInboundLocationMessage(cease_message);
|
|
CHECK(decision.kind == Telemetry::LocationMessageKind::VALID_CEASE);
|
|
CHECK(decision.apply_location && !decision.persist && !decision.notify);
|
|
Telemetry::executeLocationMessageDecision(decision, effects);
|
|
Telemetry::PeerLocationRecord record{};
|
|
CHECK(!effects.store.get(first, record));
|
|
CHECK(effects.store.get(second, record));
|
|
CHECK(samePeer(effects.applied_sender, first));
|
|
|
|
Fields cease_false = validFields(21, true, false);
|
|
Telemetry::InboundLocationMessage false_message = input(first, cease_false);
|
|
false_message.custom_meta.present = true;
|
|
false_message.custom_meta.raw_value =
|
|
Telemetry::BinaryView(cease_false.meta, cease_false.meta_size);
|
|
decision = Telemetry::classifyInboundLocationMessage(false_message);
|
|
CHECK(decision.kind == Telemetry::LocationMessageKind::VALID_LOCATION);
|
|
CHECK(decision.apply_location);
|
|
|
|
cease_message.content = Telemetry::TextField(true, reinterpret_cast<const uint8_t*>("stopped"), 7);
|
|
decision = Telemetry::classifyInboundLocationMessage(cease_message);
|
|
CHECK(decision.apply_location && decision.persist && decision.route && decision.notify);
|
|
}
|
|
|
|
void staleDuplicateCapacityAndPersistenceFailure() {
|
|
FakeEffects effects;
|
|
for (std::size_t i = 0; i < Telemetry::MAX_PEER_LOCATIONS + 1U; ++i) {
|
|
Fields fields = validFields(100U + static_cast<uint64_t>(i));
|
|
Telemetry::InboundLocationMessage message = input(peer(static_cast<uint8_t>(i)), fields);
|
|
message.received_at_millis = static_cast<uint64_t>(i);
|
|
Telemetry::executeLocationMessageDecision(Telemetry::classifyInboundLocationMessage(message), effects);
|
|
}
|
|
CHECK(effects.store.size() == Telemetry::MAX_PEER_LOCATIONS);
|
|
Telemetry::PeerLocationRecord record{};
|
|
CHECK(!effects.store.get(peer(0), record));
|
|
CHECK(effects.store.get(peer(static_cast<uint8_t>(Telemetry::MAX_PEER_LOCATIONS)), record));
|
|
|
|
Fields newer = validFields(500);
|
|
Telemetry::InboundLocationMessage message = input(peer(99), newer);
|
|
Telemetry::executeLocationMessageDecision(Telemetry::classifyInboundLocationMessage(message), effects);
|
|
Fields stale = validFields(499);
|
|
message = input(peer(99), stale);
|
|
Telemetry::LocationMessageExecution execution = Telemetry::executeLocationMessageDecision(Telemetry::classifyInboundLocationMessage(message), effects);
|
|
CHECK(execution.location_result == Telemetry::PeerLocationResult::STALE);
|
|
|
|
Fields fields = validFields(700);
|
|
message = input(peer(100), fields);
|
|
message.content = Telemetry::TextField(true, reinterpret_cast<const uint8_t*>("chat"), 4);
|
|
FakeEffects failed;
|
|
failed.persist_ok = false;
|
|
execution = Telemetry::executeLocationMessageDecision(Telemetry::classifyInboundLocationMessage(message), failed);
|
|
CHECK(!execution.persisted);
|
|
CHECK(failed.count == 2 && std::memcmp(failed.calls, "LP", 2) == 0);
|
|
}
|
|
|
|
void sanitizerStressAndBounds() {
|
|
CHECK(sizeof(Telemetry::LocationMessageDecision) <= 160U);
|
|
CHECK(sizeof(Telemetry::InboundLocationMessage) <= 128U);
|
|
uint8_t fuzz[32]{};
|
|
for (std::size_t i = 0; i < 100000U; ++i) {
|
|
for (std::size_t j = 0; j < sizeof(fuzz); ++j) fuzz[j] = static_cast<uint8_t>(i + j * 17U);
|
|
Telemetry::InboundLocationMessage message{};
|
|
message.authenticated_sender = peer(static_cast<uint8_t>(i));
|
|
message.telemetry.present = true;
|
|
message.telemetry.raw_value = Telemetry::BinaryView(fuzz, i % sizeof(fuzz));
|
|
if ((i & 1U) != 0U) message.content = Telemetry::TextField(true, fuzz, 1);
|
|
const Telemetry::LocationMessageDecision decision = Telemetry::classifyInboundLocationMessage(message);
|
|
CHECK(!decision.apply_location || decision.kind == Telemetry::LocationMessageKind::VALID_LOCATION || decision.kind == Telemetry::LocationMessageKind::VALID_CEASE);
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
|
|
int main() {
|
|
validTelemetryPolicyMatrixAndOrdering();
|
|
absenceEmptyAndNonLocationCases();
|
|
malformedLocationFailsClosedButTextSurvives();
|
|
ceaseAndAuthenticatedSenderIsolation();
|
|
staleDuplicateCapacityAndPersistenceFailure();
|
|
sanitizerStressAndBounds();
|
|
std::cout << "location message policy: " << passed << " passed, " << failures << " failed\n";
|
|
return failures == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
|
|
}
|