diff --git a/tests/nxdn/CAC_Tests.cpp b/tests/nxdn/CAC_Tests.cpp new file mode 100644 index 00000000..15e829ed --- /dev/null +++ b/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 +#include + +#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(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()); +} diff --git a/tests/nxdn/RCCH_Tests.cpp b/tests/nxdn/RCCH_Tests.cpp new file mode 100644 index 00000000..cc0a46da --- /dev/null +++ b/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 +#include + +#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)"); +} diff --git a/tests/nxdn/UDCH_Tests.cpp b/tests/nxdn/UDCH_Tests.cpp new file mode 100644 index 00000000..d8cd518f --- /dev/null +++ b/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 +#include + +#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(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(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); +}