DBC Framework
DBC parsing and CAN signal decoding framework
Loading...
Searching...
No Matches
dbc_coverage_test.cpp
1// Additional regression coverage. Kept separate for review before the first run.
2#include "dbc_decode_builder.h"
3#include "dbc_decoder.h"
4#include "dbc_parser.h"
5#include "dbc_statement_handler.h"
6#include "dbc_tree_builder.h"
7#include "typefactory.h"
8#include <QTemporaryFile>
9#include <QtTest>
10#include <array>
11#include <limits>
12#include <stdexcept>
13
14namespace {
15 DbcDatabase ParseText(const std::string &text) {
16 QTemporaryFile file;
17 if (!file.open()) throw std::runtime_error("Cannot create DBC fixture");
18 if (file.write(text.data(), static_cast<qint64>(text.size())) != static_cast<qint64>(text.size()) || !file.flush())
19 throw std::runtime_error("Cannot write DBC fixture");
20 return DbcParser().ParseFile(file.fileName().toStdString());
21 }
22
23 DecodeDatabase SingleSignal(const DecodeSignal &signal) {
24 DecodeDatabase database;
25 DecodeFrame frame;
26 frame.canId = 17U;
27 frame.signals.push_back(signal);
28 database.frames.push_back(frame);
29 database.frameIndexByKey.emplace(FrameKey(17U, false), 0U);
30 return database;
31 }
32
33 // Independent reference: collect the visited bits first, then weight them.
34 // Motorola uses a linear MSB-first coordinate instead of sawtooth traversal.
35 std::uint64_t ReferenceExtract(const std::vector<std::uint8_t> &data,
36 ByteOrder order, unsigned start, unsigned length) {
37 std::uint64_t expected = 0;
38 for (unsigned i = 0; i < length; ++i) {
39 const unsigned coordinate = order == ByteOrder::Intel
40 ? start + i
41 : (start / 8U) * 8U + (7U - start % 8U) + i;
42 const unsigned bit = order == ByteOrder::Intel ? coordinate % 8U : 7U - coordinate % 8U;
43 const unsigned weight = order == ByteOrder::Intel ? i : length - 1U - i;
44 expected |= std::uint64_t((data.at(coordinate / 8U) >> bit) & 1U) << weight;
45 }
46 return expected;
47 }
48
49 struct FactoryBase {
50 virtual ~FactoryBase() = default;
51 virtual int Value() const = 0;
52 };
53 struct FactoryFirst : FactoryBase {
54 explicit FactoryFirst(std::unique_ptr<int> value) : value(std::move(value)) {}
55 int Value() const override { return *value; }
56 std::unique_ptr<int> value;
57 };
58 struct FactorySecond : FactoryFirst {
59 using FactoryFirst::FactoryFirst;
60 int Value() const override { return *value + 1; }
61 };
62}// namespace
63
64class CoverageTest : public QObject {
65 Q_OBJECT
66private Q_SLOTS:
67 void frameLookup();
68 void signedBoundaries_data();
69 void signedBoundaries();
70 void extraction_data();
71 void extraction();
72 void invalidSignalStatus_data();
73 void invalidSignalStatus();
74 void malformedRuntimeMultiplexing_data();
75 void malformedRuntimeMultiplexing();
76 void pgn_data();
77 void pgn();
78 void comments_data();
79 void comments();
80 void ignoredCommentStatements_data();
81 void ignoredCommentStatements();
82 void ambiguousValueReferences_data();
83 void ambiguousValueReferences();
84 void valueReferenceScope();
85 void fileFormatting_data();
86 void fileFormatting();
87 void missingFile();
88 void builders();
89 void physicalConversion_data();
90 void physicalConversion();
91 void multiplexingScenarios();
92 void multiplexingErrorLocations_data();
93 void multiplexingErrorLocations();
94 void escapedValueDescriptions();
95 void factory();
96};
97
98void CoverageTest::frameLookup() {
99 DbcDecoder decoder;
100 RawCanFrame raw;
101 raw.canId = 17U;
102 DecodeDatabase empty;
103 QVERIFY(decoder.FindFrame(empty, 17U, false) == nullptr);
104 const DecodedFrameValue absent = decoder.Decode(empty, raw);
105 QVERIFY(!absent.valid);
106 QVERIFY(absent.definition == nullptr);
107 QVERIFY(absent.signals.empty());
108 DecodeSignal signal;
109 DecodeDatabase database = SingleSignal(signal);
110 QVERIFY(decoder.FindFrame(database, 18U, false) == nullptr);
111 QVERIFY(decoder.FindFrame(database, 17U, true) == nullptr);
112 raw.isExtended = true;
113 QVERIFY(!decoder.Decode(database, raw).valid);
114 raw.isExtended = false;
115 raw.canId = 18U;
116 QVERIFY(!decoder.Decode(database, raw).valid);
117 raw.canId = 17U;
118 database.frameIndexByKey.at(FrameKey(17U, false)) = database.frames.size();
119 QVERIFY(decoder.FindFrame(database, 17U, false) == nullptr);
120 QVERIFY(!decoder.Decode(database, raw).valid);
121 database.frameIndexByKey.at(FrameKey(17U, false)) = 0U;
122 database.frames[0].signals.clear();
123 const DecodedFrameValue matched = decoder.Decode(database, raw);
124 QVERIFY(matched.valid);
125 QCOMPARE(matched.definition, &database.frames[0]);
126 QVERIFY(matched.signals.empty());
127}
128
129void CoverageTest::signedBoundaries_data() {
130 QTest::addColumn<int>("order");
131 QTest::addColumn<unsigned>("length");
132 QTest::addColumn<qlonglong>("expected");
133 for (int order = 0; order < 2; ++order) {
134 for (unsigned length: {1U, 2U, 7U, 8U, 31U, 32U, 63U}) {
135 const std::int64_t half = std::int64_t(1) << (length - 1U);
136 const std::array<std::int64_t, 4> values{{0, -1, -half, half - 1}};
137 for (unsigned index = 0; index < values.size(); ++index) {
138 const QByteArray name = QByteArray::number(order) + "-" + QByteArray::number(length) + "-" + QByteArray::number(index);
139 QTest::newRow(name.constData()) << order << length << qlonglong(values[index]);
140 }
141 }
142 }
143}
144
145void CoverageTest::signedBoundaries() {
146 QFETCH(int, order);
147 QFETCH(unsigned, length);
148 QFETCH(qlonglong, expected);
149 DecodeSignal signal;
150 signal.byteOrder = order == 0 ? ByteOrder::Intel : ByteOrder::Motorola;
151 signal.startBit = order == 0 ? 0U : 7U;
152 signal.length = length;
153 signal.valueType = ValueType::Signed;
154 RawCanFrame raw;
155 raw.canId = 17U;
156 raw.data.assign(8U, 0U);
157 const std::uint64_t bits = static_cast<std::uint64_t>(expected);
158 for (unsigned i = 0; i < length; ++i) {
159 const unsigned weight = order == 0 ? i : length - 1U - i;
160 const unsigned position = order == 0 ? i % 8U : 7U - i % 8U;
161 raw.data[i / 8U] |= static_cast<std::uint8_t>(((bits >> weight) & 1U) << position);
162 }
163 const DecodeDatabase database = SingleSignal(signal);
164 const DecodedFrameValue result = DbcDecoder().Decode(database, raw);
165 QVERIFY(result.signals[0].valid);
166 QVERIFY(std::holds_alternative<std::int64_t>(result.signals[0].rawValue));
167 QCOMPARE(std::get<std::int64_t>(result.signals[0].rawValue), static_cast<std::int64_t>(expected));
168}
169
170void CoverageTest::extraction_data() {
171 QTest::addColumn<int>("order");
172 QTest::addColumn<unsigned>("start");
173 QTest::addColumn<unsigned>("length");
174 for (int order = 0; order < 2; ++order)
175 for (unsigned start = 0; start < 16U; ++start)
176 for (unsigned length = 1; length <= 64U; ++length) {
177 const QByteArray name = QByteArray::number(order) + "-" + QByteArray::number(start) + "-" + QByteArray::number(length);
178 QTest::newRow(name.constData()) << order << start << length;
179 }
180}
181
182void CoverageTest::extraction() {
183 QFETCH(int, order);
184 QFETCH(unsigned, start);
185 QFETCH(unsigned, length);
186 DecodeSignal signal;
187 signal.byteOrder = order == 0 ? ByteOrder::Intel : ByteOrder::Motorola;
188 signal.startBit = start;
189 signal.length = length;
190 const DecodeDatabase database = SingleSignal(signal);
191 RawCanFrame raw;
192 raw.canId = 17U;
193 const std::vector<std::vector<std::uint8_t>> patterns = {
194 std::vector<std::uint8_t>(10U, 0U),
195 std::vector<std::uint8_t>(10U, 255U),
196 {0xA5, 0x3C, 0x81, 0x7E, 0x12, 0xD4, 0x69, 0xB0, 0x5A, 0xC3}};
197 for (const std::vector<std::uint8_t> &data: patterns) {
198 raw.data = data;
199 const unsigned firstCoordinate = order == 0 ? start : (start / 8U) * 8U + 7U - start % 8U;
200 raw.data.resize((firstCoordinate + length + 7U) / 8U);
201 const DecodedFrameValue decoded = DbcDecoder().Decode(database, raw);
202 QVERIFY(decoded.signals[0].valid);
203 QCOMPARE(std::get<std::uint64_t>(decoded.signals[0].rawValue), ReferenceExtract(data, signal.byteOrder, start, length));
204 }
205}
206
207void CoverageTest::invalidSignalStatus_data() {
208 QTest::addColumn<int>("order");
209 QTest::addColumn<unsigned>("start");
210 QTest::addColumn<unsigned>("length");
211 QTest::addColumn<unsigned>("bytes");
212 QTest::addColumn<int>("status");
213 for (int order = 0; order < 2; ++order) {
214 const unsigned start = order == 0 ? 0U : 7U;
215 const QByteArray prefix = QByteArray::number(order);
216 QTest::newRow((prefix + "-zero").constData()) << order << start << 0U << 1U << int(SignalDecodeStatus::InvalidDefinition);
217 QTest::newRow((prefix + "-65").constData()) << order << start << 65U << 9U << int(SignalDecodeStatus::InvalidDefinition);
218 QTest::newRow((prefix + "-empty").constData()) << order << start << 8U << 0U << int(SignalDecodeStatus::InsufficientPayload);
219 QTest::newRow((prefix + "-short").constData()) << order << start << 16U << 1U << int(SignalDecodeStatus::InsufficientPayload);
220 QTest::newRow((prefix + "-large-start").constData()) << order << std::numeric_limits<unsigned>::max() << 8U << 1U << int(SignalDecodeStatus::InsufficientPayload);
221 }
222}
223
224void CoverageTest::invalidSignalStatus() {
225 QFETCH(int, order);
226 QFETCH(unsigned, start);
227 QFETCH(unsigned, length);
228 QFETCH(unsigned, bytes);
229 QFETCH(int, status);
230 DecodeSignal signal;
231 signal.startBit = start;
232 signal.length = length;
233 signal.byteOrder = order == 0 ? ByteOrder::Intel : ByteOrder::Motorola;
234 const DecodeDatabase database = SingleSignal(signal);
235 RawCanFrame raw;
236 raw.canId = 17U;
237 raw.data.assign(bytes, 255U);
238 const DecodedFrameValue decoded = DbcDecoder().Decode(database, raw);
239 QVERIFY(decoded.valid);
240 QVERIFY(!decoded.signals[0].valid);
241 QCOMPARE(int(decoded.signals[0].status), status);
242 QVERIFY(decoded.signals[0].GetValueDescription() == nullptr);
243}
244
245void CoverageTest::malformedRuntimeMultiplexing_data() {
246 QTest::addColumn<int>("kind");
247 QTest::newRow("two-selectors") << 0;
248 QTest::newRow("signed-selector") << 1;
249 QTest::newRow("65-bit-selector") << 2;
250 QTest::newRow("branch-out-of-range") << 3;
251}
252
253void CoverageTest::malformedRuntimeMultiplexing() {
254 QFETCH(int, kind);
255 DecodeSignal selector;
256 selector.length = 1U;
257 selector.multiplexing.role = MultiplexRole::Selector;
258 DecodeDatabase database = SingleSignal(selector);
259 DecodeSignal branch;
260 branch.startBit = 8U;
261 branch.length = 8U;
262 branch.multiplexing.role = MultiplexRole::Branch;
263 branch.multiplexing.value = 1U;
264 database.frames[0].signals.push_back(branch);
265 DecodeSignal ordinary;
266 ordinary.startBit = 16U;
267 ordinary.length = 8U;
268 database.frames[0].signals.push_back(ordinary);
269 if (kind == 0) database.frames[0].signals.push_back(selector);
270 if (kind == 1) database.frames[0].signals[0].valueType = ValueType::Signed;
271 if (kind == 2) database.frames[0].signals[0].length = 65U;
272 if (kind == 3) database.frames[0].signals[1].multiplexing.value = 2U;
273 RawCanFrame raw;
274 raw.canId = 17U;
275 raw.data = {1U, 42U, 99U};
276 const DecodedFrameValue result = DbcDecoder().Decode(database, raw);
277 QCOMPARE(int(result.signals[1].status), int(SignalDecodeStatus::InvalidDefinition));
278 QVERIFY(!result.signals[1].valid);
279 QVERIFY(result.signals[2].valid);
280 QCOMPARE(std::get<std::uint64_t>(result.signals[2].rawValue), std::uint64_t(99));
281 if (kind != 3) {
282 QCOMPARE(int(result.signals[0].status), int(SignalDecodeStatus::InvalidDefinition));
283 if (kind == 0) QCOMPARE(int(result.signals[3].status), int(SignalDecodeStatus::InvalidDefinition));
284 }
285}
286
287void CoverageTest::pgn_data() {
288 QTest::addColumn<unsigned>("id");
289 QTest::addColumn<unsigned>("expected");
290 QTest::addColumn<bool>("hasPgn");
291 QTest::newRow("standard") << 0x7FFU << 0U << false;
292 for (unsigned dp: {0U, 1U})
293 for (unsigned pf: {239U, 240U})
294 for (unsigned ps: {0U, 0xABU}) {
295 const unsigned id = 0x80000000U | (dp << 24U) | (pf << 16U) | (ps << 8U) | 0x42U;
296 const unsigned expected = (dp << 16U) | (pf == 239U ? 0xEF00U : 0xF000U | ps);
297 const QByteArray name = QByteArray::number(dp) + "-" + QByteArray::number(pf) + "-" + QByteArray::number(ps);
298 QTest::newRow(name.constData()) << id << expected << true;
299 }
300}
301
302void CoverageTest::pgn() {
303 QFETCH(unsigned, id);
304 QFETCH(unsigned, expected);
305 QFETCH(bool, hasPgn);
306 const DbcDatabase parsed = ParseText("BO_ " + std::to_string(id) + " Frame: 8 ECU\n");
307 QCOMPARE(parsed.frames[0].hasPgn, hasPgn);
308 QCOMPARE(parsed.frames[0].pgn, expected);
309}
310
311void CoverageTest::comments_data() {
312 QTest::addColumn<QString>("before");
313 QTest::addColumn<QString>("after");
314 QTest::addColumn<QString>("frameComment");
315 QTest::addColumn<QString>("signalComment");
316 QTest::newRow("tabs") << QString::fromUtf8("") << QString::fromUtf8("CM_\tBO_ 1 \"Frame\";\nCM_\tSG_ 1 State \"Signal\";\n") << QString::fromUtf8("Frame") << QString::fromUtf8("Signal");
317 QTest::newRow("empty-overwrite") << QString::fromUtf8("") << QString::fromUtf8("CM_ BO_ 1 \"Old\";\nCM_ BO_ 1 \"\";\nCM_ SG_ 1 State \"Old\";\nCM_ SG_ 1 State \"\";\n") << QString::fromUtf8("") << QString::fromUtf8("");
318 QTest::newRow("last-wins") << QString::fromUtf8("") << QString::fromUtf8("CM_ BO_ 1 \"First\";\nCM_ BO_ 1 \"Last\";\nCM_ SG_ 1 State \"First\";\nCM_ SG_ 1 State \"Last\";\n") << QString::fromUtf8("Last") << QString::fromUtf8("Last");
319 QTest::newRow("missing-targets") << QString::fromUtf8("") << QString::fromUtf8("CM_ BO_ 2 \"Unknown\";\nCM_ SG_ 2 State \"Unknown\";\nCM_ SG_ 1 Missing \"Unknown\";\n") << QString::fromUtf8("") << QString::fromUtf8("");
320 // Current documented limitation: comments resolve only already parsed targets.
321 QTest::newRow("before-definitions") << QString::fromUtf8("CM_ BO_ 1 \"Early\";\nCM_ SG_ 1 State \"Early\";\n") << QString::fromUtf8("") << QString::fromUtf8("") << QString::fromUtf8("");
322 QTest::newRow("missing-quotes") << QString::fromUtf8("") << QString::fromUtf8("CM_ BO_ 1 Missing;\nCM_ SG_ 1 State \"Unclosed;\n") << QString::fromUtf8("") << QString::fromUtf8("");
323}
324
325void CoverageTest::comments() {
326 QFETCH(QString, before);
327 QFETCH(QString, after);
328 QFETCH(QString, frameComment);
329 QFETCH(QString, signalComment);
330 const DbcDatabase parsed = ParseText(before.toStdString() + "BO_ 1 Frame: 1 ECU\nSG_ State : 0|8@1+ (1,0) [0|255] \"\" ECU\n" + after.toStdString());
331 QCOMPARE(parsed.frames[0].comment, frameComment.toStdString());
332 QCOMPARE(parsed.frames[0].signals[0].comment, signalComment.toStdString());
333}
334
335void CoverageTest::ignoredCommentStatements_data() {
336 QTest::addColumn<QString>("statement");
337 QTest::newRow("empty") << QString();
338 QTest::newRow("wrong-keyword") << QStringLiteral("OTHER_ BO_ 1 \"Ignored\";");
339 QTest::newRow("keyword-prefix") << QStringLiteral("CM_OTHER BO_ 1 \"Ignored\";");
340 QTest::newRow("frame-without-cm") << QStringLiteral("BO_ 1 \"Ignored\";");
341 QTest::newRow("missing-subtype") << QStringLiteral("CM_");
342 QTest::newRow("global-comment") << QStringLiteral("CM_ \"Ignored\";");
343 QTest::newRow("node-comment") << QStringLiteral("CM_ BU_ ECU \"Ignored\";");
344 QTest::newRow("environment-comment") << QStringLiteral("CM_ EV_ State \"Ignored\";");
345 QTest::newRow("unknown-subtype") << QStringLiteral("CM_ OTHER_ 1 \"Ignored\";");
346}
347
348void CoverageTest::ignoredCommentStatements() {
349 QFETCH(QString, statement);
350 DbcDatabase database;
351 FrameInfo frame;
352 frame.canId = 1U;
353 frame.name = "Frame";
354 frame.comment = "Existing frame comment";
355 SignalInfo signal;
356 signal.name = "State";
357 signal.comment = "Existing signal comment";
358 frame.signals.push_back(signal);
359 database.frames.push_back(frame);
360 DbcParseContext context{database, &database.frames[0]};
361
362 // The handler is public: callers may bypass keyword dispatch. Ignored input
363 // must preserve existing metadata, including comments already assigned.
364 DbcCommentHandler().Handle(statement.toStdString(), context);
365 QCOMPARE(database.frames.size(), std::size_t(1));
366 QCOMPARE(database.frames[0].canId, 1U);
367 QCOMPARE(database.frames[0].name, frame.name);
368 QCOMPARE(database.frames[0].comment, frame.comment);
369 QCOMPARE(database.frames[0].signals.size(), std::size_t(1));
370 QCOMPARE(database.frames[0].signals[0].name, signal.name);
371 QCOMPARE(database.frames[0].signals[0].comment, signal.comment);
372 QCOMPARE(context.currentFrame, &database.frames[0]);
373}
374
375void CoverageTest::ambiguousValueReferences_data() {
376 QTest::addColumn<bool>("duplicateFrames");
377 QTest::addColumn<bool>("extended");
378 QTest::newRow("duplicate-standard-frames") << true << false;
379 QTest::newRow("duplicate-extended-frames") << true << true;
380 QTest::newRow("duplicate-signals-in-standard-frame") << false << false;
381 QTest::newRow("duplicate-signals-in-extended-frame") << false << true;
382}
383
384void CoverageTest::ambiguousValueReferences() {
385 QFETCH(bool, duplicateFrames);
386 QFETCH(bool, extended);
387 DbcDatabase database;
388 FrameInfo frame;
389 frame.canId = 1U;
390 frame.name = "Frame";
391 frame.isExtended = extended;
392 SignalInfo signal;
393 signal.name = "State";
394 frame.signals.push_back(signal);
395 if (!duplicateFrames) frame.signals.push_back(signal);
396 database.frames.push_back(frame);
397 if (duplicateFrames) database.frames.push_back(frame);
398
399 // ParseFile rejects duplicate definitions earlier. Construct the database
400 // through the public metadata API to exercise the resolver's own checks.
401 DbcParseContext context{database, nullptr};
402 context.lineNumber = 37U;
403 const std::string rawId = extended ? "2147483649" : "1";
404 DbcValueDescriptionHandler().Handle("VAL_ " + rawId + " State 0 \"Off\";", context);
405 QCOMPARE(context.pendingValues.size(), std::size_t(1));
406 QCOMPARE(context.pendingValues[0].lineNumber, std::size_t(37));
407 const std::string path = "manual database.dbc";
408 try {
409 context.ResolveValueDescriptions(path);
410 QFAIL("The resolver must reject an ambiguous target");
411 } catch (const std::runtime_error &error) {
412 const std::string message = duplicateFrames ? "Ambiguous VAL_ frame reference."
413 : "Ambiguous VAL_ signal reference: State";
414 QCOMPARE(std::string(error.what()), path + ":37: " + message);
415 }
416 // Ambiguity must be detected before applying any descriptions.
417 for (const FrameInfo &candidate: database.frames)
418 for (const SignalInfo &candidateSignal: candidate.signals)
419 QVERIFY(candidateSignal.valueDescriptions.empty());
420}
421
422void CoverageTest::valueReferenceScope() {
423 DbcDatabase database;
424 FrameInfo frame;
425 frame.canId = 1U;
426 SignalInfo signal;
427 signal.name = "State";
428 frame.signals.push_back(signal);
429 database.frames.push_back(frame);
430 frame.isExtended = true;
431 database.frames.push_back(frame);
432 frame.canId = 2U;
433 frame.isExtended = false;
434 database.frames.push_back(frame);
435
436 DbcParseContext context{database, nullptr};
437 const DbcValueDescriptionHandler handler;
438 context.lineNumber = 3U;
439 handler.Handle("VAL_ 1 State 0 \"Standard\";", context);
440 context.lineNumber = 7U;
441 handler.Handle("VAL_ 2147483649 State 0 \"Extended\";", context);
442 context.ResolveValueDescriptions("manual database.dbc");
443
444 const std::string *standard = FindValueDescription(database.frames[0].signals[0].valueDescriptions, std::uint64_t(0));
445 const std::string *extended = FindValueDescription(database.frames[1].signals[0].valueDescriptions, std::uint64_t(0));
446 QVERIFY(standard != nullptr);
447 QVERIFY(extended != nullptr);
448 QCOMPARE(*standard, std::string("Standard"));
449 QCOMPARE(*extended, std::string("Extended"));
450 QVERIFY(database.frames[2].signals[0].valueDescriptions.empty());
451}
452
453void CoverageTest::fileFormatting_data() {
454 QTest::addColumn<QString>("text");
455 QTest::addColumn<unsigned>("frames");
456 QTest::newRow("empty") << QString::fromUtf8("") << 0U;
457 QTest::newRow("whitespace") << QString::fromUtf8(" \t\r\n\n\t") << 0U;
458 QTest::newRow("unknown-only") << QString::fromUtf8("VERSION \"test\"\nBU_: ECU\nUNKNOWN_ data\n") << 0U;
459 QTest::newRow("no-final-newline") << QString::fromUtf8("BO_ 1 Frame: 1 ECU\nSG_ State : 0|8@1+ (1,0) [0|255] \"\" ECU") << 1U;
460 QTest::newRow("crlf") << QString::fromUtf8("\r\nBO_ 1 Frame: 1 ECU\r\nSG_ State : 0|8@1+ (1,0) [0|255] \"\" ECU\r\nCM_ BO_ 1 \"Comment\";\r\nVAL_ 1 State 0 \"Off\";\r\n") << 1U;
461}
462
463void CoverageTest::fileFormatting() {
464 QFETCH(QString, text);
465 QFETCH(unsigned, frames);
466 const DbcDatabase parsed = ParseText(text.toStdString());
467 QCOMPARE(parsed.frames.size(), std::size_t(frames));
468 if (frames) {
469 QCOMPARE(parsed.frames[0].signals.size(), std::size_t(1));
470 if (text.contains("\r\nBO_")) {
471 QCOMPARE(parsed.frames[0].comment, std::string("Comment"));
472 const std::string *description = FindValueDescription(parsed.frames[0].signals[0].valueDescriptions, std::uint64_t(0));
473 QVERIFY(description != nullptr);
474 QCOMPARE(*description, std::string("Off"));
475 }
476 }
477}
478
479void CoverageTest::missingFile() {
480 QTemporaryFile file;
481 QVERIFY(file.open());
482 const QString path = file.fileName();
483 QVERIFY(file.remove());
484 try {
485 DbcParser().ParseFile(path.toStdString());
486 QFAIL("Missing file must throw");
487 } catch (const std::runtime_error &error) {
488 QCOMPARE(std::string(error.what()), "Failed to open DBC file: " + path.toStdString());
489 }
490}
491
492void CoverageTest::builders() {
493 const DecodeDatabase emptyRuntime = DbcDecodeBuilder().Build(DbcDatabase());
494 QVERIFY(emptyRuntime.frames.empty());
495 QVERIFY(emptyRuntime.frameIndexByKey.empty());
496 const std::unique_ptr<TreeNode> emptyTree = DbcTreeBuilder().Build(DbcDatabase());
497 QCOMPARE(emptyTree->GetType(), NodeType::Root);
498 QCOMPARE(emptyTree->GetName(), std::string("dbc"));
499 QCOMPARE(emptyTree->GetChildCount(), std::size_t(0));
500 QVERIFY(emptyTree->GetFrame() == nullptr && emptyTree->GetSignal() == nullptr);
501 const DbcDatabase expected = ParseText(
502 "BO_ 256 Standard: 3 ECU1\n"
503 "SG_ Mode M : 0|8@1+ (2,3) [0|513] \"mode\" ECU1,ECU2\n"
504 "SG_ Branch m1 : 15|8@0- (-2,5) [-249|261] \"rpm\" ECU2,ECU3\n"
505 "SG_ Always : 16|8@1+ (0.25,-1) [-1|62.75] \"V\" ECU3\n"
506 "CM_ BO_ 256 \"Frame comment\";\nCM_ SG_ 256 Branch \"Branch comment\";\n"
507 "VAL_ 256 Branch -1 \"Negative\" 1 \"Positive\";\n"
508 "BO_ 2163212866 Extended: 8 ECU4\n");
509 DecodeDatabase runtime;
510 std::unique_ptr<TreeNode> tree;
511 {
512 DbcDatabase source = expected;
513 runtime = DbcDecodeBuilder().Build(source);
514 tree = DbcTreeBuilder().Build(source);
515 source.frames[0].name = "Changed";
516 source.frames[0].signals[1].receivers.clear();
517 source.frames[0].signals[1].valueDescriptions.clear();
518 source.frames.clear();
519 }
520 QCOMPARE(runtime.frames.size(), expected.frames.size());
521 QCOMPARE(tree->GetChildCount(), expected.frames.size());
522 QCOMPARE(runtime.frameIndexByKey.size(), expected.frames.size());
523 for (std::size_t i = 0; i < expected.frames.size(); ++i) {
524 const FrameInfo &frame = expected.frames[i];
525 const DecodeFrame &decodedFrame = runtime.frames[i];
526 const TreeNode *node = tree->GetChild(i);
527 QVERIFY(node && node->GetFrame());
528 QCOMPARE(node->GetType(), NodeType::Frame);
529 QCOMPARE(node->GetName(), frame.name);
530 QVERIFY(node->GetSignal() == nullptr);
531 QCOMPARE(runtime.frameIndexByKey.at(FrameKey(frame.canId, frame.isExtended)), i);
532 const FrameInfo &copied = *node->GetFrame();
533 QCOMPARE(copied.name, frame.name);
534 QCOMPARE(decodedFrame.name, frame.name);
535 QCOMPARE(copied.canId, frame.canId);
536 QCOMPARE(decodedFrame.canId, frame.canId);
537 QCOMPARE(copied.isExtended, frame.isExtended);
538 QCOMPARE(decodedFrame.isExtended, frame.isExtended);
539 QCOMPARE(copied.dlc, frame.dlc);
540 QCOMPARE(decodedFrame.dlc, frame.dlc);
541 QCOMPARE(copied.pgn, frame.pgn);
542 QCOMPARE(decodedFrame.pgn, frame.pgn);
543 QCOMPARE(copied.hasPgn, frame.hasPgn);
544 QCOMPARE(decodedFrame.hasPgn, frame.hasPgn);
545 QCOMPARE(copied.transmitter, frame.transmitter);
546 QCOMPARE(decodedFrame.transmitter, frame.transmitter);
547 QCOMPARE(copied.comment, frame.comment);
548 QCOMPARE(decodedFrame.comment, frame.comment);
549 QCOMPARE(node->GetChildCount(), frame.signals.size());
550 QCOMPARE(copied.signals.size(), frame.signals.size());
551 QCOMPARE(decodedFrame.signals.size(), frame.signals.size());
552 for (std::size_t j = 0; j < frame.signals.size(); ++j) {
553 const SignalInfo &original = frame.signals[j];
554 const DecodeSignal &target = decodedFrame.signals[j];
555 const TreeNode *leaf = node->GetChild(j);
556 QVERIFY(leaf && leaf->GetSignal());
557 QCOMPARE(leaf->GetType(), NodeType::Signal);
558 QCOMPARE(leaf->GetName(), original.name);
559 QVERIFY(leaf->GetFrame() == nullptr);
560 // Check both the frame payload copy and each child payload copy.
561 for (const SignalInfo *copy: {&copied.signals[j], leaf->GetSignal()}) {
562 QCOMPARE(copy->name, original.name);
563 QCOMPARE(copy->startBit, original.startBit);
564 QCOMPARE(copy->length, original.length);
565 QCOMPARE(copy->isLittleEndian, original.isLittleEndian);
566 QCOMPARE(copy->isSigned, original.isSigned);
567 QCOMPARE(copy->factor, original.factor);
568 QCOMPARE(copy->offset, original.offset);
569 QCOMPARE(copy->minimum, original.minimum);
570 QCOMPARE(copy->maximum, original.maximum);
571 QCOMPARE(copy->unit, original.unit);
572 QCOMPARE(copy->comment, original.comment);
573 QVERIFY(copy->receivers == original.receivers);
574 QVERIFY(copy->valueDescriptions == original.valueDescriptions);
575 QCOMPARE(copy->multiplexing.role, original.multiplexing.role);
576 QCOMPARE(copy->multiplexing.value, original.multiplexing.value);
577 }
578 QCOMPARE(target.name, original.name);
579 QCOMPARE(target.startBit, original.startBit);
580 QCOMPARE(target.length, original.length);
581 QCOMPARE(target.byteOrder, original.isLittleEndian ? ByteOrder::Intel : ByteOrder::Motorola);
582 QCOMPARE(target.valueType, original.isSigned ? ValueType::Signed : ValueType::Unsigned);
583 QCOMPARE(target.factor, original.factor);
584 QCOMPARE(target.offset, original.offset);
585 QCOMPARE(target.minimum, original.minimum);
586 QCOMPARE(target.maximum, original.maximum);
587 QCOMPARE(target.unit, original.unit);
588 QCOMPARE(target.comment, original.comment);
589 QVERIFY(target.receivers == original.receivers);
590 QVERIFY(target.valueDescriptions == original.valueDescriptions);
591 QCOMPARE(target.multiplexing.role, original.multiplexing.role);
592 QCOMPARE(target.multiplexing.value, original.multiplexing.value);
593 }
594 }
595}
596
597void CoverageTest::physicalConversion_data() {
598 QTest::addColumn<double>("factor");
599 QTest::addColumn<double>("offset");
600 QTest::addColumn<double>("expected");
601 QTest::newRow("zero-factor") << 0.0 << 7.0 << 7.0;
602 QTest::newRow("negative-factor") << -2.0 << 5.0 << -15.0;
603 QTest::newRow("above-declared-range") << 2.0 << 3.0 << 23.0;
604}
605
606void CoverageTest::physicalConversion() {
607 QFETCH(double, factor);
608 QFETCH(double, offset);
609 QFETCH(double, expected);
610 DecodeSignal signal;
611 signal.length = 8U;
612 signal.factor = factor;
613 signal.offset = offset;
614 signal.minimum = 0.0;
615 signal.maximum = 1.0;
616 const DecodeDatabase database = SingleSignal(signal);
617 RawCanFrame raw;
618 raw.canId = 17U;
619 raw.data = {10U};
620 const DecodedFrameValue decoded = DbcDecoder().Decode(database, raw);
621 QVERIFY(decoded.signals[0].valid);
622 QCOMPARE(std::get<std::uint64_t>(decoded.signals[0].rawValue), std::uint64_t(10));
623 QCOMPARE(decoded.signals[0].physicalValue, expected);
624}
625
626void CoverageTest::multiplexingScenarios() {
627 const DecodeDatabase selectorOnly = DbcDecodeBuilder().Build(ParseText(
628 "BO_ 1 Frame: 1 ECU\nSG_ Mode M : 0|1@1+ (1,0) [0|1] \"\" ECU\n"));
629 RawCanFrame raw;
630 raw.canId = 1U;
631 raw.data = {1U};
632 const DecodedFrameValue only = DbcDecoder().Decode(selectorOnly, raw);
633 QCOMPARE(only.signals.size(), std::size_t(1));
634 QVERIFY(only.signals[0].valid);
635 const DecodeDatabase database = DbcDecodeBuilder().Build(ParseText(
636 "BO_ 1 First: 3 ECU\n"
637 "SG_ Mode M : 0|1@1+ (1,0) [0|1] \"\" ECU\n"
638 "SG_ A m0 : 8|8@1+ (1,0) [0|255] \"\" ECU\n"
639 "SG_ B m0 : 16|8@1+ (1,0) [0|255] \"\" ECU\n"
640 "BO_ 2 Second: 2 ECU\n"
641 "SG_ Mode M : 0|1@1+ (1,0) [0|1] \"\" ECU\n"
642 "SG_ A m1 : 8|8@1+ (1,0) [0|255] \"\" ECU\n"));
643 raw.data = {0U, 42U, 99U};
644 const DecodedFrameValue first = DbcDecoder().Decode(database, raw);
645 QVERIFY(first.signals[1].valid && first.signals[2].valid);
646 QCOMPARE(std::get<std::uint64_t>(first.signals[1].rawValue), std::uint64_t(42));
647 QCOMPARE(std::get<std::uint64_t>(first.signals[2].rawValue), std::uint64_t(99));
648 raw.canId = 2U;
649 const DecodedFrameValue secondInactive = DbcDecoder().Decode(database, raw);
650 QCOMPARE(secondInactive.signals[1].status, SignalDecodeStatus::Inactive);
651 raw.data[0] = 1U;
652 QVERIFY(DbcDecoder().Decode(database, raw).signals[1].valid);
653 raw.canId = 1U;
654 const DecodedFrameValue firstInactive = DbcDecoder().Decode(database, raw);
655 QCOMPARE(firstInactive.signals[1].status, SignalDecodeStatus::Inactive);
656 QCOMPARE(firstInactive.signals[2].status, SignalDecodeStatus::Inactive);
657}
658
659void CoverageTest::multiplexingErrorLocations_data() {
660 QTest::addColumn<QString>("text");
661 QTest::addColumn<unsigned>("line");
662 QTest::addColumn<QString>("message");
663 const QString header = "BO_ 1 Frame: 3 ECU\n\n";
664 const QString selector = "SG_ Mode M : 0|1@1+ (1,0) [0|1] \"\" ECU\n";
665 const QString branch = "SG_ A m1 : 8|8@1+ (1,0) [0|255] \"\" ECU\n";
666 QTest::newRow("missing-selector") << header + branch << 3U << QString::fromUtf8("Multiplexed branch has no selector.");
667 QTest::newRow("second-selector") << header + selector + "\nSG_ Other M : 16|1@1+ (1,0) [0|1] \"\" ECU\n"
668 << 5U << QString::fromUtf8("Multiplexing requires one unsigned selector per frame.");
669 QTest::newRow("signed-selector") << header + "SG_ Mode M : 0|1@1- (1,0) [-1|0] \"\" ECU\n"
670 << 3U << QString::fromUtf8("Multiplexing requires one unsigned selector per frame.");
671 QTest::newRow("branch-range") << header + "SG_ A m2 : 8|8@1+ (1,0) [0|255] \"\" ECU\n" + selector << 3U << QString::fromUtf8("Branch value exceeds selector raw range.");
672 QTest::newRow("same-branch-overlap") << header + selector + branch + "SG_ B m1 : 15|8@0+ (1,0) [0|255] \"\" ECU\n"
673 << 5U << QString::fromUtf8("Signals overlap without mutually exclusive multiplexing conditions.");
674 QTest::newRow("selector-overlap") << header + selector + "SG_ A m1 : 0|1@1+ (1,0) [0|1] \"\" ECU\n"
675 << 4U << QString::fromUtf8("Signals overlap without mutually exclusive multiplexing conditions.");
676 QTest::newRow("unconditional-overlap") << header + selector + branch + "SG_ Always : 8|8@1+ (1,0) [0|255] \"\" ECU\n"
677 << 5U << QString::fromUtf8("Signals overlap without mutually exclusive multiplexing conditions.");
678 QTest::newRow("ordinary-overlap") << header + "SG_ A : 8|8@1+ (1,0) [0|255] \"\" ECU\nSG_ B : 15|8@0+ (1,0) [0|255] \"\" ECU\n"
679 << 4U << QString::fromUtf8("Signals overlap without mutually exclusive multiplexing conditions.");
680 QTest::newRow("extended-multiplexing") << header + "SG_MUL_VAL_ 1 A Mode 1-2;\n"
681 << 3U << QString::fromUtf8("Extended and nested multiplexing are unsupported.");
682 QTest::newRow("nested-marker") << header + "SG_ A m1M : 8|8@1+ (1,0) [0|255] \"\" ECU\n"
683 << 3U << QString::fromUtf8("Invalid or unsupported multiplexing marker.");
684}
685
686void CoverageTest::multiplexingErrorLocations() {
687 QFETCH(QString, text);
688 QFETCH(unsigned, line);
689 QFETCH(QString, message);
690 QTemporaryFile file;
691 QVERIFY(file.open());
692 const QByteArray content = text.toUtf8();
693 QCOMPARE(file.write(content), qint64(content.size()));
694 QVERIFY(file.flush());
695 try {
696 DbcParser().ParseFile(file.fileName().toStdString());
697 QFAIL("Expected multiplexing rejection");
698 } catch (const std::runtime_error &error) {
699 QCOMPARE(QString::fromStdString(error.what()), file.fileName() + ":" + QString::number(line) + ": " + message);
700 }
701}
702
703void CoverageTest::escapedValueDescriptions() {
704 const DbcDatabase parsed = ParseText(
705 "BO_ 1 Frame: 1 ECU\nSG_ State : 0|8@1+ (1,0) [0|255] \"\" ECU\n"
706 R"dbc(VAL_ 1 State -0 "Ноль" 1 "C:\\trace" 2 "\\\"quoted\"\\";)dbc"
707 "\n");
708 const ValueDescriptions &values = parsed.frames[0].signals[0].valueDescriptions;
709 QCOMPARE(values.size(), std::size_t(3));
710 QVERIFY(values.find(RawSignalValue(std::int64_t(0))) == values.end());
711 const std::string *zero = FindValueDescription(values, std::int64_t(0));
712 const std::string *path = FindValueDescription(values, std::uint64_t(1));
713 const std::string *quoted = FindValueDescription(values, std::uint64_t(2));
714 QVERIFY(zero && path && quoted);
715 QCOMPARE(*zero, std::string("Ноль"));
716 QCOMPARE(*path, std::string("C:\\trace"));
717 QCOMPARE(*quoted, std::string("\\\"quoted\"\\"));
718 QVERIFY(NormalizeValueKey(RawSignalValue(std::int64_t(0))) == RawSignalValue(std::uint64_t(0)));
719 QVERIFY(NormalizeValueKey(RawSignalValue(std::int64_t(-1))) == RawSignalValue(std::int64_t(-1)));
720}
721
722void CoverageTest::factory() {
723 TypeFactory<std::string, FactoryBase, std::unique_ptr<int>> factory;
724 QVERIFY(!factory.contains("value"));
725 QVERIFY_THROWS_EXCEPTION(std::out_of_range, static_cast<void>(factory.creator("missing")));
726 QVERIFY_THROWS_EXCEPTION(std::out_of_range, static_cast<void>(factory.create("missing", std::make_unique<int>(1))));
727 factory.registerType<FactoryFirst>("value");
728 QVERIFY(factory.contains("value"));
729 std::unique_ptr<int> argument = std::make_unique<int>(42);
730 const std::shared_ptr<FactoryBase> first = factory.create("value", std::move(argument));
731 QVERIFY(argument == nullptr);
732 QCOMPARE(first->Value(), 42);
733 const TypeFactory<std::string, FactoryBase, std::unique_ptr<int>>::CreatorFn creator = factory.creator("value");
734 QCOMPARE(creator(std::make_unique<int>(7))->Value(), 7);
735 factory.registerType<FactorySecond>("value");
736 QCOMPARE(factory.create("value", std::make_unique<int>(42))->Value(), 43);
737 QCOMPARE(first->Value(), 42);
738 QCOMPARE(creator(std::make_unique<int>(7))->Value(), 7);
739}
740
741int RunCoverageTests(int argc, char **argv) {
742 CoverageTest tests;
743 return QTest::qExec(&tests, argc, argv);
744}
745#include "dbc_coverage_test.moc"
DbcDecodeBuilder
Converts parsed DBC data into runtime decode database.
Definition dbc_decode_builder.h:21
DbcDecodeBuilder::Build
DecodeDatabase Build(const DbcDatabase &source) const
Build runtime decode database.
Definition dbc_decode_builder.cpp:14
DbcDecoder
Runtime CAN decoder using prebuilt decode database.
Definition dbc_decoder.h:72
DbcDecoder::Decode
DecodedFrameValue Decode(const DecodeDatabase &database, const RawCanFrame &frame) const
Decode one raw CAN frame.
Definition dbc_decoder.cpp:31
DbcDecoder::FindFrame
const DecodeFrame * FindFrame(const DecodeDatabase &database, std::uint32_t canId, bool isExtended) const
Find frame definition by CAN ID.
Definition dbc_decoder.cpp:14
DbcParser
Minimal DBC parser.
Definition dbc_parser.h:34
DbcParser::ParseFile
DbcDatabase ParseFile(const std::string &filePath) const
Parse DBC file.
Definition dbc_parser.cpp:19
DbcTreeBuilder
Builds a simple tree from parsed DBC database.
Definition dbc_tree_builder.h:23
DbcTreeBuilder::Build
std::unique_ptr< TreeNode > Build(const DbcDatabase &database) const
Build tree representation of parsed DBC data.
Definition dbc_tree_builder.cpp:14
TreeNode
Tree node for later use in model/view or other hierarchy consumers.
Definition tree_node.h:35
TreeNode::GetSignal
const SignalInfo * GetSignal() const
Get signal payload if node is signal.
Definition tree_node.cpp:64
TreeNode::GetChild
const TreeNode * GetChild(std::size_t index) const
Get child by index.
Definition tree_node.cpp:38
TreeNode::GetName
const std::string & GetName() const
Get display name.
Definition tree_node.cpp:56
TreeNode::GetChildCount
std::size_t GetChildCount() const
Get child count.
Definition tree_node.cpp:34
TreeNode::GetType
NodeType GetType() const
Get node type.
Definition tree_node.cpp:52
TreeNode::GetFrame
const FrameInfo * GetFrame() const
Get frame payload if node is frame.
Definition tree_node.cpp:60
TypeFactory
Registry-based factory for creating objects by runtime identifier.
Definition typefactory.h:59
TypeFactory::contains
bool contains(const ClassId &id) const
Checks whether an id is registered.
Definition typefactory.h:104
TypeFactory::create
BasePtr create(const ClassId &id, Args... args) const
Creates an instance for the given id using provided arguments.
Definition typefactory.h:97
TypeFactory::registerType
void registerType(const ClassId &id)
Registers a Derived type under the given id.
Definition typefactory.h:76
TypeFactory::creator
CreatorFn creator(const ClassId &id) const
Returns creator function for the given id.
Definition typefactory.h:89
dbc_decode_builder.h
Created: 2026-03-13 Author: Deeaitch (Dim. Himro)
dbc_decoder.h
Created: 2026-03-13 Author: Deeaitch (Dim. Himro)
dbc_parser.h
Created: 2026-03-13 Author: Deeaitch (Dim. Himro)
dbc_tree_builder.h
Created: 2026-03-13 Author: Deeaitch (Dim. Himro)
ByteOrder
ByteOrder
Signal byte order used for runtime decoding.
Definition decode_database.h:25
ValueType
ValueType
Signal numeric type.
Definition decode_database.h:33
DbcDatabase
Parsed DBC content stored in a simple internal form.
Definition dbc_database.h:22
DbcDatabase::frames
std::vector< FrameInfo > frames
Definition dbc_database.h:23
DecodeDatabase
Runtime decode database with fast lookup by CAN ID.
Definition decode_database.h:109
DecodeFrame
Runtime-ready frame definition.
Definition decode_database.h:63
DecodeFrame::pgn
std::uint32_t pgn
Definition decode_database.h:68
DecodeFrame::comment
std::string comment
Definition decode_database.h:71
DecodeFrame::dlc
std::uint8_t dlc
Definition decode_database.h:67
DecodeFrame::canId
std::uint32_t canId
Definition decode_database.h:65
DecodeFrame::name
std::string name
Definition decode_database.h:64
DecodeFrame::transmitter
std::string transmitter
Definition decode_database.h:70
DecodeSignal
Runtime-ready signal definition.
Definition decode_database.h:41
DecodeSignal::unit
std::string unit
Definition decode_database.h:52
DecodeSignal::name
std::string name
Definition decode_database.h:43
DecodeSignal::valueDescriptions
ValueDescriptions valueDescriptions
Definition decode_database.h:54
DecodeSignal::valueType
ValueType valueType
Definition decode_database.h:47
DecodeSignal::startBit
std::uint32_t startBit
Definition decode_database.h:44
DecodeSignal::receivers
std::vector< std::string > receivers
Definition decode_database.h:53
DecodeSignal::byteOrder
ByteOrder byteOrder
Definition decode_database.h:46
DecodeSignal::length
std::uint32_t length
Definition decode_database.h:45
DecodeSignal::comment
std::string comment
Definition decode_database.h:55
DecodedFrameValue
Fully decoded frame.
Definition dbc_decoder.h:61
DecodedFrameValue::definition
const DecodeFrame * definition
Definition dbc_decoder.h:62
FrameInfo
Describes one CAN frame from a DBC file.
Definition frame_info.h:24
FrameInfo::isExtended
bool isExtended
Definition frame_info.h:27
FrameInfo::hasPgn
bool hasPgn
Definition frame_info.h:29
FrameInfo::transmitter
std::string transmitter
Definition frame_info.h:31
FrameInfo::dlc
std::uint8_t dlc
Definition frame_info.h:30
FrameInfo::name
std::string name
Definition frame_info.h:25
FrameInfo::comment
std::string comment
Definition frame_info.h:32
FrameInfo::pgn
std::uint32_t pgn
Definition frame_info.h:28
FrameInfo::canId
std::uint32_t canId
Definition frame_info.h:26
FrameKey
Key for fast frame lookup.
Definition decode_database.h:80
RawCanFrame
Raw CAN frame used for runtime or trace decoding.
Definition dbc_decoder.h:24
RawCanFrame::data
std::vector< std::uint8_t > data
Definition dbc_decoder.h:27
RawCanFrame::canId
std::uint32_t canId
Definition dbc_decoder.h:25
RawCanFrame::isExtended
bool isExtended
Definition dbc_decoder.h:26
SignalInfo
Describes one signal inside a DBC frame.
Definition signal_info.h:24
SignalInfo::length
std::uint32_t length
Definition signal_info.h:28
SignalInfo::unit
std::string unit
Definition signal_info.h:35
SignalInfo::receivers
std::vector< std::string > receivers
Definition signal_info.h:36
SignalInfo::name
std::string name
Definition signal_info.h:26
SignalInfo::valueDescriptions
ValueDescriptions valueDescriptions
Definition signal_info.h:37
SignalInfo::isSigned
bool isSigned
Definition signal_info.h:30
SignalInfo::offset
double offset
Definition signal_info.h:32
SignalInfo::comment
std::string comment
Definition signal_info.h:38
SignalInfo::startBit
std::uint32_t startBit
Definition signal_info.h:27
SignalInfo::minimum
double minimum
Definition signal_info.h:33
SignalInfo::maximum
double maximum
Definition signal_info.h:34
SignalInfo::factor
double factor
Definition signal_info.h:31
SignalInfo::isLittleEndian
bool isLittleEndian
Definition signal_info.h:29