dbc_pipeline_test.cpp

#include "dbc_decode_builder.h"
#include "dbc_decoder.h"
#include "dbc_parser.h"
#include "dbc_tree_builder.h"
#include <QTemporaryFile>
#include <QtTest>
#include <stdexcept>
#include <utility>
 
namespace {
    const std::string fixture = R"DBC(BO_ 291 Standard: 2 SenderA
 SG_ Mode M : 0|8@1+ (1,0) [0|255] "" ReceiverA
 SG_ State m3 : 8|8@1+ (2,1) [1|511] "km/h" ReceiverA,ReceiverB
BO_ 2147483939 Extended: 1 SenderB
 SG_ State : 7|8@0- (0.5,-3) [-67|60.5] "deg C" ReceiverB
BO_ 2565866562 J1939: 0 SenderC
CM_ BO_ 291 "Standard frame comment";
CM_ SG_ 291 Mode "Selector comment";
CM_ SG_ 291 State "Standard signal comment";
CM_ BO_ 2147483939 "Extended frame comment";
CM_ SG_ 2147483939 State "Extended signal comment";
VAL_ 291 Mode 3 "Selected";
VAL_ 291 State 4 "Standard four";
VAL_ 2147483939 State -2 "Extended minus two";
)DBC";
 
    DbcParseResult ParseFixture(const std::string &text) {
        QTemporaryFile file;
        if (!file.open()) throw std::runtime_error("Cannot create DBC fixture");
        if (file.write(text.data(), static_cast<qint64>(text.size())) != static_cast<qint64>(text.size()) || !file.flush())
            throw std::runtime_error("Cannot write DBC fixture");
        return DbcParser(DbcParserOptions{true}).ParseFileWithDiagnostics(file.fileName().toStdString());
    }
 
    // Independent expectations ensure a parser regression cannot be hidden by
    // comparing builders only with the same incorrect parsed input.
    DbcDatabase ExpectedMetadata() {
        FrameInfo standard;
        standard.name = "Standard";
        standard.canId = 291U;
        standard.dlc = 2U;
        standard.transmitter = "SenderA";
        standard.comment = "Standard frame comment";
        SignalInfo mode;
        mode.name = "Mode";
        mode.multiplexing.role = MultiplexRole::Selector;
        mode.length = 8U;
        mode.maximum = 255;
        mode.receivers = {"ReceiverA"};
        mode.comment = "Selector comment";
        mode.valueDescriptions = {{std::uint64_t(3), "Selected"}};
        SignalInfo state;
        state.name = "State";
        state.multiplexing.role = MultiplexRole::Branch;
        state.multiplexing.value = 3U;
        state.startBit = 8U;
        state.length = 8U;
        state.factor = 2;
        state.offset = 1;
        state.minimum = 1;
        state.maximum = 511;
        state.unit = "km/h";
        state.receivers = {"ReceiverA", "ReceiverB"};
        state.comment = "Standard signal comment";
        state.valueDescriptions = {{std::uint64_t(4), "Standard four"}};
        standard.signals = {mode, state};
 
        FrameInfo extended;
        extended.name = "Extended";
        extended.canId = 291U;
        extended.isExtended = true;
        extended.hasPgn = true;
        extended.dlc = 1U;
        extended.transmitter = "SenderB";
        extended.comment = "Extended frame comment";
        state.multiplexing = Multiplexing();
        state.startBit = 7U;
        state.isLittleEndian = false;
        state.isSigned = true;
        state.factor = 0.5;
        state.offset = -3;
        state.minimum = -67;
        state.maximum = 60.5;
        state.unit = "deg C";
        state.receivers = {"ReceiverB"};
        state.comment = "Extended signal comment";
        state.valueDescriptions = {{std::int64_t(-2), "Extended minus two"}};
        extended.signals = {state};
 
        FrameInfo j1939;
        j1939.name = "J1939";
        j1939.canId = 0x18F00442U;
        j1939.isExtended = true;
        j1939.hasPgn = true;
        j1939.pgn = 0xF004U;
        j1939.transmitter = "SenderC";
        return DbcDatabase{{standard, extended, j1939}};
    }
 
    template<class Signal>
    void CheckSignalMetadata(const Signal &actual, const SignalInfo &expected) {
        QCOMPARE(actual.name, expected.name);
        QCOMPARE(actual.startBit, expected.startBit);
        QCOMPARE(actual.length, expected.length);
        QCOMPARE(actual.factor, expected.factor);
        QCOMPARE(actual.offset, expected.offset);
        QCOMPARE(actual.minimum, expected.minimum);
        QCOMPARE(actual.maximum, expected.maximum);
        QCOMPARE(actual.unit, expected.unit);
        QVERIFY(actual.receivers == expected.receivers);
        QCOMPARE(actual.comment, expected.comment);
        QVERIFY(actual.valueDescriptions == expected.valueDescriptions);
        QCOMPARE(actual.multiplexing.role, expected.multiplexing.role);
        QCOMPARE(actual.multiplexing.value, expected.multiplexing.value);
    }
 
    void CheckSignal(const SignalInfo &actual, const SignalInfo &expected) {
        CheckSignalMetadata(actual, expected);
        QCOMPARE(actual.isLittleEndian, expected.isLittleEndian);
        QCOMPARE(actual.isSigned, expected.isSigned);
    }
 
    void CheckSignal(const DecodeSignal &actual, const SignalInfo &expected) {
        CheckSignalMetadata(actual, expected);
        QCOMPARE(actual.byteOrder, expected.isLittleEndian ? ByteOrder::Intel : ByteOrder::Motorola);
        QCOMPARE(actual.valueType, expected.isSigned ? ValueType::Signed : ValueType::Unsigned);
    }
 
    template<class Frame>
    void CheckFrame(const Frame &actual, const FrameInfo &expected) {
        QCOMPARE(actual.name, expected.name);
        QCOMPARE(actual.canId, expected.canId);
        QCOMPARE(actual.isExtended, expected.isExtended);
        QCOMPARE(actual.dlc, expected.dlc);
        QCOMPARE(actual.pgn, expected.pgn);
        QCOMPARE(actual.hasPgn, expected.hasPgn);
        QCOMPARE(actual.transmitter, expected.transmitter);
        QCOMPARE(actual.comment, expected.comment);
        QCOMPARE(actual.signals.size(), expected.signals.size());
        for (std::size_t i = 0; i < expected.signals.size(); ++i)
            CheckSignal(actual.signals[i], expected.signals[i]);
    }
 
    void CheckTree(const TreeNode &root, const DbcDatabase &expected) {
        QCOMPARE(root.GetType(), NodeType::Root);
        QVERIFY(root.GetParent() == nullptr);
        QVERIFY(root.GetFrame() == nullptr);
        QVERIFY(root.GetSignal() == nullptr);
        QCOMPARE(root.GetChildCount(), expected.frames.size());
        for (std::size_t i = 0; i < expected.frames.size(); ++i) {
            const TreeNode *frame = root.GetChild(i);
            QVERIFY(frame != nullptr);
            QCOMPARE(frame->GetType(), NodeType::Frame);
            QCOMPARE(frame->GetParent(), &root);
            QCOMPARE(frame->GetRow(), i);
            QCOMPARE(frame->GetName(), expected.frames[i].name);
            QVERIFY(frame->GetFrame() != nullptr);
            QVERIFY(frame->GetSignal() == nullptr);
            CheckFrame(*frame->GetFrame(), expected.frames[i]);
            QCOMPARE(frame->GetChildCount(), expected.frames[i].signals.size());
            for (std::size_t j = 0; j < frame->GetChildCount(); ++j) {
                const TreeNode *signal = frame->GetChild(j);
                QVERIFY(signal != nullptr);
                QCOMPARE(signal->GetType(), NodeType::Signal);
                QCOMPARE(signal->GetParent(), frame);
                QCOMPARE(signal->GetRow(), j);
                QCOMPARE(signal->GetName(), expected.frames[i].signals[j].name);
                QVERIFY(signal->GetSignal() != nullptr);
                QVERIFY(signal->GetFrame() == nullptr);
                QCOMPARE(signal->GetChildCount(), std::size_t(0));
                CheckSignal(*signal->GetSignal(), expected.frames[i].signals[j]);
            }
        }
        QVERIFY(root.GetChild(expected.frames.size()) == nullptr);
    }
 
    void CheckUnknown(const DecodeDatabase &runtime, bool extended) {
        const FrameKey key(291U, extended);
        QVERIFY(runtime.FindFrame(key) == nullptr);
        QVERIFY(runtime.FindSignal(SignalKey(key, "State")) == nullptr);
        QVERIFY(DbcDecoder().FindFrame(runtime, key.canId, key.isExtended) == nullptr);
        RawCanFrame raw;
        raw.canId = key.canId;
        raw.isExtended = extended;
        raw.data = {3U, 4U};
        const DecodedFrameValue decoded = DbcDecoder().Decode(runtime, raw);
        QVERIFY(!decoded.valid);
        QCOMPARE(decoded.status, FrameDecodeStatus::UnknownFrame);
        QVERIFY(decoded.definition == nullptr);
        QVERIFY(decoded.signals.empty());
        QVERIFY(decoded.key == key);
    }
}// namespace
 
class PipelineTest : public QObject {
    Q_OBJECT
private Q_SLOTS:
    void metadataLookupDecodeAndTree();
    void emptyDatabase_data();
    void emptyDatabase();
    void databaseReplacement();
    void unsupportedSignalTypes_data();
    void unsupportedSignalTypes();
};
 
void PipelineTest::metadataLookupDecodeAndTree() {
    const DbcParseResult parsed = ParseFixture(fixture);
    QVERIFY(!parsed.HasErrors());
    QVERIFY(parsed.diagnostics.empty());
    const DbcDatabase expected = ExpectedMetadata();
    QCOMPARE(parsed.database.frames.size(), expected.frames.size());
    const DecodeDatabase runtime = DbcDecodeBuilder().Build(parsed.database);
    QCOMPARE(runtime.GetFrames().size(), expected.frames.size());
    const std::unique_ptr<TreeNode> tree = DbcTreeBuilder().Build(parsed.database);
    QVERIFY(tree != nullptr);
    CheckTree(*tree, expected);
    for (std::size_t i = 0; i < expected.frames.size(); ++i) {
        CheckFrame(parsed.database.frames[i], expected.frames[i]);
        CheckFrame(runtime.GetFrames()[i], expected.frames[i]);
        const FrameKey key(expected.frames[i].canId, expected.frames[i].isExtended);
        const std::shared_ptr<const DecodeFrame> found = runtime.FindFrame(key);
        QVERIFY(found != nullptr);
        QCOMPARE(found.get(), &runtime.GetFrames()[i]);
        QCOMPARE(DbcDecoder().FindFrame(runtime, key.canId, key.isExtended).get(), found.get());
        for (std::size_t j = 0; j < found->signals.size(); ++j) {
            const std::shared_ptr<const DecodeSignal> signal = runtime.FindSignal(SignalKey(key, found->signals[j].name));
            QVERIFY(signal != nullptr);
            QCOMPARE(signal.get(), &found->signals[j]);
        }
    }
    QVERIFY(runtime.FindSignal(SignalKey(FrameKey(291U, true), "Mode")) == nullptr);
    QVERIFY(runtime.FindFrame(FrameKey(292U, false)) == nullptr);
 
    RawCanFrame raw;
    raw.canId = 291U;
    raw.data = {3U, 4U};
    const DecodedFrameValue standard = DbcDecoder().Decode(runtime, raw);
    QVERIFY(standard.valid);
    QCOMPARE(standard.status, FrameDecodeStatus::Valid);
    QVERIFY(standard.key == FrameKey(291U, false));
    QCOMPARE(standard.definition.get(), runtime.FindFrame(standard.key).get());
    QCOMPARE(standard.signals.size(), std::size_t(2));
    for (std::size_t i = 0; i < standard.signals.size(); ++i) {
        const DecodedSignalValue &signal = standard.signals[i];
        QVERIFY(signal.valid);
        QCOMPARE(signal.status, SignalDecodeStatus::Valid);
        QVERIFY(signal.key == SignalKey(standard.key, i == 0 ? "Mode" : "State"));
        QCOMPARE(signal.definition.get(), runtime.FindSignal(signal.key).get());
        QCOMPARE(std::get<std::uint64_t>(signal.rawValue), i == 0 ? 3U : 4U);
        QCOMPARE(signal.physicalValue, i == 0 ? 3.0 : 9.0);
        QVERIFY(signal.GetValueDescription() != nullptr);
        QCOMPARE(*signal.GetValueDescription(), std::string(i == 0 ? "Selected" : "Standard four"));
    }
    raw.isExtended = true;
    raw.data = {0xFEU};
    const DecodedFrameValue extended = DbcDecoder().Decode(runtime, raw);
    QVERIFY(extended.valid);
    QCOMPARE(extended.status, FrameDecodeStatus::Valid);
    QVERIFY(extended.key == FrameKey(291U, true));
    QCOMPARE(extended.definition.get(), runtime.FindFrame(extended.key).get());
    QCOMPARE(extended.signals.size(), std::size_t(1));
    const DecodedSignalValue &signal = extended.signals[0];
    QVERIFY(signal.valid);
    QCOMPARE(signal.status, SignalDecodeStatus::Valid);
    QVERIFY(signal.key == SignalKey(extended.key, "State"));
    QCOMPARE(signal.definition.get(), runtime.FindSignal(signal.key).get());
    QCOMPARE(std::get<std::int64_t>(signal.rawValue), std::int64_t(-2));
    QCOMPARE(signal.physicalValue, -4.0);
    QVERIFY(signal.GetValueDescription() != nullptr);
    QCOMPARE(*signal.GetValueDescription(), std::string("Extended minus two"));
 
    raw.canId = 0x18F00442U;
    raw.data.clear();
    const DecodedFrameValue j1939 = DbcDecoder().Decode(runtime, raw);
    QVERIFY(j1939.valid);
    QCOMPARE(j1939.status, FrameDecodeStatus::Valid);
    QVERIFY(j1939.key == FrameKey(0x18F00442U, true));
    QCOMPARE(j1939.definition.get(), runtime.FindFrame(j1939.key).get());
    QVERIFY(j1939.signals.empty());
}
 
void PipelineTest::unsupportedSignalTypes_data() {
    QTest::addColumn<unsigned>("bits");
    QTest::addColumn<unsigned>("type");
    QTest::addColumn<std::vector<std::uint8_t>>("payload");
    QTest::addColumn<std::uint64_t>("integerValue");
    QTest::newRow("float32-one") << 32U << 1U << std::vector<std::uint8_t>{0U, 0U, 128U, 63U}
                                << std::uint64_t(0x3F800000U);
    QTest::newRow("float64-one") << 64U << 2U << std::vector<std::uint8_t>{0U, 0U, 0U, 0U, 0U, 0U, 240U, 63U}
                                << std::uint64_t(0x3FF0000000000000ULL);
}
 
void PipelineTest::unsupportedSignalTypes() {
    QFETCH(unsigned, bits);
    QFETCH(unsigned, type);
    QFETCH(std::vector<std::uint8_t>, payload);
    QFETCH(std::uint64_t, integerValue);
    const std::string definitions = "BO_ 1 Frame: " + std::to_string(bits / 8U) + " ECU\n"
        "SG_ Value : 0|" + std::to_string(bits) + "@1+ (1,0) [0|100] \"\" ECU\n";
    RawCanFrame raw;
    raw.canId = 1U;
    raw.data = payload;
    const DbcDecodeBuilder builder;
    const DbcDecoder decoder;
 
    // Without a type override, the same bits are a supported integer signal.
    const DbcParseResult integers = ParseFixture(definitions);
    QVERIFY(!integers.HasErrors());
    const DecodedFrameValue integerFrame = decoder.Decode(builder.Build(integers.database), raw);
    QCOMPARE(integerFrame.status, FrameDecodeStatus::Valid);
    QCOMPARE(integerFrame.signals.size(), std::size_t(1));
    QVERIFY(integerFrame.signals[0].valid);
    QCOMPARE(std::get<std::uint64_t>(integerFrame.signals[0].rawValue), integerValue);
 
    const DbcParseResult floatingPoint = ParseFixture(definitions +
        "SIG_VALTYPE_ 1 Value : " + std::to_string(type) + ";\n");
    QVERIFY(floatingPoint.HasErrors());
    QCOMPARE(floatingPoint.diagnostics.size(), std::size_t(1));
    QCOMPARE(floatingPoint.diagnostics[0].code, DbcDiagnosticCode::UnsupportedSignalType);
    QCOMPARE(floatingPoint.diagnostics[0].lineNumber, std::size_t(3));
    QVERIFY(floatingPoint.database.frames.empty());
    // Even if a caller overlooks the error, no integer definition is published.
    const DecodedFrameValue rejected = decoder.Decode(builder.Build(floatingPoint.database), raw);
    QCOMPARE(rejected.status, FrameDecodeStatus::UnknownFrame);
    QVERIFY(!rejected.valid);
    QVERIFY(!rejected.definition);
    QVERIFY(rejected.signals.empty());
}
 
void PipelineTest::emptyDatabase_data() {
    QTest::addColumn<QString>("text");
    QTest::newRow("empty-file") << QString();
    QTest::newRow("headers-only") << QString::fromUtf8("VERSION \"empty\"\nNS_ :\nBS_:\nBU_: Sender\n");
}
 
void PipelineTest::emptyDatabase() {
    QFETCH(QString, text);
    const DbcParseResult parsed = ParseFixture(text.toStdString());
    QVERIFY(!parsed.HasErrors());
    QVERIFY(parsed.diagnostics.empty());
    QVERIFY(parsed.database.frames.empty());
    const DecodeDatabase runtime = DbcDecodeBuilder().Build(parsed.database);
    QVERIFY(runtime.GetFrames().empty());
    CheckUnknown(runtime, false);
    CheckUnknown(runtime, true);
    const std::unique_ptr<TreeNode> tree = DbcTreeBuilder().Build(parsed.database);
    QVERIFY(tree != nullptr);
    CheckTree(*tree, DbcDatabase());
}
 
void PipelineTest::databaseReplacement() {
    DbcParseResult parsed = ParseFixture(fixture);
    QVERIFY(!parsed.HasErrors());
    DecodeDatabase runtime = DbcDecodeBuilder().Build(parsed.database);
    std::unique_ptr<TreeNode> tree = DbcTreeBuilder().Build(parsed.database);
    RawCanFrame raw;
    raw.canId = 291U;
    raw.data = {3U, 4U};
    const DecodedFrameValue saved = DbcDecoder().Decode(runtime, raw);
    QVERIFY(saved.valid);
    QCOMPARE(saved.signals.size(), std::size_t(2));
    QVERIFY(tree != nullptr);
    std::unique_ptr<TreeNode> savedTree = std::move(tree);
 
    parsed = ParseFixture(R"DBC(BO_ 291 Replacement: 1 NewSender
 SG_ NewState : 0|8@1+ (3,-1) [-1|764] "V" NewReceiver
CM_ BO_ 291 "Replacement frame";
CM_ SG_ 291 NewState "Replacement signal";
VAL_ 291 NewState 4 "New four";
)DBC");
    QVERIFY(!parsed.HasErrors());
    QVERIFY(parsed.diagnostics.empty());
    FrameInfo replacement;
    replacement.name = "Replacement";
    replacement.canId = 291U;
    replacement.dlc = 1U;
    replacement.transmitter = "NewSender";
    replacement.comment = "Replacement frame";
    SignalInfo state;
    state.name = "NewState";
    state.length = 8U;
    state.factor = 3;
    state.offset = -1;
    state.minimum = -1;
    state.maximum = 764;
    state.unit = "V";
    state.receivers = {"NewReceiver"};
    state.comment = "Replacement signal";
    state.valueDescriptions = {{std::uint64_t(4), "New four"}};
    replacement.signals = {state};
    const DbcDatabase expected{{replacement}};
    QCOMPARE(parsed.database.frames.size(), std::size_t(1));
    CheckFrame(parsed.database.frames[0], replacement);
    runtime = DbcDecodeBuilder().Build(parsed.database);
    tree = DbcTreeBuilder().Build(parsed.database);
    QVERIFY(tree != nullptr);
    QCOMPARE(runtime.GetFrames().size(), std::size_t(1));
    CheckFrame(runtime.GetFrames()[0], replacement);
    CheckTree(*tree, expected);
    CheckUnknown(runtime, true);
    QVERIFY(runtime.FindFrame(FrameKey(0x18F00442U, true)) == nullptr);
    QVERIFY(runtime.FindSignal(SignalKey(FrameKey(291U, false), "State")) == nullptr);
    QVERIFY(runtime.FindSignal(SignalKey(FrameKey(291U, false), "Mode")) == nullptr);
    raw.data = {4U};
    const DecodedFrameValue current = DbcDecoder().Decode(runtime, raw);
    QVERIFY(current.valid);
    QCOMPARE(current.status, FrameDecodeStatus::Valid);
    QCOMPARE(current.signals.size(), std::size_t(1));
    QVERIFY(current.signals[0].valid);
    QVERIFY(current.signals[0].key == SignalKey(FrameKey(291U, false), "NewState"));
    QCOMPARE(current.signals[0].definition.get(), runtime.FindSignal(current.signals[0].key).get());
    QCOMPARE(std::get<std::uint64_t>(current.signals[0].rawValue), std::uint64_t(4));
    QCOMPARE(current.signals[0].physicalValue, 11.0);
    QVERIFY(current.signals[0].GetValueDescription() != nullptr);
    QCOMPARE(*current.signals[0].GetValueDescription(), std::string("New four"));
 
    parsed = ParseFixture("");
    QVERIFY(!parsed.HasErrors());
    QVERIFY(parsed.diagnostics.empty());
    runtime = DbcDecodeBuilder().Build(parsed.database);
    tree = DbcTreeBuilder().Build(parsed.database);
    QVERIFY(tree != nullptr);
    QVERIFY(runtime.GetFrames().empty());
    CheckUnknown(runtime, false);
    CheckUnknown(runtime, true);
    CheckTree(*tree, DbcDatabase());
    QVERIFY(runtime.FindSignal(current.signals[0].key) == nullptr);
    CheckFrame(*current.definition, replacement);
    CheckFrame(*saved.definition, ExpectedMetadata().frames[0]);
    CheckTree(*savedTree, ExpectedMetadata());
    QCOMPARE(saved.signals[1].physicalValue, 9.0);
    QVERIFY(saved.signals[1].GetValueDescription() != nullptr);
    QCOMPARE(*saved.signals[1].GetValueDescription(), std::string("Standard four"));
}
 
int RunPipelineTests(int argc, char **argv) {
    PipelineTest test;
    return QTest::qExec(&test, argc, argv);
}
 
#include "dbc_pipeline_test.moc"