From d515020fa1bcb5d874084a68c9de9434dc9d994e Mon Sep 17 00:00:00 2001 From: Manikandan C Date: Mon, 29 Oct 2018 16:32:17 +0100 Subject: Gateway Improvements -Support to send and parse periodic control messages -add application/contexts to passive ECU list -Refactor dlt_gateway_send_control_message -Gateway issues with corrupted data and on demand connection -Unit Test update Signed-off-by: Saya Sugiura ssugiura@jp.adit-jv.com Signed-off-by: Christoph Lipka clipka@jp.adit-jv.com Signed-off-by: S. Hameed shameed@jp.adit-jv.com Signed-off-by: ManikandanC Manikandan.Chockalingam@in.bosch.com --- tests/g_test_dlt_daemon_gateway.sh | 6 +- tests/gtest_common.h | 251 ++++++ tests/gtest_dlt_daemon_event_handler.cpp | 3 +- tests/gtest_dlt_daemon_gateway.cpp | 266 ++++-- tests/gtest_dlt_daemon_offline_log.cpp | 1375 ++++++++++++++++++++++++++++++ 5 files changed, 1816 insertions(+), 85 deletions(-) create mode 100644 tests/gtest_common.h create mode 100644 tests/gtest_dlt_daemon_offline_log.cpp (limited to 'tests') diff --git a/tests/g_test_dlt_daemon_gateway.sh b/tests/g_test_dlt_daemon_gateway.sh index bb76a6b..85f37db 100755 --- a/tests/g_test_dlt_daemon_gateway.sh +++ b/tests/g_test_dlt_daemon_gateway.sh @@ -54,9 +54,9 @@ cleanup() return 1 fi fi - return 0 - rm $tmpPath/dlt.conf + rm $tmpPath/idlt_gateway.conf + return 0 } # # Function: -setupTest() @@ -106,6 +106,8 @@ setupTest() echo "EcuID=ECU1" >>$tmpPath/dlt_gateway.conf echo "Connect=OnStartup" >>$tmpPath/dlt_gateway.conf echo "Timeout=10" >>$tmpPath/dlt_gateway.conf + echo "SendControl=0x03,0x13" >>$tmpPath/dlt_gateway.conf + echo "SendSerialHeader=0" >>$tmpPath/dlt_gateway.conf echo "NOFiles=1" >>$tmpPath/dlt_gateway.conf return 0 } diff --git a/tests/gtest_common.h b/tests/gtest_common.h new file mode 100644 index 0000000..0ca9f7e --- /dev/null +++ b/tests/gtest_common.h @@ -0,0 +1,251 @@ +/** + * @licence app begin@ + * Copyright (C) 2016 Advanced Driver Information Technology. + * This code is developed by Advanced Driver Information Technology. + * Copyright of Advanced Driver Information Technology, Bosch and DENSO. + * + * DLT gtest common header file. + * + * \copyright + * This Source Code Form is subject to the terms of the + * Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with + * this file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * + * \author Onkar Palkar + * + * \file: gtest_common.h + * For further information see http://www.genivi.org/. + * @licence end@ + */ + +/******************************************************************************* + * ** + * SRC-MODULE: gtest_common.h ** + * ** + * TARGET : linux ** + * ** + * PROJECT : DLT ** + * ** + * AUTHOR : onkar.palkar@wipro.com ** + * PURPOSE : ** + * ** + * REMARKS : ** + * ** + * PLATFORM DEPENDANT [yes/no]: yes ** + * ** + * TO BE CHANGED BY USER [yes/no]: no ** + * ** + ******************************************************************************/ + +/******************************************************************************* +* Author Identity ** +******************************************************************************* +* ** +* Initials Name Company ** +* -------- ------------------------- ---------------------------------- ** +* op Onkar Palkar Wipro ** +*******************************************************************************/ +#ifndef GTEST_COMMON_H +#define GTEST_COMMON_H +int dlt_logstorage_split_key(char *key, char *appid, char *ctxid); +int dlt_logstorage_update_all_contexts(DltDaemon *daemon, + char *id, + int curr_log_level, + int cmp_flag, + int verbose); +int dlt_logstorage_update_context(DltDaemon *daemon, + char *apid, + char *ctxid, + char *ecuid, + int curr_log_level, + int verbose); +int dlt_logstorage_update_context_loglevel(DltDaemon *daemon, + char *key, + int curr_log_level, + int verbose); +void dlt_daemon_logstorage_reset_application_loglevel(DltDaemon *daemon, + int dev_num, + int max_device, + int verbose); +typedef struct { + char *key; /* The configuration key */ + int (*func)(DltLogStorage *handle, char *value); /* conf handler */ + int is_opt; /* If configuration is optional or not */ +} DltLogstorageGeneralConf; + +typedef enum { + DLT_LOGSTORAGE_GENERAL_CONF_BLOCKMODE = 0, + DLT_LOGSTORAGE_GENERAL_CONF_COUNT +} DltLogstorageGeneralConfType; + +typedef struct { + char *key; /* Configuration key */ + int (*func)(DltLogStorageFilterConfig *config, char *value); /* conf handler */ + int is_opt; /* If configuration is optional or not */ +} DltLogstorageFilterConf; + +typedef enum { + DLT_LOGSTORAGE_FILTER_CONF_LOGAPPNAME = 0, + DLT_LOGSTORAGE_FILTER_CONF_CONTEXTNAME, + DLT_LOGSTORAGE_FILTER_CONF_LOGLEVEL, + DLT_LOGSTORAGE_FILTER_CONF_FILE, + DLT_LOGSTORAGE_FILTER_CONF_FILESIZE, + DLT_LOGSTORAGE_FILTER_CONF_NOFILES, + DLT_LOGSTORAGE_FILTER_CONF_SYNCBEHAVIOR, + DLT_LOGSTORAGE_FILTER_CONF_ECUID, + DLT_LOGSTORAGE_FILTER_CONF_COUNT +} DltLogstorageFilterConfType; + + int dlt_logstorage_hash_create(int num_entries, + struct hsearch_data *htab); + int dlt_logstorage_hash_destroy(struct hsearch_data *htab); + int dlt_logstorage_hash_add(char *key, void *value, + struct hsearch_data *htab); + void *dlt_logstorage_hash_find(char *key, struct hsearch_data *htab); + int dlt_logstorage_count_ids(const char *str); + int dlt_logstorage_read_number(unsigned int *number, char *value); + int dlt_logstorage_read_list_of_names(char **names, char *value); + int dlt_logstorage_check_apids(DltLogStorageFilterConfig *config, char *value); + int dlt_logstorage_check_ctids(DltLogStorageFilterConfig *config, char *value); + int dlt_logstorage_check_loglevel(DltLogStorageFilterConfig *config, char *value); + int dlt_logstorage_check_filename(DltLogStorageFilterConfig *config, char *value); + int dlt_logstorage_check_filesize(DltLogStorageFilterConfig *config, char *value); + int dlt_logstorage_check_nofiles(DltLogStorageFilterConfig *config, char *value); + int dlt_logstorage_check_sync_strategy(DltLogStorageFilterConfig *config, char *value); + int dlt_logstorage_check_ecuid(DltLogStorageFilterConfig *config, char *value); + int dlt_logstorage_check_param(DltLogStorageFilterConfig *config, + DltLogstorageFilterConfType ctype, + char *value); + int dlt_logstorage_check_blockmode(DltLogStorage *handle, + char *value); + int dlt_logstorage_check_general_param(DltLogStorage *handle, + DltLogstorageGeneralConfType ctype, + char *value); + int dlt_daemon_setup_general_properties(DltLogStorage *handle, + DltConfigFile *config_file, + char *sec_name); + int dlt_logstorage_store_filters(DltLogStorage *handle, + char *config_file_name); + void dlt_logstorage_free(DltLogStorage *handle, int reason); + int dlt_logstorage_create_keys(char *appids, + char *ctxids, + char **keys, + int *num_keys); + int dlt_logstorage_prepare_table(DltLogStorage *handle, + DltLogStorageFilterConfig *data); + int dlt_logstorage_validate_filter_name(char *name); + void dlt_logstorage_filter_set_strategy(DltLogStorageFilterConfig *config, + int strategy); + int dlt_logstorage_load_config(DltLogStorage *handle); + int dlt_logstorage_filter(DltLogStorage *handle, + DltLogStorageFilterConfig **config, + char *apid, + char *ctid, + char *ecuid, + int log_level); +void dlt_logstorage_log_file_name(char *log_file_name, + DltLogStorageUserConfig *file_config, + char *name, + int idx); +void dlt_logstorage_sort_file_name(DltLogStorageFileList **head); +void dlt_logstorage_rearrange_file_name(DltLogStorageFileList **head); +unsigned int dlt_logstorage_get_idx_of_log_file( + DltLogStorageUserConfig *file_config, + char *file); +int dlt_logstorage_storage_dir_info(DltLogStorageUserConfig *file_config, + char *path, + DltLogStorageFilterConfig *config); +int dlt_logstorage_open_log_file(DltLogStorageFilterConfig *config, + DltLogStorageUserConfig *file_config, + char *dev_path, + int msg_size); +/* gtest_dlt_daemon_gateway */ +typedef enum { + GW_CONF_IP_ADDRESS = 0, + GW_CONF_PORT, + GW_CONF_ECUID, + GW_CONF_CONNECT, + GW_CONF_TIMEOUT, + GW_CONF_SEND_CONTROL, + GW_CONF_SEND_PERIODIC_CONTROL, + GW_CONF_SEND_SERIAL_HEADER, + GW_CONF_COUNT +} DltGatewayConfType; +int enable_all(DltServiceIdFlag *flags); +int init_flags(DltServiceIdFlag *flags); +int set_bit(DltServiceIdFlag *flags, int id); +int bit(DltServiceIdFlag *flags, int id); +int dlt_daemon_filter_name(DltMessageFilter *mf, + DltFilterConfiguration *config, + char *value); +int dlt_daemon_filter_level(DltMessageFilter *mf, + DltFilterConfiguration *config, + char *value); +int dlt_daemon_filter_control_mask(DltMessageFilter *mf, + DltFilterConfiguration *config, + char *value); +int dlt_daemon_filter_client_mask(DltMessageFilter *mf, + DltFilterConfiguration *config, + char *value); +int dlt_daemon_filter_injections(DltMessageFilter *mf, + DltFilterConfiguration *config, + char *value); +int dlt_daemon_set_injection_service_ids(int **ids, + int *num, + char *value); +DltInjectionConfig *dlt_daemon_filter_find_injection_by_name( + DltInjectionConfig *injections, + char *name); +int dlt_daemon_injection_name(DltMessageFilter *mf, + DltInjectionConfig *config, + char *value); +int dlt_daemon_injection_apid(DltMessageFilter *mf, + DltInjectionConfig *config, + char *value); +int dlt_daemon_injection_ctid(DltMessageFilter *mf, + DltInjectionConfig *config, + char *value); +int dlt_daemon_injection_ecu_id(DltMessageFilter *mf, + DltInjectionConfig *config, + char *value); +int dlt_daemon_injection_service_id(DltMessageFilter *mf, + DltInjectionConfig *config, + char *value); +int dlt_daemon_get_name(DltMessageFilter *mf, char *val); +int dlt_daemon_get_default_level(DltMessageFilter *mf, char *val); +int dlt_daemon_get_backend(DltMessageFilter *mf, char *val); +int dlt_daemon_setup_filter_section(DltMessageFilter *mf, + DltConfigFile *config, + char *sec_name); +int dlt_daemon_setup_filter_properties(DltMessageFilter *mf, + DltConfigFile *config, + char *sec_name); +void dlt_daemon_filter_backend_level_changed(unsigned int level, + void *ptr1, + void *ptr2); +int dlt_gateway_check_ip(DltGatewayConnection *con, char *value); +int dlt_gateway_check_port(DltGatewayConnection *con, char *value); +int dlt_gateway_check_ecu(DltGatewayConnection *con, char *value); +int dlt_gateway_check_connect_trigger(DltGatewayConnection *con, + char *value); +int dlt_gateway_check_timeout(DltGatewayConnection *con, char *value); +int dlt_gateway_check_send_serial(DltGatewayConnection *con, char *value); +int dlt_gateway_allocate_control_messages(DltGatewayConnection *con); +int dlt_gateway_check_control_messages(DltGatewayConnection *con, + char *value); +int dlt_gateway_check_periodic_control_messages(DltGatewayConnection *con, + char *value); +int dlt_gateway_check_param(DltGateway *gateway, + DltGatewayConnection *con, + DltGatewayConfType ctype, + char *value); +int dlt_gateway_configure(DltGateway *gateway, char *config_file, int verbose); +int dlt_gateway_store_connection(DltGateway *gateway, + DltGatewayConnection *tmp, + int verbose); +int dlt_gateway_parse_get_log_info(DltDaemon *daemon, + char *ecu, + DltMessage *msg, + int verbose); +#endif diff --git a/tests/gtest_dlt_daemon_event_handler.cpp b/tests/gtest_dlt_daemon_event_handler.cpp index 86cfb1d..b4a00e0 100644 --- a/tests/gtest_dlt_daemon_event_handler.cpp +++ b/tests/gtest_dlt_daemon_event_handler.cpp @@ -216,6 +216,7 @@ TEST(t_dlt_event_handler_cleanup_connections, normal) } /* Begin Method: dlt_daemon_event_handler::dlt_connection_check_activate*/ +/* TEST(t_dlt_connection_check_activate, normal) { int ret; @@ -240,7 +241,7 @@ TEST(t_dlt_connection_check_activate, nullpointer) { EXPECT_EQ(DLT_RETURN_ERROR, dlt_connection_check_activate(NULL, NULL, DEACTIVATE)); } - +*/ /* Begin Method: dlt_daemon_event_handler::dlt_event_handler_register_connection*/ TEST(t_dlt_event_handler_register_connection, normal) { diff --git a/tests/gtest_dlt_daemon_gateway.cpp b/tests/gtest_dlt_daemon_gateway.cpp index 950f260..f681243 100644 --- a/tests/gtest_dlt_daemon_gateway.cpp +++ b/tests/gtest_dlt_daemon_gateway.cpp @@ -61,35 +61,8 @@ extern "C" { -#include "dlt-daemon.h" -#include "dlt_user.h" -#include "dlt_user_shared.h" -#include "dlt_user_shared_cfg.h" -#include "dlt_user_cfg.h" -#include "dlt-daemon_cfg.h" -#include "dlt_version.h" #include "dlt_gateway.h" -#include "dlt_daemon_common.h" -#include "dlt_daemon_connection_types.h" -#include "dlt_daemon_event_handler.h" -#include "dlt_daemon_connection.h" -#include "dlt_daemon_event_handler_types.h" - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "dlt_config_file_parser.h" -#include "dlt_common.h" -#include "dlt-daemon_cfg.h" -#include "dlt_daemon_event_handler.h" -#include "dlt_daemon_connection.h" -#include "dlt_daemon_client.h" +#include "gtest_common.h" } /* Begin Method: dlt_gateway::t_dlt_gateway_init*/ @@ -99,17 +72,20 @@ TEST(t_dlt_gateway_init, normal) DltGatewayConnection connections; daemon_local.pGateway.connections = &connections; daemon_local.pGateway.num_connections = 1; - + daemon_local.flags.lflag = 0; + DltFilterConfiguration current; + daemon_local.pFilter.current = ¤t; DltConnection connections1; DltReceiver receiver; daemon_local.pEvent.connections = &connections1; daemon_local.pEvent.connections->receiver = &receiver; daemon_local.pEvent.connections->next = NULL; - memset(daemon_local.flags.gatewayConfigFile,0,DLT_DAEMON_FLAG_MAX); strncpy(daemon_local.flags.gatewayConfigFile, "/tmp/dlt_gateway.conf", DLT_DAEMON_FLAG_MAX - 1); EXPECT_EQ(DLT_RETURN_OK, dlt_gateway_init(&daemon_local, 1)); + + dlt_gateway_deinit(&daemon_local.pGateway, 0); } TEST(t_dlt_gateway_init, nullpointer) @@ -123,6 +99,8 @@ TEST(t_dlt_gateway_send_control_message, Normal) { int ret = 0; DltDaemonLocal daemon_local; + DltFilterConfiguration current; + daemon_local.pFilter.current = ¤t; DltGatewayConnection connections; DltConnection connections1; DltReceiver receiver1; @@ -132,11 +110,12 @@ TEST(t_dlt_gateway_send_control_message, Normal) daemon_local.pEvent.connections->receiver = &receiver1; memset(daemon_local.flags.gatewayConfigFile,0,DLT_DAEMON_FLAG_MAX); strncpy(daemon_local.flags.gatewayConfigFile, "/tmp/dlt_gateway.conf", DLT_DAEMON_FLAG_MAX - 1); - ret = dlt_gateway_init(&daemon_local, 0); + EXPECT_EQ(DLT_RETURN_OK, ret); - dlt_gateway_send_control_message(daemon_local.pGateway.connections, &daemon_local.pGateway, &daemon_local, 0); + dlt_gateway_send_control_message(daemon_local.pGateway.connections, daemon_local.pGateway.connections->p_control_msgs, NULL, 0); + dlt_gateway_deinit(&daemon_local.pGateway, 0); } TEST(t_dlt_gateway_send_control_message, nullpointer) @@ -153,11 +132,9 @@ TEST(t_dlt_gateway_store_connection, normal) DltGateway gateway; DltGatewayConnection tmp; DltGatewayConnection tmp1; - gateway.num_connections = 1; gateway.connections = &tmp1; gateway.connections->status = DLT_GATEWAY_UNINITIALIZED; - tmp.ip_address = ip_address; tmp.ecuid = ecuid; tmp.sock_domain = 1; @@ -168,12 +145,18 @@ TEST(t_dlt_gateway_store_connection, normal) tmp.timeout = 500; EXPECT_EQ(DLT_RETURN_OK, dlt_gateway_store_connection(&gateway, &tmp, 0)); + EXPECT_EQ(gateway.connections->sock_domain, tmp.sock_domain); + EXPECT_EQ(gateway.connections->sock_type, tmp.sock_type); + EXPECT_EQ(gateway.connections->port, tmp.port); } TEST(t_dlt_gateway_store_connection, nullpointer) { // NULL-Pointer, expect -1 + DltGateway gateway; + EXPECT_EQ(DLT_RETURN_ERROR, dlt_gateway_store_connection(NULL , NULL, 0)); + EXPECT_EQ(DLT_RETURN_ERROR, dlt_gateway_store_connection(&gateway , NULL, 0)); } /* Begin Method: dlt_gateway::t_dlt_gateway_check_ip*/ @@ -200,6 +183,7 @@ TEST(t_dlt_gateway_check_send_serial, normal) DltGatewayConnection *con; char value[DLT_CONFIG_FILE_ENTRY_MAX_LEN] = "134dltgatway"; con = &tmp; + EXPECT_EQ(DLT_RETURN_OK, dlt_gateway_check_send_serial(con, value)); } @@ -209,14 +193,29 @@ TEST(t_dlt_gateway_check_send_serial, nullpointer) EXPECT_EQ(DLT_RETURN_ERROR, dlt_gateway_check_send_serial(NULL,NULL)); } +/* Begin Method: dlt_gateway::t_dlt_gateway_allocate_control_messages*/ +TEST(t_dlt_gateway_allocate_control_messages, normal) +{ + DltGatewayConnection tmp; + DltGatewayConnection *con; + tmp.p_control_msgs = NULL; + con = &tmp; + EXPECT_EQ(DLT_RETURN_OK, dlt_gateway_allocate_control_messages(con)); +} + +TEST(t_dlt_gateway_allocate_control_messages, nullpointer) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_gateway_allocate_control_messages(NULL)); +} + /* Begin Method: dlt_gateway::t_dlt_gateway_check_control_messages*/ TEST(t_dlt_gateway_check_control_messages, normal) { DltGatewayConnection tmp; DltGatewayConnection *con; char value[DLT_CONFIG_FILE_ENTRY_MAX_LEN] = "1,2,3,4,5"; + tmp.p_control_msgs = NULL; con = &tmp; - con->control_msgs[0] = DLT_SERVICE_ID_LAST_ENTRY; EXPECT_EQ(DLT_RETURN_OK, dlt_gateway_check_control_messages(con, value)); } @@ -226,6 +225,22 @@ TEST(t_dlt_gateway_check_control_messages, nullpointer) EXPECT_EQ(DLT_RETURN_ERROR, dlt_gateway_check_control_messages(NULL,NULL)); } +/* Begin Method: dlt_gateway::t_dlt_gateway_check_periodic_control_messages*/ +TEST(t_dlt_gateway_check_periodic_control_messages, normal) +{ + DltGatewayConnection tmp; + DltGatewayConnection *con; + char value[DLT_CONFIG_FILE_ENTRY_MAX_LEN] = "1:5,2:10"; + tmp.p_control_msgs = NULL; + con = &tmp; + EXPECT_EQ(DLT_RETURN_OK, dlt_gateway_check_periodic_control_messages(con, value)); +} + +TEST(t_dlt_gateway_check_periodic_control_messages, nullpointer) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_gateway_check_periodic_control_messages(NULL,NULL)); +} + /* Begin Method: dlt_gateway::t_dlt_gateway_check_port*/ TEST(t_dlt_gateway_check_port, normal) { @@ -233,6 +248,7 @@ TEST(t_dlt_gateway_check_port, normal) DltGatewayConnection *con; char value[DLT_CONFIG_FILE_ENTRY_MAX_LEN] = "3490"; con = &tmp; + EXPECT_EQ(DLT_RETURN_OK, dlt_gateway_check_port(con, value)); } @@ -242,6 +258,7 @@ TEST(t_dlt_gateway_check_port, abnormal) DltGatewayConnection *con; char value[DLT_CONFIG_FILE_ENTRY_MAX_LEN] = "9999999999"; con = &tmp; + EXPECT_EQ(DLT_RETURN_ERROR, dlt_gateway_check_port(con, value)); } @@ -258,6 +275,7 @@ TEST(t_dlt_gateway_check_ecu, normal) DltGatewayConnection *con; char value[DLT_CONFIG_FILE_ENTRY_MAX_LEN] = "ECU2"; con = &tmp; + EXPECT_EQ(DLT_RETURN_OK, dlt_gateway_check_ecu(con, value)); } @@ -274,6 +292,7 @@ TEST(t_dlt_gateway_check_connect_trigger, normal) DltGatewayConnection *con; char value[DLT_CONFIG_FILE_ENTRY_MAX_LEN] = "OnStartup"; con = &tmp; + EXPECT_EQ(DLT_RETURN_OK, dlt_gateway_check_connect_trigger(con, value)); } @@ -283,6 +302,7 @@ TEST(t_dlt_gateway_check_connect_trigger, abnormal) DltGatewayConnection *con; char value[DLT_CONFIG_FILE_ENTRY_MAX_LEN] = "wrong_parameter"; con = &tmp; + EXPECT_EQ(DLT_RETURN_ERROR, dlt_gateway_check_connect_trigger(con, value)); } @@ -299,6 +319,7 @@ TEST(t_dlt_gateway_check_timeout, normal) DltGatewayConnection *con; char value[DLT_CONFIG_FILE_ENTRY_MAX_LEN] = "10"; con = &tmp; + EXPECT_EQ(DLT_RETURN_OK, dlt_gateway_check_timeout(con, value)); } @@ -308,6 +329,7 @@ TEST(t_dlt_gateway_check_timeout, abnormal) DltGatewayConnection *con; char value[DLT_CONFIG_FILE_ENTRY_MAX_LEN] = "0"; con = &tmp; + EXPECT_EQ(DLT_RETURN_ERROR, dlt_gateway_check_timeout(con, value)); } @@ -325,7 +347,9 @@ TEST(t_dlt_gateway_establish_connections, normal) DltGatewayConnection connections; gateway->num_connections = 1; gateway->connections = &connections; - gateway->connections->status = DLT_GATEWAY_CONNECTED; + gateway->connections->status = DLT_GATEWAY_INITIALIZED; + gateway->connections->trigger = DLT_GATEWAY_ON_STARTUP; + EXPECT_EQ(DLT_RETURN_OK, dlt_gateway_establish_connections(gateway, &daemon_local, 0)); } @@ -348,6 +372,7 @@ TEST(t_dlt_gateway_get_connection_receiver, normal) gateway.connections->client.receiver.fd = 12; gateway.connections->status = DLT_GATEWAY_CONNECTED; ret = dlt_gateway_get_connection_receiver(&gateway, fd); + EXPECT_EQ(12, ret->fd); } @@ -362,6 +387,7 @@ TEST(t_dlt_gateway_get_connection_receiver, abnormal) gateway.connections->client.sock = fd; gateway.connections->client.receiver.fd = 12; ret = dlt_gateway_get_connection_receiver(&gateway, fd); + EXPECT_EQ(NULL, ret); } @@ -370,9 +396,120 @@ TEST(t_dlt_gateway_get_connection_receiver, nullpointer) // NULL-Pointer, expect -1 DltReceiver *ret; ret = dlt_gateway_get_connection_receiver(NULL, 0); + EXPECT_EQ(NULL, ret); } +/* Begin Method: dlt_gateway::t_dlt_gateway_parse_get_log_info*/ +TEST(t_dlt_gateway_parse_get_log_info, normal) +{ + int32_t len; + DltDaemon daemon; + DltGateway gateway; + DltMessage msg; + char ecuid[DLT_CONFIG_FILE_ENTRY_MAX_LEN] = "ECU2"; + uint32_t sid = DLT_SERVICE_ID_GET_LOG_INFO; + uint8_t status = 7; + uint16_t count_app_ids = 1; + uint16_t count_context_ids = 1; + const char *apid = "LOG"; + const char *ctid = "TEST"; + const char *com = "remo"; + char app_description[] = "Test Application for Logging"; + char context_description[] = "Test Context for Logging"; + uint16_t len_app = 0; + uint16_t len_con = 0; + int8_t log_level = -1; + int8_t trace_status = -1;; + int offset = 0; + memset(&daemon, 0, sizeof(DltDaemon)); + dlt_set_id(daemon.ecuid, ecuid); + EXPECT_EQ(0, dlt_daemon_init_user_information(&daemon, &gateway, 0, 0)); + EXPECT_STREQ(daemon.ecuid, daemon.user_list[0].ecu); + + /* create response message */ + msg.datasize = sizeof(DltServiceGetLogInfoResponse) + + sizeof(AppIDsType) + + sizeof(ContextIDsInfoType); + msg.databuffer = (uint8_t *) malloc(msg.datasize); + msg.databuffersize = msg.datasize; + memset(msg.databuffer, 0, msg.datasize); + + memcpy(msg.databuffer, &sid, sizeof(uint32_t)); + offset += sizeof(uint32_t); + + memcpy(msg.databuffer + offset, &status, sizeof(int8_t)); + offset += sizeof(int8_t); + + memcpy(msg.databuffer + offset, &count_app_ids, sizeof(uint16_t)); + offset += sizeof(uint16_t); + + dlt_set_id((char*)(msg.databuffer + offset), apid); + offset += sizeof(ID4); + + memcpy(msg.databuffer + offset, &count_context_ids, sizeof(uint16_t)); + offset += sizeof(uint16_t); + + dlt_set_id((char*)(msg.databuffer + offset), ctid); + offset += sizeof(ID4); + + memcpy(msg.databuffer + offset, &log_level, sizeof(int8_t)); + offset += sizeof(int8_t); + + memcpy(msg.databuffer + offset, &trace_status, sizeof(int8_t)); + offset += sizeof(int8_t); + + len_con = strlen(context_description); + memcpy(msg.databuffer + offset, &len_con, sizeof(uint16_t)); + offset += sizeof(uint16_t); + + memcpy(msg.databuffer + offset, context_description, strlen(context_description)); + offset += strlen(context_description); + + len_app = strlen(app_description); + memcpy(msg.databuffer + offset, &len_app, sizeof(uint16_t)); + offset += sizeof(uint16_t); + + memcpy(msg.databuffer + offset, app_description, strlen(app_description)); + offset += strlen(app_description); + + dlt_set_id((char*)(msg.databuffer + offset), com); + + msg.storageheader = (DltStorageHeader*)msg.headerbuffer; + dlt_set_storageheader(msg.storageheader, ""); + + msg.standardheader = (DltStandardHeader*)(msg.headerbuffer + sizeof(DltStorageHeader)); + msg.standardheader->htyp = DLT_HTYP_WEID | DLT_HTYP_WTMS | DLT_HTYP_UEH | DLT_HTYP_PROTOCOL_VERSION1 ; + msg.standardheader->mcnt = 0; + + dlt_set_id(msg.headerextra.ecu, ecuid); + msg.headerextra.tmsp = dlt_uptime(); + dlt_message_set_extraparameters(&msg, 0); + + msg.extendedheader = (DltExtendedHeader*)(msg.headerbuffer + + sizeof(DltStorageHeader) + + sizeof(DltStandardHeader) + + DLT_STANDARD_HEADER_EXTRA_SIZE(msg.standardheader->htyp) ); + msg.extendedheader->msin = DLT_MSIN_CONTROL_RESPONSE; + msg.extendedheader->noar = 1; + dlt_set_id(msg.extendedheader->apid, ""); + dlt_set_id(msg.extendedheader->ctid, ""); + + msg.headersize = sizeof(DltStorageHeader) + + sizeof(DltStandardHeader) + + sizeof(DltExtendedHeader) + + DLT_STANDARD_HEADER_EXTRA_SIZE(msg.standardheader->htyp); + len = msg.headersize - sizeof(DltStorageHeader) + msg.datasize; + msg.standardheader->len = DLT_HTOBE_16(len); + + EXPECT_EQ(DLT_RETURN_OK, dlt_gateway_parse_get_log_info(&daemon, ecuid, &msg, 0)); +} + +TEST(t_dlt_gateway_parse_get_log_info, nullpointer) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_gateway_parse_get_log_info(NULL, NULL, NULL, 0)); +} + /* Begin Method: dlt_gateway::t_dlt_gateway_process_passive_node_messages*/ TEST(t_dlt_gateway_process_passive_node_messages, normal) { @@ -380,9 +517,14 @@ TEST(t_dlt_gateway_process_passive_node_messages, normal) DltDaemonLocal daemon_local; DltReceiver receiver; DltGatewayConnection connections; + memset(&daemon, 0, sizeof(DltDaemon)); + memset(&daemon_local, 0, sizeof(DltDaemonLocal)); + memset(&receiver, 0, sizeof(DltReceiver)); + memset(&connections, 0, sizeof(DltGatewayConnection)); daemon_local.pGateway.connections = &connections; daemon_local.pGateway.num_connections = 1; daemon_local.pGateway.connections->status = DLT_GATEWAY_CONNECTED; + EXPECT_EQ(DLT_RETURN_OK, dlt_gateway_process_passive_node_messages(&daemon,&daemon_local,&receiver,1)); } @@ -404,13 +546,13 @@ TEST(t_dlt_gateway_process_gateway_timer, normal) daemon_local.pGateway.connections = &connections; daemon_local.pGateway.num_connections = 1; DltLogStorage storage_handle; - daemon_local.pGateway.connections->status = DLT_GATEWAY_CONNECTED; + daemon_local.pGateway.connections->status = DLT_GATEWAY_INITIALIZED; + daemon_local.pGateway.connections->trigger = DLT_GATEWAY_ON_STARTUP; daemon_local.pEvent.connections = &connections1; daemon_local.pEvent.connections->receiver = &receiver; daemon.ECUVersionString = ECUVersionString; daemon.storage_handle = &storage_handle; - daemon_local.pEvent.connections->receiver->fd = -1; EXPECT_EQ(DLT_RETURN_OK, dlt_gateway_process_gateway_timer(&daemon,&daemon_local,daemon_local.pEvent.connections->receiver,1)); @@ -427,12 +569,12 @@ TEST(t_dlt_gateway_process_on_demand_request, normal) { char node_id[DLT_ID_SIZE] = "123"; uint32_t connection_status = 1; - DltDaemonLocal daemon_local; DltGatewayConnection connections; daemon_local.pGateway.connections = &connections; daemon_local.pGateway.num_connections = 1; connections.status = DLT_GATEWAY_CONNECTED; + connections.trigger = DLT_GATEWAY_ON_STARTUP; connections.ecuid = node_id; EXPECT_EQ(DLT_RETURN_OK, dlt_gateway_process_on_demand_request(&daemon_local.pGateway, @@ -446,7 +588,6 @@ TEST(t_dlt_gateway_process_on_demand_request, abnormal) { char node_id[DLT_ID_SIZE] = "123"; uint32_t connection_status = 1; - DltDaemonLocal daemon_local; DltGatewayConnection connections; daemon_local.pGateway.connections = &connections; @@ -491,7 +632,6 @@ TEST(t_dlt_gateway_check_param, normal) TEST(t_dlt_gateway_check_param, abnormal) { char value_1[DLT_CONFIG_FILE_ENTRY_MAX_LEN] = "10.11.22.33"; - DltGateway gateway; DltGatewayConnection tmp; gateway.connections = &tmp; @@ -516,7 +656,8 @@ TEST(t_dlt_gateway_configure, Normal) gateway.connections = &tmp; gateway.num_connections = 1; char gatewayConfigFile[DLT_DAEMON_FLAG_MAX]; - strncpy(gatewayConfigFile, DLT_GATEWAY_CONFIG_PATH, DLT_DAEMON_FLAG_MAX - 1); + strncpy(gatewayConfigFile, "/tmp/dlt_gateway.conf", DLT_DAEMON_FLAG_MAX - 1); + EXPECT_EQ(DLT_RETURN_OK, dlt_gateway_configure(&gateway, gatewayConfigFile, 0)); } @@ -526,49 +667,10 @@ TEST(t_dlt_gateway_configure, nullpointer) EXPECT_EQ(DLT_RETURN_ERROR, dlt_gateway_configure(NULL, NULL, 0)); } -/* Begin Method: dlt_gateway::t_dlt_gateway_forward_control_message*/ -TEST(t_dlt_gateway_forward_control_message, normal) -{ - int ret = 0; - char ecu[DLT_ID_SIZE] = {'E', 'C', 'U', '1'}; - DltDaemonLocal daemon_local; - DltGatewayConnection connections; - DltConnection connections1; - DltReceiver receiver1; - - daemon_local.pGateway.connections = &connections; - daemon_local.pEvent.connections = &connections1; - daemon_local.pEvent.connections->receiver = &receiver1; - daemon_local.pEvent.connections->receiver->fd = 1; - daemon_local.pEvent.connections->next = NULL; - daemon_local.pGateway.num_connections = 1; - daemon_local.pEvent.connections->type = DLT_CONNECTION_CLIENT_MSG_TCP; - - DltMessage msg; - memset(daemon_local.flags.gatewayConfigFile,0,DLT_DAEMON_FLAG_MAX); - strncpy(daemon_local.flags.gatewayConfigFile, "/tmp/dlt_gateway.conf", DLT_DAEMON_FLAG_MAX - 1); - - ret = dlt_gateway_init(&daemon_local, 0); - EXPECT_EQ(DLT_RETURN_OK, ret); - - ret = dlt_gateway_forward_control_message(&daemon_local.pGateway, - &daemon_local, - &msg, - ecu, - 0); - EXPECT_EQ(DLT_RETURN_OK, ret); -} - -TEST(t_dlt_gateway_forward_control_message, nullpointer) -{ - // NULL-Pointer, expect -1 - EXPECT_EQ(DLT_RETURN_ERROR, dlt_gateway_forward_control_message(NULL, NULL, NULL, NULL, 0)); -} - int main(int argc, char **argv) { ::testing::InitGoogleTest(&argc, argv); // ::testing::FLAGS_gtest_break_on_failure = true; -// ::testing::FLAGS_gtest_filter = "t_dlt_gateway_forward_control_message*"; +// ::testing::FLAGS_gtest_filter = "t_dlt_gateway_process_passive_node_messages*"; return RUN_ALL_TESTS(); } diff --git a/tests/gtest_dlt_daemon_offline_log.cpp b/tests/gtest_dlt_daemon_offline_log.cpp new file mode 100644 index 0000000..7711839 --- /dev/null +++ b/tests/gtest_dlt_daemon_offline_log.cpp @@ -0,0 +1,1375 @@ +/*! + * file gtest_dlt_daemon_logstorage.cpp + * + * Descriptiom : Unit test for dlt_logstorage.c + * + * Author : Onkar Palkar + * + * Email : onkar.palkar@wipro.com + * + * History : 30-Jun-2016 +*/ +#include + +extern "C" +{ +#include "dlt_offline_logstorage.h" +#include "dlt_offline_logstorage_behavior.h" +#include "dlt_daemon_offline_logstorage.h" +#include "dlt_daemon_common_cfg.h" +#include "gtest_common.h" +} + +#ifndef DLT_DAEMON_BLOCKING_TEST +#define DLT_DAEMON_BLOCKING_TEST 1 +#endif + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_hash_create*/ +TEST(t_dlt_logstorage_hash_create, normal) +{ + struct hsearch_data htab; + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_create(5,&htab)); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_destroy(&htab)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_hash_add*/ +TEST(t_dlt_logstorage_hash_add, normal) +{ + struct hsearch_data htab; + char key = 1; + char value = 5; + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_create(5,&htab)); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_add(&key, &value, &htab)); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_destroy(&htab)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_hash_destroy*/ +TEST(t_dlt_logstorage_hash_destroy, normal) +{ + struct hsearch_data htab; + char key = 1; + char value = 5; + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_create(5,&htab)); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_add(&key, &value, &htab)); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_destroy(&htab)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_hash_find*/ +TEST(t_dlt_logstorage_hash_find, normal) +{ + struct hsearch_data htab; + char key = 1; + char value = 5; + char *retData; + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_create(5,&htab)); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_add(&key, &value, &htab)); + + retData = (char*)dlt_logstorage_hash_find(&key, &htab); + + EXPECT_EQ(5, *retData); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_destroy(&htab)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_free*/ +TEST(t_dlt_logstorage_free, normal) +{ + char key = 1; + char value = 5; + DltLogStorage handle; + int reason = 0; + handle.num_configs = 0; + handle.filter_keys = (char *)calloc (1, sizeof(char)); + handle.configs = (DltLogStorageFilterConfig *)calloc (1, sizeof(DltLogStorageFilterConfig)); + if(handle.filter_keys != NULL && handle.configs != NULL) + { + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_create(5,&handle.config_htab)); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_add(&key, &value, &handle.config_htab)); + + dlt_logstorage_free(&handle, reason); + } +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_count_ids*/ +TEST(t_dlt_logstorage_count_ids, normal) +{ + char const *str = "a,b,c,d"; + + EXPECT_EQ(4, dlt_logstorage_count_ids(str)); +} + +TEST(t_dlt_logstorage_count_ids, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_count_ids(NULL)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_read_number*/ +TEST(t_dlt_logstorage_read_number, normal) +{ + char str[] = "100"; + unsigned int number; + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_read_number(&number, str)); + EXPECT_EQ(100, number); +} + +TEST(t_dlt_logstorage_read_number, null) +{ + unsigned int number; + + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_read_number(&number, NULL)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_create_keys*/ +TEST(t_dlt_logstorage_create_keys, normal) +{ + DltLogStorageFilterConfig data; + char *keys = NULL; + int num_keys = 0; + char apids; + char ctids; + data.apids = &apids; + data.ctids = &ctids; + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_create_keys(data.apids, data.ctids, &keys, &num_keys)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_prepare_table*/ +TEST(t_dlt_logstorage_prepare_table, normal) +{ + DltLogStorage handle; + DltLogStorageFilterConfig data; + memset(&handle, 0, sizeof(DltLogStorage)); + memset(&data, 0, sizeof(DltLogStorageFilterConfig)); + char apids; + char ctids; + char filter_keys; + data.apids = &apids; + data.ctids = &ctids; + handle.num_filter_keys = 1; + data.records = NULL; + data.log = NULL; + data.cache = NULL; + handle.filter_keys = &filter_keys; + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_create(5,&handle.config_htab)); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_prepare_table(&handle, &data)); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_destroy(&handle.config_htab)); +} + +TEST(t_dlt_logstorage_prepare_table, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_prepare_table(NULL, NULL)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_validate_filter_name*/ +TEST(t_dlt_logstorage_validate_filter_name, normal) +{ + char name[] = "FILTER100"; + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_validate_filter_name(name)); +} + +TEST(t_dlt_logstorage_validate_filter_name, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_validate_filter_name(NULL)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_filter_set_strategy*/ +TEST(t_dlt_logstorage_filter_set_strategy, normal) +{ + DltLogStorageFilterConfig config; + dlt_logstorage_filter_set_strategy(&config, DLT_LOGSTORAGE_SYNC_ON_MSG); + + EXPECT_EQ(&dlt_logstorage_prepare_on_msg, config.dlt_logstorage_prepare); + + dlt_logstorage_filter_set_strategy(&config, 2); + + EXPECT_EQ(&dlt_logstorage_prepare_msg_cache, config.dlt_logstorage_prepare); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_read_list_of_names*/ +TEST(t_dlt_logstorage_read_list_of_names, normal) +{ + char *namesPtr = NULL; + char value[] = "a,b,c,d"; + + namesPtr = (char *)calloc (1, sizeof(char)); + if(namesPtr != NULL) + { + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_read_list_of_names(&namesPtr, value)); + + free(namesPtr); + } +} + +TEST(t_dlt_logstorage_read_list_of_names, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_read_list_of_names(NULL, NULL)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_check_apids*/ +TEST(t_dlt_logstorage_check_apids, normal) +{ + char value[] = "a,b,c,d"; + DltLogStorageFilterConfig config; + config.apids = (char *)calloc (1, sizeof(char)); + if(config.apids != NULL) + { + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_check_apids(&config, value)); + + free(config.apids); + } +} + +TEST(t_dlt_logstorage_check_apids, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_check_apids(NULL, NULL)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_check_ctids*/ +TEST(t_dlt_logstorage_check_ctids, normal) +{ + char value[] = "a,b,c,d"; + DltLogStorageFilterConfig config; + config.ctids = (char *)calloc (1, sizeof(char)); + if(config.ctids != NULL) + { + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_check_ctids(&config, value)); + + free(config.ctids); + } +} + +TEST(t_dlt_logstorage_check_ctids, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_check_ctids(NULL, NULL)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_check_loglevel*/ +TEST(t_dlt_logstorage_check_loglevel, normal) +{ + char value[] = "DLT_LOG_FATAL"; + DltLogStorageFilterConfig config; + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_check_loglevel(&config, value)); + EXPECT_EQ(1, config.log_level); +} + +TEST(t_dlt_logstorage_check_loglevel, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_check_loglevel(NULL, NULL)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_check_filename*/ +TEST(t_dlt_logstorage_check_filename, normal) +{ + char value[] = "file_name"; + DltLogStorageFilterConfig config; + config.file_name = (char *)calloc (1, sizeof(char)); + if(config.file_name != NULL) + { + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_check_filename(&config, value)); + + free(config.file_name); + } +} + +TEST(t_dlt_logstorage_check_filename, abnormal) +{ + char value[] = "../file_name"; + DltLogStorageFilterConfig config; + config.file_name = (char *)calloc (1, sizeof(char)); + if(config.file_name != NULL) + { + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_check_filename(&config, value)); + + free(config.file_name); + } +} + +TEST(t_dlt_logstorage_check_filename, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_check_filename(NULL, NULL)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_check_filesize*/ +TEST(t_dlt_logstorage_check_filesize, normal) +{ + char value[] = "100"; + DltLogStorageFilterConfig config; + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_check_filesize(&config, value)); + EXPECT_EQ(100, config.file_size); +} + +TEST(t_dlt_logstorage_check_filesize, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_check_filesize(NULL, NULL)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_check_nofiles*/ +TEST(t_dlt_logstorage_check_nofiles, normal) +{ + char value[] = "100"; + DltLogStorageFilterConfig config; + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_check_nofiles(&config, value)); + EXPECT_EQ(100, config.num_files); +} + +TEST(t_dlt_logstorage_check_nofiles, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_check_nofiles(NULL, NULL)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_check_sync_strategy*/ +TEST(t_dlt_logstorage_check_sync_strategy, normal) +{ + char value[] = "ON_MSG"; + DltLogStorageFilterConfig config; + config.sync = 0; + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_check_sync_strategy(&config, value)); + EXPECT_EQ(DLT_LOGSTORAGE_SYNC_ON_MSG, config.sync); +} + +TEST(t_dlt_logstorage_check_sync_strategy, abnormal) +{ + char value[] = "UNKNOWN"; + DltLogStorageFilterConfig config; + config.sync = 0; + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_check_sync_strategy(&config, value)); + EXPECT_EQ(DLT_LOGSTORAGE_SYNC_ON_MSG, config.sync); +} + +TEST(t_dlt_logstorage_check_sync_strategy, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_check_sync_strategy(NULL, NULL)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_check_ecuid*/ +TEST(t_dlt_logstorage_check_ecuid, normal) +{ + char value[] = "213"; + DltLogStorageFilterConfig config; + config.ecuid = (char *)calloc (1, sizeof(char)); + if(config.ecuid != NULL) + { + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_check_ecuid(&config, value)); + EXPECT_EQ('2', *config.ecuid); + EXPECT_EQ('1', *(config.ecuid+1)); + EXPECT_EQ('3', *(config.ecuid+2)); + + free(config.ecuid); + } +} + +TEST(t_dlt_logstorage_check_ecuid, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_check_ecuid(NULL, NULL)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_check_param*/ +TEST(t_dlt_logstorage_check_param, normal) +{ + char value[] = "100"; + DltLogStorageFilterConfig config; + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_check_param(&config, DLT_LOGSTORAGE_FILTER_CONF_FILESIZE, value)); + EXPECT_EQ(100, config.file_size); +} + +TEST(t_dlt_logstorage_check_param, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_check_param(NULL, DLT_LOGSTORAGE_FILTER_CONF_FILESIZE, NULL)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_store_filters*/ +TEST(t_dlt_logstorage_store_filters, normal) +{ + DltLogStorage handle; + char config_file_name[] = "/tmp/dlt_logstorage.conf"; + handle.connection_type = DLT_OFFLINE_LOGSTORAGE_DEVICE_CONNECTED; + handle.config_status = 0; + handle.write_errors = 0; + handle.num_filter_keys = 0; + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_create(5,&(handle.config_htab))); + + handle.configs = NULL; + handle.filter_keys = NULL; + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_store_filters(&handle, config_file_name)); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_destroy(&handle.config_htab)); +} + +TEST(t_dlt_logstorage_store_filters, null) +{ + EXPECT_EQ(DLT_RETURN_WRONG_PARAMETER, dlt_logstorage_store_filters(NULL, NULL)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_load_config*/ +TEST(t_dlt_logstorage_load_config, normal) +{ + DltLogStorage handle; + handle.connection_type = DLT_OFFLINE_LOGSTORAGE_DEVICE_CONNECTED; + handle.config_status = 0; + handle.write_errors = 0; + handle.num_filter_keys = 0; + handle.configs = NULL; + handle.filter_keys = NULL; + strncpy(handle.device_mount_point, "/tmp", DLT_MOUNT_PATH_MAX); + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_load_config(&handle)); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_destroy(&handle.config_htab)); +} + +TEST(t_dlt_logstorage_load_config, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_load_config(NULL)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_device_connected*/ +TEST(t_dlt_logstorage_device_connected, normal) +{ + DltLogStorage handle; + char mount_point[DLT_MOUNT_PATH_MAX] = "/tmp"; + handle.config_status = 0; + handle.connection_type = 0; + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_device_connected(&handle, mount_point)); +} + +TEST(t_dlt_logstorage_device_connected, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_device_connected(NULL, NULL)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_device_disconnected*/ +TEST(t_dlt_logstorage_device_disconnected, normal) +{ + DltLogStorage handle; + int reason = 0; + handle.config_status = 0; + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_device_disconnected(&handle, reason)); +} + +TEST(t_dlt_logstorage_device_disconnected, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_device_disconnected(NULL, 1)); +} + +TEST(t_dlt_logstorage_get_loglevel_by_key, normal) +{ + char arr[] = "abc"; + char *key = arr; + DltLogStorageFilterConfig config; + DltLogStorage handle; + handle.config_status = 0; + handle.connection_type = DLT_OFFLINE_LOGSTORAGE_DEVICE_CONNECTED; + handle.config_status = DLT_OFFLINE_LOGSTORAGE_CONFIG_DONE; + + config.log_level = DLT_LOG_ERROR; + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_create(5,&(handle.config_htab))); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_add(key, &config, &(handle.config_htab))); + EXPECT_GE(DLT_LOG_ERROR, dlt_logstorage_get_loglevel_by_key(&handle, key)); +} + +TEST(t_dlt_logstorage_get_loglevel_by_key, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_get_loglevel_by_key(NULL, NULL)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_get_config*/ +TEST(t_dlt_logstorage_get_config, normal) +{ + char apid[] = "1234"; + char ctid[] = "5678"; + char ecuid[] = "12"; + int num_config = 0; + DltLogStorageFilterConfig value; + value.log_level = 0; + value.apids = apid; + value.ctids = ctid; + value.ecuid = ecuid; + char key0[] = "1234:\000\000\000\000"; + char key1[] = ":5678\000\000\000\000"; + char key2[] = "1234:5678"; + DltLogStorageFilterConfig *config[3] = {0}; + DltLogStorage handle; + handle.connection_type = DLT_OFFLINE_LOGSTORAGE_DEVICE_CONNECTED; + handle.config_status = DLT_OFFLINE_LOGSTORAGE_CONFIG_DONE; + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_create(5, &(handle.config_htab))); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_add(key0, &value, &(handle.config_htab))); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_add(key1, &value, &(handle.config_htab))); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_add(key2, &value, &(handle.config_htab))); + + num_config = dlt_logstorage_get_config(&handle, config, apid, ctid); + + EXPECT_EQ(num_config, 3); +} + +TEST(t_dlt_logstorage_get_config, null) +{ + int num = -1; + num = dlt_logstorage_get_config(NULL, NULL, NULL, NULL); + + EXPECT_EQ(num, 0); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_filter*/ +TEST(t_dlt_logstorage_filter, normal) +{ + char apid[] = "1234"; + char ctid[] = "5678"; + char ecuid[] = "12"; + int num = 1; + DltLogStorageFilterConfig value; + value.apids = apid; + value.ctids = ctid; + value.ecuid = ecuid; + char key0[] = "1234:\000\000\000\000"; + char key1[] = ":5678\000\000\000\000"; + char key2[] = "1234:5678"; + DltLogStorageFilterConfig *config[3] = {0}; + DltLogStorage handle; + handle.connection_type = DLT_OFFLINE_LOGSTORAGE_DEVICE_CONNECTED; + handle.config_status = DLT_OFFLINE_LOGSTORAGE_CONFIG_DONE; + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_create(5, &(handle.config_htab))); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_add(key0, &value, &(handle.config_htab))); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_add(key1, &value, &(handle.config_htab))); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_add(key2, &value, &(handle.config_htab))); + + num = dlt_logstorage_filter(&handle, config, apid, ctid, ecuid, 0); + + EXPECT_EQ(num, 3); +} + +TEST(t_dlt_logstorage_filter, null) +{ + DltLogStorageFilterConfig *config[3] = {0}; + int num = dlt_logstorage_filter(NULL, config, NULL, NULL, NULL, 0); + EXPECT_EQ(DLT_RETURN_WRONG_PARAMETER, num); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_write*/ +TEST(t_dlt_logstorage_write, normal) +{ + char apid[] = "1234"; + char ctid[] = "5678"; + char ecuid[] = "12"; + DltLogStorage handle; + DltLogStorageUserConfig uconfig; + unsigned char data1[] = "123"; + int size1 = 3; + unsigned char data2[] = "123"; + int size2 = 3; + unsigned char data3[] = "123"; + int size3 = 3; + handle.connection_type = DLT_OFFLINE_LOGSTORAGE_DEVICE_CONNECTED; + handle.config_status = DLT_OFFLINE_LOGSTORAGE_CONFIG_DONE; + DltLogStorageFilterConfig value; + value.apids = apid; + value.ctids = ctid; + value.ecuid = ecuid; + char key0[] = "1234:\000\000\000\000"; + char key1[] = ":5678\000\000\000\000"; + char key2[] = "1234:5678"; + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_create(5, &(handle.config_htab))); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_add(key0, &value, &(handle.config_htab))); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_add(key1, &value, &(handle.config_htab))); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_add(key2, &value, &(handle.config_htab))); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_write(&handle, &uconfig, data1, size1, data2, size2, data3, size3)); +} + +TEST(t_dlt_logstorage_write, null) +{ + EXPECT_EQ(0, dlt_logstorage_write(NULL, NULL, NULL, 1, NULL, 1, NULL, 1)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_sync_caches*/ +TEST(t_dlt_logstorage_sync_caches, normal) +{ + char apid[] = "1234"; + char ctid[] = "5678"; + char ecuid[] = "12"; + DltLogStorage handle; + handle.num_configs = 1; + DltLogStorageFilterConfig configs; + handle.configs = &configs; + configs.apids = apid; + configs.ctids = ctid; + configs.ecuid = ecuid; + dlt_logstorage_filter_set_strategy(handle.configs, DLT_LOGSTORAGE_SYNC_ON_MSG); + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_sync_caches(&handle)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_log_file_name*/ +TEST(t_dlt_logstorage_log_file_name, normal) +{ + char log_file_name[DLT_MOUNT_PATH_MAX] = {'\0'}; + DltLogStorageUserConfig file_config; + file_config.logfile_delimiter = '/'; + file_config.logfile_maxcounter = 0; + file_config.logfile_timestamp = 1; + file_config.logfile_counteridxlen = 10; + int cmpRes = 0; + char name[] = "log"; + dlt_logstorage_log_file_name(log_file_name, &file_config, name, 0); + cmpRes = strncmp(log_file_name, "log/0000000000", 14); + + EXPECT_EQ(0, cmpRes); +} + +TEST(t_dlt_logstorage_log_file_name, null) +{ + char name[] = "log"; + dlt_logstorage_log_file_name(NULL, NULL, name, 0); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_sort_file_name*/ +TEST(t_dlt_logstorage_sort_file_name, normal) +{ + DltLogStorageFileList *node1, *node2, *node3;; + DltLogStorageFileList **head; + node1 = (DltLogStorageFileList *)calloc (1, sizeof(DltLogStorageFileList)); + node2 = (DltLogStorageFileList *)calloc (1, sizeof(DltLogStorageFileList)); + node3 = (DltLogStorageFileList *)calloc (1, sizeof(DltLogStorageFileList)); + if(node1 != NULL && node2 != NULL && node3 != NULL) + { + node1->next = node2; + node2->next = node3; + node3->next = NULL; + head = &node1; + + node1->idx = 8; + node2->idx = 4; + node3->idx = 1; + + EXPECT_EQ(8, (*head)->idx); + EXPECT_EQ(4, ((*head)->next)->idx); + EXPECT_EQ(1, ((((*head)->next)->next)->idx)); + + dlt_logstorage_sort_file_name(head); + + EXPECT_EQ(1, (*head)->idx); + EXPECT_EQ(4, ((*head)->next)->idx); + EXPECT_EQ(8, ((((*head)->next)->next)->idx)); + free((((*head)->next)->next)); + free(((*head)->next)); + free(*head); + node1 = NULL; + node2 = NULL; + node3 = NULL; + } + if(node1 != NULL) + { + free(node1); + } + if(node2 != NULL) + { + free(node2); + } + if(node3 != NULL) + { + free(node3); + } +} + +TEST(t_dlt_logstorage_sort_file_name, null) +{ + dlt_logstorage_sort_file_name(NULL); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_rearrange_file_name*/ +TEST(t_dlt_logstorage_rearrange_file_name, normal) +{ + DltLogStorageFileList *node1, *node2, *node3;; + DltLogStorageFileList **head; + node1 = (DltLogStorageFileList *)calloc (1, sizeof(DltLogStorageFileList)); + node2 = (DltLogStorageFileList *)calloc (1, sizeof(DltLogStorageFileList)); + node3 = (DltLogStorageFileList *)calloc (1, sizeof(DltLogStorageFileList)); + if((node1 != NULL) && (node2 != NULL) && (node3 != NULL)) + { + + node1->next = node2; + node2->next = node3; + node3->next = NULL; + + head = &node1; + + node1->idx = 8; + node2->idx = 4; + node3->idx = 1; + + EXPECT_EQ(8, (*head)->idx); + EXPECT_EQ(4, ((*head)->next)->idx); + EXPECT_EQ(1, ((((*head)->next)->next)->idx)); + + dlt_logstorage_rearrange_file_name(head); + + EXPECT_EQ(1, (*head)->idx); + EXPECT_EQ(8, ((*head)->next)->idx); + EXPECT_EQ(4, ((((*head)->next)->next)->idx)); + free((((*head)->next)->next)); + free(((*head)->next)); + free(*head); + node1 = NULL; + node2 = NULL; + node3 = NULL; + } + if(node1 != NULL) + { + free(node1); + } + if(node2 != NULL) + { + free(node2); + } + if(node3 != NULL) + { + free(node3); + } +} + +TEST(t_dlt_logstorage_rearrange_file_name, null) +{ + dlt_logstorage_rearrange_file_name(NULL); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_get_idx_of_log_file*/ +TEST(t_dlt_logstorage_get_idx_of_log_file, normal) +{ + DltLogStorageUserConfig file_config; + file_config.logfile_timestamp =191132; + file_config.logfile_delimiter = {'_'}; + file_config.logfile_maxcounter = 2; + file_config.logfile_counteridxlen = 2; + char *file = (char*)"Test_002_20160509_191132.dlt"; + + EXPECT_EQ(2, dlt_logstorage_get_idx_of_log_file(&file_config, file)); +} +TEST(t_dlt_logstorage_get_idx_of_log_file, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_get_idx_of_log_file(NULL, NULL)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_storage_dir_info*/ +TEST(t_dlt_logstorage_storage_dir_info, normal) +{ + DltLogStorageUserConfig file_config; + file_config.logfile_timestamp =191132; + file_config.logfile_delimiter = {'_'}; + file_config.logfile_maxcounter = 2; + file_config.logfile_counteridxlen = 2; + char *path = (char*)"/tmp"; + DltLogStorageFilterConfig config; + char apids; + char ctids; + config.apids = &apids; + config.ctids = &ctids; + config.file_name = (char*)"Test_002_20160509_191132.dlt"; + config.records = NULL; + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_storage_dir_info(&file_config, path, &config)); +} +TEST(t_dlt_logstorage_storage_dir_info, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_storage_dir_info(NULL, NULL, NULL)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_open_log_file*/ +TEST(t_dlt_logstorage_open_log_file, normal) +{ + DltLogStorageUserConfig file_config; + file_config.logfile_timestamp =191132; + file_config.logfile_delimiter = {'_'}; + file_config.logfile_maxcounter = 2; + file_config.logfile_counteridxlen = 2; + char *path = (char*)"/tmp"; + DltLogStorageFilterConfig config; + char apids; + char ctids; + config.apids = &apids; + config.ctids = &ctids; + config.file_name = (char*)"Test"; + config.records = NULL; + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_open_log_file(&config, &file_config, path, 1)); +} +TEST(t_dlt_logstorage_open_log_file, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_open_log_file(NULL, NULL, NULL, 0)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_prepare_on_msg*/ +TEST(t_dlt_logstorage_prepare_on_msg, normal) +{ + DltLogStorageUserConfig file_config; + file_config.logfile_timestamp =191132; + file_config.logfile_delimiter = {'_'}; + file_config.logfile_maxcounter = 2; + file_config.logfile_counteridxlen = 2; + char *path = (char*)"/tmp"; + DltLogStorageFilterConfig config; + char apids; + char ctids; + config.apids = &apids; + config.ctids = &ctids; + config.file_name = (char*)"Test"; + config.records = NULL; + config.log = NULL; + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_prepare_on_msg(&config, &file_config, path, 1)); +} + +TEST(t_dlt_logstorage_prepare_on_msg, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_prepare_on_msg(NULL, NULL, NULL, 0)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_write_on_msg*/ +TEST(t_dlt_logstorage_write_on_msg, normal) +{ + DltLogStorageUserConfig file_config; + file_config.logfile_timestamp =191132; + file_config.logfile_delimiter = {'_'}; + file_config.logfile_maxcounter = 2; + file_config.logfile_counteridxlen = 2; + char *path = (char*)"/tmp"; + DltLogStorageFilterConfig config; + char apids; + char ctids; + config.apids = &apids; + config.ctids = &ctids; + config.file_name = (char*)"Test"; + config.records = NULL; + config.log = NULL; + unsigned int size = 8; + unsigned char data1[] = "dlt_data"; + unsigned char data2[] = "dlt_data"; + unsigned char data3[] = "dlt_data"; + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_prepare_on_msg(&config, &file_config, path, 1)); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_write_on_msg(&config, data1, size, data2, size, data3, size)); +} + +TEST(t_dlt_logstorage_write_on_msg, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_write_on_msg(NULL, NULL, 0, NULL, 0, NULL, 0)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_sync_on_msg*/ +TEST(t_dlt_logstorage_sync_on_msg, normal) +{ + DltLogStorageFilterConfig config; + char apids; + char ctids; + config.apids = &apids; + config.ctids = &ctids; + config.file_name = (char*)"Test"; + config.records = NULL; + config.log = NULL; + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_sync_on_msg(&config, DLT_LOGSTORAGE_SYNC_ON_MSG)); +} + +TEST(t_dlt_logstorage_sync_on_msg, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_sync_on_msg(NULL, 0)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_prepare_msg_cache*/ +TEST(t_dlt_logstorage_prepare_msg_cache, normal) +{ + DltLogStorageUserConfig file_config; + file_config.logfile_timestamp =191132; + file_config.logfile_delimiter = {'_'}; + file_config.logfile_maxcounter = 2; + file_config.logfile_counteridxlen = 2; + char *path = (char*)"/tmp"; + DltLogStorageFilterConfig config; + char apids; + char ctids; + config.apids = &apids; + config.ctids = &ctids; + config.file_name = (char*)"Test"; + config.records = NULL; + config.log = NULL; + config.cache = NULL; + config.file_size = 0; + g_logstorage_cache_max = 16; + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_prepare_msg_cache(&config, &file_config, path, 1)); + + free(config.cache); +} + +TEST(t_dlt_logstorage_prepare_msg_cache, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_prepare_msg_cache(NULL, NULL, NULL, 0)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_write_msg_cache*/ +TEST(t_dlt_logstorage_write_msg_cache, normal) +{ + unsigned int size = 10; + unsigned char data1[10] = "dlt_data1"; + unsigned char data2[10] = "dlt_data2"; + unsigned char data3[10] = "dlt_dat3"; + DltLogStorageFilterConfig config; + memset(&config, 0, sizeof(DltLogStorageFilterConfig)); + + config.cache = calloc(1, 50 + sizeof(DltLogStorageCacheFooter)); + if(config.cache != NULL) + { + config.file_size = 50; + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_write_msg_cache(&config, data1, size, data2, size, data3, size)); + + free(config.cache); + config.cache = NULL; + } +} + +TEST(t_dlt_logstorage_write_msg_cache, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_write_msg_cache(NULL, NULL, 0, NULL, 0, NULL, 0)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_split_key*/ +TEST(t_dlt_logstorage_split_key, normal) +{ + char key[] = "dlt:1020"; + char appid[] = "2345"; + char ctxid[] = "6789"; + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_split_key(key, appid, ctxid)); +} + +TEST(t_dlt_logstorage_split_key, null) +{ + char key[] = "dlt:1020"; + char appid[] = "2345"; + char ctxid[] = "6789"; + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_split_key(NULL, NULL, NULL)); + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_split_key(NULL, appid, ctxid)); + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_split_key(key, NULL, ctxid)); + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_split_key(key, appid, NULL)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_update_all_contexts*/ +TEST(t_dlt_logstorage_update_all_contexts, normal) +{ + DltDaemon daemon; + DltGateway gateway; + memset(&daemon, 0, sizeof(DltDaemon)); + memset(&gateway, 0, sizeof(DltGateway)); + char ecu[] = "ECU1"; + + EXPECT_EQ(0, dlt_daemon_init(&daemon, + DLT_DAEMON_RINGBUFFER_MIN_SIZE, + DLT_DAEMON_RINGBUFFER_MAX_SIZE, + DLT_DAEMON_RINGBUFFER_STEP_SIZE, + DLT_RUNTIME_DEFAULT_DIRECTORY, + DLT_LOG_INFO, DLT_TRACE_STATUS_OFF,0,0)); + dlt_set_id(daemon.ecuid, ecu); + EXPECT_EQ(0, dlt_daemon_init_user_information(&daemon, &gateway, 0, 0)); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_update_all_contexts(&daemon, ecu, 1, 1, 0)); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_update_all_contexts(&daemon, ecu, 0, 1, 0)); +} + +TEST(t_dlt_logstorage_update_all_contexts, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_update_all_contexts(NULL, NULL, 0, 0, 0)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_update_context*/ +TEST(t_dlt_logstorage_update_context, normal) +{ + DltDaemon daemon; + DltGateway gateway; + DltDaemonContext *daecontext = NULL; + memset(&daemon, 0, sizeof(DltDaemon)); + memset(&gateway, 0, sizeof(DltGateway)); + + char apid[] = "123"; + char ctid[] = "456"; + char desc[255] = "TEST dlt_logstorage_update_context"; + char ecu[] = "ECU1"; + + EXPECT_EQ(0, dlt_daemon_init(&daemon, + DLT_DAEMON_RINGBUFFER_MIN_SIZE, + DLT_DAEMON_RINGBUFFER_MAX_SIZE, + DLT_DAEMON_RINGBUFFER_STEP_SIZE, + DLT_RUNTIME_DEFAULT_DIRECTORY, + DLT_LOG_INFO, DLT_TRACE_STATUS_OFF,0,0)); + dlt_set_id(daemon.ecuid, ecu); + EXPECT_EQ(0, dlt_daemon_init_user_information(&daemon, &gateway, 0, 0)); + daecontext = dlt_daemon_context_add(&daemon, apid, ctid, DLT_LOG_DEFAULT, + DLT_TRACE_STATUS_DEFAULT, 0, 0, desc, daemon.ecuid, 0); + EXPECT_EQ((DltDaemonContext*)(NULL), daecontext); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_update_context(&daemon, apid, ctid, 1, 0)); +} + +TEST(t_dlt_logstorage_update_context, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_update_context(NULL, NULL, NULL, 0, 0)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_update_context_loglevel*/ +TEST(t_dlt_logstorage_update_context_loglevel, normal) +{ + DltDaemon daemon; + DltGateway gateway; + DltDaemonContext *daecontext = NULL; + memset(&daemon, 0, sizeof(DltDaemon)); + memset(&gateway, 0, sizeof(DltGateway)); + + char apid[] = "123"; + char ctid[] = "456"; + char key[] = "123:456"; + char desc[255] = "TEST dlt_logstorage_update_context"; + char ecu[] = "ECU1"; + + EXPECT_EQ(0, dlt_daemon_init(&daemon, + DLT_DAEMON_RINGBUFFER_MIN_SIZE, + DLT_DAEMON_RINGBUFFER_MAX_SIZE, + DLT_DAEMON_RINGBUFFER_STEP_SIZE, + DLT_RUNTIME_DEFAULT_DIRECTORY, + DLT_LOG_INFO, DLT_TRACE_STATUS_OFF,0,0)); + dlt_set_id(daemon.ecuid, ecu); + EXPECT_EQ(0, dlt_daemon_init_user_information(&daemon, &gateway, 0, 0)); + + daecontext = dlt_daemon_context_add(&daemon, apid, ctid, DLT_LOG_DEFAULT, + DLT_TRACE_STATUS_DEFAULT, 0, 0, desc, daemon.ecuid, 0); + + EXPECT_EQ((DltDaemonContext*)(NULL), daecontext); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_update_context_loglevel + (&daemon, key, 1, 0)); +} + +TEST(t_dlt_logstorage_update_context_loglevel, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_update_context_loglevel(NULL, NULL, 0, 0)); +} + +/* Begin Method: dlt_logstorage::t_dlt_daemon_logstorage_reset_application_loglevel*/ +TEST(t_dlt_daemon_logstorage_reset_application_loglevel, normal) +{ + DltDaemon daemon; + DltGateway gateway; + memset(&daemon, 0, sizeof(DltDaemon)); + memset(&gateway, 0, sizeof(DltGateway)); + char ecu[] = "ECU1"; + int device_index = 0; + EXPECT_EQ(0, dlt_daemon_init(&daemon, + DLT_DAEMON_RINGBUFFER_MIN_SIZE, + DLT_DAEMON_RINGBUFFER_MAX_SIZE, + DLT_DAEMON_RINGBUFFER_STEP_SIZE, + DLT_RUNTIME_DEFAULT_DIRECTORY, + DLT_LOG_INFO, DLT_TRACE_STATUS_OFF,0,0)); + dlt_set_id(daemon.ecuid, ecu); + EXPECT_EQ(0, dlt_daemon_init_user_information(&daemon, &gateway, 0, 0)); + EXPECT_NO_THROW(dlt_daemon_logstorage_reset_application_loglevel(&daemon, device_index, 1, 0)); +} + +TEST(t_dlt_daemon_logstorage_reset_application_loglevel, null) +{ + EXPECT_NO_THROW(dlt_daemon_logstorage_reset_application_loglevel(NULL, 0, 0, 0)); +} + +/* Begin Method: dlt_logstorage::t_dlt_daemon_logstorage_update_application_loglevel*/ +TEST(t_dlt_daemon_logstorage_update_application_loglevel, normal) +{ + char ecu[] = "ECU1"; + int device_index = 0; + DltDaemon daemon; + DltGateway gateway; + memset(&daemon, 0, sizeof(DltDaemon)); + memset(&gateway, 0, sizeof(DltGateway)); + DltLogStorageFilterConfig value; + value.log_level = 5; + DltLogStorage storage_handle; + + EXPECT_EQ(0, dlt_daemon_init(&daemon, + DLT_DAEMON_RINGBUFFER_MIN_SIZE, + DLT_DAEMON_RINGBUFFER_MAX_SIZE, + DLT_DAEMON_RINGBUFFER_STEP_SIZE, + DLT_RUNTIME_DEFAULT_DIRECTORY, + DLT_LOG_INFO, DLT_TRACE_STATUS_OFF,0,0)); + dlt_set_id(daemon.ecuid, ecu); + EXPECT_EQ(0, dlt_daemon_init_user_information(&daemon, &gateway, 0, 0)); + + daemon.storage_handle = &storage_handle; + daemon.storage_handle->connection_type = DLT_OFFLINE_LOGSTORAGE_DEVICE_CONNECTED; + daemon.storage_handle->num_filter_keys = 1; + daemon.storage_handle->config_status = DLT_OFFLINE_LOGSTORAGE_CONFIG_DONE; + daemon.storage_handle->filter_keys = (char*)calloc( + DLT_OFFLINE_LOGSTORAGE_MAX_KEY_LEN, sizeof(char)); + strncpy(daemon.storage_handle->filter_keys, "key:1020", + DLT_OFFLINE_LOGSTORAGE_MAX_KEY_LEN); + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_create(5, &(daemon.storage_handle->config_htab))); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_add(daemon.storage_handle->filter_keys, &value, &(daemon.storage_handle->config_htab))); + EXPECT_NO_THROW(dlt_daemon_logstorage_update_application_loglevel(&daemon, device_index, 0)); + free(daemon.storage_handle->filter_keys); +} + +TEST(t_dlt_daemon_logstorage_update_application_loglevel, null) +{ + EXPECT_NO_THROW(dlt_daemon_logstorage_update_application_loglevel(NULL, 0, 0)); +} + +/* Begin Method: dlt_logstorage::t_dlt_daemon_logstorage_get_loglevel*/ +TEST(t_dlt_daemon_logstorage_get_loglevel, normal) +{ + char ecu[] = "ECU1"; + char apid[] = "1234"; + char ctid[] = "5678"; + int device_index = 0; + DltDaemon daemon; + DltGateway gateway; + memset(&daemon, 0, sizeof(DltDaemon)); + memset(&gateway, 0, sizeof(DltGateway)); + DltLogStorageFilterConfig value; + value.log_level = 5; + value.apids = apid; + value.ctids = ctid; + value.ecuid = ecu; + DltLogStorage storage_handle; + + EXPECT_EQ(0, dlt_daemon_init(&daemon, + DLT_DAEMON_RINGBUFFER_MIN_SIZE, + DLT_DAEMON_RINGBUFFER_MAX_SIZE, + DLT_DAEMON_RINGBUFFER_STEP_SIZE, + DLT_RUNTIME_DEFAULT_DIRECTORY, + DLT_LOG_INFO, DLT_TRACE_STATUS_OFF,0,0)); + dlt_set_id(daemon.ecuid, ecu); + EXPECT_EQ(0, dlt_daemon_init_user_information(&daemon, &gateway, 0, 0)); + + daemon.storage_handle = &storage_handle; + daemon.storage_handle->connection_type = DLT_OFFLINE_LOGSTORAGE_DEVICE_CONNECTED; + daemon.storage_handle->num_filter_keys = 1; + daemon.storage_handle->config_status = DLT_OFFLINE_LOGSTORAGE_CONFIG_DONE; + daemon.storage_handle->filter_keys = (char*)calloc( + DLT_OFFLINE_LOGSTORAGE_MAX_KEY_LEN, sizeof(char)); + strncpy(daemon.storage_handle->filter_keys, "1234:5678", + DLT_OFFLINE_LOGSTORAGE_MAX_KEY_LEN); + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_create(5, &(daemon.storage_handle->config_htab))); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_add(daemon.storage_handle-> + filter_keys, &value, &(daemon.storage_handle->config_htab))); + EXPECT_NO_THROW(dlt_daemon_logstorage_update_application_loglevel(&daemon, device_index, 0)); + + EXPECT_EQ(5, dlt_daemon_logstorage_get_loglevel(&daemon, 1, apid, ctid)); + free(daemon.storage_handle->filter_keys); +} + +TEST(t_dlt_daemon_logstorage_get_loglevel, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_daemon_logstorage_get_loglevel(NULL, 0, NULL, NULL)); +} + +/* Begin Method: dlt_logstorage::t_dlt_daemon_logstorage_write*/ +TEST(t_dlt_daemon_logstorage_write, normal) +{ + DltDaemon daemon; + DltGateway gateway; + memset(&daemon, 0, sizeof(DltDaemon)); + memset(&gateway, 0, sizeof(DltGateway)); + char ecu[] = "ECU1"; + DltLogStorage storage_handle; + + EXPECT_EQ(0, dlt_daemon_init(&daemon, + DLT_DAEMON_RINGBUFFER_MIN_SIZE, + DLT_DAEMON_RINGBUFFER_MAX_SIZE, + DLT_DAEMON_RINGBUFFER_STEP_SIZE, + DLT_RUNTIME_DEFAULT_DIRECTORY, + DLT_LOG_INFO, DLT_TRACE_STATUS_OFF,0,0)); + dlt_set_id(daemon.ecuid, ecu); + EXPECT_EQ(0, dlt_daemon_init_user_information(&daemon, &gateway, 0, 0)); + daemon.storage_handle = &storage_handle; + char apid[] = "1234"; + char ctid[] = "5678"; + char ecuid[] = "12"; + DltDaemonFlags uconfig; + uconfig.offlineLogstorageTimestamp = 1; + uconfig.offlineLogstorageDelimiter = '/'; + uconfig.offlineLogstorageMaxCounter = 5; + uconfig.offlineLogstorageMaxCounterIdx = 1; + uconfig.offlineLogstorageMaxDevices = 1; + unsigned char data1[] = "123"; + unsigned char data2[] = "123"; + unsigned char data3[] = "123"; + int size = 10 * sizeof(uint32_t);; + daemon.storage_handle->connection_type = DLT_OFFLINE_LOGSTORAGE_DEVICE_CONNECTED; + daemon.storage_handle->config_status = DLT_OFFLINE_LOGSTORAGE_CONFIG_DONE; + DltLogStorageFilterConfig value; + value.apids = apid; + value.ctids = ctid; + value.ecuid = ecuid; + char key0[] = "1234:\000\000\000\000"; + char key1[] = ":5678\000\000\000\000"; + char key2[] = "1234:5678"; + DltLogStorageFilterConfig configs; + daemon.storage_handle->configs = &configs; + daemon.storage_handle->configs->apids = apid; + daemon.storage_handle->configs->ctids = ctid; + daemon.storage_handle->configs->ecuid = ecuid; + daemon.storage_handle->configs->log_level = 5; + + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_create(5, &(daemon.storage_handle->config_htab))); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_add(key0, &value, &(daemon.storage_handle->config_htab))); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_add(key1, &value, &(daemon.storage_handle->config_htab))); + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_hash_add(key2, &value, &(daemon.storage_handle->config_htab))); + EXPECT_NO_THROW(dlt_daemon_logstorage_write(&daemon, &uconfig, data1, size, data2, size, data3, size)); +} + +TEST(t_dlt_daemon_logstorage_write, null) +{ + EXPECT_NO_THROW(dlt_daemon_logstorage_write(NULL, NULL, NULL, 0, NULL, 0,NULL, 0)); +} + +/* Begin Method: dlt_logstorage::t_dlt_daemon_logstorage_setup_internal_storage*/ +TEST(t_dlt_daemon_logstorage_setup_internal_storage, normal) +{ + DltDaemon daemon; + DltGateway gateway; + memset(&daemon, 0, sizeof(DltDaemon)); + memset(&gateway, 0, sizeof(DltGateway)); + char ecu[] = "ECU1"; + char path[] = "/tmp"; + EXPECT_EQ(0, dlt_daemon_init(&daemon, + DLT_DAEMON_RINGBUFFER_MIN_SIZE, + DLT_DAEMON_RINGBUFFER_MAX_SIZE, + DLT_DAEMON_RINGBUFFER_STEP_SIZE, + DLT_RUNTIME_DEFAULT_DIRECTORY, + DLT_LOG_INFO, DLT_TRACE_STATUS_OFF,0,0)); + dlt_set_id(daemon.ecuid, ecu); + EXPECT_EQ(0, dlt_daemon_init_user_information(&daemon, &gateway, 0, 0)); + DltLogStorage storage_handle; + daemon.storage_handle = &storage_handle; + daemon.storage_handle->config_status = 0; + daemon.storage_handle->connection_type = DLT_OFFLINE_LOGSTORAGE_DEVICE_DISCONNECTED; + EXPECT_EQ(DLT_RETURN_OK, dlt_daemon_logstorage_setup_internal_storage(&daemon, path, 1, 0)); +} + +TEST(t_dlt_daemon_logstorage_setup_internal_storage, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_daemon_logstorage_setup_internal_storage(NULL, NULL, 0, 0)); +} + +/* Begin Method: dlt_logstorage::dlt_daemon_logstorage_set_logstorage_cache_size*/ +TEST(t_dlt_daemon_logstorage_set_logstorage_cache_size, normal) +{ + EXPECT_NO_THROW(dlt_daemon_logstorage_set_logstorage_cache_size(1)); +} + +/* Begin Method: dlt_logstorage::t_dlt_daemon_logstorage_cleanup*/ +TEST(t_dlt_daemon_logstorage_cleanup, normal) +{ + DltDaemon daemon; + DltDaemonLocal daemon_local; + daemon_local.flags.offlineLogstorageMaxDevices = 1; + DltLogStorage storage_handle; + daemon.storage_handle = &storage_handle; + daemon.storage_handle->config_status = 0; + EXPECT_EQ(DLT_RETURN_OK, dlt_daemon_logstorage_cleanup(&daemon, &daemon_local, 0)); +} + +TEST(t_dlt_daemon_logstorage_cleanup, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_daemon_logstorage_cleanup(NULL, NULL, 0)); +} + +/* Begin Method: dlt_logstorage::t_dlt_daemon_logstorage_sync_cache*/ +TEST(t_dlt_daemon_logstorage_sync_cache, normal) +{ + DltDaemon daemon; + DltDaemonLocal daemon_local; + daemon_local.flags.offlineLogstorageMaxDevices = 1; + DltLogStorage storage_handle; + daemon.storage_handle = &storage_handle; + daemon.storage_handle->config_status = 0; + char path[] = "/tmp"; + char apid[] = "1234"; + char ctid[] = "5678"; + char ecuid[] = "12"; + daemon.storage_handle->num_configs = 1; + DltLogStorageFilterConfig configs; + daemon.storage_handle->configs = &configs; + configs.apids = apid; + configs.ctids = ctid; + configs.ecuid = ecuid; + dlt_logstorage_filter_set_strategy(daemon.storage_handle->configs, DLT_LOGSTORAGE_SYNC_ON_MSG); + + EXPECT_EQ(DLT_RETURN_OK, dlt_daemon_logstorage_sync_cache(&daemon, &daemon_local, path, 0)); +} + +TEST(t_dlt_daemon_logstorage_sync_cache, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_daemon_logstorage_sync_cache(NULL, NULL, NULL, 0)); +} + +/* Begin Method: dlt_logstorage::t_dlt_daemon_logstorage_get_device*/ +TEST(t_dlt_daemon_logstorage_get_device, normal) +{ + DltDaemon daemon; + DltDaemonLocal daemon_local; + daemon_local.flags.offlineLogstorageMaxDevices = 1; + DltLogStorage storage_handle; + daemon.storage_handle = &storage_handle; + daemon.storage_handle->config_status = 0; + char path[] = "/tmp"; + strncpy(daemon.storage_handle->device_mount_point, "/tmp", 5); + + EXPECT_NE((DltLogStorage *)NULL, dlt_daemon_logstorage_get_device(&daemon, &daemon_local, path, 0)); +} + +TEST(t_dlt_daemon_logstorage_get_device, null) +{ + EXPECT_EQ((DltLogStorage *)NULL, dlt_daemon_logstorage_get_device(NULL, NULL, NULL, 0)); +} + +/* Begin Method: dlt_logstorage::t_dlt_logstorage_sync_msg_cache*/ +TEST(t_dlt_logstorage_sync_msg_cache, normal) +{ + DltLogStorageFilterConfig config; + memset(&config, 0, sizeof(DltLogStorageFilterConfig)); + config.sync = 1; + config.log = fopen("/tmp/test.log", "a+"); + if(config.log != NULL) + { + config.cache = calloc(1, 1 + sizeof(DltLogStorageCacheFooter)); + if(config.cache != NULL) + { + config.file_size = 1; + EXPECT_EQ(DLT_RETURN_OK, dlt_logstorage_sync_msg_cache(&config, 1)); + free(config.cache); + config.cache = NULL; + } + } +} + +TEST(t_dlt_logstorage_sync_msg_cache, null) +{ + EXPECT_EQ(DLT_RETURN_ERROR, dlt_logstorage_sync_msg_cache(NULL, 0)); +} + +int main(int argc, char **argv) +{ + ::testing::InitGoogleTest(&argc, argv); + ::testing::FLAGS_gtest_break_on_failure = true; + return RUN_ALL_TESTS(); +} -- cgit v1.2.1