Closes #33

tests/dbc_pipeline_test.cpp

@@ -199,6 +199,8 @@ private Q_SLOTS:
     void emptyDatabase_data();
     void emptyDatabase();
     void databaseReplacement();
+    void unsupportedSignalTypes_data();
+    void unsupportedSignalTypes();
 };
 
 void PipelineTest::metadataLookupDecodeAndTree() {
@@ -277,6 +279,54 @@ void PipelineTest::metadataLookupDecodeAndTree() {
     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();