xcp test session

void
PXCPTest::initTestCase()
{
    InitErrorCodes();

    m_can_handle = PCAN_PCIBUS1;
    m_can_baudrate = PCAN_BAUD_1M;

}

void
PXCPTest::TestXCPInitializeCanChannel()
{
    m_result = XCP_InitializeCanChannel(&m_xcp_channel,
            m_can_handle,
            m_can_baudrate,
            0,0,0);

    GetErrorMessage();
    QVERIFY2(m_result == XCP_ERR_OK, m_error_message);

}

void
PXCPTest::TestXCPAddSlave()
{
    FillLayerDataAndConfig();
    m_result = XCP_AddSlaveOnCAN(m_xcp_channel,
            m_layer_data,
            m_layer_config,
            &m_xcp_handle);


    GetErrorMessage();
    QVERIFY2(m_result == XCP_ERR_OK, m_error_message);

}

void PXCPTest::FillLayerDataAndConfig()
{
//      /begin IF_DATA XCP
//         /begin PROTOCOL_LAYER
//            0x0100
//            2000  /* T1 */
//            2000  /* T2 */
//            2000  /* T3 */
//            65535  /* T4 */
//            2000  /* T5 */
//            0005  /* T6 */
//            0005  /* T7 */
//            0x08
//            0x0008
//            BYTE_ORDER_MSB_LAST /* Motorola Format */
//            ADDRESS_GRANULARITY_BYTE  /* address granularity: 1 */
//            ...
//         /end PROTOCOL_LAYER
//         ...
//       /end IF_DATA XCP

    m_layer_data.BroadcastID = 0;
    m_layer_data.MasterID = 0x078A;
    m_layer_data.SlaveID = 0x0791;
    m_layer_data.IncrementalIdUsed = false;

    m_layer_config.MotorolaFormat = true;
    m_layer_config.T1 = 2000;
    m_layer_config.T2 = 2000;
    m_layer_config.T3 = 2000;
    m_layer_config.T4 = 65535;
    m_layer_config.T5 = 2000;
    m_layer_config.T6 = 5;
    m_layer_config.T7 = 5;
    m_layer_config.AddressGranularity = 1;
}

void
PXCPTest::TestXCPConnect()
{
    m_result = XCP_Connect(m_xcp_handle, 0, m_cto_buffer, m_cto_buffer_length);
    GetErrorMessage();
    QVERIFY2(m_result == XCP_ERR_OK, m_error_message);


    BYTE resource_byte = m_cto_buffer[1];
    QVERIFY2(resource_byte & (1 << 2), "DAQ lists not available.");
}

void
PXCPTest::TestXCPFreeDAQLists()
{
    m_result =
        XCP_FreeDAQLists(m_xcp_handle, m_cto_buffer, m_cto_buffer_length);
    GetErrorMessage();
    QVERIFY2(m_result == XCP_ERR_OK, m_error_message);
}

void
PXCPTest::TestXCPAllocateDAQList()
{
    m_result =
        XCP_AllocateDAQLists(m_xcp_handle,
                1,
                m_cto_buffer,
                m_cto_buffer_length);
    GetErrorMessage();
    QVERIFY2(m_result == XCP_ERR_OK, m_error_message);
}

void
PXCPTest::TestXCPAllocateODT()
{
    m_result =
        XCP_AllocateODT(m_xcp_handle,
                m_daq_list_number, // = 0
                1, // number of dtos
                m_cto_buffer,
                m_cto_buffer_length);
    GetErrorMessage();
    QVERIFY2(m_result == XCP_ERR_OK, m_error_message);
}

void
PXCPTest::TestXCPAllocateODTEntry()
{
    m_result =
        XCP_AllocateODTEntry(m_xcp_handle,
                m_daq_list_number,
                0, // dto number
                1, // number of dto entries
                m_cto_buffer,
                m_cto_buffer_length);
    GetErrorMessage();
    QVERIFY2(m_result == XCP_ERR_OK, m_error_message);
}

void
PXCPTest::TestXCPSetDAQListPointer()
{

    m_result = XCP_SetDAQListPointer(
            m_xcp_handle,
            m_daq_list_number,
            0, // dto number
            0, // dto_entry number
            m_cto_buffer,
            m_cto_buffer_length);

    GetErrorMessage();
    QVERIFY2(m_result == XCP_ERR_OK, m_error_message);

}

void
PXCPTest::TestXCPWriteDAQListEntry()
{
    TXCPODTEntry odt_entry;
    odt_entry.BitOffset = 0;
    odt_entry.DAQSize = sizeof(float);
    odt_entry.DAQAddressExtension = 0;
    odt_entry.DAQAddress = 0xD0010FF0;

    m_result = XCP_WriteDAQListEntry(m_xcp_handle,
            odt_entry,
            m_cto_buffer,
            m_cto_buffer_length);

    GetErrorMessage();
    QVERIFY2(m_result == XCP_ERR_OK, m_error_message);
}

void
PXCPTest::TestXCPGetAndSetDAQListMode()
{
    m_result = XCP_GetDAQListMode(m_xcp_handle,
            m_daq_list_number,
            m_cto_buffer,
            m_cto_buffer_length);
    GetErrorMessage();
    QVERIFY2(m_result == XCP_ERR_OK, m_error_message);

    BYTE mode = m_cto_buffer[1];

    mode = 00000000;

    TXCPDAQListConfig daq_list_config;
    daq_list_config.DAQListNumber = m_daq_list_number;
    daq_list_config.EventChannelNumber = 0;
    daq_list_config.TransmissionRate = 1;
    daq_list_config.DAQPriority = 0;

    m_result = XCP_SetDAQListMode(m_xcp_handle,
            mode,
            daq_list_config,
            m_cto_buffer,
            m_cto_buffer_length);

    GetErrorMessage();
    QVERIFY2(m_result == XCP_ERR_OK, m_error_message);

}

void
PXCPTest::TestXCPStartStopDAQList()
{
    m_result = XCP_StartStopDAQList(m_xcp_handle,
            2, // Mode: 0-stop, 1-start, 2-select
            m_daq_list_number, // list number
            m_cto_buffer,
            m_cto_buffer_length);
    GetErrorMessage();
    QVERIFY2(m_result == XCP_ERR_OK, m_error_message);
}

void
PXCPTest::TestXCPStartStopSynchronizedDAQList()
{
    m_result = XCP_StartStopSynchronizedDAQList(m_xcp_handle,
            1, // 0-stop all, 1-start selected, 2-stop selected
            m_cto_buffer,
            m_cto_buffer_length);

    GetErrorMessage();
    QVERIFY2(m_result == XCP_ERR_OK, m_error_message);

    QTest::qSleep(1000);
}

void
PXCPTest::TestXCPDequeuePacket()
{
    WORD packet_buffer_length = 8;
    BYTE packet_buffer[packet_buffer_length];
    m_result = XCP_DequeuePacket(m_xcp_handle,
            XCP_DTO_QUEUE,
            packet_buffer,
            packet_buffer_length);
    GetErrorMessage();
    QVERIFY2(m_result == XCP_ERR_OK, m_error_message);

    float value;
    std::memcpy(&value, &(packet_buffer[1]), sizeof(float));
    qDebug() << QString("%1").arg(value);
}

void
PXCPTest::TestXCPDisconnect()
{
    m_result = XCP_Disconnect(m_xcp_handle, m_cto_buffer, m_cto_buffer_length);
    GetErrorMessage();
    QVERIFY2(m_result == XCP_ERR_OK, m_error_message);

}

void
PXCPTest::TestXCPRemoveSlave()
{
    m_result = XCP_RemoveSlave(m_xcp_handle);
    GetErrorMessage();
    QVERIFY2(m_result == XCP_ERR_OK, m_error_message);

}

void
PXCPTest::TestXCPUninitializeChannel()
{
    m_result = XCP_UninitializeChannel(m_xcp_channel);
    GetErrorMessage();
    QVERIFY2(m_result == XCP_ERR_OK, m_error_message);

}