/* * @licence app begin@ * SPDX license identifier: MPL-2.0 * * 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. * * This file is part of GENIVI Project DLT - Diagnostic Log and Trace. * * This Source Code Form is subject to the terms of the * Mozilla Public License (MPL), 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/. * * For further information see http://www.genivi.org/. * @licence end@ */ /*! * \author Onkar Palkar onkar.palkar@wipro.com * * \copyright Copyright © 2016 Advanced Driver Information Technology. * * License MPL-2.0: Mozilla Public License version 2.0 http://mozilla.org/MPL/2.0/. * * \file gtest_dlt_daemon_event_handler.cpp */ /******************************************************************************* ** ** ** SRC-MODULE: gtest_dlt_daemon_event_handler.cpp ** ** ** ** TARGET : linux ** ** ** ** PROJECT : DLT ** ** ** ** AUTHOR : Onkar Palkar onkar.palkar@wipro.com ** ** PURPOSE : Unit test connection and event handling ** ** ** ** REMARKS : ** ** ** ** PLATFORM DEPENDANT [yes/no]: yes ** ** ** ** TO BE CHANGED BY USER [yes/no]: no ** ** ** *******************************************************************************/ /******************************************************************************* ** Author Identity ** ******************************************************************************** ** ** ** Initials Name Company ** ** -------- ------------------------- ---------------------------------- ** ** op Onkar Palkar Wipro ** *******************************************************************************/ #include int connectServer(void); extern "C" { #include "dlt_daemon_event_handler.h" #include "dlt_daemon_connection.h" #include #include #include #include } /* Begin Method: dlt_daemon_event_handler::t_dlt_daemon_prepare_event_handling*/ TEST(t_dlt_daemon_prepare_event_handling, normal) { DltEventHandler ev; EXPECT_EQ(DLT_RETURN_OK, dlt_daemon_prepare_event_handling(&ev)); } TEST(t_dlt_daemon_prepare_event_handling, nullpointer) { // NULL-Pointer, expect -1 EXPECT_EQ(DLT_RETURN_ERROR, dlt_daemon_prepare_event_handling(NULL)); } /* Begin Method: dlt_daemon_event_handler::t_dlt_daemon_handle_event*/ TEST(t_dlt_daemon_handle_event, normal) { DltDaemonLocal daemon_local; DltDaemon daemon; EXPECT_EQ(DLT_RETURN_OK, dlt_daemon_prepare_event_handling(&daemon_local.pEvent)); EXPECT_EQ(DLT_RETURN_OK, dlt_daemon_handle_event(&daemon_local.pEvent, &daemon, &daemon_local)); } TEST(t_dlt_daemon_handle_event, nullpointer) { EXPECT_EQ(DLT_RETURN_ERROR, dlt_daemon_handle_event(NULL,NULL,NULL)); } /* Begin Method: dlt_daemon_event_handler::dlt_event_handler_find_connection*/ TEST(t_dlt_event_handler_find_connection, normal) { int fd = 10; DltEventHandler ev = {}; DltConnection connections = {}; DltConnection *ret = nullptr; DltReceiver receiver = {}; receiver.fd = fd; ev.connections = &connections; ev.connections->receiver = &receiver; ret = dlt_event_handler_find_connection(&ev, fd); EXPECT_EQ(10, ret->receiver->fd); } /* Begin Method: dlt_daemon_event_handler::dlt_daemon_add_connection*/ TEST(t_dlt_daemon_add_connection, normal) { DltEventHandler ev1 = {}; DltConnection *head = nullptr; DltConnection *connections1 = nullptr; DltReceiver receiver = {}; ev1.connections = (DltConnection *)malloc(sizeof(DltConnection)); head = (DltConnection*)ev1.connections; memset(ev1.connections, 0, sizeof(DltConnection)); ev1.connections->next = 0; ev1.connections->type = DLT_CONNECTION_CLIENT_MSG_SERIAL; connections1 = (DltConnection *)malloc(sizeof(DltConnection)); memset(connections1, 0, sizeof(DltConnection)); connections1->next = 0; connections1->type = DLT_CONNECTION_GATEWAY; connections1->receiver = &receiver; EXPECT_EQ(DLT_CONNECTION_CLIENT_MSG_SERIAL, ev1.connections->type); dlt_daemon_add_connection(&ev1, connections1); head = (DltConnection*)ev1.connections->next; EXPECT_EQ(DLT_CONNECTION_GATEWAY, head->type); free(ev1.connections); free(connections1); } /* Begin Method: dlt_daemon_event_handler::dlt_daemon_remove_connection*/ TEST(t_dlt_daemon_remove_connection, normal) { DltEventHandler ev1 = {}; DltConnection *head = nullptr; DltConnection *connections1 = nullptr; ev1.connections = (DltConnection *)malloc(sizeof(DltConnection)); head = (DltConnection*)ev1.connections; memset(ev1.connections, 0, sizeof(DltConnection)); ev1.connections->next = 0; ev1.connections->type = DLT_CONNECTION_CLIENT_MSG_SERIAL; connections1 = (DltConnection *)malloc(sizeof(DltConnection)); memset(connections1, 0, sizeof(DltConnection)); connections1->next = 0; connections1->type = DLT_CONNECTION_GATEWAY; DltReceiver receiver; connections1->receiver = &receiver; EXPECT_EQ(DLT_CONNECTION_CLIENT_MSG_SERIAL, ev1.connections->type); dlt_daemon_add_connection(&ev1, connections1); head = (DltConnection*)ev1.connections->next; EXPECT_EQ(DLT_CONNECTION_GATEWAY, head->type); EXPECT_EQ(DLT_RETURN_OK, dlt_daemon_remove_connection(&ev1, connections1)); } /* Begin Method: dlt_daemon_event_handler::dlt_event_handler_cleanup_connections*/ TEST(t_dlt_event_handler_cleanup_connections, normal) { DltEventHandler ev1 = {}; DltReceiver receiver1 = {}; ev1.connections = (DltConnection *)malloc(sizeof(DltConnection)); memset(ev1.connections, 0, sizeof(DltConnection)); ev1.connections->next = 0; ev1.connections->type = DLT_CONNECTION_GATEWAY; ev1.connections->receiver = &receiver1; dlt_event_handler_cleanup_connections(&ev1); } /* Begin Method: dlt_daemon_event_handler::dlt_connection_check_activate*/ TEST(t_dlt_connection_check_activate, normal) { int ret; DltEventHandler evhdl = {}; DltReceiver receiver = {}; DltConnection con = {}; receiver.fd = 1; con.receiver = &receiver; con.status = INACTIVE; con.type = DLT_CONNECTION_CLIENT_MSG_TCP; EXPECT_EQ(DLT_RETURN_OK, dlt_daemon_prepare_event_handling(&evhdl)); ret = dlt_connection_check_activate(&evhdl, &con, ACTIVATE); EXPECT_EQ(DLT_RETURN_OK, ret); ret = dlt_connection_check_activate(&evhdl, &con, DEACTIVATE); EXPECT_EQ(DLT_RETURN_OK, ret); free(evhdl.pfd); } 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) { int ret = 0; DltDaemonLocal daemon_local = {}; int mask = 0; DltEventHandler ev1 = {}; DltConnection *connections1 = nullptr; DltReceiver receiver = {}; EXPECT_EQ(DLT_RETURN_OK, dlt_daemon_prepare_event_handling(&ev1)); connections1 = (DltConnection *)malloc(sizeof(DltConnection)); memset(connections1, 0, sizeof(DltConnection)); connections1->next = 0; connections1->type = DLT_CONNECTION_GATEWAY; connections1->receiver = &receiver; ret = dlt_event_handler_register_connection(&ev1, &daemon_local, connections1, mask); EXPECT_EQ(DLT_RETURN_OK, ret); EXPECT_EQ(DLT_CONNECTION_GATEWAY, ev1.connections->type); free(ev1.pfd); free(connections1); } TEST(t_dlt_event_handler_register_connection, nullpointer) { EXPECT_EQ(DLT_RETURN_ERROR, dlt_event_handler_register_connection(NULL, NULL, NULL, 1)); } /* Begin Method: dlt_daemon_event_handler::dlt_event_handler_unregister_connection*/ TEST(t_dlt_event_handler_unregister_connection, normal) { int ret = 0; DltDaemonLocal daemon_local = {}; int mask = 0; DltEventHandler ev1 = {}; DltConnection *connections1 = nullptr; DltReceiver receiver = {}; EXPECT_EQ(DLT_RETURN_OK, dlt_daemon_prepare_event_handling(&ev1)); connections1 = (DltConnection *)malloc(sizeof(DltConnection)); memset(connections1, 0, sizeof(DltConnection)); connections1->next = 0; connections1->type = DLT_CONNECTION_GATEWAY; connections1->receiver = &receiver; receiver.fd = 100; ret = dlt_event_handler_register_connection(&ev1, &daemon_local, connections1, mask); EXPECT_EQ(DLT_RETURN_OK, ret); EXPECT_EQ(DLT_CONNECTION_GATEWAY, ev1.connections->type); ret = dlt_event_handler_unregister_connection(&ev1, &daemon_local, receiver.fd); EXPECT_EQ(DLT_RETURN_OK, ret); free(ev1.pfd); } /* Begin Method: dlt_daemon_connections::dlt_connection_create*/ TEST(t_dlt_connection_create, normal) { int fd = 100; int ret = 0; DltDaemonLocal daemon_local = {}; EXPECT_EQ(DLT_RETURN_OK, dlt_daemon_prepare_event_handling(&daemon_local.pEvent)); ret = dlt_connection_create(&daemon_local, &daemon_local.pEvent, fd, POLLIN, DLT_CONNECTION_CLIENT_MSG_SERIAL); EXPECT_EQ(DLT_RETURN_OK, ret); dlt_event_handler_unregister_connection(&daemon_local.pEvent, &daemon_local, fd); free(daemon_local.pEvent.pfd); } /* Begin Method: dlt_daemon_connections::dlt_connection_destroy*/ TEST(t_dlt_connection_destroy, normal) { DltConnection *to_destroy = (DltConnection *)malloc(sizeof(DltConnection)); memset(to_destroy, 0, sizeof(DltConnection)); to_destroy->next = 0; to_destroy->type = DLT_CONNECTION_CLIENT_MSG_SERIAL; to_destroy->receiver = (DltReceiver *)malloc(sizeof(DltReceiver)); memset(to_destroy->receiver, 0, sizeof(DltReceiver)); to_destroy->receiver->fd = -1; to_destroy->receiver->buffer = nullptr; dlt_connection_destroy(to_destroy); } /* Begin Method: dlt_daemon_connections::t_dlt_connection_destroy_receiver*/ TEST(t_dlt_connection_destroy_receiver, normal) { DltConnection to_destroy = {}; to_destroy.receiver = (DltReceiver *)malloc(sizeof(DltReceiver)); memset(to_destroy.receiver, 0, sizeof(DltReceiver)); to_destroy.receiver->fd = -1; to_destroy.receiver->buffer = nullptr; dlt_connection_destroy_receiver(&to_destroy); } /* Begin Method: dlt_daemon_connections::t_dlt_connection_get_receiver*/ TEST(t_dlt_connection_get_receiver, normal) { int fd = 10; DltReceiver *ret; DltDaemonLocal daemon_local = {}; ret = dlt_connection_get_receiver(&daemon_local, DLT_CONNECTION_CLIENT_MSG_TCP, fd); ASSERT_NE(ret, nullptr); EXPECT_EQ(fd, ret->fd); } /* Begin Method: dlt_daemon_connections::(t_dlt_connection_get_next*/ TEST(t_dlt_connection_get_next, normal) { int type_mask = (DLT_CON_MASK_CLIENT_MSG_TCP | DLT_CON_MASK_CLIENT_MSG_SERIAL); DltConnection *ret = nullptr; DltConnection node = {}; DltConnection current = {}; node.type = DLT_CONNECTION_CLIENT_MSG_TCP; current.type = DLT_CONNECTION_ONE_S_TIMER; current.next = &node; ret = dlt_connection_get_next(¤t, type_mask); ASSERT_NE(ret, nullptr); EXPECT_EQ(DLT_CONNECTION_CLIENT_MSG_TCP, ret->type); EXPECT_NE(DLT_CONNECTION_ONE_S_TIMER, ret->type); } /* Begin Method: dlt_daemon_connections::(t_dlt_connection_get_next*/ TEST(t_dlt_connection_get_next, abnormal) { int type_mask = (DLT_CON_MASK_CLIENT_MSG_TCP | DLT_CON_MASK_CLIENT_MSG_SERIAL); DltConnection *ret; DltConnection node = {}; DltConnection current = {}; node.type = DLT_CONNECTION_CLIENT_MSG_TCP; current.type = DLT_CONNECTION_CLIENT_MSG_SERIAL; current.next = &node; ret = dlt_connection_get_next(¤t, type_mask); ASSERT_NE(ret, nullptr); EXPECT_NE(DLT_CONNECTION_CLIENT_MSG_TCP, ret->type); EXPECT_EQ(DLT_CONNECTION_CLIENT_MSG_SERIAL, ret->type); } /* Begin Method: dlt_daemon_connections::t_dlt_connection_send*/ TEST(t_dlt_connection_send, normal_1) { int ret = 0; DltConnection conn = {}; DltReceiver receiver = {}; void *data1 = nullptr; int size1 = 0; DltDaemonLocal daemon_local = {}; receiver.fd = connectServer(); EXPECT_NE(-1, receiver.fd); conn.receiver = &receiver; conn.type = DLT_CONNECTION_CLIENT_MSG_TCP; daemon_local.msg.databuffer = (uint8_t *)malloc(sizeof(uint8_t)); if (daemon_local.msg.databuffer == NULL) close(receiver.fd); EXPECT_NE((uint8_t *)NULL, daemon_local.msg.databuffer); memset(daemon_local.msg.databuffer, 1, sizeof(uint8_t)); daemon_local.msg.datasize = sizeof(uint8_t); data1 = daemon_local.msg.databuffer; size1 = daemon_local.msg.datasize; ret = dlt_connection_send(&conn, data1, size1); EXPECT_EQ(DLT_RETURN_OK, ret); close(receiver.fd); free(daemon_local.msg.databuffer); } TEST(t_dlt_connection_send, normal_2) { int ret = 0; DltConnection conn = {}; DltReceiver receiver = {}; receiver.fd = 1; conn.receiver = &receiver; conn.type = DLT_CONNECTION_CLIENT_MSG_SERIAL; ret = dlt_connection_send(&conn, (void *)dltSerialHeader, sizeof(dltSerialHeader)); EXPECT_EQ(DLT_RETURN_OK, ret); } TEST(t_dlt_connection_send, abnormal) { int ret = 0; DltConnection conn = {}; DltReceiver receiver = {}; receiver.fd = -1; conn.receiver = &receiver; conn.type = DLT_CONNECTION_TYPE_MAX; ret = dlt_connection_send(&conn, (void *)dltSerialHeader, sizeof(dltSerialHeader)); EXPECT_EQ(DLT_RETURN_ERROR, ret); } /* Begin Method: dlt_daemon_connections::t_dlt_connection_send_multiple*/ TEST(t_dlt_connection_send_multiple, normal_1) { int ret = 0; void *data1 = nullptr; void *data2 = nullptr; int size1 = 0; int size2 = 0; DltConnection conn = {}; DltReceiver receiver = {}; DltDaemonLocal daemon_local = {}; data1 = daemon_local.msg.headerbuffer + sizeof(DltStorageHeader); size1 = daemon_local.msg.headersize - sizeof(DltStorageHeader); data2 = daemon_local.msg.databuffer; size2 = daemon_local.msg.datasize; receiver.fd = connectServer(); EXPECT_NE(-1, receiver.fd); conn.receiver = &receiver; conn.type = DLT_CONNECTION_CLIENT_MSG_TCP; daemon_local.msg.headersize = sizeof(DltStorageHeader) + sizeof(DltStandardHeader) + sizeof(DltStandardHeaderExtra) + sizeof(DltExtendedHeader); memset(daemon_local.msg.headerbuffer, 0, daemon_local.msg.headersize); data1 = daemon_local.msg.headerbuffer + sizeof(DltStorageHeader); size1 = daemon_local.msg.headersize - sizeof(DltStorageHeader); daemon_local.msg.databuffer = (uint8_t *)malloc(sizeof(uint8_t)); if (daemon_local.msg.databuffer == NULL) close(receiver.fd); EXPECT_NE((uint8_t *)NULL, daemon_local.msg.databuffer); memset(daemon_local.msg.databuffer, 0, sizeof(uint8_t)); daemon_local.msg.datasize = sizeof(uint8_t); data2 = daemon_local.msg.databuffer; size2 = daemon_local.msg.datasize; ret = dlt_connection_send_multiple(&conn, data1, size1, data2, size2, 1); EXPECT_EQ(DLT_RETURN_OK, ret); close(receiver.fd); free(daemon_local.msg.databuffer); } TEST(t_dlt_connection_send_multiple, normal_2) { int ret = 0; void *data1 = nullptr; void *data2 = nullptr; int size1 = 0; int size2 = 0; DltConnection conn = {}; DltReceiver receiver = {}; DltDaemonLocal daemon_local = {}; data1 = daemon_local.msg.headerbuffer + sizeof(DltStorageHeader); size1 = daemon_local.msg.headersize - sizeof(DltStorageHeader); data2 = daemon_local.msg.databuffer; size2 = daemon_local.msg.datasize; receiver.fd = connectServer(); EXPECT_NE(-1, receiver.fd); conn.receiver = &receiver; conn.type = DLT_CONNECTION_CLIENT_MSG_TCP; daemon_local.msg.headersize = sizeof(DltStorageHeader) + sizeof(DltStandardHeader) + sizeof(DltStandardHeaderExtra) + sizeof(DltExtendedHeader); memset(daemon_local.msg.headerbuffer, 0, daemon_local.msg.headersize); data1 = daemon_local.msg.headerbuffer + sizeof(DltStorageHeader); size1 = daemon_local.msg.headersize - sizeof(DltStorageHeader); daemon_local.msg.databuffer = (uint8_t *)malloc(sizeof(uint8_t)); if (daemon_local.msg.databuffer == NULL) close(receiver.fd); EXPECT_NE((uint8_t *)NULL, daemon_local.msg.databuffer); memset(daemon_local.msg.databuffer, 0, sizeof(uint8_t)); daemon_local.msg.datasize = sizeof(uint8_t); data2 = daemon_local.msg.databuffer; size2 = daemon_local.msg.datasize; ret = dlt_connection_send_multiple(&conn, data1, size1, data2, size2, 0); EXPECT_EQ(DLT_RETURN_OK, ret); close(receiver.fd); free(daemon_local.msg.databuffer); } TEST(t_dlt_connection_send_multiple, nullpointer) { int ret = 0; void *data1 = nullptr; void *data2 = nullptr; int size1 = 0; int size2 = 0; DltDaemonLocal daemon_local = {}; data1 = daemon_local.msg.headerbuffer + sizeof(DltStorageHeader); size1 = daemon_local.msg.headersize - sizeof(DltStorageHeader); data2 = daemon_local.msg.databuffer; size2 = daemon_local.msg.datasize; ret = dlt_connection_send_multiple(NULL, data1, size1, data2, size2, 0); EXPECT_EQ(DLT_RETURN_ERROR, ret); } int connectServer(void) { int sockfd = 0, portno = 0; struct sockaddr_in serv_addr = {}; struct hostent *server = nullptr; portno = 8080; sockfd = socket(AF_INET, SOCK_STREAM, 0); server = gethostbyname("127.0.0.1"); memset((char *) &serv_addr, 0, sizeof(serv_addr)); serv_addr.sin_family = AF_INET; memcpy((char *)&serv_addr.sin_addr.s_addr, (char *)server->h_addr, server->h_length); serv_addr.sin_port = htons(portno); if (connect(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) { printf("Error: %s (%d) occured in connect socket\n", strerror(errno), errno); close(sockfd); return -1; } return sockfd; } #define GTEST_SOCKS_ACCEPTED 3 int main(int argc, char **argv) { pid_t cpid = fork(); if(cpid == -1) { printf("fork fail\n"); return -1; } if (cpid) { int i = GTEST_SOCKS_ACCEPTED; int j = 0, optval = 1; char buffer[256] = {}; int sockfd = 0, newsockfd[GTEST_SOCKS_ACCEPTED] = {}, portno = 0; socklen_t clilen = {}; struct sockaddr_in serv_addr = {}, cli_addr = {}; sockfd = socket(AF_INET, SOCK_STREAM, 0); if(sockfd == -1) { printf("Error in creating socket\n"); return -1; } bzero((char *) &serv_addr, sizeof(serv_addr)); portno = 8080; serv_addr.sin_family = AF_INET; serv_addr.sin_addr.s_addr = INADDR_ANY; serv_addr.sin_port = htons(portno); if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)) == -1) { perror("setsockopt"); close(sockfd); exit(1); } j = bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)); if(j == -1) { perror("Bind Error\n"); close(sockfd); return -1; } listen(sockfd, 5); while(i) { clilen = sizeof(cli_addr); newsockfd[i - 1] = accept(sockfd, (struct sockaddr *)&cli_addr, &clilen); if(newsockfd[i - 1] == -1) { printf("Error in accept"); return -1; } memset(buffer, 0, 256); (void)(read(newsockfd[i - 1], buffer, 255) + 1); /* just ignore result */ i--; } for(j = 0; j < GTEST_SOCKS_ACCEPTED; j++) close(newsockfd[i]); close(sockfd); } else { ::testing::InitGoogleTest(&argc, argv); ::testing::FLAGS_gtest_break_on_failure = false; // ::testing::FLAGS_gtest_filter = "t_dlt_event_handler_register_connection*"; return RUN_ALL_TESTS(); } return 0; }