dbc_decoder_test.cpp

#include "dbc_decoder.h"
 
#include <QtTest>
#include <limits>
#include <sstream>
 
struct DecodeCase {
    const char *name;
    ByteOrder byteOrder;
    std::uint32_t startBit;
    std::uint32_t length;
    ValueType valueType;
    std::vector<std::uint8_t> data;
    bool valid;
    std::int64_t rawValue;
    double factor;
    double offset;
    double physicalValue;
};
 
Q_DECLARE_METATYPE(DecodeCase)
 
class DbcDecoderTest : public QObject {
    Q_OBJECT
private Q_SLOTS:
    void decode_data();
    void decode();
    void boundaries();
};
 
void DbcDecoderTest::decode_data() {
    QTest::addColumn<DecodeCase>("test");
    const DecodeCase cases[] = {
            {"Motorola reproduction", ByteOrder::Motorola, 7U, 16U, ValueType::Unsigned, {0x12, 0x34}, true, 0x1234, 1.0, 0.0, 4660.0},
            {"Motorola within byte", ByteOrder::Motorola, 5U, 4U, ValueType::Unsigned, {0xAC}, true, 11, 1.0, 0.0, 11.0},
            {"Motorola unaligned crossing", ByteOrder::Motorola, 3U, 12U, ValueType::Unsigned, {0xAB, 0xCD}, true, 0xBCD, 1.0, 0.0, 3021.0},
            {"Motorola starts at bit zero", ByteOrder::Motorola, 0U, 2U, ValueType::Unsigned, {0x01, 0x80}, true, 3, 1.0, 0.0, 3.0},
            {"Motorola second byte", ByteOrder::Motorola, 15U, 16U, ValueType::Unsigned, {0xFF, 0x12, 0x34}, true, 0x1234, 1.0, 0.0, 4660.0},
            {"Motorola signed scaled", ByteOrder::Motorola, 7U, 16U, ValueType::Signed, {0xFF, 0xFE}, true, -2, 0.5, 10.0, 9.0},
            {"Motorola 64 bits", ByteOrder::Motorola, 7U, 64U, ValueType::Unsigned, {0, 0, 0, 0, 0, 0, 0x12, 0x34}, true, 0x1234, 1.0, 0.0, 4660.0},
            {"Motorola 64 bits high bit", ByteOrder::Motorola, 7U, 64U, ValueType::Unsigned, {0x40, 0, 0, 0, 0, 0, 0, 0}, true, 0x4000000000000000LL, 1.0, 0.0, 4611686018427387904.0},
            {"Motorola short payload", ByteOrder::Motorola, 7U, 16U, ValueType::Unsigned, {0x12}, false, 0, 1.0, 0.0, 0.0},
            {"Motorola empty payload", ByteOrder::Motorola, 7U, 8U, ValueType::Unsigned, {}, false, 0, 1.0, 0.0, 0.0},
            {"Motorola large start", ByteOrder::Motorola, std::numeric_limits<std::uint32_t>::max(), 8U, ValueType::Unsigned, {0xFF}, false, 0, 1.0, 0.0, 0.0},
            {"Motorola zero length", ByteOrder::Motorola, 7U, 0U, ValueType::Unsigned, {0xFF}, false, 0, 1.0, 0.0, 0.0},
            {"Motorola excessive length", ByteOrder::Motorola, 7U, 65U, ValueType::Unsigned,
             std::vector<std::uint8_t>(9U, 0xFF), false, 0, 1.0, 0.0, 0.0},
            {"Intel regression", ByteOrder::Intel, 0U, 16U, ValueType::Unsigned, {0x12, 0x34}, true, 0x3412, 1.0, 0.0, 13330.0},
            {"Intel signed regression", ByteOrder::Intel, 0U, 16U, ValueType::Signed, {0xFE, 0xFF}, true, -2, 0.5, 10.0, 9.0},
            {"Intel short payload", ByteOrder::Intel, 0U, 16U, ValueType::Unsigned, {0x12}, false, 0, 1.0, 0.0, 0.0}};
 
    for (const DecodeCase &test: cases)
        QTest::newRow(test.name) << test;
}
 
void DbcDecoderTest::decode() {
    QFETCH(DecodeCase, test);
    DecodeSignal signal;
    signal.name = test.name;
    signal.byteOrder = test.byteOrder;
    signal.startBit = test.startBit;
    signal.length = test.length;
    signal.valueType = test.valueType;
    signal.factor = test.factor;
    signal.offset = test.offset;
 
    DecodeFrame definition;
    definition.canId = 0x123U;
    definition.dlc = static_cast<std::uint8_t>(test.data.size());
    definition.signals.push_back(signal);
    DecodeDatabase database;
    database.frames.push_back(definition);
    database.frameIndexByKey.emplace(FrameKey(definition.canId, false), 0U);
 
    RawCanFrame frame;
    frame.canId = definition.canId;
    frame.data = test.data;
    const DecodedFrameValue result = DbcDecoder().Decode(database, frame);
    QVERIFY2(result.valid, test.name);
    QCOMPARE(result.definition, &database.frames[0]);
    QCOMPARE(result.signals.size(), std::size_t(1U));
    const DecodedSignalValue &decoded = result.signals[0];
    QCOMPARE(decoded.definition, &database.frames[0].signals[0]);
    QCOMPARE(decoded.valid, test.valid);
    if (!test.valid)
        return;
 
    if (test.valueType == ValueType::Signed) {
        const std::int64_t *raw = std::get_if<std::int64_t>(&decoded.rawValue);
        QVERIFY(raw != nullptr);
        QCOMPARE(*raw, test.rawValue);
    } else {
        const std::uint64_t *raw = std::get_if<std::uint64_t>(&decoded.rawValue);
        QVERIFY(raw != nullptr);
        QCOMPARE(*raw, static_cast<std::uint64_t>(test.rawValue));
    }
    QCOMPARE(decoded.physicalValue, test.physicalValue);
}
 
void DbcDecoderTest::boundaries() {
    for (ByteOrder order: {ByteOrder::Intel, ByteOrder::Motorola}) {
        for (ValueType type: {ValueType::Unsigned, ValueType::Signed}) {
            for (std::uint64_t bits: {std::uint64_t(0U), std::uint64_t(0x7FFFFFFFFFFFFFFFULL),
                                      std::uint64_t(0x8000000000000000ULL),
                                      std::uint64_t(0x8000000000000001ULL),
                                      std::uint64_t(0xFFFFFFFFFFFFFFFFULL)}) {
                DecodeDatabase database;
                DecodeFrame definition;
                DecodeSignal signal;
                signal.startBit = order == ByteOrder::Intel ? 0U : 7U;
                signal.length = 64U;
                signal.byteOrder = order;
                signal.valueType = type;
                signal.factor = 0.5;
                signal.offset = 10.0;
                definition.signals.push_back(signal);
                database.frames.push_back(definition);
                database.frameIndexByKey.emplace(FrameKey(0U, false), 0U);
                RawCanFrame frame;
                for (unsigned byte = 0U; byte < 8U; ++byte) {
                    const unsigned shift = (order == ByteOrder::Intel ? byte : 7U - byte) * 8U;
                    frame.data.push_back(static_cast<std::uint8_t>(bits >> shift));
                }
                const DecodedFrameValue result = DbcDecoder().Decode(database, frame);
                const std::int64_t signedExpected = bits <= 0x7FFFFFFFFFFFFFFFULL
                                                            ? static_cast<std::int64_t>(bits)
                                                            : std::numeric_limits<std::int64_t>::min() +
                                                                      static_cast<std::int64_t>(bits - 0x8000000000000000ULL);
                const DecodedSignalValue &decoded = result.signals.at(0U);
                const RawSignalValue expected = type == ValueType::Unsigned
                                              ? std::variant<std::int64_t, std::uint64_t>(bits)
                                              : std::variant<std::int64_t, std::uint64_t>(signedExpected);
                const double physical = (type == ValueType::Unsigned
                                                 ? static_cast<double>(bits)
                                                 : static_cast<double>(signedExpected)) *
                                                0.5 +
                                        10.0;
                std::ostringstream actualText;
                std::ostringstream expectedText;
                if (const std::int64_t *signedValue = std::get_if<std::int64_t>(&decoded.rawValue))
                    actualText << *signedValue;
                else
                    actualText << std::get<std::uint64_t>(decoded.rawValue);
                if (type == ValueType::Unsigned)
                    expectedText << bits;
                else
                    expectedText << signedExpected;
                QVERIFY(decoded.valid);
                QVERIFY(decoded.rawValue == expected);
                QCOMPARE(decoded.physicalValue, physical);
                QCOMPARE(actualText.str(), expectedText.str());
            }
        }
    }
}
 
int RunDecoderTests(int argc, char **argv) {
    DbcDecoderTest tests;
    return QTest::qExec(&tests, argc, argv);
}
 
#include "dbc_decoder_test.moc"