add CAC/RCCH/UDCH rudimentary round-trip tests;

tests/nxdn/CAC_Tests.cpp

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Digital Voice Modem - Test Suite
+ * GPLv2 Open Source. Use is subject to license terms.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  Copyright (C) 2026 Bryan Biedenkapp, N2PLL
+ *
+ */
+
+#include <catch2/catch_test_macros.hpp>
+#include <cstring>
+
+#include "common/nxdn/channel/CAC.h"
+#include "common/nxdn/NXDNDefines.h"
+
+using namespace nxdn;
+using namespace nxdn::defines;
+using namespace nxdn::channel;
+
+TEST_CASE("CAC encodes and decodes short inbound fields", "[nxdn][cac]") {
+    uint8_t frameData[NXDN_FRAME_LENGTH_BYTES + 2U];
+    ::memset(frameData, 0x00U, sizeof(frameData));
+
+    uint8_t rawData[NXDN_CAC_CRC_LENGTH_BYTES];
+    ::memset(rawData, 0x00U, sizeof(rawData));
+    for (uint32_t i = 0U; i < sizeof(rawData); i++) {
+        rawData[i] = static_cast<uint8_t>(i * 11U + 7U);
+    }
+
+    CAC cac;
+    cac.setRAN(23U);
+    cac.setStructure(ChStructure::SR_RCCH_SINGLE);
+    cac.setIdleBusy(false);
+    cac.setTxContinuous(true);
+    cac.setReceive(false);
+    cac.setData(rawData);
+
+    cac.encode(frameData);
+
+    CAC decoded;
+    REQUIRE(decoded.decode(frameData, false));
+    REQUIRE(decoded.getRAN() == 23U);
+    REQUIRE(decoded.getStructure() == ChStructure::SR_RCCH_SINGLE);
+
+    uint8_t decodedData[12U];
+    ::memset(decodedData, 0x00U, sizeof(decodedData));
+    decoded.getData(decodedData);
+    REQUIRE(::memcmp(decodedData, rawData, sizeof(decodedData)) == 0);
+}
+
+TEST_CASE("CAC copy and assignment preserve key fields", "[nxdn][cac]") {
+    CAC original;
+    original.setRAN(9U);
+    original.setStructure(ChStructure::SR_3_4);
+
+    CAC copy(original);
+    REQUIRE(copy.getRAN() == original.getRAN());
+    REQUIRE(copy.getStructure() == original.getStructure());
+
+    CAC assigned;
+    assigned = original;
+    REQUIRE(assigned.getRAN() == original.getRAN());
+    REQUIRE(assigned.getStructure() == original.getStructure());
+}

tests/nxdn/RCCH_Tests.cpp

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Digital Voice Modem - Test Suite
+ * GPLv2 Open Source. Use is subject to license terms.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  Copyright (C) 2026 Bryan Biedenkapp, N2PLL
+ *
+ */
+
+#include <catch2/catch_test_macros.hpp>
+#include <cstring>
+
+#include "common/nxdn/lc/rcch/MESSAGE_TYPE_IDLE.h"
+#include "common/nxdn/lc/rcch/RCCHFactory.h"
+#include "common/nxdn/NXDNDefines.h"
+
+using namespace nxdn;
+using namespace nxdn::defines;
+using namespace nxdn::lc;
+using namespace nxdn::lc::rcch;
+
+TEST_CASE("RCCH IDLE encode/decode preserves message type", "[nxdn][rcch]") {
+    uint8_t data[NXDN_RCCH_LC_LENGTH_BYTES + 2U];
+    ::memset(data, 0x00U, sizeof(data));
+
+    MESSAGE_TYPE_IDLE idle;
+    idle.encode(data, NXDN_RCCH_LC_LENGTH_BITS);
+
+    REQUIRE((data[0U] & 0x3FU) == MessageType::IDLE);
+
+    MESSAGE_TYPE_IDLE decoded;
+    decoded.decode(data, NXDN_RCCH_LC_LENGTH_BITS);
+    REQUIRE(decoded.getMessageType() == MessageType::IDLE);
+    REQUIRE(decoded.toString() == "IDLE (Idle)");
+}
+
+TEST_CASE("RCCHFactory creates IDLE instance from encoded buffer", "[nxdn][rcch]") {
+    uint8_t data[NXDN_RCCH_LC_LENGTH_BYTES + 2U];
+    ::memset(data, 0x00U, sizeof(data));
+
+    MESSAGE_TYPE_IDLE idle;
+    idle.encode(data, NXDN_RCCH_LC_LENGTH_BITS);
+
+    auto rcch = RCCHFactory::createRCCH(data, NXDN_RCCH_LC_LENGTH_BITS);
+    REQUIRE(rcch != nullptr);
+    REQUIRE(rcch->getMessageType() == MessageType::IDLE);
+    REQUIRE(rcch->toString() == "IDLE (Idle)");
+}

tests/nxdn/UDCH_Tests.cpp

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Digital Voice Modem - Test Suite
+ * GPLv2 Open Source. Use is subject to license terms.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  Copyright (C) 2026 Bryan Biedenkapp, N2PLL
+ *
+ */
+
+#include <catch2/catch_test_macros.hpp>
+#include <cstring>
+
+#include "common/nxdn/channel/UDCH.h"
+#include "common/nxdn/NXDNDefines.h"
+
+using namespace nxdn;
+using namespace nxdn::defines;
+using namespace nxdn::channel;
+
+TEST_CASE("UDCH encodes and decodes payload with RAN", "[nxdn][udch]") {
+    uint8_t frameData[NXDN_FRAME_LENGTH_BYTES + 2U];
+    ::memset(frameData, 0x00U, sizeof(frameData));
+
+    uint8_t payload[NXDN_RTCH_LC_LENGTH_BYTES];
+    for (uint32_t i = 0U; i < NXDN_RTCH_LC_LENGTH_BYTES; i++) {
+        payload[i] = static_cast<uint8_t>(0xA0U + i);
+    }
+
+    UDCH udch;
+    udch.setRAN(41U);
+    udch.setData(payload);
+    udch.encode(frameData);
+
+    UDCH decoded;
+    REQUIRE(decoded.decode(frameData));
+    REQUIRE(decoded.getRAN() == 41U);
+
+    uint8_t decodedPayload[NXDN_RTCH_LC_LENGTH_BYTES];
+    ::memset(decodedPayload, 0x00U, sizeof(decodedPayload));
+    decoded.getData(decodedPayload);
+    REQUIRE(::memcmp(decodedPayload, payload, sizeof(payload)) == 0);
+}
+
+TEST_CASE("UDCH copy and assignment preserve payload", "[nxdn][udch]") {
+    uint8_t payload[NXDN_RTCH_LC_LENGTH_BYTES];
+    for (uint32_t i = 0U; i < NXDN_RTCH_LC_LENGTH_BYTES; i++) {
+        payload[i] = static_cast<uint8_t>(i * 3U + 1U);
+    }
+
+    UDCH original;
+    original.setRAN(6U);
+    original.setData(payload);
+
+    UDCH copy(original);
+    REQUIRE(copy.getRAN() == original.getRAN());
+
+    uint8_t originalPayload[NXDN_RTCH_LC_LENGTH_BYTES];
+    uint8_t copyPayload[NXDN_RTCH_LC_LENGTH_BYTES];
+    original.getData(originalPayload);
+    copy.getData(copyPayload);
+    REQUIRE(::memcmp(originalPayload, copyPayload, sizeof(originalPayload)) == 0);
+
+    UDCH assigned;
+    assigned = original;
+    REQUIRE(assigned.getRAN() == original.getRAN());
+
+    uint8_t assignedPayload[NXDN_RTCH_LC_LENGTH_BYTES];
+    assigned.getData(assignedPayload);
+    REQUIRE(::memcmp(originalPayload, assignedPayload, sizeof(originalPayload)) == 0);
+}