View difference between Paste ID: dcpUznkj and Ky8mdM1D

 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);
 
 }