From: Tarun Kumar Date: Wed, 20 Mar 2024 17:04:34 +0000 (+0530) Subject: [ITC][tizen-core][ACR-1828] Add new tizen-core module and TC's X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=9cb6e3d90d7fdf2397c263a33a359e8a8b0f7534;p=test%2Ftct%2Fnative%2Fapi.git [ITC][tizen-core][ACR-1828] Add new tizen-core module and TC's Change-Id: I1a2b9b4bcab34c174bf6e2abed1ea1ae605e0fcc Signed-off-by: Tarun Kumar --- diff --git a/src/itc/tizen-core/CMakeLists.txt b/src/itc/tizen-core/CMakeLists.txt new file mode 100755 index 000000000..c467082a6 --- /dev/null +++ b/src/itc/tizen-core/CMakeLists.txt @@ -0,0 +1,44 @@ +SET(PKG_NAME "tizen-core") + +SET(EXEC_NAME "tct-${PKG_NAME}-native") +SET(RPM_NAME "native-${PKG_NAME}-itc") + +SET(CAPI_LIB "tizen-core") +SET(TC_SOURCES + ITs-tizen-core-common.c + ITs-tizen-core.c + ITs-tizen-core-channel.c + ITs-tizen-core-event.c +) + +PKG_CHECK_MODULES(${CAPI_LIB} REQUIRED + ${CAPI_LIB} + capi-appfw-application + glib-2.0 + bundle + capi-system-info + dlog + elementary +) + +INCLUDE_DIRECTORIES( + ${${CAPI_LIB}_INCLUDE_DIRS} +) + +ADD_EXECUTABLE(${EXEC_NAME} ${EXEC_NAME}.c ${TC_SOURCES} ${COMMON_FILE}) +TARGET_LINK_LIBRARIES(${EXEC_NAME} + ${${CAPI_LIB}_LIBRARIES} + bundle +) + +INSTALL(PROGRAMS ${EXEC_NAME} + DESTINATION ${BIN_DIR}/${RPM_NAME}/bin +) + +IF( DEFINED ASAN ) +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC -Wall -pie -g -fsanitize=address -fsanitize-recover=address -U_FORTIFY_SOURCE -fno-omit-frame-pointer") +SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -Wl,--rpath=/usr/lib -Wl,-fsanitize=address") +ELSE() +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O0 -g -fPIE -Wall") +SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -Wl,--rpath=/usr/lib -pie") +ENDIF() diff --git a/src/itc/tizen-core/ITs-tizen-core-channel.c b/src/itc/tizen-core/ITs-tizen-core-channel.c new file mode 100755 index 000000000..6d81bb827 --- /dev/null +++ b/src/itc/tizen-core/ITs-tizen-core-channel.c @@ -0,0 +1,468 @@ +// +// Copyright (c) 2024 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#include "ITs-tizen-core-common.h" +#include +#include +#include + +tizen_core_channel_sender_h g_Sender; +tizen_core_channel_receiver_h g_Receiver; +tizen_core_channel_object_h g_Object; +tizen_core_task_h g_Sender_task; +int g_tizencorestartup; + + +static bool SenderIdleJobCallback(void *user_data) +{ + FPRINTF("[Line : %d][%s] Inside callback SenderIdleJobCallback\\n", __LINE__, API_NAMESPACE); + g_tizenchannelsendret = tizen_core_channel_sender_send(g_Sender, g_Object); + g_taskquitret = tizen_core_task_quit(g_Sender_task); + return false; +} + +/** + * @function ITc_tizen_core_channel_startup + * @description Called before each test, set the service boolean true + * @parameter NA + * @return NA + */ + +void ITc_tizen_core_channel_startup(void) +{ + struct stat stBuff; + int nRet; + if ( stat(ERR_LOG, &stBuff) == 0 ) + { + remove(ERR_LOG); + } + +#if DEBUG + FPRINTF("[Line : %d][%s] TEST SUIT start-up: ITc_Tizen_core_channel_startup_p\\n", __LINE__, API_NAMESPACE); +#endif + + g_tizencorestartup = TizenCoreChannelStartupMethod(); + if(g_tizencorestartup!=0) + { + FPRINTF("[Line : %d][ TizenCoreChannelStartupMethod Failed \\n",__LINE__, API_NAMESPACE); + return; + } + +} + +/** + * @function ITc_tizen_core_channel_cleanup + * @description Called after each test + * @parameter NA + * @return NA + */ +void ITc_tizen_core_channel_cleanup(void) +{ + if (g_Sender_task!=NULL) { + tizen_core_task_destroy(g_Sender_task); + g_Sender_task = NULL; + } + + if (g_Object!=NULL) { + tizen_core_channel_object_destroy(g_Object); + g_Object = NULL; + } + + if (g_Sender!=NULL) { + tizen_core_channel_sender_destroy(g_Sender); + g_Sender = NULL; + } + + if (g_Receiver!=NULL) { + tizen_core_channel_receiver_destroy(g_Receiver); + g_Receiver = NULL; + } + tizen_core_shutdown(); +} + + //& purpose: To make a pair of channel sender and receiver. +//& type : auto +/** +* @testcase ITc_tizen_core_channel_make_pair_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Makes a pair of channel sender and receiver. +* @scenario Calls the tizen_core_channel_make_pair(). +* @apicovered tizen_core_channel_make_pair. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ +int ITc_tizen_core_channel_make_pair_p(void) +{ + START_TEST; + tizen_core_channel_sender_h g_hsender = NULL; + tizen_core_channel_receiver_h g_hreceiver = NULL; + int nRet; + + nRet = tizen_core_channel_make_pair(&g_hsender, &g_hreceiver); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_channel_make_pair",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(g_hsender, "tizen_core_channel_make_pair"); + CHECK_HANDLE(g_hreceiver, "tizen_core_channel_make_pair"); + + nRet = tizen_core_channel_sender_destroy(g_hsender); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_channel_sender_destroy",TizenCoreGetErrorMsg(nRet)); + nRet = tizen_core_channel_receiver_destroy(g_hreceiver); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_channel_receiver_destroy",TizenCoreGetErrorMsg(nRet)); + return 0; +} + + + //& purpose: To send the channel object to the receiver. +//& type : auto +/** +* @testcase ITc_tizen_core_channel_sender_send_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Sends the channel object to the receiver.. +* @scenario Calls the tizen_core_channel_sender_send(). +* @apicovered tizen_core_channel_sender_send. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ +int ITc_tizen_core_channel_sender_send_p(void) +{ + START_TEST; + int nRet; + + nRet = tizen_core_channel_sender_send(g_Sender, g_Object); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_channel_sender_send",TizenCoreGetErrorMsg(nRet)); + return 0; +} + + //& purpose: To destroy the channel sender handle. +//& type : auto +/** +* @testcase ITc_tizen_core_channel_sender_destroy_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Destroys the channel sender handle. +* @scenario Calls the tizen_core_channel_sender_destroy() +* @apicovered tizen_core_channel_sender_destroy. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ +int ITc_tizen_core_channel_sender_destroy_p(void) +{ + START_TEST; + int nRet; + + nRet = tizen_core_channel_sender_destroy(g_Sender); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_channel_sender_destroy",TizenCoreGetErrorMsg(nRet)); + g_Sender = NULL; + return 0; +} + + + //& purpose: To destroy the channel sender handle. +//& type : auto +/** +* @testcase ITc_tizen_core_channel_sender_clone_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Creates and returns a copy of the given the sender handle. +* @scenario Calls the tizen_core_channel_sender_clone(). +* @apicovered tizen_core_channel_sender_clone. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ +int ITc_tizen_core_channel_sender_clone_p(void) +{ + START_TEST; + tizen_core_channel_sender_h g_Cloned_sender = NULL; + int nRet; + + nRet = tizen_core_channel_sender_clone(g_Sender, &g_Cloned_sender); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_channel_sender_clone",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(g_Cloned_sender, "tizen_core_channel_sender_clone"); + nRet = tizen_core_channel_sender_destroy(g_Cloned_sender); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_channel_sender_destroy",TizenCoreGetErrorMsg(nRet)); + + return 0; +} + + + //& purpose: To receive the channel object from the sender. +//& type : auto +/** +* @testcase ITc_tizen_core_channel_receiver_receive_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Receives the channel object from the sender. +* @scenario Calls the tizen_core_channel_sender_send(). + * And, calls the tizen_core_channel_receiver_receive(). +* @apicovered tizen_core_channel_receiver_receive. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ +int ITc_tizen_core_channel_receiver_receive_p(void) +{ + START_TEST; + tizen_core_channel_object_h g_hObject = NULL; + int id = -1; + char *data = NULL; + int nRet; + + nRet = tizen_core_channel_sender_send(g_Sender, g_Object); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_channel_sender_send",TizenCoreGetErrorMsg(nRet)); + + nRet = tizen_core_channel_receiver_receive(g_Receiver, &g_hObject); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_channel_receiver_receive",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(g_hObject, "tizen_core_channel_receiver_receive"); + + nRet = tizen_core_channel_object_get_id(g_hObject, &id); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_channel_object_get_id",TizenCoreGetErrorMsg(nRet)); + if(id!=99) + { + FPRINTF("[Line : %d][%s] Id mismatch\\n", __LINE__, API_NAMESPACE); + return 1; + } + + nRet = tizen_core_channel_object_get_data(g_hObject, (void **)&data); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_channel_object_get_data",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(data, "tizen_core_channel_object_get_data"); + + nRet = tizen_core_channel_object_destroy(g_hObject); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_channel_object_destroy",TizenCoreGetErrorMsg(nRet)); + + return 0; +} + + + + //& purpose: To destroy the tizen core channel receiver handle. +//& type : auto +/** +* @testcase ITc_tizen_core_channel_receiver_destroy_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Destroys the tizen core channel receiver handle. +* @scenario Calls the tizen_core_channel_receiver_destroy(). +* @apicovered tizen_core_channel_receiver_destroy. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ +int ITc_tizen_core_channel_receiver_destroy_p(void) +{ + START_TEST; + int nRet; + + nRet = tizen_core_channel_receiver_destroy(g_Receiver); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_channel_receiver_destroy",TizenCoreGetErrorMsg(nRet)); + g_Receiver = NULL; + return 0; +} + + +//& purpose: To create and destroy the tizen core channel object handle. +//& type : auto +/** +* @testcase ITc_tizen_core_channel_object_create_destroy_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Creates and destroys the tizen core channel object handle. +* @scenario Calls the tizen_core_channel_object_create(),tizen_core_channel_object_destroy(). +* @apicovered tizen_core_channel_object_create. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ +int ITc_tizen_core_channel_object_create_destroy_p(void) +{ + START_TEST; + tizen_core_channel_object_h g_hObject = NULL; + int nRet; + + nRet = tizen_core_channel_object_create(&g_hObject); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_channel_object_create",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(g_hObject,"tizen_core_channel_object_create"); + + nRet = tizen_core_channel_object_destroy(g_hObject); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_channel_object_destroy",TizenCoreGetErrorMsg(nRet)); + g_hObject = NULL; + + return 0; +} + + + //& purpose: To set and get the ID to the tizen core channel object handle. +//& type : auto +/** +* @testcase ITc_tizen_core_channel_object_set_get_id_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Sets and Gets the ID to the tizen core channel object handle. +* @scenario Calls the tizen_core_channel_object_set_id(),tizen_core_channel_object_get_id(). +* @apicovered tizen_core_channel_object_set_id,tizen_core_channel_object_get_id. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ +int ITc_tizen_core_channel_object_set_get_id_p(void) +{ + START_TEST; + int nRet; + int id = -1; + nRet = tizen_core_channel_object_set_id(g_Object, 22); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_channel_object_set_id",TizenCoreGetErrorMsg(nRet)); + + nRet = tizen_core_channel_object_get_id(g_Object, &id); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_channel_object_get_id",TizenCoreGetErrorMsg(nRet)); + if(id!=22) + { + FPRINTF("[Line : %d][%s] Id mismatch \\n", __LINE__, API_NAMESPACE); + return 1; + } + + return 0; +} + + +//& purpose: To set and get the ID to the tizen core channel object handle. +//& type : auto +/** +* @testcase ITc_tizen_core_channel_object_set_get_data_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Sets and Gets the data to the tizen core channel object handle. +* @scenario Calls the tizen_core_channel_object_set_data(),tizen_core_channel_object_set_data(). +* @apicovered tizen_core_channel_object_set_data,tizen_core_channel_object_get_data. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ +int ITc_tizen_core_channel_object_set_get_data_p(void) +{ + START_TEST; + char *data = NULL; + int nRet; + + nRet = tizen_core_channel_object_set_data(g_Object, "test2"); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_channel_object_set_data",TizenCoreGetErrorMsg(nRet)); + + nRet = tizen_core_channel_object_get_data(g_Object, (void **)&data); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_channel_object_get_data",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(data, "tizen_core_channel_object_get_data"); + + if(strcmp(data,"test2")!=0) + { + FPRINTF("[Line : %d][%s] Object Data Mismatch\\n", __LINE__, API_NAMESPACE); + return 1; + } + + return 0; +} + + + //& purpose: To get the sender task name from the tizen core channel object handle. +//& type : auto +/** +* @testcase ITc_tizen_core_channel_object_get_sender_task_name_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Gets the sender task name from the tizen core channel object handle. +* @scenario Adds an idle job and runs the sender task. + * Calls the tizen_core_channel_receiver_receive(). + * Calls the tizen_core_channel_object_get_sender_task_name(). + * And then, checks the sender task name. +* @apicovered tizen_core_channel_object_get_sender_task_name. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ +int ITc_tizen_core_channel_object_get_sender_task_name_p(void) +{ + START_TEST; + tizen_core_h g_Core = NULL; + tizen_core_source_h g_Source = NULL; + tizen_core_channel_object_h g_hObject = NULL; + const char *task_name = NULL; + int nRet; + + nRet = tizen_core_task_get_tizen_core(g_Sender_task, &g_Core); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_task_get_tizen_core",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(g_Core, "tizen_core_task_get_tizen_core"); + + nRet = tizen_core_add_idle_job(g_Core, SenderIdleJobCallback, NULL, &g_Source); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_add_idle_job",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(g_Source, "tizen_core_add_idle_job"); + if(g_tizenchannelsendret!=TIZEN_CORE_ERROR_NONE || g_taskquitret!=TIZEN_CORE_ERROR_NONE) + { + return 1; + } + + nRet = tizen_core_task_run(g_Sender_task); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_task_run",TizenCoreGetErrorMsg(nRet)); + + nRet = tizen_core_channel_receiver_receive(g_Receiver, &g_hObject); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_channel_receiver_receive",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(g_hObject, "tizen_core_channel_receiver_receive"); + + nRet = tizen_core_channel_object_get_sender_task_name(g_hObject, + &task_name); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_channel_object_get_sender_task_name",TizenCoreGetErrorMsg(nRet)); + if(strcmp(task_name, "sender")!=0) + { + FPRINTF("[Line : %d][%s] Set Get value mismatch\\n", __LINE__, API_NAMESPACE); + return 1; + } + + nRet = tizen_core_channel_object_destroy(g_hObject); + PRINT_RESULT(nRet,TIZEN_CORE_ERROR_NONE,"tizen_core_channel_object_destroy",TizenCoreGetErrorMsg(nRet)); + + return 0; +} + diff --git a/src/itc/tizen-core/ITs-tizen-core-common.c b/src/itc/tizen-core/ITs-tizen-core-common.c new file mode 100755 index 000000000..6cc461a25 --- /dev/null +++ b/src/itc/tizen-core/ITs-tizen-core-common.c @@ -0,0 +1,171 @@ +// +// Copyright (c) 2024 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#include "ITs-tizen-core-common.h" + +/** @addtogroup itc-tizen-core +* @ingroup itc +* @{ +*/ + + +/** +* @function TizenCoreGetErrorMsg +* @description Maps error enums to string values +* @parameter nRet : error code returned +* @return error string +*/ +char* TizenCoreGetErrorMsg(int nRet) +{ + char *szErrorVal = NULL; + switch(nRet) + { + case TIZEN_CORE_ERROR_NONE: szErrorVal = "TIZEN_ERROR_NONE"; break; + case TIZEN_CORE_ERROR_INVALID_PARAMETER: szErrorVal = "TIZEN_ERROR_INVALID_PARAMETER"; break; + case TIZEN_CORE_ERROR_OUT_OF_MEMORY: szErrorVal = "TIZEN_ERROR_OUT_OF_MEMORY"; break; + case TIZEN_CORE_ERROR_INVALID_CONTEXT: szErrorVal = "TIZEN_CORE_ERROR_INVALID_CONTEXT"; break; + default: szErrorVal = "Unknown Error"; break; + } + return szErrorVal; +} + + +//Add helper function definitions here +int TizenCoreInitializationMethod() +{ + int nRet; + tizen_core_init(); + + nRet = tizen_core_task_create("ITc_test_task", true, &g_Task); + FPRINTF("[Return Value : %d]\\n",nRet); + PRINT_RESULT(0, nRet, "tizen_core_create_task", TizenCoreGetErrorMsg(nRet)); + + nRet = tizen_core_task_create("ITc_main_testing", false, &g_Main_task); + PRINT_RESULT(0, nRet, "tizen_core_create_task", TizenCoreGetErrorMsg(nRet)); + + nRet = tizen_core_source_create(&g_Source); + PRINT_RESULT(0, nRet, "tizen_core_source_create", TizenCoreGetErrorMsg(nRet)); + + return 0; + +} + +int TizenCoreChannelSetup() +{ + int nRet; + + nRet = tizen_core_channel_make_pair(&g_Sender, &g_Receiver); + FPRINTF("[Return Value of TizenCoreChannelsetup : %d]\\n",nRet); + PRINT_RESULT(0, nRet, "tizen_core_channel_make_pair", TizenCoreGetErrorMsg(nRet)); + + nRet = tizen_core_channel_object_create(&g_Channel_object); + PRINT_RESULT(0, nRet, "tizen_core_channel_object_create", TizenCoreGetErrorMsg(nRet)); + + nRet = tizen_core_channel_object_set_id(g_Channel_object, 99); + PRINT_RESULT(0, nRet, "tizen_core_channel_object_set_id", TizenCoreGetErrorMsg(nRet)); + + nRet = tizen_core_channel_object_set_data(g_Channel_object, "test"); + PRINT_RESULT(0, nRet, "tizen_core_channel_object_set_data", TizenCoreGetErrorMsg(nRet)); + + return 0; +} + +int TizenCoreEventSetup() +{ + int nRet; + + nRet = tizen_core_event_create(&g_Event); + PRINT_RESULT(0, nRet, "tizen_core_event_create", TizenCoreGetErrorMsg(nRet)); + + nRet = tizen_core_event_object_create(&g_Event_object, g_Event_id, "test"); + PRINT_RESULT(0, nRet, "tizen_core_event_object_create", TizenCoreGetErrorMsg(nRet)); + + return 0; +} + +int TizenCoreFdPollSetup() +{ + + int nRet; + //tcore_poll_fd_setup(); + nRet = tizen_core_poll_fd_create(&g_Poll_fd); + PRINT_RESULT(0, nRet, "tizen_core_poll_fd_create", TizenCoreGetErrorMsg(nRet)); + + nRet = tizen_core_poll_fd_set_fd(g_Poll_fd, 0); + PRINT_RESULT(0, nRet, "tizen_core_poll_fd_set_fd", TizenCoreGetErrorMsg(nRet)); + + nRet = tizen_core_poll_fd_set_events(g_Poll_fd,TIZEN_CORE_POLL_EVENT_IN | TIZEN_CORE_POLL_EVENT_OUT); + PRINT_RESULT(0, nRet, "tizen_core_poll_fd_set_events", TizenCoreGetErrorMsg(nRet)); + + nRet = tizen_core_poll_fd_set_returned_events(g_Poll_fd, TIZEN_CORE_POLL_EVENT_IN); + PRINT_RESULT(0, nRet, "tizen_core_poll_fd_set_returned_events", TizenCoreGetErrorMsg(nRet)); + + return 0; +} + + +static bool event_handler_cb(tizen_core_event_object_h object, void *user_data) +{ + return true; +} + +int TizenCoreEventStartupMethod() +{ + int nRet; + tizen_core_init(); + + nRet = tizen_core_event_create(&g_Event); + PRINT_RESULT(nRet,0,"tizen_core_event_create",TizenCoreGetErrorMsg(nRet)); + + nRet = tizen_core_event_add_handler(g_Event, event_handler_cb, NULL, + &g_Event_handler); + PRINT_RESULT(nRet,0,"tizen_core_event_add_handler",TizenCoreGetErrorMsg(nRet)); + + nRet = tizen_core_event_object_create(&g_Object, 99, "test"); + PRINT_RESULT(nRet,0,"tizen_core_event_object_create",TizenCoreGetErrorMsg(nRet)); + + return 0; + +} + +int TizenCoreChannelStartupMethod() +{ + int nRet; + + tizen_core_init(); + + nRet = tizen_core_channel_make_pair(&g_Sender, &g_Receiver); + PRINT_RESULT(nRet,0,"tizen_core_channel_make_pair", TizenCoreGetErrorMsg(nRet)); + + nRet = tizen_core_channel_object_create(&g_Object); + PRINT_RESULT(nRet,0,"tizen_core_channel_object_create", TizenCoreGetErrorMsg(nRet)); + + nRet = tizen_core_channel_object_set_id(g_Object, 99); + PRINT_RESULT(nRet,0,"tizen_core_channel_object_set_id", TizenCoreGetErrorMsg(nRet)); + + nRet = tizen_core_channel_object_set_data(g_Object, "test"); + PRINT_RESULT(nRet,0,"tizen_core_channel_object_set_data", TizenCoreGetErrorMsg(nRet)); + + nRet = tizen_core_task_create("sender", true, &g_Sender_task); + PRINT_RESULT(nRet,0,"tizen_core_channel_object_set_data", TizenCoreGetErrorMsg(nRet)); + + return 0; +} + + + +/** @} */ + + diff --git a/src/itc/tizen-core/ITs-tizen-core-common.h b/src/itc/tizen-core/ITs-tizen-core-common.h new file mode 100755 index 000000000..4e1863594 --- /dev/null +++ b/src/itc/tizen-core/ITs-tizen-core-common.h @@ -0,0 +1,92 @@ +// +// Copyright (c) 2024 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef _ITS_TIZEN_CORE_COMMON_H_ +#define _ITS_TIZEN_CORE_COMMON_H_ + +//Add test package related includes here +#include "tct_common.h" +#include +#include +#include +#include +#include + +/** @addtogroup itc-%{MODULE_NAME} +* @ingroup itc +* @{ +*/ + +int g_tizenemiteventret; +int g_tizeneventidret; +int g_taskquitret; +int g_tizenchannelsendret; +int g_tizengetchannelidret; +int g_tizencorechanneldataret; +int g_taskquitret; +int g_taskcorefindret; +int g_taskgetret; +int g_taskrunningret; +tizen_core_task_h g_Main_task; +tizen_core_task_h g_Task; +tizen_core_source_h g_Source; +bool g_bCallBackHit_tizen_core; +tizen_core_event_h g_Event; +tizen_core_event_h g_Event_handler; +tizen_core_event_object_h g_Object; +tizen_core_channel_sender_h g_Sender; +tizen_core_channel_receiver_h g_Receiver; +tizen_core_channel_object_h g_Object; +tizen_core_task_h g_Sender_task; + +tizen_core_channel_sender_h g_Sender; +tizen_core_channel_receiver_h g_Receiver; +tizen_core_channel_object_h g_Channel_object; + +tizen_core_event_h g_Event; +tizen_core_event_object_h g_Event_object; +int g_Event_id; +int g_tizencorestartup; + +tizen_core_poll_fd_h g_Poll_fd; + +#define API_NAMESPACE "TIZEN_CORE" + + +#define START_TEST {\ + FPRINTF("[Line : %d][%s] Starting test: %s\\n", __LINE__, API_NAMESPACE, __FUNCTION__);\ + if ( g_tizencorestartup!=0 ) {\ + FPRINTF("[Line:%d][%s] Test Case Startup Conditions Failed \n", __LINE__, API_NAMESPACE);\ + return 1;\ + }\ +} + + + + +//Add helper function declarations here +int TizenCoreInitializationMethod(); +int TizenCoreChannelSetup(); +int TizenCoreEventSetup(); +int TizenCoreFdPollSetup(); +int TizenCoreEventStartupMethod(); +int TizenCoreChannelStartupMethod(); +char* TizenCoreGetErrorMsg(int nRet); + + + +/** @} */ +#endif //_ITS_TIZEN_CORE_COMMON_H_ + diff --git a/src/itc/tizen-core/ITs-tizen-core-event.c b/src/itc/tizen-core/ITs-tizen-core-event.c new file mode 100755 index 000000000..e66c76fb4 --- /dev/null +++ b/src/itc/tizen-core/ITs-tizen-core-event.c @@ -0,0 +1,386 @@ +// +// Copyright (c) 2024 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#include "ITs-tizen-core-common.h" +#include +#include +#include + + +tizen_core_event_h g_Event; +tizen_core_event_h g_Event_handler; +tizen_core_event_object_h g_Object; +bool g_bCallBackHit_tizen_core; +int g_tizencorestartup; + + + +static bool AddHandlerCallback(tizen_core_event_object_h object, void *user_data) +{ + FPRINTF("[Line : %d][%s] Inside callback AddHandlerCallback\\n", __LINE__, API_NAMESPACE); + return true; +} + +static bool PrependHandlerCallback(tizen_core_event_object_h object, + void *user_data) +{ + FPRINTF("[Line : %d][%s] Inside callback PrependHandlerCallback\\n", __LINE__, API_NAMESPACE); + return true; +} + +static void EventObjectDestroyCallback(void *event_data, void *user_data) +{ + FPRINTF("[Line : %d][%s] Inside callback EventObjectDestroyCallback\\n", __LINE__, API_NAMESPACE); + char *str = (char *)event_data; + + g_bCallBackHit_tizen_core = true; + if (str) + free(str); +} + +/** + * @function ITc_tizen_core_event_startup + * @description Called before each test, set the service boolean true + * @parameter NA + * @return NA + */ +void ITc_tizen_core_event_startup(void) +{ + struct stat stBuff; + int nRet; + if ( stat(ERR_LOG, &stBuff) == 0 ) + { + remove(ERR_LOG); + } + +#if DEBUG + FPRINTF("[Line : %d][%s] TEST SUIT start-up: ITc_Tizen_core_event_startup_p\\n", __LINE__, API_NAMESPACE); +#endif + + g_tizencorestartup = TizenCoreEventStartupMethod(); + if(g_tizencorestartup!=0) + { + FPRINTF("[Line : %d][ TizenCoreEventStartupMethod Failed \\n",__LINE__, API_NAMESPACE); + return; + } + + +} + +/** + * @function ITc_tizen_core_event_cleanup + * @description Called after each test + * @parameter NA + * @return NA + */ +void ITc_tizen_core_event_cleanup(void) +{ + if (g_Object!=NULL) { + tizen_core_event_object_destroy(g_Object); + g_Object = NULL; + } + + if (g_Event_handler!=NULL) { + if (g_Event!=NULL) { + tizen_core_event_remove_handler(g_Event,g_Event_handler); + } + + g_Event_handler = NULL; + } + + if (g_Event!=NULL) { + tizen_core_event_destroy(g_Event); + g_Event = NULL; + } + tizen_core_shutdown(); +} + + //& purpose: To Create and Destroy the tizen core event handle +//& type : auto +/** +* @testcase ITc_tizen_core_event_create_destroy_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Creates and Destroys the tizen core event handle. +* @scenario Calls the tizen_core_event_create(),tizen_core_event_destroy(). +* @apicovered tizen_core_event_create,tizen_core_event_destroy. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ +int ITc_tizen_core_event_create_destroy_p(void) +{ + START_TEST; + + tizen_core_event_h g_hevent = NULL; + int nRet; + + nRet = tizen_core_event_create(&g_hevent); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_event_create",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(g_hevent, "tizen_core_event_create"); + + nRet = tizen_core_event_destroy(g_hevent); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_event_destroy",TizenCoreGetErrorMsg(nRet)); + + return 0; +} + + + + //& purpose: To add and remove the event handler to the tizen core event. +//& type : auto +/** +* @testcase ITc_tizen_core_event_add_remove_handler_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Adds and Removes the event handler to the tizen core event. +* @scenario Calls the tizen_core_event_add_handler(),tizen_core_event_remove_handler(). +* @apicovered tizen_core_event_add_handler,tizen_core_event_remove_handler. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ +int ITc_tizen_core_event_add_remove_handler_p(void) +{ + START_TEST; + + tizen_core_event_handler_h g_hevent_handler = NULL; + int nRet; + + nRet = tizen_core_event_add_handler(g_Event, AddHandlerCallback, NULL, + &g_hevent_handler); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_event_add_handler",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(g_hevent_handler, "tizen_core_event_add_handler"); + + nRet = tizen_core_event_remove_handler(g_Event, g_Event_handler); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_event_remove_handler",TizenCoreGetErrorMsg(nRet)); + g_Event_handler = NULL; + return 0; +} + + //& purpose: To prepend the event handler to the tizen core event. +//& type : auto +/** +* @testcase ITc_tizen_core_event_prepend_handler_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Prepends the event handler to the tizen core event. +* @scenario Calls the tizen_core_event_prepend_handler(). +* @apicovered tizen_core_event_prepend_handler. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ +int ITc_tizen_core_event_prepend_handler_p(void) +{ + START_TEST; + + tizen_core_event_handler_h g_hevent_handler = NULL; + int nRet; + + nRet = tizen_core_event_prepend_handler(g_Event, PrependHandlerCallback, + NULL, &g_hevent_handler); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_event_prepend_handler",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(g_hevent_handler,"tizen_core_event_prepend_handler" ); + + nRet = tizen_core_event_remove_handler(g_Event, g_hevent_handler); + PRINT_RESULT(nRet,TIZEN_CORE_ERROR_NONE,"tizen_core_event_remove_handler",TizenCoreGetErrorMsg(nRet)); + + return 0; +} + + + //& purpose: To emit the event to the tizen core event. +//& type : auto +/** +* @testcase ITc_tizen_core_event_emit_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Emits the event to the tizen core event. +* @scenario Calls the tizen_core_event_emit(). + * The event object will be emitted to the event. + * The event is passed to the event handler when + * tizen_core_emit_event() is called. +* @apicovered tizen_core_event_emit. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ +int ITc_tizen_core_event_emit_p(void) +{ + START_TEST; + int nRet; + + nRet = tizen_core_event_emit(g_Event, g_Object); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_event_emit",TizenCoreGetErrorMsg(nRet)); + g_Object = NULL; + return 0; +} + + //& purpose: To create and destroy the tizen core event object handle. +//& type : auto +/** +* @testcase ITc_tizen_core_event_object_create_destroy_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Creates and Destroys the tizen core event object handle. +* @scenario Calls the tizen_core_event_object_create(), tizen_core_event_object_destroy(). +* @apicovered tizen_core_event_object_create,tizen_core_event_object_destroy. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ +int ITc_tizen_core_event_object_create_destroy_p(void) +{ + START_TEST; + tizen_core_event_object_h g_hobject = NULL; + int nRet; + + nRet = tizen_core_event_object_create(&g_hobject, 22, "test2"); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_event_object_create",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(g_hobject, "tizen_core_event_object_create"); + + nRet = tizen_core_event_object_destroy(g_hobject); + PRINT_RESULT(nRet,TIZEN_CORE_ERROR_NONE,"tizen_core_event_object_destroy",TizenCoreGetErrorMsg(nRet)); + g_Object = NULL; + return 0; +} + + + //& purpose: To set the destroy callback function to invoke when the event object is destroyed. +//& type : auto +/** +* @testcase ITc_tizen_core_event_object_set_destroy_cb_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Sets the destroy callback function to invoke when the event object is destroyed. +* @scenario Calls the tizen_core_event_object_create() and calls + * the tizen_core_event_object_set_destroy_cb(). + * Calls the tizen_core_event_object_destroy(). + * And then, checks whether the g_bCallBackHit_tizen_core flag is set or not. +* @apicovered tizen_core_event_object_set_destroy_cb. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ +int ITc_tizen_core_event_object_set_destroy_cb_p(void) +{ + START_TEST; + tizen_core_event_object_h g_hobject = NULL; + int nRet; + + nRet = tizen_core_event_object_create(&g_hobject, 11, strdup("test_string")); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_event_object_create",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(g_hobject, "tizen_core_event_object_create"); + + nRet = tizen_core_event_object_set_destroy_cb(g_hobject, + EventObjectDestroyCallback, NULL); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_event_object_set_destroy_cb",TizenCoreGetErrorMsg(nRet)); + + g_bCallBackHit_tizen_core=false; + nRet = tizen_core_event_object_destroy(g_hobject); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_event_object_destroy",TizenCoreGetErrorMsg(nRet)); + PRINT_RESULT(g_bCallBackHit_tizen_core, true,"callback not invoked",TizenCoreGetErrorMsg(g_bCallBackHit_tizen_core)); + return 0; +} + + //& purpose: To get core event object id. +//& type : auto +/** +* @testcase ITc_tizen_core_event_object_get_id_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Gets the event ID from the tizen core event object handle. +* @scenario Calls the tizen_core_event_object_get_id(). + * And then, checks whether the id is equal to 99 or not. +* @apicovered tizen_core_event_object_get_id. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ +int ITc_tizen_core_event_object_get_id_p(void) +{ + START_TEST; + int id = -1; + int nRet; + + nRet = tizen_core_event_object_get_id(g_Object, &id); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_event_object_get_id",TizenCoreGetErrorMsg(nRet)); + if(id!=99) + { + FPRINTF("[Line : %d][%s]Id not matched\\n", __LINE__, API_NAMESPACE); + return 1; + } + return 0; +} + + //& purpose: To get the event data from the tizen core event object handle. +//& type : auto +/** +* @testcase ITc_tizen_core_event_object_get_data_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Gets the event data from the tizen core event object handle. +* @scenario Calls the tizen_core_event_object_get_data(). + * And then, checks whether the data is equal to "test" or not. +* @apicovered tizen_core_event_object_get_data. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ +int ITc_tizen_core_event_object_get_data_p(void) +{ + START_TEST; + char *data = NULL; + int nRet; + + nRet = tizen_core_event_object_get_data(g_Object, (void **)&data); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_event_object_get_data",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(data,"tizen_core_event_object_get_data" ); + if(strcmp(data,"test")!=0) + { + FPRINTF("[Line : %d][%s] Object Data Mismatch\\n", __LINE__, API_NAMESPACE); + return 1; + } + + return 0; +} + + diff --git a/src/itc/tizen-core/ITs-tizen-core.c b/src/itc/tizen-core/ITs-tizen-core.c new file mode 100755 index 000000000..3777c82e7 --- /dev/null +++ b/src/itc/tizen-core/ITs-tizen-core.c @@ -0,0 +1,1331 @@ +// +// Copyright (c) 2024 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#include "ITs-tizen-core-common.h" +#include +#include +#include + + + +//& set: TizenCore + +/** @addtogroup itc-tizen-core +* @ingroup itc +* @{ +*/ + +tizen_core_task_h g_Main_task; +tizen_core_task_h g_Task; +tizen_core_source_h g_Source; +bool g_bCallBackHit_tizen_core; + +tizen_core_channel_sender_h g_Sender; +tizen_core_channel_receiver_h g_Receiver; +tizen_core_channel_object_h g_Channel_object; + +tizen_core_event_h g_Event; +tizen_core_event_object_h g_Event_object; +int g_Event_id = 22; + +tizen_core_poll_fd_h g_Poll_fd; +int g_tizencorestartup; + +bool TaskRunIdleJobCallback(void *user_data) +{ + FPRINTF("[Line : %d][%s] Inside callback TaskRunIdleJobCallback\\n", __LINE__, API_NAMESPACE); + g_bCallBackHit_tizen_core = true; + g_taskquitret = tizen_core_task_quit(g_Main_task); + return false; +} + +static bool TaskIsRunningIdleCallback(void *user_data) +{ + FPRINTF("[Line : %d][%s] Inside callback TaskIsRunningIdleCallback\\n", __LINE__, API_NAMESPACE); + g_taskrunningret = tizen_core_task_is_running(g_Main_task, &g_bCallBackHit_tizen_core); + g_taskquitret = tizen_core_task_quit(g_Main_task); + return false; +} + +static bool TaskQuitThreadIdleCallback(void *user_data) +{ + FPRINTF("[Line : %d][%s] Inside callback TaskQuitThreadIdleCallback\\n", __LINE__, API_NAMESPACE); + g_taskquitret = tizen_core_task_quit(g_Task); + g_bCallBackHit_tizen_core = true; + return false; +} + +static bool TaskQuitMainTimerCallback(void *user_data) +{ + FPRINTF("[Line : %d][%s] Inside callback TaskQuitMainTimerCallback\\n", __LINE__, API_NAMESPACE); + if (g_bCallBackHit_tizen_core) { + g_taskquitret = tizen_core_task_quit(g_Main_task); + return false; + } + return true; +} + +static bool AddIdleJobCallback(void *user_data) +{ + FPRINTF("[Line : %d][%s] Inside callback AddIdleJobCallback\\n", __LINE__, API_NAMESPACE); + g_bCallBackHit_tizen_core = true; + g_taskquitret = tizen_core_task_quit(g_Main_task); + return false; +} + + +static void SetFinalizeCbCallback(tizen_core_source_h source, void *user_data) +{ + FPRINTF("[Line : %d][%s] Inside callback SetFinalizeCbCallback\\n", __LINE__, API_NAMESPACE); +} + + +static bool SetDispatchCbCallback(tizen_core_source_h source, void *user_data) +{ + FPRINTF("[Line : %d][%s] Inside callback SetDispatchCbCallback\\n", __LINE__, API_NAMESPACE); + return true; +} + +static bool SetCheckCbCallback(tizen_core_source_h source, void *user_data) +{ + FPRINTF("[Line : %d][%s] Inside callback SetCheckCbCallback\\n", __LINE__, API_NAMESPACE); + return true; +} + +static bool SetPrepareCbCallback(tizen_core_source_h source, int *timeout, + void *user_data) +{ + FPRINTF("[Line : %d][%s] Inside callback SetPrepareCbCallback\\n", __LINE__, API_NAMESPACE); + return false; +} + + +static bool EventHandlerCallback(tizen_core_event_object_h object, void *user_data) +{ + FPRINTF("[Line : %d][%s] Inside callback EventHandlerCallback\\n", __LINE__, API_NAMESPACE); + int id = 0; + g_tizeneventidret = tizen_core_event_object_get_id(object, &id); + if (id == 22) { + g_bCallBackHit_tizen_core = true; + g_taskquitret = tizen_core_task_quit(g_Main_task); + } + return true; +} + +static bool EmitEventTimerCallback(void *user_data) +{ + FPRINTF("[Line : %d][%s] Inside callback EmitEventTimerCallback\\n", __LINE__, API_NAMESPACE); + + tizen_core_h main_core = NULL; + + tizen_core_task_get_tizen_core(g_Main_task, &main_core); + g_tizenemiteventret = tizen_core_emit_event(main_core, g_Event_object); + g_Event_object = NULL; + return false; +} + + +static bool FindFromThreadCallback(void *user_data) +{ + FPRINTF("[Line : %d][%s] Inside callback FindFromThreadCallback\\n", __LINE__, API_NAMESPACE); + tizen_core_h task_core = NULL; + tizen_core_h current_core = NULL; + bool running = false; + + g_taskrunningret = tizen_core_task_is_running(g_Main_task, &running); + if (!running) { + usleep(10); + return true; + } + + g_taskgetret = tizen_core_task_get_tizen_core(g_Task, &task_core); + g_taskcorefindret = tizen_core_find_from_this_thread(¤t_core); + if (task_core && current_core && task_core == current_core) + g_bCallBackHit_tizen_core = true; + + g_taskquitret = tizen_core_task_quit(g_Task); + g_taskquitret = tizen_core_task_quit(g_Main_task); + return false; +} + +static bool AddTimerCallback(void *user_data) +{ + FPRINTF("[Line : %d][%s] Inside callback AddTimerCallback\\n", __LINE__, API_NAMESPACE); + g_bCallBackHit_tizen_core = true; + g_taskquitret = tizen_core_task_quit(g_Main_task); + return false; +} + +static void ChannelReceiveCallback(tizen_core_channel_object_h object, + void *user_data) +{ + FPRINTF("[Line : %d][%s] Inside callback ChannelReceiveCallback\\n", __LINE__, API_NAMESPACE); + int id = 0; + char* data = NULL; + + g_tizengetchannelidret = tizen_core_channel_object_get_id(object, &id); + g_tizencorechanneldataret = tizen_core_channel_object_get_data(object, (void **)&data); + if (id == 99 && data && !strcmp(data, "test")) + g_bCallBackHit_tizen_core = true; + g_taskquitret = tizen_core_task_quit(g_Main_task); +} + +static bool AddChannelIdleCallback(void *user_data) +{ + FPRINTF("[Line : %d][%s] Inside callback AddChannelIdleCallback\\n", __LINE__, API_NAMESPACE); + g_tizenchannelsendret = tizen_core_channel_sender_send(g_Sender, g_Channel_object); + g_taskquitret = tizen_core_task_quit(g_Task); + return false; +} + + + +/** + * @function ITs_tizen_core_startup + * @description Called before each test + * @parameter NA + * @return NA + */ +void ITc_tizen_core_startup(void) +{ + struct stat stBuff; + g_bCallBackHit_tizen_core = false; + if ( stat(ERR_LOG, &stBuff) == 0 ) + { + remove(ERR_LOG); + } + +#if DEBUG + FPRINTF("[Line : %d][%s] TEST SUIT start-up: ITs_Tizen_core_p\\n", __LINE__, API_NAMESPACE); +#endif + + //tcore_setup(); + g_tizencorestartup = TizenCoreInitializationMethod(); + if(g_tizencorestartup!=0) + { + FPRINTF("[Line : %d][ TizenCoreInitialization Failed[%s][%d]\\n" ,__LINE__, API_NAMESPACE,g_tizencorestartup); + return; + } + g_tizencorestartup = TizenCoreChannelSetup(); + if(g_tizencorestartup!=0) + { + FPRINTF("[Line : %d][%s][ TizenCoreChannelSetup Failed \\n",__LINE__, API_NAMESPACE); + return; + } + g_tizencorestartup = TizenCoreEventSetup(); + if(g_tizencorestartup!=0) + { + FPRINTF("[Line : %d][%s][ TizenCoreEventSetup Failed \\n",__LINE__, API_NAMESPACE); + return; + } + g_tizencorestartup = TizenCoreFdPollSetup(); + if(g_tizencorestartup!=0) + { + FPRINTF("[Line : %d][%s][ TizenCoreFdPollSetup Failed \\n",__LINE__, API_NAMESPACE); + return; + + } +} + + +/** + * @function ITs_tizen_core_cleanup + * @description Called after each test + * @parameter NA + * @return NA + */ +void ITc_tizen_core_cleanup(void) +{ + int nRet; + if (g_Poll_fd!=NULL) { + tizen_core_poll_fd_destroy(g_Poll_fd); + g_Poll_fd = NULL; + } + + if (g_Event_object!=NULL) { + tizen_core_event_object_destroy(g_Event_object); + g_Event_object = NULL; + } + + if (g_Event!=NULL) { + nRet = tizen_core_event_destroy(g_Event); + g_Event = NULL; + } + + if (g_Channel_object!=NULL) { + tizen_core_channel_object_destroy(g_Channel_object); + g_Channel_object = NULL; + } + + if (g_Sender!=NULL) { + tizen_core_channel_sender_destroy(g_Sender); + g_Sender = NULL; + } + + if (g_Receiver!=NULL) { + tizen_core_channel_receiver_destroy(g_Receiver); + g_Receiver = NULL; + } + + if (g_Source!=NULL) { + tizen_core_source_destroy(g_Source); + g_Source = NULL; + } + + if (g_Main_task!=NULL) { + tizen_core_task_destroy(g_Main_task); + g_Main_task = NULL; + } + + if (g_Task!=NULL) { + tizen_core_task_destroy(g_Task); + g_Task = NULL; + } + + g_bCallBackHit_tizen_core = false; + tizen_core_shutdown(); + return; +} + +/** @addtogroup itc-tizen-core-testcases +* @brief Integration testcases for module tizen-core +* @ingroup itc-tizen-core +* @{ +*/ + + //& purpose: To initialize and shutdown the tizen core. +//& type : auto +/** +* @testcase ITc_tizen_core_init_shutdown_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Initializes and shutdown the tizen core. +* @scenario Calls the tizen_core_init() and tizen_core_shutdown() to initialize the tizen core +* @apicovered tizen_core_init,tizen_core_shutdown +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ + +int ITc_tizen_core_init_shutdown_p(void) +{ + START_TEST; + tizen_core_init(); + tizen_core_shutdown(); + return 0; +} + + + //& purpose: To check whether the tizen core is ready or not. +//& type : auto +/** +* @testcase ITc_tizen_core_ready_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Checks whether the tizen core is ready or not +* @scenario The function returns 'true' +* @apicovered tizen_core_ready +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ + +int ITc_tizen_core_ready_p(void) +{ + START_TEST; + bool nRet; + nRet = tizen_core_ready(); + if ( nRet == false ) + { + FPRINTF("[Line: %d][%s] tizen core not ready\\n", __LINE__, API_NAMESPACE); + return 1; + } + FPRINTF("[Line: %d][%s] Tizen_Core_Ready API-\\n", __LINE__, API_NAMESPACE); + + return 0; + +} + + + //& purpose: To create and destroy the tizen core handle +//& type : auto +/** +* @testcase ITc_tizen_core_task_create_destroy_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Creates and destroys the tizen core task handle +* @scenario Calls the tizen_core_task_create() to create the task handle and tizen_core_task_destroy() to destroy the handle +* @apicovered tizen_core_task_create,tizen_core_task_destroy +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ + +int ITc_tizen_core_task_create_destroy_p(void) +{ + + START_TEST; + + tizen_core_task_h task = NULL; + + int nRet = tizen_core_task_create("g_htask",true,&task); + PRINT_RESULT(TIZEN_CORE_ERROR_NONE, nRet, "tizen_core_task_create", TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(task, "tizen_core_task_create"); + + nRet = tizen_core_task_destroy(task); + PRINT_RESULT(TIZEN_CORE_ERROR_NONE, nRet, "tizen_core_task_destroy", TizenCoreGetErrorMsg(nRet)); + + return 0; +} + + //& purpose: To run the main loop of tizen core task +//& type : auto +/** +* @testcase ITc_tizen_core_task_run_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Run the main loop of tizen core task. +* @scenario Calls the tizen_core_task_run() to run the main loop of the task. + * Before runs the task, the idle job is added to check + * whether the main is running or not. +* @apicovered tizen_core_task_get_tizen_core,tizen_core_add_idle_job,tizen_core_task_run +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ + +int ITc_tizen_core_task_run_p(void) +{ + START_TEST; + + tizen_core_h core = NULL; + tizen_core_source_h source = NULL; + int nRet; + + nRet = tizen_core_task_get_tizen_core(g_Main_task, &core); + PRINT_RESULT(TIZEN_CORE_ERROR_NONE, nRet, "tizen_core_task_get_tizen_core", TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(core, "tizen_core_task_get_tizen_core"); + + nRet = tizen_core_add_idle_job(core, TaskRunIdleJobCallback, NULL, &source); + PRINT_RESULT(TIZEN_CORE_ERROR_NONE, nRet, "tizen_core_task_get_tizen_core", TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(source, "tizen_core_add_idle_job"); + if(g_taskquitret!=TIZEN_CORE_ERROR_NONE) + { + return 1; + } + + g_bCallBackHit_tizen_core=false; + nRet = tizen_core_task_run(g_Main_task); + PRINT_RESULT(TIZEN_CORE_ERROR_NONE, nRet,"tizen_core_task_run",TizenCoreGetErrorMsg(nRet)); + PRINT_RESULT(g_bCallBackHit_tizen_core, 1,"callback_not_invoked",TizenCoreGetErrorMsg(g_bCallBackHit_tizen_core)); + + return 0; +} + + //& purpose: To check whether the task is running or not. +//& type : auto +/** +* @testcase ITc_tizen_core_task_is_running_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Checks whether the task is running or not. +* @scenario Calls the tizen_core_task_is_running() in the idle callback + * to check whether the task is running or not. + * The function returns TIZEN_CORE_ERROR_NONE and 'true' +* @apicovered tizen_core_task_get_tizen_core,tizen_core_add_idle_job,tizen_core_task_run +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ + +int ITc_tizen_core_task_is_running_p(void) +{ + START_TEST; + + tizen_core_h core = NULL; + tizen_core_source_h source = NULL; + int nRet; + + nRet = tizen_core_task_get_tizen_core(g_Main_task, &core); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE, "tizen_core_task_is_running",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(core, "tizen_core_task_get_tizen_core"); + + nRet = tizen_core_add_idle_job(core, TaskIsRunningIdleCallback, NULL, &source); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_add_idle_job",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(source, "tizen_core_add_idle_job"); + if((g_taskquitret!=TIZEN_CORE_ERROR_NONE) || g_taskrunningret!=TIZEN_CORE_ERROR_NONE) + { + return 1; + } + + g_bCallBackHit_tizen_core=false; + nRet = tizen_core_task_run(g_Main_task); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_task_run",TizenCoreGetErrorMsg(nRet)); + PRINT_RESULT(g_bCallBackHit_tizen_core, true,"callback_not_invoked",TizenCoreGetErrorMsg(g_bCallBackHit_tizen_core)); + return 0; +} + + + //& purpose: To exit the main loop of tizen core task. +//& type : auto +/** +/** +* @testcase ITc_tizen_core_task_quit_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Exits the main loop of the tizen core task. +* @scenario Runs the main loop of the thread task. + * And, calls the tizen_core_task_quit() to exit + * the main loop of the thread task in the idle callback. + * Runs the main loop of the main task. + * And, calls the tizen_core_task_quit() to exit + * the main loop of the main task in the timer callback. +* @apicovered tizen_core_task_get_tizen_core,tizen_core_add_idle_job,tizen_core_task_run,tizen_core_add_timer +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ + +int ITc_tizen_core_task_quit_p(void) +{ + START_TEST; + + tizen_core_h core = NULL; + tizen_core_source_h source = NULL; + tizen_core_source_h timer_source = NULL; + int nRet; + + nRet = tizen_core_task_get_tizen_core(g_Task, &core); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE, "tizen_core_task_get_tizen_core", TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(core, "tizen_core_task_get_tizen_core"); + + nRet = tizen_core_add_idle_job(core, TaskQuitThreadIdleCallback, NULL, &source); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_add_idle_job",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(source, "tizen_core_add_idle_job"); + if(g_taskquitret!=TIZEN_CORE_ERROR_NONE) + { + return 1; + } + + nRet = tizen_core_task_run(g_Task); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE, "tizen_core_task_run", TizenCoreGetErrorMsg(nRet)); + + core = NULL; + nRet = tizen_core_task_get_tizen_core(g_Main_task, &core); + PRINT_RESULT(nRet,TIZEN_CORE_ERROR_NONE,"tizen_core_task_get_tizen_core",TizenCoreGetErrorMsg(nRet)); + + nRet = tizen_core_add_timer(core, 100, TaskQuitMainTimerCallback, NULL, + &timer_source); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE, "tizen_core_add_timer",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(timer_source, "tizen_core_add_timer"); + if(g_taskquitret!=TIZEN_CORE_ERROR_NONE) + { + return 1; + } + + g_bCallBackHit_tizen_core=false; + nRet = tizen_core_task_run(g_Main_task); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_task_run",TizenCoreGetErrorMsg(nRet)); + PRINT_RESULT(g_bCallBackHit_tizen_core, true, "tizen_core_run_task",TizenCoreGetErrorMsg(g_bCallBackHit_tizen_core)); + return 0; +} + + + //& purpose: To check tizen core from tizen core task handle +//& type : auto +/** +* @testcase ITc_tizen_core_task_get_tizen_core_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Gets the tizen core from the tizen core task handle. +* @scenario Calls the tizen_core_task_get_tizen_core() to get the tizen core handle. +* @apicovered tizen_core_task_get_tizen_core. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ + +int ITc_tizen_core_task_get_tizen_core_p(void) +{ + START_TEST; + + tizen_core_h core = NULL; + int nRet; + + nRet = tizen_core_task_get_tizen_core(g_Task, &core); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_task_get_tizen_core",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(core,"tizen_core_task_get_tizen_core"); + return 0; +} + + //& purpose: To find the tizen core from the name +//& type : auto +/** +* @testcase ITc_tizen_core_find_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Finds the tizen core from the name. +* @scenario Calls the tizen_core_find() with the task name. +* @apicovered tizen_core_find. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ +int ITc_tizen_core_find_p(void) +{ + START_TEST; + + tizen_core_h task_core = NULL; + tizen_core_h main_task_core = NULL; + int nRet; + + nRet = tizen_core_find("ITc_test_task", &task_core); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_find",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(task_core, "tizen_core_find"); + + nRet = tizen_core_find("ITc_main_testing", &main_task_core); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_find",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(main_task_core, "tizen_core_find"); + return 0; +} + + //& purpose: To find the tizen core from this thread. +//& type : auto +/** +* @testcase ITc_tizen_core_find_from_this_thread_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Finds the tizen core from this thread. +* @scenario Calls the tizen_core_find_from_this_thread() in the main thread. + * Adds an idle job to the thread task and runs the thread task. + * And, calls the tizen_core_find_from_this_thread() in the idle callback. +* @apicovered tizen_core_find_from_this_thread. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ + +int ITc_tizen_core_find_from_this_thread_p(void) +{ + START_TEST; + + tizen_core_h core = NULL; + tizen_core_h main_task_core = NULL; + tizen_core_source_h source = NULL; + int nRet; + + nRet = tizen_core_find_from_this_thread(&core); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_find_from_this_thread",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(core, "tizen_core_find_from_this_thread"); + + nRet = tizen_core_task_get_tizen_core(g_Main_task, &main_task_core); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_task_get_tizen_core",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(main_task_core, "tizen_core_task_get_tizen_core"); + PRINT_RESULT(core, main_task_core,"Handle Equal Check",TizenCoreGetErrorMsg(nRet)); + + core = NULL; + nRet = tizen_core_task_get_tizen_core(g_Task, &core); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_task_get_tizen_core", TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(core, "tizen_core_task_get_tizen_core"); + + nRet = tizen_core_add_idle_job(core, FindFromThreadCallback, NULL, + &source); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_add_idle_job",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(source, "tizen_core_add_idle_job"); + if((g_taskquitret!=TIZEN_CORE_ERROR_NONE) || (g_taskrunningret!=TIZEN_CORE_ERROR_NONE) || (g_taskgetret!=TIZEN_CORE_ERROR_NONE) || (g_taskcorefindret!= TIZEN_CORE_ERROR_NONE) ) + { + return 1; + } + + nRet = tizen_core_task_run(g_Task); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_task_run",TizenCoreGetErrorMsg(nRet)); + + g_bCallBackHit_tizen_core=false; + nRet = tizen_core_task_run(g_Main_task); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_task_run",TizenCoreGetErrorMsg(nRet)); + PRINT_RESULT(g_bCallBackHit_tizen_core, true,"callback_not_invoked",TizenCoreGetErrorMsg(g_bCallBackHit_tizen_core)); + return 0; +} + + //& purpose: To add an idle job to the tizen core. +//& type : auto +/** +* @testcase ITc_tizen_core_add_idle_job_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Adds an idle job to the tizen core. +* @scenario Adds an idle job and runs the task. + * And, checks whether the g_bCallBackHit_tizen_core flag is set or not. +* @apicovered tizen_core_add_idle_job. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ + +int ITc_tizen_core_add_idle_job_p(void) +{ + START_TEST; + + tizen_core_h core = NULL; + tizen_core_source_h source = NULL; + int nRet; + + nRet = tizen_core_task_get_tizen_core(g_Main_task, &core); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_task_get_tizen_core",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(core, "tizen_core_task_get_tizen_core"); + + nRet = tizen_core_add_idle_job(core, AddIdleJobCallback, NULL, &source); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_add_idle_job",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(source, "tizen_core_add_idle_job"); + if(g_taskquitret!=TIZEN_CORE_ERROR_NONE) + { + return 1; + } + + g_bCallBackHit_tizen_core=false; + nRet = tizen_core_task_run(g_Main_task); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_task_run",TizenCoreGetErrorMsg(nRet)); + PRINT_RESULT(g_bCallBackHit_tizen_core, true,"callback_not_invoked",TizenCoreGetErrorMsg(g_bCallBackHit_tizen_core)); + return 0; +} + + + //& purpose: To check state of dhcp +//& type : auto +/** +* @testcase ITc_tizen_core_add_timer_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Adds a timer to the tizen core. +* @scenario Calls the tizen_core_add_timer() and runs the task. + * And, checks whether the g_bCallBackHit_tizen_core flag is set or not. +* @apicovered tizen_core_add_timer. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ +int ITc_tizen_core_add_timer_p(void) +{ + START_TEST; + + tizen_core_h core = NULL; + tizen_core_source_h source = NULL; + int nRet; + + nRet = tizen_core_task_get_tizen_core(g_Main_task, &core); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_task_get_tizen_core",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(core, "tizen_core_task_get_tizen_core"); + + nRet = tizen_core_add_timer(core, 100, AddTimerCallback, NULL, &source); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_add_timer",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(source, "tizen_core_add_timer"); + if(g_taskquitret!=TIZEN_CORE_ERROR_NONE) + { + return 1; + } + + g_bCallBackHit_tizen_core=false; + nRet = tizen_core_task_run(g_Main_task); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_task_run",TizenCoreGetErrorMsg(nRet)); + PRINT_RESULT(g_bCallBackHit_tizen_core, true,"callback_not_invoked",TizenCoreGetErrorMsg(g_bCallBackHit_tizen_core)); + return 0; +} + + //& purpose: To add channel receiver to the tizen core. +//& type : auto +/** +* @testcase ITc_tizen_core_add_channel_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Adds a channel receiver to the tizen core. +* @scenario Adds a channel receiver using tizen_core_add_channel() to the main core. + * Adds an idler job to the thread core. + * Runs the main and thread tasks. + * And, checks whether the g_bCallBackHit_tizen_core flag is set or not. +* @apicovered tizen_core_add_channel. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ +int ITc_tizen_core_add_channel_p(void) +{ + START_TEST; + + tizen_core_h main_core = NULL; + tizen_core_h core = NULL; + tizen_core_source_h source = NULL; + tizen_core_source_h idle_source = NULL; + int nRet; + + nRet = tizen_core_task_get_tizen_core(g_Main_task, &main_core); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_task_get_tizen_core",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(main_core, "tizen_core_task_get_tizen_core"); + + nRet = tizen_core_add_channel(main_core, g_Receiver, ChannelReceiveCallback, NULL, + &source); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_add_channel",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(source, "tizen_core_add_channel"); + if(g_tizengetchannelidret!=TIZEN_CORE_ERROR_NONE || g_tizencorechanneldataret!=TIZEN_CORE_ERROR_NONE || g_taskquitret!=TIZEN_CORE_ERROR_NONE) + { + return 1; + } + + nRet = tizen_core_task_get_tizen_core(g_Task, &core); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_task_get_tizen_core",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(core, "tizen_core_task_get_tizen_core"); + + nRet = tizen_core_add_idle_job(core, AddChannelIdleCallback, NULL, &idle_source); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_add_idle_job",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(idle_source, "tizen_core_add_idle_job"); + if(g_tizenchannelsendret!=TIZEN_CORE_ERROR_NONE||g_taskquitret!=TIZEN_CORE_ERROR_NONE) + { + return 1; + } + + nRet = tizen_core_task_run(g_Task); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_task_run",TizenCoreGetErrorMsg(nRet)); + + g_bCallBackHit_tizen_core=false; + nRet = tizen_core_task_run(g_Main_task); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_task_run",TizenCoreGetErrorMsg(nRet)); + PRINT_RESULT(g_bCallBackHit_tizen_core, true,"callback_not_invoked",TizenCoreGetErrorMsg(g_bCallBackHit_tizen_core)); + return 0; +} + + //& purpose: To add an event to the tizen core. +//& type : auto +/** +* @testcase ITc_tizen_core_add_event_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Adds an event to the tizen core. +* @scenario Adds an event using tizen_core_add_event() to the main core. + * The function returns TIZEN_CORE_ERROR_NONE. +* @apicovered tizen_core_add_event. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ +int ITc_tizen_core_add_event_p(void) +{ + START_TEST; + + tizen_core_h core = NULL; + tizen_core_source_h source = NULL; + int nRet; + + nRet = tizen_core_task_get_tizen_core(g_Main_task, &core); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_task_get_tizen_core",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(core, "tizen_core_task_get_tizen_core"); + + nRet = tizen_core_add_event(core, g_Event, &source); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_add_event",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(source, "tizen_core_add_event"); + g_Event = NULL; + + nRet = tizen_core_remove_source(core, source); + PRINT_RESULT(nRet,TIZEN_CORE_ERROR_NONE,"tizen_core_remov_source",TizenCoreGetErrorMsg(nRet)); + return 0; +} + + + //& purpose: To emit the event to the tizen core. +//& type : auto +/** +* @testcase ITc_tizen_core_emit_event_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Emits the event to the tizen core. +* @scenario Adds an event handler to the event and adds a timer to the main core. + * Runs the main task and checks whether the g_bCallBackHit_tizen_core flag is set or not. +* @apicovered tizen_core_event_add_handler,tizen_core_task_get_tizen_core,tizen_core_add_event,tizen_core_add_timer,tizen_core_task_run,tizen_core_event_remove_handler,tizen_core_remove_source. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ +/* +int ITc_tizen_core_emit_event_p(void) +{ + START_TEST; + + tizen_core_event_handler_h event_handler = NULL; + tizen_core_h core = NULL; + tizen_core_source_h source = NULL; + tizen_core_source_h timer_source = NULL; + int nRet; + + nRet = tizen_core_event_add_handler(g_Event, EventHandlerCallback, NULL, + &event_handler); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_event_add_handler",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(event_handler, "tizen_core_event_add_handler"); + if(g_tizeneventidret!=TIZEN_CORE_ERROR_NONE || g_taskquitret!=TIZEN_ERROR_NONE) + { + return 1; + } + + nRet = tizen_core_task_get_tizen_core(g_Main_task, &core); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_task_get_tizen_core",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(core, "tizen_core_task_get_tizen_core"); + + nRet = tizen_core_add_event(core, g_Event, &source); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_add_event",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(source, "tizen_core_add_event"); + + nRet = tizen_core_add_timer(core, 100, EmitEventTimerCallback, NULL, + &timer_source); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_add_timer",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(timer_source, "tizen_core_add_timer"); + if(g_tizenemiteventret!=TIZEN_CORE_ERROR_NONE) + { + return 1; + } + + + nRet = tizen_core_task_run(g_Main_task); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_task_run",TizenCoreGetErrorMsg(nRet)); + + nRet = tizen_core_event_remove_handler(g_Event, event_handler); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_event_remove_handler",TizenCoreGetErrorMsg(nRet)); + + g_bCallBackHit_tizen_core=false; + nRet = tizen_core_remove_source(core, source); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_remove_source",TizenCoreGetErrorMsg(nRet)); + PRINT_RESULT(g_bCallBackHit_tizen_core, true,"callback_not_invoked",TizenCoreGetErrorMsg(g_bCallBackHit_tizen_core)); + return 0; +} +*/ + + //& purpose: To add and remove source to the tizen core. +//& type : auto +/** +* @testcase ITc_tizen_core_add_remove_source_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Add and remove a source to the tizen core. +* @scenario Calls the tizen_core_add_source() and tizen_core_remove_source() with the created source handle. +* @apicovered tizen_core_add_source,tizen_core_remove_source. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ + +int ITc_tizen_core_add_remove_source_p(void) +{ + START_TEST; + + tizen_core_h core = NULL; + int nRet; + + nRet = tizen_core_task_get_tizen_core(g_Main_task, &core); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_task_get_tizen_core",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(core, "tizen_core_task_get_tizen_core"); + + nRet = tizen_core_add_source(core, g_Source); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_add_source",TizenCoreGetErrorMsg(nRet)); + + nRet = tizen_core_remove_source(core, g_Source); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_remove_source",TizenCoreGetErrorMsg(nRet)); + g_Source = NULL; + return 0; +} + + //& purpose: To create and destroy the tizen core source. +//& type : auto +/** +* @testcase ITc_tizen_core_source_create_destroy_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Creates and destroys the tizen core source. +* @scenario Calls the tizen_core_source_create(),tizen_core_source_destroy(). + * The functions returns TIZEN_CORE_ERROR_NONE.. +* @apicovered tizen_core_source_create,tizen_core_source_destroy. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ + +int ITc_tizen_core_source_create_destroy_p(void) +{ + START_TEST; + + tizen_core_source_h source = NULL; + int nRet; + + nRet = tizen_core_source_create(&source); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_source_create",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(source, "tizen_core_source_create"); + + nRet = tizen_core_source_destroy(source); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_source_destroy",TizenCoreGetErrorMsg(nRet)); + return 0; +} + + //& purpose: To add and remove to wait for some events on the file descriptor +//& type : auto +/** +* @testcase ITc_tizen_core_source_add_remove_poll_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Add and Removes to wait for some events on the file descriptor. +* @scenario Calls the tizen_core_source_add_poll() and + * calls the tizen_core_source_remove_poll(). +* @apicovered tizen_core_source_add_poll,tizen_core_source_remove_poll. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ + +int ITc_tizen_core_source_add_remove_poll_p(void) +{ + START_TEST; + + int nRet; + + nRet = tizen_core_source_add_poll(g_Source, g_Poll_fd); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_source_add_poll",TizenCoreGetErrorMsg(nRet)); + + nRet = tizen_core_source_remove_poll(g_Source, g_Poll_fd); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_source_remove_poll",TizenCoreGetErrorMsg(nRet)); + return 0; +} + + //& purpose: To set the prepare callback function to the tizen core source +//& type : auto +/** +* @testcase ITc_tizen_core_source_set_prepare_cb_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Sets the prepare callback function to the tizen core source. +* @scenario Calls the tizen_core_source_set_prepare_cb() +* @apicovered tizen_core_source_set_prepare_cb +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ +int ITc_tizen_core_source_set_prepare_cb_p(void) +{ + START_TEST; + int nRet; + + nRet = tizen_core_source_set_prepare_cb(g_Source, SetPrepareCbCallback, NULL); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_source_set_prepare_cb",TizenCoreGetErrorMsg(nRet)); + return 0; +} + + + //& purpose: To set the check callback function to the tizen core source +//& type : auto +/** +* @testcase ITc_tizen_core_source_set_check_cb_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Sets the check callback function to the tizen core source. +* @scenario Calls the tizen_core_source_set_check_cb(). +* @apicovered tizen_core_source_set_check_cb. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ + +int ITc_tizen_core_source_set_check_cb_p(void) +{ + START_TEST; + int nRet; + + nRet = tizen_core_source_set_check_cb(g_Source, SetCheckCbCallback, NULL); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_source_set_check_cb",TizenCoreGetErrorMsg(nRet)); + return 0; +} + + + //& purpose: To set the dispatch callback function to the tizen core source +//& type : auto +/** +* @testcase ITc_tizen_core_source_set_dispatch_cb_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Sets the dispatch callback function to the tizen core source. +* @scenario Calls the tizen_core_source_set_dispatch_cb(). +* @apicovered tizen_core_source_set_dispatch_cb. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ + +int ITc_tizen_core_source_set_dispatch_cb_p(void) +{ + START_TEST; + int nRet; + + nRet = tizen_core_source_set_dispatch_cb(g_Source, SetDispatchCbCallback, NULL); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_source_set_dispatch_cb",TizenCoreGetErrorMsg(nRet)); + return 0; +} + + //& purpose: To set the finalize callback function to the tizen core source +//& type : auto +/** +* @testcase ITc_tizen_core_source_set_finalize_cb_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Sets the finalize callback function to the tizen core source. +* @scenario Calls the tizen_core_source_set_finalize_cb(). +* @apicovered tizen_core_source_set_finalize_cb. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ + +int ITc_tizen_core_source_set_finalize_cb_p(void) +{ + START_TEST; + int nRet; + + nRet = tizen_core_source_set_finalize_cb(g_Source, SetFinalizeCbCallback, NULL); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_source_set_finalize_cb",TizenCoreGetErrorMsg(nRet)); + return 0; +} + + //& purpose: To set the priority to the tizen core source +//& type : auto +/** +* @testcase ITc_tizen_core_source_set_priority_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Sets the priority to the tizen core source. +* @scenario Calls the tizen_core_source_set_priority(). +* @apicovered tizen_core_source_set_priority. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ +int ITc_tizen_core_source_set_priority_p(void) +{ + START_TEST; + int nRet; + + nRet = tizen_core_source_set_priority(g_Source, TIZEN_CORE_PRIORITY_HIGH); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_source_set_priority",TizenCoreGetErrorMsg(nRet)); + return 0; +} + + + //& purpose: To create and destroy a tizen core poll fd handle +//& type : auto +/** +* @testcase ITc_tizen_core_poll_fd_create_destroy_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Creates and destroys a tizen core poll fd handle. +* @scenario Calls the tizen_core_poll_fd_create(),tizen_core_poll_fd_destroy(). +* @apicovered tizen_core_poll_fd_create,tizen_core_poll_fd_destroy. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ + +int ITc_tizen_core_poll_fd_create_destroy_p(void) +{ + START_TEST; + tizen_core_poll_fd_h poll_fd = NULL; + int nRet; + + nRet = tizen_core_poll_fd_create(&poll_fd); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_poll_fd_create",TizenCoreGetErrorMsg(nRet)); + CHECK_HANDLE(poll_fd,"tizen_core_poll_fd_create") + + nRet = tizen_core_poll_fd_destroy(poll_fd); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_poll_fd_destroy",TizenCoreGetErrorMsg(nRet)); + return 0; +} + + + //& purpose: To set and get the file descriptor to the poll fd handle +//& type : auto +/** +* @testcase ITc_tizen_core_poll_fd_set_get_fd_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Sets and gets the file descriptor to the poll fd handle. +* @scenario Calls the tizen_core_poll_fd_set_fd(), tizen_core_poll_fd_get_fd() +* @apicovered tizen_core_poll_fd_set_fd,tizen_core_poll_fd_get_fd. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ + +int ITc_tizen_core_poll_fd_set_get_fd_p(void) +{ + START_TEST; + int nRet; + int fd = -1; + + nRet = tizen_core_poll_fd_set_fd(g_Poll_fd, 1); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_poll_fd_set_fd",TizenCoreGetErrorMsg(nRet)); + + nRet = tizen_core_poll_fd_get_fd(g_Poll_fd, &fd); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_poll_fd_get_fd",TizenCoreGetErrorMsg(nRet)); + if(fd!=1) + { + FPRINTF("[Line : %d][%s] fd id not matched\\n", __LINE__, API_NAMESPACE); + return 1; + } + return 0; +} + + + //& purpose: To set and get the requested events from the poll fd handle +//& type : auto +/** +* @testcase ITc_tizen_core_poll_fd_set_get_events_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Sets and Gets the requested events from the poll fd handle. +* @scenario Calls the tizen_core_poll_fd_get_events(),tizen_core_poll_fd_set_events(). +* @apicovered tizen_core_poll_fd_set_events,tizen_core_poll_fd_get_events. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ + +int ITc_tizen_core_poll_fd_set_get_events_p(void) +{ + START_TEST; + uint16_t events = 0; + int nRet; + + nRet = tizen_core_poll_fd_set_events(g_Poll_fd, + TIZEN_CORE_POLL_EVENT_IN | TIZEN_CORE_POLL_EVENT_ERR); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_poll_fd_set_events",TizenCoreGetErrorMsg(nRet)); + + nRet = tizen_core_poll_fd_get_events(g_Poll_fd, &events); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_poll_fd_get_events",TizenCoreGetErrorMsg(nRet)); + PRINT_RESULT(events, (TIZEN_CORE_POLL_EVENT_IN | TIZEN_CORE_POLL_EVENT_ERR),"events value mismatch with set value api",TizenCoreGetErrorMsg(events)); + return 0; +} + +//& purpose: To set and get the returned events to the poll fd handle +//& type : auto +/** +* @testcase ITc_tizen_core_poll_fd_set_get_returned_events_p +* @since_tizen 9.0 +* @author SRID(tarun1.kumar) +* @reviewer SRID(shobhit.v) +* @type auto +* @description Sets and gets the returned events to the poll fd handle. +* @scenario Calls the tizen_core_poll_fd_set_returned_events(),tizen_core_poll_fd_get_returned_events(). +* @apicovered tizen_core_poll_fd_set_returned_events,tizen_core_poll_fd_get_returned_events. +* @passcase When API return TIZEN_ERROR_NONE +* @failcase When API not return TIZEN_ERROR_NONE +* @precondition None +* @postcondition None +*/ + +int ITc_tizen_core_poll_fd_set_get_returned_events_p(void) +{ + START_TEST; + uint16_t returned_events = 0; + int nRet; + + nRet = tizen_core_poll_fd_set_returned_events(g_Poll_fd,TIZEN_CORE_POLL_EVENT_IN | TIZEN_CORE_POLL_EVENT_OUT); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_poll_fd_get_returned_events",TizenCoreGetErrorMsg(nRet)); + + nRet = tizen_core_poll_fd_get_returned_events(g_Poll_fd, &returned_events); + PRINT_RESULT(nRet, TIZEN_CORE_ERROR_NONE,"tizen_core_poll_fd_get_returned_events",TizenCoreGetErrorMsg(nRet)); + PRINT_RESULT(returned_events, TIZEN_CORE_POLL_EVENT_IN | TIZEN_CORE_POLL_EVENT_OUT,"returned events not matched with set api values",TizenCoreGetErrorMsg(returned_events)); + return 0; +} + + + +/** @} */ +/** @} */ + + diff --git a/src/itc/tizen-core/tct-tizen-core-native.c b/src/itc/tizen-core/tct-tizen-core-native.c new file mode 100755 index 000000000..7f24d8bae --- /dev/null +++ b/src/itc/tizen-core/tct-tizen-core-native.c @@ -0,0 +1,143 @@ +// +// Copyright (c) 2022 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#include "tct_common.h" + +#ifdef MOBILE //Starts MOBILE +#include "tct-tizen-core-native_mobile.h" +#endif //MOBILE //End MOBILE + +#ifdef WEARABLE //Starts WEARABLE +#include "tct-tizen-core-native_wearable.h" +#endif //WEARABLE //End WEARABLE + +#ifdef TV //Starts TV +#include "tct-tizen-core-native_tv.h" +#endif //TV //End TV + +#ifdef TIZENIOT //Starts TIZENIOT +#include "tct-tizen-core-native_tizeniot.h" +#endif //TIZENIOT //End TIZENIOT + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include + +typedef struct appdata { + Evas_Object *win; + Evas_Object *conform; + Evas_Object *label; +} appdata_s; + +static bool app_create(void *data) +{ + return true; +} + +static void app_control(app_control_h app_control, void *data) +{ + char* pszGetTCName = NULL; + int i=0, result=0, nRet=0; + nRet = app_control_get_extra_data(app_control, "testcase_name", &pszGetTCName); + if(nRet != APP_CONTROL_ERROR_NONE) + { + dlog_print(DLOG_ERROR, "NativeTCT", "[%s:%d] app_control_get_extra_data returns error = %d", __FUNCTION__, __LINE__, nRet); + PRINT_UTC_LOG("\\n[%s][Line : %d]Unable to fetch test case name: app_control_get_extra_data API call fails\\n", __FILE__, __LINE__); + PRINT_TC_RESULT("%d",1); + FREE_MEMORY_TC(pszGetTCName); + return; + } + + dlog_print(DLOG_INFO, "NativeTCT", "[%s:%d] Executing TC Name = %s", __FUNCTION__, __LINE__, pszGetTCName); + for ( i = 0; tc_array[i].name; i++ ) + { + if ( 0 == strncmp(pszGetTCName, tc_array[i].name, strlen(pszGetTCName)) ) + { + if ( tc_array[i].startup ) + { + dlog_print(DLOG_INFO, "NativeTCT", "%s : Start up", pszGetTCName); + tc_array[i].startup(); + } + + dlog_print(DLOG_INFO, "NativeTCT", "%s : Body", pszGetTCName); + result = tc_array[i].function(); + dlog_print(DLOG_INFO, "NativeTCT", "%s returns value = %d", pszGetTCName, result); + + if ( tc_array[i].cleanup ) + { + dlog_print(DLOG_INFO, "NativeTCT", "%s : Clean up", pszGetTCName); + tc_array[i].cleanup(); + } + + PRINT_TC_RESULT("%d",result); + FREE_MEMORY_TC(pszGetTCName); + return; + } + } + + dlog_print(DLOG_ERROR, "NativeTCT", "[%s:%d] Unable to execute %s : Unknown Test Case Name", __FUNCTION__, __LINE__, pszGetTCName); + PRINT_UTC_LOG("\\n[%s][Line : %d]Unable to execute %s : Unknown Test Case Name\\n", __FILE__, __LINE__, pszGetTCName); + PRINT_TC_RESULT("%d",1); + FREE_MEMORY_TC(pszGetTCName); + return; +} + +static void app_terminate(void *data) +{ + dlog_print(DLOG_INFO, "NativeTCT", "[%s:%d] Application Package is now Terminating", __FUNCTION__, __LINE__); +} + +int main(int argc, char *argv[]) +{ + int ret = 0; + appdata_s ad = {0,}; + + ui_app_lifecycle_callback_s event_callback = {0,}; + event_callback.create = app_create; + event_callback.terminate = app_terminate; + event_callback.app_control = app_control; + + //setting gcda file location for coverage + setenv("GCOV_PREFIX","/tmp",1); + dlog_print(DLOG_INFO, "NativeTCT", "[%s:%d] Coverage *.gcda File location set to /tmp/home/abuild/rpmbuild/BUILD/ ", __FUNCTION__, __LINE__); + + dlog_print(DLOG_INFO, "NativeTCT", "[%s:%d] Application Main Function is Invoked", __FUNCTION__, __LINE__); + ret = ui_app_main(argc, argv, &event_callback, &ad); + if (ret != APP_ERROR_NONE) + { + dlog_print(DLOG_ERROR, "NativeTCT", "Application ui_app_main call gets failed. err = %d", ret); + PRINT_UTC_LOG("\\n[%s][Line : %d]Application ui_app_main call gets failed. err = %d\\n", __FILE__, __LINE__, ret); + PRINT_TC_RESULT("%d",1); + return ret; + } + + dlog_print(DLOG_INFO, "NativeTCT", "[%s:%d] Application Package is Terminated", __FUNCTION__, __LINE__); + return ret; +} diff --git a/src/itc/tizen-core/tct-tizen-core-native_mobile.h b/src/itc/tizen-core/tct-tizen-core-native_mobile.h new file mode 100755 index 000000000..f65e0c5aa --- /dev/null +++ b/src/itc/tizen-core/tct-tizen-core-native_mobile.h @@ -0,0 +1,127 @@ +// Copyright (c) 2024 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef __TCT_TIZEN_CORE_NATIVE_H__ +#define __TCT_TIZEN_CORE_NATIVE_H__ + +#include "testcase.h" +#include "tct_common.h" + +// ITs-tizen-core.c +extern void ITc_tizen_core_startup(void); +extern void ITc_tizen_core_cleanup(void); +extern int ITc_tizen_core_init_shutdown_p(void); +extern int ITc_tizen_core_ready_p(void); +extern int ITc_tizen_core_task_create_destroy_p(void); +extern int ITc_tizen_core_task_run_p(void); +extern int ITc_tizen_core_task_is_running_p(void); +extern int ITc_tizen_core_task_quit_p(void); +extern int ITc_tizen_core_task_get_tizen_core_p(void); +extern int ITc_tizen_core_find_p(void); +extern int ITc_tizen_core_find_from_this_thread_p(void); +extern int ITc_tizen_core_add_idle_job_p(void); +extern int ITc_tizen_core_add_timer_p(void); +extern int ITc_tizen_core_add_channel_p(void); +extern int ITc_tizen_core_add_event_p(void); +//extern int ITc_tizen_core_emit_event_p(void); +extern int ITc_tizen_core_add_remove_source_p(void); +extern int ITc_tizen_core_source_create_destroy_p(void); +extern int ITc_tizen_core_source_add_remove_poll_p(void); +extern int ITc_tizen_core_source_set_prepare_cb_p(void); +extern int ITc_tizen_core_source_set_check_cb_p(void); +extern int ITc_tizen_core_source_set_dispatch_cb_p(void); +extern int ITc_tizen_core_source_set_finalize_cb_p(void); +extern int ITc_tizen_core_source_set_priority_p(void); +extern int ITc_tizen_core_poll_fd_create_destroy_p(void); +extern int ITc_tizen_core_poll_fd_set_get_fd_p(void); +extern int ITc_tizen_core_poll_fd_set_get_events_p(void); +extern int ITc_tizen_core_poll_fd_set_get_returned_events_p(void); + +// ITs-tizen-core-channel.c +extern void ITc_tizen_core_channel_startup(void); +extern void ITc_tizen_core_channel_cleanup(void); +extern int ITc_tizen_core_channel_make_pair_p(void); +extern int ITc_tizen_core_channel_sender_send_p(void); +extern int ITc_tizen_core_channel_sender_destroy_p(void); +extern int ITc_tizen_core_channel_sender_clone_p(void); +extern int ITc_tizen_core_channel_receiver_receive_p(void); +extern int ITc_tizen_core_channel_receiver_destroy_p(void); +extern int ITc_tizen_core_channel_object_create_destroy_p(void); +extern int ITc_tizen_core_channel_object_set_get_id_p(void); +extern int ITc_tizen_core_channel_object_set_get_data_p(void); +extern int ITc_tizen_core_channel_object_get_sender_task_name_p(void); + +// ITs-tizen-core-event.c +extern void ITc_tizen_core_event_startup(void); +extern void ITc_tizen_core_event_cleanup(void); +extern int ITc_tizen_core_event_create_destroy_p(void); +extern int ITc_tizen_core_event_add_remove_handler_p(void); +extern int ITc_tizen_core_event_emit_p(void); +extern int ITc_tizen_core_event_object_create_destroy_p(void); +extern int ITc_tizen_core_event_object_set_destroy_cb_p(void); +extern int ITc_tizen_core_event_object_get_id_p(void); +extern int ITc_tizen_core_event_object_get_data_p(void); + +testcase tc_array[] = { + // ITs-tizen-core.c + {"ITc_tizen_core_init_shutdown_p", ITc_tizen_core_init_shutdown_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + {"ITc_tizen_core_ready_p", ITc_tizen_core_ready_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + {"ITc_tizen_core_task_create_destroy_p", ITc_tizen_core_task_create_destroy_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_task_run_p", ITc_tizen_core_task_run_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_task_is_running_p", ITc_tizen_core_task_is_running_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_task_quit_p", ITc_tizen_core_task_quit_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_task_get_tizen_core_p",ITc_tizen_core_task_get_tizen_core_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + {"ITc_tizen_core_find_p", ITc_tizen_core_find_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + {"ITc_tizen_core_find_from_this_thread_p",ITc_tizen_core_find_from_this_thread_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + {"ITc_tizen_core_add_idle_job_p", ITc_tizen_core_add_idle_job_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_add_timer_p", ITc_tizen_core_add_timer_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_add_channel_p", ITc_tizen_core_add_channel_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_add_event_p", ITc_tizen_core_add_event_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, +// {"ITc_tizen_core_emit_event_p", ITc_tizen_core_emit_event_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_add_remove_source_p", ITc_tizen_core_add_remove_source_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_source_create_destroy_p", ITc_tizen_core_source_create_destroy_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_source_add_remove_poll_p", ITc_tizen_core_source_create_destroy_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_source_set_prepare_cb_p",ITc_tizen_core_source_set_prepare_cb_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + {"ITc_tizen_core_source_set_check_cb_p",ITc_tizen_core_source_set_check_cb_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + {"ITc_tizen_core_source_set_dispatch_cb_p",ITc_tizen_core_source_set_dispatch_cb_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + {"ITc_tizen_core_source_set_finalize_cb_p",ITc_tizen_core_source_set_finalize_cb_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + {"ITc_tizen_core_source_set_priority_p",ITc_tizen_core_source_set_priority_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + {"ITc_tizen_core_poll_fd_create_destroy_p", ITc_tizen_core_poll_fd_create_destroy_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_poll_fd_set_get_fd_p", ITc_tizen_core_poll_fd_set_get_fd_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_poll_fd_set_get_events_p", ITc_tizen_core_poll_fd_set_get_events_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_poll_fd_set_get_returned_events_p",ITc_tizen_core_poll_fd_set_get_returned_events_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + // ITs-tizen-core-channel.c + {"ITc_tizen_core_channel_make_pair_p", ITc_tizen_core_channel_make_pair_p,ITc_tizen_core_channel_startup, ITc_tizen_core_channel_cleanup}, + {"ITc_tizen_core_channel_sender_send_p",ITc_tizen_core_channel_sender_send_p, ITc_tizen_core_channel_startup,ITc_tizen_core_channel_cleanup}, + {"ITc_tizen_core_channel_sender_destroy_p",ITc_tizen_core_channel_sender_destroy_p, ITc_tizen_core_channel_startup,ITc_tizen_core_channel_cleanup}, + {"ITc_tizen_core_channel_sender_clone_p",ITc_tizen_core_channel_sender_clone_p, ITc_tizen_core_channel_startup,ITc_tizen_core_channel_cleanup}, + {"ITc_tizen_core_channel_receiver_receive_p",ITc_tizen_core_channel_receiver_receive_p, ITc_tizen_core_channel_startup,ITc_tizen_core_channel_cleanup}, + {"ITc_tizen_core_channel_receiver_destroy_p",ITc_tizen_core_channel_receiver_destroy_p, ITc_tizen_core_channel_startup,ITc_tizen_core_channel_cleanup}, + {"ITc_tizen_core_channel_object_create_destroy_p",ITc_tizen_core_channel_object_create_destroy_p, ITc_tizen_core_channel_startup,ITc_tizen_core_channel_cleanup}, + {"ITc_tizen_core_channel_object_set_get_id_p",ITc_tizen_core_channel_object_set_get_id_p, ITc_tizen_core_channel_startup,ITc_tizen_core_channel_cleanup}, + {"ITc_tizen_core_channel_object_set_get_data_p",ITc_tizen_core_channel_object_set_get_data_p, ITc_tizen_core_channel_startup,ITc_tizen_core_channel_cleanup}, + {"ITc_tizen_core_channel_object_get_sender_task_name_p",ITc_tizen_core_channel_object_get_sender_task_name_p,ITc_tizen_core_channel_startup, ITc_tizen_core_channel_cleanup}, + // ITs-tizen-core-event.c + {"ITc_tizen_core_event_create_destroy_p", ITc_tizen_core_event_create_destroy_p,ITc_tizen_core_event_startup, ITc_tizen_core_event_cleanup}, + {"ITc_tizen_core_event_add_remove_handler_p", ITc_tizen_core_event_add_remove_handler_p,ITc_tizen_core_event_startup, ITc_tizen_core_event_cleanup}, + {"ITc_tizen_core_event_emit_p", ITc_tizen_core_event_emit_p,ITc_tizen_core_event_startup, ITc_tizen_core_event_cleanup}, + {"ITc_tizen_core_event_object_create_destroy_p",ITc_tizen_core_event_object_create_destroy_p, ITc_tizen_core_event_startup,ITc_tizen_core_event_cleanup}, + {"ITc_tizen_core_event_object_set_destroy_cb_p",ITc_tizen_core_event_object_set_destroy_cb_p, ITc_tizen_core_event_startup,ITc_tizen_core_event_cleanup}, + {"ITc_tizen_core_event_object_get_id_p",ITc_tizen_core_event_object_get_id_p, ITc_tizen_core_event_startup,ITc_tizen_core_event_cleanup}, + {"ITc_tizen_core_event_object_get_data_p",ITc_tizen_core_event_object_get_data_p, ITc_tizen_core_event_startup,ITc_tizen_core_event_cleanup}, + {NULL, NULL}}; + +#endif // __TCT_TIZEN_CORE_NATIVE_H__ + + diff --git a/src/itc/tizen-core/tct-tizen-core-native_tizeniot.h b/src/itc/tizen-core/tct-tizen-core-native_tizeniot.h new file mode 100755 index 000000000..f65e0c5aa --- /dev/null +++ b/src/itc/tizen-core/tct-tizen-core-native_tizeniot.h @@ -0,0 +1,127 @@ +// Copyright (c) 2024 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef __TCT_TIZEN_CORE_NATIVE_H__ +#define __TCT_TIZEN_CORE_NATIVE_H__ + +#include "testcase.h" +#include "tct_common.h" + +// ITs-tizen-core.c +extern void ITc_tizen_core_startup(void); +extern void ITc_tizen_core_cleanup(void); +extern int ITc_tizen_core_init_shutdown_p(void); +extern int ITc_tizen_core_ready_p(void); +extern int ITc_tizen_core_task_create_destroy_p(void); +extern int ITc_tizen_core_task_run_p(void); +extern int ITc_tizen_core_task_is_running_p(void); +extern int ITc_tizen_core_task_quit_p(void); +extern int ITc_tizen_core_task_get_tizen_core_p(void); +extern int ITc_tizen_core_find_p(void); +extern int ITc_tizen_core_find_from_this_thread_p(void); +extern int ITc_tizen_core_add_idle_job_p(void); +extern int ITc_tizen_core_add_timer_p(void); +extern int ITc_tizen_core_add_channel_p(void); +extern int ITc_tizen_core_add_event_p(void); +//extern int ITc_tizen_core_emit_event_p(void); +extern int ITc_tizen_core_add_remove_source_p(void); +extern int ITc_tizen_core_source_create_destroy_p(void); +extern int ITc_tizen_core_source_add_remove_poll_p(void); +extern int ITc_tizen_core_source_set_prepare_cb_p(void); +extern int ITc_tizen_core_source_set_check_cb_p(void); +extern int ITc_tizen_core_source_set_dispatch_cb_p(void); +extern int ITc_tizen_core_source_set_finalize_cb_p(void); +extern int ITc_tizen_core_source_set_priority_p(void); +extern int ITc_tizen_core_poll_fd_create_destroy_p(void); +extern int ITc_tizen_core_poll_fd_set_get_fd_p(void); +extern int ITc_tizen_core_poll_fd_set_get_events_p(void); +extern int ITc_tizen_core_poll_fd_set_get_returned_events_p(void); + +// ITs-tizen-core-channel.c +extern void ITc_tizen_core_channel_startup(void); +extern void ITc_tizen_core_channel_cleanup(void); +extern int ITc_tizen_core_channel_make_pair_p(void); +extern int ITc_tizen_core_channel_sender_send_p(void); +extern int ITc_tizen_core_channel_sender_destroy_p(void); +extern int ITc_tizen_core_channel_sender_clone_p(void); +extern int ITc_tizen_core_channel_receiver_receive_p(void); +extern int ITc_tizen_core_channel_receiver_destroy_p(void); +extern int ITc_tizen_core_channel_object_create_destroy_p(void); +extern int ITc_tizen_core_channel_object_set_get_id_p(void); +extern int ITc_tizen_core_channel_object_set_get_data_p(void); +extern int ITc_tizen_core_channel_object_get_sender_task_name_p(void); + +// ITs-tizen-core-event.c +extern void ITc_tizen_core_event_startup(void); +extern void ITc_tizen_core_event_cleanup(void); +extern int ITc_tizen_core_event_create_destroy_p(void); +extern int ITc_tizen_core_event_add_remove_handler_p(void); +extern int ITc_tizen_core_event_emit_p(void); +extern int ITc_tizen_core_event_object_create_destroy_p(void); +extern int ITc_tizen_core_event_object_set_destroy_cb_p(void); +extern int ITc_tizen_core_event_object_get_id_p(void); +extern int ITc_tizen_core_event_object_get_data_p(void); + +testcase tc_array[] = { + // ITs-tizen-core.c + {"ITc_tizen_core_init_shutdown_p", ITc_tizen_core_init_shutdown_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + {"ITc_tizen_core_ready_p", ITc_tizen_core_ready_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + {"ITc_tizen_core_task_create_destroy_p", ITc_tizen_core_task_create_destroy_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_task_run_p", ITc_tizen_core_task_run_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_task_is_running_p", ITc_tizen_core_task_is_running_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_task_quit_p", ITc_tizen_core_task_quit_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_task_get_tizen_core_p",ITc_tizen_core_task_get_tizen_core_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + {"ITc_tizen_core_find_p", ITc_tizen_core_find_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + {"ITc_tizen_core_find_from_this_thread_p",ITc_tizen_core_find_from_this_thread_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + {"ITc_tizen_core_add_idle_job_p", ITc_tizen_core_add_idle_job_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_add_timer_p", ITc_tizen_core_add_timer_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_add_channel_p", ITc_tizen_core_add_channel_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_add_event_p", ITc_tizen_core_add_event_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, +// {"ITc_tizen_core_emit_event_p", ITc_tizen_core_emit_event_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_add_remove_source_p", ITc_tizen_core_add_remove_source_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_source_create_destroy_p", ITc_tizen_core_source_create_destroy_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_source_add_remove_poll_p", ITc_tizen_core_source_create_destroy_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_source_set_prepare_cb_p",ITc_tizen_core_source_set_prepare_cb_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + {"ITc_tizen_core_source_set_check_cb_p",ITc_tizen_core_source_set_check_cb_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + {"ITc_tizen_core_source_set_dispatch_cb_p",ITc_tizen_core_source_set_dispatch_cb_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + {"ITc_tizen_core_source_set_finalize_cb_p",ITc_tizen_core_source_set_finalize_cb_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + {"ITc_tizen_core_source_set_priority_p",ITc_tizen_core_source_set_priority_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + {"ITc_tizen_core_poll_fd_create_destroy_p", ITc_tizen_core_poll_fd_create_destroy_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_poll_fd_set_get_fd_p", ITc_tizen_core_poll_fd_set_get_fd_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_poll_fd_set_get_events_p", ITc_tizen_core_poll_fd_set_get_events_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_poll_fd_set_get_returned_events_p",ITc_tizen_core_poll_fd_set_get_returned_events_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + // ITs-tizen-core-channel.c + {"ITc_tizen_core_channel_make_pair_p", ITc_tizen_core_channel_make_pair_p,ITc_tizen_core_channel_startup, ITc_tizen_core_channel_cleanup}, + {"ITc_tizen_core_channel_sender_send_p",ITc_tizen_core_channel_sender_send_p, ITc_tizen_core_channel_startup,ITc_tizen_core_channel_cleanup}, + {"ITc_tizen_core_channel_sender_destroy_p",ITc_tizen_core_channel_sender_destroy_p, ITc_tizen_core_channel_startup,ITc_tizen_core_channel_cleanup}, + {"ITc_tizen_core_channel_sender_clone_p",ITc_tizen_core_channel_sender_clone_p, ITc_tizen_core_channel_startup,ITc_tizen_core_channel_cleanup}, + {"ITc_tizen_core_channel_receiver_receive_p",ITc_tizen_core_channel_receiver_receive_p, ITc_tizen_core_channel_startup,ITc_tizen_core_channel_cleanup}, + {"ITc_tizen_core_channel_receiver_destroy_p",ITc_tizen_core_channel_receiver_destroy_p, ITc_tizen_core_channel_startup,ITc_tizen_core_channel_cleanup}, + {"ITc_tizen_core_channel_object_create_destroy_p",ITc_tizen_core_channel_object_create_destroy_p, ITc_tizen_core_channel_startup,ITc_tizen_core_channel_cleanup}, + {"ITc_tizen_core_channel_object_set_get_id_p",ITc_tizen_core_channel_object_set_get_id_p, ITc_tizen_core_channel_startup,ITc_tizen_core_channel_cleanup}, + {"ITc_tizen_core_channel_object_set_get_data_p",ITc_tizen_core_channel_object_set_get_data_p, ITc_tizen_core_channel_startup,ITc_tizen_core_channel_cleanup}, + {"ITc_tizen_core_channel_object_get_sender_task_name_p",ITc_tizen_core_channel_object_get_sender_task_name_p,ITc_tizen_core_channel_startup, ITc_tizen_core_channel_cleanup}, + // ITs-tizen-core-event.c + {"ITc_tizen_core_event_create_destroy_p", ITc_tizen_core_event_create_destroy_p,ITc_tizen_core_event_startup, ITc_tizen_core_event_cleanup}, + {"ITc_tizen_core_event_add_remove_handler_p", ITc_tizen_core_event_add_remove_handler_p,ITc_tizen_core_event_startup, ITc_tizen_core_event_cleanup}, + {"ITc_tizen_core_event_emit_p", ITc_tizen_core_event_emit_p,ITc_tizen_core_event_startup, ITc_tizen_core_event_cleanup}, + {"ITc_tizen_core_event_object_create_destroy_p",ITc_tizen_core_event_object_create_destroy_p, ITc_tizen_core_event_startup,ITc_tizen_core_event_cleanup}, + {"ITc_tizen_core_event_object_set_destroy_cb_p",ITc_tizen_core_event_object_set_destroy_cb_p, ITc_tizen_core_event_startup,ITc_tizen_core_event_cleanup}, + {"ITc_tizen_core_event_object_get_id_p",ITc_tizen_core_event_object_get_id_p, ITc_tizen_core_event_startup,ITc_tizen_core_event_cleanup}, + {"ITc_tizen_core_event_object_get_data_p",ITc_tizen_core_event_object_get_data_p, ITc_tizen_core_event_startup,ITc_tizen_core_event_cleanup}, + {NULL, NULL}}; + +#endif // __TCT_TIZEN_CORE_NATIVE_H__ + + diff --git a/src/itc/tizen-core/tct-tizen-core-native_wearable.h b/src/itc/tizen-core/tct-tizen-core-native_wearable.h new file mode 100755 index 000000000..f65e0c5aa --- /dev/null +++ b/src/itc/tizen-core/tct-tizen-core-native_wearable.h @@ -0,0 +1,127 @@ +// Copyright (c) 2024 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef __TCT_TIZEN_CORE_NATIVE_H__ +#define __TCT_TIZEN_CORE_NATIVE_H__ + +#include "testcase.h" +#include "tct_common.h" + +// ITs-tizen-core.c +extern void ITc_tizen_core_startup(void); +extern void ITc_tizen_core_cleanup(void); +extern int ITc_tizen_core_init_shutdown_p(void); +extern int ITc_tizen_core_ready_p(void); +extern int ITc_tizen_core_task_create_destroy_p(void); +extern int ITc_tizen_core_task_run_p(void); +extern int ITc_tizen_core_task_is_running_p(void); +extern int ITc_tizen_core_task_quit_p(void); +extern int ITc_tizen_core_task_get_tizen_core_p(void); +extern int ITc_tizen_core_find_p(void); +extern int ITc_tizen_core_find_from_this_thread_p(void); +extern int ITc_tizen_core_add_idle_job_p(void); +extern int ITc_tizen_core_add_timer_p(void); +extern int ITc_tizen_core_add_channel_p(void); +extern int ITc_tizen_core_add_event_p(void); +//extern int ITc_tizen_core_emit_event_p(void); +extern int ITc_tizen_core_add_remove_source_p(void); +extern int ITc_tizen_core_source_create_destroy_p(void); +extern int ITc_tizen_core_source_add_remove_poll_p(void); +extern int ITc_tizen_core_source_set_prepare_cb_p(void); +extern int ITc_tizen_core_source_set_check_cb_p(void); +extern int ITc_tizen_core_source_set_dispatch_cb_p(void); +extern int ITc_tizen_core_source_set_finalize_cb_p(void); +extern int ITc_tizen_core_source_set_priority_p(void); +extern int ITc_tizen_core_poll_fd_create_destroy_p(void); +extern int ITc_tizen_core_poll_fd_set_get_fd_p(void); +extern int ITc_tizen_core_poll_fd_set_get_events_p(void); +extern int ITc_tizen_core_poll_fd_set_get_returned_events_p(void); + +// ITs-tizen-core-channel.c +extern void ITc_tizen_core_channel_startup(void); +extern void ITc_tizen_core_channel_cleanup(void); +extern int ITc_tizen_core_channel_make_pair_p(void); +extern int ITc_tizen_core_channel_sender_send_p(void); +extern int ITc_tizen_core_channel_sender_destroy_p(void); +extern int ITc_tizen_core_channel_sender_clone_p(void); +extern int ITc_tizen_core_channel_receiver_receive_p(void); +extern int ITc_tizen_core_channel_receiver_destroy_p(void); +extern int ITc_tizen_core_channel_object_create_destroy_p(void); +extern int ITc_tizen_core_channel_object_set_get_id_p(void); +extern int ITc_tizen_core_channel_object_set_get_data_p(void); +extern int ITc_tizen_core_channel_object_get_sender_task_name_p(void); + +// ITs-tizen-core-event.c +extern void ITc_tizen_core_event_startup(void); +extern void ITc_tizen_core_event_cleanup(void); +extern int ITc_tizen_core_event_create_destroy_p(void); +extern int ITc_tizen_core_event_add_remove_handler_p(void); +extern int ITc_tizen_core_event_emit_p(void); +extern int ITc_tizen_core_event_object_create_destroy_p(void); +extern int ITc_tizen_core_event_object_set_destroy_cb_p(void); +extern int ITc_tizen_core_event_object_get_id_p(void); +extern int ITc_tizen_core_event_object_get_data_p(void); + +testcase tc_array[] = { + // ITs-tizen-core.c + {"ITc_tizen_core_init_shutdown_p", ITc_tizen_core_init_shutdown_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + {"ITc_tizen_core_ready_p", ITc_tizen_core_ready_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + {"ITc_tizen_core_task_create_destroy_p", ITc_tizen_core_task_create_destroy_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_task_run_p", ITc_tizen_core_task_run_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_task_is_running_p", ITc_tizen_core_task_is_running_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_task_quit_p", ITc_tizen_core_task_quit_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_task_get_tizen_core_p",ITc_tizen_core_task_get_tizen_core_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + {"ITc_tizen_core_find_p", ITc_tizen_core_find_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + {"ITc_tizen_core_find_from_this_thread_p",ITc_tizen_core_find_from_this_thread_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + {"ITc_tizen_core_add_idle_job_p", ITc_tizen_core_add_idle_job_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_add_timer_p", ITc_tizen_core_add_timer_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_add_channel_p", ITc_tizen_core_add_channel_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_add_event_p", ITc_tizen_core_add_event_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, +// {"ITc_tizen_core_emit_event_p", ITc_tizen_core_emit_event_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_add_remove_source_p", ITc_tizen_core_add_remove_source_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_source_create_destroy_p", ITc_tizen_core_source_create_destroy_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_source_add_remove_poll_p", ITc_tizen_core_source_create_destroy_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_source_set_prepare_cb_p",ITc_tizen_core_source_set_prepare_cb_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + {"ITc_tizen_core_source_set_check_cb_p",ITc_tizen_core_source_set_check_cb_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + {"ITc_tizen_core_source_set_dispatch_cb_p",ITc_tizen_core_source_set_dispatch_cb_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + {"ITc_tizen_core_source_set_finalize_cb_p",ITc_tizen_core_source_set_finalize_cb_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + {"ITc_tizen_core_source_set_priority_p",ITc_tizen_core_source_set_priority_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + {"ITc_tizen_core_poll_fd_create_destroy_p", ITc_tizen_core_poll_fd_create_destroy_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_poll_fd_set_get_fd_p", ITc_tizen_core_poll_fd_set_get_fd_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_poll_fd_set_get_events_p", ITc_tizen_core_poll_fd_set_get_events_p,ITc_tizen_core_startup, ITc_tizen_core_cleanup}, + {"ITc_tizen_core_poll_fd_set_get_returned_events_p",ITc_tizen_core_poll_fd_set_get_returned_events_p, ITc_tizen_core_startup,ITc_tizen_core_cleanup}, + // ITs-tizen-core-channel.c + {"ITc_tizen_core_channel_make_pair_p", ITc_tizen_core_channel_make_pair_p,ITc_tizen_core_channel_startup, ITc_tizen_core_channel_cleanup}, + {"ITc_tizen_core_channel_sender_send_p",ITc_tizen_core_channel_sender_send_p, ITc_tizen_core_channel_startup,ITc_tizen_core_channel_cleanup}, + {"ITc_tizen_core_channel_sender_destroy_p",ITc_tizen_core_channel_sender_destroy_p, ITc_tizen_core_channel_startup,ITc_tizen_core_channel_cleanup}, + {"ITc_tizen_core_channel_sender_clone_p",ITc_tizen_core_channel_sender_clone_p, ITc_tizen_core_channel_startup,ITc_tizen_core_channel_cleanup}, + {"ITc_tizen_core_channel_receiver_receive_p",ITc_tizen_core_channel_receiver_receive_p, ITc_tizen_core_channel_startup,ITc_tizen_core_channel_cleanup}, + {"ITc_tizen_core_channel_receiver_destroy_p",ITc_tizen_core_channel_receiver_destroy_p, ITc_tizen_core_channel_startup,ITc_tizen_core_channel_cleanup}, + {"ITc_tizen_core_channel_object_create_destroy_p",ITc_tizen_core_channel_object_create_destroy_p, ITc_tizen_core_channel_startup,ITc_tizen_core_channel_cleanup}, + {"ITc_tizen_core_channel_object_set_get_id_p",ITc_tizen_core_channel_object_set_get_id_p, ITc_tizen_core_channel_startup,ITc_tizen_core_channel_cleanup}, + {"ITc_tizen_core_channel_object_set_get_data_p",ITc_tizen_core_channel_object_set_get_data_p, ITc_tizen_core_channel_startup,ITc_tizen_core_channel_cleanup}, + {"ITc_tizen_core_channel_object_get_sender_task_name_p",ITc_tizen_core_channel_object_get_sender_task_name_p,ITc_tizen_core_channel_startup, ITc_tizen_core_channel_cleanup}, + // ITs-tizen-core-event.c + {"ITc_tizen_core_event_create_destroy_p", ITc_tizen_core_event_create_destroy_p,ITc_tizen_core_event_startup, ITc_tizen_core_event_cleanup}, + {"ITc_tizen_core_event_add_remove_handler_p", ITc_tizen_core_event_add_remove_handler_p,ITc_tizen_core_event_startup, ITc_tizen_core_event_cleanup}, + {"ITc_tizen_core_event_emit_p", ITc_tizen_core_event_emit_p,ITc_tizen_core_event_startup, ITc_tizen_core_event_cleanup}, + {"ITc_tizen_core_event_object_create_destroy_p",ITc_tizen_core_event_object_create_destroy_p, ITc_tizen_core_event_startup,ITc_tizen_core_event_cleanup}, + {"ITc_tizen_core_event_object_set_destroy_cb_p",ITc_tizen_core_event_object_set_destroy_cb_p, ITc_tizen_core_event_startup,ITc_tizen_core_event_cleanup}, + {"ITc_tizen_core_event_object_get_id_p",ITc_tizen_core_event_object_get_id_p, ITc_tizen_core_event_startup,ITc_tizen_core_event_cleanup}, + {"ITc_tizen_core_event_object_get_data_p",ITc_tizen_core_event_object_get_data_p, ITc_tizen_core_event_startup,ITc_tizen_core_event_cleanup}, + {NULL, NULL}}; + +#endif // __TCT_TIZEN_CORE_NATIVE_H__ + +