#include "evo/network/session_protocol.hpp" #include #include #include #include #include namespace { using namespace evo::network; void check(bool value, std::source_location at = std::source_location::current()) { if (!value) throw std::runtime_error("cellular intent protocol line " + std::to_string(at.line())); } #define CHECK(...) check(static_cast(__VA_ARGS__)) void round_trip_and_version_gate() { const CellularIntention targeted{17, 23, 29, 31, -707, 707, true, 4'000, 5'000}; const SessionMessage message{targeted}; const auto bytes = encode_session(message); CHECK(!bytes.empty() && bytes.size() == session_header_bytes + 48); std::uint16_t version{}; const auto decoded = decode_session(bytes, &version); CHECK(decoded && version == session_protocol_v6); CHECK(std::get(*decoded) == targeted); CHECK(encode_session(*decoded) == bytes); CHECK(encode_session(message, session_protocol_v5).empty()); const CellularIntention no_target{1, 2, 3, 4, 0, -1, false, 0, 0}; const auto no_target_bytes = encode_session(SessionMessage{no_target}); CHECK(std::get(*decode_session(no_target_bytes)) == no_target); } void malformed_frames_are_refused() { const auto bytes = encode_session(SessionMessage{CellularIntention{1, 2, 3, 4, 0, 0, true, 1'000, 2'000}}); for (std::size_t size = 0; size < bytes.size(); ++size) { const auto truncated = decode_session(std::span{bytes}.first(size)); CHECK(!truncated); CHECK(truncated.error() == (size < session_header_bytes ? SessionCodecError::truncated : SessionCodecError::wrong_length)); } auto bad = bytes; bad.at(6) = 255; // Unknown message type. const auto wrong_type = decode_session(bad); CHECK(!wrong_type && wrong_type.error() == SessionCodecError::unknown_type); bad = bytes; bad.at(session_header_bytes + 36) = 2; const auto bad_flag = decode_session(bad); CHECK(!bad_flag && bad_flag.error() == SessionCodecError::invalid_value); bad = bytes; bad.at(session_header_bytes + 38) = 1; const auto bad_reserved = decode_session(bad); CHECK(!bad_reserved && bad_reserved.error() == SessionCodecError::invalid_value); bad = encode_session(SessionMessage{CellularIntention{1, 2, 3, 4, 0, 0, false, 0, 0}}); bad.at(session_header_bytes + 40) = 1; // Coordinates must be zero when target is absent. const auto noncanonical = decode_session(bad); CHECK(!noncanonical && noncanonical.error() == SessionCodecError::invalid_value); bad = bytes; bad.at(4) = static_cast(session_protocol_v5); const auto old_version = decode_session(bad); CHECK(!old_version && old_version.error() == SessionCodecError::unsupported_version); CHECK(encode_session(SessionMessage{CellularIntention{1, 2, 3, 4}}, 7).empty()); } void v7_reliable_action_is_stable_and_strict() { const CellularAction action{17, 23, 29, 31, -707, 707, true, 4'000, 5'000}; const auto bytes = encode_session(SessionMessage{action}); CHECK(bytes.size() == session_header_bytes + 48); std::uint16_t version{}; const auto decoded = decode_session(bytes, &version); CHECK(decoded && version == session_protocol_v7); CHECK(std::get(*decoded) == action); CHECK(encode_session(*decoded) == bytes); CHECK(encode_session(SessionMessage{action}, session_protocol_v6).empty()); const auto outcome = ActionOutcome{29, ActionResult::committed, 31, 41}; const auto outcome_bytes = encode_session(SessionMessage{outcome}, session_protocol_v7); CHECK(std::get(*decode_session(outcome_bytes)) == outcome); CHECK(encode_session(SessionMessage{outcome}, session_protocol_v6).empty()); auto bad = bytes; std::fill(bad.begin() + static_cast(session_header_bytes + 16), bad.begin() + static_cast(session_header_bytes + 24), std::uint8_t{0}); CHECK(!decode_session(bad)); // Stable action id cannot be zero. bad = bytes; bad[session_header_bytes + 37] = 1; CHECK(!decode_session(bad)); // Reserved bytes are canonical. bad = encode_session(SessionMessage{CellularAction{1, 2, 3, 4, 0, 0, false, 0, 0}}); bad[session_header_bytes + 44] = 1; CHECK(!decode_session(bad)); // An absent patch has no coordinates. } } // namespace int main() { try { round_trip_and_version_gate(); malformed_frames_are_refused(); v7_reliable_action_is_stable_and_strict(); std::puts("PASS cellular protocol: v6 intention and v7 action strict framing"); } catch (const std::exception& error) { std::fprintf(stderr, "%s\n", error.what()); return 1; } }