@padosoft/react-native-ecr17 0.0.0 → 2.0.0

package/cpp/tests/CMakeLists.txt

@@ -1,55 +1,55 @@
-cmake_minimum_required(VERSION 3.16)
-project(ecr17_cpp_tests CXX)
-
-set(CMAKE_CXX_STANDARD 20)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(CMAKE_CXX_EXTENSIONS OFF)
-
-# GoogleTest via FetchContent (CI has network access).
-include(FetchContent)
-FetchContent_Declare(
-  googletest
-  URL https://github.com/google/googletest/archive/refs/tags/v1.15.2.tar.gz
-)
-# Keep CRT linkage consistent on Windows runners.
-set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
-FetchContent_MakeAvailable(googletest)
-
-enable_testing()
-
-# Production C++ sources under test (../ is package/cpp).
-set(ECR17_CPP_DIR ${CMAKE_CURRENT_SOURCE_DIR}/..)
-
-add_executable(ecr17_cpp_tests
-  test_lrc.cpp
-  test_packet_codec.cpp
-  test_protocol.cpp
-  test_protocol_commands.cpp
-  test_response.cpp
-  test_session.cpp
-  test_retry_policy.cpp
-  test_integration_terminal.cpp
-  test_flows.cpp
-  ${ECR17_CPP_DIR}/Lcr/Lcr.cpp
-  ${ECR17_CPP_DIR}/PacketCodec/PacketCodec.cpp
-  ${ECR17_CPP_DIR}/Ecr17Protocol/Ecr17Protocol.cpp
-  ${ECR17_CPP_DIR}/Ecr17Response/Ecr17Response.cpp
-  ${ECR17_CPP_DIR}/Session/Ecr17Session.cpp
-)
-
-target_include_directories(ecr17_cpp_tests PRIVATE
-  ${ECR17_CPP_DIR}                  # resolves "Lcr/Lcr.hpp", "PacketCodec/..."
-  ${CMAKE_CURRENT_SOURCE_DIR}/stubs # test-only LrcMode.hpp (Nitrogen-generated in real builds)
-)
-
-if(MSVC)
-  target_compile_options(ecr17_cpp_tests PRIVATE /W4)
-else()
-  target_compile_options(ecr17_cpp_tests PRIVATE -Wall -Wextra)
-endif()
-
-find_package(Threads REQUIRED)
-target_link_libraries(ecr17_cpp_tests PRIVATE GTest::gtest_main Threads::Threads)
-
-include(GoogleTest)
-gtest_discover_tests(ecr17_cpp_tests)
+cmake_minimum_required(VERSION 3.16)
+project(ecr17_cpp_tests CXX)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+# GoogleTest via FetchContent (CI has network access).
+include(FetchContent)
+FetchContent_Declare(
+  googletest
+  URL https://github.com/google/googletest/archive/refs/tags/v1.15.2.tar.gz
+)
+# Keep CRT linkage consistent on Windows runners.
+set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+FetchContent_MakeAvailable(googletest)
+
+enable_testing()
+
+# Production C++ sources under test (../ is package/cpp).
+set(ECR17_CPP_DIR ${CMAKE_CURRENT_SOURCE_DIR}/..)
+
+add_executable(ecr17_cpp_tests
+  test_lrc.cpp
+  test_packet_codec.cpp
+  test_protocol.cpp
+  test_protocol_commands.cpp
+  test_response.cpp
+  test_session.cpp
+  test_retry_policy.cpp
+  test_integration_terminal.cpp
+  test_flows.cpp
+  ${ECR17_CPP_DIR}/Lcr/Lcr.cpp
+  ${ECR17_CPP_DIR}/PacketCodec/PacketCodec.cpp
+  ${ECR17_CPP_DIR}/Ecr17Protocol/Ecr17Protocol.cpp
+  ${ECR17_CPP_DIR}/Ecr17Response/Ecr17Response.cpp
+  ${ECR17_CPP_DIR}/Session/Ecr17Session.cpp
+)
+
+target_include_directories(ecr17_cpp_tests PRIVATE
+  ${ECR17_CPP_DIR}                  # resolves "Lcr/Lcr.hpp", "PacketCodec/..."
+  ${CMAKE_CURRENT_SOURCE_DIR}/stubs # test-only LrcMode.hpp (Nitrogen-generated in real builds)
+)
+
+if(MSVC)
+  target_compile_options(ecr17_cpp_tests PRIVATE /W4)
+else()
+  target_compile_options(ecr17_cpp_tests PRIVATE -Wall -Wextra)
+endif()
+
+find_package(Threads REQUIRED)
+target_link_libraries(ecr17_cpp_tests PRIVATE GTest::gtest_main Threads::Threads)
+
+include(GoogleTest)
+gtest_discover_tests(ecr17_cpp_tests)

package/cpp/tests/PosixTcpTransport.hpp

@@ -1,105 +1,105 @@
-#pragma once
-
-// Test-only POSIX TCP transport, used by the opt-in real-terminal integration
-// test. Lets a developer run the C++ protocol core (builders + session + parsers)
-// against an actual terminal over the LAN, without the native (Kotlin/Swift)
-// transport. POSIX-only (Linux/macOS); excluded on Windows.
-#if !defined(_WIN32)
-
-#include <arpa/inet.h>
-#include <netdb.h>
-#include <sys/socket.h>
-#include <unistd.h>
-
-#include <atomic>
-#include <cstdint>
-#include <stdexcept>
-#include <string>
-#include <thread>
-#include <vector>
-
-#include "Transport/Transport.hpp"
-
-namespace margelo::nitro::ecr17 {
-
-class PosixTcpTransport : public Transport {
-   public:
-    PosixTcpTransport(std::string host, int port) : host_(std::move(host)), port_(port) {}
-    ~PosixTcpTransport() override { disconnect(); }
-
-    void connect() override {
-        addrinfo hints{};
-        hints.ai_family = AF_UNSPEC;
-        hints.ai_socktype = SOCK_STREAM;
-        addrinfo* res = nullptr;
-        if (getaddrinfo(host_.c_str(), std::to_string(port_).c_str(), &hints, &res) != 0) {
-            throw std::runtime_error("PosixTcpTransport: host resolution failed");
-        }
-        fd_ = ::socket(res->ai_family, res->ai_socktype, res->ai_protocol);
-        if (fd_ < 0) {
-            freeaddrinfo(res);
-            throw std::runtime_error("PosixTcpTransport: socket() failed");
-        }
-        if (::connect(fd_, res->ai_addr, res->ai_addrlen) != 0) {
-            freeaddrinfo(res);
-            ::close(fd_);
-            fd_ = -1;
-            throw std::runtime_error("PosixTcpTransport: connect() failed");
-        }
-        freeaddrinfo(res);
-        running_ = true;
-        reader_ = std::thread([this]() { readLoop(); });
-    }
-
-    void disconnect() override {
-        running_ = false;
-        if (fd_ >= 0) {
-            ::shutdown(fd_, SHUT_RDWR);
-            ::close(fd_);
-            fd_ = -1;
-        }
-        if (reader_.joinable()) {
-            reader_.join();
-        }
-    }
-
-    bool isConnected() const override { return fd_ >= 0; }
-
-    void send(const std::vector<uint8_t>& bytes) override {
-        if (fd_ >= 0) {
-            ::send(fd_, bytes.data(), bytes.size(), 0);
-        }
-    }
-
-    void setDataCallback(DataCallback cb) override { onData_ = std::move(cb); }
-    void setDisconnectCallback(DisconnectCallback cb) override { onDisconnect_ = std::move(cb); }
-
-   private:
-    void readLoop() {
-        uint8_t buffer[4096];
-        while (running_) {
-            ssize_t n = ::recv(fd_, buffer, sizeof(buffer), 0);
-            if (n <= 0) {
-                break;
-            }
-            if (onData_) {
-                onData_(std::vector<uint8_t>(buffer, buffer + n));
-            }
-        }
-        if (onDisconnect_) {
-            onDisconnect_();
-        }
-    }
-
-    std::string host_;
-    int port_;
-    int fd_ = -1;
-    std::atomic<bool> running_{false};
-    std::thread reader_;
-    DataCallback onData_{};
-    DisconnectCallback onDisconnect_{};
-};
-
-}  // namespace margelo::nitro::ecr17
-
-#endif  // !_WIN32
+#pragma once
+
+// Test-only POSIX TCP transport, used by the opt-in real-terminal integration
+// test. Lets a developer run the C++ protocol core (builders + session + parsers)
+// against an actual terminal over the LAN, without the native (Kotlin/Swift)
+// transport. POSIX-only (Linux/macOS); excluded on Windows.
+#if !defined(_WIN32)
+
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include <atomic>
+#include <cstdint>
+#include <stdexcept>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include "Transport/Transport.hpp"
+
+namespace margelo::nitro::ecr17 {
+
+class PosixTcpTransport : public Transport {
+   public:
+    PosixTcpTransport(std::string host, int port) : host_(std::move(host)), port_(port) {}
+    ~PosixTcpTransport() override { disconnect(); }
+
+    void connect() override {
+        addrinfo hints{};
+        hints.ai_family = AF_UNSPEC;
+        hints.ai_socktype = SOCK_STREAM;
+        addrinfo* res = nullptr;
+        if (getaddrinfo(host_.c_str(), std::to_string(port_).c_str(), &hints, &res) != 0) {
+            throw std::runtime_error("PosixTcpTransport: host resolution failed");
+        }
+        fd_ = ::socket(res->ai_family, res->ai_socktype, res->ai_protocol);
+        if (fd_ < 0) {
+            freeaddrinfo(res);
+            throw std::runtime_error("PosixTcpTransport: socket() failed");
+        }
+        if (::connect(fd_, res->ai_addr, res->ai_addrlen) != 0) {
+            freeaddrinfo(res);
+            ::close(fd_);
+            fd_ = -1;
+            throw std::runtime_error("PosixTcpTransport: connect() failed");
+        }
+        freeaddrinfo(res);
+        running_ = true;
+        reader_ = std::thread([this]() { readLoop(); });
+    }
+
+    void disconnect() override {
+        running_ = false;
+        if (fd_ >= 0) {
+            ::shutdown(fd_, SHUT_RDWR);
+            ::close(fd_);
+            fd_ = -1;
+        }
+        if (reader_.joinable()) {
+            reader_.join();
+        }
+    }
+
+    bool isConnected() const override { return fd_ >= 0; }
+
+    void send(const std::vector<uint8_t>& bytes) override {
+        if (fd_ >= 0) {
+            ::send(fd_, bytes.data(), bytes.size(), 0);
+        }
+    }
+
+    void setDataCallback(DataCallback cb) override { onData_ = std::move(cb); }
+    void setDisconnectCallback(DisconnectCallback cb) override { onDisconnect_ = std::move(cb); }
+
+   private:
+    void readLoop() {
+        uint8_t buffer[4096];
+        while (running_) {
+            ssize_t n = ::recv(fd_, buffer, sizeof(buffer), 0);
+            if (n <= 0) {
+                break;
+            }
+            if (onData_) {
+                onData_(std::vector<uint8_t>(buffer, buffer + n));
+            }
+        }
+        if (onDisconnect_) {
+            onDisconnect_();
+        }
+    }
+
+    std::string host_;
+    int port_;
+    int fd_ = -1;
+    std::atomic<bool> running_{false};
+    std::thread reader_;
+    DataCallback onData_{};
+    DisconnectCallback onDisconnect_{};
+};
+
+}  // namespace margelo::nitro::ecr17
+
+#endif  // !_WIN32

package/cpp/tests/stubs/LrcMode.hpp

@@ -1,25 +1,25 @@
-#pragma once
-
-// TEST-ONLY STUB.
-//
-// In a real build this header is generated by Nitrogen from the TypeScript
-// union `type LrcMode = "stx" | "std" | "noext" | "stx_noext"` (see
-// package/src/types/client.ts). The unit tests compile the pure-logic C++
-// units (Lrc, PacketCodec, Ecr17Protocol) in isolation, without running
-// Nitrogen, so we provide a minimal enum that mirrors the generated one.
-//
-// The member names MUST match what the production code references
-// (Lrc.cpp uses LrcMode::STX, LrcMode::STX_NOEXT, LrcMode::NOEXT). If Nitrogen
-// turns out to emit different casing, that is a real bug to reconcile when the
-// codegen is run — this stub documents the contract the code assumes today.
-
-namespace margelo::nitro::ecr17 {
-
-enum class LrcMode {
-    STX,
-    STD,
-    NOEXT,
-    STX_NOEXT,
-};
-
-}  // namespace margelo::nitro::ecr17
+#pragma once
+
+// TEST-ONLY STUB.
+//
+// In a real build this header is generated by Nitrogen from the TypeScript
+// union `type LrcMode = "stx" | "std" | "noext" | "stx_noext"` (see
+// package/src/types/client.ts). The unit tests compile the pure-logic C++
+// units (Lrc, PacketCodec, Ecr17Protocol) in isolation, without running
+// Nitrogen, so we provide a minimal enum that mirrors the generated one.
+//
+// The member names MUST match what the production code references
+// (Lrc.cpp uses LrcMode::STX, LrcMode::STX_NOEXT, LrcMode::NOEXT). If Nitrogen
+// turns out to emit different casing, that is a real bug to reconcile when the
+// codegen is run — this stub documents the contract the code assumes today.
+
+namespace margelo::nitro::ecr17 {
+
+enum class LrcMode {
+    STX,
+    STD,
+    NOEXT,
+    STX_NOEXT,
+};
+
+}  // namespace margelo::nitro::ecr17

package/cpp/tests/test_flows.cpp

@@ -1,148 +1,148 @@
-// End-to-end protocol *flow* tests, modelled on the documented Nexi ECR17
-// sequences (basic payment, reversal/"annullamento", re-payment, status,
-// NAK retransmission).
-//
-// These exercise the layers that exist today: request building
-// (Ecr17Protocol) + physical framing (PacketCodec). Response *field* parsing
-// is not implemented yet, so terminal responses are synthesized as spec-shaped
-// payloads and asserted at the framing/classification level (packet type, LRC
-// validity, message code position), not by parsed fields.
-
-#include <gtest/gtest.h>
-
-#include <cstdint>
-#include <string>
-#include <vector>
-
-#include "Ecr17Protocol/Ecr17Protocol.hpp"
-#include "PacketCodec/PacketCodec.hpp"
-
-using namespace margelo::nitro::ecr17;
-
-namespace {
-
-constexpr uint8_t kStx = 0x02;
-constexpr uint8_t kEtx = 0x03;
-constexpr uint8_t kSoh = 0x01;
-constexpr uint8_t kEot = 0x04;
-constexpr uint8_t kAck = 0x06;
-constexpr uint8_t kNak = 0x15;
-
-const std::string kTerminal = "12345678";
-const std::string kCashReg = "00000001";
-
-// Terminal-side framing of a progress-update packet: SOH + 20-char message + EOT.
-std::vector<uint8_t> progressFrame(const std::string& msg20) {
-    std::vector<uint8_t> f{kSoh};
-    f.insert(f.end(), msg20.begin(), msg20.end());
-    f.push_back(kEot);
-    return f;
-}
-
-// Terminal-side framing of a spec-shaped result message ('E', result "00" = OK).
-std::vector<uint8_t> okResultFrame(PacketCodec& codec) {
-    std::string e = kTerminal + "0" + "E" + "00" + std::string(60, '0');
-    return codec.encodeApplication(e);
-}
-
-}  // namespace
-
-// Documented "Basic Payment Flow": request -> ACK -> progress -> result -> ACK.
-TEST(Flow, BasicPayment) {
-    PacketCodec codec(LrcMode::STD);
-
-    // 1. ECR -> POS: payment request on the wire (STX .. ETX .. LRC).
-    std::string req = Ecr17Protocol::buildPaymentMessage(kTerminal, kCashReg, 650);
-    auto reqFrame = codec.encodeApplication(req);
-    EXPECT_EQ(reqFrame.front(), kStx);
-    EXPECT_EQ(reqFrame[reqFrame.size() - 2], kEtx);
-
-    // POS validates and recovers the exact request payload.
-    DecodedPacket atPos = codec.decode(reqFrame);
-    EXPECT_EQ(atPos.type, PacketType::APPLICATION);
-    EXPECT_TRUE(atPos.validLrc);
-    EXPECT_EQ(atPos.payload, req);
-    EXPECT_EQ(atPos.payload[9], 'P');
-
-    // 2. POS -> ECR: physical ACK.
-    EXPECT_EQ(codec.decode(codec.encodeControl(kAck)).type, PacketType::ACK);
-
-    // 3. POS -> ECR: progress update while contacting the host (no LRC).
-    DecodedPacket prog = codec.decode(progressFrame("ATTENDERE PREGO     "));
-    EXPECT_EQ(prog.type, PacketType::PROGRESS);
-    EXPECT_EQ(prog.payload, "ATTENDERE PREGO     ");
-
-    // 4. POS -> ECR: positive result.
-    DecodedPacket result = codec.decode(okResultFrame(codec));
-    EXPECT_EQ(result.type, PacketType::APPLICATION);
-    EXPECT_TRUE(result.validLrc);
-    EXPECT_EQ(result.payload[9], 'E');
-    EXPECT_EQ(result.payload.substr(10, 2), "00");
-
-    // 5. ECR -> POS: ACK confirming receipt of the result.
-    EXPECT_EQ(codec.decode(codec.encodeControl(kAck)).type, PacketType::ACK);
-}
-
-// Documented NAK handling: a NAK triggers retransmission of the same message
-// (up to 3 times). Framing is deterministic, so the retransmitted bytes match.
-TEST(Flow, NakTriggersIdenticalRetransmit) {
-    PacketCodec codec(LrcMode::STD);
-    std::string req = Ecr17Protocol::buildPaymentMessage(kTerminal, kCashReg, 1999);
-    auto first = codec.encodeApplication(req);
-
-    EXPECT_EQ(codec.decode(codec.encodeControl(kNak)).type, PacketType::NAK);
-
-    auto retransmit = codec.encodeApplication(req);
-    EXPECT_EQ(first, retransmit);
-}
-
-// Documented "Reversal Last Transaction" (annullamento), command 'S'.
-TEST(Flow, ReversalAnnullamento) {
-    PacketCodec codec(LrcMode::STD);
-
-    std::string req = Ecr17Protocol::buildReversalMessage(kTerminal, kCashReg, "000123");
-    ASSERT_EQ(req.size(), 26u);
-    EXPECT_EQ(req[9], 'S');
-    EXPECT_EQ(req.substr(18, 6), "000123");
-
-    DecodedPacket atPos = codec.decode(codec.encodeApplication(req));
-    EXPECT_EQ(atPos.type, PacketType::APPLICATION);
-    EXPECT_TRUE(atPos.validLrc);
-    EXPECT_EQ(atPos.payload, req);
-
-    EXPECT_EQ(codec.decode(codec.encodeControl(kAck)).type, PacketType::ACK);
-    DecodedPacket result = codec.decode(okResultFrame(codec));
-    EXPECT_TRUE(result.validLrc);
-    EXPECT_EQ(result.payload[9], 'E');
-}
-
-// Pay -> annullamento -> ripaga (re-payment with the corrected amount).
-TEST(Flow, PayReverseRepay) {
-    PacketCodec codec(LrcMode::STD);
-
-    auto pay1 = codec.encodeApplication(Ecr17Protocol::buildPaymentMessage(kTerminal, kCashReg, 650));
-    auto rev = codec.encodeApplication(Ecr17Protocol::buildReversalMessage(kTerminal, kCashReg));
-    auto pay2 = codec.encodeApplication(Ecr17Protocol::buildPaymentMessage(kTerminal, kCashReg, 720));
-
-    for (const auto* frame : {&pay1, &rev, &pay2}) {
-        DecodedPacket d = codec.decode(*frame);
-        EXPECT_EQ(d.type, PacketType::APPLICATION);
-        EXPECT_TRUE(d.validLrc);
-    }
-
-    EXPECT_EQ(codec.decode(pay1).payload.substr(23, 8), "00000650");
-    EXPECT_EQ(codec.decode(pay2).payload.substr(23, 8), "00000720");
-    EXPECT_NE(pay1, pay2);  // the corrected re-payment differs on the wire
-}
-
-// Terminal status request/round-trip ('s').
-TEST(Flow, StatusRequest) {
-    PacketCodec codec(LrcMode::STD);
-    std::string req = Ecr17Protocol::buildStatusMessage(kTerminal);
-    EXPECT_EQ(req, "123456780s");
-
-    DecodedPacket atPos = codec.decode(codec.encodeApplication(req));
-    EXPECT_EQ(atPos.type, PacketType::APPLICATION);
-    EXPECT_TRUE(atPos.validLrc);
-    EXPECT_EQ(atPos.payload, req);
-}
+// End-to-end protocol *flow* tests, modelled on the documented Nexi ECR17
+// sequences (basic payment, reversal/"annullamento", re-payment, status,
+// NAK retransmission).
+//
+// These exercise the layers that exist today: request building
+// (Ecr17Protocol) + physical framing (PacketCodec). Response *field* parsing
+// is not implemented yet, so terminal responses are synthesized as spec-shaped
+// payloads and asserted at the framing/classification level (packet type, LRC
+// validity, message code position), not by parsed fields.
+
+#include <gtest/gtest.h>
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "Ecr17Protocol/Ecr17Protocol.hpp"
+#include "PacketCodec/PacketCodec.hpp"
+
+using namespace margelo::nitro::ecr17;
+
+namespace {
+
+constexpr uint8_t kStx = 0x02;
+constexpr uint8_t kEtx = 0x03;
+constexpr uint8_t kSoh = 0x01;
+constexpr uint8_t kEot = 0x04;
+constexpr uint8_t kAck = 0x06;
+constexpr uint8_t kNak = 0x15;
+
+const std::string kTerminal = "12345678";
+const std::string kCashReg = "00000001";
+
+// Terminal-side framing of a progress-update packet: SOH + 20-char message + EOT.
+std::vector<uint8_t> progressFrame(const std::string& msg20) {
+    std::vector<uint8_t> f{kSoh};
+    f.insert(f.end(), msg20.begin(), msg20.end());
+    f.push_back(kEot);
+    return f;
+}
+
+// Terminal-side framing of a spec-shaped result message ('E', result "00" = OK).
+std::vector<uint8_t> okResultFrame(PacketCodec& codec) {
+    std::string e = kTerminal + "0" + "E" + "00" + std::string(60, '0');
+    return codec.encodeApplication(e);
+}
+
+}  // namespace
+
+// Documented "Basic Payment Flow": request -> ACK -> progress -> result -> ACK.
+TEST(Flow, BasicPayment) {
+    PacketCodec codec(LrcMode::STD);
+
+    // 1. ECR -> POS: payment request on the wire (STX .. ETX .. LRC).
+    std::string req = Ecr17Protocol::buildPaymentMessage(kTerminal, kCashReg, 650);
+    auto reqFrame = codec.encodeApplication(req);
+    EXPECT_EQ(reqFrame.front(), kStx);
+    EXPECT_EQ(reqFrame[reqFrame.size() - 2], kEtx);
+
+    // POS validates and recovers the exact request payload.
+    DecodedPacket atPos = codec.decode(reqFrame);
+    EXPECT_EQ(atPos.type, PacketType::APPLICATION);
+    EXPECT_TRUE(atPos.validLrc);
+    EXPECT_EQ(atPos.payload, req);
+    EXPECT_EQ(atPos.payload[9], 'P');
+
+    // 2. POS -> ECR: physical ACK.
+    EXPECT_EQ(codec.decode(codec.encodeControl(kAck)).type, PacketType::ACK);
+
+    // 3. POS -> ECR: progress update while contacting the host (no LRC).
+    DecodedPacket prog = codec.decode(progressFrame("ATTENDERE PREGO     "));
+    EXPECT_EQ(prog.type, PacketType::PROGRESS);
+    EXPECT_EQ(prog.payload, "ATTENDERE PREGO     ");
+
+    // 4. POS -> ECR: positive result.
+    DecodedPacket result = codec.decode(okResultFrame(codec));
+    EXPECT_EQ(result.type, PacketType::APPLICATION);
+    EXPECT_TRUE(result.validLrc);
+    EXPECT_EQ(result.payload[9], 'E');
+    EXPECT_EQ(result.payload.substr(10, 2), "00");
+
+    // 5. ECR -> POS: ACK confirming receipt of the result.
+    EXPECT_EQ(codec.decode(codec.encodeControl(kAck)).type, PacketType::ACK);
+}
+
+// Documented NAK handling: a NAK triggers retransmission of the same message
+// (up to 3 times). Framing is deterministic, so the retransmitted bytes match.
+TEST(Flow, NakTriggersIdenticalRetransmit) {
+    PacketCodec codec(LrcMode::STD);
+    std::string req = Ecr17Protocol::buildPaymentMessage(kTerminal, kCashReg, 1999);
+    auto first = codec.encodeApplication(req);
+
+    EXPECT_EQ(codec.decode(codec.encodeControl(kNak)).type, PacketType::NAK);
+
+    auto retransmit = codec.encodeApplication(req);
+    EXPECT_EQ(first, retransmit);
+}
+
+// Documented "Reversal Last Transaction" (annullamento), command 'S'.
+TEST(Flow, ReversalAnnullamento) {
+    PacketCodec codec(LrcMode::STD);
+
+    std::string req = Ecr17Protocol::buildReversalMessage(kTerminal, kCashReg, "000123");
+    ASSERT_EQ(req.size(), 26u);
+    EXPECT_EQ(req[9], 'S');
+    EXPECT_EQ(req.substr(18, 6), "000123");
+
+    DecodedPacket atPos = codec.decode(codec.encodeApplication(req));
+    EXPECT_EQ(atPos.type, PacketType::APPLICATION);
+    EXPECT_TRUE(atPos.validLrc);
+    EXPECT_EQ(atPos.payload, req);
+
+    EXPECT_EQ(codec.decode(codec.encodeControl(kAck)).type, PacketType::ACK);
+    DecodedPacket result = codec.decode(okResultFrame(codec));
+    EXPECT_TRUE(result.validLrc);
+    EXPECT_EQ(result.payload[9], 'E');
+}
+
+// Pay -> annullamento -> ripaga (re-payment with the corrected amount).
+TEST(Flow, PayReverseRepay) {
+    PacketCodec codec(LrcMode::STD);
+
+    auto pay1 = codec.encodeApplication(Ecr17Protocol::buildPaymentMessage(kTerminal, kCashReg, 650));
+    auto rev = codec.encodeApplication(Ecr17Protocol::buildReversalMessage(kTerminal, kCashReg));
+    auto pay2 = codec.encodeApplication(Ecr17Protocol::buildPaymentMessage(kTerminal, kCashReg, 720));
+
+    for (const auto* frame : {&pay1, &rev, &pay2}) {
+        DecodedPacket d = codec.decode(*frame);
+        EXPECT_EQ(d.type, PacketType::APPLICATION);
+        EXPECT_TRUE(d.validLrc);
+    }
+
+    EXPECT_EQ(codec.decode(pay1).payload.substr(23, 8), "00000650");
+    EXPECT_EQ(codec.decode(pay2).payload.substr(23, 8), "00000720");
+    EXPECT_NE(pay1, pay2);  // the corrected re-payment differs on the wire
+}
+
+// Terminal status request/round-trip ('s').
+TEST(Flow, StatusRequest) {
+    PacketCodec codec(LrcMode::STD);
+    std::string req = Ecr17Protocol::buildStatusMessage(kTerminal);
+    EXPECT_EQ(req, "123456780s");
+
+    DecodedPacket atPos = codec.decode(codec.encodeApplication(req));
+    EXPECT_EQ(atPos.type, PacketType::APPLICATION);
+    EXPECT_TRUE(atPos.validLrc);
+    EXPECT_EQ(atPos.payload, req);
+}