@padosoft/react-native-ecr17 0.0.0

package/cpp/tests/test_packet_codec.cpp

@@ -0,0 +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);
+}

package/cpp/tests/test_protocol.cpp

@@ -0,0 +1,102 @@
+#include <gtest/gtest.h>
+
+#include <stdexcept>
+#include <string>
+
+#include "Ecr17Protocol/Ecr17Protocol.hpp"
+
+using margelo::nitro::ecr17::Ecr17Protocol;
+
+// Field layout reference (1-based positions from the Nexi ECR17 spec, Payment
+// request "P"):
+//   1   8  Terminal ID
+//   9   1  Reserved '0'
+//   10  1  Message code 'P'
+//   11  8  Cash register ID
+//   19  1  Presence of additional data for GT
+//   20  2  Reserved "00"
+//   22  1  Start transaction when card already present
+//   23  1  Payment type
+//   24  8  Transaction amount (right aligned, '0' filled)
+//   32  128 Text to print (' ' filled)
+//   160 8  Reserved '0'  => total 167 bytes
+
+TEST(Protocol, StatusMessageLayout) {
+    std::string m = Ecr17Protocol::buildStatusMessage("42");
+    ASSERT_EQ(m.size(), 10u);
+    EXPECT_EQ(m.substr(0, 8), "00000042");  // terminal id, left-padded
+    EXPECT_EQ(m[8], '0');                    // reserved
+    EXPECT_EQ(m[9], 's');                    // lowercase message code per spec
+}
+
+TEST(Protocol, StatusMessageKeepsFullWidthId) {
+    std::string m = Ecr17Protocol::buildStatusMessage("12345678");
+    EXPECT_EQ(m, "123456780s");
+}
+
+TEST(Protocol, PaymentMessageIs167Bytes) {
+    std::string m = Ecr17Protocol::buildPaymentMessage("1", "2", 650);
+    EXPECT_EQ(m.size(), 167u);
+}
+
+TEST(Protocol, PaymentMessageFieldLayout) {
+    std::string m = Ecr17Protocol::buildPaymentMessage("12345678", "87654321", 650);
+    ASSERT_EQ(m.size(), 167u);
+    EXPECT_EQ(m.substr(0, 8), "12345678");           // terminal id
+    EXPECT_EQ(m[8], '0');                              // reserved
+    EXPECT_EQ(m[9], 'P');                              // message code
+    EXPECT_EQ(m.substr(10, 8), "87654321");           // cash register id
+    EXPECT_EQ(m[18], '0');                             // presence of additional data
+    EXPECT_EQ(m.substr(19, 2), "00");                 // reserved
+    EXPECT_EQ(m[21], '0');                             // start-with-card
+    EXPECT_EQ(m[22], '0');                             // payment type
+    EXPECT_EQ(m.substr(23, 8), "00000650");           // amount, right aligned
+    EXPECT_EQ(m.substr(31, 128), std::string(128, ' '));  // text field
+    EXPECT_EQ(m.substr(159, 8), "00000000");          // trailing reserved
+}
+
+TEST(Protocol, PaymentMessageAmountMaxFits) {
+    std::string m = Ecr17Protocol::buildPaymentMessage("1", "2", 99999999);
+    EXPECT_EQ(m.substr(23, 8), "99999999");
+}
+
+TEST(Protocol, PaymentRejectsNegativeAmount) {
+    EXPECT_THROW(Ecr17Protocol::buildPaymentMessage("1", "2", -1), std::invalid_argument);
+}
+
+TEST(Protocol, PaymentRejectsAmountOverflowingField) {
+    // 9 digits does not fit the 8-byte amount field.
+    EXPECT_THROW(Ecr17Protocol::buildPaymentMessage("1", "2", 100000000), std::invalid_argument);
+}
+
+TEST(Protocol, PaymentRejectsOversizedTerminalId) {
+    EXPECT_THROW(Ecr17Protocol::buildPaymentMessage("123456789", "2", 650), std::invalid_argument);
+}
+
+TEST(Protocol, StatusRejectsOversizedTerminalId) {
+    EXPECT_THROW(Ecr17Protocol::buildStatusMessage("123456789"), std::invalid_argument);
+}
+
+// Reversal request "S" layout (1-based spec positions):
+//   1 8 Terminal ID · 9 1 Reserved · 10 1 'S' · 11 8 Cash register ID
+//   19 6 STAN · 25 1 Presence of GT data · 26 1 Reserved  => 26 bytes
+TEST(Protocol, ReversalMessageLayout) {
+    std::string m = Ecr17Protocol::buildReversalMessage("12345678", "87654321", "000123");
+    ASSERT_EQ(m.size(), 26u);
+    EXPECT_EQ(m.substr(0, 8), "12345678");
+    EXPECT_EQ(m[8], '0');
+    EXPECT_EQ(m[9], 'S');
+    EXPECT_EQ(m.substr(10, 8), "87654321");
+    EXPECT_EQ(m.substr(18, 6), "000123");
+    EXPECT_EQ(m[24], '0');
+    EXPECT_EQ(m[25], '0');
+}
+
+TEST(Protocol, ReversalDefaultStanIsNoCheck) {
+    std::string m = Ecr17Protocol::buildReversalMessage("12345678", "87654321");
+    EXPECT_EQ(m.substr(18, 6), "000000");
+}
+
+TEST(Protocol, ReversalRejectsOversizedStan) {
+    EXPECT_THROW(Ecr17Protocol::buildReversalMessage("1", "2", "1234567"), std::invalid_argument);
+}

package/cpp/tests/test_protocol_commands.cpp

@@ -0,0 +1,190 @@
+// Byte-layout tests for the full ECR17 command builder set (Phase 1).
+// Positions are checked against the Nexi ECR17 spec tables in docs/.
+
+#include <gtest/gtest.h>
+
+#include <stdexcept>
+#include <string>
+
+#include "Ecr17Protocol/Ecr17Protocol.hpp"
+
+using margelo::nitro::ecr17::Ecr17Protocol;
+
+namespace {
+constexpr char kFieldSep = 0x1B;
+const std::string T = "12345678";   // terminal id
+const std::string C = "87654321";   // cash register id
+}  // namespace
+
+// --- Payment family (167 bytes) --------------------------------------------
+
+TEST(Commands, ExtendedPaymentLayoutAndFlags) {
+    std::string m = Ecr17Protocol::buildExtendedPaymentMessage(T, C, 650, '2', true, true, "ABC");
+    ASSERT_EQ(m.size(), 167u);
+    EXPECT_EQ(m.substr(0, 8), T);
+    EXPECT_EQ(m[8], '0');
+    EXPECT_EQ(m[9], 'X');
+    EXPECT_EQ(m.substr(10, 8), C);
+    EXPECT_EQ(m[18], '1');                       // withAdditionalData
+    EXPECT_EQ(m.substr(19, 2), "00");
+    EXPECT_EQ(m[21], '1');                       // cardAlreadyPresent
+    EXPECT_EQ(m[22], '2');                       // payment type
+    EXPECT_EQ(m.substr(23, 8), "00000650");      // amount
+    EXPECT_EQ(m.substr(31, 125), std::string(125, ' '));  // text left-padding
+    EXPECT_EQ(m.substr(156, 3), "ABC");          // text right-aligned
+    EXPECT_EQ(m.substr(159, 8), "00000000");
+}
+
+TEST(Commands, PreAuthUsesCodeLowerP) {
+    std::string m = Ecr17Protocol::buildPreAuthMessage(T, C, 1000);
+    ASSERT_EQ(m.size(), 167u);
+    EXPECT_EQ(m[9], 'p');
+    EXPECT_EQ(m.substr(23, 8), "00001000");
+}
+
+TEST(Commands, PaymentDefaultsMatchBasicLayout) {
+    std::string m = Ecr17Protocol::buildPaymentMessage(T, C, 650);
+    ASSERT_EQ(m.size(), 167u);
+    EXPECT_EQ(m[9], 'P');
+    EXPECT_EQ(m[18], '0');  // no additional data by default
+    EXPECT_EQ(m[21], '0');  // card not present by default
+    EXPECT_EQ(m[22], '0');  // auto payment type by default
+    EXPECT_EQ(m.substr(31, 128), std::string(128, ' '));
+}
+
+// --- Pre-auth integration / closure (176 bytes) ----------------------------
+
+TEST(Commands, IncrementalLayout) {
+    std::string m = Ecr17Protocol::buildIncrementalMessage(T, C, 1000, "123456789");
+    ASSERT_EQ(m.size(), 176u);
+    EXPECT_EQ(m[9], 'i');
+    EXPECT_EQ(m.substr(19, 4), "0000");
+    EXPECT_EQ(m.substr(23, 8), "00001000");
+    EXPECT_EQ(m.substr(159, 9), "123456789");  // original pre-auth code
+    EXPECT_EQ(m.substr(168, 8), "00000000");
+}
+
+TEST(Commands, PreAuthClosureLayout) {
+    std::string m = Ecr17Protocol::buildPreAuthClosureMessage(T, C, 500, "000000042");
+    ASSERT_EQ(m.size(), 176u);
+    EXPECT_EQ(m[9], 'c');
+    EXPECT_EQ(m.substr(159, 9), "000000042");
+}
+
+// --- Card verification (39 bytes) ------------------------------------------
+
+TEST(Commands, CardVerificationLayout) {
+    std::string m = Ecr17Protocol::buildCardVerificationMessage(T, C, '1');
+    ASSERT_EQ(m.size(), 39u);
+    EXPECT_EQ(m[9], 'H');
+    EXPECT_EQ(m.substr(10, 8), C);
+    EXPECT_EQ(m[18], '0');                       // no additional data
+    EXPECT_EQ(m.substr(19, 2), "00");
+    EXPECT_EQ(m[21], '0');                       // standard verification
+    EXPECT_EQ(m[22], '1');                       // payment type
+    EXPECT_EQ(m.substr(23, 16), std::string(16, '0'));
+}
+
+// --- Session commands (26 bytes) -------------------------------------------
+
+TEST(Commands, CloseSessionLayout) {
+    std::string m = Ecr17Protocol::buildCloseSessionMessage(T, C);
+    ASSERT_EQ(m.size(), 26u);
+    EXPECT_EQ(m[9], 'C');
+    EXPECT_EQ(m.substr(10, 8), C);
+    EXPECT_EQ(m[18], '0');
+    EXPECT_EQ(m.substr(19, 7), std::string(7, '0'));
+}
+
+TEST(Commands, TotalsLayout) {
+    std::string m = Ecr17Protocol::buildTotalsMessage(T, C);
+    ASSERT_EQ(m.size(), 26u);
+    EXPECT_EQ(m[9], 'T');
+}
+
+// --- Send last result (22 bytes) -------------------------------------------
+
+TEST(Commands, SendLastResultLayout) {
+    std::string m = Ecr17Protocol::buildSendLastResultMessage(T, C);
+    ASSERT_EQ(m.size(), 22u);
+    EXPECT_EQ(m[9], 'G');
+    EXPECT_EQ(m.substr(19, 3), "000");
+}
+
+// --- Enable/disable ECR printing (11 bytes) --------------------------------
+
+TEST(Commands, EnableEcrPrintLayout) {
+    EXPECT_EQ(Ecr17Protocol::buildEnableEcrPrintMessage(T, true), "123456780E1");
+    EXPECT_EQ(Ecr17Protocol::buildEnableEcrPrintMessage(T, false), "123456780E0");
+}
+
+// --- Reprint (22 bytes) -----------------------------------------------------
+
+TEST(Commands, ReprintLayout) {
+    std::string m = Ecr17Protocol::buildReprintMessage(T, true);
+    ASSERT_EQ(m.size(), 22u);
+    EXPECT_EQ(m[9], 'R');
+    EXPECT_EQ(m[10], '1');  // send to ECR
+    EXPECT_EQ(m[11], '0');  // ticket type default
+    EXPECT_EQ(m.substr(12, 10), std::string(10, '0'));
+}
+
+// --- VAS (variable, length-prefixed) ---------------------------------------
+
+TEST(Commands, VasLayoutAndLengthPrefix) {
+    std::string m = Ecr17Protocol::buildVasMessage(T, C, "<x/>");
+    ASSERT_EQ(m.size(), 30u);
+    EXPECT_EQ(m[9], 'K');
+    EXPECT_EQ(m.substr(10, 8), C);
+    EXPECT_EQ(m.substr(18, 3), "000");
+    EXPECT_EQ(m[21], '0');
+    EXPECT_EQ(m.substr(22, 4), "0004");  // length of "<x/>"
+    EXPECT_EQ(m.substr(26), "<x/>");
+}
+
+TEST(Commands, VasRejectsOversizedRequest) {
+    EXPECT_THROW(Ecr17Protocol::buildVasMessage(T, C, std::string(1025, 'x')), std::invalid_argument);
+}
+
+// --- Additional data / tokenization 'U' ------------------------------------
+
+TEST(Commands, AdditionalTagsLayout) {
+    const std::string content = "0COF0TRK123|0FNZ03";  // 18 chars
+    std::string m = Ecr17Protocol::buildAdditionalTagsMessage(T, content);
+    ASSERT_EQ(m.size(), 36u + content.size() + 1u);
+    EXPECT_EQ(m[9], 'U');
+    EXPECT_EQ(m.substr(10, 6), "000000");
+    EXPECT_EQ(m.substr(16, 2), "62");
+    EXPECT_EQ(m.substr(18, 8), "DF8D01  ");  // left-justified, blank-filled
+    EXPECT_EQ(m[26], '0');
+    EXPECT_EQ(m.substr(27, 4), "0000");
+    EXPECT_EQ(m.substr(31, 5), "00000");
+    EXPECT_EQ(m.substr(36, content.size()), content);
+    EXPECT_EQ(m.back(), kFieldSep);
+}
+
+TEST(Commands, AdditionalTagsRejectsBadContent) {
+    EXPECT_THROW(Ecr17Protocol::buildAdditionalTagsMessage(T, ""), std::invalid_argument);
+    EXPECT_THROW(Ecr17Protocol::buildAdditionalTagsMessage(T, std::string(101, 'x')),
+                 std::invalid_argument);
+}
+
+TEST(Commands, TokenizationTagFormat) {
+    EXPECT_EQ(Ecr17Protocol::formatTokenizationTag(false, "1666354841608"),
+              "0COF0TRK1666354841608|0FNZ03");
+    EXPECT_EQ(Ecr17Protocol::formatTokenizationTag(true, "ABC"), "0REC0TRKABC|0FNZ03");
+    EXPECT_THROW(Ecr17Protocol::formatTokenizationTag(false, ""), std::invalid_argument);
+    EXPECT_THROW(Ecr17Protocol::formatTokenizationTag(false, std::string(19, 'x')),
+                 std::invalid_argument);
+}
+
+// --- Validation shared via leftPad -----------------------------------------
+
+TEST(Commands, IncrementalRejectsOversizedPreAuthCode) {
+    EXPECT_THROW(Ecr17Protocol::buildIncrementalMessage(T, C, 100, "1234567890"),
+                 std::invalid_argument);  // 10 digits > 9-byte field
+}
+
+TEST(Commands, PreAuthRejectsNegativeAmount) {
+    EXPECT_THROW(Ecr17Protocol::buildPreAuthMessage(T, C, -1), std::invalid_argument);
+}

package/cpp/tests/test_response.cpp

@@ -0,0 +1,164 @@
+// Tests for the ECR17 response parsers. Payloads are synthesized field-by-field
+// at the exact 1-based offsets from the spec response tables in docs/. Helpers
+// guarantee each field's width so offsets can't drift from a miscounted space.
+
+#include <gtest/gtest.h>
+
+#include <string>
+
+#include "Ecr17Response/Ecr17Response.hpp"
+
+using namespace margelo::nitro::ecr17;
+
+namespace {
+
+// Left-justified field, right-padded with spaces to `width` (alpha fields).
+std::string a(const std::string& value, size_t width) {
+    std::string s = value;
+    s.resize(width, ' ');
+    return s;
+}
+
+// Right-justified numeric field, left-padded with '0' to `width`.
+std::string n(const std::string& value, size_t width) {
+    return std::string(width - value.size(), '0') + value;
+}
+
+}  // namespace
+
+TEST(Response, PaymentPositive) {
+    std::string p = a("12345678", 8) + "0" + "E" + "00" +  // header + result
+                    n("4111111111", 19) +                  // PAN(19)
+                    a("ICC", 3) + a("ABC123", 6) + "2111520" +  // txType authCode dateTime
+                    "2" +                                   // cardType
+                    a("ACQ", 11) + n("42", 6) + n("99", 6); // acquirer STAN idOnline
+    PaymentResponse r = Ecr17Response::parsePayment(p);
+    EXPECT_EQ(r.outcome, Outcome::Ok);
+    EXPECT_EQ(r.resultCode, "00");
+    EXPECT_EQ(r.pan, n("4111111111", 19));
+    EXPECT_EQ(r.transactionType, "ICC");
+    EXPECT_EQ(r.authCode, "ABC123");
+    EXPECT_EQ(r.hostDateTime, "2111520");
+    EXPECT_EQ(r.cardType, "2");
+    EXPECT_EQ(r.acquirerId, "ACQ");
+    EXPECT_EQ(r.stan, "000042");
+    EXPECT_EQ(r.onlineId, "000099");
+    EXPECT_FALSE(r.currency.applied);
+}
+
+TEST(Response, PaymentNegative) {
+    std::string p = a("12345678", 8) + "0" + "E" + "01" + a("CARTA RIFIUTATA", 24) +
+                    n("", 11) +           // reserved 37-47
+                    "3" + a("AC2", 11) + n("7", 6) + n("3", 6);
+    PaymentResponse r = Ecr17Response::parsePayment(p);
+    EXPECT_EQ(r.outcome, Outcome::Ko);
+    EXPECT_EQ(r.resultCode, "01");
+    EXPECT_EQ(r.errorDescription, "CARTA RIFIUTATA");
+    EXPECT_EQ(r.cardType, "3");
+    EXPECT_EQ(r.stan, "000007");
+}
+
+TEST(Response, PaymentWithCurrencyExchange) {
+    std::string base = a("12345678", 8) + "0" + "V" + "00" + n("4111111111", 19) + a("ICC", 3) +
+                       a("ABC123", 6) + "2111520" + "2" + a("ACQ", 11) + n("42", 6) + n("99", 6);
+    // actionCode(3) origAmount(8) flag(1) rate(8) ccy(3) amount(12) precision(1)
+    std::string p = base + "000" + n("650", 8) + "1" + n("12345", 8) + "USD" + n("650", 12) + "2";
+    PaymentResponse r = Ecr17Response::parsePayment(p);
+    EXPECT_EQ(r.outcome, Outcome::Ok);
+    EXPECT_TRUE(r.currency.applied);
+    EXPECT_EQ(r.currency.rate, "00012345");
+    EXPECT_EQ(r.currency.currencyCode, "USD");
+    EXPECT_EQ(r.currency.amount, "000000000650");
+    EXPECT_EQ(r.currency.precision, "2");
+}
+
+TEST(Response, Status) {
+    std::string p = a("12345678", 8) + "0" + "s" + n("", 10) +  // reserved 11-20
+                    "0102251530" + "2" + "V1.2.3";              // dateTime status sw
+    StatusResponse r = Ecr17Response::parseStatus(p);
+    EXPECT_EQ(r.terminalId, "12345678");
+    EXPECT_EQ(r.dateTimeRaw, "0102251530");
+    EXPECT_EQ(r.status, 2);
+    EXPECT_EQ(r.softwareRelease, "V1.2.3");
+}
+
+TEST(Response, Totals) {
+    std::string p = a("12345678", 8) + "0" + "T" + "00" + n("123456", 16) + n("", 6);
+    TotalsResponse r = Ecr17Response::parseTotals(p);
+    EXPECT_EQ(r.outcome, Outcome::Ok);
+    EXPECT_EQ(r.posTotal, n("123456", 16));
+}
+
+TEST(Response, ClosePositive) {
+    std::string p = a("12345678", 8) + "0" + "C" + "00" + n("1000", 16) + n("1000", 16);
+    CloseResponse r = Ecr17Response::parseClose(p);
+    EXPECT_EQ(r.outcome, Outcome::Ok);
+    EXPECT_EQ(r.posTotal, n("1000", 16));
+    EXPECT_EQ(r.hostTotal, n("1000", 16));
+}
+
+TEST(Response, CloseNegative) {
+    std::string p = a("12345678", 8) + "0" + "C" + "01" + a("SBILANCIO", 19) + "100";
+    CloseResponse r = Ecr17Response::parseClose(p);
+    EXPECT_EQ(r.outcome, Outcome::Ko);
+    EXPECT_EQ(r.errorDescription, "SBILANCIO");
+    EXPECT_EQ(r.actionCode, "100");
+}
+
+TEST(Response, PreAuthPositive) {
+    std::string p = a("12345678", 8) + "0" + "e" + "00" + n("4111111111", 19) + a("CLI", 3) +
+                    a("AUTH01", 6) + n("50000", 8) + n("123", 9) + "000" + "2111520";
+    PreAuthResponse r = Ecr17Response::parsePreAuth(p);
+    EXPECT_EQ(r.outcome, Outcome::Ok);
+    EXPECT_EQ(r.transactionType, "CLI");
+    EXPECT_EQ(r.authCode, "AUTH01");
+    EXPECT_EQ(r.preAuthorizedAmount, "00050000");
+    EXPECT_EQ(r.preAuthCode, "000000123");
+    EXPECT_EQ(r.hostDateTime, "2111520");
+}
+
+// Regression: on an approved pre-auth the amount field occupies positions 41-48,
+// so its last digit sits exactly where cardType would be read. An amount ending
+// in 1/2/3 must NOT be surfaced as debit/credit/other. cardType is only
+// meaningful for the KO layout.
+TEST(Response, PreAuthPositiveDoesNotLeakAmountDigitAsCardType) {
+    std::string p = a("12345678", 8) + "0" + "e" + "00" + n("4111111111", 19) + a("CLI", 3) +
+                    a("AUTH01", 6) + n("50001", 8) + n("123", 9) + "000" + "2111520";
+    PreAuthResponse r = Ecr17Response::parsePreAuth(p);
+    EXPECT_EQ(r.outcome, Outcome::Ok);
+    EXPECT_EQ(r.preAuthorizedAmount, "00050001");  // ends in '1'
+    EXPECT_EQ(r.cardType, "");                      // must stay empty, not "1"
+}
+
+TEST(Response, Vas) {
+    std::string xml =
+        "<ecrres><p k=\"RESPID\">0</p><p k=\"RESPMSG\">OK-APPROVED</p>"
+        "<p k=\"ORDER_ID\">ABC123</p></ecrres>";
+    // header(10) reserved(4) concatFlag(1) idMessage(3) filler-to-pos27(8) xml
+    std::string p = a("12345678", 8) + "0" + "K" + n("", 4) + "0" + "001" + n("", 8) + xml;
+    VasResponse r = Ecr17Response::parseVas(p);
+    EXPECT_FALSE(r.moreMessages);
+    EXPECT_EQ(r.idMessage, "001");
+    EXPECT_EQ(r.responseId, "0");
+    EXPECT_EQ(r.responseMessage, "OK-APPROVED");
+    EXPECT_EQ(r.orderId, "ABC123");
+    EXPECT_EQ(r.rawXml, xml);
+}
+
+TEST(Response, DefensiveOnShortOrEmptyPayload) {
+    PaymentResponse r = Ecr17Response::parsePayment("");
+    EXPECT_EQ(r.outcome, Outcome::Unknown);
+    EXPECT_EQ(r.resultCode, "");
+    EXPECT_EQ(r.pan, "");
+
+    StatusResponse s = Ecr17Response::parseStatus("123");  // truncated, must not crash
+    EXPECT_EQ(s.status, -1);
+}
+
+TEST(Response, OutcomeMapping) {
+    EXPECT_EQ(outcomeFromCode("00"), Outcome::Ok);
+    EXPECT_EQ(outcomeFromCode("01"), Outcome::Ko);
+    EXPECT_EQ(outcomeFromCode("05"), Outcome::CardNotPresent);
+    EXPECT_EQ(outcomeFromCode("09"), Outcome::UnknownTag);
+    EXPECT_EQ(outcomeFromCode("zz"), Outcome::Unknown);
+}

package/cpp/tests/test_retry_policy.cpp

@@ -0,0 +1,28 @@
+// Money-critical safety tests for the auto-reconnect retry decision.
+// The terminal handles real payments, so a financial command must NEVER be
+// blindly re-sent after a connection drop (double-charge risk).
+
+#include <gtest/gtest.h>
+
+#include "Session/RetryPolicy.hpp"
+
+using margelo::nitro::ecr17::shouldRetryAfterReconnect;
+
+// A financial command (safeToRetry == false) must never be retried, regardless
+// of autoReconnect / drop state. This is the invariant that prevents double
+// charging; recovery is via sendLastResult ('G'), not a re-send.
+TEST(RetryPolicy, FinancialCommandIsNeverRetried) {
+    EXPECT_FALSE(shouldRetryAfterReconnect(/*autoReconnect=*/true, /*dropped=*/true, /*safe=*/false));
+    EXPECT_FALSE(shouldRetryAfterReconnect(/*autoReconnect=*/false, /*dropped=*/true, /*safe=*/false));
+    EXPECT_FALSE(shouldRetryAfterReconnect(/*autoReconnect=*/true, /*dropped=*/false, /*safe=*/false));
+    EXPECT_FALSE(shouldRetryAfterReconnect(/*autoReconnect=*/false, /*dropped=*/false, /*safe=*/false));
+}
+
+// A safe/idempotent command is retried ONLY when autoReconnect is on AND the
+// transport actually dropped.
+TEST(RetryPolicy, SafeCommandRetriedOnlyOnReconnectAfterDrop) {
+    EXPECT_TRUE(shouldRetryAfterReconnect(/*autoReconnect=*/true, /*dropped=*/true, /*safe=*/true));
+    EXPECT_FALSE(shouldRetryAfterReconnect(/*autoReconnect=*/false, /*dropped=*/true, /*safe=*/true));
+    EXPECT_FALSE(shouldRetryAfterReconnect(/*autoReconnect=*/true, /*dropped=*/false, /*safe=*/true));
+    EXPECT_FALSE(shouldRetryAfterReconnect(/*autoReconnect=*/false, /*dropped=*/false, /*safe=*/true));
+}