raphael/secs-gem
Public Access
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
b59c62bbc94a085dd9b02d8f687451af46f6c8da
secs-gem/tests/test_messages.cpp
T
raphael b59c62bbc9 A1: S5F13-F18 exception recovery messages (E5 §9.5-9.7) 
Catalog gains the recover-request / recover-complete / recover-abort
loop that closes E5's exception lifecycle.  Wire shapes:

  S5F13/F14  Exception Recover Request / Acknowledge
  S5F15/F16  Exception Recover Complete Notify / Acknowledge
  S5F17/F18  Exception Recover Abort Request / Acknowledge

Acks use the same AlarmAck byte already in use by S5F10/F12.  EXRESULT
on F15 is modelled as ASCII (the common case; vendor-specific richer
shapes are a YAML edit).

Round-trip tests cover all three pairs.  Server dispatch is left for a
later commit alongside the per-alarm AlarmStateMachine (Tranche C) —
this commit is wire-coverage only.

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

629 lines
23 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("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("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("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") {
auto req = s16f11_pr_job_create("PJ-1", "RECIPE-A", {"WFR-1", "WFR-2"});
CHECK(req.stream == 16);
CHECK(req.function == 11);
auto parsed = parse_s16f11(req);
REQUIRE(parsed.has_value());
CHECK(parsed->prjobid == "PJ-1");
CHECK(parsed->ppid == "RECIPE-A");
CHECK(parsed->mtrloutspec == std::vector<std::string>{"WFR-1", "WFR-2"});
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("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);
}
Reference in New Issue View Git Blame Copy Permalink