oliver/cls_master
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

added handling of CanData To Tasks

Browse Source
This commit is contained in:
Oliver Walter
2024-02-04 23:38:22 +01:00
parent 0a72c8b553
commit bfc28e6c94
16 changed files with 2658 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
tests/native/CMakeLists.txt
View File

@@ -8,7 +8,10 @@ set(CMAKE_EXPORT_COMPILE_COMMANDS 1)
add_executable(${CMAKE_PROJECT_NAME})
target_sources(${CMAKE_PROJECT_NAME} PUBLIC
tests.c
usbdata_test.c
candata_test.c
mock_os/mock_os.c
mock_os/mock_hal.c
../lib/Unity/src/unity.c
)

220
tests/native/candata_test.c Normal file
View File

@@ -0,0 +1,220 @@
#include "unity.h"
#include "CanDataHandler.h"
#define MAX_MESSAGE_SLOTS 100
#define MAX_EVENT_SLOTS 100
uint32_t hfdcan1 =0;
// Test when you register a new canid, it should return true.
void test_CanDataRegDataMsg_insert_valid() {
CanDataHandler_init(); // Reset the state of the module
CanDataId canid = 1; // Test with a valid canid
bool result = CanData_regDataMsg(canid);
TEST_ASSERT_TRUE(result); // Check that the function returned true
}
// Test when you register a canid when all slots are filled, it should return false.
void test_CanDataRegDataMsg_insert_full() {
CanDataHandler_init(); // Reset the state of the module
// Fill all the slots
for (int i = 1; i < MAX_MESSAGE_SLOTS+1; i++) {
bool result = CanData_regDataMsg(i);
TEST_ASSERT_TRUE(result);
}
// Try to register a new canid
CanDataId canid = MAX_MESSAGE_SLOTS + 2; // This canid should not fit in the slots
bool result = CanData_regDataMsg(canid);
TEST_ASSERT_FALSE(result); // Check that the function returned false
}
// Test when registering the same canid multible times there should be no error
void test_CanDataRegDataMsg_insert_duplicate() {
CanDataHandler_init(); // Reset the state of the module
CanDataId canid = 1; // Test with a valid canid
// Register the same canid multiple times
for (int i = 0; i < 5; i++) {
bool result = CanData_regDataMsg(canid);
TEST_ASSERT_TRUE(result); // Check that the function returned true each time
}
}
// A dummy event callback function for testing
void dummyEventCallback(CanDataId canid, uint8_t* data, uint8_t len) {
// This function doesn't need to do anything
}
// Test when you register a new event callback, it should return true.
void test_CanDataRegEventMsg_insert_valid() {
CanDataHandler_init(); // Reset the state of the module
CanDataId canid = 1; // Test with a valid canid
bool result = CanData_regEventMsg(canid, dummyEventCallback);
TEST_ASSERT_TRUE(result); // Check that the function returned true
}
// Test when you register an event callback when all slots are filled, it should return false.
void test_CanDataRegEventMsg_insert_full() {
CanDataHandler_init(); // Reset the state of the module
// Fill all the slots
for (int i = 1; i < MAX_EVENT_SLOTS+1; i++) {
bool result = CanData_regEventMsg(i, dummyEventCallback);
TEST_ASSERT_TRUE(result); // Check that the function returned true
}
// Try to register a new event callback
CanDataId canid = MAX_EVENT_SLOTS + 2; // This canid should not fit in the slots
bool result = CanData_regEventMsg(canid, dummyEventCallback);
TEST_ASSERT_FALSE(result); // Check that the function returned false
}
// Test when you register a canid with a NULL callback, it should return false.
void test_CanDataRegEventMsg_NullCallback() {
CanDataHandler_init(); // Reset the state of the module
CanDataId canid = 1; // Test with a valid canid
bool result = CanData_regEventMsg(canid, NULL);
TEST_ASSERT_FALSE(result); // Check that the function returned false
}
// Test when you register a canid that has already been registered, it should return false.
void test_CanDataRegEventMsg_insert_duplicate() {
CanDataHandler_init(); // Reset the state of the module
CanDataId canid = 1; // Test with a valid canid
// Register the canid once
bool result = CanData_regEventMsg(canid, dummyEventCallback);
TEST_ASSERT_TRUE(result); // Check that the function returned true
// Try to register the same canid again
result = CanData_regEventMsg(canid, dummyEventCallback);
TEST_ASSERT_FALSE(result); // Check that the function returned false
}
// Test for CanData_canFifo0RxCallback(CanDataId canid, uint8_t* data, uint8_t len) function
void test_CanData_canFifo0RxCallback_data_valid() {
CanDataHandler_init(); // Reset the state of the module
CanDataId canid = 1; // Test with a valid canid
uint8_t data[8] = {1, 2, 3, 4, 5, 6, 7, 8}; // Test with valid data
uint8_t len = 8; // Test with a valid length
// Register the canid
bool result = CanData_regDataMsg(canid);
TEST_ASSERT_TRUE(result); // Check that the function returned true
// Call the function with the test parameters
CanData_canFifo0RxCallback(canid, data, len);
// Get the message that was processed
const CanDataMessage* message = CanData_getDataMessage(canid);
// Check that the message was processed correctly
TEST_ASSERT_EQUAL_UINT8(len, message->data_length);
TEST_ASSERT_EQUAL_UINT8_ARRAY(data, message->data, len);
}
// Test for CanData_canFifo0RxCallback(CanDataId canid, uint8_t* data, uint8_t len) function
// Test with an invalid canid or NULL data, the function should handle the error correctly.
void test_CanData_canFifo0RxCallback_data_invalid() {
CanDataHandler_init(); // Reset the state of the module
CanDataId canid = 1; // Test with a valid canid
uint8_t* data = NULL; // Test with NULL data
uint8_t len = 8; // Test with a valid length
// Register the canid
bool result = CanData_regDataMsg(canid);
TEST_ASSERT_TRUE(result); // Check that the function returned true
// Call the function with the test parameters
CanData_canFifo0RxCallback(canid, data, len);
// Get the message that was processed
const CanDataMessage* message = CanData_getDataMessage(canid);
// Check that the message was not processed
TEST_ASSERT_EQUAL_UINT8(0, message->data_length);
}
bool test_CanData_canFifo1RxCallback_callbackCalled = false;
void test_CanData_canFifo1RxCallback_callback(CanDataId canid, uint8_t* data, uint8_t len) {
test_CanData_canFifo1RxCallback_callbackCalled = true;
TEST_ASSERT_EQUAL_UINT16(1,canid);
TEST_ASSERT_EQUAL_UINT8(8,len);
}
// Test for CanData_canFifo1RxCallback(CanDataId canid, uint8_t* data, uint8_t len) function
void test_CanData_canFifo1RxCallback_data_valid() {
CanDataHandler_init(); // Reset the state of the module
CanDataId canid = 1; // Test with a valid canid
uint8_t data[8] = {1, 2, 3, 4, 5, 6, 7, 8}; // Test with valid data
uint8_t len = 8; // Test with a valid length
// Register the canid with the callback
bool result = CanData_regEventMsg(canid, test_CanData_canFifo1RxCallback_callback);
TEST_ASSERT_TRUE(result); // Check that the function returned true
// Call the function with the test parameters
CanData_canFifo1RxCallback(canid, data, len);
// Check that the callback was called
TEST_ASSERT_TRUE(test_CanData_canFifo1RxCallback_callbackCalled);
}
bool test_CanData_removeEvent_callbackCalled = false;
void test_CanData_removeEvent_callback(CanDataId canid, uint8_t* data, uint8_t len) {
test_CanData_removeEvent_callbackCalled = true;
TEST_ASSERT_EQUAL_UINT16(1,canid);
TEST_ASSERT_EQUAL_UINT8(8,len);
}
// Test for CanData_removeEvent(CanDataId canid) function
void test_CanData_removeEvent() {
CanDataHandler_init(); // Reset the state of the module
CanDataId canid = 1; // Test with a valid canid
// Register the canid with the callback
bool result = CanData_regEventMsg(canid, test_CanData_removeEvent_callback);
TEST_ASSERT_TRUE(result); // Check that the function returned true
// Remove the canid
result = CanData_removeEvent(canid);
TEST_ASSERT_TRUE(result); // Check that the function returned true
// Call the function with the test parameters
uint8_t data[8] = {1, 2, 3, 4, 5, 6, 7, 8}; // Test with valid data
uint8_t len = 8; // Test with a valid length
CanData_canFifo1RxCallback(canid, data, len);
// Check that the callback was not called
TEST_ASSERT_FALSE(test_CanData_removeEvent_callbackCalled);
}
// Create a test runner function
void test_CanData(void) {
RUN_TEST(test_CanDataRegDataMsg_insert_valid);
RUN_TEST(test_CanDataRegDataMsg_insert_full);
RUN_TEST(test_CanDataRegDataMsg_insert_duplicate);
RUN_TEST(test_CanDataRegEventMsg_insert_valid);
RUN_TEST(test_CanDataRegEventMsg_insert_full);
RUN_TEST(test_CanDataRegEventMsg_NullCallback);
RUN_TEST(test_CanDataRegEventMsg_insert_duplicate);
RUN_TEST(test_CanData_canFifo0RxCallback_data_valid);
RUN_TEST(test_CanData_canFifo0RxCallback_data_invalid);
RUN_TEST(test_CanData_canFifo1RxCallback_data_valid);
RUN_TEST(test_CanData_removeEvent);
}

1
tests/native/mock_os/FreeRTOS.h Normal file
View File

@@ -0,0 +1 @@
typedef unsigned long int StaticTask_t;

7
tests/native/mock_os/cmsis_os2.h
View File

@@ -104,4 +104,9 @@ void Error_Handler();
osThreadId_t osThreadNew(osThreadFunc_t func, void *argument, const osThreadAttr_t *attr);
osStatus_t osMessageQueueGet (osMessageQueueId_t mq_id, void *msg_ptr, uint8_t *msg_prio, uint32_t timeout);
osStatus_t osMessageQueuePut (osMessageQueueId_t mq_id, const void *msg_ptr, uint8_t msg_prio, uint32_t timeout);
osMessageQueueId_t osMessageQueueNew (uint32_t msg_count, uint32_t msg_size, const osMessageQueueAttr_t *attr) ;
osMessageQueueId_t osMessageQueueNew (uint32_t msg_count, uint32_t msg_size, const osMessageQueueAttr_t *attr) ;
osStatus_t osDelay (uint32_t ticks);
uint32_t osKernelGetSysTimerCount (void);

4
tests/native/mock_os/crc.h Normal file
View File

@@ -0,0 +1,4 @@
typedef uint32_t CRC_HandleTypeDef;
extern CRC_HandleTypeDef hcrc;
uint32_t HAL_CRC_Calculate(CRC_HandleTypeDef *hcrc, uint32_t pBuffer[], uint32_t BufferLength);

15
tests/native/mock_os/fatfs.h Normal file
View File

@@ -0,0 +1,15 @@
#include "stdint.h"
typedef unsigned int FRESULT;
typedef struct
{
void * ptr; /* data */
}FIL;
FRESULT f_open (FIL* fp, const char* path, uint8_t mode); /* Open or create a file */
FRESULT f_close (FIL* fp); /* Close an open file object */
FRESULT f_write (FIL* fp, const void* buff, uint32_t btw, uint32_t* bw); /* Write data to the file */
#define FA_CREATE_ALWAYS 0
#define FA_WRITE 0

1716
tests/native/mock_os/fdcan.h Normal file
View File

File diff suppressed because it is too large Load Diff

9
tests/native/mock_os/mock_hal.c Normal file
View File

@@ -0,0 +1,9 @@
#include "fdcan.h"
#include "crc.h"
HAL_StatusTypeDef HAL_FDCAN_ConfigFilter(FDCAN_HandleTypeDef *hfdcan, FDCAN_FilterTypeDef *sFilterConfig) {
return 0;
}

4
tests/native/mock_os/usbd_cdc_if.h Normal file
View File

@@ -0,0 +1,4 @@
uint8_t CDC_Transmit_HS(uint8_t* Buf, uint16_t Len);
#define USBD_BUSY 1
#define USBD_OK 0

151
tests/native/tests.c
View File

@@ -1,166 +1,23 @@
#include "unity.h"
#include "UsbDataHandler.h"
#include "pb_encode.h"
#include "firmware.pb.h"
void setUp() {
}
#define START_PACKAES 10
#define START_SIZE 123456
#define START_CRC 0xffff
#define START_DEVICE 0x04
#define START_NAME "slave0x04.bin"
#define PACK_COUTNER 3
#define PACK_CRC 0xabcd
#define PACK_DEVICE 0x04
#define PACK_DATA_SIZE 50
#define ACK_COUTNER 43
#define ACK_CRC 0xabcdef
#define ACK_DEVICE 0x9
#define DONE_CRC 0xffffffff
#define DONE_DEVICE 0xf
#define DONE_SIZE 1024 * 65
uint16_t StartCounter = 0;
uint16_t PackageCounter = 0;
uint16_t AckCounter = 0;
uint16_t DoneCounter = 0;
void transmit_package(uint16_t id, const pb_msgdesc_t *fields , const void* msg){
UsbDataPacket buffer = {0};
buffer.head.type = id;
pb_ostream_t ostream = pb_ostream_from_buffer(buffer.data, sizeof(buffer.data));
pb_encode(&ostream, fields, msg);
buffer.head.length= ostream.bytes_written;
buffer.head.check = UsbDataPacket_head_sum(&buffer);
UsbDataHandler_RxCallback((uint8_t*)(&buffer), buffer.head.length+sizeof(UsbDataPacketHead));
}
void test_UsbDataHandler(void) {
// Set up the module
UsbDataHandler_Start();
// Call the runner with no messages this should do nothing
UsbDataHandler_Runner();
FirmwareStart start ={
.name=START_NAME,
.packages=START_PACKAES,
.size=START_SIZE,
.crc_fw=START_CRC,
.device_id=START_DEVICE,
};
transmit_package(UsbPackageType_FIRMWARESTART, FirmwareStart_fields, &start);
// Call the runner with start message in the queue
UsbDataHandler_Runner();
TEST_ASSERT_EQUAL(StartCounter,1);
//Put 2 packages in the buffer an parse them
transmit_package(UsbPackageType_FIRMWARESTART, FirmwareStart_fields, &start);
transmit_package(UsbPackageType_FIRMWARESTART, FirmwareStart_fields, &start);
UsbDataHandler_Runner();
UsbDataHandler_Runner();
TEST_ASSERT_EQUAL(StartCounter,3);
FirmwarePackage pack = {
.counter =PACK_COUTNER ,
.crc_pac = PACK_CRC,
.device_id= PACK_DEVICE,
.data={.size = PACK_DATA_SIZE,
.bytes={0}
},
};
transmit_package(UsbPackageType_FIRMWAREPACKAGE, FirmwarePackage_fields, &pack);
UsbDataHandler_Runner();
TEST_ASSERT_EQUAL(PackageCounter,1);
FirmwarePackageAck ack = {
.ack =true,
.counter = ACK_COUTNER,
.crc_pac = ACK_CRC,
.device_id = ACK_DEVICE,
};
transmit_package(UsbPackageType_FIRMWAREPACKAGEACK, FirmwarePackageAck_fields, &ack);
UsbDataHandler_Runner();
TEST_ASSERT_EQUAL(PackageCounter,1);
FirmwareDone done = {
.crc_fw = DONE_CRC,
.device_id = DONE_DEVICE,
.size = DONE_SIZE,
};
transmit_package(UsbPackageType_FIRMWAREDONE, FirmwareDone_fields, &done);
UsbDataHandler_Runner();
TEST_ASSERT_EQUAL(DoneCounter,1);
}
void tearDown() {
}
void test_UsbDataHandler(void);
void test_CanData(void);
int main(void) {
UNITY_BEGIN();
RUN_TEST(test_UsbDataHandler);
RUN_TEST(test_CanData);
return UNITY_END();
}
void DataClbk_FirmwareStart(void * msg, uint32_t length) {
FirmwareStart start;
memcpy(&start,msg,sizeof(start));
TEST_ASSERT_EQUAL(START_SIZE, start.size);
TEST_ASSERT_EQUAL(START_PACKAES, start.packages);
TEST_ASSERT_EQUAL(START_CRC, start.crc_fw);
TEST_ASSERT_EQUAL(START_DEVICE, start.device_id);
TEST_ASSERT_EQUAL_STRING(START_NAME,start.name);
StartCounter++;
}
void DataClbk_FirmwarePackage(void * msg, uint32_t length) {
FirmwarePackage pack;
memcpy(&pack,msg,sizeof(pack));
TEST_ASSERT_EQUAL(FirmwarePackage_size, length);
TEST_ASSERT_EQUAL(PACK_COUTNER, pack.counter);
TEST_ASSERT_EQUAL(PACK_CRC, pack.crc_pac);
TEST_ASSERT_EQUAL(PACK_DEVICE, pack.device_id);
TEST_ASSERT_EQUAL(PACK_DATA_SIZE, pack.data.size);
PackageCounter++;
}
void DataClbk_FirmwarePackageAck(void * msg, uint32_t length) {
FirmwarePackageAck ack;
memcpy(&ack,msg,sizeof(ack));
TEST_ASSERT_EQUAL(FirmwarePackageAck_size, length);
TEST_ASSERT(ack.ack);
TEST_ASSERT_EQUAL(ACK_COUTNER, ack.counter);
TEST_ASSERT_EQUAL(ACK_CRC, ack.crc_pac);
TEST_ASSERT_EQUAL(ACK_DEVICE, ack.device_id);
AckCounter++;
}
void DataClbk_FirmwareDone(void * msg, uint32_t length) {
FirmwareDone done;
memcpy(&done,msg,sizeof(done));
TEST_ASSERT_EQUAL(FirmwareDone_size, length);
TEST_ASSERT_EQUAL(DONE_CRC,done.crc_fw);
TEST_ASSERT_EQUAL(DONE_DEVICE,done.device_id);
TEST_ASSERT_EQUAL(DONE_SIZE,done.size);
DoneCounter++;
}

150
tests/native/usbdata_test.c Normal file
View File

@@ -0,0 +1,150 @@
#include "unity.h"
#include "UsbDataHandler.h"
#include "pb_encode.h"
#include "firmware.pb.h"
#define START_PACKAES 10
#define START_SIZE 123456
#define START_CRC 0xffff
#define START_DEVICE 0x04
#define START_NAME "slave0x04.bin"
#define PACK_COUTNER 3
#define PACK_CRC 0xabcd
#define PACK_DEVICE 0x04
#define PACK_DATA_SIZE 50
#define ACK_COUTNER 43
#define ACK_CRC 0xabcdef
#define ACK_DEVICE 0x9
#define DONE_CRC 0xffffffff
#define DONE_DEVICE 0xf
#define DONE_SIZE 1024 * 65
uint16_t StartCounter = 0;
uint16_t PackageCounter = 0;
uint16_t AckCounter = 0;
uint16_t DoneCounter = 0;
void transmit_package(uint16_t id, const pb_msgdesc_t *fields , const void* msg){
UsbDataPacket buffer = {0};
buffer.head.type = id;
pb_ostream_t ostream = pb_ostream_from_buffer(buffer.data, sizeof(buffer.data));
pb_encode(&ostream, fields, msg);
buffer.head.length= ostream.bytes_written;
buffer.head.check = UsbDataPacket_head_sum(&buffer);
UsbDataHandler_RxCallback((uint8_t*)(&buffer), buffer.head.length+sizeof(UsbDataPacketHead));
}
void test_UsbDataHandler(void) {
// Set up the module
UsbDataHandler_Start();
// Call the runner with no messages this should do nothing
UsbDataHandler_Runner();
FirmwareStart start ={
.name=START_NAME,
.packages=START_PACKAES,
.size=START_SIZE,
.crc_fw=START_CRC,
.device_id=START_DEVICE,
};
transmit_package(UsbPackageType_FIRMWARESTART, FirmwareStart_fields, &start);
// Call the runner with start message in the queue
UsbDataHandler_Runner();
TEST_ASSERT_EQUAL(StartCounter,1);
//Put 2 packages in the buffer an parse them
transmit_package(UsbPackageType_FIRMWARESTART, FirmwareStart_fields, &start);
transmit_package(UsbPackageType_FIRMWARESTART, FirmwareStart_fields, &start);
UsbDataHandler_Runner();
UsbDataHandler_Runner();
TEST_ASSERT_EQUAL(StartCounter,3);
FirmwarePackage pack = {
.counter =PACK_COUTNER ,
.crc_pac = PACK_CRC,
.device_id= PACK_DEVICE,
.data={.size = PACK_DATA_SIZE,
.bytes={0}
},
};
transmit_package(UsbPackageType_FIRMWAREPACKAGE, FirmwarePackage_fields, &pack);
UsbDataHandler_Runner();
TEST_ASSERT_EQUAL(PackageCounter,1);
FirmwarePackageAck ack = {
.ack =true,
.counter = ACK_COUTNER,
.crc_pac = ACK_CRC,
.device_id = ACK_DEVICE,
};
transmit_package(UsbPackageType_FIRMWAREPACKAGEACK, FirmwarePackageAck_fields, &ack);
UsbDataHandler_Runner();
TEST_ASSERT_EQUAL(PackageCounter,1);
FirmwareDone done = {
.crc_fw = DONE_CRC,
.device_id = DONE_DEVICE,
.size = DONE_SIZE,
};
transmit_package(UsbPackageType_FIRMWAREDONE, FirmwareDone_fields, &done);
UsbDataHandler_Runner();
TEST_ASSERT_EQUAL(DoneCounter,1);
}
void DataClbk_FirmwareStart(void * msg, uint32_t length) {
FirmwareStart start;
memcpy(&start,msg,sizeof(start));
TEST_ASSERT_EQUAL(sizeof(FirmwareStart), length);
TEST_ASSERT_EQUAL(START_SIZE, start.size);
TEST_ASSERT_EQUAL(START_PACKAES, start.packages);
TEST_ASSERT_EQUAL(START_CRC, start.crc_fw);
TEST_ASSERT_EQUAL(START_DEVICE, start.device_id);
TEST_ASSERT_EQUAL_STRING(START_NAME,start.name);
StartCounter++;
}
void DataClbk_FirmwarePackage(void * msg, uint32_t length) {
FirmwarePackage pack;
memcpy(&pack,msg,sizeof(pack));
TEST_ASSERT_EQUAL(sizeof(FirmwarePackage), length);
TEST_ASSERT_EQUAL(PACK_COUTNER, pack.counter);
TEST_ASSERT_EQUAL(PACK_CRC, pack.crc_pac);
TEST_ASSERT_EQUAL(PACK_DEVICE, pack.device_id);
TEST_ASSERT_EQUAL(PACK_DATA_SIZE, pack.data.size);
PackageCounter++;
}
void DataClbk_FirmwarePackageAck(void * msg, uint32_t length) {
FirmwarePackageAck ack;
memcpy(&ack,msg,sizeof(ack));
TEST_ASSERT_EQUAL(sizeof(FirmwarePackageAck), length);
TEST_ASSERT(ack.ack);
TEST_ASSERT_EQUAL(ACK_COUTNER, ack.counter);
TEST_ASSERT_EQUAL(ACK_CRC, ack.crc_pac);
TEST_ASSERT_EQUAL(ACK_DEVICE, ack.device_id);
AckCounter++;
}
void DataClbk_FirmwareDone(void * msg, uint32_t length) {
FirmwareDone done;
memcpy(&done,msg,sizeof(done));
TEST_ASSERT_EQUAL(sizeof(FirmwareDone), length);
TEST_ASSERT_EQUAL(DONE_CRC,done.crc_fw);
TEST_ASSERT_EQUAL(DONE_DEVICE,done.device_id);
TEST_ASSERT_EQUAL(DONE_SIZE,done.size);
DoneCounter++;
}