Closes #16

tests/dbc_decoder_test.cpp

@@ -4,6 +4,7 @@
 #include <cmath>
 #include <limits>
 #include <sstream>
+#include <stdexcept>
 
 struct DecodeCase {
     const char *name;
@@ -77,6 +78,10 @@ void DbcDecoderTest::decode() {
     definition.canId = 0x123U;
     definition.dlc = 8U;
     definition.signals.push_back(signal);
+    if (test.length == 0U || test.length > 64U || test.startBit > 64U) {
+        QVERIFY_THROWS_EXCEPTION(std::invalid_argument, (void) DecodeDatabase({definition}));
+        return;
+    }
     const DecodeDatabase database({definition});
 
     RawCanFrame frame;
@@ -253,22 +258,7 @@ void DbcDecoderTest::invalidDefinitions() {
         case 7: bad.multiplexing.role = MultiplexRole::Branch; break;
         }
         definition.signals = {bad, good};
-        const DecodeDatabase database({definition});
-        RawCanFrame raw;
-        raw.data = {0xFFU, 0xFFU}; // Extra bytes must not rescue an invalid definition.
-        const DecodedFrameValue result = DbcDecoder().Decode(database, raw);
-        QVERIFY(result.valid);
-        QCOMPARE(result.status, FrameDecodeStatus::SignalErrors);
-        QCOMPARE(result.signals[0].status, SignalDecodeStatus::InvalidDefinition);
-        QVERIFY(!result.signals[0].valid && !result.signals[0].GetValueDescription());
-        QCOMPARE(result.signals[1].status, SignalDecodeStatus::Valid);
-        QCOMPARE(std::get<std::uint64_t>(result.signals[1].rawValue), std::uint64_t(15U));
-        QCOMPARE(result.signals[1].physicalValue, 15.0);
-        raw.data.clear();
-        const DecodedFrameValue shortResult = DbcDecoder().Decode(database, raw);
-        QCOMPARE(shortResult.status, FrameDecodeStatus::InsufficientPayload);
-        QCOMPARE(shortResult.signals[0].status, SignalDecodeStatus::InvalidDefinition);
-        QCOMPARE(shortResult.signals[1].status, SignalDecodeStatus::InsufficientPayload);
+        QVERIFY_THROWS_EXCEPTION(std::invalid_argument, (void) DecodeDatabase({definition}));
     }
 }
 
@@ -313,6 +303,10 @@ void DbcDecoderTest::physicalConversion() {
         definition.signals.push_back(signal);
         RawCanFrame raw;
         raw.data = {0x32U};
+        if (!std::isfinite(factor) || !std::isfinite(offset)) {
+            QVERIFY_THROWS_EXCEPTION(std::invalid_argument, (void) DecodeDatabase({definition}));
+            continue;
+        }
         const DecodedFrameValue result = DbcDecoder().Decode(DecodeDatabase({definition}), raw);
         QVERIFY(result.valid);
         QCOMPARE(result.status, finite ? FrameDecodeStatus::Valid : FrameDecodeStatus::SignalErrors);
@@ -340,25 +334,25 @@ void DbcDecoderTest::selectorConversionFailure() {
     definition.dlc = 1U;
     DecodeSignal selector;
     selector.name = "Selector";
-    selector.length = 1U;
+    selector.length = 2U;
     selector.multiplexing.role = MultiplexRole::Selector;
-    selector.factor = std::numeric_limits<double>::infinity();
+    selector.factor = std::numeric_limits<double>::max();
     DecodeSignal branch;
     branch.name = "Branch";
-    branch.startBit = 1U;
-    branch.length = 7U;
+    branch.startBit = 2U;
+    branch.length = 6U;
     branch.multiplexing.role = MultiplexRole::Branch;
-    branch.multiplexing.value = 1U;
+    branch.multiplexing.value = 2U;
     definition.signals = {branch, selector};
     RawCanFrame raw;
-    raw.data = {85U};
+    raw.data = {170U};
     const DecodedFrameValue result = DbcDecoder().Decode(DecodeDatabase({definition}), raw);
     QCOMPARE(result.status, FrameDecodeStatus::SignalErrors);
     QVERIFY(result.signals[0].valid);
     QCOMPARE(result.signals[0].physicalValue, 42.0);
     QCOMPARE(result.signals[1].status, SignalDecodeStatus::PhysicalConversionFailed);
-    QCOMPARE(std::get<std::uint64_t>(result.signals[1].rawValue), std::uint64_t(1U));
-    raw.data = {84U};
+    QCOMPARE(std::get<std::uint64_t>(result.signals[1].rawValue), std::uint64_t(2U));
+    raw.data = {168U};
     selector.factor = 1.0;
     definition.signals = {branch, selector};
     const DecodedFrameValue inactive = DbcDecoder().Decode(DecodeDatabase({definition}), raw);
@@ -378,9 +372,7 @@ void DbcDecoderTest::zeroDlc() {
     DecodeSignal signal;
     signal.length = 8U;
     definition.signals.push_back(signal);
-    const DecodedFrameValue invalid = DbcDecoder().Decode(DecodeDatabase({definition}), raw);
-    QCOMPARE(invalid.status, FrameDecodeStatus::SignalErrors);
-    QCOMPARE(invalid.signals[0].status, SignalDecodeStatus::InvalidDefinition);
+    QVERIFY_THROWS_EXCEPTION(std::invalid_argument, (void) DecodeDatabase({definition}));
 }
 
 int RunDecoderTests(int argc, char **argv) {