fsfw/tests/src/fsfw_tests/unit/globalfunctions/testDleEncoder.cpp

#include "fsfw/globalfunctions/DleEncoder.h"
#include "fsfw_tests/unit/CatchDefinitions.h"
#include "catch2/catch_test_macros.hpp"

#include <array>

const std::vector<uint8_t> TEST_ARRAY_0 = { 0, 0, 0, 0, 0 };
const std::vector<uint8_t> TEST_ARRAY_1 = { 0, DleEncoder::DLE_CHAR, 5};
const std::vector<uint8_t> TEST_ARRAY_2 = { 0, DleEncoder::STX_CHAR, 5};
const std::vector<uint8_t> TEST_ARRAY_3 = { 0, DleEncoder::CARRIAGE_RETURN, DleEncoder::ETX_CHAR};
const std::vector<uint8_t> TEST_ARRAY_4 = { DleEncoder::DLE_CHAR, DleEncoder::ETX_CHAR,
        DleEncoder::STX_CHAR };

const std::vector<uint8_t> TEST_ARRAY_0_ENCODED_ESCAPED = {
        DleEncoder::STX_CHAR, 0, 0, 0, 0, 0, DleEncoder::ETX_CHAR
};
const std::vector<uint8_t> TEST_ARRAY_0_ENCODED_NON_ESCAPED = {
        DleEncoder::DLE_CHAR, DleEncoder::STX_CHAR, 0, 0, 0, 0, 0,
        DleEncoder::DLE_CHAR, DleEncoder::ETX_CHAR
};

const std::vector<uint8_t> TEST_ARRAY_1_ENCODED_ESCAPED = {
        DleEncoder::STX_CHAR, 0, DleEncoder::DLE_CHAR, DleEncoder::DLE_CHAR, 5, DleEncoder::ETX_CHAR
};
const std::vector<uint8_t> TEST_ARRAY_1_ENCODED_NON_ESCAPED = {
        DleEncoder::DLE_CHAR, DleEncoder::STX_CHAR, 0, DleEncoder::DLE_CHAR, DleEncoder::DLE_CHAR,
        5, DleEncoder::DLE_CHAR, DleEncoder::ETX_CHAR
};

const std::vector<uint8_t> TEST_ARRAY_2_ENCODED_ESCAPED = {
        DleEncoder::STX_CHAR, 0, DleEncoder::DLE_CHAR, DleEncoder::STX_CHAR + 0x40,
        5, DleEncoder::ETX_CHAR
};
const std::vector<uint8_t> TEST_ARRAY_2_ENCODED_NON_ESCAPED = {
        DleEncoder::DLE_CHAR, DleEncoder::STX_CHAR, 0,
        DleEncoder::STX_CHAR, 5, DleEncoder::DLE_CHAR, DleEncoder::ETX_CHAR
};

const std::vector<uint8_t> TEST_ARRAY_3_ENCODED_ESCAPED = {
        DleEncoder::STX_CHAR, 0, DleEncoder::CARRIAGE_RETURN,
        DleEncoder::DLE_CHAR,  DleEncoder::ETX_CHAR + 0x40, DleEncoder::ETX_CHAR
};
const std::vector<uint8_t> TEST_ARRAY_3_ENCODED_NON_ESCAPED = {
        DleEncoder::DLE_CHAR, DleEncoder::STX_CHAR, 0,
        DleEncoder::CARRIAGE_RETURN, DleEncoder::ETX_CHAR, DleEncoder::DLE_CHAR,
        DleEncoder::ETX_CHAR
};

const std::vector<uint8_t> TEST_ARRAY_4_ENCODED_ESCAPED = {
        DleEncoder::STX_CHAR, DleEncoder::DLE_CHAR, DleEncoder::DLE_CHAR,
        DleEncoder::DLE_CHAR, DleEncoder::ETX_CHAR + 0x40, DleEncoder::DLE_CHAR,
        DleEncoder::STX_CHAR + 0x40, DleEncoder::ETX_CHAR
};
const std::vector<uint8_t> TEST_ARRAY_4_ENCODED_NON_ESCAPED = {
        DleEncoder::DLE_CHAR, DleEncoder::STX_CHAR, DleEncoder::DLE_CHAR, DleEncoder::DLE_CHAR,
        DleEncoder::ETX_CHAR, DleEncoder::STX_CHAR, DleEncoder::DLE_CHAR, DleEncoder::ETX_CHAR
};


TEST_CASE("DleEncoder" , "[DleEncoder]") {
    DleEncoder dleEncoder;
    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
    std::array<uint8_t, 32> buffer;

    size_t encodedLen = 0;
    size_t readLen = 0;
    size_t decodedLen = 0;

    auto testLambdaEncode = [&](DleEncoder& encoder, const std::vector<uint8_t>& vecToEncode,
            const std::vector<uint8_t>& expectedVec) {
        result = encoder.encode(vecToEncode.data(), vecToEncode.size(),
                buffer.data(), buffer.size(), &encodedLen);
        REQUIRE(result == retval::CATCH_OK);
        for(size_t idx = 0; idx < expectedVec.size(); idx++) {
            REQUIRE(buffer[idx] == expectedVec[idx]);
        }
        REQUIRE(encodedLen == expectedVec.size());
    };

    auto testLambdaDecode = [&](DleEncoder& encoder, const std::vector<uint8_t>& testVecEncoded,
            const std::vector<uint8_t>& expectedVec) {
        result = encoder.decode(testVecEncoded.data(),
                testVecEncoded.size(),
                &readLen, buffer.data(), buffer.size(), &decodedLen);
        REQUIRE(result == retval::CATCH_OK);
        REQUIRE(readLen == testVecEncoded.size());
        REQUIRE(decodedLen == expectedVec.size());
        for(size_t idx = 0; idx < decodedLen; idx++) {
            REQUIRE(buffer[idx] == expectedVec[idx]);
        }
    };

    SECTION("Encoding") {
        testLambdaEncode(dleEncoder, TEST_ARRAY_0, TEST_ARRAY_0_ENCODED_ESCAPED);
        testLambdaEncode(dleEncoder, TEST_ARRAY_1, TEST_ARRAY_1_ENCODED_ESCAPED);
        testLambdaEncode(dleEncoder, TEST_ARRAY_2, TEST_ARRAY_2_ENCODED_ESCAPED);
        testLambdaEncode(dleEncoder, TEST_ARRAY_3, TEST_ARRAY_3_ENCODED_ESCAPED);
        testLambdaEncode(dleEncoder, TEST_ARRAY_4, TEST_ARRAY_4_ENCODED_ESCAPED);

        auto testFaultyEncoding = [&](const std::vector<uint8_t>& vecToEncode,
                const std::vector<uint8_t>& expectedVec) {

            for(size_t faultyDestSize = 0; faultyDestSize < expectedVec.size(); faultyDestSize ++) {
                result = dleEncoder.encode(vecToEncode.data(), vecToEncode.size(),
                        buffer.data(), faultyDestSize, &encodedLen);
                REQUIRE(result == DleEncoder::STREAM_TOO_SHORT);
            }
        };

        testFaultyEncoding(TEST_ARRAY_0, TEST_ARRAY_0_ENCODED_ESCAPED);
        testFaultyEncoding(TEST_ARRAY_1, TEST_ARRAY_1_ENCODED_ESCAPED);
        testFaultyEncoding(TEST_ARRAY_2, TEST_ARRAY_2_ENCODED_ESCAPED);
        testFaultyEncoding(TEST_ARRAY_3, TEST_ARRAY_3_ENCODED_ESCAPED);
        testFaultyEncoding(TEST_ARRAY_4, TEST_ARRAY_4_ENCODED_ESCAPED);

        dleEncoder.setEscapeMode(false);
        testLambdaEncode(dleEncoder, TEST_ARRAY_0, TEST_ARRAY_0_ENCODED_NON_ESCAPED);
        testLambdaEncode(dleEncoder, TEST_ARRAY_1, TEST_ARRAY_1_ENCODED_NON_ESCAPED);
        testLambdaEncode(dleEncoder, TEST_ARRAY_2, TEST_ARRAY_2_ENCODED_NON_ESCAPED);
        testLambdaEncode(dleEncoder, TEST_ARRAY_3, TEST_ARRAY_3_ENCODED_NON_ESCAPED);
        testLambdaEncode(dleEncoder, TEST_ARRAY_4, TEST_ARRAY_4_ENCODED_NON_ESCAPED);

        testFaultyEncoding(TEST_ARRAY_0, TEST_ARRAY_0_ENCODED_NON_ESCAPED);
        testFaultyEncoding(TEST_ARRAY_1, TEST_ARRAY_1_ENCODED_NON_ESCAPED);
        testFaultyEncoding(TEST_ARRAY_2, TEST_ARRAY_2_ENCODED_NON_ESCAPED);
        testFaultyEncoding(TEST_ARRAY_3, TEST_ARRAY_3_ENCODED_NON_ESCAPED);
        testFaultyEncoding(TEST_ARRAY_4, TEST_ARRAY_4_ENCODED_NON_ESCAPED);
        dleEncoder.setEscapeMode(true);
    }

    SECTION("Decoding") {
        testLambdaDecode(dleEncoder, TEST_ARRAY_0_ENCODED_ESCAPED, TEST_ARRAY_0);
        testLambdaDecode(dleEncoder, TEST_ARRAY_1_ENCODED_ESCAPED, TEST_ARRAY_1);
        testLambdaDecode(dleEncoder, TEST_ARRAY_2_ENCODED_ESCAPED, TEST_ARRAY_2);
        testLambdaDecode(dleEncoder, TEST_ARRAY_3_ENCODED_ESCAPED, TEST_ARRAY_3);
        testLambdaDecode(dleEncoder, TEST_ARRAY_4_ENCODED_ESCAPED, TEST_ARRAY_4);

        // Faulty source data
        auto testArray1EncodedFaulty = TEST_ARRAY_1_ENCODED_ESCAPED;
        testArray1EncodedFaulty[3] = 0;
        result = dleEncoder.decode(testArray1EncodedFaulty.data(), testArray1EncodedFaulty.size(),
                &readLen, buffer.data(), buffer.size(), &encodedLen);
        REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));
        auto testArray2EncodedFaulty = TEST_ARRAY_2_ENCODED_ESCAPED;
        testArray2EncodedFaulty[5] = 0;
        result = dleEncoder.decode(testArray2EncodedFaulty.data(), testArray2EncodedFaulty.size(),
                &readLen, buffer.data(), buffer.size(), &encodedLen);
        REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));
        auto testArray4EncodedFaulty = TEST_ARRAY_4_ENCODED_ESCAPED;
        testArray4EncodedFaulty[2] = 0;
        result = dleEncoder.decode(testArray4EncodedFaulty.data(), testArray4EncodedFaulty.size(),
                &readLen, buffer.data(), buffer.size(), &encodedLen);
        REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));
        auto testArray4EncodedFaulty2 = TEST_ARRAY_4_ENCODED_ESCAPED;
        testArray4EncodedFaulty2[4] = 0;
        result = dleEncoder.decode(testArray4EncodedFaulty2.data(), testArray4EncodedFaulty2.size(),
                &readLen, buffer.data(), buffer.size(), &encodedLen);
        REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));

        auto testFaultyDecoding = [&](const std::vector<uint8_t>& vecToDecode,
                const std::vector<uint8_t>& expectedVec) {
            for(size_t faultyDestSizes = 0;
                    faultyDestSizes < expectedVec.size();
                    faultyDestSizes ++) {
                result = dleEncoder.decode(vecToDecode.data(),
                        vecToDecode.size(), &readLen,
                        buffer.data(), faultyDestSizes, &decodedLen);
                REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));
            }
        };

        testFaultyDecoding(TEST_ARRAY_0_ENCODED_ESCAPED, TEST_ARRAY_0);
        testFaultyDecoding(TEST_ARRAY_1_ENCODED_ESCAPED, TEST_ARRAY_1);
        testFaultyDecoding(TEST_ARRAY_2_ENCODED_ESCAPED, TEST_ARRAY_2);
        testFaultyDecoding(TEST_ARRAY_3_ENCODED_ESCAPED, TEST_ARRAY_3);
        testFaultyDecoding(TEST_ARRAY_4_ENCODED_ESCAPED, TEST_ARRAY_4);

        dleEncoder.setEscapeMode(false);
        testLambdaDecode(dleEncoder, TEST_ARRAY_0_ENCODED_NON_ESCAPED, TEST_ARRAY_0);
        testLambdaDecode(dleEncoder, TEST_ARRAY_1_ENCODED_NON_ESCAPED, TEST_ARRAY_1);
        testLambdaDecode(dleEncoder, TEST_ARRAY_2_ENCODED_NON_ESCAPED, TEST_ARRAY_2);
        testLambdaDecode(dleEncoder, TEST_ARRAY_3_ENCODED_NON_ESCAPED, TEST_ARRAY_3);
        testLambdaDecode(dleEncoder, TEST_ARRAY_4_ENCODED_NON_ESCAPED, TEST_ARRAY_4);

        testFaultyDecoding(TEST_ARRAY_0_ENCODED_NON_ESCAPED, TEST_ARRAY_0);
        testFaultyDecoding(TEST_ARRAY_1_ENCODED_NON_ESCAPED, TEST_ARRAY_1);
        testFaultyDecoding(TEST_ARRAY_2_ENCODED_NON_ESCAPED, TEST_ARRAY_2);
        testFaultyDecoding(TEST_ARRAY_3_ENCODED_NON_ESCAPED, TEST_ARRAY_3);
        testFaultyDecoding(TEST_ARRAY_4_ENCODED_NON_ESCAPED, TEST_ARRAY_4);

        // Faulty source data
        testArray1EncodedFaulty = TEST_ARRAY_1_ENCODED_NON_ESCAPED;
        auto prevVal = testArray1EncodedFaulty[0];
        testArray1EncodedFaulty[0] = 0;
        result = dleEncoder.decode(testArray1EncodedFaulty.data(), testArray1EncodedFaulty.size(),
                &readLen, buffer.data(), buffer.size(), &encodedLen);
        REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));
        testArray1EncodedFaulty[0] = prevVal;
        testArray1EncodedFaulty[1] = 0;
        result = dleEncoder.decode(testArray1EncodedFaulty.data(), testArray1EncodedFaulty.size(),
                &readLen, buffer.data(), buffer.size(), &encodedLen);
        REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));

        testArray1EncodedFaulty = TEST_ARRAY_1_ENCODED_NON_ESCAPED;
        testArray1EncodedFaulty[6] = 0;
        result = dleEncoder.decode(testArray1EncodedFaulty.data(), testArray1EncodedFaulty.size(),
                &readLen, buffer.data(), buffer.size(), &encodedLen);
        REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));
        testArray1EncodedFaulty = TEST_ARRAY_1_ENCODED_NON_ESCAPED;
        testArray1EncodedFaulty[7] = 0;
        result = dleEncoder.decode(testArray1EncodedFaulty.data(), testArray1EncodedFaulty.size(),
                &readLen, buffer.data(), buffer.size(), &encodedLen);
        REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));
        testArray4EncodedFaulty = TEST_ARRAY_4_ENCODED_NON_ESCAPED;
        testArray4EncodedFaulty[3] = 0;
        result = dleEncoder.decode(testArray4EncodedFaulty.data(), testArray4EncodedFaulty.size(),
                &readLen, buffer.data(), buffer.size(), &encodedLen);
        REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));

        dleEncoder.setEscapeMode(true);
    }
}