qt/qtserialbus/tests/auto/qcanframeprocessor/tst_qcanframeprocessor.cpp

Revision control

Copy as Markdown

// Copyright (C) 2022 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
#include <QtTest/qtest.h>
#include <QtCore/QtEndian>
#include <QtSerialBus/qcanbusframe.h>
#include <QtSerialBus/qcanframeprocessor.h>
#include <QtSerialBus/qcanmessagedescription.h>
#include <QtSerialBus/qcansignaldescription.h>
#include <QtSerialBus/private/qcanframeprocessor_p.h>
QT_USE_NAMESPACE
class tst_QCanFrameProcessor : public QObject
{
Q_OBJECT
private slots:
/* basics */
void construct();
/* parse */
void parseSignal_data();
void parseSignal();
void parseWithValueConversion_data();
void parseWithValueConversion();
void parseMultiplexedSignals_data();
void parseMultiplexedSignals();
void parseExtendedMultiplexedSignals_data();
void parseExtendedMultiplexedSignals();
void parseWithErrorsAndWarnings_data();
void parseWithErrorsAndWarnings();
void extractUniqueId_data();
void extractUniqueId();
/* generate */
void prepareFrame_data();
void prepareFrame();
void prepareWithValueConversion_data();
void prepareWithValueConversion();
void prepareMultiplexedPayload_data();
void prepareMultiplexedPayload();
void prepareWithErrorsAndWarnings_data();
void prepareWithErrorsAndWarnings();
void prepareUniqueId_data();
void prepareUniqueId();
/* roundtrip */
void roundtrip_data();
void roundtrip();
};
void tst_QCanFrameProcessor::construct()
{
QCanFrameProcessor p;
QVERIFY(p.messageDescriptions().isEmpty());
QCOMPARE(p.error(), QCanFrameProcessor::Error::None);
QVERIFY(p.errorString().isEmpty());
QVERIFY(p.warnings().isEmpty());
QVERIFY(!p.uniqueIdDescription().isValid());
}
void tst_QCanFrameProcessor::parseSignal_data()
{
QTest::addColumn<QtCanBus::DataSource>("source");
QTest::addColumn<quint64>("data");
QTest::addColumn<quint16>("startBit");
QTest::addColumn<quint16>("bitLength");
QTest::addColumn<QtCanBus::DataFormat>("format");
QTest::addColumn<QSysInfo::Endian>("endian");
QTest::addColumn<QVariant>("expectedValue");
struct SourceDesc {
QtCanBus::DataSource source;
const char name[8];
};
static constexpr SourceDesc sources[] = {
{QtCanBus::DataSource::FrameId, "FrameId"},
{QtCanBus::DataSource::Payload, "Payload"}
};
for (const auto &s : sources) {
// LE, 16 bit, start 0
QTest::addRow("%s, unsigned, 16bit, start 0, le", s.name)
<< s.source
<< quint64(0x1234FFEC) << quint16(0) << quint16(16)
<< QtCanBus::DataFormat::UnsignedInteger
<< QSysInfo::Endian::LittleEndian
<< QVariant(65516);
QTest::addRow("%s, signed neg, 16bit, start 0, le", s.name)
<< s.source
<< quint64(0x1234FFEC) << quint16(0) << quint16(16)
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::LittleEndian
<< QVariant(-20);
QTest::addRow("%s, signed pos, 16bit, start 0, le", s.name)
<< s.source
<< quint64(0x12340FEC) << quint16(0) << quint16(16)
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::LittleEndian
<< QVariant(4076);
// LE, 16 bit, start 5
QTest::addRow("%s, unsigned, 16bit, start 5, le", s.name)
<< s.source
<< quint64(0x1234FFECULL << 5)
<< quint16(5) << quint16(16)
<< QtCanBus::DataFormat::UnsignedInteger
<< QSysInfo::Endian::LittleEndian
<< QVariant(65516);
QTest::addRow("%s, signed neg, 16bit, start 5, le", s.name)
<< s.source
<< quint64((0x1234FFECULL << 5) & 0x1FFFFFFFU)
<< quint16(5) << quint16(16)
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::LittleEndian
<< QVariant(-20);
QTest::addRow("%s, signed pos, 16bit, start 5, le", s.name)
<< s.source
<< quint64(0x12340FECULL << 5)
<< quint16(5) << quint16(16)
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::LittleEndian
<< QVariant(4076);
// LE, 19 bit, start 0
QTest::addRow("%s, unsigned, 19bit, start 0, le", s.name)
<< s.source
<< quint64(0x1234FFEC) << quint16(0) << quint16(19)
<< QtCanBus::DataFormat::UnsignedInteger
<< QSysInfo::Endian::LittleEndian
<< QVariant(327660);
QTest::addRow("%s, signed neg, 19bit, start 0, le", s.name)
<< s.source
<< quint64(0x123D800A) << quint16(0) << quint16(19)
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::LittleEndian
<< QVariant(-163830);
QTest::addRow("%s, signed pos, 19bit, start 0, le", s.name)
<< s.source
<< quint64(0x1231800A) << quint16(0) << quint16(19)
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::LittleEndian
<< QVariant(98314);
// LE, 19 bit, start 3
QTest::addRow("%s, unsigned, 19bit, start 3, le", s.name)
<< s.source
<< quint64(0x1234FFECULL << 3)
<< quint16(3) << quint16(19)
<< QtCanBus::DataFormat::UnsignedInteger
<< QSysInfo::Endian::LittleEndian
<< QVariant(327660);
QTest::addRow("%s, signed neg, 19bit, start 3, le", s.name)
<< s.source
<< quint64(0x123D800AULL << 3)
<< quint16(3) << quint16(19)
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::LittleEndian
<< QVariant(-163830);
QTest::addRow("%s, signed pos, 19bit, start 3, le", s.name)
<< s.source
<< quint64(0x1231800AULL << 3)
<< quint16(3) << quint16(19)
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::LittleEndian
<< QVariant(98314);
// BE, 16 bit, start 7
QTest::addRow("%s, unsigned, 16bit, start 7, be", s.name)
<< s.source
<< quint64(0x1234ECFF) << quint16(7) << quint16(16)
<< QtCanBus::DataFormat::UnsignedInteger
<< QSysInfo::Endian::BigEndian
<< QVariant(65516);
QTest::addRow("%s, signed neg, 16bit, start 7, be", s.name)
<< s.source
<< quint64(0x1234ECFF) << quint16(7) << quint16(16)
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::BigEndian
<< QVariant(-20);
QTest::addRow("%s, signed pos, 16bit, start 7, be", s.name)
<< s.source
<< quint64(0x1234EC0F) << quint16(7) << quint16(16)
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::BigEndian
<< QVariant(4076);
// BE, 16 bit, start 5
QTest::addRow("%s, unsigned, 16bit, start 5, be", s.name)
<< s.source
<< quint64(0x1234FB3F) << quint16(5) << quint16(16)
<< QtCanBus::DataFormat::UnsignedInteger
<< QSysInfo::Endian::BigEndian
<< QVariant(65516);
QTest::addRow("%s, signed neg, 16bit, start 5, be", s.name)
<< s.source
<< quint64(0x1234FB3F) << quint16(5) << quint16(16)
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::BigEndian
<< QVariant(-20);
QTest::addRow("%s, signed pos, 16bit, start 5, be", s.name)
<< s.source
<< quint64(0x1234FB03) << quint16(5) << quint16(16)
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::BigEndian
<< QVariant(4076);
// BE, 21 bit, start 7
QTest::addRow("%s, unsigned, 21bit, start 7, be", s.name)
<< s.source
<< quint64(0x1264FFA7) << quint16(7) << quint16(21)
<< QtCanBus::DataFormat::UnsignedInteger
<< QSysInfo::Endian::BigEndian
<< QVariant(1376236);
QTest::addRow("%s, signed neg, 21bit, start 7, be", s.name)
<< s.source
<< quint64(0x1264FFA7) << quint16(7) << quint16(21)
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::BigEndian
<< QVariant(-720916);
QTest::addRow("%s, signed pos, 21bit, start 7, be", s.name)
<< s.source
<< quint64(0x1264FF27) << quint16(7) << quint16(21)
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::BigEndian
<< QVariant(327660);
// BE, 21 bit, start 4
QTest::addRow("%s, unsigned, 21bit, start 4, be", s.name)
<< s.source
<< quint64(0x12ECFF14) << quint16(4) << quint16(21)
<< QtCanBus::DataFormat::UnsignedInteger
<< QSysInfo::Endian::BigEndian
<< QVariant(1376236);
QTest::addRow("%s, signed neg, 21bit, start 4, be", s.name)
<< s.source
<< quint64(0x12ECFF14) << quint16(4) << quint16(21)
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::BigEndian
<< QVariant(-720916);
QTest::addRow("%s, signed pos, 21bit, start 4, be", s.name)
<< s.source
<< quint64(0x12ECFF04) << quint16(4) << quint16(21)
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::BigEndian
<< QVariant(327660);
// Some LE tests for values less than 8 bit
QTest::addRow("%s, unsinged, 4bit, start 0, le", s.name)
<< s.source
<< quint64(0x12345678) << quint16(0) << quint16(4)
<< QtCanBus::DataFormat::UnsignedInteger
<< QSysInfo::Endian::LittleEndian
<< QVariant(8);
QTest::addRow("%s, unsinged, 4bit, start 3, le", s.name)
<< s.source
<< quint64(0x12345678) << quint16(3) << quint16(4)
<< QtCanBus::DataFormat::UnsignedInteger
<< QSysInfo::Endian::LittleEndian
<< QVariant(15);
QTest::addRow("%s, unsinged, 4bit, start 7, le", s.name)
<< s.source
<< quint64(0x12345678) << quint16(7) << quint16(4)
<< QtCanBus::DataFormat::UnsignedInteger
<< QSysInfo::Endian::LittleEndian
<< QVariant(12);
// Some BE tests for values less than 8 bit
QTest::addRow("%s, unsinged, 4bit, start 7, be", s.name)
<< s.source
<< quint64(0x12345678) << quint16(7) << quint16(4)
<< QtCanBus::DataFormat::UnsignedInteger
<< QSysInfo::Endian::BigEndian
<< QVariant(7);
QTest::addRow("%s, unsinged, 4bit, start 5, be", s.name)
<< s.source
<< quint64(0x12345678) << quint16(5) << quint16(4)
<< QtCanBus::DataFormat::UnsignedInteger
<< QSysInfo::Endian::BigEndian
<< QVariant(14);
QTest::addRow("%s, unsinged, 4bit, start 0, be", s.name)
<< s.source
<< quint64(0x12345678) << quint16(0) << quint16(4)
<< QtCanBus::DataFormat::UnsignedInteger
<< QSysInfo::Endian::BigEndian
<< QVariant(2);
}
// float data - payload only
{
const float floatVal = 123.456f;
for (quint16 i = 0; i < 8; ++i) {
quint64 value = 0;
const float leFloatVal = qToLittleEndian(floatVal);
memcpy(&value, &leFloatVal, sizeof(float));
value = value << i;
QTest::addRow("Payload, float, le, start %d", i)
<< QtCanBus::DataSource::Payload
<< value << i << quint16(32)
<< QtCanBus::DataFormat::Float
<< QSysInfo::Endian::LittleEndian
<< QVariant(floatVal);
// to get the proper BE value with an offset, we need to take an LE
// value, shift it to the right, and then swap bytes
value = 0;
memcpy(&value, &leFloatVal, sizeof(float));
value = value << 16; // so that we have some room for right shift
// this means that default start bit is 23
value = value >> i;
value = qToBigEndian(value);
QTest::addRow("Payload, float, be, start %d", 23 - i)
<< QtCanBus::DataSource::Payload
<< value << quint16(23 - i) << quint16(32)
<< QtCanBus::DataFormat::Float
<< QSysInfo::Endian::BigEndian
<< QVariant(floatVal);
}
}
// double data - payload only
{
const double doubleVal = 1.234e-15;
const double leDoubleVal = qToLittleEndian(doubleVal);
quint64 value = 0;
memcpy(&value, &leDoubleVal, sizeof(leDoubleVal));
QTest::addRow("Payload, double, le")
<< QtCanBus::DataSource::Payload
<< value << quint16(0) << quint16(64)
<< QtCanBus::DataFormat::Double
<< QSysInfo::Endian::LittleEndian
<< QVariant(doubleVal);
const double beDoubleVal = qToBigEndian(doubleVal);
memcpy(&value, &beDoubleVal, sizeof(beDoubleVal));
QTest::addRow("Payload, double, be")
<< QtCanBus::DataSource::Payload
<< value << quint16(7) << quint16(64)
<< QtCanBus::DataFormat::Double
<< QSysInfo::Endian::BigEndian
<< QVariant(doubleVal);
}
// ASCII
for (const auto &s : sources) {
const bool isPayload = s.source == QtCanBus::DataSource::Payload;
const QByteArray expectedData = isPayload ? QByteArray("abc", 3) : QByteArray("ab", 2);
const quint16 offset = isPayload ? 8 : 4;
for (quint16 i = 0; i < 8; ++i) {
quint64 value = 0;
memcpy(&value, expectedData.constData(), expectedData.size());
value = value << (offset + i);
QTest::addRow("%s, ascii, offset %d", s.name, offset + i)
<< s.source
<< value << quint16(offset + i) << quint16(expectedData.size() * 8)
<< QtCanBus::DataFormat::AsciiString
<< QSysInfo::Endian::LittleEndian
<< QVariant(expectedData);
}
}
}
void tst_QCanFrameProcessor::parseSignal()
{
QFETCH(QtCanBus::DataSource, source);
QFETCH(quint64, data);
QFETCH(quint16, startBit);
QFETCH(quint16, bitLength);
QFETCH(QtCanBus::DataFormat, format);
QFETCH(QSysInfo::Endian, endian);
QFETCH(QVariant, expectedValue);
QCanSignalDescription sig;
sig.setName("test_signal");
sig.setDataSource(source);
sig.setDataFormat(format);
sig.setDataEndian(endian);
sig.setStartBit(startBit);
sig.setBitLength(bitLength);
QVERIFY(sig.isValid());
const bool sourceIsPayload = source == QtCanBus::DataSource::Payload;
// The unique id will be extracted from the 0-th payload byte
const auto uidSource = sourceIsPayload ? QtCanBus::DataSource::FrameId
: QtCanBus::DataSource::Payload;
QCanUniqueIdDescription uidDesc;
uidDesc.setSource(uidSource);
uidDesc.setStartBit(0);
uidDesc.setBitLength(4);
const QtCanBus::UniqueId expectedUid{0x0A};
const auto messageSize = sourceIsPayload ? sizeof(data) : 1;
QCanMessageDescription message;
message.setName("test_message");
message.setUniqueId(expectedUid);
message.setSize(messageSize);
message.addSignalDescription(sig);
QVERIFY(message.isValid());
QCanFrameProcessor parser;
parser.setUniqueIdDescription(uidDesc);
parser.addMessageDescriptions({ message });
QCanBusFrame frame;
if (sourceIsPayload) {
frame.setFrameId(static_cast<QCanBusFrame::FrameId>(expectedUid));
const QByteArray payload(reinterpret_cast<const char *>(&data), sizeof(data));
frame.setPayload(payload);
} else {
frame.setFrameId(data & 0x1FFFFFFFU);
frame.setPayload(QByteArray(1, 0x0A));
}
QVERIFY(frame.isValid());
const auto result = parser.parseFrame(frame);
const auto signalValues = result.signalValues;
QCOMPARE(result.uniqueId, expectedUid);
QVERIFY(!signalValues.isEmpty());
const QVariantMap expectedSignalValues({qMakePair(sig.name(), expectedValue)});
// The values can be doubles, so we need to compare them explicitly
QCOMPARE(signalValues.keys(), expectedSignalValues.keys());
for (const auto &key : expectedSignalValues.keys()) {
const auto expectedValue = expectedSignalValues.value(key);
if (expectedValue.canConvert(QMetaType::fromType<double>()))
QCOMPARE(signalValues.value(key).toDouble(), expectedValue.toDouble());
else
QCOMPARE(signalValues.value(key), expectedValue);
}
}
void tst_QCanFrameProcessor::parseWithValueConversion_data()
{
QTest::addColumn<double>("factor");
QTest::addColumn<double>("offset");
QTest::addColumn<double>("scaling");
QTest::addColumn<quint8>("payloadValue");
QTest::addColumn<QVariant>("expectedValue");
// expectedValue = scaling * (payloadValue * factor + offset);
QTest::newRow("nan, nan, nan") << qQNaN() << qQNaN() << qQNaN() << quint8(30) << QVariant(30);
QTest::newRow("0.75, nan, nan") << 0.75 << qQNaN() << qQNaN() << quint8(30) << QVariant(22.5);
QTest::newRow("0.75, 15.3, nan") << 0.75 << 15.3 << qQNaN() << quint8(30) << QVariant(37.8);
QTest::newRow("0.75, 15.3, 100") << 0.75 << 15.3 << 100. << quint8(30) << QVariant(3780.);
QTest::newRow("0.75, nan, 100") << 0.75 << qQNaN() << 100. << quint8(30) << QVariant(2250.);
QTest::newRow("nan, 15.3, 100") << qQNaN() << 15.3 << 100. << quint8(30) << QVariant(4530.);
// check that setting factor and/or scaling to 0 is equivalent to NaN
QTest::newRow("0, 15.3, 100") << 0. << 15.3 << 100. << quint8(30) << QVariant(4530.);
QTest::newRow("0, 15.3, 0") << 0. << 15.3 << 0. << quint8(30) << QVariant(45.3);
}
void tst_QCanFrameProcessor::parseWithValueConversion()
{
QFETCH(double, factor);
QFETCH(double, offset);
QFETCH(double, scaling);
QFETCH(quint8, payloadValue);
QFETCH(QVariant, expectedValue);
QCanSignalDescription sig;
sig.setName("test_signal");
sig.setStartBit(7);
sig.setBitLength(8);
sig.setFactor(factor);
sig.setOffset(offset);
sig.setScaling(scaling);
const QtCanBus::UniqueId uniqueId{123};
QCanMessageDescription message;
message.setName("test_message");
message.setUniqueId(uniqueId);
message.setSize(1);
message.addSignalDescription(sig);
QVERIFY(message.isValid());
// Assume that our uniqueId is the whole FrameId
QCanUniqueIdDescription uidDesc;
uidDesc.setBitLength(29);
QCanFrameProcessor parser;
parser.setUniqueIdDescription(uidDesc);
parser.addMessageDescriptions({ message });
QCanBusFrame frame(static_cast<QCanBusFrame::FrameId>(uniqueId),
QByteArray(1, char(payloadValue)));
QVERIFY(frame.isValid());
const auto result = parser.parseFrame(frame);
const auto signalValues = result.signalValues;
QCOMPARE(result.uniqueId, uniqueId);
QVERIFY(!signalValues.isEmpty());
const QVariantMap expectedSignalValues({qMakePair(sig.name(), expectedValue)});
// The values can be doubles, so we need to compare them explicitly
QCOMPARE(signalValues.keys(), expectedSignalValues.keys());
for (const auto &key : expectedSignalValues.keys()) {
const auto expectedValue = expectedSignalValues.value(key);
if (expectedValue.canConvert(QMetaType::fromType<double>()))
QCOMPARE(signalValues.value(key).toDouble(), expectedValue.toDouble());
else
QCOMPARE(signalValues.value(key), expectedValue);
}
}
void tst_QCanFrameProcessor::parseMultiplexedSignals_data()
{
QTest::addColumn<QString>("s0Name");
QTest::addColumn<QString>("s1Name");
QTest::addColumn<QString>("s2Name");
QTest::addColumn<QVariant>("s1MuxValue");
QTest::addColumn<QVariant>("s2MuxValue");
QTest::addColumn<QByteArray>("payload");
QTest::addColumn<QVariantMap>("expectedResult");
const QString s0("s0");
const QString s1("s1");
const QString s2("s2");
const QVariant s1MuxValue(1);
const QVariant s2MuxValue(2);
QTest::newRow("s0 and s1") << s0 << s1 << s2 << s1MuxValue << s2MuxValue
<< QByteArray(1, 0x29)
<< QVariantMap({ qMakePair(s0, s1MuxValue), qMakePair(s1, 0x0A) });
QTest::newRow("s0 and s2") << s0 << s1 << s2 << s1MuxValue << s2MuxValue
<< QByteArray(1, 0x2E)
<< QVariantMap({ qMakePair(s0, s2MuxValue), qMakePair(s2, 0x0B) });
QTest::newRow("only s0") << s0 << s1 << s2 << s1MuxValue << s2MuxValue
<< QByteArray(1, 0x73)
<< QVariantMap({ qMakePair(s0, 0x03) });
}
void tst_QCanFrameProcessor::parseMultiplexedSignals()
{
QFETCH(QString, s0Name);
QFETCH(QString, s1Name);
QFETCH(QString, s2Name);
QFETCH(QVariant, s1MuxValue);
QFETCH(QVariant, s2MuxValue);
QFETCH(QByteArray, payload);
QFETCH(QVariantMap, expectedResult);
QCanSignalDescription s0; // multiplexor
s0.setName(s0Name);
s0.setStartBit(1);
s0.setBitLength(2);
s0.setDataFormat(QtCanBus::DataFormat::UnsignedInteger);
s0.setMultiplexState(QtCanBus::MultiplexState::MultiplexorSwitch);
QCanSignalDescription s1; // multiplexed signal 1, used when s0 == 1
s1.setName(s1Name);
s1.setStartBit(7);
s1.setBitLength(6);
s1.setMultiplexState(QtCanBus::MultiplexState::MultiplexedSignal);
s1.addMultiplexSignal(s0.name(), s1MuxValue);
QCanSignalDescription s2; // multiplexed signal 2, used when s0 == 2
s2.setName(s2Name);
s2.setStartBit(7);
s2.setBitLength(6);
s2.setMultiplexState(QtCanBus::MultiplexState::MultiplexedSignal);
s2.addMultiplexSignal(s0.name(), s2MuxValue);
const QtCanBus::UniqueId uniqueId{123};
QCanMessageDescription msg;
msg.setName("test");
msg.setUniqueId(uniqueId);
msg.setSize(payload.size());
msg.setSignalDescriptions({ s0, s1, s2 });
// Assume that our uniqueId is the whole FrameId
QCanUniqueIdDescription uidDesc;
uidDesc.setBitLength(29);
QCanFrameProcessor parser;
parser.setUniqueIdDescription(uidDesc);
parser.addMessageDescriptions({ msg });
QCanBusFrame frame(static_cast<QCanBusFrame::FrameId>(msg.uniqueId()), payload);
QVERIFY(frame.isValid());
const auto result = parser.parseFrame(frame);
QCOMPARE(result.uniqueId, uniqueId);
QCOMPARE(result.signalValues, expectedResult);
}
void tst_QCanFrameProcessor::parseExtendedMultiplexedSignals_data()
{
QTest::addColumn<QByteArray>("payload");
QTest::addColumn<QVariantMap>("expectedResult");
const QString s0Name("s0");
const QString s1Name("s1");
const QString s2Name("s2");
const QString s3Name("s3");
const QString s4Name("s4");
QTest::newRow("s0 and s2") << QByteArray::fromHex("2434")
<< QVariantMap({ qMakePair(s0Name, 4),
qMakePair(s2Name, 0x342) });
QTest::newRow("s0, s1 and s3") << QByteArray::fromHex("1134")
<< QVariantMap({ qMakePair(s0Name, 1),
qMakePair(s1Name, 1),
qMakePair(s3Name, 0x34) });
QTest::newRow("s0, s1 and s4") << QByteArray::fromHex("2134")
<< QVariantMap({ qMakePair(s0Name, 1),
qMakePair(s1Name, 2),
qMakePair(s4Name, 0x34) });
QTest::newRow("s0 and s1") << QByteArray::fromHex("7134")
<< QVariantMap({ qMakePair(s0Name, 1),
qMakePair(s1Name, 7) });
QTest::newRow("only s0") << QByteArray::fromHex("2534")
<< QVariantMap({ qMakePair(s0Name, 5) });
}
void tst_QCanFrameProcessor::parseExtendedMultiplexedSignals()
{
QFETCH(QByteArray, payload);
QFETCH(QVariantMap, expectedResult);
QCanSignalDescription s0; // multiplexor 1
s0.setName("s0");
s0.setDataEndian(QSysInfo::Endian::LittleEndian);
s0.setStartBit(0);
s0.setBitLength(4);
s0.setMultiplexState(QtCanBus::MultiplexState::MultiplexorSwitch);
QCanSignalDescription s1; // multiplexor 2, also depends on the value of s0
s1.setName("s1");
s1.setDataEndian(QSysInfo::Endian::LittleEndian);
s1.setStartBit(4);
s1.setBitLength(4);
s1.setMultiplexState(QtCanBus::MultiplexState::SwitchAndSignal);
s1.addMultiplexSignal(s0.name(), 1);
QCanSignalDescription s2; // depends on mux1 only, contains 12 bits of data
s2.setName("s2");
s2.setDataEndian(QSysInfo::Endian::LittleEndian);
s2.setStartBit(4);
s2.setBitLength(12);
s2.setMultiplexState(QtCanBus::MultiplexState::MultiplexedSignal);
const QCanSignalDescription::MultiplexValues muxValuesS0 { {2, 4} };
s2.addMultiplexSignal(s0.name(), muxValuesS0);
QCanSignalDescription s3; // depends on mux2 (so indirectly on mux1)
s3.setName("s3");
s3.setDataEndian(QSysInfo::Endian::LittleEndian);
s3.setStartBit(8);
s3.setBitLength(8);
s3.setMultiplexState(QtCanBus::MultiplexState::MultiplexedSignal);
s3.addMultiplexSignal(s1.name(), 1);
QCanSignalDescription s4; // depends on mux2 (so indirectly on mux1)
s4.setName("s4");
s4.setDataEndian(QSysInfo::Endian::LittleEndian);
s4.setStartBit(8);
s4.setBitLength(8);
s4.setMultiplexState(QtCanBus::MultiplexState::MultiplexedSignal);
const QCanSignalDescription::MultiplexValues muxValuesS1 { {2, 3}, {5, 5} };
s4.addMultiplexSignal(s1.name(), muxValuesS1);
const QtCanBus::UniqueId uniqueId{123};
QCanMessageDescription msg;
msg.setName("test");
msg.setUniqueId(uniqueId);
msg.setSize(payload.size());
msg.setSignalDescriptions({ s0, s1, s2, s3, s4 });
// Assume that our uniqueId is the whole FrameId
QCanUniqueIdDescription uidDesc;
uidDesc.setBitLength(29);
QCanFrameProcessor parser;
parser.setUniqueIdDescription(uidDesc);
parser.addMessageDescriptions({ msg });
QCanBusFrame frame(static_cast<QCanBusFrame::FrameId>(msg.uniqueId()), payload);
QVERIFY(frame.isValid());
const auto result = parser.parseFrame(frame);
QCOMPARE(result.uniqueId, uniqueId);
QCOMPARE(result.signalValues, expectedResult);
}
void tst_QCanFrameProcessor::parseWithErrorsAndWarnings_data()
{
QTest::addColumn<QCanMessageDescription>("messageDescription");
QTest::addColumn<QCanUniqueIdDescription>("uniqueIdDescription");
QTest::addColumn<QCanBusFrame>("frame");
QTest::addColumn<QCanFrameProcessor::Error>("expectedError");
QTest::addColumn<QString>("expectedErrorDescription");
QTest::addColumn<QStringList>("expectedWarnings");
QTest::addColumn<QtCanBus::UniqueId>("expectedUniqueId");
QTest::addColumn<QVariantMap>("expectedResult");
QTest::addRow("Invalid frame") << QCanMessageDescription()
<< QCanUniqueIdDescription()
<< QCanBusFrame(0x2345ABCD, QByteArray())
<< QCanFrameProcessor::Error::InvalidFrame
<< tr("Invalid frame.")
<< QStringList()
<< QtCanBus::UniqueId(0)
<< QVariantMap();
QTest::addRow("Unsupported frame") << QCanMessageDescription()
<< QCanUniqueIdDescription()
<< QCanBusFrame(QCanBusFrame::RemoteRequestFrame)
<< QCanFrameProcessor::Error::UnsupportedFrameFormat
<< tr("Unsupported frame format.")
<< QStringList()
<< QtCanBus::UniqueId(0)
<< QVariantMap();
QTest::addRow("No UID description")
<< QCanMessageDescription() << QCanUniqueIdDescription()
<< QCanBusFrame(123, QByteArray(2, 0x01))
<< QCanFrameProcessor::Error::Decoding
<< tr("No valid unique identifier description is specified.")
<< QStringList() << QtCanBus::UniqueId(0) << QVariantMap();
QCanUniqueIdDescription uidDesc;
uidDesc.setSource(QtCanBus::DataSource::Payload);
uidDesc.setStartBit(8);
uidDesc.setBitLength(16); // for extended FrameId
QTest::addRow("UID extraction failed")
<< QCanMessageDescription() << uidDesc
<< QCanBusFrame(123, QByteArray(2, 0x01))
<< QCanFrameProcessor::Error::Decoding
<< tr("Failed to extract unique id from the frame.")
<< QStringList() << QtCanBus::UniqueId(0) << QVariantMap();
uidDesc = QCanUniqueIdDescription(); // reset
uidDesc.setBitLength(29);
QTest::addRow("Unknown unique id")
<< QCanMessageDescription() << uidDesc
<< QCanBusFrame(123, QByteArray(8, 0x01))
<< QCanFrameProcessor::Error::Decoding
<< tr("Could not find a message description for unique id 123.")
<< QStringList() << QtCanBus::UniqueId(0) << QVariantMap();
QCanSignalDescription signalDesc;
signalDesc.setName("s0");
signalDesc.setStartBit(7);
signalDesc.setBitLength(16);
QCanMessageDescription messageDesc;
messageDesc.setName("testMessage");
messageDesc.setUniqueId(QtCanBus::UniqueId{123});
messageDesc.setSize(2);
messageDesc.addSignalDescription(signalDesc);
QTest::addRow("Invalid payload size")
<< messageDesc << uidDesc
<< QCanBusFrame(123, QByteArray(8, 0x01))
<< QCanFrameProcessor::Error::Decoding
<< tr("Payload size does not match message description. "
"Actual size = 8, expected size = 2.")
<< QStringList()
<< QtCanBus::UniqueId(0)
<< QVariantMap();
// format float, but length != 32
QCanSignalDescription invalidSignalDesc;
invalidSignalDesc.setName("invalidSignal");
invalidSignalDesc.setStartBit(23);
invalidSignalDesc.setBitLength(8);
invalidSignalDesc.setDataFormat(QtCanBus::DataFormat::Float);
messageDesc.setSize(8);
messageDesc.addSignalDescription(invalidSignalDesc);
QStringList expectedWarnings = { tr("Skipping signal invalidSignal in message with "
"unique id 123 because its description is invalid.") };
// Invalid signal skipped, and we still get results from other signals
QTest::addRow("invalid signal desc warning")
<< messageDesc << uidDesc << QCanBusFrame(123, QByteArray(8, 0x01))
<< QCanFrameProcessor::Error::None << QString()
<< expectedWarnings << QtCanBus::UniqueId(123)
<< QVariantMap({ qMakePair("s0", 0x0101) });
// other valid signal
signalDesc.setName("s1");
signalDesc.setStartBit(39);
signalDesc.setBitLength(8);
messageDesc.addSignalDescription(signalDesc);
// valid signal, but length exceeds frame length
signalDesc.setName("tooLong");
signalDesc.setStartBit(47);
signalDesc.setBitLength(32);
messageDesc.addSignalDescription(signalDesc);
expectedWarnings.push_back(tr("Skipping signal tooLong in message with unique id 123. "
"Its expected length exceeds the data length."));
// Two invalid signals skipped, two valid results are received
QTest::addRow("invalid signal desc warning")
<< messageDesc << uidDesc << QCanBusFrame(123, QByteArray(8, 0x01))
<< QCanFrameProcessor::Error::None << QString()
<< expectedWarnings << QtCanBus::UniqueId(123)
<< QVariantMap({ qMakePair("s0", 0x0101), qMakePair("s1", 0x01) });
// Signals whose end-of-signal bit position exceeds 65535 must be skipped:
// that position must not truncate to a small value that passes the bounds
// check while the untruncated start bit drives the memory access.
// The end bit position calculation depends on endianness, so
// both endians are covered.
QCanMessageDescription truncationMsg;
truncationMsg.setName("truncationMessage");
truncationMsg.setUniqueId(QtCanBus::UniqueId{123});
truncationMsg.setSize(8);
QCanSignalDescription oobLittleEndian;
oobLittleEndian.setName("oobLittleEndian");
oobLittleEndian.setDataEndian(QSysInfo::Endian::LittleEndian);
oobLittleEndian.setDataFormat(QtCanBus::DataFormat::UnsignedInteger);
oobLittleEndian.setStartBit(65480); // 65480 + 64 - 1 = 65543, truncates to 7
oobLittleEndian.setBitLength(64);
truncationMsg.addSignalDescription(oobLittleEndian);
QCanSignalDescription oobBigEndian;
oobBigEndian.setName("oobBigEndian");
oobBigEndian.setDataEndian(QSysInfo::Endian::BigEndian);
oobBigEndian.setDataFormat(QtCanBus::DataFormat::UnsignedInteger);
oobBigEndian.setStartBit(65535); // last byte 8199 -> bit 65591, truncates to 55
oobBigEndian.setBitLength(64);
truncationMsg.addSignalDescription(oobBigEndian);
const QStringList truncationWarnings = {
tr("Skipping signal oobLittleEndian in message with unique id 123. "
"Its expected length exceeds the data length."),
tr("Skipping signal oobBigEndian in message with unique id 123. "
"Its expected length exceeds the data length.")
};
QTest::addRow("signal offset exceeds quint16")
<< truncationMsg << uidDesc << QCanBusFrame(123, QByteArray(8, 0x41))
<< QCanFrameProcessor::Error::None << QString()
<< truncationWarnings << QtCanBus::UniqueId(123)
<< QVariantMap();
}
void tst_QCanFrameProcessor::parseWithErrorsAndWarnings()
{
QFETCH(QCanMessageDescription, messageDescription);
QFETCH(QCanUniqueIdDescription, uniqueIdDescription);
QFETCH(QCanBusFrame, frame);
QFETCH(QCanFrameProcessor::Error, expectedError);
QFETCH(QString, expectedErrorDescription);
QFETCH(QStringList, expectedWarnings);
QFETCH(QtCanBus::UniqueId, expectedUniqueId);
QFETCH(QVariantMap, expectedResult);
QCanFrameProcessor parser;
parser.setUniqueIdDescription(uniqueIdDescription);
parser.addMessageDescriptions({ messageDescription });
const auto result = parser.parseFrame(frame);
QCOMPARE(parser.error(), expectedError);
QCOMPARE(parser.errorString(), expectedErrorDescription);
// signal descriptions are stored as a QHash internally, so they are
// processed in a hash-dependent order. Because of that the order of
// warnings cannot be defined. So we sort them alphabetically before
// comparing.
std::sort(expectedWarnings.begin(), expectedWarnings.end());
QStringList warnings = parser.warnings();
std::sort(warnings.begin(), warnings.end());
QCOMPARE(warnings, expectedWarnings);
QCOMPARE(result.uniqueId, expectedUniqueId);
// The values can be doubles, so we need to compare them explicitly
const auto signalValues = result.signalValues;
QCOMPARE(signalValues.keys(), expectedResult.keys());
for (auto it = expectedResult.cbegin(); it != expectedResult.cend(); ++it) {
const auto &expectedValue = it.value();
const auto &key = it.key();
if (expectedValue.canConvert(QMetaType::fromType<double>()))
QCOMPARE(signalValues.value(key).toDouble(), expectedValue.toDouble());
else
QCOMPARE(signalValues.value(key), expectedValue);
}
}
void tst_QCanFrameProcessor::extractUniqueId_data()
{
QTest::addColumn<QCanUniqueIdDescription>("uniqueIdDescription");
QTest::addColumn<QCanBusFrame>("frame");
QTest::addColumn<QtCanBus::UniqueId>("expectedUniqueId");
// unique id in frame id
QCanUniqueIdDescription uidDesc;
uidDesc.setSource(QtCanBus::DataSource::FrameId);
uidDesc.setBitLength(12);
const quint32 uniqueId = 0x0965;
for (quint16 startBit = 0; startBit < 8; ++startBit) {
uidDesc.setStartBit(startBit);
uidDesc.setEndian(QSysInfo::Endian::LittleEndian);
const QCanBusFrame::FrameId frameIdLe = qToLittleEndian(uniqueId) << startBit;
QTest::addRow("frameId, LE, start %d", startBit)
<< uidDesc
<< QCanBusFrame(frameIdLe, QByteArray(1, 0x01))
<< QtCanBus::UniqueId{uniqueId};
}
static constexpr quint16 startBitsFrame[] = { 3, 2, 1, 0, 15, 14, 13, 12 };
static constexpr qsizetype startBitsFrameLen =
sizeof(startBitsFrame)/sizeof(startBitsFrame[0]);
for (qsizetype idx = 0; idx < startBitsFrameLen; ++idx) {
const auto val = (qToLittleEndian(uniqueId) << 16) >> idx;
const auto startBit = startBitsFrame[idx];
const QCanBusFrame::FrameId frameIdBe = qToBigEndian(val);
uidDesc.setEndian(QSysInfo::Endian::BigEndian);
uidDesc.setStartBit(startBit);
QTest::addRow("frameId, BE, start %d", startBit)
<< uidDesc
<< QCanBusFrame(frameIdBe, QByteArray(1, 0x01))
<< QtCanBus::UniqueId{uniqueId};
}
// unique id in payload, the 1st byte of the payload is used for signal,
// so we start from the 2nd byte
uidDesc.setSource(QtCanBus::DataSource::Payload);
for (quint16 startBit = 8; startBit < 16; ++startBit) {
uidDesc.setStartBit(startBit);
uidDesc.setEndian(QSysInfo::Endian::LittleEndian);
const quint32 payload = 0x01 | (qToLittleEndian(uniqueId) << startBit);
const QByteArray payloadData(reinterpret_cast<const char *>(&payload), sizeof(payload));
QTest::addRow("payload, LE, offset %d", startBit)
<< uidDesc
<< QCanBusFrame(0, payloadData)
<< QtCanBus::UniqueId{uniqueId};
}
static constexpr quint16 startBitsPayload[] = { 11, 10, 9, 8, 23, 22, 21, 20 };
static constexpr qsizetype startBitsPayloadLen =
sizeof(startBitsPayload)/sizeof(startBitsPayload[0]);
for (qsizetype idx = 0; idx < startBitsPayloadLen; ++idx) {
const auto startBit = startBitsPayload[idx];
const auto val = (qToLittleEndian(uniqueId) << 8) >> idx;
quint32 payload = 0x01 | qToBigEndian(val);
const QByteArray payloadData(reinterpret_cast<const char *>(&payload), sizeof(payload));
uidDesc.setEndian(QSysInfo::Endian::BigEndian);
uidDesc.setStartBit(startBit);
QTest::addRow("payload, BE, offset %d", startBit)
<< uidDesc
<< QCanBusFrame(0, payloadData)
<< QtCanBus::UniqueId{uniqueId};
}
}
void tst_QCanFrameProcessor::extractUniqueId()
{
QFETCH(QCanUniqueIdDescription, uniqueIdDescription);
QFETCH(QCanBusFrame, frame);
QFETCH(QtCanBus::UniqueId, expectedUniqueId);
// Some valid message description.
QCanSignalDescription signalDesc;
signalDesc.setName("s0");
signalDesc.setStartBit(7);
signalDesc.setBitLength(8);
QCanMessageDescription messageDesc;
messageDesc.setName("test");
messageDesc.setUniqueId(expectedUniqueId);
messageDesc.setSize(frame.payload().size());
messageDesc.addSignalDescription(signalDesc);
QCanFrameProcessor processor;
processor.setUniqueIdDescription(uniqueIdDescription);
processor.setMessageDescriptions({ messageDesc });
auto result = processor.parseFrame(frame);
QCOMPARE(result.uniqueId, expectedUniqueId);
}
void tst_QCanFrameProcessor::prepareFrame_data()
{
QTest::addColumn<quint16>("startBit");
QTest::addColumn<quint16>("bitLength");
QTest::addColumn<QtCanBus::DataSource>("source");
QTest::addColumn<QtCanBus::DataFormat>("format");
QTest::addColumn<QSysInfo::Endian>("endian");
QTest::addColumn<QVariant>("signalValue");
QTest::addColumn<quint64>("expectedData");
struct SourceDesc {
QtCanBus::DataSource source;
const char name[8];
};
static constexpr SourceDesc sources[] = {
{QtCanBus::DataSource::FrameId, "FrameId"},
{QtCanBus::DataSource::Payload, "Payload"}
};
for (const auto &s : sources) {
// LE, 16bit, start 0
QTest::addRow("%s, unsigned, 16bit, start 0, le", s.name)
<< quint16(0) << quint16(16) << s.source
<< QtCanBus::DataFormat::UnsignedInteger
<< QSysInfo::Endian::LittleEndian
<< QVariant(65516)
<< quint64(0xFFEC);
QTest::addRow("%s, signed neg, 16bit, start 0, le", s.name)
<< quint16(0) << quint16(16) << s.source
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::LittleEndian
<< QVariant(-20)
<< quint64(0xFFEC);
QTest::addRow("%s, signed pos, 16bit, start 0, le", s.name)
<< quint16(0) << quint16(16) << s.source
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::LittleEndian
<< QVariant(32748)
<< quint64(0x7FEC);
// LE, 16bit, start 5
QTest::addRow("%s, unsigned, 16bit, start 5, le", s.name)
<< quint16(5) << quint16(16) << s.source
<< QtCanBus::DataFormat::UnsignedInteger
<< QSysInfo::Endian::LittleEndian
<< QVariant(65516)
<< quint64(0xFFECULL << 5);
QTest::addRow("%s, signed neg, 16bit, start 5, le", s.name)
<< quint16(5) << quint16(16) << s.source
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::LittleEndian
<< QVariant(-20)
<< quint64(0xFFECULL << 5);
QTest::addRow("%s, signed pos, 16bit, start 5, le", s.name)
<< quint16(5) << quint16(16) << s.source
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::LittleEndian
<< QVariant(32748)
<< quint64(0x7FECULL << 5);
// LE, 19bit, start 0
QTest::addRow("%s, unsigned, 19bit, start 0, le", s.name)
<< quint16(0) << quint16(19) << s.source
<< QtCanBus::DataFormat::UnsignedInteger
<< QSysInfo::Endian::LittleEndian
<< QVariant(327660)
<< quint64(0x4FFEC);
QTest::addRow("%s, signed neg, 19bit, start 0, le", s.name)
<< quint16(0) << quint16(19) << s.source
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::LittleEndian
<< QVariant(-196628)
<< quint64(0x4FFEC);
QTest::addRow("%s, signed pos, 19bit, start 0, le", s.name)
<< quint16(0) << quint16(19) << s.source
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::LittleEndian
<< QVariant(196588)
<< quint64(0x2FFEC);
// LE, 19bit, start 3
QTest::addRow("%s, unsigned, 19bit, start 3, le", s.name)
<< quint16(3) << quint16(19) << s.source
<< QtCanBus::DataFormat::UnsignedInteger
<< QSysInfo::Endian::LittleEndian
<< QVariant(327660)
<< quint64(0x4FFECULL << 3);
QTest::addRow("%s, signed neg, 19bit, start 3, le", s.name)
<< quint16(3) << quint16(19) << s.source
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::LittleEndian
<< QVariant(-196628)
<< quint64(0x4FFECULL << 3);
QTest::addRow("%s, signed pos, 19bit, start 3, le", s.name)
<< quint16(3) << quint16(19) << s.source
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::LittleEndian
<< QVariant(196588)
<< quint64(0x2FFECULL << 3);
// BE, 16bit, start 7
QTest::addRow("%s, unsigned, 16bit, start 7, be", s.name)
<< quint16(7) << quint16(16) << s.source
<< QtCanBus::DataFormat::UnsignedInteger
<< QSysInfo::Endian::BigEndian
<< QVariant(65516)
<< quint64(0xECFF);
QTest::addRow("%s, signed neg, 16bit, start 7, be", s.name)
<< quint16(7) << quint16(16) << s.source
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::BigEndian
<< QVariant(-20)
<< quint64(0xECFF);
QTest::addRow("%s, signed pos, 16bit, start 7, be", s.name)
<< quint16(7) << quint16(16) << s.source
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::BigEndian
<< QVariant(32748)
<< quint64(0xEC7F);
// BE, 16bit, start 5
QTest::addRow("%s, unsigned, 16bit, start 5, be", s.name)
<< quint16(5) << quint16(16) << s.source
<< QtCanBus::DataFormat::UnsignedInteger
<< QSysInfo::Endian::BigEndian
<< QVariant(65516)
<< quint64(0x00FB3F);
QTest::addRow("%s, signed neg, 16bit, start 5, be", s.name)
<< quint16(5) << quint16(16) << s.source
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::BigEndian
<< QVariant(-20)
<< quint64(0x00FB3F);
QTest::addRow("%s, signed pos, 16bit, start 5, be", s.name)
<< quint16(5) << quint16(16) << s.source
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::BigEndian
<< QVariant(32748)
<< quint64(0x00FB1F);
// BE, 21bit, start 7
QTest::addRow("%s, unsigned, 21bit, start 7, be", s.name)
<< quint16(7) << quint16(21) << s.source
<< QtCanBus::DataFormat::UnsignedInteger
<< QSysInfo::Endian::BigEndian
<< QVariant(1834988) /* 0x1BFFEC */
<< quint64(0x60FFDF);
QTest::addRow("%s, signed neg, 21bit, start 7, be", s.name)
<< quint16(7) << quint16(21) << s.source
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::BigEndian
<< QVariant(-262164)
<< quint64(0x60FFDF);
QTest::addRow("%s, signed pos, 21bit, start 7, be", s.name)
<< quint16(7) << quint16(21) << s.source
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::BigEndian
<< QVariant(786412)
<< quint64(0x60FF5F);
// BE, 21bit, start 4
QTest::addRow("%s, unsigned, 21bit, start 4, be", s.name)
<< quint16(4) << quint16(21) << s.source
<< QtCanBus::DataFormat::UnsignedInteger
<< QSysInfo::Endian::BigEndian
<< QVariant(1834988) /* 0x1BFFEC */
<< quint64(0xECFF1B);
QTest::addRow("%s, signed neg, 21bit, start 4, be", s.name)
<< quint16(4) << quint16(21) << s.source
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::BigEndian
<< QVariant(-262164)
<< quint64(0xECFF1B);
QTest::addRow("%s, signed pos, 21bit, start 4, be", s.name)
<< quint16(4) << quint16(21) << s.source
<< QtCanBus::DataFormat::SignedInteger
<< QSysInfo::Endian::BigEndian
<< QVariant(786412)
<< quint64(0xECFF0B);
// Some LE tests for values less than 8 bit
QTest::addRow("%s, unsinged, 4bit, start 0, le", s.name)
<< quint16(0) << quint16(4) << s.source
<< QtCanBus::DataFormat::UnsignedInteger
<< QSysInfo::Endian::LittleEndian
<< QVariant(8)
<< quint64(0x08);
QTest::addRow("%s, unsinged, 4bit, start 3, le", s.name)
<< quint16(3) << quint16(4) << s.source
<< QtCanBus::DataFormat::UnsignedInteger
<< QSysInfo::Endian::LittleEndian
<< QVariant(15)
<< quint64(0x78);
QTest::addRow("%s, unsinged, 4bit, start 7, le", s.name)
<< quint16(7) << quint16(4) << s.source
<< QtCanBus::DataFormat::UnsignedInteger
<< QSysInfo::Endian::LittleEndian
<< QVariant(12)
<< quint64(0x0600);
// Some BE tests for values less than 8 bit
QTest::addRow("%s, unsinged, 4bit, start 7, be", s.name)
<< quint16(7) << quint16(4) << s.source
<< QtCanBus::DataFormat::UnsignedInteger
<< QSysInfo::Endian::BigEndian
<< QVariant(8)
<< quint64(0x80);
QTest::addRow("%s, unsinged, 4bit, start 5, be", s.name)
<< quint16(5) << quint16(4) << s.source
<< QtCanBus::DataFormat::UnsignedInteger
<< QSysInfo::Endian::BigEndian
<< QVariant(14)
<< quint64(0x38);
QTest::addRow("%s, unsinged, 4bit, start 0, be", s.name)
<< quint16(0) << quint16(4) << s.source
<< QtCanBus::DataFormat::UnsignedInteger
<< QSysInfo::Endian::BigEndian
<< QVariant(3)
<< quint64(0x6000);
}
// float data - payload only
{
const float floatVal = 123.456f;
for (quint16 i = 0; i < 8; ++i) {
const float leFloatVal = qToLittleEndian(floatVal);
quint64 value = 0;
memcpy(&value, &leFloatVal, sizeof(leFloatVal));
value = value << i;
QTest::addRow("Payload, float, start %d, le", i)
<< quint16(i) << quint16(32)
<< QtCanBus::DataSource::Payload
<< QtCanBus::DataFormat::Float
<< QSysInfo::Endian::LittleEndian
<< QVariant(floatVal)
<< value;
// to get the proper BE value with an offset, we need to take an LE
// value, shift it to the right, and then swap bytes
value = 0;
memcpy(&value, &leFloatVal, sizeof(leFloatVal));
value = value << 16; // so that we have some room for right shift
// this means that default start bit is 23
value = value >> i;
value = qToBigEndian(value);
QTest::addRow("Payload, float, start %d, be", 23 - i)
<< quint16(23 - i) << quint16(32)
<< QtCanBus::DataSource::Payload
<< QtCanBus::DataFormat::Float
<< QSysInfo::Endian::BigEndian
<< QVariant(floatVal)
<< value;
}
}
// double data - payload only
{
const double doubleVal = 1.234e-15;
const double leDoubleVal = qToLittleEndian(doubleVal);
quint64 value = 0;
memcpy(&value, &leDoubleVal, sizeof(leDoubleVal));
QTest::addRow("Payload, double, le")
<< quint16(0) << quint16(64)
<< QtCanBus::DataSource::Payload
<< QtCanBus::DataFormat::Double
<< QSysInfo::Endian::LittleEndian
<< QVariant(doubleVal)
<< value;
const double beDoubleVal = qToBigEndian(doubleVal);
value = 0;
memcpy(&value, &beDoubleVal, sizeof(beDoubleVal));
QTest::addRow("Payload, double, be")
<< quint16(7) << quint16(64)
<< QtCanBus::DataSource::Payload
<< QtCanBus::DataFormat::Double
<< QSysInfo::Endian::BigEndian
<< QVariant(doubleVal)
<< value;
}
// ASCII
for (const auto &s : sources) {
const bool isPayload = s.source == QtCanBus::DataSource::Payload;
const QByteArray asciiData = isPayload ? QByteArray("abc", 3) : QByteArray("ab", 2);
const quint16 offset = isPayload ? 8 : 4;
for (quint16 i = 0; i < 8; ++i) {
quint64 value = 0;
memcpy(&value, asciiData.constData(), asciiData.size());
value = value << (offset + i);
QTest::addRow("%s, ascii, start %d", s.name, offset + i)
<< quint16(offset + i) << quint16(asciiData.size() * 8) << s.source
<< QtCanBus::DataFormat::AsciiString
<< QSysInfo::Endian::LittleEndian /* does not matter */
<< QVariant(asciiData)
<< value;
}
}
// ASCII - not enough data
{
const QByteArray data("ab", 2);
QByteArray expectedData = data;
expectedData.push_back('\0'); // ab\0
quint64 value = 0;
memcpy(&value, expectedData.constData(), expectedData.size());
QTest::addRow("ascii, not enough data")
<< quint16(0) << quint16(expectedData.size() * 8)
<< QtCanBus::DataSource::Payload
<< QtCanBus::DataFormat::AsciiString
<< QSysInfo::Endian::LittleEndian
<< QVariant(data)
<< value;
}
// ASCII - too much data
{
const QByteArray data("abcd", 4);
const QByteArray expectedData = data.left(3); // abc
quint64 value = 0;
memcpy(&value, expectedData.constData(), expectedData.size());
QTest::addRow("ascii, too much data")
<< quint16(0) << quint16(expectedData.size() * 8)
<< QtCanBus::DataSource::Payload
<< QtCanBus::DataFormat::AsciiString
<< QSysInfo::Endian::LittleEndian
<< QVariant(data)
<< value;
}
}
void tst_QCanFrameProcessor::prepareFrame()
{
QFETCH(quint16, startBit);
QFETCH(quint16, bitLength);
QFETCH(QtCanBus::DataSource, source);
QFETCH(QtCanBus::DataFormat, format);
QFETCH(QSysInfo::Endian, endian);
QFETCH(QVariant, signalValue);
QFETCH(quint64, expectedData);
QCanSignalDescription signalDesc;
signalDesc.setName("s0");
signalDesc.setStartBit(startBit);
signalDesc.setBitLength(bitLength);
signalDesc.setDataSource(source);
signalDesc.setDataFormat(format);
signalDesc.setDataEndian(endian);
// Unique Id will be located in a different place from the signal data.
// If it's in a payload, we assume that it's in the first byte.
// If it's in the frame id, we assume that it takes the whole frame id.
const bool sourceInPayload = source == QtCanBus::DataSource::Payload;
const auto uidSource = sourceInPayload ? QtCanBus::DataSource::FrameId
: QtCanBus::DataSource::Payload;
const auto uidLength = sourceInPayload ? 29 : 8;
static constexpr quint32 uniqueId = 123;
QCanUniqueIdDescription uidDesc;
uidDesc.setEndian(QSysInfo::Endian::LittleEndian);
uidDesc.setSource(uidSource);
uidDesc.setStartBit(0);
uidDesc.setBitLength(uidLength);
const auto messageSize = sourceInPayload ? sizeof(expectedData) : 1;
QCanMessageDescription messageDesc;
messageDesc.setName("test");
messageDesc.setUniqueId(QtCanBus::UniqueId{uniqueId});
messageDesc.setSize(messageSize);
messageDesc.setSignalDescriptions({ signalDesc });
const QVariantMap signalValues = { qMakePair(signalDesc.name(), signalValue) };
QCanBusFrame expectedFrame;
if (sourceInPayload) {
expectedFrame.setFrameId(uniqueId & 0x1FFFFFFFU);
const QByteArray payload(reinterpret_cast<const char *>(&expectedData),
sizeof(expectedData));
expectedFrame.setPayload(payload);
} else {
expectedFrame.setFrameId(expectedData & 0x1FFFFFFFU);
// Explicitly truncating uniqueId to 1 byte. Fine, because it equals 123.
expectedFrame.setPayload(QByteArray(1, static_cast<char>(uniqueId)));
}
QVERIFY(expectedFrame.isValid());
QCanFrameProcessor processor;
processor.setUniqueIdDescription(uidDesc);
processor.addMessageDescriptions({ messageDesc });
const QCanBusFrame frame = processor.prepareFrame(QtCanBus::UniqueId{uniqueId}, signalValues);
QVERIFY(frame.isValid());
QCOMPARE(frame.frameId(), expectedFrame.frameId());
QCOMPARE(frame.payload(), expectedFrame.payload());
}
void tst_QCanFrameProcessor::prepareWithValueConversion_data()
{
QTest::addColumn<double>("factor");
QTest::addColumn<double>("offset");
QTest::addColumn<double>("scaling");
QTest::addColumn<QVariant>("signalValue");
QTest::addColumn<QByteArray>("expectedPayload");
// payloadValue = (signalValue / scaling - offset) / factor;
QTest::newRow("nan, nan, nan") << qQNaN() << qQNaN() << qQNaN() << QVariant(30) << QByteArray(1, 30);
QTest::newRow("0.75, nan, nan") << 0.75 << qQNaN() << qQNaN() << QVariant(22.5) << QByteArray(1, 30);
QTest::newRow("0.75, 15.3, nan") << 0.75 << 15.3 << qQNaN() << QVariant(37.8) << QByteArray(1, 30);
QTest::newRow("0.75, 15.3, 100") << 0.75 << 15.3 << 100. << QVariant(3780.) << QByteArray(1, 30);
QTest::newRow("0.75, nan, 100") << 0.75 << qQNaN() << 100. << QVariant(2250.) << QByteArray(1, 30);
QTest::newRow("nan, 15.3, 100") << qQNaN() << 15.3 << 100. << QVariant(4530.) << QByteArray(1, 30);
// check that setting factor and/or scaling to 0 is equivalent to NaN
QTest::newRow("0, 15.3, 100") << 0. << 15.3 << 100. << QVariant(4530.) << QByteArray(1, 30);
QTest::newRow("0, 15.3, 0") << 0. << 15.3 << 0. << QVariant(45.3) << QByteArray(1, 30);
}
void tst_QCanFrameProcessor::prepareWithValueConversion()
{
QFETCH(double, factor);
QFETCH(double, offset);
QFETCH(double, scaling);
QFETCH(QVariant, signalValue);
QFETCH(QByteArray, expectedPayload);
QCanSignalDescription signalDesc;
signalDesc.setName("s0");
signalDesc.setStartBit(7);
signalDesc.setBitLength(8);
signalDesc.setFactor(factor);
signalDesc.setOffset(offset);
signalDesc.setScaling(scaling);
const QtCanBus::UniqueId uniqueId{123};
QCanMessageDescription messageDesc;
messageDesc.setUniqueId(uniqueId);
messageDesc.setSize(expectedPayload.size());
messageDesc.addSignalDescription(signalDesc);
// Assume that our uniqueId is the whole FrameId
QCanUniqueIdDescription uidDesc;
uidDesc.setBitLength(29);
const QVariantMap signalValues = { qMakePair(signalDesc.name(), signalValue) };
QCanFrameProcessor processor;
processor.setUniqueIdDescription(uidDesc);
processor.addMessageDescriptions({ messageDesc });
const QCanBusFrame frame = processor.prepareFrame(uniqueId, signalValues);
QVERIFY(frame.isValid());
QCOMPARE(frame.frameId(), static_cast<QCanBusFrame::FrameId>(uniqueId));
QCOMPARE(frame.payload(), expectedPayload);
}
void tst_QCanFrameProcessor::prepareMultiplexedPayload_data()
{
QTest::addColumn<QByteArray>("expectedPayload");
QTest::addColumn<QVariantMap>("signalValues");
const QString s0Name("s0");
const QString s1Name("s1");
const QString s2Name("s2");
const QString s3Name("s3");
const QString s4Name("s4");
QTest::newRow("s0 and s2") << QByteArray::fromHex("2334")
<< QVariantMap({ qMakePair(s0Name, 3),
qMakePair(s2Name, 0x342) });
QTest::newRow("s0, s1 and s3") << QByteArray::fromHex("1134")
<< QVariantMap({ qMakePair(s0Name, 1),
qMakePair(s1Name, 1),
qMakePair(s3Name, 0x34) });
QTest::newRow("s0, s1 and s4") << QByteArray::fromHex("5134")
<< QVariantMap({ qMakePair(s0Name, 1),
qMakePair(s1Name, 5),
qMakePair(s4Name, 0x34) });
QTest::newRow("s0 and s1") << QByteArray::fromHex("3100")
<< QVariantMap({ qMakePair(s0Name, 1),
qMakePair(s1Name, 3) });
QTest::newRow("only s0") << QByteArray::fromHex("0300")
<< QVariantMap({ qMakePair(s0Name, 3) });
}
void tst_QCanFrameProcessor::prepareMultiplexedPayload()
{
QFETCH(QByteArray, expectedPayload);
QFETCH(QVariantMap, signalValues);
QCanSignalDescription s0; // multiplexor 1
s0.setName("s0");
s0.setDataEndian(QSysInfo::Endian::LittleEndian);
s0.setStartBit(0);
s0.setBitLength(4);
s0.setMultiplexState(QtCanBus::MultiplexState::MultiplexorSwitch);
QCanSignalDescription s1; // multiplexor 2, also depends on the value of s0
s1.setName("s1");
s1.setDataEndian(QSysInfo::Endian::LittleEndian);
s1.setStartBit(4);
s1.setBitLength(4);
s1.setMultiplexState(QtCanBus::MultiplexState::SwitchAndSignal);
s1.addMultiplexSignal(s0.name(), 1);
QCanSignalDescription s2; // depends on mux1 only, contains 12 bits of data
s2.setName("s2");
s2.setDataEndian(QSysInfo::Endian::LittleEndian);
s2.setStartBit(4);
s2.setBitLength(12);
s2.setMultiplexState(QtCanBus::MultiplexState::MultiplexedSignal);
const QCanSignalDescription::MultiplexValues muxValuesS0 { {2, 4} };
s2.addMultiplexSignal(s0.name(), muxValuesS0);
QCanSignalDescription s3; // depends on mux2 (so indirectly on mux1)
s3.setName("s3");
s3.setDataEndian(QSysInfo::Endian::LittleEndian);
s3.setStartBit(8);
s3.setBitLength(8);
s3.setMultiplexState(QtCanBus::MultiplexState::MultiplexedSignal);
s3.addMultiplexSignal(s1.name(), 1);
QCanSignalDescription s4; // depends on mux2 (so indirectly on mux1)
s4.setName("s4");
s4.setDataEndian(QSysInfo::Endian::LittleEndian);
s4.setStartBit(8);
s4.setBitLength(8);
s4.setMultiplexState(QtCanBus::MultiplexState::MultiplexedSignal);
const QCanSignalDescription::MultiplexValues muxValuesS1 { {2, 3}, {5, 5} };
s4.addMultiplexSignal(s1.name(), muxValuesS1);
const QtCanBus::UniqueId uniqueId{123};
QCanMessageDescription msg;
msg.setName("test");
msg.setUniqueId(uniqueId);
msg.setSize(expectedPayload.size());
msg.setSignalDescriptions({ s0, s1, s2, s3, s4 });
// Assume that our uniqueId is the whole FrameId
QCanUniqueIdDescription uidDesc;
uidDesc.setBitLength(29);
QCanFrameProcessor processor;
processor.setUniqueIdDescription(uidDesc);
processor.addMessageDescriptions({ msg });
const QCanBusFrame frame = processor.prepareFrame(msg.uniqueId(), signalValues);
QVERIFY(frame.isValid());
QCOMPARE(frame.frameId(), static_cast<QCanBusFrame::FrameId>(uniqueId));
QCOMPARE(frame.payload(), expectedPayload);
}
void tst_QCanFrameProcessor::prepareWithErrorsAndWarnings_data()
{
QTest::addColumn<QCanMessageDescription>("messageDescription");
QTest::addColumn<QCanUniqueIdDescription>("uniqueIdDescription");
QTest::addColumn<QtCanBus::UniqueId>("uniqueId");
QTest::addColumn<QVariantMap>("signalValues");
QTest::addColumn<QCanFrameProcessor::Error>("expectedError");
QTest::addColumn<QString>("expectedErrorDescription");
QTest::addColumn<QStringList>("expectedWarnings");
QTest::addColumn<QCanBusFrame::FrameId>("expectedFrameId");
QTest::addColumn<QByteArray>("expectedPayload");
QTest::addRow("no UID description")
<< QCanMessageDescription() << QCanUniqueIdDescription()
<< QtCanBus::UniqueId(0) << QVariantMap()
<< QCanFrameProcessor::Error::Encoding
<< tr("No valid unique identifier description is specified.")
<< QStringList() << QCanBusFrame::FrameId(0) << QByteArray();
QCanUniqueIdDescription uidDesc;
uidDesc.setBitLength(29);
QTest::addRow("no message description")
<< QCanMessageDescription() << uidDesc << QtCanBus::UniqueId(123)
<< QVariantMap() << QCanFrameProcessor::Error::Encoding
<< tr("Failed to find message description for unique id 123.")
<< QStringList() << QCanBusFrame::FrameId(0) << QByteArray();
QCanSignalDescription signalDesc;
signalDesc.setName("s0");
signalDesc.setStartBit(3);
signalDesc.setBitLength(4);
QCanMessageDescription messageDesc;
messageDesc.setUniqueId(QtCanBus::UniqueId{123});
messageDesc.setSize(2);
messageDesc.addSignalDescription(signalDesc);
uidDesc.setSource(QtCanBus::DataSource::Payload);
uidDesc.setStartBit(8);
uidDesc.setBitLength(16); // does not fit into the payload
QTest::addRow("set UID fail")
<< messageDesc << uidDesc << messageDesc.uniqueId()
<< QVariantMap() << QCanFrameProcessor::Error::Encoding
<< tr("Failed to encode unique id 123 into the frame")
<< QStringList() << QCanBusFrame::FrameId(0) << QByteArray();
// reset uidDesc
uidDesc = QCanUniqueIdDescription();
uidDesc.setBitLength(29);
QStringList warnings = { tr("Skipping signal s1. It is not found in message "
"description for unique id 123.") };
QTest::addRow("no signal description")
<< messageDesc << uidDesc << messageDesc.uniqueId()
<< QVariantMap({ qMakePair("s0", 1), qMakePair("s1", 2) })
<< QCanFrameProcessor::Error::None << QString()
<< warnings << QCanBusFrame::FrameId(messageDesc.uniqueId())
<< QByteArray::fromHex("0100");
// invalid signal desc - 0 length
signalDesc.setName("s2");
signalDesc.setStartBit(7);
signalDesc.setBitLength(0);
messageDesc.addSignalDescription(signalDesc);
warnings.push_back(tr("Skipping signal s2. Its description is invalid."));
QTest::addRow("invalid signal description")
<< messageDesc << uidDesc << messageDesc.uniqueId()
<< QVariantMap({ qMakePair("s0", 1), qMakePair("s1", 2), qMakePair("s2", 3) })
<< QCanFrameProcessor::Error::None << QString()
<< warnings << QCanBusFrame::FrameId(messageDesc.uniqueId())
<< QByteArray::fromHex("0100");
// max bit exceed data length
signalDesc.setName("s3");
signalDesc.setStartBit(15);
signalDesc.setBitLength(10);
messageDesc.addSignalDescription(signalDesc);
warnings.push_back(tr("Skipping signal s3. Its length exceeds the expected message length."));
QTest::addRow("invalid signal length")
<< messageDesc << uidDesc << messageDesc.uniqueId()
<< QVariantMap({ qMakePair("s0", 1), qMakePair("s1", 2),
qMakePair("s2", 3), qMakePair("s3", 4) })
<< QCanFrameProcessor::Error::None << QString()
<< warnings << QCanBusFrame::FrameId(messageDesc.uniqueId())
<< QByteArray::fromHex("0100");
// Test that multiplexed signals are used only when proper multiplexor
// values are provided.
messageDesc.clearSignalDescriptions();
// first multiplexor
signalDesc.setName("s0");
signalDesc.setMultiplexState(QtCanBus::MultiplexState::MultiplexorSwitch);
signalDesc.setStartBit(7);
signalDesc.setBitLength(4);
messageDesc.addSignalDescription(signalDesc);
// s1 is used only when s0 is in range [2, 4] or 6
signalDesc.setName("s1");
signalDesc.setStartBit(3);
signalDesc.setBitLength(12);
signalDesc.setMultiplexState(QtCanBus::MultiplexState::MultiplexedSignal);
const QCanSignalDescription::MultiplexValues muxValuesS0 { {2, 4}, {6, 6} };
signalDesc.addMultiplexSignal("s0", muxValuesS0);
messageDesc.addSignalDescription(signalDesc);
// second multiplexor, used when s0 == 1
signalDesc.setName("s2");
signalDesc.setStartBit(3);
signalDesc.setBitLength(4);
signalDesc.setMultiplexState(QtCanBus::MultiplexState::SwitchAndSignal);
signalDesc.addMultiplexSignal("s0", 1);
messageDesc.addSignalDescription(signalDesc);
// s3 depends on two multiplexors
signalDesc.setName("s3");
signalDesc.setStartBit(15);
signalDesc.setBitLength(8);
signalDesc.setMultiplexState(QtCanBus::MultiplexState::MultiplexedSignal);
signalDesc.addMultiplexSignal("s0", 1);
const QCanSignalDescription::MultiplexValues muxValuesS2 { {1, 3}, {5, 6} };
signalDesc.addMultiplexSignal("s2", muxValuesS2);
messageDesc.addSignalDescription(signalDesc);
// s4 depends on two multiplexors
signalDesc.setName("s4");
signalDesc.setStartBit(15);
signalDesc.setBitLength(8);
signalDesc.setMultiplexState(QtCanBus::MultiplexState::MultiplexedSignal);
signalDesc.addMultiplexSignal("s0", 1);
signalDesc.addMultiplexSignal("s2", 4);
messageDesc.addSignalDescription(signalDesc);
warnings.clear();
warnings.push_back(tr("Skipping signal s1. Proper multiplexor values not found."));
warnings.push_back(tr("Skipping signal s4. Proper multiplexor values not found."));
QTest::addRow("multiplexed signals")
<< messageDesc << uidDesc << messageDesc.uniqueId()
<< QVariantMap({ qMakePair("s0", 1), qMakePair("s1", 10), qMakePair("s2", 2),
qMakePair("s3", 5), qMakePair("s4", 6) })
<< QCanFrameProcessor::Error::None << QString()
<< warnings << QCanBusFrame::FrameId(messageDesc.uniqueId())
<< QByteArray::fromHex("1205");
// A signal whose (startBit + bitLength) exceeds 65535 must be skipped, not
// encoded: otherwise the truncated end-of-signal position passes the bounds
// check while the untruncated start offset drives an out-of-bounds write.
QCanMessageDescription truncationMsg;
truncationMsg.setUniqueId(QtCanBus::UniqueId{123});
truncationMsg.setSize(8);
QCanSignalDescription oobWrite;
oobWrite.setName("oobWrite");
oobWrite.setDataEndian(QSysInfo::Endian::LittleEndian);
oobWrite.setDataFormat(QtCanBus::DataFormat::UnsignedInteger);
oobWrite.setStartBit(65480); // 65480 + 64 - 1 = 65543, truncates to 7
oobWrite.setBitLength(64);
truncationMsg.addSignalDescription(oobWrite);
QTest::addRow("signal offset exceeds quint16")
<< truncationMsg << uidDesc << truncationMsg.uniqueId()
<< QVariantMap({ qMakePair("oobWrite",
QVariant::fromValue<quint64>(0xdeadbeefcafebabeULL)) })
<< QCanFrameProcessor::Error::None << QString()
<< QStringList{ tr("Skipping signal oobWrite. Its length exceeds the "
"expected message length.") }
<< QCanBusFrame::FrameId(truncationMsg.uniqueId())
<< QByteArray(8, 0x00);
}
void tst_QCanFrameProcessor::prepareWithErrorsAndWarnings()
{
QFETCH(QCanMessageDescription, messageDescription);
QFETCH(QCanUniqueIdDescription, uniqueIdDescription);
QFETCH(QtCanBus::UniqueId, uniqueId);
QFETCH(QVariantMap, signalValues);
QFETCH(QCanFrameProcessor::Error, expectedError);
QFETCH(QString, expectedErrorDescription);
QFETCH(QStringList, expectedWarnings);
QFETCH(QCanBusFrame::FrameId, expectedFrameId);
QFETCH(QByteArray, expectedPayload);
QCanFrameProcessor processor;
processor.setUniqueIdDescription(uniqueIdDescription);
processor.setMessageDescriptions({ messageDescription });
const QCanBusFrame frame = processor.prepareFrame(uniqueId, signalValues);
QCOMPARE(processor.error(), expectedError);
QCOMPARE(processor.errorString(), expectedErrorDescription);
// signal descriptions are stored as a QHash internally, so they are
// processed in a hash-dependent order. Because of that the order of
// warnings cannot be defined. So we sort them alphabetically before
// comparing.
std::sort(expectedWarnings.begin(), expectedWarnings.end());
QStringList warnings = processor.warnings();
std::sort(warnings.begin(), warnings.end());
QCOMPARE(warnings, expectedWarnings);
QCOMPARE(frame.frameId(), expectedFrameId);
QCOMPARE(frame.payload(), expectedPayload);
}
void tst_QCanFrameProcessor::prepareUniqueId_data()
{
QTest::addColumn<QCanUniqueIdDescription>("uniqueIdDescription");
QTest::addColumn<QCanMessageDescription>("messageDescription");
QTest::addColumn<QtCanBus::UniqueId>("uniqueId");
QTest::addColumn<QVariantMap>("signalValues");
QTest::addColumn<QCanBusFrame>("expectedFrame");
const quint32 uniqueId = 0x0965;
QCanSignalDescription signalDesc;
signalDesc.setName("s0");
signalDesc.setDataSource(QtCanBus::DataSource::Payload);
signalDesc.setDataEndian(QSysInfo::Endian::LittleEndian);
signalDesc.setDataFormat(QtCanBus::DataFormat::UnsignedInteger);
signalDesc.setStartBit(0);
signalDesc.setBitLength(8);
QCanMessageDescription messageDesc;
messageDesc.setName("test");
messageDesc.setUniqueId(QtCanBus::UniqueId{uniqueId});
messageDesc.setSize(1);
messageDesc.addSignalDescription(signalDesc);
const QVariantMap signalValues { qMakePair("s0", 1) };
// Encode unique id into frame id.
QCanUniqueIdDescription uidDesc;
uidDesc.setSource(QtCanBus::DataSource::FrameId);
uidDesc.setBitLength(12);
for (quint8 startBit = 0; startBit < 8; ++startBit) {
uidDesc.setStartBit(startBit);
uidDesc.setEndian(QSysInfo::Endian::LittleEndian);
const QCanBusFrame::FrameId frameId = qFromLittleEndian(uniqueId) << startBit;
QTest::addRow("frameId, LE, start %d", startBit)
<< uidDesc << messageDesc << QtCanBus::UniqueId{uniqueId}
<< signalValues << QCanBusFrame(frameId, QByteArray(1, 0x01));
}
static constexpr quint16 startBitsFrame[] = { 3, 2, 1, 0, 15, 14, 13, 12 };
static constexpr quint16 startBitsFrameLen =
sizeof(startBitsFrame)/sizeof(startBitsFrame[0]);
for (quint16 idx = 0; idx < startBitsFrameLen; ++idx) {
const auto val = (qToLittleEndian(uniqueId) << 16) >> idx;
const QCanBusFrame::FrameId frameId = qToBigEndian(val);
const auto startBit = startBitsFrame[idx];
uidDesc.setEndian(QSysInfo::Endian::BigEndian);
uidDesc.setStartBit(startBit);
QTest::addRow("frameId, BE, offser %d", startBit)
<< uidDesc << messageDesc << QtCanBus::UniqueId{uniqueId}
<< signalValues << QCanBusFrame(frameId, QByteArray(1, 0x01));
}
// Encode unique id into payload. The 1st byte of the payload is already
// populated with a signal value, so we start from the 2nd byte
uidDesc.setSource(QtCanBus::DataSource::Payload);
messageDesc.setSize(sizeof(quint32));
for (quint8 startBit = 8; startBit < 16; ++startBit) {
uidDesc.setStartBit(startBit);
uidDesc.setEndian(QSysInfo::Endian::LittleEndian);
const quint32 payload = 0x01 | qFromLittleEndian(uniqueId) << startBit;
const QByteArray payloadData(reinterpret_cast<const char *>(&payload), sizeof(payload));
QTest::addRow("payload, LE, offser %d", startBit)
<< uidDesc << messageDesc << QtCanBus::UniqueId{uniqueId}
<< signalValues << QCanBusFrame(0, payloadData);
}
static constexpr quint16 startBitsPayload[] = { 11, 10, 9, 8, 23, 22, 21, 20 };
static constexpr qsizetype startBitsPayloadLen =
sizeof(startBitsPayload)/sizeof(startBitsPayload[0]);
for (quint16 idx = 0; idx < startBitsPayloadLen; ++idx) {
const auto val = (qToLittleEndian(uniqueId) << 8) >> idx;
const auto startBit = startBitsPayload[idx];
quint32 payload = 0x01 | qToBigEndian(val);
const QByteArray payloadData(reinterpret_cast<const char *>(&payload), sizeof(payload));
uidDesc.setEndian(QSysInfo::Endian::BigEndian);
uidDesc.setStartBit(startBit);
QTest::addRow("payload, BE, start %d", startBit)
<< uidDesc << messageDesc << QtCanBus::UniqueId{uniqueId}
<< signalValues << QCanBusFrame(0, payloadData);
}
}
void tst_QCanFrameProcessor::prepareUniqueId()
{
QFETCH(QCanUniqueIdDescription, uniqueIdDescription);
QFETCH(QCanMessageDescription, messageDescription);
QFETCH(QtCanBus::UniqueId, uniqueId);
QFETCH(QVariantMap, signalValues);
QFETCH(QCanBusFrame, expectedFrame);
QCanFrameProcessor processor;
processor.setUniqueIdDescription(uniqueIdDescription);
processor.setMessageDescriptions({ messageDescription });
const auto result = processor.prepareFrame(uniqueId, signalValues);
QCOMPARE(processor.error(), QCanFrameProcessor::Error::None);
QCOMPARE(result.frameId(), expectedFrame.frameId());
QCOMPARE(result.payload(), expectedFrame.payload());
}
void tst_QCanFrameProcessor::roundtrip_data()
{
QTest::addColumn<QCanMessageDescription>("messageDescription");
QTest::addColumn<QCanUniqueIdDescription>("uniqueIdDescription");
QTest::addColumn<QCanBusFrame>("inputFrame");
QTest::addColumn<QtCanBus::UniqueId>("expectedUniqueId");
QTest::addColumn<QVariantMap>("expectedSignalValues");
{
QCanUniqueIdDescription uidDesc;
uidDesc.setSource(QtCanBus::DataSource::FrameId);
uidDesc.setEndian(QSysInfo::Endian::LittleEndian);
uidDesc.setStartBit(0);
uidDesc.setBitLength(11);
const quint32 uniqueId = 1467;
QCanMessageDescription messageDesc;
messageDesc.setName("test");
messageDesc.setUniqueId(QtCanBus::UniqueId{uniqueId});
messageDesc.setSize(8);
// s0 - 4 bits [0:3], signed int
QCanSignalDescription signalDesc;
signalDesc.setName("s0");
signalDesc.setDataSource(QtCanBus::DataSource::Payload);
signalDesc.setDataEndian(QSysInfo::Endian::LittleEndian);
signalDesc.setDataFormat(QtCanBus::DataFormat::SignedInteger);
signalDesc.setStartBit(0);
signalDesc.setBitLength(4);
messageDesc.addSignalDescription(signalDesc);
// s1 - 12 bits [4:15], unsigned int
signalDesc.setName("s1");
signalDesc.setDataFormat(QtCanBus::DataFormat::UnsignedInteger);
signalDesc.setStartBit(4);
signalDesc.setBitLength(12);
messageDesc.addSignalDescription(signalDesc);
// s2 - 32 bits [16:47], float
signalDesc.setName("s2");
signalDesc.setDataFormat(QtCanBus::DataFormat::Float);
signalDesc.setStartBit(16);
signalDesc.setBitLength(32);
messageDesc.addSignalDescription(signalDesc);
// gap - 6 bits [48:53]
// s3 - 10 bits [54:63], unsinged int
signalDesc.setName("s3");
signalDesc.setDataFormat(QtCanBus::DataFormat::UnsignedInteger);
signalDesc.setStartBit(54);
signalDesc.setBitLength(10);
messageDesc.addSignalDescription(signalDesc);
const qint8 s0Val = -3;
const quint16 s1Val = 2890;
const float s2Val = 123.456f;
const quint16 s3Val = 963;
QVariantMap signalValues = { qMakePair("s0", s0Val), qMakePair("s1", s1Val),
qMakePair("s2", s2Val), qMakePair("s3", s3Val) };
quint64 payloadValue = (static_cast<quint64>(s3Val) << 54) +
(static_cast<quint64>(s1Val & 0x0FFF) << 4) + static_cast<quint64>(s0Val & 0x0F);
QByteArray payload(reinterpret_cast<const char *>(&payloadValue), sizeof(quint64));
memcpy(&payload[2], &s2Val, sizeof(float));
QCanBusFrame inputFrame(uniqueId, payload);
QTest::addRow("LE") << messageDesc << uidDesc << inputFrame
<< QtCanBus::UniqueId{uniqueId} << signalValues;
}
{
QCanUniqueIdDescription uidDesc;
uidDesc.setSource(QtCanBus::DataSource::FrameId);
uidDesc.setEndian(QSysInfo::Endian::BigEndian);
uidDesc.setStartBit(7);
uidDesc.setBitLength(11);
const quint32 uniqueId = 1467; // 0x60B7 for the specified layout
QCanMessageDescription messageDesc;
messageDesc.setName("test");
messageDesc.setUniqueId(QtCanBus::UniqueId{uniqueId});
messageDesc.setSize(8);
// s0 - 4 bits [7:4], signed int
QCanSignalDescription signalDesc;
signalDesc.setName("s0");
signalDesc.setDataSource(QtCanBus::DataSource::Payload);
signalDesc.setDataEndian(QSysInfo::Endian::BigEndian);
signalDesc.setDataFormat(QtCanBus::DataFormat::SignedInteger);
signalDesc.setStartBit(7);
signalDesc.setBitLength(4);
messageDesc.addSignalDescription(signalDesc);
// s1 - 12 bits [3:0]+[15:8], unsigned int
signalDesc.setName("s1");
signalDesc.setDataFormat(QtCanBus::DataFormat::UnsignedInteger);
signalDesc.setStartBit(3);
signalDesc.setBitLength(12);
messageDesc.addSignalDescription(signalDesc);
// s2 - 32 bits [23:16]+[31:24]+[39:32]+[47:10], float
signalDesc.setName("s2");
signalDesc.setDataFormat(QtCanBus::DataFormat::Float);
signalDesc.setStartBit(23);
signalDesc.setBitLength(32);
messageDesc.addSignalDescription(signalDesc);
// gap - 6 bits [55:50]
// s3 - 10 bits [49:48]+[63:56], unsinged int
signalDesc.setName("s3");
signalDesc.setDataFormat(QtCanBus::DataFormat::UnsignedInteger);
signalDesc.setStartBit(49);
signalDesc.setBitLength(10);
messageDesc.addSignalDescription(signalDesc);
const qint8 s0Val = -3; // 0xD
const quint16 s1Val = 2890; // 0xB4A
const float s2Val = 123.456f;
const quint16 s3Val = 963; // 0x3C3
QVariantMap signalValues = { qMakePair("s0", s0Val), qMakePair("s1", s1Val),
qMakePair("s2", s2Val), qMakePair("s3", s3Val) };
quint64 payloadValue = 0xC303000000004ADBULL;
QByteArray payload(reinterpret_cast<const char *>(&payloadValue), sizeof(quint64));
const float s2BeVal = qToBigEndian(s2Val);
memcpy(&payload[2], &s2BeVal, sizeof(float));
QCanBusFrame inputFrame(0x60B7, payload);
QTest::addRow("BE") << messageDesc << uidDesc << inputFrame
<< QtCanBus::UniqueId{uniqueId} << signalValues;
}
}
void tst_QCanFrameProcessor::roundtrip()
{
QFETCH(QCanMessageDescription, messageDescription);
QFETCH(QCanUniqueIdDescription, uniqueIdDescription);
QFETCH(QCanBusFrame, inputFrame);
QFETCH(QtCanBus::UniqueId, expectedUniqueId);
QFETCH(QVariantMap, expectedSignalValues);
QCanFrameProcessor processor;
processor.setUniqueIdDescription(uniqueIdDescription);
processor.setMessageDescriptions({ messageDescription });
const auto result = processor.parseFrame(inputFrame);
QCOMPARE(result.uniqueId, expectedUniqueId);
QCOMPARE(result.signalValues, expectedSignalValues);
const auto encodedFrame = processor.prepareFrame(result.uniqueId, result.signalValues);
QCOMPARE(encodedFrame.frameId(), inputFrame.frameId());
QCOMPARE(encodedFrame.payload(), inputFrame.payload());
}
QTEST_MAIN(tst_QCanFrameProcessor)
#include "tst_qcanframeprocessor.moc"