PX4-Autopilot/libuavcan/test/transport/transfer.cpp

/*
 * Copyright (C) 2014 Pavel Kirienko <pavel.kirienko@gmail.com>
 */

#include <string>
#include <gtest/gtest.h>
#include <uavcan/internal/transport/transfer.hpp>
#include "../common.hpp"


TEST(Transfer, TransferID)
{
    using uavcan::TransferID;

    // Tests below are based on this assumption
    ASSERT_EQ(8, 1 << TransferID::BITLEN);

    /*
     * forwardDistance()
     */
    EXPECT_EQ(0, TransferID(0).forwardDistance(0));
    EXPECT_EQ(1, TransferID(0).forwardDistance(1));
    EXPECT_EQ(7, TransferID(0).forwardDistance(7));

    EXPECT_EQ(0, TransferID(7).forwardDistance(7));
    EXPECT_EQ(7, TransferID(7).forwardDistance(6));
    EXPECT_EQ(1, TransferID(7).forwardDistance(0));

    EXPECT_EQ(7, TransferID(7).forwardDistance(6));
    EXPECT_EQ(5, TransferID(0).forwardDistance(5));

    /*
     * Misc
     */
    EXPECT_TRUE(TransferID(2) == TransferID(2));
    EXPECT_FALSE(TransferID(2) != TransferID(2));
    EXPECT_FALSE(TransferID(2) == TransferID(0));
    EXPECT_TRUE(TransferID(2) != TransferID(0));

    TransferID tid;
    for (int i = 0; i < 999; i++)
    {
        ASSERT_EQ(i & ((1 << TransferID::BITLEN) - 1), tid.get());
        const TransferID copy = tid;
        tid.increment();
        ASSERT_EQ(1, copy.forwardDistance(tid));
        ASSERT_EQ(7, tid.forwardDistance(copy));
        ASSERT_EQ(0, tid.forwardDistance(tid));
    }
}

TEST(Transfer, FrameParseCompile)
{
    using uavcan::Frame;
    using uavcan::CanFrame;
    using uavcan::TransferID;
    using uavcan::TransferType;

    Frame frame;

    const uint32_t can_id =
        (2 << 0)   |      //    Transfer ID
        (1 << 3)   |      //    Last Frame
        (29 << 4)  |      //    Frame Index
        (42 << 10) |      //    Source Node ID
        (uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST << 17)  |
        (456 << 19);      //    Data Type ID

    const std::string payload_string = "hello";

    /*
     * Parse
     */
    // Invalid CAN frames
    ASSERT_FALSE(frame.parse(CanFrame(can_id | CanFrame::FLAG_RTR, (const uint8_t*)"", 0)));
    ASSERT_FALSE(frame.parse(makeCanFrame(can_id, payload_string, STD)));

    // Valid
    ASSERT_TRUE(frame.parse(makeCanFrame(can_id, payload_string, EXT)));

    EXPECT_EQ(TransferID(2), frame.getTransferID());
    EXPECT_TRUE(frame.isLastFrame());
    EXPECT_EQ(29, frame.getFrameIndex());
    EXPECT_EQ(uavcan::NodeID(42), frame.getSrcNodeID());
    EXPECT_EQ(uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, frame.getTransferType());
    EXPECT_EQ(456, frame.getDataTypeID());

    EXPECT_EQ(payload_string.length(), frame.getPayloadLen());
    EXPECT_TRUE(std::equal(frame.getPayloadPtr(), frame.getPayloadPtr() + frame.getPayloadLen(),
                           payload_string.begin()));

    /*
     * Compile
     */
    CanFrame can_frame;
    ASSERT_TRUE(frame.parse(makeCanFrame(can_id, payload_string, EXT)));

    ASSERT_TRUE(frame.compile(can_frame));
    ASSERT_EQ(can_frame, makeCanFrame(can_id, payload_string, EXT));

    EXPECT_EQ(payload_string.length(), can_frame.dlc);
    EXPECT_TRUE(std::equal(can_frame.data, can_frame.data + can_frame.dlc, payload_string.begin()));

    /*
     * Comparison
     */
    ASSERT_FALSE(Frame() == frame);
    ASSERT_TRUE(Frame() != frame);
    frame = Frame();
    ASSERT_TRUE(Frame() == frame);
    ASSERT_FALSE(Frame() != frame);
}


TEST(Transfer, RxFrameParse)
{
    using uavcan::Frame;
    using uavcan::RxFrame;
    using uavcan::CanFrame;
    using uavcan::CanRxFrame;

    CanRxFrame can_rx_frame;
    RxFrame rx_frame;

    // Failure
    ASSERT_FALSE(rx_frame.parse(can_rx_frame));

    // Valid
    can_rx_frame.id = CanFrame::FLAG_EFF |
        (2 << 0)   |      //    Transfer ID
        (1 << 3)   |      //    Last Frame
        (29 << 4)  |      //    Frame Index
        (42 << 10) |      //    Source Node ID
        (uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST << 17)  |
        (456 << 19);      //    Data Type ID

    ASSERT_TRUE(rx_frame.parse(can_rx_frame));
    ASSERT_EQ(0, rx_frame.getMonotonicTimestamp());
    ASSERT_EQ(0, rx_frame.getIfaceIndex());

    can_rx_frame.ts_monotonic = 123;
    can_rx_frame.iface_index = 2;

    Frame frame(456, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 1, uavcan::NodeID::BROADCAST, 0, 0);
    ASSERT_TRUE(frame.compile(can_rx_frame));

    ASSERT_TRUE(rx_frame.parse(can_rx_frame));
    ASSERT_EQ(123, rx_frame.getMonotonicTimestamp());
    ASSERT_EQ(2, rx_frame.getIfaceIndex());
    ASSERT_EQ(456, rx_frame.getDataTypeID());
    ASSERT_EQ(uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, rx_frame.getTransferType());
}


TEST(Transfer, FrameToString)
{
    using uavcan::Frame;
    using uavcan::RxFrame;

    // RX frame default
    RxFrame rx_frame;
    EXPECT_EQ("dtid=0 tt=4 snid=255 dnid=255 idx=0 last=0 tid=0 payload=[] ts_m=0 ts_utc=0 iface=0", rx_frame.toString());

    // RX frame max len
    rx_frame = RxFrame(Frame(Frame::DATA_TYPE_ID_MAX, uavcan::TRANSFER_TYPE_MESSAGE_UNICAST,
                             uavcan::NodeID::MAX, uavcan::NodeID::MAX - 1, Frame::FRAME_INDEX_MAX,
                             uavcan::TransferID::MAX, true),
                       0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 3);

    uint8_t data[8];
    for (unsigned int i = 0; i < sizeof(data); i++)
        data[i] = i;
    rx_frame.setPayload(data, sizeof(data));

    EXPECT_EQ(
    "dtid=1023 tt=3 snid=127 dnid=126 idx=62 last=1 tid=7 payload=[00 01 02 03 04 05 06] ts_m=18446744073709551615 ts_utc=18446744073709551615 iface=3",
    rx_frame.toString());

    // Plain frame default
    Frame frame;
    EXPECT_EQ("dtid=0 tt=4 snid=255 dnid=255 idx=0 last=0 tid=0 payload=[]", frame.toString());

    // Plain frame max len
    frame = rx_frame;
    EXPECT_EQ("dtid=1023 tt=3 snid=127 dnid=126 idx=62 last=1 tid=7 payload=[00 01 02 03 04 05 06]", frame.toString());
}