Additional tests

tests/README.md

@@ -1,5 +1,8 @@
 # QtTest regression tests
 
+For instrumented builds, LCOV HTML reports, Qt Creator coverage configuration,
+and Coco installation, see [Measuring code coverage](../README.md#measuring-code-coverage).
+
 Open the repository's root `dbc.pro` in Qt Creator. It contains `core` (a static
 C++17 library) and `tests` (the `dbc_tests` QtTest executable). Core is built first;
 tests link its archive rather than compiling its implementation again.

tests/dbc_coverage_test.cpp

@@ -3,6 +3,7 @@
 #include "dbc_decode_builder.h"
 #include "dbc_decoder.h"
 #include "dbc_tree_builder.h"
+#include "dbc_statement_handler.h"
 #include "typefactory.h"
 #include <QtTest>
 #include <QTemporaryFile>
@@ -75,6 +76,11 @@ private Q_SLOTS:
     void pgn();
     void comments_data();
     void comments();
+    void ignoredCommentStatements_data();
+    void ignoredCommentStatements();
+    void ambiguousValueReferences_data();
+    void ambiguousValueReferences();
+    void valueReferenceScope();
     void fileFormatting_data();
     void fileFormatting();
     void missingFile();
@@ -300,6 +306,124 @@ void CoverageTest::comments() {
     QCOMPARE(parsed.frames[0].signals[0].comment, signalComment.toStdString());
 }
 
+void CoverageTest::ignoredCommentStatements_data() {
+    QTest::addColumn<QString>("statement");
+    QTest::newRow("empty") << QString();
+    QTest::newRow("wrong-keyword") << QStringLiteral("OTHER_ BO_ 1 \"Ignored\";");
+    QTest::newRow("keyword-prefix") << QStringLiteral("CM_OTHER BO_ 1 \"Ignored\";");
+    QTest::newRow("frame-without-cm") << QStringLiteral("BO_ 1 \"Ignored\";");
+    QTest::newRow("missing-subtype") << QStringLiteral("CM_");
+    QTest::newRow("global-comment") << QStringLiteral("CM_ \"Ignored\";");
+    QTest::newRow("node-comment") << QStringLiteral("CM_ BU_ ECU \"Ignored\";");
+    QTest::newRow("environment-comment") << QStringLiteral("CM_ EV_ State \"Ignored\";");
+    QTest::newRow("unknown-subtype") << QStringLiteral("CM_ OTHER_ 1 \"Ignored\";");
+}
+
+void CoverageTest::ignoredCommentStatements() {
+    QFETCH(QString, statement);
+    DbcDatabase database;
+    FrameInfo frame;
+    frame.canId = 1U;
+    frame.name = "Frame";
+    frame.comment = "Existing frame comment";
+    SignalInfo signal;
+    signal.name = "State";
+    signal.comment = "Existing signal comment";
+    frame.signals.push_back(signal);
+    database.frames.push_back(frame);
+    DbcParseContext context{database, &database.frames[0]};
+
+    // The handler is public: callers may bypass keyword dispatch. Ignored input
+    // must preserve existing metadata, including comments already assigned.
+    DbcCommentHandler().Handle(statement.toStdString(), context);
+    QCOMPARE(database.frames.size(), std::size_t(1));
+    QCOMPARE(database.frames[0].canId, 1U);
+    QCOMPARE(database.frames[0].name, frame.name);
+    QCOMPARE(database.frames[0].comment, frame.comment);
+    QCOMPARE(database.frames[0].signals.size(), std::size_t(1));
+    QCOMPARE(database.frames[0].signals[0].name, signal.name);
+    QCOMPARE(database.frames[0].signals[0].comment, signal.comment);
+    QCOMPARE(context.currentFrame, &database.frames[0]);
+}
+
+void CoverageTest::ambiguousValueReferences_data() {
+    QTest::addColumn<bool>("duplicateFrames");
+    QTest::addColumn<bool>("extended");
+    QTest::newRow("duplicate-standard-frames") << true << false;
+    QTest::newRow("duplicate-extended-frames") << true << true;
+    QTest::newRow("duplicate-signals-in-standard-frame") << false << false;
+    QTest::newRow("duplicate-signals-in-extended-frame") << false << true;
+}
+
+void CoverageTest::ambiguousValueReferences() {
+    QFETCH(bool, duplicateFrames);
+    QFETCH(bool, extended);
+    DbcDatabase database;
+    FrameInfo frame;
+    frame.canId = 1U;
+    frame.name = "Frame";
+    frame.isExtended = extended;
+    SignalInfo signal;
+    signal.name = "State";
+    frame.signals.push_back(signal);
+    if (!duplicateFrames) frame.signals.push_back(signal);
+    database.frames.push_back(frame);
+    if (duplicateFrames) database.frames.push_back(frame);
+
+    // ParseFile rejects duplicate definitions earlier. Construct the database
+    // through the public metadata API to exercise the resolver's own checks.
+    DbcParseContext context{database, nullptr};
+    context.lineNumber = 37U;
+    const std::string rawId = extended ? "2147483649" : "1";
+    DbcValueDescriptionHandler().Handle("VAL_ " + rawId + " State 0 \"Off\";", context);
+    QCOMPARE(context.pendingValues.size(), std::size_t(1));
+    QCOMPARE(context.pendingValues[0].lineNumber, std::size_t(37));
+    const std::string path = "manual database.dbc";
+    try {
+        context.ResolveValueDescriptions(path);
+        QFAIL("The resolver must reject an ambiguous target");
+    } catch (const std::runtime_error &error) {
+        const std::string message = duplicateFrames ? "Ambiguous VAL_ frame reference."
+                                                   : "Ambiguous VAL_ signal reference: State";
+        QCOMPARE(std::string(error.what()), path + ":37: " + message);
+    }
+    // Ambiguity must be detected before applying any descriptions.
+    for (const auto &candidate : database.frames)
+        for (const auto &candidateSignal : candidate.signals)
+            QVERIFY(candidateSignal.valueDescriptions.empty());
+}
+
+void CoverageTest::valueReferenceScope() {
+    DbcDatabase database;
+    FrameInfo frame;
+    frame.canId = 1U;
+    SignalInfo signal;
+    signal.name = "State";
+    frame.signals.push_back(signal);
+    database.frames.push_back(frame);
+    frame.isExtended = true;
+    database.frames.push_back(frame);
+    frame.canId = 2U;
+    frame.isExtended = false;
+    database.frames.push_back(frame);
+
+    DbcParseContext context{database, nullptr};
+    const DbcValueDescriptionHandler handler;
+    context.lineNumber = 3U;
+    handler.Handle("VAL_ 1 State 0 \"Standard\";", context);
+    context.lineNumber = 7U;
+    handler.Handle("VAL_ 2147483649 State 0 \"Extended\";", context);
+    context.ResolveValueDescriptions("manual database.dbc");
+
+    const auto *standard = FindValueDescription(database.frames[0].signals[0].valueDescriptions, std::uint64_t(0));
+    const auto *extended = FindValueDescription(database.frames[1].signals[0].valueDescriptions, std::uint64_t(0));
+    QVERIFY(standard != nullptr);
+    QVERIFY(extended != nullptr);
+    QCOMPARE(*standard, std::string("Standard"));
+    QCOMPARE(*extended, std::string("Extended"));
+    QVERIFY(database.frames[2].signals[0].valueDescriptions.empty());
+}
+
 void CoverageTest::fileFormatting_data() {
     QTest::addColumn<QString>("text"); QTest::addColumn<unsigned>("frames");
     QTest::newRow("empty") << QString::fromUtf8("") << 0U;