Revision control

Copy as Markdown

// Copyright (C) 2022 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only 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();
void copy();
void move();
void comparison();
void detachOnOperations();
/* parse */
void parseSignalFromFrameId_data();
void parseSignalFromFrameId();
void parseSignalFromPayload_data();
void parseSignalFromPayload();
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 prepareFrameId_data();
void prepareFrameId();
void preparePayload_data();
void preparePayload();
void prepareWithValueConversion_data();
void prepareWithValueConversion();
void prepareMultiplexedPayload_data();
void prepareMultiplexedPayload();
void prepareWithErrorsAndWarnings_data();
void prepareWithErrorsAndWarnings();
void prepareUniqueId_data();
void prepareUniqueId();
};
void tst_QCanFrameProcessor::construct()
{
QCanFrameProcessor p;
QVERIFY(p.messageDescriptions().isEmpty());
QCOMPARE(p.error(), QCanFrameProcessor::Error::NoError);
QVERIFY(p.errorString().isEmpty());
QVERIFY(p.warnings().isEmpty());
QVERIFY(!p.uniqueIdDescription().isValid());
QVERIFY(!QCanFrameProcessorPrivate::get(p)->isShared());
}
void tst_QCanFrameProcessor::copy()
{
QCanMessageDescription desc;
desc.setName("test");
desc.setUniqueId(123);
desc.setSize(8);
QCanFrameProcessor p;
p.setMessageDescriptions({ desc });
QVERIFY(!QCanFrameProcessorPrivate::get(p)->isShared());
QCanFrameProcessor p1(p);
QCOMPARE(p1, p);
QVERIFY(QCanFrameProcessorPrivate::get(p)->isShared());
QVERIFY(QCanFrameProcessorPrivate::get(p1)->isShared());
QCanFrameProcessor p2 = p;
QCOMPARE(p2, p);
QVERIFY(QCanFrameProcessorPrivate::get(p)->isShared());
QVERIFY(QCanFrameProcessorPrivate::get(p1)->isShared());
QVERIFY(QCanFrameProcessorPrivate::get(p2)->isShared());
p2.clearMessageDescriptions();
QCOMPARE_NE(p2, p);
QVERIFY(QCanFrameProcessorPrivate::get(p)->isShared());
QVERIFY(QCanFrameProcessorPrivate::get(p1)->isShared());
QVERIFY(!QCanFrameProcessorPrivate::get(p2)->isShared());
}
void tst_QCanFrameProcessor::move()
{
QCanMessageDescription desc;
desc.setName("test");
desc.setUniqueId(123);
desc.setSize(8);
QCanFrameProcessor p;
p.setMessageDescriptions({ desc });
QVERIFY(!QCanFrameProcessorPrivate::get(p)->isShared());
QCanFrameProcessor pCopy;
pCopy.setMessageDescriptions({ desc });
QCOMPARE(pCopy, p);
QCanFrameProcessor p1(std::move(p));
QCOMPARE(p1, pCopy);
QVERIFY(!QCanFrameProcessorPrivate::get(p1)->isShared());
QCanFrameProcessor p2 = std::move(p1);
QCOMPARE(p2, pCopy);
QVERIFY(!QCanFrameProcessorPrivate::get(p2)->isShared());
p = std::move(p2);
QCOMPARE(p, pCopy);
QVERIFY(!QCanFrameProcessorPrivate::get(p)->isShared());
}
void tst_QCanFrameProcessor::comparison()
{
QCanSignalDescription sigDesc;
sigDesc.setBitLength(8);
QCanMessageDescription desc;
desc.setName("test");
desc.setUniqueId(123);
desc.setSize(1);
desc.addSignalDescription(sigDesc);
QCanUniqueIdDescription uidDesc;
uidDesc.setSource(QtCanBus::DataSource::FrameId);
uidDesc.setStartBit(0);
uidDesc.setBitLength(29);
QCanFrameProcessor p;
p.setUniqueIdDescription(uidDesc);
p.setMessageDescriptions({ desc });
QCanFrameProcessor p1 = p;
QCOMPARE(p1, p);
// make sure that parsing errors do not affect the comparison
p1.parseFrame(QCanBusFrame(1, QByteArray(1, 0x00)));
QCOMPARE_NE(p1.error(), p.error());
QCOMPARE_EQ(p1, p);
// make sure that warnings do not affect comparison
p1.parseFrame(QCanBusFrame(123, QByteArray(1, 0x00)));
QCOMPARE_NE(p1.warnings(), p.warnings());
QCOMPARE_EQ(p1, p);
// updating uniqueId description affects comparison
uidDesc.setSource(QtCanBus::DataSource::Payload);
p1.setUniqueIdDescription(uidDesc);
QCOMPARE_NE(p1, p);
p1 = p;
QCOMPARE(p1, p);
// updating message descriptions affects comparison
desc.setName("test1");
desc.setUniqueId(456);
p1.addMessageDescriptions({ desc });
QCOMPARE_NE(p1, p);
}
void tst_QCanFrameProcessor::detachOnOperations()
{
QCanMessageDescription desc;
desc.setName("test");
desc.setUniqueId(123);
desc.setSize(8);
QCanFrameProcessor p;
p.setMessageDescriptions({ desc });
// calling const methods does not detach
{
QCanFrameProcessor p1(p);
QVERIFY(QCanFrameProcessorPrivate::get(p1)->isShared());
const auto error = p1.error();
Q_UNUSED(error);
QVERIFY(QCanFrameProcessorPrivate::get(p1)->isShared());
const auto errorDesc = p1.errorString();
Q_UNUSED(errorDesc);
QVERIFY(QCanFrameProcessorPrivate::get(p1)->isShared());
const auto warnings = p1.warnings();
Q_UNUSED(warnings);
QVERIFY(QCanFrameProcessorPrivate::get(p1)->isShared());
const auto msgDesc = p1.messageDescriptions();
Q_UNUSED(msgDesc);
QVERIFY(QCanFrameProcessorPrivate::get(p1)->isShared());
const auto uidDesc = p1.uniqueIdDescription();
Q_UNUSED(uidDesc);
QVERIFY(QCanFrameProcessorPrivate::get(p1)->isShared());
}
// callings non-const methods detaches
{
QCanFrameProcessor p1(p);
QVERIFY(QCanFrameProcessorPrivate::get(p1)->isShared());
p1.prepareFrame(123, QVariantMap());
QVERIFY(!QCanFrameProcessorPrivate::get(p1)->isShared());
}
{
QCanFrameProcessor p1(p);
QVERIFY(QCanFrameProcessorPrivate::get(p1)->isShared());
p1.parseFrame(QCanBusFrame(123, QByteArray(8, 0x01)));
QVERIFY(!QCanFrameProcessorPrivate::get(p1)->isShared());
}
QCanMessageDescription desc1;
desc1.setName("test1");
desc1.setUniqueId(234);
desc1.setSize(8);
{
QCanFrameProcessor p1(p);
QVERIFY(QCanFrameProcessorPrivate::get(p1)->isShared());
p1.addMessageDescriptions({ desc1 });
QVERIFY(!QCanFrameProcessorPrivate::get(p1)->isShared());
}
{
QCanFrameProcessor p1(p);
QVERIFY(QCanFrameProcessorPrivate::get(p1)->isShared());
p1.setMessageDescriptions({ desc, desc1 });
QVERIFY(!QCanFrameProcessorPrivate::get(p1)->isShared());
}
{
QCanFrameProcessor p1(p);
QVERIFY(QCanFrameProcessorPrivate::get(p1)->isShared());
p1.clearMessageDescriptions();
QVERIFY(!QCanFrameProcessorPrivate::get(p1)->isShared());
}
{
QCanFrameProcessor p1(p);
QVERIFY(QCanFrameProcessorPrivate::get(p1)->isShared());
auto uidDesc = p.uniqueIdDescription();
uidDesc.setBitLength(1);
p1.setUniqueIdDescription(uidDesc);
QVERIFY(!QCanFrameProcessorPrivate::get(p1)->isShared());
}
}
void tst_QCanFrameProcessor::parseSignalFromFrameId_data()
{
QTest::addColumn<quint32>("frameId");
QTest::addColumn<quint16>("startBit");
QTest::addColumn<quint16>("bitLength");
QTest::addColumn<QtCanBus::DataFormat>("format");
QTest::addColumn<QtCanBus::DataEndian>("endian");
QTest::addColumn<QVariant>("expectedValue");
quint32 frameId {0x1234FFEC};
for (quint16 i = 0; i < 8; ++i) {
quint32 value = (frameId << i) & 0x1FFFFFFFU;
QTest::addRow("int16, le, from %d", i)
<< value << i << quint16(16)
<< QtCanBus::DataFormat::SignedInteger
<< QtCanBus::DataEndian::LittleEndian
<< QVariant(-20);
QTest::addRow("uint16, le, from %d", i)
<< value << i << quint16(16)
<< QtCanBus::DataFormat::UnsignedInteger
<< QtCanBus::DataEndian::LittleEndian
<< QVariant(65516);
}
frameId = quint32(0x12348582);
for (quint16 i = 0; i < 8; ++i) {
quint32 value = (frameId << i) & 0x1FFFFFFFU;
QTest::addRow("int16, be, from %d", i)
<< value << i << quint16(16)
<< QtCanBus::DataFormat::SignedInteger
<< QtCanBus::DataEndian::BigEndian
<< QVariant(-32123);
QTest::addRow("uint16, be, from %d", i)
<< value << i << quint16(16)
<< QtCanBus::DataFormat::UnsignedInteger
<< QtCanBus::DataEndian::BigEndian
<< QVariant(33413);
}
}
void tst_QCanFrameProcessor::parseSignalFromFrameId()
{
QFETCH(quint32, frameId);
QFETCH(quint16, startBit);
QFETCH(quint16, bitLength);
QFETCH(QtCanBus::DataFormat, format);
QFETCH(QtCanBus::DataEndian, endian);
QFETCH(QVariant, expectedValue);
QCanSignalDescription sig;
sig.setName("test_signal");
sig.setDataSource(QtCanBus::DataSource::FrameId);
sig.setDataFormat(format);
sig.setDataEndian(endian);
sig.setStartBit(startBit);
sig.setBitLength(bitLength);
QVERIFY(sig.isValid());
// The unique id will be extracted from the 0-th payload byte
QCanUniqueIdDescription uidDesc;
uidDesc.setSource(QtCanBus::DataSource::Payload);
uidDesc.setStartBit(0);
uidDesc.setBitLength(4);
const QtCanBus::UniqueId expectedUid = 0x0A;
QCanMessageDescription message;
message.setName("test_message");
message.setUniqueId(expectedUid);
message.setSize(1);
message.addSignalDescription(sig);
QVERIFY(message.isValid());
QCanFrameProcessor parser;
parser.setUniqueIdDescription(uidDesc);
parser.addMessageDescriptions({ message });
QCanBusFrame frame(frameId, 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::parseSignalFromPayload_data()
{
QTest::addColumn<QByteArray>("payload");
QTest::addColumn<quint16>("startBit");
QTest::addColumn<quint16>("bitLength");
QTest::addColumn<QtCanBus::DataFormat>("format");
QTest::addColumn<QtCanBus::DataEndian>("endian");
QTest::addColumn<QVariant>("expectedValue");
// (u)int, LE/BE, variable start and bitLength
// Every next value in the list is supposed to have a length in bits cut
// by one.
static constexpr quint16 unsignedValues[] = { 0xCFC7, 0x67E3, 0x33F1, 0x19F8,
0x0CFC, 0x067E, 0x033F, 0x019F };
// signedValues contain signed representations of the unsignedValues,
// considering that the bit lengths is cut every time. For example,
// unsingedValues[1] contain 1 in its 14'th bit (starting from 0), so it
// must be treated as a negative value.
static constexpr qint16 signedValues[] = { -12345, -6173, -3087, -1544,
-772, -386, -193, -97 };
for (quint16 i = 0; i < 8; ++i) {
// shift, to change start bit
quint32 valueForPayload = qToLittleEndian(unsignedValues[i]) << i;
const QByteArray expectedPayload(reinterpret_cast<const char*>(&valueForPayload),
sizeof(quint32));
QTest::addRow("int, le, from %d, length %d", i, 16 - i)
<< expectedPayload << i << quint16(16 - i)
<< QtCanBus::DataFormat::SignedInteger
<< QtCanBus::DataEndian::LittleEndian
<< QVariant(signedValues[i]);
QTest::addRow("uint, le, from %d, length %d", i, 16 - i)
<< expectedPayload << i << quint16(16 - i)
<< QtCanBus::DataFormat::UnsignedInteger
<< QtCanBus::DataEndian::LittleEndian
<< QVariant(unsignedValues[i]);
const quint16 beValue = qToBigEndian(unsignedValues[i]);
const uchar *beValueData = reinterpret_cast<const uchar *>(&beValue);
quint32 beValueForPayload = (beValueData[0] << i) + (beValueData[1] << 8);
const QByteArray expectedBePayload(reinterpret_cast<const char*>(&beValueForPayload),
sizeof(quint32));
QTest::addRow("int, be, from %d, length %d", i, 16 - i)
<< expectedBePayload << i << quint16(16 - i)
<< QtCanBus::DataFormat::SignedInteger
<< QtCanBus::DataEndian::BigEndian
<< QVariant(signedValues[i]);
QTest::addRow("uint, be, from %d, length %d", i, 16 - i)
<< expectedBePayload << i << quint16(16 - i)
<< QtCanBus::DataFormat::UnsignedInteger
<< QtCanBus::DataEndian::BigEndian
<< QVariant(unsignedValues[i]);
}
// float, LE/BE, variable start
const float floatVal = 123.456f;
for (quint16 i = 0; i < 8; ++i) {
quint64 valueForPayload = 0;
const float leFloatVal = qToLittleEndian(floatVal);
memcpy(&valueForPayload, &leFloatVal, sizeof(float));
valueForPayload = valueForPayload << i;
const QByteArray expectedPayload(reinterpret_cast<const char*>(&valueForPayload),
sizeof(quint64));
QTest::addRow("float, le, from %d", i)
<< expectedPayload << i << quint16(32)
<< QtCanBus::DataFormat::Float
<< QtCanBus::DataEndian::LittleEndian
<< QVariant(floatVal);
valueForPayload = 0;
const float beFloatVal = qToBigEndian(floatVal);
memcpy(&valueForPayload, &beFloatVal, sizeof(float));
valueForPayload = valueForPayload << i;
const QByteArray expectedBePayload(reinterpret_cast<const char*>(&valueForPayload),
sizeof(quint64));
QTest::addRow("float, be, from %d", i)
<< expectedBePayload << i << quint16(32)
<< QtCanBus::DataFormat::Float
<< QtCanBus::DataEndian::BigEndian
<< QVariant(floatVal);
}
// double, LE/BE
{
const double doubleVal = 1.234e-15;
const double leDoubleVal = qToLittleEndian(doubleVal);
const QByteArray expectedPayload(reinterpret_cast<const char*>(&leDoubleVal),
sizeof(double));
QTest::addRow("double, le")
<< expectedPayload << quint16(0) << quint16(64)
<< QtCanBus::DataFormat::Double
<< QtCanBus::DataEndian::LittleEndian
<< QVariant(doubleVal);
const double beDoubleVal = qToBigEndian(doubleVal);
const QByteArray expectedBePayload(reinterpret_cast<const char*>(&beDoubleVal),
sizeof(double));
QTest::addRow("double, be")
<< expectedBePayload << quint16(0) << quint16(64)
<< QtCanBus::DataFormat::Double
<< QtCanBus::DataEndian::BigEndian
<< QVariant(doubleVal);
}
// ASCII
{
const QByteArray expectedData("abc", 3);
const quint16 offset = 8; // start from the 2nd byte
for (quint16 i = 0; i < 8; ++i) {
quint64 valueForPayload = 0;
memcpy(&valueForPayload, expectedData.constData(), expectedData.size());
valueForPayload = valueForPayload << (offset + i);
const QByteArray payload(reinterpret_cast<const char *>(&valueForPayload),
sizeof(quint64));
QTest::addRow("ascii, offset %d", offset + i)
<< payload << quint16(offset + i) << quint16(expectedData.size() * 8)
<< QtCanBus::DataFormat::Ascii
<< QtCanBus::DataEndian::LittleEndian
<< QVariant(expectedData);
}
}
}
void tst_QCanFrameProcessor::parseSignalFromPayload()
{
QFETCH(QByteArray, payload);
QFETCH(quint16, startBit);
QFETCH(quint16, bitLength);
QFETCH(QtCanBus::DataFormat, format);
QFETCH(QtCanBus::DataEndian, endian);
QFETCH(QVariant, expectedValue);
QCanSignalDescription sig;
sig.setName("test_signal");
sig.setDataFormat(format);
sig.setDataEndian(endian);
sig.setStartBit(startBit);
sig.setBitLength(bitLength);
QVERIFY(sig.isValid());
const QtCanBus::UniqueId uniqueId = 123;
QCanMessageDescription message;
message.setName("test_message");
message.setUniqueId(uniqueId);
message.setSize(payload.size());
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(uniqueId, payload);
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::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(0);
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(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(0);
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(2);
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(2);
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(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(QtCanBus::DataEndian::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(QtCanBus::DataEndian::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(QtCanBus::DataEndian::LittleEndian);
s2.setStartBit(4);
s2.setBitLength(12);
s2.setMultiplexState(QtCanBus::MultiplexState::MultiplexedSignal);
const QCanSignalDescription::MultiplexValues muxValuesS0 { qMakePair(2, 4) };
s2.addMultiplexSignal(s0.name(), muxValuesS0);
QCanSignalDescription s3; // depends on mux2 (so indirectly on mux1)
s3.setName("s3");
s3.setDataEndian(QtCanBus::DataEndian::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(QtCanBus::DataEndian::LittleEndian);
s4.setStartBit(8);
s4.setBitLength(8);
s4.setMultiplexState(QtCanBus::MultiplexState::MultiplexedSignal);
const QCanSignalDescription::MultiplexValues muxValuesS1 { qMakePair(2, 3), qMakePair(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(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::DecodingError
<< 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::DecodingError
<< 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::DecodingError
<< tr("Could not find a message description for unique id 123.")
<< QStringList() << QtCanBus::UniqueId(0) << QVariantMap();
QCanSignalDescription signalDesc;
signalDesc.setName("s0");
signalDesc.setStartBit(0);
signalDesc.setBitLength(16);
QCanMessageDescription messageDesc;
messageDesc.setName("testMessage");
messageDesc.setUniqueId(123);
messageDesc.setSize(2);
messageDesc.addSignalDescription(signalDesc);
QTest::addRow("Invalid payload size")
<< messageDesc << uidDesc
<< QCanBusFrame(123, QByteArray(8, 0x01))
<< QCanFrameProcessor::Error::DecodingError
<< 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(16);
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::NoError << QString()
<< expectedWarnings << QtCanBus::UniqueId(123)
<< QVariantMap({ qMakePair("s0", 0x0101) });
// other valid signal
signalDesc.setName("s1");
signalDesc.setStartBit(32);
signalDesc.setBitLength(8);
messageDesc.addSignalDescription(signalDesc);
// valid signal, but length exceeds frame length
signalDesc.setName("tooLong");
signalDesc.setStartBit(40);
signalDesc.setBitLength(32);
messageDesc.addSignalDescription(signalDesc);
expectedWarnings.push_back(tr("Skipping signal tooLong in message with unique id 123. "
"Its start + length exceeds 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::NoError << QString()
<< expectedWarnings << QtCanBus::UniqueId(123)
<< QVariantMap({ qMakePair("s0", 0x0101), qMakePair("s1", 0x01) });
}
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 QtCanBus::UniqueId uniqueIdLe = 0x0965;
const QtCanBus::UniqueId uniqueIdBe = 0x0596;
for (quint16 startBit = 0; startBit < 8; ++startBit) {
uidDesc.setStartBit(startBit);
uidDesc.setEndian(QtCanBus::DataEndian::LittleEndian);
const QCanBusFrame::FrameId frameId = qToLittleEndian(uniqueIdLe) << startBit;
QTest::addRow("frameId, LE, offset %d", startBit)
<< uidDesc
<< QCanBusFrame(frameId, QByteArray(1, 0x01))
<< uniqueIdLe;
uidDesc.setEndian(QtCanBus::DataEndian::BigEndian);
QTest::addRow("frameId, BE, offset %d", startBit)
<< uidDesc
<< QCanBusFrame(frameId, QByteArray(1, 0x01))
<< uniqueIdBe;
}
// 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(QtCanBus::DataEndian::LittleEndian);
const quint32 payload = 0x01 | (qToLittleEndian(uniqueIdLe) << startBit);
const QByteArray payloadData(reinterpret_cast<const char *>(&payload), sizeof(payload));
QTest::addRow("payload, LE, offset %d", startBit)
<< uidDesc
<< QCanBusFrame(0, payloadData)
<< uniqueIdLe;
uidDesc.setEndian(QtCanBus::DataEndian::BigEndian);
QTest::addRow("payload, BE, offset %d", startBit)
<< uidDesc
<< QCanBusFrame(0, payloadData)
<< uniqueIdBe;
}
}
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(0);
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::prepareFrameId_data()
{
QTest::addColumn<quint32>("initialFrameId");
QTest::addColumn<quint16>("startBit");
QTest::addColumn<quint16>("bitLength");
QTest::addColumn<QtCanBus::DataFormat>("format");
QTest::addColumn<QtCanBus::DataEndian>("endian");
QTest::addColumn<QVariant>("signalValue");
QTest::addColumn<quint32>("expectedFrameId");
const quint32 initialFrameId = 1;
// Every next value in the list is supposed to have a length in bits cut
// by one.
static constexpr quint16 leValues[] = { 0xCFC7, 0x67E3, 0x33F1, 0x19F8,
0x0CFC, 0x067E, 0x033F, 0x019F };
const quint16 startIdx = 4;
for (quint16 i = 0; i < 8; ++i) {
quint32 expectedFrameId = (leValues[i] << (startIdx + i)) | initialFrameId;
QTest::addRow("int, le, start %d, length %d", (startIdx + i), 16 - i)
<< initialFrameId << quint16(startIdx + i) << quint16(16 - i)
<< QtCanBus::DataFormat::SignedInteger
<< QtCanBus::DataEndian::LittleEndian
<< QVariant(static_cast<qint16>(leValues[i]))
<< expectedFrameId;
QTest::addRow("uint, le, start %d, length %d", (startIdx + i), 16 - i)
<< initialFrameId << quint16(startIdx + i) << quint16(16 - i)
<< QtCanBus::DataFormat::UnsignedInteger
<< QtCanBus::DataEndian::LittleEndian
<< QVariant(leValues[i])
<< expectedFrameId;
const uchar *leValueData = reinterpret_cast<const uchar *>(&leValues[i]);
const quint16 beValue = (0x00FF & (leValueData[1] << i)) + (leValueData[0] << 8);
expectedFrameId = (beValue << startIdx) | initialFrameId;
QTest::addRow("int, be, start %d, length %d", (startIdx + i), 16 - i)
<< initialFrameId << quint16(startIdx + i) << quint16(16 - i)
<< QtCanBus::DataFormat::SignedInteger
<< QtCanBus::DataEndian::BigEndian
<< QVariant(static_cast<qint16>(leValues[i]))
<< expectedFrameId;
QTest::addRow("uint, be, start %d, length %d", (startIdx + i), 16 - i)
<< initialFrameId << quint16(startIdx + i) << quint16(16 - i)
<< QtCanBus::DataFormat::UnsignedInteger
<< QtCanBus::DataEndian::BigEndian
<< QVariant(leValues[i])
<< expectedFrameId;
}
}
void tst_QCanFrameProcessor::prepareFrameId()
{
QFETCH(quint32, initialFrameId);
QFETCH(quint16, startBit);
QFETCH(quint16, bitLength);
QFETCH(QtCanBus::DataFormat, format);
QFETCH(QtCanBus::DataEndian, endian);
QFETCH(QVariant, signalValue);
QFETCH(quint32, expectedFrameId);
QCanSignalDescription signalDesc;
signalDesc.setName("s0");
signalDesc.setDataSource(QtCanBus::DataSource::FrameId);
signalDesc.setDataFormat(format);
signalDesc.setDataEndian(endian);
signalDesc.setStartBit(startBit);
signalDesc.setBitLength(bitLength);
QCanUniqueIdDescription uidDesc;
uidDesc.setBitLength(4); // see the test data -> first 4 bits never change
QCanMessageDescription messageDesc;
messageDesc.setUniqueId(initialFrameId);
messageDesc.setSize(0);
messageDesc.addSignalDescription(signalDesc);
const QVariantMap signalValues = { qMakePair(signalDesc.name(), signalValue) };
QCanFrameProcessor processor;
processor.setUniqueIdDescription(uidDesc);
processor.addMessageDescriptions({ messageDesc });
const QCanBusFrame frame = processor.prepareFrame(initialFrameId, signalValues);
QVERIFY(frame.isValid());
QCOMPARE(frame.frameId(), expectedFrameId);
}
void tst_QCanFrameProcessor::preparePayload_data()
{
QTest::addColumn<quint16>("startBit");
QTest::addColumn<quint16>("bitLength");
QTest::addColumn<QtCanBus::DataFormat>("format");
QTest::addColumn<QtCanBus::DataEndian>("endian");
QTest::addColumn<QVariant>("signalValue");
QTest::addColumn<QByteArray>("expectedPayload");
// (u)int, LE/BE, variable length and start
// Every next value in the list is supposed to have a length in bits cut
// by one.
static constexpr quint16 leValues[] = { 0xCFC7, 0x67E3, 0x33F1, 0x19F8,
0x0CFC, 0x067E, 0x033F, 0x019F };
const quint16 startIdx = 4;
for (quint16 i = 0; i < 8; ++i) {
quint32 expectedPayloadData = (leValues[i] << (startIdx + i));
QByteArray expectedPayload(reinterpret_cast<const char *>(&expectedPayloadData),
sizeof(quint32));
QTest::addRow("int, le, start %d, length %d", (startIdx + i), 16 - i)
<< quint16(startIdx + i) << quint16(16 - i)
<< QtCanBus::DataFormat::SignedInteger
<< QtCanBus::DataEndian::LittleEndian
<< QVariant(static_cast<qint16>(leValues[i]))
<< expectedPayload;
QTest::addRow("uint, le, start %d, length %d", (startIdx + i), 16 - i)
<< quint16(startIdx + i) << quint16(16 - i)
<< QtCanBus::DataFormat::UnsignedInteger
<< QtCanBus::DataEndian::LittleEndian
<< QVariant(leValues[i])
<< expectedPayload;
const quint16 beValue = qToBigEndian(leValues[i]);
const uchar *beValueData = reinterpret_cast<const uchar *>(&beValue);
quint32 beValueForPayload = ((beValueData[0] << i) + (beValueData[1] << 8)) << startIdx;
expectedPayload = QByteArray(reinterpret_cast<const char*>(&beValueForPayload),
sizeof(quint32));
QTest::addRow("int, be, start %d, length %d", (startIdx + i), 16 - i)
<< quint16(startIdx + i) << quint16(16 - i)
<< QtCanBus::DataFormat::SignedInteger
<< QtCanBus::DataEndian::BigEndian
<< QVariant(static_cast<qint16>(leValues[i]))
<< expectedPayload;
QTest::addRow("uint, be, start %d, length %d", (startIdx + i), 16 - i)
<< quint16(startIdx + i) << quint16(16 - i)
<< QtCanBus::DataFormat::UnsignedInteger
<< QtCanBus::DataEndian::BigEndian
<< QVariant(leValues[i])
<< expectedPayload;
}
// float, LE/BE, variable start
const float floatVal = 123.456f;
for (quint16 i = 0; i < 8; ++i) {
quint64 valueForPayload = 0;
const float leFloatVal = qToLittleEndian(floatVal);
memcpy(&valueForPayload, &leFloatVal, sizeof(float));
valueForPayload = valueForPayload << i;
QByteArray expectedPayload(reinterpret_cast<const char*>(&valueForPayload),
sizeof(quint64));
QTest::addRow("float, le, from %d", i)
<< i << quint16(32)
<< QtCanBus::DataFormat::Float
<< QtCanBus::DataEndian::LittleEndian
<< QVariant(floatVal)
<< expectedPayload;
valueForPayload = 0;
const float beFloatVal = qToBigEndian(floatVal);
memcpy(&valueForPayload, &beFloatVal, sizeof(float));
valueForPayload = valueForPayload << i;
expectedPayload = QByteArray(reinterpret_cast<const char*>(&valueForPayload),
sizeof(quint64));
QTest::addRow("float, be, from %d", i)
<< i << quint16(32)
<< QtCanBus::DataFormat::Float
<< QtCanBus::DataEndian::BigEndian
<< QVariant(floatVal)
<< expectedPayload;
}
// double, LE/BE
{
const double doubleVal = 1.234e-15;
const double leDoubleVal = qToLittleEndian(doubleVal);
QByteArray expectedPayload(reinterpret_cast<const char*>(&leDoubleVal), sizeof(double));
QTest::addRow("double, le")
<< quint16(0) << quint16(64)
<< QtCanBus::DataFormat::Double
<< QtCanBus::DataEndian::LittleEndian
<< QVariant(doubleVal)
<< expectedPayload;
const double beDoubleVal = qToBigEndian(doubleVal);
expectedPayload = QByteArray(reinterpret_cast<const char*>(&beDoubleVal),
sizeof(double));
QTest::addRow("double, be")
<< quint16(0) << quint16(64)
<< QtCanBus::DataFormat::Double
<< QtCanBus::DataEndian::BigEndian
<< QVariant(doubleVal)
<< expectedPayload;
}
// ASCII
{
const QByteArray expectedData("abc", 3);
const quint16 offset = 8; // start from the 2nd byte
for (quint16 i = 0; i < 8; ++i) {
quint64 valueForPayload = 0;
memcpy(&valueForPayload, expectedData.constData(), expectedData.size());
valueForPayload = valueForPayload << (offset + i);
const QByteArray payload(reinterpret_cast<const char *>(&valueForPayload),
sizeof(quint64));
QTest::addRow("ascii, offset %d", offset + i)
<< quint16(offset + i) << quint16(expectedData.size() * 8)
<< QtCanBus::DataFormat::Ascii
<< QtCanBus::DataEndian::LittleEndian
<< QVariant(expectedData)
<< payload;
}
}
// ASCII - not enough data
{
const QByteArray data("ab", 2);
QByteArray expectedPayload = data;
expectedPayload.push_back('\0'); // ab\0
QTest::addRow("ascii, not enough data")
<< quint16(0) << quint16(expectedPayload.size() * 8)
<< QtCanBus::DataFormat::Ascii
<< QtCanBus::DataEndian::LittleEndian
<< QVariant(data)
<< expectedPayload;
}
// ASCII - too much data
{
const QByteArray data("abcd", 4);
const QByteArray expectedPayload = data.left(3); // abc
QTest::addRow("ascii, too much data")
<< quint16(0) << quint16(expectedPayload.size() * 8)
<< QtCanBus::DataFormat::Ascii
<< QtCanBus::DataEndian::LittleEndian
<< QVariant(data)
<< expectedPayload;
}
}
void tst_QCanFrameProcessor::preparePayload()
{
QFETCH(quint16, startBit);
QFETCH(quint16, bitLength);
QFETCH(QtCanBus::DataFormat, format);
QFETCH(QtCanBus::DataEndian, endian);
QFETCH(QVariant, signalValue);
QFETCH(QByteArray, expectedPayload);
QCanSignalDescription signalDesc;
signalDesc.setName("s0");
signalDesc.setDataFormat(format);
signalDesc.setDataEndian(endian);
signalDesc.setStartBit(startBit);
signalDesc.setBitLength(bitLength);
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(), uniqueId);
QCOMPARE(frame.payload(), expectedPayload);
}
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(0);
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(), 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(QtCanBus::DataEndian::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(QtCanBus::DataEndian::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(QtCanBus::DataEndian::LittleEndian);
s2.setStartBit(4);
s2.setBitLength(12);
s2.setMultiplexState(QtCanBus::MultiplexState::MultiplexedSignal);
const QCanSignalDescription::MultiplexValues muxValuesS0 { qMakePair(2, 4) };
s2.addMultiplexSignal(s0.name(), muxValuesS0);
QCanSignalDescription s3; // depends on mux2 (so indirectly on mux1)
s3.setName("s3");
s3.setDataEndian(QtCanBus::DataEndian::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(QtCanBus::DataEndian::LittleEndian);
s4.setStartBit(8);
s4.setBitLength(8);
s4.setMultiplexState(QtCanBus::MultiplexState::MultiplexedSignal);
const QCanSignalDescription::MultiplexValues muxValuesS1 { qMakePair(2, 3), qMakePair(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(), 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::EncodingError
<< 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::EncodingError
<< tr("Failed to find message description for unique id 123.")
<< QStringList() << QCanBusFrame::FrameId(0) << QByteArray();
QCanSignalDescription signalDesc;
signalDesc.setName("s0");
signalDesc.setStartBit(0);
signalDesc.setBitLength(4);
QCanMessageDescription messageDesc;
messageDesc.setUniqueId(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::EncodingError
<< 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::NoError << QString()
<< warnings << QCanBusFrame::FrameId(messageDesc.uniqueId())
<< QByteArray::fromHex("0100");
// invalid signal desc - 0 length
signalDesc.setName("s2");
signalDesc.setStartBit(4);
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::NoError << QString()
<< warnings << QCanBusFrame::FrameId(messageDesc.uniqueId())
<< QByteArray::fromHex("0100");
// start + length exceed data length
signalDesc.setName("s3");
signalDesc.setStartBit(8);
signalDesc.setBitLength(10);
messageDesc.addSignalDescription(signalDesc);
warnings.push_back(tr("Skipping signal s3. Its start + 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::NoError << 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(0);
signalDesc.setBitLength(4);
messageDesc.addSignalDescription(signalDesc);
// s1 is used only when s0 is in range [2, 4] or 6
signalDesc.setName("s1");
signalDesc.setStartBit(4);
signalDesc.setBitLength(12);
signalDesc.setMultiplexState(QtCanBus::MultiplexState::MultiplexedSignal);
const QCanSignalDescription::MultiplexValues muxValuesS0 { qMakePair(2, 4), qMakePair(6, 6) };
signalDesc.addMultiplexSignal("s0", muxValuesS0);
messageDesc.addSignalDescription(signalDesc);
// second multiplexor, used when s0 == 1
signalDesc.setName("s2");
signalDesc.setStartBit(4);
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(8);
signalDesc.setBitLength(8);
signalDesc.setMultiplexState(QtCanBus::MultiplexState::MultiplexedSignal);
signalDesc.addMultiplexSignal("s0", 1);
const QCanSignalDescription::MultiplexValues muxValuesS2 { qMakePair(1, 3), qMakePair(5, 6) };
signalDesc.addMultiplexSignal("s2", muxValuesS2);
messageDesc.addSignalDescription(signalDesc);
// s4 depends on two multiplexors
signalDesc.setName("s4");
signalDesc.setStartBit(8);
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("Skipped signal s1. Proper multiplexor values not found."));
warnings.push_back(tr("Skipped 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::NoError << QString()
<< warnings << QCanBusFrame::FrameId(messageDesc.uniqueId())
<< QByteArray::fromHex("2105");
}
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 QtCanBus::UniqueId uniqueIdLe = 0x0965;
const QtCanBus::UniqueId uniqueIdBe = 0x0596;
QCanSignalDescription signalDesc;
signalDesc.setName("s0");
signalDesc.setDataSource(QtCanBus::DataSource::Payload);
signalDesc.setDataEndian(QtCanBus::DataEndian::LittleEndian);
signalDesc.setDataFormat(QtCanBus::DataFormat::UnsignedInteger);
signalDesc.setStartBit(0);
signalDesc.setBitLength(8);
QCanMessageDescription messageDesc;
messageDesc.setName("test");
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) {
messageDesc.setUniqueId(uniqueIdLe);
uidDesc.setStartBit(startBit);
uidDesc.setEndian(QtCanBus::DataEndian::LittleEndian);
const QCanBusFrame::FrameId frameId = qFromLittleEndian(uniqueIdLe) << startBit;
QTest::addRow("frameId, LE, offser %d", startBit)
<< uidDesc << messageDesc << uniqueIdLe << signalValues
<< QCanBusFrame(frameId, QByteArray(1, 0x01));
messageDesc.setUniqueId(uniqueIdBe);
uidDesc.setEndian(QtCanBus::DataEndian::BigEndian);
QTest::addRow("frameId, BE, offser %d", startBit)
<< uidDesc << messageDesc << uniqueIdBe << 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) {
messageDesc.setUniqueId(uniqueIdLe);
uidDesc.setStartBit(startBit);
uidDesc.setEndian(QtCanBus::DataEndian::LittleEndian);
const quint32 payload = 0x01 | qFromLittleEndian(uniqueIdLe) << startBit;
const QByteArray payloadData(reinterpret_cast<const char *>(&payload), sizeof(payload));
QTest::addRow("payload, LE, offser %d", startBit)
<< uidDesc << messageDesc << uniqueIdLe << signalValues
<< QCanBusFrame(0, payloadData);
messageDesc.setUniqueId(uniqueIdBe);
uidDesc.setEndian(QtCanBus::DataEndian::BigEndian);
QTest::addRow("payload, BE, offser %d", startBit)
<< uidDesc << messageDesc << uniqueIdBe << 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::NoError);
QCOMPARE(result.frameId(), expectedFrame.frameId());
QCOMPARE(result.payload(), expectedFrame.payload());
}
QTEST_MAIN(tst_QCanFrameProcessor)
#include "tst_qcanframeprocessor.moc"