@padosoft/react-native-ecr17 0.0.0 → 2.0.1

package/cpp/tests/test_integration_terminal.cpp

@@ -1,72 +1,72 @@
-// OPT-IN real-terminal integration test.
-//
-// Skipped unless ECR17_TERMINAL_HOST is set, so it never affects CI. To run it
-// against a real Nexi terminal on your LAN:
-//
-//   ECR17_TERMINAL_HOST=192.168.1.50 \
-//   ECR17_TERMINAL_PORT=10000 \
-//   ECR17_TERMINAL_ID=00000000 \
-//   ECR17_LRC_MODE=std \
-//   ctest --test-dir build --output-on-failure -R Integration
-//
-// It connects over real TCP, sends a Terminal Status ('s') request through the
-// full C++ core (builder -> session/ACK-NAK -> parser) and prints the result.
-
-#if !defined(_WIN32)
-
-#include <gtest/gtest.h>
-
-#include <cstdlib>
-#include <iostream>
-#include <string>
-
-#include "Ecr17Protocol/Ecr17Protocol.hpp"
-#include "Ecr17Response/Ecr17Response.hpp"
-#include "PosixTcpTransport.hpp"
-#include "Session/Ecr17Session.hpp"
-
-using namespace margelo::nitro::ecr17;
-
-namespace {
-LrcMode lrcModeFromEnv() {
-    const char* m = std::getenv("ECR17_LRC_MODE");
-    const std::string mode = m ? m : "std";
-    if (mode == "stx") return LrcMode::STX;
-    if (mode == "noext") return LrcMode::NOEXT;
-    if (mode == "stx_noext") return LrcMode::STX_NOEXT;
-    return LrcMode::STD;
-}
-}  // namespace
-
-TEST(Integration, RealTerminalStatus) {
-    const char* host = std::getenv("ECR17_TERMINAL_HOST");
-    if (host == nullptr) {
-        GTEST_SKIP() << "set ECR17_TERMINAL_HOST to run against a real terminal";
-    }
-    const char* portEnv = std::getenv("ECR17_TERMINAL_PORT");
-    const char* idEnv = std::getenv("ECR17_TERMINAL_ID");
-    const int port = portEnv ? std::atoi(portEnv) : 10000;
-    const std::string terminalId = idEnv ? idEnv : "00000000";
-
-    PosixTcpTransport transport(host, port);
-    transport.connect();
-
-    SessionConfig cfg;
-    cfg.lrcMode = lrcModeFromEnv();
-    cfg.ackTimeoutMs = 3000;
-    cfg.responseTimeoutMs = 15000;
-    Ecr17Session session(transport, cfg);
-
-    DecodedPacket pkt = session.exchange(Ecr17Protocol::buildStatusMessage(terminalId));
-    StatusResponse status = Ecr17Response::parseStatus(pkt.payload);
-
-    std::cout << "[ECR17] terminalId=" << status.terminalId << " status=" << status.status
-              << " dateTime=" << status.dateTimeRaw << " sw=" << status.softwareRelease << std::endl;
-
-    EXPECT_TRUE(pkt.validLrc);
-    EXPECT_FALSE(status.terminalId.empty());
-
-    transport.disconnect();
-}
-
-#endif  // !_WIN32
+// OPT-IN real-terminal integration test.
+//
+// Skipped unless ECR17_TERMINAL_HOST is set, so it never affects CI. To run it
+// against a real Nexi terminal on your LAN:
+//
+//   ECR17_TERMINAL_HOST=192.168.1.50 \
+//   ECR17_TERMINAL_PORT=10000 \
+//   ECR17_TERMINAL_ID=00000000 \
+//   ECR17_LRC_MODE=std \
+//   ctest --test-dir build --output-on-failure -R Integration
+//
+// It connects over real TCP, sends a Terminal Status ('s') request through the
+// full C++ core (builder -> session/ACK-NAK -> parser) and prints the result.
+
+#if !defined(_WIN32)
+
+#include <gtest/gtest.h>
+
+#include <cstdlib>
+#include <iostream>
+#include <string>
+
+#include "Ecr17Protocol/Ecr17Protocol.hpp"
+#include "Ecr17Response/Ecr17Response.hpp"
+#include "PosixTcpTransport.hpp"
+#include "Session/Ecr17Session.hpp"
+
+using namespace margelo::nitro::ecr17;
+
+namespace {
+LrcMode lrcModeFromEnv() {
+    const char* m = std::getenv("ECR17_LRC_MODE");
+    const std::string mode = m ? m : "std";
+    if (mode == "stx") return LrcMode::STX;
+    if (mode == "noext") return LrcMode::NOEXT;
+    if (mode == "stx_noext") return LrcMode::STX_NOEXT;
+    return LrcMode::STD;
+}
+}  // namespace
+
+TEST(Integration, RealTerminalStatus) {
+    const char* host = std::getenv("ECR17_TERMINAL_HOST");
+    if (host == nullptr) {
+        GTEST_SKIP() << "set ECR17_TERMINAL_HOST to run against a real terminal";
+    }
+    const char* portEnv = std::getenv("ECR17_TERMINAL_PORT");
+    const char* idEnv = std::getenv("ECR17_TERMINAL_ID");
+    const int port = portEnv ? std::atoi(portEnv) : 10000;
+    const std::string terminalId = idEnv ? idEnv : "00000000";
+
+    PosixTcpTransport transport(host, port);
+    transport.connect();
+
+    SessionConfig cfg;
+    cfg.lrcMode = lrcModeFromEnv();
+    cfg.ackTimeoutMs = 3000;
+    cfg.responseTimeoutMs = 15000;
+    Ecr17Session session(transport, cfg);
+
+    DecodedPacket pkt = session.exchange(Ecr17Protocol::buildStatusMessage(terminalId));
+    StatusResponse status = Ecr17Response::parseStatus(pkt.payload);
+
+    std::cout << "[ECR17] terminalId=" << status.terminalId << " status=" << status.status
+              << " dateTime=" << status.dateTimeRaw << " sw=" << status.softwareRelease << std::endl;
+
+    EXPECT_TRUE(pkt.validLrc);
+    EXPECT_FALSE(status.terminalId.empty());
+
+    transport.disconnect();
+}
+
+#endif  // !_WIN32

package/cpp/tests/test_lrc.cpp

@@ -1,66 +1,66 @@
-#include <gtest/gtest.h>
-
-#include <cstdint>
-#include <string>
-#include <vector>
-
-#include "Lcr/Lcr.hpp"
-
-using margelo::nitro::ecr17::Lrc;
-using margelo::nitro::ecr17::LrcMode;
-
-namespace {
-
-constexpr uint8_t kBase = 0x7F;
-constexpr uint8_t kStx = 0x02;
-constexpr uint8_t kEtx = 0x03;
-
-// Reference implementation kept intentionally independent from the production
-// code, so the tests assert against first principles rather than a copy.
-uint8_t reference(const std::vector<uint8_t>& payload, LrcMode mode) {
-    uint8_t lrc = kBase;
-    if (mode == LrcMode::STX || mode == LrcMode::STX_NOEXT) {
-        lrc ^= kStx;
-    }
-    for (uint8_t b : payload) {
-        lrc ^= b;
-    }
-    if (mode == LrcMode::STX || mode == LrcMode::NOEXT) {
-        lrc ^= kEtx;
-    }
-    return lrc;
-}
-
-}  // namespace
-
-TEST(Lrc, EmptyPayloadStdIsBase) {
-    EXPECT_EQ(Lrc::compute(std::vector<uint8_t>{}, LrcMode::STD), kBase);
-}
-
-TEST(Lrc, EmptyPayloadStxFoldsStxAndEtx) {
-    // 0x7F ^ 0x02 ^ 0x03 == 0x7E
-    EXPECT_EQ(Lrc::compute(std::vector<uint8_t>{}, LrcMode::STX), 0x7E);
-}
-
-TEST(Lrc, KnownVectorAllModes) {
-    const std::vector<uint8_t> payload{'A'};  // 0x41
-    EXPECT_EQ(Lrc::compute(payload, LrcMode::STD), 0x3E);
-    EXPECT_EQ(Lrc::compute(payload, LrcMode::STX), 0x3F);
-    EXPECT_EQ(Lrc::compute(payload, LrcMode::NOEXT), 0x3D);
-    EXPECT_EQ(Lrc::compute(payload, LrcMode::STX_NOEXT), 0x3C);
-}
-
-TEST(Lrc, MatchesReferenceForEveryMode) {
-    const std::vector<uint8_t> payload{0x00, 0x7F, 0x55, 0xAA, 'Z', 0x10};
-    for (LrcMode mode : {LrcMode::STX, LrcMode::STD, LrcMode::NOEXT, LrcMode::STX_NOEXT}) {
-        EXPECT_EQ(Lrc::compute(payload, mode), reference(payload, mode));
-    }
-}
-
-TEST(Lrc, StringAndVectorOverloadsAgree) {
-    const std::string payload = "12345678P0";
-    const std::vector<uint8_t> bytes(payload.begin(), payload.end());
-    for (LrcMode mode : {LrcMode::STX, LrcMode::STD, LrcMode::NOEXT, LrcMode::STX_NOEXT}) {
-        EXPECT_EQ(Lrc::compute(payload, mode), Lrc::compute(bytes, mode));
-    }
-}
+#include <gtest/gtest.h>
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "Lcr/Lcr.hpp"
+
+using margelo::nitro::ecr17::Lrc;
+using margelo::nitro::ecr17::LrcMode;
+
+namespace {
+
+constexpr uint8_t kBase = 0x7F;
+constexpr uint8_t kStx = 0x02;
+constexpr uint8_t kEtx = 0x03;
+
+// Reference implementation kept intentionally independent from the production
+// code, so the tests assert against first principles rather than a copy.
+uint8_t reference(const std::vector<uint8_t>& payload, LrcMode mode) {
+    uint8_t lrc = kBase;
+    if (mode == LrcMode::STX || mode == LrcMode::STX_NOEXT) {
+        lrc ^= kStx;
+    }
+    for (uint8_t b : payload) {
+        lrc ^= b;
+    }
+    if (mode == LrcMode::STX || mode == LrcMode::NOEXT) {
+        lrc ^= kEtx;
+    }
+    return lrc;
+}
+
+}  // namespace
+
+TEST(Lrc, EmptyPayloadStdIsBase) {
+    EXPECT_EQ(Lrc::compute(std::vector<uint8_t>{}, LrcMode::STD), kBase);
+}
+
+TEST(Lrc, EmptyPayloadStxFoldsStxAndEtx) {
+    // 0x7F ^ 0x02 ^ 0x03 == 0x7E
+    EXPECT_EQ(Lrc::compute(std::vector<uint8_t>{}, LrcMode::STX), 0x7E);
+}
+
+TEST(Lrc, KnownVectorAllModes) {
+    const std::vector<uint8_t> payload{'A'};  // 0x41
+    EXPECT_EQ(Lrc::compute(payload, LrcMode::STD), 0x3E);
+    EXPECT_EQ(Lrc::compute(payload, LrcMode::STX), 0x3F);
+    EXPECT_EQ(Lrc::compute(payload, LrcMode::NOEXT), 0x3D);
+    EXPECT_EQ(Lrc::compute(payload, LrcMode::STX_NOEXT), 0x3C);
+}
+
+TEST(Lrc, MatchesReferenceForEveryMode) {
+    const std::vector<uint8_t> payload{0x00, 0x7F, 0x55, 0xAA, 'Z', 0x10};
+    for (LrcMode mode : {LrcMode::STX, LrcMode::STD, LrcMode::NOEXT, LrcMode::STX_NOEXT}) {
+        EXPECT_EQ(Lrc::compute(payload, mode), reference(payload, mode));
+    }
+}
+
+TEST(Lrc, StringAndVectorOverloadsAgree) {
+    const std::string payload = "12345678P0";
+    const std::vector<uint8_t> bytes(payload.begin(), payload.end());
+    for (LrcMode mode : {LrcMode::STX, LrcMode::STD, LrcMode::NOEXT, LrcMode::STX_NOEXT}) {
+        EXPECT_EQ(Lrc::compute(payload, mode), Lrc::compute(bytes, mode));
+    }
+}

package/cpp/tests/test_packet_codec.cpp

@@ -1,164 +1,164 @@
-#include <gtest/gtest.h>
-
-#include <cstdint>
-#include <string>
-#include <vector>
-
-#include "PacketCodec/PacketCodec.hpp"
-
-using margelo::nitro::ecr17::DecodedPacket;
-using margelo::nitro::ecr17::LrcMode;
-using margelo::nitro::ecr17::PacketCodec;
-using margelo::nitro::ecr17::PacketType;
-
-namespace {
-constexpr uint8_t kSoh = 0x01;
-constexpr uint8_t kStx = 0x02;
-constexpr uint8_t kEtx = 0x03;
-constexpr uint8_t kEot = 0x04;
-constexpr uint8_t kAck = 0x06;
-constexpr uint8_t kNak = 0x15;
-}  // namespace
-
-TEST(PacketCodec, EncodeApplicationFramesStxPayloadEtxLrc) {
-    PacketCodec codec(LrcMode::STD);
-    auto frame = codec.encodeApplication("AB");
-    ASSERT_EQ(frame.size(), 5u);
-    EXPECT_EQ(frame[0], kStx);
-    EXPECT_EQ(frame[1], 'A');
-    EXPECT_EQ(frame[2], 'B');
-    EXPECT_EQ(frame[3], kEtx);
-    EXPECT_EQ(frame[4], 0x7C);  // 0x7F ^ 'A' ^ 'B'
-}
-
-TEST(PacketCodec, ApplicationRoundTrip) {
-    for (LrcMode mode : {LrcMode::STX, LrcMode::STD, LrcMode::NOEXT, LrcMode::STX_NOEXT}) {
-        PacketCodec codec(mode);
-        const std::string payload = "123456780P0000065000";
-        DecodedPacket decoded = codec.decode(codec.encodeApplication(payload));
-        EXPECT_EQ(decoded.type, PacketType::APPLICATION);
-        EXPECT_EQ(decoded.payload, payload);
-        EXPECT_TRUE(decoded.validLrc);
-    }
-}
-
-TEST(PacketCodec, ApplicationDetectsCorruptedLrc) {
-    PacketCodec codec(LrcMode::STD);
-    auto frame = codec.encodeApplication("HELLO");
-    frame.back() ^= 0xFF;  // corrupt the LRC byte
-    DecodedPacket decoded = codec.decode(frame);
-    EXPECT_EQ(decoded.type, PacketType::APPLICATION);
-    EXPECT_EQ(decoded.payload, "HELLO");
-    EXPECT_FALSE(decoded.validLrc);
-}
-
-TEST(PacketCodec, EncodeControlFramesCtrlEtxLrc) {
-    PacketCodec codec(LrcMode::STD);
-    auto frame = codec.encodeControl(kAck);
-    ASSERT_EQ(frame.size(), 3u);
-    EXPECT_EQ(frame[0], kAck);
-    EXPECT_EQ(frame[1], kEtx);
-}
-
-TEST(PacketCodec, DecodeAck) {
-    PacketCodec codec(LrcMode::STD);
-    DecodedPacket decoded = codec.decode({kAck});
-    EXPECT_EQ(decoded.type, PacketType::ACK);
-    EXPECT_TRUE(decoded.validLrc);
-}
-
-TEST(PacketCodec, DecodeNak) {
-    PacketCodec codec(LrcMode::STD);
-    DecodedPacket decoded = codec.decode({kNak});
-    EXPECT_EQ(decoded.type, PacketType::NAK);
-    EXPECT_TRUE(decoded.validLrc);
-}
-
-TEST(PacketCodec, DecodeEmptyIsUnknown) {
-    PacketCodec codec(LrcMode::STD);
-    DecodedPacket decoded = codec.decode({});
-    EXPECT_EQ(decoded.type, PacketType::UNKNOWN);
-    EXPECT_FALSE(decoded.validLrc);
-}
-
-// Regression: a lone SOH byte previously built a string from an inverted
-// iterator range [begin()+1, end()-1) == [end(), begin()) -> UB/crash.
-TEST(PacketCodec, DecodeLoneSohIsUnknownNotCrash) {
-    PacketCodec codec(LrcMode::STD);
-    DecodedPacket decoded = codec.decode({kSoh});
-    EXPECT_EQ(decoded.type, PacketType::UNKNOWN);
-    EXPECT_FALSE(decoded.validLrc);
-}
-
-TEST(PacketCodec, DecodeProgressUpdate) {
-    PacketCodec codec(LrcMode::STD);
-    std::vector<uint8_t> frame{kSoh};
-    const std::string msg = "ELABORAZIONE...     ";  // 20 chars per spec
-    frame.insert(frame.end(), msg.begin(), msg.end());
-    frame.push_back(kEot);
-
-    DecodedPacket decoded = codec.decode(frame);
-    EXPECT_EQ(decoded.type, PacketType::PROGRESS);
-    EXPECT_EQ(decoded.payload, msg);
-}
-
-TEST(PacketCodec, DecodeStxWithoutEtxIsUnknown) {
-    PacketCodec codec(LrcMode::STD);
-    DecodedPacket decoded = codec.decode({kStx, 'A', 'B'});
-    EXPECT_EQ(decoded.type, PacketType::UNKNOWN);
-    EXPECT_FALSE(decoded.validLrc);
-}
-
-// Regression: ETX present but no trailing LRC byte must not read past the end
-// nor mistake ETX for the LRC.
-TEST(PacketCodec, DecodeStxWithEtxButNoLrcIsUnknown) {
-    PacketCodec codec(LrcMode::STD);
-    DecodedPacket decoded = codec.decode({kStx, 'A', kEtx});
-    EXPECT_EQ(decoded.type, PacketType::UNKNOWN);
-    EXPECT_FALSE(decoded.validLrc);
-}
-
-TEST(PacketCodec, DecodeUnknownLeadByte) {
-    PacketCodec codec(LrcMode::STD);
-    DecodedPacket decoded = codec.decode({0x99, 0x00});
-    EXPECT_EQ(decoded.type, PacketType::UNKNOWN);
-    EXPECT_FALSE(decoded.validLrc);
-}
-
-// Regression: trailing bytes after a complete frame's LRC must not be silently
-// accepted (the LRC must be the final byte).
-TEST(PacketCodec, DecodeStxWithTrailingBytesAfterLrcIsUnknown) {
-    PacketCodec codec(LrcMode::STD);
-    auto frame = codec.encodeApplication("AB");  // STX A B ETX LRC
-    frame.push_back(0x00);                        // stray trailing byte
-    DecodedPacket decoded = codec.decode(frame);
-    EXPECT_EQ(decoded.type, PacketType::UNKNOWN);
-    EXPECT_FALSE(decoded.validLrc);
-}
-
-// Regression: a coalesced read holding two frames must not be reported as one
-// valid APPLICATION packet (which would silently drop the second frame).
-// Framing/splitting a byte stream is the transport layer's job.
-TEST(PacketCodec, DecodeCoalescedFramesIsUnknown) {
-    PacketCodec codec(LrcMode::STD);
-    auto first = codec.encodeApplication("AB");
-    auto second = codec.encodeApplication("CD");
-    first.insert(first.end(), second.begin(), second.end());
-    DecodedPacket decoded = codec.decode(first);
-    EXPECT_EQ(decoded.type, PacketType::UNKNOWN);
-    EXPECT_FALSE(decoded.validLrc);
-}
-
-// Regression: SOH frame whose last byte is not EOT must not be accepted as a
-// valid PROGRESS packet. Only SOH + payload + EOT is well-formed per spec.
-TEST(PacketCodec, DecodeSohWithoutEotIsUnknown) {
-    PacketCodec codec(LrcMode::STD);
-    // SOH + 20-char message, but terminated with 0xFF instead of EOT.
-    std::vector<uint8_t> frame{kSoh};
-    const std::string msg = "ELABORAZIONE...     ";
-    frame.insert(frame.end(), msg.begin(), msg.end());
-    frame.push_back(0xFF);  // wrong terminator
-    DecodedPacket decoded = codec.decode(frame);
-    EXPECT_EQ(decoded.type, PacketType::UNKNOWN);
-    EXPECT_FALSE(decoded.validLrc);
-}
+#include <gtest/gtest.h>
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "PacketCodec/PacketCodec.hpp"
+
+using margelo::nitro::ecr17::DecodedPacket;
+using margelo::nitro::ecr17::LrcMode;
+using margelo::nitro::ecr17::PacketCodec;
+using margelo::nitro::ecr17::PacketType;
+
+namespace {
+constexpr uint8_t kSoh = 0x01;
+constexpr uint8_t kStx = 0x02;
+constexpr uint8_t kEtx = 0x03;
+constexpr uint8_t kEot = 0x04;
+constexpr uint8_t kAck = 0x06;
+constexpr uint8_t kNak = 0x15;
+}  // namespace
+
+TEST(PacketCodec, EncodeApplicationFramesStxPayloadEtxLrc) {
+    PacketCodec codec(LrcMode::STD);
+    auto frame = codec.encodeApplication("AB");
+    ASSERT_EQ(frame.size(), 5u);
+    EXPECT_EQ(frame[0], kStx);
+    EXPECT_EQ(frame[1], 'A');
+    EXPECT_EQ(frame[2], 'B');
+    EXPECT_EQ(frame[3], kEtx);
+    EXPECT_EQ(frame[4], 0x7C);  // 0x7F ^ 'A' ^ 'B'
+}
+
+TEST(PacketCodec, ApplicationRoundTrip) {
+    for (LrcMode mode : {LrcMode::STX, LrcMode::STD, LrcMode::NOEXT, LrcMode::STX_NOEXT}) {
+        PacketCodec codec(mode);
+        const std::string payload = "123456780P0000065000";
+        DecodedPacket decoded = codec.decode(codec.encodeApplication(payload));
+        EXPECT_EQ(decoded.type, PacketType::APPLICATION);
+        EXPECT_EQ(decoded.payload, payload);
+        EXPECT_TRUE(decoded.validLrc);
+    }
+}
+
+TEST(PacketCodec, ApplicationDetectsCorruptedLrc) {
+    PacketCodec codec(LrcMode::STD);
+    auto frame = codec.encodeApplication("HELLO");
+    frame.back() ^= 0xFF;  // corrupt the LRC byte
+    DecodedPacket decoded = codec.decode(frame);
+    EXPECT_EQ(decoded.type, PacketType::APPLICATION);
+    EXPECT_EQ(decoded.payload, "HELLO");
+    EXPECT_FALSE(decoded.validLrc);
+}
+
+TEST(PacketCodec, EncodeControlFramesCtrlEtxLrc) {
+    PacketCodec codec(LrcMode::STD);
+    auto frame = codec.encodeControl(kAck);
+    ASSERT_EQ(frame.size(), 3u);
+    EXPECT_EQ(frame[0], kAck);
+    EXPECT_EQ(frame[1], kEtx);
+}
+
+TEST(PacketCodec, DecodeAck) {
+    PacketCodec codec(LrcMode::STD);
+    DecodedPacket decoded = codec.decode({kAck});
+    EXPECT_EQ(decoded.type, PacketType::ACK);
+    EXPECT_TRUE(decoded.validLrc);
+}
+
+TEST(PacketCodec, DecodeNak) {
+    PacketCodec codec(LrcMode::STD);
+    DecodedPacket decoded = codec.decode({kNak});
+    EXPECT_EQ(decoded.type, PacketType::NAK);
+    EXPECT_TRUE(decoded.validLrc);
+}
+
+TEST(PacketCodec, DecodeEmptyIsUnknown) {
+    PacketCodec codec(LrcMode::STD);
+    DecodedPacket decoded = codec.decode({});
+    EXPECT_EQ(decoded.type, PacketType::UNKNOWN);
+    EXPECT_FALSE(decoded.validLrc);
+}
+
+// Regression: a lone SOH byte previously built a string from an inverted
+// iterator range [begin()+1, end()-1) == [end(), begin()) -> UB/crash.
+TEST(PacketCodec, DecodeLoneSohIsUnknownNotCrash) {
+    PacketCodec codec(LrcMode::STD);
+    DecodedPacket decoded = codec.decode({kSoh});
+    EXPECT_EQ(decoded.type, PacketType::UNKNOWN);
+    EXPECT_FALSE(decoded.validLrc);
+}
+
+TEST(PacketCodec, DecodeProgressUpdate) {
+    PacketCodec codec(LrcMode::STD);
+    std::vector<uint8_t> frame{kSoh};
+    const std::string msg = "ELABORAZIONE...     ";  // 20 chars per spec
+    frame.insert(frame.end(), msg.begin(), msg.end());
+    frame.push_back(kEot);
+
+    DecodedPacket decoded = codec.decode(frame);
+    EXPECT_EQ(decoded.type, PacketType::PROGRESS);
+    EXPECT_EQ(decoded.payload, msg);
+}
+
+TEST(PacketCodec, DecodeStxWithoutEtxIsUnknown) {
+    PacketCodec codec(LrcMode::STD);
+    DecodedPacket decoded = codec.decode({kStx, 'A', 'B'});
+    EXPECT_EQ(decoded.type, PacketType::UNKNOWN);
+    EXPECT_FALSE(decoded.validLrc);
+}
+
+// Regression: ETX present but no trailing LRC byte must not read past the end
+// nor mistake ETX for the LRC.
+TEST(PacketCodec, DecodeStxWithEtxButNoLrcIsUnknown) {
+    PacketCodec codec(LrcMode::STD);
+    DecodedPacket decoded = codec.decode({kStx, 'A', kEtx});
+    EXPECT_EQ(decoded.type, PacketType::UNKNOWN);
+    EXPECT_FALSE(decoded.validLrc);
+}
+
+TEST(PacketCodec, DecodeUnknownLeadByte) {
+    PacketCodec codec(LrcMode::STD);
+    DecodedPacket decoded = codec.decode({0x99, 0x00});
+    EXPECT_EQ(decoded.type, PacketType::UNKNOWN);
+    EXPECT_FALSE(decoded.validLrc);
+}
+
+// Regression: trailing bytes after a complete frame's LRC must not be silently
+// accepted (the LRC must be the final byte).
+TEST(PacketCodec, DecodeStxWithTrailingBytesAfterLrcIsUnknown) {
+    PacketCodec codec(LrcMode::STD);
+    auto frame = codec.encodeApplication("AB");  // STX A B ETX LRC
+    frame.push_back(0x00);                        // stray trailing byte
+    DecodedPacket decoded = codec.decode(frame);
+    EXPECT_EQ(decoded.type, PacketType::UNKNOWN);
+    EXPECT_FALSE(decoded.validLrc);
+}
+
+// Regression: a coalesced read holding two frames must not be reported as one
+// valid APPLICATION packet (which would silently drop the second frame).
+// Framing/splitting a byte stream is the transport layer's job.
+TEST(PacketCodec, DecodeCoalescedFramesIsUnknown) {
+    PacketCodec codec(LrcMode::STD);
+    auto first = codec.encodeApplication("AB");
+    auto second = codec.encodeApplication("CD");
+    first.insert(first.end(), second.begin(), second.end());
+    DecodedPacket decoded = codec.decode(first);
+    EXPECT_EQ(decoded.type, PacketType::UNKNOWN);
+    EXPECT_FALSE(decoded.validLrc);
+}
+
+// Regression: SOH frame whose last byte is not EOT must not be accepted as a
+// valid PROGRESS packet. Only SOH + payload + EOT is well-formed per spec.
+TEST(PacketCodec, DecodeSohWithoutEotIsUnknown) {
+    PacketCodec codec(LrcMode::STD);
+    // SOH + 20-char message, but terminated with 0xFF instead of EOT.
+    std::vector<uint8_t> frame{kSoh};
+    const std::string msg = "ELABORAZIONE...     ";
+    frame.insert(frame.end(), msg.begin(), msg.end());
+    frame.push_back(0xFF);  // wrong terminator
+    DecodedPacket decoded = codec.decode(frame);
+    EXPECT_EQ(decoded.type, PacketType::UNKNOWN);
+    EXPECT_FALSE(decoded.validLrc);
+}