| /**************************************************************************** |
| ** |
| ** Copyright (C) 2017 The Qt Company Ltd. |
| ** Contact: http://www.qt.io/licensing/ |
| ** |
| ** This file is part of the QtSerialBus module of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL3$ |
| ** Commercial License Usage |
| ** Licensees holding valid commercial Qt licenses may use this file in |
| ** accordance with the commercial license agreement provided with the |
| ** Software or, alternatively, in accordance with the terms contained in |
| ** a written agreement between you and The Qt Company. For licensing terms |
| ** and conditions see http://www.qt.io/terms-conditions. For further |
| ** information use the contact form at http://www.qt.io/contact-us. |
| ** |
| ** GNU Lesser General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU Lesser |
| ** General Public License version 3 as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.LGPLv3 included in the |
| ** packaging of this file. Please review the following information to |
| ** ensure the GNU Lesser General Public License version 3 requirements |
| ** will be met: https://www.gnu.org/licenses/lgpl.html. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU |
| ** General Public License version 2.0 or later as published by the Free |
| ** Software Foundation and appearing in the file LICENSE.GPL included in |
| ** the packaging of this file. Please review the following information to |
| ** ensure the GNU General Public License version 2.0 requirements will be |
| ** met: http://www.gnu.org/licenses/gpl-2.0.html. |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| #include <QtSerialBus/qcanbusframe.h> |
| |
| #include <QtCore/qdatastream.h> |
| #include <QtTest/qtest.h> |
| |
| class tst_QCanBusFrame : public QObject |
| { |
| Q_OBJECT |
| public: |
| explicit tst_QCanBusFrame(); |
| |
| private slots: |
| void constructors(); |
| void id(); |
| void payload(); |
| void timeStamp(); |
| void bitRateSwitch(); |
| void errorStateIndicator(); |
| void localEcho(); |
| |
| void tst_isValid_data(); |
| void tst_isValid(); |
| void tst_isValidSize_data(); |
| void tst_isValidSize(); |
| |
| void tst_toString_data(); |
| void tst_toString(); |
| |
| void streaming_data(); |
| void streaming(); |
| |
| void tst_error(); |
| }; |
| |
| tst_QCanBusFrame::tst_QCanBusFrame() |
| { |
| } |
| |
| void tst_QCanBusFrame::constructors() |
| { |
| QCanBusFrame frame1; |
| QCanBusFrame frame2(123, "tst"); |
| QCanBusFrame frame3(123456, "tst"); |
| QCanBusFrame frame4(1234, "tst tst tst"); |
| QCanBusFrame::TimeStamp timeStamp1; |
| QCanBusFrame::TimeStamp timeStamp2(5, 5); |
| |
| QVERIFY(frame1.payload().isEmpty()); |
| QVERIFY(!frame1.frameId()); |
| QVERIFY(!frame1.hasFlexibleDataRateFormat()); |
| QVERIFY(!frame1.hasExtendedFrameFormat()); |
| QCOMPARE(frame1.frameType(), QCanBusFrame::DataFrame); |
| |
| QVERIFY(!frame2.payload().isEmpty()); |
| QVERIFY(frame2.frameId()); |
| QVERIFY(!frame2.hasFlexibleDataRateFormat()); |
| QVERIFY(!frame2.hasExtendedFrameFormat()); |
| QCOMPARE(frame2.frameType(), QCanBusFrame::DataFrame); |
| |
| QVERIFY(!frame3.payload().isEmpty()); |
| QVERIFY(frame3.frameId()); |
| QVERIFY(!frame3.hasFlexibleDataRateFormat()); |
| QVERIFY(frame3.hasExtendedFrameFormat()); |
| QCOMPARE(frame3.frameType(), QCanBusFrame::DataFrame); |
| |
| QVERIFY(!frame4.payload().isEmpty()); |
| QVERIFY(frame4.frameId()); |
| QVERIFY(frame4.hasFlexibleDataRateFormat()); |
| QVERIFY(!frame4.hasExtendedFrameFormat()); |
| QCOMPARE(frame4.frameType(), QCanBusFrame::DataFrame); |
| |
| QVERIFY(!timeStamp1.seconds()); |
| QVERIFY(!timeStamp1.microSeconds()); |
| |
| QVERIFY(timeStamp2.seconds()); |
| QVERIFY(timeStamp2.microSeconds()); |
| } |
| |
| void tst_QCanBusFrame::id() |
| { |
| QCanBusFrame frame; |
| QVERIFY(!frame.frameId()); |
| frame.setExtendedFrameFormat(false); |
| frame.setFrameId(2047u); |
| QCOMPARE(frame.frameId(), 2047u); |
| QVERIFY(frame.isValid()); |
| QVERIFY(!frame.hasExtendedFrameFormat()); |
| // id > 2^11 -> extended format |
| frame.setExtendedFrameFormat(false); |
| frame.setFrameId(2048u); |
| QCOMPARE(frame.frameId(), 2048u); |
| QVERIFY(frame.isValid()); |
| QVERIFY(frame.hasExtendedFrameFormat()); |
| // id < 2^11 -> no extended format |
| frame.setExtendedFrameFormat(false); |
| frame.setFrameId(512u); |
| QCOMPARE(frame.frameId(), 512u); |
| QVERIFY(frame.isValid()); |
| QVERIFY(!frame.hasExtendedFrameFormat()); |
| // id < 2^11 -> keep extended format |
| frame.setExtendedFrameFormat(true); |
| frame.setFrameId(512u); |
| QCOMPARE(frame.frameId(), 512u); |
| QVERIFY(frame.isValid()); |
| QVERIFY(frame.hasExtendedFrameFormat()); |
| // id >= 2^29 -> invalid |
| frame.setExtendedFrameFormat(false); |
| frame.setFrameId(536870912u); |
| QCOMPARE(frame.frameId(), 0u); |
| QVERIFY(!frame.isValid()); |
| QVERIFY(!frame.hasExtendedFrameFormat()); |
| } |
| |
| void tst_QCanBusFrame::payload() |
| { |
| QCanBusFrame frame; |
| QVERIFY(frame.payload().isEmpty()); |
| frame.setPayload("test"); |
| QCOMPARE(frame.payload().data(), "test"); |
| QVERIFY(!frame.hasFlexibleDataRateFormat()); |
| // setting long payload should automatically set hasFlexibleDataRateFormat() |
| frame.setPayload("testtesttest"); |
| QCOMPARE(frame.payload().data(), "testtesttest"); |
| QVERIFY(frame.hasFlexibleDataRateFormat()); |
| // setting short payload should not change hasFlexibleDataRateFormat() |
| frame.setPayload("test"); |
| QCOMPARE(frame.payload().data(), "test"); |
| QVERIFY(frame.hasFlexibleDataRateFormat()); |
| } |
| |
| void tst_QCanBusFrame::timeStamp() |
| { |
| QCanBusFrame frame; |
| QCanBusFrame::TimeStamp timeStamp = frame.timeStamp(); |
| QVERIFY(!timeStamp.seconds()); |
| QVERIFY(!timeStamp.microSeconds()); |
| |
| // fromMicroSeconds: no microsecond overflow |
| timeStamp = QCanBusFrame::TimeStamp::fromMicroSeconds(999999); |
| QCOMPARE(timeStamp.seconds(), 0); |
| QCOMPARE(timeStamp.microSeconds(), 999999); |
| |
| // fromMicroSeconds: microsecond overflow |
| timeStamp = QCanBusFrame::TimeStamp::fromMicroSeconds(1000000); |
| QCOMPARE(timeStamp.seconds(), 1); |
| QCOMPARE(timeStamp.microSeconds(), 0); |
| |
| // fromMicroSeconds: microsecond overflow |
| timeStamp = QCanBusFrame::TimeStamp::fromMicroSeconds(2000001); |
| QCOMPARE(timeStamp.seconds(), 2); |
| QCOMPARE(timeStamp.microSeconds(), 1); |
| } |
| |
| void tst_QCanBusFrame::bitRateSwitch() |
| { |
| QCanBusFrame frame(QCanBusFrame::DataFrame); |
| QVERIFY(!frame.hasBitrateSwitch()); |
| |
| // set CAN FD does not set BRS |
| frame.setFlexibleDataRateFormat(true); |
| QVERIFY(frame.hasFlexibleDataRateFormat()); |
| QVERIFY(!frame.hasBitrateSwitch()); |
| |
| // set BRS keeps CAN FD |
| frame.setBitrateSwitch(true); |
| QVERIFY(frame.hasFlexibleDataRateFormat()); |
| QVERIFY(frame.hasBitrateSwitch()); |
| |
| // clear BRS keeps CAN FD |
| frame.setBitrateSwitch(false); |
| QVERIFY(frame.hasFlexibleDataRateFormat()); |
| QVERIFY(!frame.hasBitrateSwitch()); |
| |
| // clear CAN FD |
| frame.setFlexibleDataRateFormat(false); |
| QVERIFY(!frame.hasFlexibleDataRateFormat()); |
| QVERIFY(!frame.hasBitrateSwitch()); |
| |
| // set BRS sets CAN FD |
| frame.setBitrateSwitch(true); |
| QVERIFY(frame.hasFlexibleDataRateFormat()); |
| QVERIFY(frame.hasBitrateSwitch()); |
| |
| // clear CAN FD clears BRS |
| frame.setFlexibleDataRateFormat(false); |
| QVERIFY(!frame.hasFlexibleDataRateFormat()); |
| QVERIFY(!frame.hasBitrateSwitch()); |
| |
| // default constructed CAN FD frame has no BRS |
| const QCanBusFrame frame2(0x123, QByteArray(10, 0x55)); |
| QVERIFY(frame2.hasFlexibleDataRateFormat()); |
| QVERIFY(!frame2.hasBitrateSwitch()); |
| } |
| |
| void tst_QCanBusFrame::errorStateIndicator() |
| { |
| QCanBusFrame frame(QCanBusFrame::DataFrame); |
| QVERIFY(!frame.hasErrorStateIndicator()); |
| |
| // set CAN FD does not set ESI |
| frame.setFlexibleDataRateFormat(true); |
| QVERIFY(frame.hasFlexibleDataRateFormat()); |
| QVERIFY(!frame.hasErrorStateIndicator()); |
| |
| // set ESI keeps CAN FD |
| frame.setErrorStateIndicator(true); |
| QVERIFY(frame.hasFlexibleDataRateFormat()); |
| QVERIFY(frame.hasErrorStateIndicator()); |
| |
| // clear ESI keeps CAN FD |
| frame.setErrorStateIndicator(false); |
| QVERIFY(frame.hasFlexibleDataRateFormat()); |
| QVERIFY(!frame.hasErrorStateIndicator()); |
| |
| // clear CAN FD |
| frame.setFlexibleDataRateFormat(false); |
| QVERIFY(!frame.hasFlexibleDataRateFormat()); |
| QVERIFY(!frame.hasErrorStateIndicator()); |
| |
| // set ESI sets CAN FD |
| frame.setErrorStateIndicator(true); |
| QVERIFY(frame.hasFlexibleDataRateFormat()); |
| QVERIFY(frame.hasErrorStateIndicator()); |
| |
| // clear CAN FD clears ESI |
| frame.setFlexibleDataRateFormat(false); |
| QVERIFY(!frame.hasFlexibleDataRateFormat()); |
| QVERIFY(!frame.hasErrorStateIndicator()); |
| |
| // default constructed CAN FD frame has no ESI |
| const QCanBusFrame frame2(0x123, QByteArray(10, 0x55)); |
| QVERIFY(frame2.hasFlexibleDataRateFormat()); |
| QVERIFY(!frame2.hasErrorStateIndicator()); |
| } |
| |
| void tst_QCanBusFrame::localEcho() |
| { |
| QCanBusFrame frame(QCanBusFrame::DataFrame); |
| QVERIFY(!frame.hasLocalEcho()); |
| |
| frame.setLocalEcho(true); |
| QVERIFY(frame.hasLocalEcho()); |
| |
| frame.setLocalEcho(false); |
| QVERIFY(!frame.hasLocalEcho()); |
| |
| const QCanBusFrame frame2(0x123, QByteArray()); |
| QVERIFY(!frame2.hasLocalEcho()); |
| } |
| |
| void tst_QCanBusFrame::tst_isValid_data() |
| { |
| QTest::addColumn<QCanBusFrame::FrameType>("frameType"); |
| QTest::addColumn<bool>("isValid"); |
| QTest::addColumn<QByteArray>("payload"); |
| QTest::addColumn<uint>("id"); |
| QTest::addColumn<bool>("extended"); |
| QTest::addColumn<bool>("flexibleData"); |
| |
| QTest::newRow("invalid frame") |
| << QCanBusFrame::InvalidFrame << false |
| << QByteArray() << 0u << false << false; |
| QTest::newRow("data frame") |
| << QCanBusFrame::DataFrame << true |
| << QByteArray() << 0u << false << false; |
| QTest::newRow("error frame") |
| << QCanBusFrame::ErrorFrame << true |
| << QByteArray() << 0u << false << false; |
| QTest::newRow("remote request frame") |
| << QCanBusFrame::RemoteRequestFrame << true |
| << QByteArray() << 0u << false << false; |
| QTest::newRow("remote request CAN FD frame") |
| << QCanBusFrame::RemoteRequestFrame << false |
| << QByteArray() << 0u << false << true; |
| QTest::newRow("unknown frame") |
| << QCanBusFrame::UnknownFrame << true |
| << QByteArray() << 0u << false << false; |
| QTest::newRow("data frame CAN max payload") |
| << QCanBusFrame::DataFrame << true |
| << QByteArray(8, 0) << 0u << false << false; |
| QTest::newRow("data frame CAN FD max payload") |
| << QCanBusFrame::DataFrame << true |
| << QByteArray(64, 0) << 0u << false << true; |
| QTest::newRow("data frame CAN too much payload") |
| << QCanBusFrame::DataFrame << false |
| << QByteArray(65, 0) << 0u << false << false; |
| QTest::newRow("data frame short id") |
| << QCanBusFrame::DataFrame << true |
| << QByteArray(8, 0) << (1u << 11) - 1 << false << false; |
| QTest::newRow("data frame long id") |
| << QCanBusFrame::DataFrame << true |
| << QByteArray(8, 0) << (1u << 11) << true << false; |
| QTest::newRow("data frame bad long id") |
| << QCanBusFrame::DataFrame << false |
| << QByteArray(8, 0) << (1u << 11) << false << false; |
| QTest::newRow("data frame CAN too long payload") |
| << QCanBusFrame::DataFrame << false |
| << QByteArray(9, 0) << 512u << false << false; |
| QTest::newRow("data frame CAN FD long payload") |
| << QCanBusFrame::DataFrame << true |
| << QByteArray(12, 0) << 512u << false << true; |
| QTest::newRow("data frame CAN FD too long payload") |
| << QCanBusFrame::DataFrame << false |
| << QByteArray(65, 0) << 512u << false << true; |
| } |
| |
| void tst_QCanBusFrame::tst_isValid() |
| { |
| QFETCH(QCanBusFrame::FrameType, frameType); |
| QFETCH(bool, isValid); |
| QFETCH(QByteArray, payload); |
| QFETCH(uint, id); |
| QFETCH(bool, extended); |
| QFETCH(bool, flexibleData); |
| |
| QCanBusFrame frame(frameType); |
| frame.setPayload(payload); |
| frame.setFrameId(id); |
| frame.setExtendedFrameFormat(extended); |
| frame.setFlexibleDataRateFormat(flexibleData); |
| QCOMPARE(frame.isValid(), isValid); |
| QCOMPARE(frame.frameType(), frameType); |
| QCOMPARE(frame.payload(), payload); |
| QCOMPARE(frame.frameId(), id); |
| QCOMPARE(frame.hasExtendedFrameFormat(), extended); |
| QCOMPARE(frame.hasFlexibleDataRateFormat(), flexibleData); |
| |
| frame.setFrameType(QCanBusFrame::InvalidFrame); |
| QCOMPARE(frame.isValid(), false); |
| QCOMPARE(QCanBusFrame::InvalidFrame, frame.frameType()); |
| } |
| |
| void tst_QCanBusFrame::tst_isValidSize_data() |
| { |
| QTest::addColumn<int>("payloadLength"); |
| QTest::addColumn<bool>("isFlexibleDataRate"); |
| QTest::addColumn<bool>("isValid"); |
| |
| QTest::newRow("2.0-0") << 0 << false << true; |
| QTest::newRow("2.0-8") << 8 << false << true; |
| QTest::newRow("2.0-9") << 9 << false << false; |
| |
| QTest::newRow("FD-0") << 0 << true << true; |
| QTest::newRow("FD-8") << 8 << true << true; |
| QTest::newRow("FD-9") << 9 << true << false; |
| QTest::newRow("FD-11") << 11 << true << false; |
| QTest::newRow("FD-12") << 12 << true << true; |
| QTest::newRow("FD-13") << 13 << true << false; |
| QTest::newRow("FD-16") << 16 << true << true; |
| |
| QTest::newRow("FD-20") << 20 << true << true; |
| QTest::newRow("FD-24") << 24 << true << true; |
| QTest::newRow("FD-32") << 32 << true << true; |
| QTest::newRow("FD-48") << 48 << true << true; |
| |
| QTest::newRow("FD-63") << 63 << true << false; |
| QTest::newRow("FD-64") << 64 << true << true; |
| QTest::newRow("FD-65") << 65 << true << false; |
| } |
| |
| void tst_QCanBusFrame::tst_isValidSize() |
| { |
| QFETCH(int, payloadLength); |
| QFETCH(bool, isFlexibleDataRate); |
| QFETCH(bool, isValid); |
| |
| QCanBusFrame frame(0, QByteArray(payloadLength, ' ')); |
| frame.setFlexibleDataRateFormat(isFlexibleDataRate); |
| |
| QCOMPARE(frame.isValid(), isValid); |
| } |
| |
| void tst_QCanBusFrame::tst_toString_data() |
| { |
| QTest::addColumn<QCanBusFrame::FrameType>("frameType"); |
| QTest::addColumn<quint32>("id"); |
| QTest::addColumn<bool>("extended"); |
| QTest::addColumn<QByteArray>("payload"); |
| QTest::addColumn<QString>("expected"); |
| |
| QTest::newRow("invalid frame") |
| << QCanBusFrame::InvalidFrame << 0x0u << false |
| << QByteArray() |
| << "(Invalid)"; |
| QTest::newRow("error frame") |
| << QCanBusFrame::ErrorFrame << 0x0u << false |
| << QByteArray() |
| << "(Error)"; |
| QTest::newRow("unknown frame") |
| << QCanBusFrame::UnknownFrame << 0x0u << false |
| << QByteArray() |
| << "(Unknown)"; |
| QTest::newRow("remote request frame") |
| << QCanBusFrame::RemoteRequestFrame << 0x123u << false |
| << QByteArray::fromHex("01") // fake data to get a DLC > 0 |
| << QString(" 123 [1] Remote Request"); |
| QTest::newRow("data frame min std id") |
| << QCanBusFrame::DataFrame << 0x0u << false |
| << QByteArray() |
| << QString(" 000 [0]"); |
| QTest::newRow("data frame max std id") |
| << QCanBusFrame::DataFrame << 0x7FFu << false |
| << QByteArray() |
| << QString(" 7FF [0]"); |
| QTest::newRow("data frame min ext id") |
| << QCanBusFrame::DataFrame << 0x0u << true |
| << QByteArray() |
| << QString("00000000 [0]"); |
| QTest::newRow("data frame max ext id") |
| << QCanBusFrame::DataFrame << 0x1FFFFFFFu << true |
| << QByteArray() |
| << QString("1FFFFFFF [0]"); |
| QTest::newRow("data frame minimal size") |
| << QCanBusFrame::DataFrame << 0x7FFu << false |
| << QByteArray::fromHex("01") |
| << QString(" 7FF [1] 01"); |
| QTest::newRow("data frame maximal size") |
| << QCanBusFrame::DataFrame << 0x1FFFFFFFu << true |
| << QByteArray::fromHex("0123456789ABCDEF") |
| << QString("1FFFFFFF [8] 01 23 45 67 89 AB CD EF"); |
| QTest::newRow("short data frame FD") |
| << QCanBusFrame::DataFrame << 0x123u << false |
| << QByteArray::fromHex("001122334455667788") |
| << QString(" 123 [09] 00 11 22 33 44 55 66 77 88"); |
| QTest::newRow("long data frame FD") |
| << QCanBusFrame::DataFrame << 0x123u << false |
| << QByteArray::fromHex("00112233445566778899") |
| << QString(" 123 [10] 00 11 22 33 44 55 66 77 88 99"); |
| } |
| |
| void tst_QCanBusFrame::tst_toString() |
| { |
| QFETCH(QCanBusFrame::FrameType, frameType); |
| QFETCH(quint32, id); |
| QFETCH(bool, extended); |
| QFETCH(QByteArray, payload); |
| QFETCH(QString, expected); |
| QCanBusFrame frame; |
| frame.setFrameType(frameType); |
| frame.setFrameId(id); |
| frame.setExtendedFrameFormat(extended); |
| frame.setPayload(payload); |
| |
| const QString result = frame.toString(); |
| |
| QCOMPARE(result, expected); |
| } |
| |
| void tst_QCanBusFrame::streaming_data() |
| { |
| QTest::addColumn<quint32>("frameId"); |
| QTest::addColumn<QByteArray>("payload"); |
| QTest::addColumn<qint64>("seconds"); |
| QTest::addColumn<qint64>("microSeconds"); |
| QTest::addColumn<bool>("isExtended"); |
| QTest::addColumn<bool>("isFlexibleDataRate"); |
| QTest::addColumn<bool>("isBitrateSwitch"); |
| QTest::addColumn<bool>("isErrorStateIndicator"); |
| QTest::addColumn<bool>("isLocalEcho"); |
| QTest::addColumn<QCanBusFrame::FrameType>("frameType"); |
| |
| |
| QTest::newRow("emptyFrame") << quint32(0) << QByteArray() |
| << qint64(0) << qint64(0) |
| << false << false << false << false << false |
| << QCanBusFrame::DataFrame; |
| QTest::newRow("fullFrame1") << quint32(123) << QByteArray("abcde1") |
| << qint64(456) << qint64(784) |
| << true << false << false << false << false |
| << QCanBusFrame::DataFrame; |
| QTest::newRow("fullFrame2") << quint32(123) << QByteArray("abcde2") |
| << qint64(457) << qint64(785) |
| << false << false << false << false << false |
| << QCanBusFrame::DataFrame; |
| QTest::newRow("fullFrameFD") << quint32(123) << QByteArray("abcdfd") |
| << qint64(457) << qint64(785) |
| << false << true << false << false << false |
| << QCanBusFrame::DataFrame; |
| QTest::newRow("fullFrameBRS") << quint32(123) << QByteArray("abcdfd") |
| << qint64(457) << qint64(785) |
| << false << true << true << false << false |
| << QCanBusFrame::DataFrame; |
| QTest::newRow("fullFrameESI") << quint32(123) << QByteArray("abcdfd") |
| << qint64(457) << qint64(785) |
| << false << true << false << true << false |
| << QCanBusFrame::DataFrame; |
| QTest::newRow("echoFrame") << quint32(123) << QByteArray("abcde7") |
| << qint64(888) << qint64(777) |
| << false << false << false << false << true |
| << QCanBusFrame::DataFrame; |
| QTest::newRow("fullFrame3") << quint32(123) << QByteArray("abcde3") |
| << qint64(458) << qint64(786) |
| << true << false << false << false << false |
| << QCanBusFrame::RemoteRequestFrame; |
| QTest::newRow("fullFrame4") << quint32(123) << QByteArray("abcde4") |
| << qint64(459) << qint64(787) |
| << false << false << false << false << false |
| << QCanBusFrame::RemoteRequestFrame; |
| QTest::newRow("fullFrame5") << quint32(123) << QByteArray("abcde5") |
| << qint64(460) << qint64(789) |
| << true << false << false << false << false |
| << QCanBusFrame::ErrorFrame; |
| QTest::newRow("fullFrame6") << quint32(123) << QByteArray("abcde6") |
| << qint64(453) << qint64(788) |
| << false << false << false << false << false |
| << QCanBusFrame::ErrorFrame; |
| } |
| |
| void tst_QCanBusFrame::streaming() |
| { |
| QFETCH(quint32, frameId); |
| QFETCH(QByteArray, payload); |
| QFETCH(qint64, seconds); |
| QFETCH(qint64, microSeconds); |
| QFETCH(bool, isExtended); |
| QFETCH(bool, isFlexibleDataRate); |
| QFETCH(bool, isBitrateSwitch); |
| QFETCH(bool, isErrorStateIndicator); |
| QFETCH(bool, isLocalEcho); |
| QFETCH(QCanBusFrame::FrameType, frameType); |
| |
| QCanBusFrame originalFrame(frameId, payload); |
| const QCanBusFrame::TimeStamp originalStamp(seconds, microSeconds); |
| originalFrame.setTimeStamp(originalStamp); |
| |
| originalFrame.setExtendedFrameFormat(isExtended); |
| originalFrame.setFlexibleDataRateFormat(isFlexibleDataRate); |
| originalFrame.setBitrateSwitch(isBitrateSwitch); |
| originalFrame.setErrorStateIndicator(isErrorStateIndicator); |
| originalFrame.setLocalEcho(isLocalEcho); |
| originalFrame.setFrameType(frameType); |
| |
| QByteArray buffer; |
| QDataStream out(&buffer, QIODevice::WriteOnly); |
| out << originalFrame; |
| |
| QDataStream in(buffer); |
| QCanBusFrame restoredFrame; |
| in >> restoredFrame; |
| const QCanBusFrame::TimeStamp restoredStamp(restoredFrame.timeStamp()); |
| |
| QCOMPARE(restoredFrame.frameId(), originalFrame.frameId()); |
| QCOMPARE(restoredFrame.payload(), originalFrame.payload()); |
| |
| QCOMPARE(restoredStamp.seconds(), originalStamp.seconds()); |
| QCOMPARE(restoredStamp.microSeconds(), originalStamp.microSeconds()); |
| |
| QCOMPARE(restoredFrame.frameType(), originalFrame.frameType()); |
| QCOMPARE(restoredFrame.hasExtendedFrameFormat(), |
| originalFrame.hasExtendedFrameFormat()); |
| QCOMPARE(restoredFrame.hasFlexibleDataRateFormat(), |
| originalFrame.hasFlexibleDataRateFormat()); |
| QCOMPARE(restoredFrame.hasBitrateSwitch(), |
| originalFrame.hasBitrateSwitch()); |
| QCOMPARE(restoredFrame.hasErrorStateIndicator(), |
| originalFrame.hasErrorStateIndicator()); |
| QCOMPARE(restoredFrame.hasLocalEcho(), |
| originalFrame.hasLocalEcho()); |
| } |
| |
| void tst_QCanBusFrame::tst_error() |
| { |
| QCanBusFrame frame(1, QByteArray()); |
| QCOMPARE(frame.frameType(), QCanBusFrame::DataFrame); |
| QCOMPARE(frame.frameId(), 1u); |
| QCOMPARE(frame.error(), QCanBusFrame::NoError); |
| |
| //set error -> should be ignored since still DataFrame |
| frame.setError(QCanBusFrame::AnyError); |
| QCOMPARE(frame.frameType(), QCanBusFrame::DataFrame); |
| QCOMPARE(frame.frameId(), 1u); |
| QCOMPARE(frame.error(), QCanBusFrame::NoError); |
| |
| frame.setFrameType(QCanBusFrame::ErrorFrame); |
| QCOMPARE(frame.frameType(), QCanBusFrame::ErrorFrame); |
| QCOMPARE(frame.frameId(), 0u); //id of Error frame always 0 |
| QCOMPARE(frame.error(), QCanBusFrame::TransmissionTimeoutError); |
| |
| frame.setError(QCanBusFrame::FrameErrors(QCanBusFrame::ControllerError | QCanBusFrame::ProtocolViolationError)); |
| QCOMPARE(frame.frameType(), QCanBusFrame::ErrorFrame); |
| QCOMPARE(frame.frameId(), 0u); //id of Error frame always 0 |
| QCOMPARE(frame.error(), |
| QCanBusFrame::ControllerError|QCanBusFrame::ProtocolViolationError); |
| |
| frame.setFrameType(QCanBusFrame::RemoteRequestFrame); |
| QCOMPARE(frame.frameType(), QCanBusFrame::RemoteRequestFrame); |
| QCOMPARE(frame.frameId(), uint(QCanBusFrame::ControllerError | QCanBusFrame::ProtocolViolationError)); |
| QCOMPARE(frame.error(), QCanBusFrame::NoError); |
| } |
| |
| QTEST_MAIN(tst_QCanBusFrame) |
| |
| #include "tst_qcanbusframe.moc" |
