raphael/secs-gem
Public Access
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
0bbc7b7acfb480e68cd8a1aa7e63d880bcc52ceb
secs-gem/tests/test_messages.cpp
T
raphael cfa2d1e531 BB1: full E40 S16F11 body — MF, PRRECIPEMETHOD, RCPVARS, PRPROCESSPARAMS 
Replaces the simplified <L,3 PRJOBID PPID MTRLOUTSPEC> demo body with
the full SEMI E40-0705 §10.2 shape:

  <L,5 PRJOBID MF PRRECIPEMETHOD
       <L,2 PPID <L,n <L,2 RCPPARNM RCPPARVAL>>>
       <L,n MTRLOUTSPEC>
       <L,n <L,2 PARAMNAME PARAMVAL>>>

ProcessJob now carries the extra fields (MaterialFlag, ProcessRecipeMethod,
RcpVar[], ProcessParam[]) so a tool's recipe engine can later consume
the recipe-variable overrides and per-job process parameters.  Server
S16F11 dispatch populates them via the new ProcessJobStore::set_e40_extras
helper after a successful create.

MaterialFlag + ProcessRecipeMethod enums live in their own tiny header
(`e40_constants.hpp`) so process_jobs.hpp (the store) can use them
without dragging in messages_helpers.hpp (which would create a circular
include via data_model.hpp).

The simplified 3-arg HostHandler::send_create_process_job convenience
remains; it constructs a sensible-default PRJobCreateRequest internally.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
2026-06-08 23:44:05 +02:00

1047 lines
37 KiB
C++
Raw Blame History

#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);
}
Reference in New Issue View Git Blame Copy Permalink