sven
/
libicsneo
mirror of https://github.com/intrepidcs/libicsneo.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
libicsneo/test/unit/icsneoc2.cpp

1351 lines
66 KiB
C++
Raw Blame History

#include <gtest/gtest.h>
#include <icsneo/icsneoc2.h>
#include <icsneo/icsneoc2settings.h>
#include <icsneo/icsneoc2messages.h>
#include "../../api/icsneoc2/icsneoc2_internal.h"
#include <icsneo/device/devicetype.h>
#include <icsneo/communication/message/linmessage.h>
#include <icsneo/communication/message/canmessage.h>
#include <icsneo/communication/message/canerrormessage.h>
#include <vector>
#include <tuple>
// Forward declare the safe_str_copy function for testing
extern bool safe_str_copy(char* dest, size_t* dest_size, std::string_view src);
TEST(icsneoc2, test_safe_str_copy)
{
char buffer[10] = {0};
size_t buffer_size = sizeof(buffer);
// Test normal copy
ASSERT_TRUE(safe_str_copy(buffer, &buffer_size, "test"));
ASSERT_STREQ(buffer, "test");
ASSERT_EQ(buffer_size, 4);
// Test copy with string too long - buffer should be null terminated, buffer_size should reflect truncated length
buffer_size = sizeof(buffer);
ASSERT_FALSE(safe_str_copy(buffer, &buffer_size, "this is a very long string")) << buffer << ": " << buffer_size;
ASSERT_EQ(buffer[sizeof(buffer) - 1], '\0');
ASSERT_STREQ(buffer, "this is a");
ASSERT_EQ(buffer_size, 9); // truncated to buffer capacity - 1
ASSERT_EQ(buffer[sizeof(buffer) - 1], '\0');
// Test null parameters - buffer_size should be unmodified on failure
buffer_size = sizeof(buffer);
ASSERT_FALSE(safe_str_copy(NULL, &buffer_size, "test"));
ASSERT_EQ(buffer_size, sizeof(buffer));
ASSERT_FALSE(safe_str_copy(buffer, NULL, "test"));
ASSERT_FALSE(safe_str_copy(NULL, NULL, "test"));
// Test empty string
buffer_size = sizeof(buffer);
memset(buffer, 0xCA, sizeof(buffer));
ASSERT_TRUE(safe_str_copy(buffer, &buffer_size, ""));
ASSERT_STREQ(buffer, "");
ASSERT_EQ(buffer_size, 0);
// Make sure the rest of the buffer is untouched (should be 0xCA)
for (size_t i = buffer_size + 1; i < sizeof(buffer) - 1; ++i)
{
ASSERT_EQ(buffer[i], '\xCA') << i << ") '" << buffer << "': " << buffer_size;
}
// Test string that fits exactly
buffer_size = sizeof(buffer);
ASSERT_TRUE(safe_str_copy(buffer, &buffer_size, "123456789"));
ASSERT_STREQ(buffer, "123456789");
ASSERT_EQ(buffer_size, 9);
ASSERT_EQ(buffer[sizeof(buffer) - 1], '\0');
// Test zero-size buffer - should always fail and write nothing
char tiny0[1] = {0};
buffer_size = 0;
ASSERT_FALSE(safe_str_copy(tiny0, &buffer_size, "test"));
ASSERT_FALSE(safe_str_copy(tiny0, &buffer_size, ""));
// Test single-byte buffer (room for null terminator only)
char tiny1[1];
buffer_size = sizeof(tiny1);
memset(tiny1, 0xFF, sizeof(tiny1));
ASSERT_FALSE(safe_str_copy(tiny1, &buffer_size, "test")); // non-empty: truncates to just '\0'
ASSERT_EQ(tiny1[0], '\0');
// Test single-byte buffer with empty string - should succeed and write just the null terminator
buffer_size = sizeof(tiny1);
memset(tiny1, 0xFF, sizeof(tiny1));
ASSERT_TRUE(safe_str_copy(tiny1, &buffer_size, "")); // empty string fits exactly
ASSERT_EQ(tiny1[0], '\0');
ASSERT_EQ(buffer_size, 0);
}
TEST(icsneoc2, test_icsneoc2_device_enumerate)
{
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_enumerate(0, NULL));
icsneoc2_device_info_t* devices = nullptr;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_device_enumerate(0, &devices));
icsneoc2_enumeration_free(devices);
}
TEST(icsneoc2, test_icsneoc2_device_is_valid)
{
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_is_valid(NULL));
}
TEST(icsneoc2, test_icsneoc2_error_invalid_parameters_and_invalid_device)
{
bool placeholderBool = false;
uint8_t placeholderInteger8 = 0;
uint32_t placeholderInteger32 = 0;
int64_t placeholderInteger64 = 0;
uint64_t placeholderUnsignedInteger64 = 0;
size_t placeholderSizeT = 0;
char placeholderStr[255] = {0};
icsneoc2_event_t *eventPlaceHolder = nullptr;
icsneoc2_lin_mode_t placeholderLinMode = 0;
icsneoc2_ae_link_mode_t placeholderAeLinkMode = 0;
icsneoc2_eth_phy_link_mode_t placeholderEthPhyLinkMode = 0;
icsneoc2_eth_phy_link_mode_t* placeholderEthPhyLinkModePtr = nullptr;
icsneoc2_misc_io_analog_voltage_t placeholderMiscIoAnalogVoltage = 0;
// All of these don't have a device parameter
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_enumerate(0, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_network_type_name_get(0, NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_event_description_get(eventPlaceHolder, placeholderStr, &placeholderSizeT));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_event_get(NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_type_name_get(0, NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_error_code_get(0, NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_netid_name_get(0, NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_can_create(NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_free(NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_data_get(NULL, NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_data_set(NULL, NULL, 0));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_netid_get(NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_netid_set(NULL, 0));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_network_type_get(NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_is_transmit(NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_is_error(NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_is_valid(NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_is_can_error(NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_can_error_props_get(NULL, NULL, NULL, NULL, NULL, NULL));
// LIN message NULL parameter checks
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_is_lin(NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_lin_create(NULL, 0));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_lin_props_get(NULL, NULL, NULL, NULL, NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_lin_props_set(NULL, NULL, NULL, NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_lin_err_flags_get(NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_lin_status_flags_get(NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_lin_calc_checksum(NULL));
// Test utility functions with NULL parameters
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_version_get(NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_serial_num_to_string(0, NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_serial_string_to_num(NULL, 0, NULL));
// Test new enumeration/info accessors with NULL parameters
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_info_serial_get(NULL, placeholderStr, &placeholderSizeT));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_info_type_get(NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_info_type_name_get(NULL, placeholderStr, &placeholderSizeT));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_info_description_get(NULL, placeholderStr, &placeholderSizeT));
// Test open/close with NULL parameters
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_create(NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_free(NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_open(NULL, 0));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_open_serial(NULL, 0, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_open_first(0, 0, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_close(NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_description_get(NULL, placeholderStr, &placeholderSizeT));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_go_online(NULL, false));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_is_online(NULL, &placeholderBool));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_is_online_supported(NULL, &placeholderBool));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_is_valid(NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_is_open(NULL, &placeholderBool));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_rtc_get(NULL, (int64_t *)&placeholderUnsignedInteger64));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_rtc_set(NULL, 0));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_serial_get(NULL, placeholderStr, &placeholderSizeT));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_pcb_serial_get(NULL, &placeholderInteger8, &placeholderSizeT));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_mac_address_get(NULL, &placeholderInteger8, &placeholderSizeT));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_supports_tc10(NULL, &placeholderBool));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_tc10_wake_request(NULL, icsneoc2_netid_dwcan_01));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_tc10_sleep_request(NULL, icsneoc2_netid_dwcan_01));
{
icsneoc2_tc10_sleep_status_t sleep_s = icsneoc2_tc10_sleep_status_no_sleep_received;
icsneoc2_tc10_wake_status_t wake_s = icsneoc2_tc10_wake_status_no_wake_received;
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_tc10_status_get(NULL, icsneoc2_netid_dwcan_01, &sleep_s, &wake_s));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_tc10_status_get(NULL, icsneoc2_netid_dwcan_01, NULL, NULL));
}
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_netid_network_type_get(icsneoc2_netid_dwcan_01, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_timestamp_resolution_get(NULL, &placeholderInteger32));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_digital_io_get(NULL, 0, 0, &placeholderBool));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_digital_io_set(NULL, 0, 0, false));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_type_get(NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_message_polling_limit_get(NULL, &placeholderInteger32));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_message_polling_limit_set(NULL, 0));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_message_get(NULL, NULL, 0));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_message_transmit(NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_apply_defaults(NULL, false));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_apply(NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_refresh(NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_baudrate_get(NULL, 0, &placeholderInteger64));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_baudrate_set(NULL, 0, placeholderInteger64));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_canfd_baudrate_get(NULL, 0, &placeholderInteger64));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_canfd_baudrate_set(NULL, 0, placeholderInteger64));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_termination_is_supported(NULL, 0, &placeholderBool));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_termination_can_enable(NULL, 0, &placeholderBool));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_termination_is_enabled(NULL, 0, &placeholderBool));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_termination_set(NULL, 0, false));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_commander_resistor_enabled(NULL, 0, &placeholderBool));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_commander_resistor_set(NULL, 0, false));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_lin_mode_get(NULL, 0, &placeholderLinMode));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_lin_mode_set(NULL, 0, placeholderLinMode));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_lin_commander_response_time_get(NULL, 0, &placeholderInteger8));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_lin_commander_response_time_set(NULL, 0, placeholderInteger8));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_phy_enable_get(NULL, 0, &placeholderBool));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_phy_enable_set(NULL, 0, false));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_phy_mode_get(NULL, 0, &placeholderAeLinkMode));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_phy_mode_set(NULL, 0, placeholderAeLinkMode));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_phy_speed_get(NULL, 0, &placeholderEthPhyLinkMode));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_phy_speed_set(NULL, 0, placeholderEthPhyLinkMode));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_phy_role_for_get(NULL, 0, &placeholderAeLinkMode));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_phy_role_for_set(NULL, 0, placeholderAeLinkMode));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_phy_link_mode_for_get(NULL, 0, &placeholderEthPhyLinkMode));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_phy_link_mode_for_set(NULL, 0, placeholderEthPhyLinkMode));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_phy_enable_for_get(NULL, 0, &placeholderBool));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_phy_enable_for_set(NULL, 0, false));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_supported_phy_link_modes_for(NULL, 0, &placeholderEthPhyLinkModePtr, &placeholderSizeT));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_is_plca_enabled_for(NULL, 0, &placeholderBool));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_plca_enabled_for_set(NULL, 0, false));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_local_id_get(NULL, 0, &placeholderInteger8));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_local_id_set(NULL, 0, placeholderInteger8));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_max_nodes_get(NULL, 0, &placeholderInteger8));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_max_nodes_set(NULL, 0, placeholderInteger8));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_tx_opp_timer_get(NULL, 0, &placeholderInteger8));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_tx_opp_timer_set(NULL, 0, placeholderInteger8));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_max_burst_timer_for_get(NULL, 0, &placeholderInteger8));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_max_burst_timer_for_set(NULL, 0, placeholderInteger8));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_burst_timer_get(NULL, 0, &placeholderInteger8));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_burst_timer_set(NULL, 0, placeholderInteger8));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_local_id_alternate_get(NULL, 0, &placeholderInteger8));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_local_id_alternate_set(NULL, 0, placeholderInteger8));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_is_termination_enabled_for(NULL, 0, &placeholderBool));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_termination_for_set(NULL, 0, false));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_is_bus_decoding_beacons_enabled_for(NULL, 0, &placeholderBool));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_bus_decoding_beacons_for_set(NULL, 0, false));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_is_bus_decoding_all_enabled_for(NULL, 0, &placeholderBool));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_bus_decoding_all_for_set(NULL, 0, false));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_multi_id_enable_mask_get(NULL, 0, &placeholderInteger8));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_multi_id_enable_mask_set(NULL, 0, placeholderInteger8));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_multi_id_get(NULL, 0, 0, &placeholderInteger8));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_multi_id_set(NULL, 0, 0, placeholderInteger8));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_misc_io_analog_output_enabled_set(NULL, 0, placeholderInteger8));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_misc_io_analog_output_set(NULL, 0, placeholderMiscIoAnalogVoltage));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_disabled_get(NULL, &placeholderBool));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_readonly_get(NULL, &placeholderBool));
// Disk formatting functions
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_disk_count_get(NULL, &placeholderSizeT));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_supports_disk_formatting(NULL, &placeholderBool));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_disk_details_get(NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_format_disk(NULL, NULL, NULL, NULL));
// Disk details accessors with NULL details
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_disk_details_count_get(NULL, &placeholderSizeT));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_disk_details_count_get(NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_disk_details_layout_get(NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_disk_details_layout_set(NULL, 0));
icsneoc2_disk_format_flags_t placeholderFlags = 0;
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_disk_details_flags_get(NULL, 0, &placeholderFlags));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_disk_details_flags_get(NULL, 0, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_disk_details_flags_set(NULL, 0, placeholderFlags));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_disk_details_flags_set(NULL, 0, 0));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_disk_details_size_get(NULL, 0, &placeholderUnsignedInteger64, &placeholderUnsignedInteger64));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_disk_details_size_get(NULL, 0, NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_disk_details_full_format_get(NULL, &placeholderBool));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_disk_details_full_format_get(NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_disk_details_full_format_set(NULL, false));
// Supported networks
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_supported_rx_networks_get(NULL, NULL, &placeholderSizeT));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_supported_rx_networks_get(NULL, NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_supported_tx_networks_get(NULL, NULL, &placeholderSizeT));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_supported_tx_networks_get(NULL, NULL, NULL));
// Script functions
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_supports_coremini_script(NULL, &placeholderBool));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_supports_coremini_script(NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_script_start(NULL, icsneoc2_memory_type_sd));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_script_stop(NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_script_clear(NULL, icsneoc2_memory_type_sd));
int8_t placeholderSignedInteger8 = 0;
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_script_prepare_load(NULL, &placeholderSignedInteger8));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_script_prepare_load(NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_coremini_upload_file(NULL, "test.bin", icsneoc2_memory_type_sd));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_coremini_upload_file(NULL, NULL, icsneoc2_memory_type_sd));
const uint8_t placeholderData[] = {0};
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_coremini_upload(NULL, placeholderData, sizeof(placeholderData), icsneoc2_memory_type_sd));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_coremini_upload(NULL, NULL, 0, icsneoc2_memory_type_sd));
icsneoc2_script_status_t* placeholderScriptStatus = NULL;
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_script_status_get(NULL, &placeholderScriptStatus));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_script_status_get(NULL, NULL));
// Script status accessors with NULL handle
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_script_status_is_coremini_running(NULL, &placeholderBool));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_script_status_is_coremini_running(NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_script_status_is_encrypted(NULL, &placeholderBool));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_script_status_sector_overflows_get(NULL, &placeholderInteger32));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_script_status_sector_overflows_get(NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_script_status_remaining_sector_buffers_get(NULL, &placeholderInteger32));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_script_status_last_sector_get(NULL, &placeholderInteger32));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_script_status_read_bin_size_get(NULL, &placeholderInteger32));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_script_status_min_sector_get(NULL, &placeholderInteger32));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_script_status_max_sector_get(NULL, &placeholderInteger32));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_script_status_current_sector_get(NULL, &placeholderInteger32));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_script_status_coremini_create_time_get(NULL, &placeholderUnsignedInteger64));
uint16_t placeholderInteger16 = 0;
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_script_status_file_checksum_get(NULL, &placeholderInteger16));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_script_status_coremini_version_get(NULL, &placeholderInteger16));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_script_status_coremini_header_size_get(NULL, &placeholderInteger16));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_script_status_diagnostic_error_code_get(NULL, &placeholderInteger8));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_script_status_diagnostic_error_code_count_get(NULL, &placeholderInteger8));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_script_status_max_coremini_size_kb_get(NULL, &placeholderInteger16));
// Ethernet message functions
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_eth_create(NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_eth_props_set(NULL, NULL, NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_eth_props_get(NULL, NULL, NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_eth_mac_get(NULL, NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_eth_ether_type_get(NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_eth_t1s_props_set(NULL, NULL, NULL, NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_eth_t1s_props_get(NULL, NULL, NULL, NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_is_ethernet(NULL, NULL));
}
TEST(icsneoc2, test_icsneoc2_devicetype_t)
{
ASSERT_EQ(icsneoc2_devicetype_unknown, 0x00000000);
ASSERT_EQ(icsneoc2_devicetype_blue, 0x00000001);
ASSERT_EQ(icsneoc2_devicetype_ecu_avb, 0x00000002);
ASSERT_EQ(icsneoc2_devicetype_rad_supermoon, 0x00000003);
ASSERT_EQ(icsneoc2_devicetype_dw_vcan, 0x00000004);
ASSERT_EQ(icsneoc2_devicetype_rad_moon2, 0x00000005);
ASSERT_EQ(icsneoc2_devicetype_rad_mars, 0x00000006);
ASSERT_EQ(icsneoc2_devicetype_vcan41, 0x00000007);
ASSERT_EQ(icsneoc2_devicetype_fire, 0x00000008);
ASSERT_EQ(icsneoc2_devicetype_rad_pluto, 0x00000009);
ASSERT_EQ(icsneoc2_devicetype_vcan42_el, 0x0000000a);
ASSERT_EQ(icsneoc2_devicetype_radio_canhub, 0x0000000b);
ASSERT_EQ(icsneoc2_devicetype_neo_ecu12, 0x0000000c);
ASSERT_EQ(icsneoc2_devicetype_obd2_lc_badge, 0x0000000d);
ASSERT_EQ(icsneoc2_devicetype_rad_moon_duo, 0x0000000e);
ASSERT_EQ(icsneoc2_devicetype_fire3, 0x0000000f);
ASSERT_EQ(icsneoc2_devicetype_vcan3, 0x00000010);
ASSERT_EQ(icsneoc2_devicetype_rad_jupiter, 0x00000011);
ASSERT_EQ(icsneoc2_devicetype_vcan4_industrial, 0x00000012);
ASSERT_EQ(icsneoc2_devicetype_rad_gigastar, 0x00000013);
ASSERT_EQ(icsneoc2_devicetype_red2, 0x00000014);
ASSERT_EQ(icsneoc2_devicetype_etherbadge, 0x00000016);
ASSERT_EQ(icsneoc2_devicetype_rad_a2b, 0x00000017);
ASSERT_EQ(icsneoc2_devicetype_rad_epsilon, 0x00000018);
ASSERT_EQ(icsneoc2_devicetype_rad_epsilon_xl, 0x0000001e);
ASSERT_EQ(icsneoc2_devicetype_rad_galaxy2, 0x00000021);
ASSERT_EQ(icsneoc2_devicetype_rad_moon3, 0x00000023);
ASSERT_EQ(icsneoc2_devicetype_rad_comet, 0x00000024);
ASSERT_EQ(icsneoc2_devicetype_fire3_flexray, 0x00000025);
ASSERT_EQ(icsneoc2_devicetype_connect, 0x00000026);
ASSERT_EQ(icsneoc2_devicetype_rad_comet3, 0x00000027);
ASSERT_EQ(icsneoc2_devicetype_rad_moon_t1s, 0x00000028);
ASSERT_EQ(icsneoc2_devicetype_rad_gigastar2, 0x00000029);
ASSERT_EQ(icsneoc2_devicetype_fire3_t1s_lin, 0x0000002a);
ASSERT_EQ(icsneoc2_devicetype_fire3_t1s_sent, 0x0000002b);
ASSERT_EQ(icsneoc2_devicetype_rad_gemini, 0x0000002c);
ASSERT_EQ(icsneoc2_devicetype_red, 0x00000040);
ASSERT_EQ(icsneoc2_devicetype_ecu, 0x00000080);
ASSERT_EQ(icsneoc2_devicetype_ievb, 0x00000100);
ASSERT_EQ(icsneoc2_devicetype_pendant, 0x00000200);
ASSERT_EQ(icsneoc2_devicetype_obd2_pro, 0x00000400);
ASSERT_EQ(icsneoc2_devicetype_ecuchip_uart, 0x00000800);
ASSERT_EQ(icsneoc2_devicetype_plasma, 0x00001000);
ASSERT_EQ(icsneoc2_devicetype_neo_analog, 0x00004000);
ASSERT_EQ(icsneoc2_devicetype_ct_obd, 0x00008000);
ASSERT_EQ(icsneoc2_devicetype_ion, 0x00040000);
ASSERT_EQ(icsneoc2_devicetype_rad_star, 0x00080000);
ASSERT_EQ(icsneoc2_devicetype_vcan44, 0x00200000);
ASSERT_EQ(icsneoc2_devicetype_vcan42, 0x00400000);
ASSERT_EQ(icsneoc2_devicetype_cm_probe, 0x00800000);
ASSERT_EQ(icsneoc2_devicetype_eevb, 0x01000000);
ASSERT_EQ(icsneoc2_devicetype_vcan_rf, 0x02000000);
ASSERT_EQ(icsneoc2_devicetype_fire2, 0x04000000);
ASSERT_EQ(icsneoc2_devicetype_flex, 0x08000000);
ASSERT_EQ(icsneoc2_devicetype_rad_galaxy, 0x10000000);
ASSERT_EQ(icsneoc2_devicetype_rad_star2, 0x20000000);
ASSERT_EQ(icsneoc2_devicetype_vividcan, 0x40000000);
ASSERT_EQ(icsneoc2_devicetype_obd2_sim, 0x80000000);
ASSERT_EQ(icsneoc2_devicetype_maxsize, 0x80000001);
ASSERT_EQ(sizeof(icsneoc2_devicetype_t), sizeof(uint32_t));
}
TEST(icsneoc2, test_devicetype_enum_alignment)
{
ASSERT_EQ(icsneo::DeviceType::Unknown, icsneoc2_devicetype_unknown);
ASSERT_EQ(icsneo::DeviceType::BLUE, icsneoc2_devicetype_blue);
ASSERT_EQ(icsneo::DeviceType::ECU_AVB, icsneoc2_devicetype_ecu_avb);
ASSERT_EQ(icsneo::DeviceType::RADSupermoon, icsneoc2_devicetype_rad_supermoon);
ASSERT_EQ(icsneo::DeviceType::DW_VCAN, icsneoc2_devicetype_dw_vcan);
ASSERT_EQ(icsneo::DeviceType::RADMoon2, icsneoc2_devicetype_rad_moon2);
ASSERT_EQ(icsneo::DeviceType::RADMars, icsneoc2_devicetype_rad_mars);
ASSERT_EQ(icsneo::DeviceType::VCAN4_1, icsneoc2_devicetype_vcan41);
ASSERT_EQ(icsneo::DeviceType::FIRE, icsneoc2_devicetype_fire);
ASSERT_EQ(icsneo::DeviceType::RADPluto, icsneoc2_devicetype_rad_pluto);
ASSERT_EQ(icsneo::DeviceType::VCAN4_2EL, icsneoc2_devicetype_vcan42_el);
ASSERT_EQ(icsneo::DeviceType::RADIO_CANHUB, icsneoc2_devicetype_radio_canhub);
ASSERT_EQ(icsneo::DeviceType::NEOECU12, icsneoc2_devicetype_neo_ecu12);
ASSERT_EQ(icsneo::DeviceType::OBD2_LCBADGE, icsneoc2_devicetype_obd2_lc_badge);
ASSERT_EQ(icsneo::DeviceType::RADMoonDuo, icsneoc2_devicetype_rad_moon_duo);
ASSERT_EQ(icsneo::DeviceType::FIRE3, icsneoc2_devicetype_fire3);
ASSERT_EQ(icsneo::DeviceType::VCAN3, icsneoc2_devicetype_vcan3);
ASSERT_EQ(icsneo::DeviceType::RADJupiter, icsneoc2_devicetype_rad_jupiter);
ASSERT_EQ(icsneo::DeviceType::VCAN4_IND, icsneoc2_devicetype_vcan4_industrial);
ASSERT_EQ(icsneo::DeviceType::RADGigastar, icsneoc2_devicetype_rad_gigastar);
ASSERT_EQ(icsneo::DeviceType::RED2, icsneoc2_devicetype_red2);
ASSERT_EQ(icsneo::DeviceType::EtherBADGE, icsneoc2_devicetype_etherbadge);
ASSERT_EQ(icsneo::DeviceType::RAD_A2B, icsneoc2_devicetype_rad_a2b);
ASSERT_EQ(icsneo::DeviceType::RADEpsilon, icsneoc2_devicetype_rad_epsilon);
ASSERT_EQ(icsneo::DeviceType::RADEpsilonXL, icsneoc2_devicetype_rad_epsilon_xl);
ASSERT_EQ(icsneo::DeviceType::RADMoon3, icsneoc2_devicetype_rad_moon3);
ASSERT_EQ(icsneo::DeviceType::RADComet, icsneoc2_devicetype_rad_comet);
ASSERT_EQ(icsneo::DeviceType::FIRE3_FlexRay, icsneoc2_devicetype_fire3_flexray);
ASSERT_EQ(icsneo::DeviceType::Connect, icsneoc2_devicetype_connect);
ASSERT_EQ(icsneo::DeviceType::RADComet3, icsneoc2_devicetype_rad_comet3);
ASSERT_EQ(icsneo::DeviceType::RADMoonT1S, icsneoc2_devicetype_rad_moon_t1s);
ASSERT_EQ(icsneo::DeviceType::RADGigastar2, icsneoc2_devicetype_rad_gigastar2);
ASSERT_EQ(icsneo::DeviceType::FIRE3_T1S_LIN, icsneoc2_devicetype_fire3_t1s_lin);
ASSERT_EQ(icsneo::DeviceType::FIRE3_T1S_SENT, icsneoc2_devicetype_fire3_t1s_sent);
ASSERT_EQ(icsneo::DeviceType::RADGemini, icsneoc2_devicetype_rad_gemini);
ASSERT_EQ(icsneo::DeviceType::RED, icsneoc2_devicetype_red);
ASSERT_EQ(icsneo::DeviceType::ECU, icsneoc2_devicetype_ecu);
ASSERT_EQ(icsneo::DeviceType::IEVB, icsneoc2_devicetype_ievb);
ASSERT_EQ(icsneo::DeviceType::Pendant, icsneoc2_devicetype_pendant);
ASSERT_EQ(icsneo::DeviceType::OBD2_PRO, icsneoc2_devicetype_obd2_pro);
ASSERT_EQ(icsneo::DeviceType::ECUChip_UART, icsneoc2_devicetype_ecuchip_uart);
ASSERT_EQ(icsneo::DeviceType::PLASMA, icsneoc2_devicetype_plasma);
ASSERT_EQ(icsneo::DeviceType::NEOAnalog, icsneoc2_devicetype_neo_analog);
ASSERT_EQ(icsneo::DeviceType::CT_OBD, icsneoc2_devicetype_ct_obd);
ASSERT_EQ(icsneo::DeviceType::ION, icsneoc2_devicetype_ion);
ASSERT_EQ(icsneo::DeviceType::RADStar, icsneoc2_devicetype_rad_star);
ASSERT_EQ(icsneo::DeviceType::VCAN4_4, icsneoc2_devicetype_vcan44);
ASSERT_EQ(icsneo::DeviceType::VCAN4_2, icsneoc2_devicetype_vcan42);
ASSERT_EQ(icsneo::DeviceType::CMProbe, icsneoc2_devicetype_cm_probe);
ASSERT_EQ(icsneo::DeviceType::EEVB, icsneoc2_devicetype_eevb);
ASSERT_EQ(icsneo::DeviceType::VCANrf, icsneoc2_devicetype_vcan_rf);
ASSERT_EQ(icsneo::DeviceType::FIRE2, icsneoc2_devicetype_fire2);
ASSERT_EQ(icsneo::DeviceType::Flex, icsneoc2_devicetype_flex);
ASSERT_EQ(icsneo::DeviceType::RADGalaxy, icsneoc2_devicetype_rad_galaxy);
ASSERT_EQ(icsneo::DeviceType::RADStar2, icsneoc2_devicetype_rad_star2);
ASSERT_EQ(icsneo::DeviceType::VividCAN, icsneoc2_devicetype_vividcan);
ASSERT_EQ(icsneo::DeviceType::OBD2_SIM, icsneoc2_devicetype_obd2_sim);
ASSERT_EQ(icsneo::DeviceType::RADGalaxy2, icsneoc2_devicetype_rad_galaxy2);
}
TEST(icsneoc2, icsneoc2_network_type_t)
{
ASSERT_EQ(icsneoc2_network_type_invalid, 0);
ASSERT_EQ(icsneoc2_network_type_internal, 1);
ASSERT_EQ(icsneoc2_network_type_can, 2);
ASSERT_EQ(icsneoc2_network_type_lin, 3);
ASSERT_EQ(icsneoc2_network_type_flexray, 4);
ASSERT_EQ(icsneoc2_network_type_most, 5);
ASSERT_EQ(icsneoc2_network_type_ethernet, 6);
ASSERT_EQ(icsneoc2_network_type_lsftcan, 7);
ASSERT_EQ(icsneoc2_network_type_swcan, 8);
ASSERT_EQ(icsneoc2_network_type_iso9141, 9);
ASSERT_EQ(icsneoc2_network_type_i2c, 10);
ASSERT_EQ(icsneoc2_network_type_a2b, 11);
ASSERT_EQ(icsneoc2_network_type_spi, 12);
ASSERT_EQ(icsneoc2_network_type_mdio, 13);
ASSERT_EQ(icsneoc2_network_type_automotive_ethernet, 14);
ASSERT_EQ(icsneoc2_network_type_maxsize, 15);
ASSERT_EQ(sizeof(icsneoc2_network_type_t), sizeof(uint8_t));
}
TEST(icsneoc2, test_icsneoc2_netid_network_type_get)
{
icsneoc2_network_type_t type = icsneoc2_network_type_invalid;
// CAN
ASSERT_EQ(icsneoc2_error_success, icsneoc2_netid_network_type_get(icsneoc2_netid_dwcan_01, &type));
ASSERT_EQ(icsneoc2_network_type_can, type);
// LIN
type = icsneoc2_network_type_invalid;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_netid_network_type_get(icsneoc2_netid_lin_01, &type));
ASSERT_EQ(icsneoc2_network_type_lin, type);
// Ethernet
type = icsneoc2_network_type_invalid;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_netid_network_type_get(icsneoc2_netid_ethernet_01, &type));
ASSERT_EQ(icsneoc2_network_type_ethernet, type);
// Automotive Ethernet
type = icsneoc2_network_type_invalid;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_netid_network_type_get(icsneoc2_netid_ae_01, &type));
ASSERT_EQ(icsneoc2_network_type_automotive_ethernet, type);
// SWCAN
type = icsneoc2_network_type_invalid;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_netid_network_type_get(icsneoc2_netid_swcan_01, &type));
ASSERT_EQ(icsneoc2_network_type_swcan, type);
// LSFTCAN
type = icsneoc2_network_type_invalid;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_netid_network_type_get(icsneoc2_netid_lsftcan_01, &type));
ASSERT_EQ(icsneoc2_network_type_lsftcan, type);
}
TEST(icsneoc2, test_icsneoc2_tc10_wake_status_t)
{
ASSERT_EQ(icsneoc2_tc10_wake_status_no_wake_received, 0);
ASSERT_EQ(icsneoc2_tc10_wake_status_wake_received, 1);
ASSERT_EQ(icsneoc2_tc10_wake_status_maxsize, 2);
ASSERT_EQ(sizeof(icsneoc2_tc10_wake_status_t), sizeof(uint8_t));
}
TEST(icsneoc2, test_icsneoc2_tc10_sleep_status_t)
{
ASSERT_EQ(icsneoc2_tc10_sleep_status_no_sleep_received, 0);
ASSERT_EQ(icsneoc2_tc10_sleep_status_sleep_received, 1);
ASSERT_EQ(icsneoc2_tc10_sleep_status_sleep_failed, 2);
ASSERT_EQ(icsneoc2_tc10_sleep_status_sleep_aborted, 3);
ASSERT_EQ(icsneoc2_tc10_sleep_status_maxsize, 4);
ASSERT_EQ(sizeof(icsneoc2_tc10_sleep_status_t), sizeof(uint8_t));
}
TEST(icsneoc2, test_icsneoc2_io_type_t)
{
ASSERT_EQ(icsneoc2_io_type_eth_activation, 0);
ASSERT_EQ(icsneoc2_io_type_usb_host_power, 1);
ASSERT_EQ(icsneoc2_io_type_backup_power_en, 2);
ASSERT_EQ(icsneoc2_io_type_backup_power_good, 3);
ASSERT_EQ(icsneoc2_io_type_misc, 4);
ASSERT_EQ(icsneoc2_io_type_emisc, 5);
ASSERT_EQ(sizeof(icsneoc2_io_type_t), sizeof(uint32_t));
}
TEST(icsneoc2, test_icsneoc2_netid_t)
{
ASSERT_EQ(icsneoc2_netid_device, 0);
ASSERT_EQ(icsneoc2_netid_dwcan_01, 1);
ASSERT_EQ(icsneoc2_netid_dwcan_08, 2);
ASSERT_EQ(icsneoc2_netid_swcan_01, 3);
ASSERT_EQ(icsneoc2_netid_lsftcan_01, 4);
ASSERT_EQ(icsneoc2_netid_fordscp, 5);
ASSERT_EQ(icsneoc2_netid_j1708, 6);
ASSERT_EQ(icsneoc2_netid_aux, 7);
ASSERT_EQ(icsneoc2_netid_j1850vpw, 8);
ASSERT_EQ(icsneoc2_netid_iso9141, 9);
ASSERT_EQ(icsneoc2_netid_disk_data, 10);
ASSERT_EQ(icsneoc2_netid_main51, 11);
ASSERT_EQ(icsneoc2_netid_red, 12);
ASSERT_EQ(icsneoc2_netid_sci, 13);
ASSERT_EQ(icsneoc2_netid_iso9141_02, 14);
ASSERT_EQ(icsneoc2_netid_iso14230, 15);
ASSERT_EQ(icsneoc2_netid_lin_01, 16);
ASSERT_EQ(icsneoc2_netid_ae_01, 17);
ASSERT_EQ(icsneoc2_netid_ae_02, 18);
ASSERT_EQ(icsneoc2_netid_ae_03, 19);
ASSERT_EQ(icsneoc2_netid_red_ext_memoryread, 20);
ASSERT_EQ(icsneoc2_netid_red_int_memoryread, 21);
ASSERT_EQ(icsneoc2_netid_red_dflash_read, 22);
ASSERT_EQ(icsneoc2_netid_neo_memory_sdread, 23); // Response from NeoMemory (MemoryTypeSD)
ASSERT_EQ(icsneoc2_netid_can_errbits, 24);
ASSERT_EQ(icsneoc2_netid_neo_memory_write_done, 25);
ASSERT_EQ(icsneoc2_netid_red_wave_can1_logical, 26);
ASSERT_EQ(icsneoc2_netid_red_wave_can2_logical, 27);
ASSERT_EQ(icsneoc2_netid_red_wave_lin1_logical, 28);
ASSERT_EQ(icsneoc2_netid_red_wave_lin2_logical, 29);
ASSERT_EQ(icsneoc2_netid_red_wave_lin1_analog, 30);
ASSERT_EQ(icsneoc2_netid_red_wave_lin2_analog, 31);
ASSERT_EQ(icsneoc2_netid_red_wave_misc_analog, 32);
ASSERT_EQ(icsneoc2_netid_red_wave_miscdio2_logical, 33);
ASSERT_EQ(icsneoc2_netid_red_network_com_enable_ex, 34);
ASSERT_EQ(icsneoc2_netid_red_neovi_network, 35);
ASSERT_EQ(icsneoc2_netid_red_read_baud_settings, 36);
ASSERT_EQ(icsneoc2_netid_red_oldformat, 37);
ASSERT_EQ(icsneoc2_netid_red_scope_capture, 38);
ASSERT_EQ(icsneoc2_netid_red_hardware_excep, 39);
ASSERT_EQ(icsneoc2_netid_red_get_rtc, 40);
ASSERT_EQ(icsneoc2_netid_iso9141_03, 41);
ASSERT_EQ(icsneoc2_netid_dwcan_02, 42);
ASSERT_EQ(icsneoc2_netid_dwcan_03, 44);
ASSERT_EQ(icsneoc2_netid_ae_04, 45);
ASSERT_EQ(icsneoc2_netid_ae_05, 46);
ASSERT_EQ(icsneoc2_netid_iso9141_04, 47);
ASSERT_EQ(icsneoc2_netid_lin_02, 48);
ASSERT_EQ(icsneoc2_netid_lin_03, 49);
ASSERT_EQ(icsneoc2_netid_lin_04, 50);
ASSERT_EQ(icsneoc2_netid_most_unused, 51); // MOST = 51, Old and unused
ASSERT_EQ(icsneoc2_netid_red_app_error, 52);
ASSERT_EQ(icsneoc2_netid_cgi, 53);
ASSERT_EQ(icsneoc2_netid_reset_status, 54);
ASSERT_EQ(icsneoc2_netid_fb_status, 55);
ASSERT_EQ(icsneoc2_netid_app_signal_status, 56);
ASSERT_EQ(icsneoc2_netid_read_datalink_cm_tx_msg, 57);
ASSERT_EQ(icsneoc2_netid_read_datalink_cm_rx_msg, 58);
ASSERT_EQ(icsneoc2_netid_logging_overflow, 59);
ASSERT_EQ(icsneoc2_netid_read_settings, 60);
ASSERT_EQ(icsneoc2_netid_dwcan_04, 61);
ASSERT_EQ(icsneoc2_netid_dwcan_05, 62);
ASSERT_EQ(icsneoc2_netid_rs232, 63);
ASSERT_EQ(icsneoc2_netid_uart_01, 64);
ASSERT_EQ(icsneoc2_netid_uart_02, 65);
ASSERT_EQ(icsneoc2_netid_uart_03, 66);
ASSERT_EQ(icsneoc2_netid_uart_04, 67);
ASSERT_EQ(icsneoc2_netid_swcan_02, 68);
ASSERT_EQ(icsneoc2_netid_ethernet_daq, 69);
ASSERT_EQ(icsneoc2_netid_data_to_host, 70);
ASSERT_EQ(icsneoc2_netid_textapi_to_host, 71);
ASSERT_EQ(icsneoc2_netid_spi_01, 72);
ASSERT_EQ(icsneoc2_netid_ae_06, 73);
ASSERT_EQ(icsneoc2_netid_red_vbat, 74);
ASSERT_EQ(icsneoc2_netid_ae_07, 75);
ASSERT_EQ(icsneoc2_netid_ae_08, 76);
ASSERT_EQ(icsneoc2_netid_ae_09, 77);
ASSERT_EQ(icsneoc2_netid_ae_10, 78);
ASSERT_EQ(icsneoc2_netid_ae_11, 79);
ASSERT_EQ(icsneoc2_netid_flexray_01a, 80);
ASSERT_EQ(icsneoc2_netid_flexray_01b, 81);
ASSERT_EQ(icsneoc2_netid_flexray_02a, 82);
ASSERT_EQ(icsneoc2_netid_flexray_02b, 83);
ASSERT_EQ(icsneoc2_netid_lin_05, 84);
ASSERT_EQ(icsneoc2_netid_flexray_01, 85);
ASSERT_EQ(icsneoc2_netid_flexray_02, 86);
ASSERT_EQ(icsneoc2_netid_ae_12, 87);
ASSERT_EQ(icsneoc2_netid_i2c_01, 88);
ASSERT_EQ(icsneoc2_netid_most_25, 90);
ASSERT_EQ(icsneoc2_netid_most_50, 91);
ASSERT_EQ(icsneoc2_netid_most_150, 92);
ASSERT_EQ(icsneoc2_netid_ethernet_01, 93);
ASSERT_EQ(icsneoc2_netid_gmfsa, 94);
ASSERT_EQ(icsneoc2_netid_tcp, 95);
ASSERT_EQ(icsneoc2_netid_dwcan_06, 96);
ASSERT_EQ(icsneoc2_netid_dwcan_07, 97);
ASSERT_EQ(icsneoc2_netid_lin_06, 98);
ASSERT_EQ(icsneoc2_netid_lsftcan_02, 99);
ASSERT_EQ(icsneoc2_netid_logical_disk_info, 187);
ASSERT_EQ(icsneoc2_netid_wivi_command, 221);
ASSERT_EQ(icsneoc2_netid_script_status, 224);
ASSERT_EQ(icsneoc2_netid_eth_phy_control, 239);
ASSERT_EQ(icsneoc2_netid_extended_command, 240);
ASSERT_EQ(icsneoc2_netid_extended_data, 242);
ASSERT_EQ(icsneoc2_netid_flexray_control, 243);
ASSERT_EQ(icsneoc2_netid_coremini_preload, 244);
ASSERT_EQ(icsneoc2_netid_hw_com_latency_test, 512);
ASSERT_EQ(icsneoc2_netid_device_status, 513);
ASSERT_EQ(icsneoc2_netid_udp, 514);
ASSERT_EQ(icsneoc2_netid_forwarded_message, 516);
ASSERT_EQ(icsneoc2_netid_i2c_02, 517);
ASSERT_EQ(icsneoc2_netid_i2c_03, 518);
ASSERT_EQ(icsneoc2_netid_i2c_04, 519);
ASSERT_EQ(icsneoc2_netid_ethernet_02, 520);
ASSERT_EQ(icsneoc2_netid_ethernet_tx_wrap, 521);
ASSERT_EQ(icsneoc2_netid_a2b_01, 522);
ASSERT_EQ(icsneoc2_netid_a2b_02, 523);
ASSERT_EQ(icsneoc2_netid_ethernet_03, 524);
ASSERT_EQ(icsneoc2_netid_wbms_01, 532);
ASSERT_EQ(icsneoc2_netid_dwcan_09, 534);
ASSERT_EQ(icsneoc2_netid_dwcan_10, 535);
ASSERT_EQ(icsneoc2_netid_dwcan_11, 536);
ASSERT_EQ(icsneoc2_netid_dwcan_12, 537);
ASSERT_EQ(icsneoc2_netid_dwcan_13, 538);
ASSERT_EQ(icsneoc2_netid_dwcan_14, 539);
ASSERT_EQ(icsneoc2_netid_dwcan_15, 540);
ASSERT_EQ(icsneoc2_netid_dwcan_16, 541);
ASSERT_EQ(icsneoc2_netid_lin_07, 542);
ASSERT_EQ(icsneoc2_netid_lin_08, 543);
ASSERT_EQ(icsneoc2_netid_spi_02, 544);
ASSERT_EQ(icsneoc2_netid_mdio_01, 545);
ASSERT_EQ(icsneoc2_netid_mdio_02, 546);
ASSERT_EQ(icsneoc2_netid_mdio_03, 547);
ASSERT_EQ(icsneoc2_netid_mdio_04, 548);
ASSERT_EQ(icsneoc2_netid_mdio_05, 549);
ASSERT_EQ(icsneoc2_netid_mdio_06, 550);
ASSERT_EQ(icsneoc2_netid_mdio_07, 551);
ASSERT_EQ(icsneoc2_netid_mdio_08, 552);
ASSERT_EQ(icsneoc2_netid_ae_13, 553);
ASSERT_EQ(icsneoc2_netid_ae_14, 554);
ASSERT_EQ(icsneoc2_netid_ae_15, 555);
ASSERT_EQ(icsneoc2_netid_ae_16, 556);
ASSERT_EQ(icsneoc2_netid_spi_03, 557);
ASSERT_EQ(icsneoc2_netid_spi_04, 558);
ASSERT_EQ(icsneoc2_netid_spi_05, 559);
ASSERT_EQ(icsneoc2_netid_spi_06, 560);
ASSERT_EQ(icsneoc2_netid_spi_07, 561);
ASSERT_EQ(icsneoc2_netid_spi_08, 562);
ASSERT_EQ(icsneoc2_netid_lin_09, 563);
ASSERT_EQ(icsneoc2_netid_lin_10, 564);
ASSERT_EQ(icsneoc2_netid_lin_11, 565);
ASSERT_EQ(icsneoc2_netid_lin_12, 566);
ASSERT_EQ(icsneoc2_netid_lin_13, 567);
ASSERT_EQ(icsneoc2_netid_lin_14, 568);
ASSERT_EQ(icsneoc2_netid_lin_15, 569);
ASSERT_EQ(icsneoc2_netid_lin_16, 570);
ASSERT_EQ(icsneoc2_netid_maxsize, 571);
}
TEST(icsneoc2, test_icsneoc2_open_options_default)
{
icsneoc2_open_options_t expected = ICSNEOC2_OPEN_OPTIONS_GO_ONLINE | ICSNEOC2_OPEN_OPTIONS_SYNC_RTC | ICSNEOC2_OPEN_OPTIONS_ENABLE_AUTO_UPDATE;
ASSERT_EQ(icsneoc2_open_options_default, expected);
}
TEST(icsneoc2, test_icsneoc2_message_is_error)
{
icsneoc2_message_t message;
message.message = std::make_shared<CANMessage>();
bool value = false;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_is_error(&message, &value));
ASSERT_FALSE(value);
auto frame = std::dynamic_pointer_cast<Frame>(message.message);
ASSERT_NE(frame, nullptr);
frame->error = true;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_is_error(&message, &value));
ASSERT_TRUE(value);
icsneoc2_message_t raw_message;
raw_message.message = std::make_shared<CANErrorMessage>();
ASSERT_EQ(icsneoc2_error_invalid_type, icsneoc2_message_is_error(&raw_message, &value));
}
TEST(icsneoc2, test_icsneoc2_message_can_props_get_can_tx_flags)
{
icsneoc2_message_t message;
auto can_message = std::make_shared<CANMessage>();
message.message = can_message;
uint64_t arb_id = 0;
icsneoc2_message_can_flags_t flags = 0;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_can_props_get(&message, &arb_id, &flags));
ASSERT_EQ(arb_id, 0u);
ASSERT_EQ(flags, 0u);
can_message->txAborted = true;
can_message->txLostArb = true;
can_message->txError = true;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_can_props_get(&message, &arb_id, &flags));
ASSERT_EQ(flags,
ICSNEOC2_MESSAGE_CAN_FLAGS_TX_ABORTED |
ICSNEOC2_MESSAGE_CAN_FLAGS_TX_LOST_ARB |
ICSNEOC2_MESSAGE_CAN_FLAGS_TX_ERROR);
}
TEST(icsneoc2, test_icsneoc2_message_can_error_props_get_invalid_type_for_can_message)
{
icsneoc2_message_t message;
message.message = std::make_shared<CANMessage>();
uint8_t tx_err_count = 0;
uint8_t rx_err_count = 0;
icsneoc2_can_error_code_t error_code = icsneoc2_can_error_code_no_error;
icsneoc2_can_error_code_t data_error_code = icsneoc2_can_error_code_no_error;
icsneoc2_message_can_error_flags_t flags = 0;
ASSERT_EQ(icsneoc2_error_invalid_type,
icsneoc2_message_can_error_props_get(&message, &tx_err_count, &rx_err_count, &error_code, &data_error_code, &flags));
}
TEST(icsneoc2, test_icsneoc2_disk_format_enums)
{
// Disk layout enum values
ASSERT_EQ(icsneoc2_disk_layout_spanned, 0);
ASSERT_EQ(icsneoc2_disk_layout_raid0, 1);
// Disk format flag bitmask values
ASSERT_EQ(ICSNEOC2_DISK_FORMAT_FLAGS_PRESENT, 0x01);
ASSERT_EQ(ICSNEOC2_DISK_FORMAT_FLAGS_INITIALIZED, 0x02);
ASSERT_EQ(ICSNEOC2_DISK_FORMAT_FLAGS_FORMATTED, 0x04);
// Disk format directive values
ASSERT_EQ(icsneoc2_disk_format_directive_continue, 0);
ASSERT_EQ(icsneoc2_disk_format_directive_stop, 1);
// Type sizes
ASSERT_EQ(sizeof(icsneoc2_disk_layout_t), sizeof(uint8_t));
ASSERT_EQ(sizeof(icsneoc2_disk_format_flags_t), sizeof(uint32_t));
ASSERT_EQ(sizeof(icsneoc2_disk_format_directive_t), sizeof(uint8_t));
}
TEST(icsneoc2, test_icsneoc2_free_null)
{
// Free functions should be safe to call with NULL
icsneoc2_disk_details_free(NULL);
icsneoc2_script_status_free(NULL);
}
TEST(icsneoc2, test_icsneoc2_format_disk_error_code)
{
// Verify the new error code exists and has a valid string
char error_str[64] = {0};
size_t error_str_len = sizeof(error_str);
ASSERT_EQ(icsneoc2_error_success, icsneoc2_error_code_get(icsneoc2_error_format_disk_failed, error_str, &error_str_len));
ASSERT_GT(error_str_len, 0u);
ASSERT_STREQ(error_str, "Disk format failed");
}
TEST(icsneoc2, test_icsneoc2_memory_type_enums)
{
// Memory type enum values should match Disk::MemoryType
ASSERT_EQ(0, icsneoc2_memory_type_flash);
ASSERT_EQ(1, icsneoc2_memory_type_sd);
}
TEST(icsneoc2, test_icsneoc2_can_error_code_t)
{
// CAN error code enum values
ASSERT_EQ(icsneoc2_can_error_code_no_error, 0);
ASSERT_EQ(icsneoc2_can_error_code_stuff_error, 1);
ASSERT_EQ(icsneoc2_can_error_code_form_error, 2);
ASSERT_EQ(icsneoc2_can_error_code_ack_error, 3);
ASSERT_EQ(icsneoc2_can_error_code_bit1_error, 4);
ASSERT_EQ(icsneoc2_can_error_code_bit0_error, 5);
ASSERT_EQ(icsneoc2_can_error_code_crc_error, 6);
ASSERT_EQ(icsneoc2_can_error_code_no_change, 7);
ASSERT_EQ(icsneoc2_can_error_code_maxsize, 8);
using _T = icsneo::CANErrorCode;
ASSERT_EQ(static_cast<icsneoc2_can_error_code_t>(_T::NoError), icsneoc2_can_error_code_no_error);
ASSERT_EQ(static_cast<icsneoc2_can_error_code_t>(_T::StuffError), icsneoc2_can_error_code_stuff_error);
ASSERT_EQ(static_cast<icsneoc2_can_error_code_t>(_T::FormError), icsneoc2_can_error_code_form_error);
ASSERT_EQ(static_cast<icsneoc2_can_error_code_t>(_T::AckError), icsneoc2_can_error_code_ack_error);
ASSERT_EQ(static_cast<icsneoc2_can_error_code_t>(_T::Bit1Error), icsneoc2_can_error_code_bit1_error);
ASSERT_EQ(static_cast<icsneoc2_can_error_code_t>(_T::Bit0Error), icsneoc2_can_error_code_bit0_error);
ASSERT_EQ(static_cast<icsneoc2_can_error_code_t>(_T::CRCError), icsneoc2_can_error_code_crc_error);
ASSERT_EQ(static_cast<icsneoc2_can_error_code_t>(_T::NoChange), icsneoc2_can_error_code_no_change);
ASSERT_EQ(sizeof(icsneoc2_can_error_code_t), sizeof(uint8_t));
// CAN error flag bitmask values
ASSERT_EQ(ICSNEOC2_MESSAGE_CAN_ERROR_FLAGS_BUS_OFF, 0x01);
ASSERT_EQ(ICSNEOC2_MESSAGE_CAN_ERROR_FLAGS_ERROR_PASSIVE, 0x02);
ASSERT_EQ(ICSNEOC2_MESSAGE_CAN_ERROR_FLAGS_ERROR_WARN, 0x04);
ASSERT_EQ(sizeof(icsneoc2_message_can_error_flags_t), sizeof(uint64_t));
}
TEST(icsneoc2, test_icsneoc2_message_can_flags_t)
{
ASSERT_EQ(ICSNEOC2_MESSAGE_CAN_FLAGS_RTR, 0x01);
ASSERT_EQ(ICSNEOC2_MESSAGE_CAN_FLAGS_IDE, 0x02);
ASSERT_EQ(ICSNEOC2_MESSAGE_CAN_FLAGS_FDF, 0x04);
ASSERT_EQ(ICSNEOC2_MESSAGE_CAN_FLAGS_BRS, 0x08);
ASSERT_EQ(ICSNEOC2_MESSAGE_CAN_FLAGS_ESI, 0x10);
ASSERT_EQ(ICSNEOC2_MESSAGE_CAN_FLAGS_TX_ABORTED, 0x20);
ASSERT_EQ(ICSNEOC2_MESSAGE_CAN_FLAGS_TX_LOST_ARB, 0x40);
ASSERT_EQ(ICSNEOC2_MESSAGE_CAN_FLAGS_TX_ERROR, 0x80);
ASSERT_EQ(sizeof(icsneoc2_message_can_flags_t), sizeof(uint64_t));
}
TEST(icsneoc2, test_icsneoc2_script_error_codes)
{
// Verify script error codes exist and have distinct string representations
char buf[256];
size_t len;
len = sizeof(buf);
ASSERT_EQ(icsneoc2_error_success, icsneoc2_error_code_get(icsneoc2_error_script_start_failed, buf, &len));
ASSERT_GT(len, 0u);
len = sizeof(buf);
ASSERT_EQ(icsneoc2_error_success, icsneoc2_error_code_get(icsneoc2_error_script_stop_failed, buf, &len));
ASSERT_GT(len, 0u);
len = sizeof(buf);
ASSERT_EQ(icsneoc2_error_success, icsneoc2_error_code_get(icsneoc2_error_script_clear_failed, buf, &len));
ASSERT_GT(len, 0u);
len = sizeof(buf);
ASSERT_EQ(icsneoc2_error_success, icsneoc2_error_code_get(icsneoc2_error_script_upload_failed, buf, &len));
ASSERT_GT(len, 0u);
len = sizeof(buf);
ASSERT_EQ(icsneoc2_error_success, icsneoc2_error_code_get(icsneoc2_error_script_load_prepare_failed, buf, &len));
ASSERT_GT(len, 0u);
}
TEST(icsneoc2, test_lin_message_create_and_props)
{
// Create a LIN message with ID 0x15
icsneoc2_message_t* msg = nullptr;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_create(&msg, 0x15));
ASSERT_NE(msg, nullptr);
// Verify it reports as LIN
bool is_lin = false;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_is_lin(msg, &is_lin));
ASSERT_TRUE(is_lin);
// Verify it does NOT report as CAN
bool is_can = true;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_is_can(msg, &is_can));
ASSERT_FALSE(is_can);
// CAN props should fail on a LIN message
uint64_t arb_id = 0;
ASSERT_EQ(icsneoc2_error_invalid_type, icsneoc2_message_can_props_get(msg, &arb_id, NULL));
// Read back default props
uint8_t id = 0xFF, protected_id = 0, checksum = 0xFF;
icsneoc2_lin_msg_type_t msg_type = 0xFF;
bool enhanced = true;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_props_get(msg, &id, &protected_id, &checksum, &msg_type, &enhanced));
ASSERT_EQ(id, 0x15);
ASSERT_NE(protected_id, 0); // Should have parity bits
ASSERT_EQ(checksum, 0);
ASSERT_EQ(msg_type, icsneoc2_lin_msg_type_not_set);
ASSERT_FALSE(enhanced);
// ID should be masked to 6 bits
icsneoc2_message_t* msg_masked = nullptr;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_create(&msg_masked, 0xFF));
uint8_t masked_id = 0xFF;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_props_get(msg_masked, &masked_id, NULL, NULL, NULL, NULL));
ASSERT_EQ(masked_id, 0x3F); // 0xFF & 0x3F
icsneoc2_message_free(msg_masked);
icsneoc2_message_free(msg);
}
TEST(icsneoc2, test_lin_message_props_set)
{
icsneoc2_message_t* msg = nullptr;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_create(&msg, 0x00));
// Set individual properties using NULL to skip others
uint8_t new_id = 0x2A;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_props_set(msg, &new_id, NULL, NULL, NULL));
uint8_t read_id = 0, read_pid = 0;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_props_get(msg, &read_id, &read_pid, NULL, NULL, NULL));
ASSERT_EQ(read_id, 0x2A);
ASSERT_NE(read_pid, 0x2A); // Protected ID should differ (has parity bits)
// Set checksum
uint8_t new_checksum = 0xAB;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_props_set(msg, NULL, &new_checksum, NULL, NULL));
uint8_t read_checksum = 0;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_props_get(msg, NULL, NULL, &read_checksum, NULL, NULL));
ASSERT_EQ(read_checksum, 0xAB);
// Set msg type
icsneoc2_lin_msg_type_t new_type = icsneoc2_lin_msg_type_commander_msg;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_props_set(msg, NULL, NULL, &new_type, NULL));
icsneoc2_lin_msg_type_t read_type = 0;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_props_get(msg, NULL, NULL, NULL, &read_type, NULL));
ASSERT_EQ(read_type, icsneoc2_lin_msg_type_commander_msg);
// Set enhanced checksum
bool new_enhanced = true;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_props_set(msg, NULL, NULL, NULL, &new_enhanced));
bool read_enhanced = false;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_props_get(msg, NULL, NULL, NULL, NULL, &read_enhanced));
ASSERT_TRUE(read_enhanced);
// LIN props set on a CAN message should fail
icsneoc2_message_t* can_msg = nullptr;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_can_create(&can_msg));
ASSERT_EQ(icsneoc2_error_invalid_type, icsneoc2_message_lin_props_set(can_msg, &new_id, NULL, NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_type, icsneoc2_message_lin_props_get(can_msg, &read_id, NULL, NULL, NULL, NULL));
icsneoc2_message_free(can_msg);
icsneoc2_message_free(msg);
}
TEST(icsneoc2, test_lin_message_data_and_netid)
{
icsneoc2_message_t* msg = nullptr;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_create(&msg, 0x10));
// Set data
uint8_t data[] = {0x01, 0x02, 0x03, 0x04};
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_data_set(msg, data, sizeof(data)));
// Read data back
uint8_t read_data[8] = {0};
size_t read_len = sizeof(read_data);
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_data_get(msg, read_data, &read_len));
ASSERT_EQ(read_len, sizeof(data));
ASSERT_EQ(memcmp(data, read_data, sizeof(data)), 0);
// Set and verify netid
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_netid_set(msg, icsneoc2_netid_lin_01));
icsneoc2_netid_t netid = 0;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_netid_get(msg, &netid));
ASSERT_EQ(netid, icsneoc2_netid_lin_01);
// Verify is_frame and is_raw
bool is_frame = false, is_raw = false;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_is_frame(msg, &is_frame));
ASSERT_TRUE(is_frame);
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_is_raw(msg, &is_raw));
ASSERT_TRUE(is_raw);
icsneoc2_message_free(msg);
}
TEST(icsneoc2, test_lin_message_flags)
{
// Create a LIN message and verify default flags are clear
icsneoc2_message_t* msg = nullptr;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_create(&msg, 0x01));
icsneoc2_lin_err_flags_t err_flags = 0xFFFFFFFF;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_err_flags_get(msg, &err_flags));
ASSERT_EQ(err_flags, 0u);
icsneoc2_lin_status_flags_t status_flags = 0xFFFFFFFF;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_status_flags_get(msg, &status_flags));
ASSERT_EQ(status_flags, 0u);
// Error/status flags on CAN message should fail
icsneoc2_message_t* can_msg = nullptr;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_can_create(&can_msg));
ASSERT_EQ(icsneoc2_error_invalid_type, icsneoc2_message_lin_err_flags_get(can_msg, &err_flags));
ASSERT_EQ(icsneoc2_error_invalid_type, icsneoc2_message_lin_status_flags_get(can_msg, &status_flags));
icsneoc2_message_free(can_msg);
icsneoc2_message_free(msg);
}
TEST(icsneoc2, test_lin_message_calc_checksum)
{
icsneoc2_message_t* msg = nullptr;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_create(&msg, 0x01));
// Set some data and calculate checksum (classic)
uint8_t data[] = {0x01, 0x02, 0x03};
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_data_set(msg, data, sizeof(data)));
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_calc_checksum(msg));
uint8_t checksum = 0;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_props_get(msg, NULL, NULL, &checksum, NULL, NULL));
ASSERT_NE(checksum, 0); // Checksum should be non-zero for this data
// Now set enhanced checksum and recalculate — should give a different value
uint8_t classic_checksum = checksum;
bool enhanced = true;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_props_set(msg, NULL, NULL, NULL, &enhanced));
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_calc_checksum(msg));
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_props_get(msg, NULL, NULL, &checksum, NULL, NULL));
ASSERT_NE(checksum, classic_checksum); // Enhanced and classic should differ
// calc_checksum on a CAN message should fail
icsneoc2_message_t* can_msg = nullptr;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_can_create(&can_msg));
ASSERT_EQ(icsneoc2_error_invalid_type, icsneoc2_message_lin_calc_checksum(can_msg));
icsneoc2_message_free(can_msg);
icsneoc2_message_free(msg);
}
TEST(icsneoc2, test_lin_msg_type_enum_values)
{
ASSERT_EQ(icsneoc2_lin_msg_type_not_set, 0);
ASSERT_EQ(icsneoc2_lin_msg_type_commander_msg, 1);
ASSERT_EQ(icsneoc2_lin_msg_type_header_only, 2);
ASSERT_EQ(icsneoc2_lin_msg_type_break_only, 3);
ASSERT_EQ(icsneoc2_lin_msg_type_sync_only, 4);
ASSERT_EQ(icsneoc2_lin_msg_type_update_responder, 5);
ASSERT_EQ(icsneoc2_lin_msg_type_error, 6);
ASSERT_EQ(sizeof(icsneoc2_lin_msg_type_t), sizeof(uint8_t));
}
TEST(icsneoc2, test_lin_msg_type_cpp_enum_sync)
{
using T = icsneo::LINMessage::Type;
ASSERT_EQ(static_cast<uint8_t>(T::NOT_SET), icsneoc2_lin_msg_type_not_set);
ASSERT_EQ(static_cast<uint8_t>(T::LIN_COMMANDER_MSG), icsneoc2_lin_msg_type_commander_msg);
ASSERT_EQ(static_cast<uint8_t>(T::LIN_HEADER_ONLY), icsneoc2_lin_msg_type_header_only);
ASSERT_EQ(static_cast<uint8_t>(T::LIN_BREAK_ONLY), icsneoc2_lin_msg_type_break_only);
ASSERT_EQ(static_cast<uint8_t>(T::LIN_SYNC_ONLY), icsneoc2_lin_msg_type_sync_only);
ASSERT_EQ(static_cast<uint8_t>(T::LIN_UPDATE_RESPONDER), icsneoc2_lin_msg_type_update_responder);
ASSERT_EQ(static_cast<uint8_t>(T::LIN_ERROR), icsneoc2_lin_msg_type_error);
}
TEST(icsneoc2, test_lin_flag_bitmask_values)
{
// Error flags should be distinct bits
ASSERT_EQ(ICSNEOC2_LIN_ERR_RX_BREAK_ONLY, 0x0001);
ASSERT_EQ(ICSNEOC2_LIN_ERR_RX_BREAK_SYNC_ONLY, 0x0002);
ASSERT_EQ(ICSNEOC2_LIN_ERR_TX_RX_MISMATCH, 0x0004);
ASSERT_EQ(ICSNEOC2_LIN_ERR_RX_BREAK_NOT_ZERO, 0x0008);
ASSERT_EQ(ICSNEOC2_LIN_ERR_RX_BREAK_TOO_SHORT, 0x0010);
ASSERT_EQ(ICSNEOC2_LIN_ERR_RX_SYNC_NOT_55, 0x0020);
ASSERT_EQ(ICSNEOC2_LIN_ERR_RX_DATA_LEN_OVER_8, 0x0040);
ASSERT_EQ(ICSNEOC2_LIN_ERR_FRAME_SYNC, 0x0080);
ASSERT_EQ(ICSNEOC2_LIN_ERR_FRAME_MESSAGE_ID, 0x0100);
ASSERT_EQ(ICSNEOC2_LIN_ERR_FRAME_RESPONDER_DATA, 0x0200);
ASSERT_EQ(ICSNEOC2_LIN_ERR_CHECKSUM_MATCH, 0x0400);
// Status flags should be distinct bits
ASSERT_EQ(ICSNEOC2_LIN_STATUS_TX_CHECKSUM_ENHANCED, 0x01);
ASSERT_EQ(ICSNEOC2_LIN_STATUS_TX_COMMANDER, 0x02);
ASSERT_EQ(ICSNEOC2_LIN_STATUS_TX_RESPONDER, 0x04);
ASSERT_EQ(ICSNEOC2_LIN_STATUS_TX_ABORTED, 0x08);
ASSERT_EQ(ICSNEOC2_LIN_STATUS_UPDATE_RESPONDER_ONCE, 0x10);
ASSERT_EQ(ICSNEOC2_LIN_STATUS_HAS_UPDATED_RESPONDER_ONCE, 0x20);
ASSERT_EQ(ICSNEOC2_LIN_STATUS_BUS_RECOVERED, 0x40);
ASSERT_EQ(ICSNEOC2_LIN_STATUS_BREAK_ONLY, 0x80);
}
TEST(icsneoc2, test_icsneoc2_eth_create)
{
// NULL parameter should fail
ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_eth_create(NULL));
// Create an Ethernet message
icsneoc2_message_t* message = nullptr;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_create(&message));
ASSERT_NE(message, nullptr);
// Verify it is an Ethernet message
bool is_ethernet = false;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_is_ethernet(message, &is_ethernet));
ASSERT_TRUE(is_ethernet);
// Verify it is NOT a CAN message
bool is_can = false;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_is_can(message, &is_can));
ASSERT_FALSE(is_can);
// Verify it is a frame and raw message
bool is_frame = false;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_is_frame(message, &is_frame));
ASSERT_TRUE(is_frame);
bool is_raw = false;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_is_raw(message, &is_raw));
ASSERT_TRUE(is_raw);
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_free(message));
}
TEST(icsneoc2, test_icsneoc2_eth_props_roundtrip)
{
icsneoc2_message_t* message = nullptr;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_create(&message));
// Set several flags
icsneoc2_message_eth_flags_t flags_in =
ICSNEOC2_MESSAGE_ETH_FLAGS_NO_PADDING |
ICSNEOC2_MESSAGE_ETH_FLAGS_FCS_VERIFIED |
ICSNEOC2_MESSAGE_ETH_FLAGS_TX_ABORTED;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_props_set(message, &flags_in, NULL, NULL));
// Get them back
icsneoc2_message_eth_flags_t flags_out = 0;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_props_get(message, &flags_out, NULL, NULL));
ASSERT_EQ(flags_in, flags_out);
// Clear all flags
icsneoc2_message_eth_flags_t flags_zero = 0;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_props_set(message, &flags_zero, NULL, NULL));
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_props_get(message, &flags_out, NULL, NULL));
ASSERT_EQ(0u, flags_out);
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_free(message));
}
TEST(icsneoc2, test_icsneoc2_eth_mac_and_ethertype)
{
icsneoc2_message_t* message = nullptr;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_create(&message));
// Set frame data: dst MAC + src MAC + EtherType
uint8_t frame_data[] = {
0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, /* Destination MAC */
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, /* Source MAC */
0x08, 0x00, /* EtherType (IPv4) */
0x01, 0x02, 0x03, 0x04 /* Payload */
};
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_data_set(message, frame_data, sizeof(frame_data)));
// Get MAC addresses
uint8_t dst_mac[6] = {0};
uint8_t src_mac[6] = {0};
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_mac_get(message, dst_mac, src_mac));
ASSERT_EQ(0, memcmp(dst_mac, frame_data, 6));
ASSERT_EQ(0, memcmp(src_mac, frame_data + 6, 6));
// Get just one MAC at a time (NULL-safe)
uint8_t dst_only[6] = {0};
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_mac_get(message, dst_only, NULL));
ASSERT_EQ(0, memcmp(dst_only, frame_data, 6));
uint8_t src_only[6] = {0};
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_mac_get(message, NULL, src_only));
ASSERT_EQ(0, memcmp(src_only, frame_data + 6, 6));
// Get EtherType
uint16_t ether_type = 0;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_ether_type_get(message, &ether_type));
ASSERT_EQ(0x0800, ether_type);
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_free(message));
}
TEST(icsneoc2, test_icsneoc2_eth_mac_too_short)
{
icsneoc2_message_t* message = nullptr;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_create(&message));
// Set data too short for MAC extraction (< 14 bytes)
uint8_t short_data[] = {0x01, 0x02, 0x03};
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_data_set(message, short_data, sizeof(short_data)));
uint8_t dst_mac[6] = {0};
ASSERT_EQ(icsneoc2_error_invalid_data, icsneoc2_message_eth_mac_get(message, dst_mac, NULL));
uint8_t src_mac[6] = {0};
ASSERT_EQ(icsneoc2_error_invalid_data, icsneoc2_message_eth_mac_get(message, NULL, src_mac));
uint16_t ether_type = 0;
ASSERT_EQ(icsneoc2_error_invalid_data, icsneoc2_message_eth_ether_type_get(message, &ether_type));
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_free(message));
}
TEST(icsneoc2, test_icsneoc2_eth_t1s_props_roundtrip)
{
icsneoc2_message_t* message = nullptr;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_create(&message));
// Set T1S properties
icsneoc2_message_eth_t1s_flags_t flags_in =
ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_IS_T1S_SYMBOL |
ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_TX_COLLISION;
uint8_t node_id = 42;
uint8_t burst_count = 7;
uint8_t symbol_type = 3;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_t1s_props_set(message, &flags_in, &node_id, &burst_count, &symbol_type));
// Get them back
icsneoc2_message_eth_t1s_flags_t flags_out = 0;
uint8_t node_id_out = 0, burst_count_out = 0, symbol_type_out = 0;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_t1s_props_get(message, &flags_out, &node_id_out, &burst_count_out, &symbol_type_out));
ASSERT_EQ(flags_in, flags_out);
ASSERT_EQ(42, node_id_out);
ASSERT_EQ(7, burst_count_out);
ASSERT_EQ(3, symbol_type_out);
// Set just one at a time (NULL-safe)
uint8_t new_node_id = 99;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_t1s_props_set(message, NULL, &new_node_id, NULL, NULL));
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_t1s_props_get(message, &flags_out, &node_id_out, &burst_count_out, &symbol_type_out));
ASSERT_EQ(flags_in, flags_out);
ASSERT_EQ(99, node_id_out);
ASSERT_EQ(7, burst_count_out); // Unchanged
ASSERT_EQ(3, symbol_type_out); // Unchanged
// Passing all NULL parameters clears the optional T1S state.
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_t1s_props_set(message, NULL, NULL, NULL, NULL));
flags_out = 0xFF;
node_id_out = 0xFF;
burst_count_out = 0xFF;
symbol_type_out = 0xFF;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_t1s_props_get(message, &flags_out, &node_id_out, &burst_count_out, &symbol_type_out));
ASSERT_EQ(0, flags_out);
ASSERT_EQ(0, node_id_out);
ASSERT_EQ(0, burst_count_out);
ASSERT_EQ(0, symbol_type_out);
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_free(message));
}
TEST(icsneoc2, test_icsneoc2_eth_fcs_roundtrip)
{
icsneoc2_message_t* message = nullptr;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_create(&message));
// Initially, FCS should not be set
bool has_fcs = true;
uint32_t fcs = 0;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_props_get(message, NULL, &has_fcs, &fcs));
ASSERT_FALSE(has_fcs);
// Set an FCS value via eth_props_set
uint32_t fcs_value = 0xDEADBEEF;
has_fcs = true;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_props_set(message, NULL, &has_fcs, &fcs_value));
// Get it back
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_props_get(message, NULL, &has_fcs, &fcs));
ASSERT_TRUE(has_fcs);
ASSERT_EQ(0xDEADBEEF, fcs);
// Clear FCS
has_fcs = false;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_props_set(message, NULL, &has_fcs, NULL));
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_props_get(message, NULL, &has_fcs, &fcs));
ASSERT_FALSE(has_fcs);
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_free(message));
}
TEST(icsneoc2, test_icsneoc2_eth_invalid_type)
{
// Create a CAN message and try to use Ethernet functions on it
icsneoc2_message_t* can_msg = nullptr;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_can_create(&can_msg));
bool is_ethernet = true;
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_is_ethernet(can_msg, &is_ethernet));
ASSERT_FALSE(is_ethernet);
icsneoc2_message_eth_flags_t flags = 0;
ASSERT_EQ(icsneoc2_error_invalid_type, icsneoc2_message_eth_props_get(can_msg, &flags, NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_type, icsneoc2_message_eth_props_set(can_msg, &flags, NULL, NULL));
uint8_t mac[6] = {0};
ASSERT_EQ(icsneoc2_error_invalid_type, icsneoc2_message_eth_mac_get(can_msg, mac, NULL));
uint16_t ether_type = 0;
ASSERT_EQ(icsneoc2_error_invalid_type, icsneoc2_message_eth_ether_type_get(can_msg, &ether_type));
uint8_t val = 0;
icsneoc2_message_eth_t1s_flags_t t1s_flags = 0;
ASSERT_EQ(icsneoc2_error_invalid_type, icsneoc2_message_eth_t1s_props_get(can_msg, &t1s_flags, &val, NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_type, icsneoc2_message_eth_t1s_props_set(can_msg, &t1s_flags, &val, NULL, NULL));
ASSERT_EQ(icsneoc2_error_invalid_type, icsneoc2_message_eth_props_set(can_msg, NULL, NULL, NULL));
ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_free(can_msg));
}
Reference in New Issue View Git Blame Copy Permalink