#include <doctest/doctest.h>

#include "secsgem/gem/messages.hpp"

using namespace secsgem::gem;

TEST_CASE("S1F3 round-trip preserves SVID list") {
  auto m = s1f3_selected_status_request({1, 2, 99});
  CHECK(m.stream == 1);
  CHECK(m.function == 3);
  CHECK(m.reply_expected);
  auto parsed = parse_s1f3(m);
  REQUIRE(parsed.has_value());
  CHECK(*parsed == std::vector<uint32_t>{1, 2, 99});
}

TEST_CASE("S1F4 substitutes empty list for unknown SVIDs") {
  std::vector<std::optional<s2::Item>> values = {s2::Item::u4(uint32_t{42}), std::nullopt,
                                                 s2::Item::ascii("ok")};
  auto m = s1f4_selected_status_data(values);
  REQUIRE(m.body.has_value());
  const auto& children = m.body->as_list();
  REQUIRE(children.size() == 3);
  CHECK(children[0] == s2::Item::u4(uint32_t{42}));
  CHECK(children[1] == s2::Item::list({}));
  CHECK(children[2] == s2::Item::ascii("ok"));
}

TEST_CASE("S1F12 round-trip preserves SVID, name, units") {
  std::vector<StatusName> svs = {{1, "Clock", "sec"}, {2, "Power", "W"}};
  auto m = s1f12_status_namelist_data(svs);
  auto parsed = parse_s1f12(m);
  REQUIRE(parsed.has_value());
  REQUIRE(parsed->size() == 2);
  CHECK((*parsed)[0].id == 1);
  CHECK((*parsed)[0].name == "Clock");
  CHECK((*parsed)[0].units == "sec");
  CHECK((*parsed)[1].id == 2);
  CHECK((*parsed)[1].name == "Power");
}

TEST_CASE("S2F15 round-trip preserves ECID-value pairs") {
  std::vector<EcSet> sets = {
      {10, s2::Item::u4(uint32_t{50})},
      {11, s2::Item::ascii("YYYYMMDDhhmmsscc")},
  };
  auto m = s2f15_ec_send(sets);
  auto parsed = parse_s2f15(m);
  REQUIRE(parsed.has_value());
  REQUIRE(parsed->size() == 2);
  CHECK((*parsed)[0].ecid == 10);
  CHECK((*parsed)[0].value == s2::Item::u4(uint32_t{50}));
  CHECK((*parsed)[1].ecid == 11);
  CHECK((*parsed)[1].value == s2::Item::ascii("YYYYMMDDhhmmsscc"));
}

TEST_CASE("S2F16 EAC ack round-trip") {
  auto m = s2f16_ec_ack(EquipmentAck::Denied_OutOfRange);
  auto byte = ack_byte(m);
  REQUIRE(byte.has_value());
  CHECK(*byte == static_cast<uint8_t>(EquipmentAck::Denied_OutOfRange));
}

TEST_CASE("S2F16 EAC enum matches SEMI E5 wire values") {
  // Pin the spec values so an inadvertent re-numbering breaks the test
  // instead of breaking interoperability with conformant hosts.
  CHECK(static_cast<uint8_t>(EquipmentAck::Accept)             == 0);
  CHECK(static_cast<uint8_t>(EquipmentAck::Denied_UnknownEcid) == 1);
  CHECK(static_cast<uint8_t>(EquipmentAck::Denied_Busy)        == 2);
  CHECK(static_cast<uint8_t>(EquipmentAck::Denied_OutOfRange)  == 3);
}

TEST_CASE("S2F34 DRACK enum matches SEMI E5 wire values") {
  CHECK(static_cast<uint8_t>(DefineReportAck::Accept)              == 0);
  CHECK(static_cast<uint8_t>(DefineReportAck::InsufficientSpace)   == 1);
  CHECK(static_cast<uint8_t>(DefineReportAck::InvalidFormat)       == 2);
  CHECK(static_cast<uint8_t>(DefineReportAck::RptidAlreadyDefined) == 3);
  CHECK(static_cast<uint8_t>(DefineReportAck::InvalidVid)          == 4);
}

TEST_CASE("S2F36 LRACK enum matches SEMI E5 wire values") {
  CHECK(static_cast<uint8_t>(LinkEventAck::Accept)             == 0);
  CHECK(static_cast<uint8_t>(LinkEventAck::InsufficientSpace)  == 1);
  CHECK(static_cast<uint8_t>(LinkEventAck::InvalidFormat)      == 2);
  CHECK(static_cast<uint8_t>(LinkEventAck::UnknownCeid)        == 3);
  CHECK(static_cast<uint8_t>(LinkEventAck::UnknownRptid)       == 4);
  CHECK(static_cast<uint8_t>(LinkEventAck::CeidAlreadyLinked)  == 5);
}

TEST_CASE("S2F42 HCACK enum matches SEMI E5 wire values") {
  CHECK(static_cast<uint8_t>(HostCmdAck::Accept)                  == 0);
  CHECK(static_cast<uint8_t>(HostCmdAck::InvalidCommand)          == 1);
  CHECK(static_cast<uint8_t>(HostCmdAck::CannotDoNow)             == 2);
  CHECK(static_cast<uint8_t>(HostCmdAck::ParameterInvalid)        == 3);
  CHECK(static_cast<uint8_t>(HostCmdAck::AcceptedWillFinishLater) == 4);
  CHECK(static_cast<uint8_t>(HostCmdAck::Rejected)                == 5);
  CHECK(static_cast<uint8_t>(HostCmdAck::InvalidObject)           == 6);
}

TEST_CASE("S7F4 ACKC7 enum matches SEMI E5 wire values") {
  CHECK(static_cast<uint8_t>(ProcessProgramAck::Accept)               == 0);
  CHECK(static_cast<uint8_t>(ProcessProgramAck::PermissionNotGranted) == 1);
  CHECK(static_cast<uint8_t>(ProcessProgramAck::LengthError)          == 2);
  CHECK(static_cast<uint8_t>(ProcessProgramAck::MatrixOverflow)       == 3);
  CHECK(static_cast<uint8_t>(ProcessProgramAck::PpidNotFound)         == 4);
  CHECK(static_cast<uint8_t>(ProcessProgramAck::ModeUnsupported)      == 5);
  CHECK(static_cast<uint8_t>(ProcessProgramAck::PerformanceError)     == 6);
}

TEST_CASE("S10F2/F4/F6 ACKC10 enum matches SEMI E5 wire values") {
  CHECK(static_cast<uint8_t>(TerminalAck::Accepted)             == 0);
  CHECK(static_cast<uint8_t>(TerminalAck::WillNotDisplay)       == 1);
  CHECK(static_cast<uint8_t>(TerminalAck::TerminalNotAvailable) == 2);
}

TEST_CASE("S1F18 ONLACK / S1F16 OFLACK / S1F14 COMMACK enum wire values") {
  CHECK(static_cast<uint8_t>(OnlineAck::Accept)        == 0);
  CHECK(static_cast<uint8_t>(OnlineAck::NotAccept)     == 1);
  CHECK(static_cast<uint8_t>(OnlineAck::AlreadyOnline) == 2);
  CHECK(static_cast<uint8_t>(OfflineAck::Accept) == 0);
  CHECK(static_cast<uint8_t>(CommAck::Accept) == 0);
  CHECK(static_cast<uint8_t>(CommAck::Denied) == 1);
}

TEST_CASE("S2F18 carries 16-char time string") {
  auto m = s2f18_date_time_data("2026052812345678");
  auto t = parse_s2f18(m);
  REQUIRE(t.has_value());
  CHECK(*t == "2026052812345678");
}

TEST_CASE("S2F41 round-trip with parameters") {
  std::vector<CommandParameter> params = {
      {"LOTID", s2::Item::ascii("LOT-42")},
      {"PPID", s2::Item::ascii("RECIPE-A")},
  };
  auto m = s2f41_host_command("START", params);
  auto parsed = parse_s2f41(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->rcmd == "START");
  REQUIRE(parsed->params.size() == 2);
  CHECK(parsed->params[0].name == "LOTID");
  CHECK(parsed->params[0].value == s2::Item::ascii("LOT-42"));
  CHECK(parsed->params[1].name == "PPID");
}

TEST_CASE("S2F42 round-trip with HCACK and CPACKs") {
  auto m = s2f42_host_command_ack(HostCmdAck::ParameterInvalid,
                                  {{"LOTID", 0}, {"PPID", 3}});
  auto parsed = parse_s2f42(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->hcack == HostCmdAck::ParameterInvalid);
  REQUIRE(parsed->cpacks.size() == 2);
  CHECK(parsed->cpacks[0].name == "LOTID");
  CHECK(parsed->cpacks[0].code == 0);
  CHECK(parsed->cpacks[1].name == "PPID");
  CHECK(parsed->cpacks[1].code == 3);
}

TEST_CASE("S2F49 / S2F50 enhanced remote command round-trip") {
  std::vector<CommandParameter> params = {
      {"LOTID", s2::Item::ascii("LOT-99")},
      {"PPID",  s2::Item::ascii("RECIPE-B")},
  };
  auto m = s2f49_enhanced_host_command(/*dataid=*/7, "CJ-1", "START", params);
  CHECK(m.stream == 2);
  CHECK(m.function == 49);
  CHECK(m.reply_expected);

  auto parsed = parse_s2f49(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->dataid == 7);
  CHECK(parsed->objspec == "CJ-1");
  CHECK(parsed->rcmd == "START");
  REQUIRE(parsed->params.size() == 2);
  CHECK(parsed->params[0].name == "LOTID");
  CHECK(parsed->params[0].value == s2::Item::ascii("LOT-99"));

  auto ack = s2f50_enhanced_host_command_ack(
      HostCmdAck::ParameterInvalid,
      {{"LOTID", 0, 0}, {"PPID", 3, 1}});
  auto preply = parse_s2f50(ack);
  REQUIRE(preply.has_value());
  CHECK(preply->hcack == HostCmdAck::ParameterInvalid);
  REQUIRE(preply->cpacks.size() == 2);
  CHECK(preply->cpacks[1].name == "PPID");
  CHECK(preply->cpacks[1].cpack == 3);
  CHECK(preply->cpacks[1].cepack == 1);
}

TEST_CASE("S2F42 no-params variant") {
  auto m = s2f42_host_command_ack(HostCmdAck::Accept, {});
  auto parsed = parse_s2f42(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->hcack == HostCmdAck::Accept);
  CHECK(parsed->cpacks.empty());
}

TEST_CASE("S10F3 terminal display round-trip") {
  auto m = s10f3_terminal_display_single(1, "ALARM: chiller temperature high");
  auto parsed = parse_s10f3(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->tid == 1);
  CHECK(parsed->text == "ALARM: chiller temperature high");
}

// ---- S10F5 multi-line terminal display ---------------------------------

TEST_CASE("S10F5 carries TID + line list; S10F6 ack round-trip") {
  auto m = s10f5_terminal_display_multi(2, {"line one", "line two", "line three"});
  auto td = parse_s10f5(m);
  REQUIRE(td.has_value());
  CHECK(td->tid == 2);
  REQUIRE(td->lines.size() == 3);
  CHECK(td->lines[0] == "line one");
  CHECK(td->lines[2] == "line three");

  CHECK(*ack_byte(s10f6_terminal_display_multi_ack(TerminalAck::Accepted)) == 0);
}

// ---- Spool data ready (S6F25/F26) --------------------------------------

TEST_CASE("S6F25 carries NUM-MSG; S6F26 ack round-trip") {
  auto m = s6f25_spool_data_ready(42);
  auto n = parse_s6f25(m);
  REQUIRE(n.has_value());
  CHECK(*n == 42);
  CHECK(m.reply_expected);

  CHECK(*ack_byte(s6f26_spool_data_ready_ack(EventReportAck::Accept)) == 0);
}

// ---- Trace Data Collection (S2F23/F24 + S6F1/F2) -----------------------

TEST_CASE("S2F23 round-trip") {
  TraceInit ti{7, "1000", 100, 10, {1, 2, 3}};
  auto m = s2f23_trace_initialize_send(ti.trid, ti.dsper, ti.totsmp, ti.repgsz, ti.svids);
  auto parsed = parse_s2f23(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->trid == 7);
  CHECK(parsed->dsper == "1000");
  CHECK(parsed->totsmp == 100);
  CHECK(parsed->repgsz == 10);
  CHECK(parsed->svids == std::vector<uint32_t>{1, 2, 3});
}

TEST_CASE("S6F1 round-trip carries TRID + SMPLN + STIME + values") {
  std::vector<s2::Item> values = {s2::Item::u4(uint32_t{42}), s2::Item::ascii("hot")};
  auto m = s6f1_trace_data_send(7, 3, "20260606123000", values);
  auto parsed = parse_s6f1(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->trid == 7);
  CHECK(parsed->smpln == 3);
  CHECK(parsed->stime == "20260606123000");
  REQUIRE(parsed->values.size() == 2);
  CHECK(parsed->values[0] == s2::Item::u4(uint32_t{42}));
}

// ---- Limits Monitoring (S2F45-F48) -------------------------------------

TEST_CASE("S2F45 round-trips define-limits request") {
  std::vector<VidLimitsEntry> entries = {
      {100, {{0, s2::Item::u4(uint32_t{1000}), s2::Item::u4(uint32_t{0})}}},
      {101, {{0, s2::Item::f4(2.0f), s2::Item::f4(0.5f)},
             {1, s2::Item::f4(3.0f), s2::Item::f4(0.1f)}}},
  };
  auto m = s2f45_define_variable_limits(7, entries);
  auto parsed = parse_s2f45(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->dataid == 7);
  REQUIRE(parsed->entries.size() == 2);
  CHECK(parsed->entries[0].vid == 100);
  REQUIRE(parsed->entries[0].limits.size() == 1);
  CHECK(parsed->entries[0].limits[0].upper == s2::Item::u4(uint32_t{1000}));
  CHECK(parsed->entries[1].vid == 101);
  REQUIRE(parsed->entries[1].limits.size() == 2);
}

TEST_CASE("S2F46 / S2F48 round-trips") {
  CHECK(*ack_byte(s2f46_define_variable_limits_ack(LimitMonitorAck::VidNotExist)) == 4);

  std::vector<VidLimitsEntry> rows = {
      {100, {{0, s2::Item::u4(uint32_t{1000}), s2::Item::u4(uint32_t{0})}}}};
  auto m = s2f48_variable_limit_attribute_data(rows);
  REQUIRE(m.body.has_value());
  REQUIRE(m.body->is_list());
}

// ---- S9 error-stream round-trips ----------------------------------------

TEST_CASE("S9 MHEAD-carrying messages round-trip") {
  // A representative 10-byte HSMS header (data message, S2F33 W, sys=42).
  const std::string mhead(
      "\x12\x34"            // session id
      "\x82"                // byte2: W=1, stream=2
      "\x21"                // byte3: function=33
      "\x00"                // ptype
      "\x00"                // stype=Data
      "\x00\x00\x00\x2A",   // system bytes = 42
      10);

  auto check = [&](const s2::Message& m, std::optional<std::string> (*p)(const s2::Message&)) {
    CHECK(m.stream == 9);
    CHECK_FALSE(m.reply_expected);
    auto out = p(m);
    REQUIRE(out.has_value());
    CHECK(*out == mhead);
  };

  check(s9f1_unrecognized_device_id(mhead),     parse_s9f1);
  check(s9f3_unrecognized_stream_type(mhead),   parse_s9f3);
  check(s9f5_unrecognized_function_type(mhead), parse_s9f5);
  check(s9f7_illegal_data(mhead),               parse_s9f7);
  check(s9f9_transaction_timer_timeout(mhead),  parse_s9f9);
  check(s9f11_data_too_long(mhead),             parse_s9f11);
}

TEST_CASE("S9F13 conversation timeout carries MEXP + EDID") {
  auto m = s9f13_conversation_timeout("S2F33W", "EQUIP-01");
  CHECK(m.stream == 9);
  CHECK(m.function == 13);
  auto parsed = parse_s9f13(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->mexp == "S2F33W");
  CHECK(parsed->edid == "EQUIP-01");
}

// ---- S5F7 / S5F8 List Enabled Alarms -----------------------------------

TEST_CASE("S5F7 header-only; S5F8 round-trips alarm listing") {
  auto req = s5f7_list_enabled_alarms_request();
  CHECK(req.stream == 5);
  CHECK(req.function == 7);
  CHECK(req.reply_expected);
  CHECK_FALSE(req.body.has_value());

  std::vector<AlarmListing> rows = {{0x84, 1, "Chiller Temp High"},
                                    {0x01, 2, "Door Open"}};
  auto m = s5f8_list_enabled_alarms_data(rows);
  auto parsed = parse_s5f8(m);
  REQUIRE(parsed.has_value());
  REQUIRE(parsed->size() == 2);
  CHECK((*parsed)[0].alcd == 0x84);
  CHECK((*parsed)[0].alid == 1);
  CHECK((*parsed)[1].alcd == 0x01);
  CHECK((*parsed)[1].altx == "Door Open");
}

// ---- S1F19 / S1F20 Get GEM Compliance ----------------------------------

TEST_CASE("S1F19 is header-only and S1F20 round-trips capability list") {
  auto req = s1f19_get_gem_compliance_request();
  CHECK(req.stream == 1);
  CHECK(req.function == 19);
  CHECK(req.reply_expected);
  CHECK_FALSE(req.body.has_value());

  std::vector<CapabilityEntry> caps = {
      {1, "Establish Communications"},
      {5, "Status Data Collection"},
      {14, "Spooling"},
  };
  auto m = s1f20_get_gem_compliance_data("0.1.0", "EQUIPMENT", caps);
  auto parsed = parse_s1f20(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->softrev == "0.1.0");
  CHECK(parsed->equipment_type == "EQUIPMENT");
  REQUIRE(parsed->capabilities.size() == 3);
  CHECK(parsed->capabilities[0].ccode == 1);
  CHECK(parsed->capabilities[0].cdesc == "Establish Communications");
  CHECK(parsed->capabilities[2].ccode == 14);
  CHECK(parsed->capabilities[2].cdesc == "Spooling");
}

// ---- S1F21 / S1F22 DVID Namelist ---------------------------------------

TEST_CASE("S1F22 round-trip preserves DVIDs (shape matches S1F12)") {
  std::vector<StatusName> dvs = {{100, "WaferCounter", "wafer"},
                                 {101, "ChamberPressure", "Torr"}};
  auto m = s1f22_data_variable_namelist_data(dvs);
  auto parsed = parse_s1f22(m);
  REQUIRE(parsed.has_value());
  REQUIRE(parsed->size() == 2);
  CHECK((*parsed)[0].id == 100);
  CHECK((*parsed)[0].name == "WaferCounter");
  CHECK((*parsed)[0].units == "wafer");
  CHECK((*parsed)[1].id == 101);
}

// ---- Extended GEM message round-trips ------------------------------------

TEST_CASE("S2F33 define-report round-trip") {
  auto m = s2f33_define_report(7, {{1000, {1, 2, 3}}, {1001, {4}}});
  auto parsed = parse_s2f33(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->dataid == 7);
  REQUIRE(parsed->reports.size() == 2);
  CHECK(parsed->reports[0].rptid == 1000);
  CHECK(parsed->reports[0].vids == std::vector<uint32_t>{1, 2, 3});
  CHECK(parsed->reports[1].rptid == 1001);
  CHECK(parsed->reports[1].vids == std::vector<uint32_t>{4});
}

TEST_CASE("S2F35 link-event round-trip") {
  auto m = s2f35_link_event_report(0, {{100, {1000, 1001}}, {200, {1001}}});
  auto parsed = parse_s2f35(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->dataid == 0);
  REQUIRE(parsed->links.size() == 2);
  CHECK(parsed->links[0].ceid == 100);
  CHECK(parsed->links[0].rptids == std::vector<uint32_t>{1000, 1001});
}

TEST_CASE("S2F37 enable-event round-trip") {
  auto enable = s2f37_enable_event(true, {100, 200});
  auto disable = s2f37_enable_event(false, {});
  auto pe = parse_s2f37(enable);
  auto pd = parse_s2f37(disable);
  REQUIRE(pe.has_value());
  REQUIRE(pd.has_value());
  CHECK(pe->enable);
  CHECK(pe->ceids == std::vector<uint32_t>{100, 200});
  CHECK_FALSE(pd->enable);
  CHECK(pd->ceids.empty());
}

TEST_CASE("S5F1 alarm-report round-trip") {
  auto m = s5f1_alarm_report(0x84, 7, "Chiller temp high");
  auto parsed = parse_s5f1(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->alid == 7);
  CHECK(parsed->altx == "Chiller temp high");
  CHECK(parsed->alcd == 0x84);
  CHECK((parsed->alcd & 0x80) != 0);  // set bit
  CHECK((parsed->alcd & 0x7F) == 4);  // category
}

TEST_CASE("S5F3 enable/disable alarm send round-trip") {
  auto on = s5f3_enable_alarm(kAlarmEnableByte, 42);
  auto off = s5f3_enable_alarm(kAlarmDisableByte, 42);
  auto pon = parse_s5f3(on);
  auto poff = parse_s5f3(off);
  REQUIRE(pon.has_value());
  REQUIRE(poff.has_value());
  CHECK((pon->aled & 0x80) != 0);
  CHECK((poff->aled & 0x80) == 0);
  CHECK(pon->alid == 42);
}

TEST_CASE("S5F6 alarm list builder marks active alarms with bit 7") {
  std::vector<Alarm> alarms = {{1, "Door", 1}, {2, "Heater", 4}};
  auto m = s5f6_list_alarms_data(alarms, [](uint32_t id) { return id == 2; });
  REQUIRE(m.body.has_value());
  REQUIRE(m.body->is_list());
  REQUIRE(m.body->as_list().size() == 2);
  const auto& row0 = m.body->as_list()[0].as_list();
  const auto& row1 = m.body->as_list()[1].as_list();
  CHECK(row0[0].as_bytes()[0] == 0x01);  // door inactive: cat 1, bit 7 clear
  CHECK(row1[0].as_bytes()[0] == 0x84);  // heater active: cat 4, bit 7 set
}

TEST_CASE("S6F11 event-report round-trip preserves DATAID, CEID, reports") {
  std::vector<ReportData> reports = {
      {1000, {s2::Item::ascii("OnlineRemote")}},
      {1001, {s2::Item::u4(uint32_t{42}), s2::Item::ascii("hello")}},
  };
  auto m = s6f11_event_report(7, 100, reports);
  auto parsed = parse_s6f11(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->dataid == 7);
  CHECK(parsed->ceid == 100);
  REQUIRE(parsed->reports.size() == 2);
  CHECK(parsed->reports[0].rptid == 1000);
  CHECK(parsed->reports[0].values[0] == s2::Item::ascii("OnlineRemote"));
  CHECK(parsed->reports[1].rptid == 1001);
  CHECK(parsed->reports[1].values[0] == s2::Item::u4(uint32_t{42}));
}

TEST_CASE("S7F3 process-program send round-trip") {
  auto m = s7f3_process_program_send("RECIPE-A", "step1\nstep2\n");
  auto parsed = parse_s7f3(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->ppid == "RECIPE-A");
  CHECK(parsed->ppbody == "step1\nstep2\n");
}

TEST_CASE("S7F1 / S7F2 PP-load inquire/grant round-trip") {
  auto m = s7f1_pp_load_inquire("RECIPE-X", 4096);
  CHECK(m.stream == 7);
  CHECK(m.function == 1);
  CHECK(m.reply_expected);
  auto parsed = parse_s7f1(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->ppid == "RECIPE-X");
  CHECK(parsed->length == 4096);

  auto grant = s7f2_pp_load_grant(ProcessProgramAck::Accept);
  CHECK(*ack_byte(grant) == 0);
}

TEST_CASE("S2F21 / S2F22 legacy remote command round-trip") {
  auto req = s2f21_remote_command("PAUSE");
  CHECK(req.stream == 2);
  CHECK(req.function == 21);
  CHECK(req.reply_expected);
  auto parsed = parse_s2f21(req);
  REQUIRE(parsed.has_value());
  CHECK(*parsed == "PAUSE");
  CHECK(*ack_byte(s2f22_remote_command_ack(HostCmdAck::Accept)) == 0);
}

TEST_CASE("S6F5 / S6F6 multi-block inquire / grant round-trip") {
  auto req = s6f5_multi_block_inquire(42, 2048);
  auto parsed = parse_s6f5(req);
  REQUIRE(parsed.has_value());
  CHECK(parsed->dataid == 42);
  CHECK(parsed->datalength == 2048);
  CHECK(*ack_byte(s6f6_multi_block_grant(MultiBlockGrant::Ok)) == 0);
  CHECK(*ack_byte(s6f6_multi_block_grant(MultiBlockGrant::Busy)) == 1);
}

TEST_CASE("S6F7 round-trip carries DATAID") {
  auto req = s6f7_data_transfer_request(7);
  auto parsed = parse_s6f7(req);
  REQUIRE(parsed.has_value());
  CHECK(*parsed == 7);
}

TEST_CASE("S6F15 / S6F16 event report request/data round-trip") {
  auto req = s6f15_event_report_request(300);
  auto parsed = parse_s6f15(req);
  REQUIRE(parsed.has_value());
  CHECK(*parsed == 300);

  EventReportMessage erm{0, 300, {ReportData{1, {s2::Item::u4(42)}}}};
  auto data = s6f16_event_report_data(erm);
  auto out = parse_s6f16(data);
  REQUIRE(out.has_value());
  CHECK(out->ceid == 300);
  REQUIRE(out->reports.size() == 1);
  CHECK(out->reports[0].rptid == 1);
}

TEST_CASE("S6F19 / S6F20 individual report round-trip") {
  auto req = s6f19_individual_report_request(7);
  auto parsed = parse_s6f19(req);
  REQUIRE(parsed.has_value());
  CHECK(*parsed == 7);
  auto reply = s6f20_individual_report_data({s2::Item::u4(99), s2::Item::ascii("ok")});
  auto out = parse_s6f20(reply);
  REQUIRE(out.has_value());
  CHECK(out->size() == 2);
}

TEST_CASE("S6F21 / S6F22 annotated report round-trip") {
  auto req = s6f21_annotated_report_request(7);
  auto parsed = parse_s6f21(req);
  REQUIRE(parsed.has_value());
  CHECK(*parsed == 7);
  std::vector<AnnotatedValue> rows{{1, s2::Item::u4(42)}, {2, s2::Item::ascii("hi")}};
  auto reply = s6f22_annotated_report_data(rows);
  auto out = parse_s6f22(reply);
  REQUIRE(out.has_value());
  REQUIRE(out->size() == 2);
  CHECK((*out)[0].vid == 1);
  CHECK((*out)[1].vid == 2);
}

TEST_CASE("S12F9 / S12F10 array map round-trip") {
  MapDataArray a{"WAFER-1", 0x01, ReferencePoint{0, 0}, std::string("\x00\x01\x02", 3)};
  auto m = s12f9_map_data_send_array(a);
  auto parsed = parse_s12f9(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->mid == "WAFER-1");
  CHECK(parsed->idtyp == 0x01);
  CHECK(parsed->binlt.size() == 3);
  CHECK(*ack_byte(s12f10_map_data_send_array_ack(MapDataAck::Accept)) == 0);
}

TEST_CASE("S12F11 / S12F12 coordinate map round-trip") {
  MapDataCoord c{"WAFER-1", 0x01,
                 {{ReferencePoint{1, 2}, std::string("\x05", 1)},
                  {ReferencePoint{3, 4}, std::string("\x06", 1)}}};
  auto m = s12f11_map_data_send_coord(c);
  auto parsed = parse_s12f11(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->mid == "WAFER-1");
  REQUIRE(parsed->entries.size() == 2);
  CHECK(parsed->entries[0].xypos.x == 1);
  CHECK(parsed->entries[1].xypos.y == 4);
  CHECK(*ack_byte(s12f12_map_data_send_coord_ack(MapDataAck::FormatError)) == 1);
}

TEST_CASE("S12F13/F14 + F15/F16 + F17/F18 request shapes round-trip") {
  MapDataIdentifier id{"WAFER-1", 0x01};
  CHECK(parse_s12f13(s12f13_map_data_request_row(id))->mid == "WAFER-1");
  CHECK(parse_s12f15(s12f15_map_data_request_array(id))->idtyp == 0x01);
  MapDataCoordRequest cr{"WAFER-1", 0x01, 0xFF};
  auto parsed_cr = parse_s12f17(s12f17_map_data_request_coord(cr));
  REQUIRE(parsed_cr.has_value());
  CHECK(parsed_cr->sdbin == 0xFF);
}

TEST_CASE("S7F17 / S7F18 delete PP round-trip") {
  auto m = s7f17_delete_pp_send({"R1", "R2", "R3"});
  auto parsed = parse_s7f17(m);
  REQUIRE(parsed.has_value());
  REQUIRE(parsed->size() == 3);
  CHECK((*parsed)[0] == "R1");
  CHECK((*parsed)[2] == "R3");

  auto empty = parse_s7f17(s7f17_delete_pp_send({}));
  REQUIRE(empty.has_value());
  CHECK(empty->empty());

  CHECK(*ack_byte(s7f18_delete_pp_ack(ProcessProgramAck::Accept)) == 0);
  CHECK(*ack_byte(s7f18_delete_pp_ack(ProcessProgramAck::PpidNotFound)) == 4);
}

TEST_CASE("S2F25 / S2F26 loopback diagnostic round-trip") {
  // Arbitrary binary payload — host sends, equipment echoes back.
  const std::string payload("\x00\x01\x02\xFE\xFF some text", 14);
  auto req = s2f25_loopback_diagnostic_request(payload);
  CHECK(req.stream == 2);
  CHECK(req.function == 25);
  CHECK(req.reply_expected);
  auto parsed_req = parse_s2f25(req);
  REQUIRE(parsed_req.has_value());
  CHECK(*parsed_req == payload);

  auto rsp = s2f26_loopback_diagnostic_data(payload);
  auto parsed_rsp = parse_s2f26(rsp);
  REQUIRE(parsed_rsp.has_value());
  CHECK(*parsed_rsp == payload);
}

TEST_CASE("S5F9 / S5F10 exception post round-trip") {
  std::vector<std::string> recovery = {"RETRY", "ABORT", "MANUAL_INTERVENTION"};
  auto m = s5f9_exception_post_notify(42, "FATAL", "vacuum lost", recovery);
  CHECK(m.stream == 5);
  CHECK(m.function == 9);
  CHECK(m.reply_expected);

  auto parsed = parse_s5f9(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->exid == 42);
  CHECK(parsed->extype == "FATAL");
  CHECK(parsed->exmessage == "vacuum lost");
  CHECK(parsed->exrecvra == recovery);

  CHECK(*ack_byte(s5f10_exception_post_confirm(AlarmAck::Accept)) == 0);
}

TEST_CASE("S5F11 / S5F12 exception clear round-trip") {
  auto m = s5f11_exception_clear_notify(42, "FATAL", "vacuum restored");
  auto parsed = parse_s5f11(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->exid == 42);
  CHECK(parsed->extype == "FATAL");
  CHECK(parsed->exmessage == "vacuum restored");

  CHECK(*ack_byte(s5f12_exception_clear_confirm(AlarmAck::Accept)) == 0);
}

TEST_CASE("S5F13 / S5F14 exception recover request round-trip") {
  auto m = s5f13_exception_recover_request(42, "RETRY");
  CHECK(m.stream == 5);
  CHECK(m.function == 13);
  CHECK(m.reply_expected);

  auto parsed = parse_s5f13(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->exid == 42);
  CHECK(parsed->exrecvra == "RETRY");

  CHECK(*ack_byte(s5f14_exception_recover_ack(AlarmAck::Accept)) == 0);
}

TEST_CASE("S5F15 / S5F16 exception recover complete round-trip") {
  auto m = s5f15_exception_recover_complete_notify(42, "OK");
  CHECK(m.stream == 5);
  CHECK(m.function == 15);
  CHECK(m.reply_expected);

  auto parsed = parse_s5f15(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->exid == 42);
  CHECK(parsed->exresult == "OK");

  CHECK(*ack_byte(s5f16_exception_recover_complete_ack(AlarmAck::Accept)) == 0);
}

TEST_CASE("S5F17 / S5F18 exception recover abort round-trip") {
  auto m = s5f17_exception_recover_abort_request(42);
  CHECK(m.stream == 5);
  CHECK(m.function == 17);
  CHECK(m.reply_expected);

  // Scalar U4 parser returns the value directly.
  auto exid = parse_s5f17(m);
  REQUIRE(exid.has_value());
  CHECK(*exid == 42);

  CHECK(*ack_byte(s5f18_exception_recover_abort_ack(AlarmAck::Accept)) == 0);
}

TEST_CASE("S7F19 / S7F20 EPPD list") {
  auto req = s7f19_current_eppd_request();
  CHECK(req.stream == 7);
  CHECK(req.function == 19);
  CHECK(req.reply_expected);
  CHECK_FALSE(req.body.has_value());

  auto data = s7f20_current_eppd_data({"RECIPE-A", "RECIPE-B"});
  auto parsed = parse_s7f20(data);
  REQUIRE(parsed.has_value());
  CHECK(*parsed == std::vector<std::string>{"RECIPE-A", "RECIPE-B"});
}

TEST_CASE("S14F1 / S14F2 GetAttr round-trip") {
  auto m = s14f1_get_attr("EQ-1", "Equipment", {"MDLN", "SOFTREV"});
  CHECK(m.stream == 14);
  CHECK(m.function == 1);
  auto parsed = parse_s14f1(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->objspec == "EQ-1");
  CHECK(parsed->objtype == "Equipment");
  REQUIRE(parsed->attrids.size() == 2);

  std::vector<AttrValue> reply{
      {"MDLN",    s2::Item::ascii("DEMO")},
      {"SOFTREV", s2::Item::ascii("1.0")},
  };
  auto r = s14f2_get_attr_data(reply, ObjectAck::Success);
  auto pr = parse_s14f2(r);
  REQUIRE(pr.has_value());
  CHECK(pr->ack == ObjectAck::Success);
  REQUIRE(pr->attrs.size() == 2);
  CHECK(pr->attrs[0].attrid == "MDLN");
}

TEST_CASE("S14F3 / S14F4 SetAttr round-trip") {
  std::vector<AttrValue> attrs{{"PORT_STATE", s2::Item::ascii("OPEN")}};
  auto m = s14f3_set_attr("LP-1", "MaterialLocation", attrs);
  auto parsed = parse_s14f3(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->objspec == "LP-1");
  REQUIRE(parsed->attrs.size() == 1);
  CHECK(parsed->attrs[0].attrid == "PORT_STATE");

  auto r = s14f4_set_attr_ack(attrs, ObjectAck::Success);
  auto pr = parse_s14f4(r);
  REQUIRE(pr.has_value());
  CHECK(pr->ack == ObjectAck::Success);
}

TEST_CASE("S14F9 / S14F10 CreateControlJob round-trip") {
  auto req = s14f9_create_control_job("CJ-1", {"PJ-1", "PJ-2"});
  CHECK(req.stream == 14);
  CHECK(req.function == 9);
  CHECK(req.reply_expected);

  auto parsed = parse_s14f9(req);
  REQUIRE(parsed.has_value());
  CHECK(parsed->ctljobid == "CJ-1");
  CHECK(parsed->prjobids == std::vector<std::string>{"PJ-1", "PJ-2"});

  auto ack = s14f10_create_control_job_ack("CJ-1", ObjectAck::Success);
  auto parsed_ack = parse_s14f10(ack);
  REQUIRE(parsed_ack.has_value());
  CHECK(parsed_ack->ctljobid == "CJ-1");
  CHECK(parsed_ack->ack == ObjectAck::Success);
}

TEST_CASE("S14F11 / S14F12 DeleteControlJob round-trip") {
  auto req = s14f11_delete_control_job("CJ-1");
  auto parsed = parse_s14f11(req);
  REQUIRE(parsed.has_value());
  CHECK(*parsed == "CJ-1");

  auto ack = s14f12_delete_control_job_ack(ObjectAck::Denied_UnknownObject);
  CHECK(*ack_byte(ack) == 2);
}

TEST_CASE("S16F11 / S16F12 PRJobCreate round-trip (full E40 body)") {
  PRJobCreateRequest req_struct{
      "PJ-1",
      MaterialFlag::Substrate,
      ProcessRecipeMethod::RecipeWithVariableTuning,
      RecipeSpec{"RECIPE-A",
                 {RecipeVariable{"TEMP", s2::Item::u4(450)},
                  RecipeVariable{"TIME", s2::Item::u4(60)}}},
      {"WFR-1", "WFR-2"},
      {ProcessParameter{"LotID", s2::Item::ascii("LOT-42")}}};
  auto m = s16f11_pr_job_create(req_struct);
  CHECK(m.stream == 16);
  CHECK(m.function == 11);

  auto parsed = parse_s16f11(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->prjobid == "PJ-1");
  CHECK(parsed->mf == MaterialFlag::Substrate);
  CHECK(parsed->prrecipemethod == ProcessRecipeMethod::RecipeWithVariableTuning);
  CHECK(parsed->rcpspec.ppid == "RECIPE-A");
  REQUIRE(parsed->rcpspec.rcpvars.size() == 2);
  CHECK(parsed->rcpspec.rcpvars[0].name == "TEMP");
  CHECK(parsed->mtrloutspec == std::vector<std::string>{"WFR-1", "WFR-2"});
  REQUIRE(parsed->prprocessparams.size() == 1);
  CHECK(parsed->prprocessparams[0].name == "LotID");

  CHECK(*ack_byte(s16f12_pr_job_create_ack(HostCmdAck::Accept)) == 0);
}

TEST_CASE("S16F13 / S16F14 PRJobDequeue round-trip") {
  auto req = s16f13_pr_job_dequeue("PJ-1");
  CHECK(*parse_s16f13(req) == "PJ-1");
  CHECK(*ack_byte(s16f14_pr_job_dequeue_ack(HostCmdAck::CannotDoNow)) == 2);
}

TEST_CASE("S16F5 / S16F6 PRJobCommand round-trip") {
  auto req = s16f5_pr_job_command("PJ-1", "PJSTART");
  auto parsed = parse_s16f5(req);
  REQUIRE(parsed.has_value());
  CHECK(parsed->prjobid == "PJ-1");
  CHECK(parsed->prcmd == "PJSTART");
  CHECK(*ack_byte(s16f6_pr_job_command_ack(HostCmdAck::Accept)) == 0);
}

TEST_CASE("S16F9 PRJobAlert round-trip with typed state byte") {
  auto m = s16f9_pr_job_alert("PJ-1", ProcessJobState::Processing);
  auto parsed = parse_s16f9(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->prjobid == "PJ-1");
  CHECK(parsed->prjobstate == ProcessJobState::Processing);
}

TEST_CASE("S16F7 / S16F8 PRJobMonitor round-trip") {
  std::vector<PRJobMonitorEntry> entries{
      {"PJ-1", 0x80},  // enable
      {"PJ-2", 0x00},  // disable
  };
  auto m = s16f7_pr_job_monitor(entries);
  CHECK(m.stream == 16);
  CHECK(m.function == 7);
  CHECK(m.reply_expected);

  auto parsed = parse_s16f7(m);
  REQUIRE(parsed.has_value());
  REQUIRE(parsed->entries.size() == 2);
  CHECK(parsed->entries[0].prjobid == "PJ-1");
  CHECK(parsed->entries[0].pralert == 0x80);

  CHECK(*ack_byte(s16f8_pr_job_monitor_ack(HostCmdAck::Accept)) == 0);
}

TEST_CASE("S16F15 / S16F16 PRJobCreateMultiple round-trip") {
  std::vector<PRJobCreateEntry> jobs{
      {"PJ-A", "RECIPE-1", {"W1"}},
      {"PJ-B", "RECIPE-2", {"W2", "W3"}},
  };
  auto m = s16f15_pr_job_create_multi(jobs);
  auto parsed = parse_s16f15(m);
  REQUIRE(parsed.has_value());
  REQUIRE(parsed->jobs.size() == 2);
  CHECK(parsed->jobs[0].prjobid == "PJ-A");
  CHECK(parsed->jobs[1].mtrloutspec.size() == 2);

  std::vector<PRJobCreateMultiResult> results{
      {"PJ-A", HostCmdAck::Accept},
      {"PJ-B", HostCmdAck::Rejected},
  };
  auto ackmsg = s16f16_pr_job_create_multi_ack(results);
  auto pack = parse_s16f16(ackmsg);
  REQUIRE(pack.has_value());
  REQUIRE(pack->results.size() == 2);
  CHECK(pack->results[1].ack == HostCmdAck::Rejected);
}

TEST_CASE("S16F27 / S16F28 CJobCommand round-trip") {
  auto req = s16f27_cj_command("CJ-1", "CJSTART");
  auto parsed = parse_s16f27(req);
  REQUIRE(parsed.has_value());
  CHECK(parsed->ctljobid == "CJ-1");
  CHECK(parsed->ctljobcmd == "CJSTART");
  CHECK(*ack_byte(s16f28_cj_command_ack(HostCmdAck::Accept)) == 0);
}

// ---- S12 Wafer Maps (E5 §13) -------------------------------------------

TEST_CASE("S12F1 / S12F2 Map Setup Data Send round-trip") {
  std::vector<ReferencePoint> refp = {{0, 0}, {100, 200}};
  std::vector<std::string> dutms = {"01", "02"};
  auto m = s12f1_map_setup_send("WAFER-1", /*idtyp=*/0, /*fnloc=*/0,
                                /*ffrot=*/0, /*orloc=*/2, /*rpsel=*/2,
                                refp, dutms);
  CHECK(m.stream == 12);
  CHECK(m.function == 1);
  CHECK(m.reply_expected);

  auto parsed = parse_s12f1(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->mid == "WAFER-1");
  CHECK(parsed->idtyp == 0);
  CHECK(parsed->orloc == 2);
  REQUIRE(parsed->refp.size() == 2);
  CHECK(parsed->refp[1].x == 100);
  CHECK(parsed->refp[1].y == 200);
  REQUIRE(parsed->dutms.size() == 2);
  CHECK(parsed->dutms[0] == "01");

  CHECK(*ack_byte(s12f2_map_setup_ack(MapSetupAck::Accept)) == 0);
  CHECK(*ack_byte(s12f2_map_setup_ack(MapSetupAck::Error)) == 1);
}

TEST_CASE("S12F3 / S12F4 Map Setup Data Request round-trip") {
  auto req = s12f3_map_setup_request("WAFER-1", /*idtyp=*/0, /*mapft=*/0);
  auto parsed = parse_s12f3(req);
  REQUIRE(parsed.has_value());
  CHECK(parsed->mid == "WAFER-1");
  CHECK(parsed->mapft == 0);

  std::vector<ReferencePoint> refp = {{0, 0}};
  auto reply = s12f4_map_setup_reply("WAFER-1", /*idtyp=*/0, /*fnloc=*/270,
                                     /*orloc=*/0, /*rpsel=*/1, refp,
                                     {"R1C1"}, /*xdies=*/4, /*ydies=*/4);
  auto preply = parse_s12f4(reply);
  REQUIRE(preply.has_value());
  CHECK(preply->fnloc == 270);
  CHECK(preply->xdies == 4);
  CHECK(preply->ydies == 4);
}

TEST_CASE("S12F5 / S12F6 Map Transmit Inquire / Grant round-trip") {
  auto m = s12f5_map_transmit_inquire("WAFER-1", /*idtyp=*/0,
                                      /*mapft=*/0, /*mlcl=*/256);
  auto parsed = parse_s12f5(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->mlcl == 256);

  CHECK(*ack_byte(s12f6_map_transmit_grant(MapTransmitGrant::Granted)) == 0);
  CHECK(*ack_byte(s12f6_map_transmit_grant(MapTransmitGrant::BusyTryAgain)) == 1);
}

TEST_CASE("S12F7 / S12F8 Map Data Send (row format) round-trip") {
  std::vector<std::string> rows = {
      std::string({0x01, 0x02, 0x03}),
      std::string({0x04, 0x05, 0x06}),
  };
  auto m = s12f7_map_data_send_row("WAFER-1", /*idtyp=*/0, rows);
  auto parsed = parse_s12f7(m);
  REQUIRE(parsed.has_value());
  REQUIRE(parsed->rows.size() == 2);
  CHECK(parsed->rows[0].size() == 3);
  CHECK(static_cast<uint8_t>(parsed->rows[1][2]) == 0x06);

  CHECK(*ack_byte(s12f8_map_data_send_row_ack(MapDataAck::Accept)) == 0);
}

TEST_CASE("S12F19 Map Error Send round-trip") {
  auto m = s12f19_map_error_send(/*mapercd=*/2, "unrecognized MID");
  auto parsed = parse_s12f19(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->mapercd == 2);
  CHECK(parsed->errtext == "unrecognized MID");
  CHECK_FALSE(m.reply_expected);
}

// ---- S3 E87 Carrier Management -----------------------------------------

TEST_CASE("S3F17 / S3F18 CarrierAction round-trip") {
  std::vector<CommandParameter> params{
      {"PORTID", s2::Item::u1(uint8_t{1})},
  };
  auto m = s3f17_carrier_action(/*dataid=*/3, "ProceedWithCarrier",
                                "CAR-001", params);
  CHECK(m.stream == 3);
  CHECK(m.function == 17);
  CHECK(m.reply_expected);

  auto parsed = parse_s3f17(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->dataid == 3);
  CHECK(parsed->carrieraction == "ProceedWithCarrier");
  CHECK(parsed->carrierid == "CAR-001");
  REQUIRE(parsed->params.size() == 1);
  CHECK(parsed->params[0].name == "PORTID");

  CHECK(*ack_byte(s3f18_carrier_action_ack(CarrierActionAck::Accept)) == 0);
  CHECK(*ack_byte(s3f18_carrier_action_ack(CarrierActionAck::CarrierIDUnknown)) == 3);
}

TEST_CASE("S3F23 / S3F24 PortGroupChangeReport round-trip") {
  auto m = s3f23_port_group_change_report("GROUP-A", {1, 2, 3});
  auto parsed = parse_s3f23(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->ctngrpid == "GROUP-A");
  REQUIRE(parsed->portids.size() == 3);
  CHECK(parsed->portids[1] == 2);
  CHECK(*ack_byte(s3f24_port_group_change_ack(PortGroupAck::Accept)) == 0);
}

TEST_CASE("S3F25 / S3F26 CarrierTransfer round-trip") {
  auto m = s3f25_carrier_transfer("CAR-001", /*source=*/1, /*target=*/2);
  auto parsed = parse_s3f25(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->carrierid == "CAR-001");
  CHECK(parsed->source_portid == 1);
  CHECK(parsed->target_portid == 2);
  CHECK(*ack_byte(s3f26_carrier_transfer_ack(CarrierActionAck::Accept)) == 0);
}

TEST_CASE("S3F19 / S3F20 SlotMapVerify round-trip") {
  std::vector<std::string> raw_slots = {std::string({0x01, 0x01, 0x00, 0x01})};
  // Build via the typed builder: list of BINARY_BYTE per slot.
  std::vector<uint8_t> slots = {0x01, 0x01, 0x00, 0x01};
  auto m = s3f19_slot_map_verify("CAR-001", slots);
  CHECK(m.stream == 3);
  CHECK(m.function == 19);
  CHECK(m.reply_expected);

  auto parsed = parse_s3f19(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->carrierid == "CAR-001");
  CHECK(parsed->slots == slots);

  CHECK(*ack_byte(s3f20_slot_map_verify_ack(SlotMapVerifyAck::Accept))   == 0);
  CHECK(*ack_byte(s3f20_slot_map_verify_ack(SlotMapVerifyAck::Mismatch)) == 1);
}

TEST_CASE("S3F21 / S3F22 SlotMapReport round-trip") {
  std::vector<uint8_t> slots = {0x01, 0x00};
  auto m = s3f21_slot_map_report("CAR-002", slots);
  auto parsed = parse_s3f21(m);
  REQUIRE(parsed.has_value());
  CHECK(parsed->carrierid == "CAR-002");
  CHECK(parsed->slots == slots);
  CHECK(*ack_byte(s3f22_slot_map_report_ack(SlotMapVerifyAck::Accept)) == 0);
}

TEST_CASE("S3F27 / S3F28 CancelCarrier round-trip") {
  auto m = s3f27_cancel_carrier("CAR-001");
  auto parsed = parse_s3f27(m);
  REQUIRE(parsed.has_value());
  CHECK(*parsed == "CAR-001");
  CHECK(*ack_byte(s3f28_cancel_carrier_ack(CarrierActionAck::Accept)) == 0);
}