From 6573c110c34c51eb5107877ddefe1d1fbdd64e8f Mon Sep 17 00:00:00 2001 From: Hwankyu Jhun Date: Thu, 1 Apr 2021 15:07:03 +0900 Subject: [PATCH] Add missing testcases to appcontrol unittests Change-Id: I2f02c628696751e841c59556f08640cd6d928e5d Signed-off-by: Hwankyu Jhun --- CMakeLists.txt | 3 + packaging/capi-appfw-app-control.spec | 3 +- test/unit_tests/CMakeLists.txt | 11 +- test/unit_tests/app_control_unittest.cc | 1445 ++++++++++++++++++++- test/unit_tests/mock/appcore_base_mock.cc | 30 + test/unit_tests/mock/appcore_base_mock.hh | 34 + test/unit_tests/mock/aul_mock.cc | 73 ++ test/unit_tests/mock/aul_mock.hh | 49 + test/unit_tests/mock/mock_hook.hh | 43 + test/unit_tests/mock/module_mock.hh | 25 + test/unit_tests/mock/test_fixture.cc | 21 + test/unit_tests/mock/test_fixture.hh | 55 + 12 files changed, 1770 insertions(+), 22 deletions(-) create mode 100644 test/unit_tests/mock/appcore_base_mock.cc create mode 100644 test/unit_tests/mock/appcore_base_mock.hh create mode 100644 test/unit_tests/mock/aul_mock.cc create mode 100644 test/unit_tests/mock/aul_mock.hh create mode 100644 test/unit_tests/mock/mock_hook.hh create mode 100644 test/unit_tests/mock/module_mock.hh create mode 100644 test/unit_tests/mock/test_fixture.cc create mode 100644 test/unit_tests/mock/test_fixture.hh diff --git a/CMakeLists.txt b/CMakeLists.txt index e3fdcb8..2751b1b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -26,6 +26,9 @@ SET(TARGET_APP_CONTROL_URI "capi-appfw-app-control-uri") ENABLE_TESTING() SET(TARGET_APP_CONTROL_UNIT_TEST "app-control-unit-test") +ADD_TEST(NAME ${TARGET_APP_CONTROL_UNIT_TEST} + COMMAND ${TARGET_APP_CONTROL_UNIT_TEST} + WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/test/unit_tests) INCLUDE(FindPkgConfig) INCLUDE(ApplyPkgConfig) diff --git a/packaging/capi-appfw-app-control.spec b/packaging/capi-appfw-app-control.spec index 4c5a51a..ddb1341 100644 --- a/packaging/capi-appfw-app-control.spec +++ b/packaging/capi-appfw-app-control.spec @@ -76,7 +76,8 @@ find . -name '*.gcno' -exec cp '{}' gcov-obj ';' %endif %check -ctest --output-on-failure %{?_smp_mflags} +export LD_LIBRARY_PATH="../../src/app-control:../../src/uri" +ctest --verbose %{?_smp_mflags} %if 0%{?gcov:1} lcov -c --ignore-errors graph --no-external -q -d . -o app_control.info genhtml app_control.info -o app_control.out diff --git a/test/unit_tests/CMakeLists.txt b/test/unit_tests/CMakeLists.txt index 061cd4c..73487cb 100644 --- a/test/unit_tests/CMakeLists.txt +++ b/test/unit_tests/CMakeLists.txt @@ -1,7 +1,10 @@ AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} APP_CONTROL_UNIT_TEST_SRCS) +AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/mock/ UNIT_TESTS_MOCK_SRCS) ADD_EXECUTABLE(${TARGET_APP_CONTROL_UNIT_TEST} - ${APP_CONTROL_UNIT_TEST_SRCS}) + ${APP_CONTROL_UNIT_TEST_SRCS} + ${UNIT_TESTS_MOCK_SRCS} +) TARGET_INCLUDE_DIRECTORIES(${TARGET_APP_CONTROL_UNIT_TEST} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../ @@ -20,7 +23,9 @@ APPLY_PKG_CONFIG(${TARGET_APP_CONTROL_UNIT_TEST} PUBLIC TARGET_LINK_LIBRARIES(${TARGET_APP_CONTROL_UNIT_TEST} PUBLIC ${TARGET_APP_CONTROL} ${TARGET_APP_CONTROL_URI}) -SET_TARGET_PROPERTIES(${TARGET_APP_CONTROL_TESTS} PROPERTIES COMPILE_FLAGS "-fPIE") -SET_TARGET_PROPERTIES(${TARGET_APP_CONTROL_TESTS} PROPERTIES LINK_FLAGS "-pie") +SET_TARGET_PROPERTIES(${TARGET_APP_CONTROL_TESTS} + PROPERTIES COMPILE_FLAGS "-fPIE") +SET_TARGET_PROPERTIES(${TARGET_APP_CONTROL_TESTS} + PROPERTIES LINK_FLAGS "-pie") INSTALL(TARGETS ${TARGET_APP_CONTROL_UNIT_TEST} DESTINATION bin) diff --git a/test/unit_tests/app_control_unittest.cc b/test/unit_tests/app_control_unittest.cc index 23964a0..3bfbd19 100644 --- a/test/unit_tests/app_control_unittest.cc +++ b/test/unit_tests/app_control_unittest.cc @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019 Samsung Electronics Co., Ltd. + * Copyright (c) 2019 - 2021 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. @@ -14,31 +14,257 @@ * limitations under the License. */ -#include +#include +#include +#include +#include +#include #include +#include +#include +#include #include #include +#include #include "include/app_control.h" +#include "include/app_control_internal.h" #include "include/app_control_uri.h" #include "src/uri/uri_internal.h" +#include "unit_tests/mock/appcore_base_mock.hh" +#include "unit_tests/mock/aul_mock.hh" +#include "unit_tests/mock/test_fixture.hh" + +using ::testing::_; +using ::testing::DoAll; +using ::testing::Return; +using ::testing::SetArgPointee; +using ::testing::Invoke; + +namespace { + +class CbInfo { + public: + CbInfo(bundle* b, int id, aul_svc_res_fn res_fn, aul_svc_err_cb err_cb, + void* data) + : b_(b), id_(id), res_fn_(res_fn), err_cb_(err_cb), data_(data) { + } + + bundle* b_; + int id_; + aul_svc_res_fn res_fn_; + aul_svc_err_cb err_cb_; + void* data_; +}; + +class ActionCbInfo { + public: + ActionCbInfo(std::string id, appcore_base_control_cb cb, void* data) + : id_(std::move(id)), cb_(cb), data_(data) { + } + + std::string id_; + appcore_base_control_cb cb_; + void* data_; +}; // The source of the following example is "https://en.wikipedia.org/wiki/Uniform_Resource_Identifier" -static const char EXAM_URI1[] = "https://john.doe@www.example.com:123"; -extern int gargc; -extern char** gargv; +constexpr const char EXAM_URI1[] = "https://john.doe@www.example.com:123"; + +int fake_aul_set_default_app_by_operation_AUL_R_OK(bundle* data) { + return AUL_R_OK; +} + +int fake_aul_set_default_app_by_operation_AUL_R_EILLACC(bundle* data) { + return AUL_R_EILLACC; +} + +int fake_aul_set_default_app_by_operation_AUL_R_ERROR(bundle* data) { + return AUL_R_ERROR; +} + +int fake_aul_unset_default_app_by_operation_AUL_R_OK(const char* app_id) { + return AUL_R_OK; +} + +int fake_aul_unset_default_app_by_operation_AUL_R_EILLACC(const char* app_id) { + return AUL_R_EILLACC; +} + +int fake_aul_unset_default_app_by_operation_AUL_R_ERROR(const char* app_id) { + return AUL_R_ERROR; +} + +int fake_aul_svc_run_service_for_uid_PID(bundle* data, int id, + aul_svc_res_fn res_fn, void* user_data, uid_t uid) { + return getpid(); +} + +int fake_aul_svc_run_service_for_uid_AUL_SVC_RET_EILLACC(bundle* data, int id, + aul_svc_res_fn res_fn, void* user_data, uid_t uid) { + return AUL_SVC_RET_EILLACC; +} + +int fake_aul_svc_run_service_for_uid_AUL_SVC_RET_ERROR(bundle* data, int id, + aul_svc_res_fn res_fn, void* user_data, uid_t uid) { + return AUL_SVC_RET_ERROR; +} + +int fake_aul_svc_subapp_terminate_request_AUL_SVC_RET_OK(bundle* b, int pid) { + return AUL_SVC_RET_OK; +} + +int fake_aul_svc_create_result_bundle_AUL_SVC_RET_OK(bundle* inb, + bundle** outb) { + *outb = bundle_dup(inb); + return AUL_SVC_RET_OK; +} + +int fake_aul_svc_create_result_bundle_AUL_SVC_RET_ERROR(bundle* inb, + bundle** outb) { + return AUL_SVC_RET_ERROR; +} + +int fake_aul_svc_send_result_AUL_SVC_RET_OK(bundle* b, + aul_svc_result_val result) { + return AUL_SVC_RET_OK; +} + +int fake_aul_svc_send_result_AUL_SVC_RET_EINVAL(bundle* b, + aul_svc_result_val result) { + return AUL_SVC_RET_EINVAL; +} + +int fake_aul_svc_send_result_AUL_SVC_RET_ERROR(bundle* b, + aul_svc_result_val result) { + return AUL_SVC_RET_ERROR; +} + +int fake_aul_svc_get_list_for_uid_AUL_SVC_RET_OK(bundle* b, + aul_svc_info_iter_fn iter_fn, void* data, uid_t uid) { + iter_fn("org.example.call", data); + return AUL_SVC_RET_OK; +} + +int fake_aul_svc_send_launch_request_for_uid_AUL_SVC_RET_OK(bundle *b, + int id, aul_svc_res_fn res_fn, aul_svc_err_cb err_cb, + void* user_data, uid_t uid) { + auto* info = new CbInfo(b, id, res_fn, err_cb, user_data); + g_idle_add([](gpointer data) -> gboolean { + auto* info = static_cast(data); + info->err_cb_(info->id_, getpid(), info->data_); + return G_SOURCE_REMOVE; + }, info); + g_idle_add([](gpointer data) -> gboolean { + auto* info = static_cast(data); + info->res_fn_(info->b_, info->id_, AUL_SVC_RES_OK, info->data_); + delete info; + return G_SOURCE_REMOVE; + }, info); + return AUL_SVC_RET_OK; +} + +int fake_aul_svc_send_launch_request_sync_for_uid_PID(bundle* b, + int id, bundle** reply_b, aul_svc_result_val* result, uid_t uid) { + *reply_b = bundle_dup(b); + *result = AUL_SVC_RES_OK; + return getpid(); +} -class AppControlTest : public testing::Test { +int fake_appcore_base_control_add_APPCORE_BASE_ERROR_NONE(const char* id, + appcore_base_control_cb callback, void* user_data, + appcore_base_control_h* h) { + auto* info = new ActionCbInfo(id, callback, user_data); + g_idle_add([](gpointer data) -> gboolean { + auto* info = static_cast(data); + bundle* b = bundle_create(); + info->cb_(b, info->data_); + bundle_free(b); + return G_SOURCE_REMOVE; + }, info); + *h = static_cast(info); + return APPCORE_BASE_ERROR_NONE; +} + +int fake_appcore_base_control_add_APPCORE_BASE_ERROR_INVALID_PARAMETER( + const char* id, appcore_base_control_cb callback, void* user_data, + appcore_base_control_h* h) { + return APPCORE_BASE_ERROR_INVALID_PARAMETER; +} + +int fake_appcore_base_control_add_APPCORE_BASE_ERROR_KEY_NOT_FOUND( + const char* id, appcore_base_control_cb callback, void* user_data, + appcore_base_control_h* h) { + return APPCORE_BASE_ERROR_KEY_NOT_FOUND; +} + +int fake_appcore_base_control_add_APPCORE_BASE_ERROR_IO_ERROR( + const char* id, appcore_base_control_cb callback, void* user_data, + appcore_base_control_h* h) { + return APPCORE_BASE_ERROR_IO_ERROR; +} + +int fake_appcore_base_control_remove_APPCORE_BASE_ERROR_NONE( + appcore_base_control_h h) { + auto* info = static_cast(h); + delete info; + return APPCORE_BASE_ERROR_NONE; +} + +int fake_aul_svc_send_resume_request_for_uid_AUL_SVC_RET_OK(bundle* b, + int id, aul_svc_err_cb err_cb, void* user_data, uid_t uid) { + auto* info = new CbInfo(b, id, nullptr, err_cb, user_data); + g_idle_add([](gpointer data) -> gboolean { + auto* info = static_cast(data); + info->err_cb_(info->id_, getpid(), info->data_); + delete info; + return G_SOURCE_REMOVE; + }, info); + return AUL_SVC_RET_OK; +} + +int fake_aul_prepare_app_defined_loader_LOADER_ID(const char* loader_name) { + return 22; +} + +} // namespace + +class Mocks : public ::testing::NiceMock, + public ::testing::NiceMock {}; + +class AppControlTest : public TestFixture { public: + AppControlTest() : TestFixture(std::make_unique()) {} + virtual ~AppControlTest() { + if (loop_ != nullptr) + g_main_loop_unref(loop_); + if (builder_ != nullptr) app_control_uri_builder_destroy(builder_); + if (uri_ != nullptr) app_control_uri_destroy(uri_); + + if (app_control_event_ != nullptr) + app_control_destroy(app_control_event_); + + if (app_control_ != nullptr) + app_control_destroy(app_control_); } virtual void SetUp() { + app_control_create(&app_control_); + bundle* data = nullptr; + app_control_to_bundle(app_control_, &data); + + app_control_create_event(data, &app_control_event_); + data = nullptr; + app_control_to_bundle(app_control_event_, &data); + bundle_add_str(data, AUL_K_CALLER_APPID, "org.example.caller"); + bundle_add_str(data, AUL_K_WAIT_RESULT, "1"); + app_control_uri_builder_create(&builder_); EXPECT_NE(builder_, nullptr); @@ -52,35 +278,61 @@ class AppControlTest : public testing::Test { app_control_uri_builder_build(builder_, &uri_); EXPECT_NE(uri_, nullptr); + + loop_ = g_main_loop_new(nullptr, FALSE); } virtual void TearDown() { - count_ = 0; + if (loop_ != nullptr) { + g_main_loop_unref(loop_); + loop_ = nullptr; + } if (builder_ != nullptr) { - auto builder = - std::unique_ptr( - builder_, app_control_uri_builder_destroy); + app_control_uri_builder_destroy(builder_); builder_ = nullptr; } + if (uri_ != nullptr) { - auto uri = std::unique_ptr(uri_, - app_control_uri_destroy); + app_control_uri_destroy(uri_); uri_ = nullptr; } + + if (app_control_event_ != nullptr) { + app_control_destroy(app_control_event_); + app_control_event_ = nullptr; + } + + if (app_control_ != nullptr) { + app_control_destroy(app_control_); + app_control_ = nullptr; + } } - app_control_uri_builder_h builder_; - app_control_uri_h uri_; - int count_ = 0; + void RunLoop() { + std::cout << "RunLoop()" << std::endl; + g_main_loop_run(loop_); + } + + void QuitLoop() { + std::cout << "QuitLoop()" << std::endl; + g_main_loop_quit(loop_); + } + + app_control_h app_control_ = nullptr; + app_control_h app_control_event_ = nullptr; + app_control_uri_builder_h builder_ = nullptr; + app_control_uri_h uri_ = nullptr; + GMainLoop* loop_ = nullptr; + int result_ = 0; }; /* - * @testcase app_control_create_from_uri_handle_p + * @testcase app_control_create_from_uri_handle_P * @description Creates a app_control handle from uri handle. * @apicovered app_control_create_from_uri_handle */ -TEST_F(AppControlTest, app_control_create_from_uri_handle_p) { +TEST_F(AppControlTest, app_control_create_from_uri_handle_P) { app_control_h app_control; int r = app_control_create_from_uri_handle(&app_control, uri_); EXPECT_EQ(r, APP_CONTROL_ERROR_NONE); @@ -100,12 +352,17 @@ TEST_F(AppControlTest, app_control_create_from_uri_handle_p) { EXPECT_EQ(std::string(value.get()), "networking"); } +TEST_F(AppControlTest, app_control_create_from_uri_handle_N) { + int ret= app_control_create_from_uri_handle(nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + /* * @testcase app_control_set_uri_by_handle_p * @description Sets uri data by uri handle. * @apicovered app_control_set_uri_by_handle */ -TEST_F(AppControlTest, app_control_set_uri_by_handle_p) { +TEST_F(AppControlTest, app_control_set_uri_by_handle_P) { app_control_h app_control; int r = app_control_create(&app_control); EXPECT_EQ(r, APP_CONTROL_URI_ERROR_NONE); @@ -122,3 +379,1155 @@ TEST_F(AppControlTest, app_control_set_uri_by_handle_p) { auto value = std::unique_ptr(v, std::free); EXPECT_EQ(std::string(value.get()), EXAM_URI1); } + +TEST_F(AppControlTest, app_control_set_uri_by_handle_N) { + int ret = app_control_set_uri_by_handle(nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_create_request_P) { + app_control_h app_control = nullptr; + int ret = app_control_create_request(nullptr, &app_control); + std::unique_ptr::type, + decltype(app_control_destroy)*> ptr(app_control, app_control_destroy); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_NE(app_control, nullptr); + + ptr.reset(nullptr); + app_control = nullptr; + + tizen_base::Bundle b; + ret = app_control_create_request(b.GetHandle(), &app_control); + ptr.reset(app_control); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_NE(app_control, nullptr); +} + +TEST_F(AppControlTest, app_control_create_request_N) { + int ret = app_control_create_request(nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_create_P) { + app_control_h app_control = nullptr;; + int ret = app_control_create(&app_control); + std::unique_ptr::type, + decltype(app_control_destroy)*> ptr(app_control, app_control_destroy); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_NE(app_control, nullptr); +} + +TEST_F(AppControlTest, app_control_create_N) { + int ret = app_control_create(nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_create_with_parameters_P) { + app_control_h app_control = nullptr; + int ret = app_control_create_with_parameters(&app_control, + APP_CONTROL_OPERATION_DEFAULT, EXAM_URI1, "*/*", nullptr, + "org.example.hello", APP_CONTROL_LAUNCH_MODE_GROUP, 2, + "key1", "value1", "key2", "value2"); + std::unique_ptr::type, + decltype(app_control_destroy)*> ptr(app_control, app_control_destroy); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_NE(app_control, nullptr); + + char* operation = nullptr; + ret = app_control_get_operation(app_control, &operation); + std::unique_ptr operation_ptr( + operation, std::free); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(std::string(APP_CONTROL_OPERATION_DEFAULT), std::string(operation)); + + char* uri = nullptr; + ret = app_control_get_uri(app_control, &uri); + std::unique_ptr uri_ptr(uri, std::free); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(std::string(EXAM_URI1), std::string(uri)); + + char* mime = nullptr; + ret = app_control_get_mime(app_control, &mime); + std::unique_ptr mime_ptr(mime, std::free); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(std::string("*/*"), std::string(mime)); + + char* app_id = nullptr; + ret = app_control_get_app_id(app_control, &app_id); + std::unique_ptr app_id_ptr(app_id, std::free); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(std::string("org.example.hello"), std::string(app_id)); + + app_control_launch_mode_e launch_mode; + ret = app_control_get_launch_mode(app_control, &launch_mode); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(launch_mode, APP_CONTROL_LAUNCH_MODE_GROUP); + + char* value1 = nullptr; + ret = app_control_get_extra_data(app_control, "key1", &value1); + std::unique_ptr value1_ptr(value1, std::free); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(std::string(value1), std::string("value1")); + + char* value2 = nullptr; + ret = app_control_get_extra_data(app_control, "key2", &value2); + std::unique_ptr value2_ptr(value2, std::free); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(std::string(value2), std::string("value2")); +} + +TEST_F(AppControlTest, app_control_create_with_parameters_N) { + int ret = app_control_create_with_parameters(nullptr, + nullptr, nullptr, nullptr, nullptr, nullptr, + APP_CONTROL_LAUNCH_MODE_GROUP, 0); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_create_event_P) { + tizen_base::Bundle b; + app_control_h app_control = nullptr; + int ret = app_control_create_event(b.GetHandle(), &app_control); + std::unique_ptr::type, + decltype(app_control_destroy)*> ptr(app_control, app_control_destroy); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_NE(app_control, nullptr); +} + +TEST_F(AppControlTest, app_control_create_event_N) { + int ret = app_control_create_event(nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_destroy_P) { + int ret = app_control_destroy(app_control_); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + app_control_ = nullptr; +} + +TEST_F(AppControlTest, app_control_destroy_N) { + int ret = app_control_destroy(nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_to_bundle_P) { + int ret = app_control_add_extra_data(app_control_, "key", "value"); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + + bundle* data = nullptr; + ret = app_control_to_bundle(app_control_, &data); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + + char* value = nullptr; + ret = bundle_get_str(data, "key", &value); + EXPECT_EQ(ret, BUNDLE_ERROR_NONE); + EXPECT_EQ(std::string(value), std::string("value")); +} + +TEST_F(AppControlTest, app_control_to_bundle_N) { + int ret= app_control_to_bundle(nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_set_operation_P) { + int ret = app_control_set_operation(app_control_, + APP_CONTROL_OPERATION_DEFAULT); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + + char* operation = nullptr; + ret = app_control_get_operation(app_control_, &operation); + std::unique_ptr operation_ptr( + operation, std::free); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(std::string(operation), std::string(APP_CONTROL_OPERATION_DEFAULT)); + + ret = app_control_set_operation(app_control_, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + operation_ptr.reset(nullptr); + operation = nullptr; + + ret = app_control_get_operation(app_control_, &operation); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(operation, nullptr); +} + +TEST_F(AppControlTest, app_control_set_operation_N) { + int ret = app_control_set_operation(nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_get_operation_P) { + int ret = app_control_set_operation(app_control_, + APP_CONTROL_OPERATION_MAIN); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + + char* operation = nullptr; + ret = app_control_get_operation(app_control_, &operation); + std::unique_ptr operation_ptr( + operation, std::free); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(std::string(operation), std::string(APP_CONTROL_OPERATION_MAIN)); +} + +TEST_F(AppControlTest, app_control_get_operation_N) { + int ret = app_control_get_operation(nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_set_uri_P) { + int ret = app_control_set_uri(app_control_, EXAM_URI1); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + + char* uri = nullptr; + ret = app_control_get_uri(app_control_, &uri); + std::unique_ptr uri_ptr(uri, std::free); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(std::string(uri), std::string(EXAM_URI1)); + + ret = app_control_set_uri(app_control_, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + uri_ptr.reset(nullptr); + uri = nullptr; + + ret = app_control_get_uri(app_control_, &uri); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(uri, nullptr); +} + +TEST_F(AppControlTest, app_control_set_uri_N) { + int ret = app_control_set_uri(nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_get_uri_P) { + int ret = app_control_set_uri(app_control_, EXAM_URI1); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + + char* uri = nullptr; + ret = app_control_get_uri(app_control_, &uri); + std::unique_ptr uri_ptr(uri, std::free); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(std::string(uri), std::string(EXAM_URI1)); +} + +TEST_F(AppControlTest, app_control_get_uri_N) { + int ret = app_control_get_uri(nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_set_mime_P) { + int ret = app_control_set_mime(app_control_, "application/octet-stream"); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + + char* mime = nullptr; + ret = app_control_get_mime(app_control_, &mime); + std::unique_ptr mime_ptr(mime, std::free); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(std::string(mime), std::string("application/octet-stream")); + + ret = app_control_set_mime(app_control_, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + mime_ptr.reset(nullptr); + mime = nullptr; + + ret = app_control_get_mime(app_control_, &mime); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(mime, nullptr); +} + +TEST_F(AppControlTest, app_control_set_mime_N) { + int ret = app_control_set_mime(nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_get_mime_P) { + int ret = app_control_set_mime(app_control_, "application/octet-stream"); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + + char* mime = nullptr; + ret = app_control_get_mime(app_control_, &mime); + std::unique_ptr mime_ptr(mime, std::free); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(std::string(mime), std::string("application/octet-stream")); +} + +TEST_F(AppControlTest, app_control_get_mime_N) { + int ret = app_control_get_mime(nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_set_category_P) { + int ret = app_control_set_category(app_control_, + "http://tizen.org/category/wearable_clock"); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + + char* category = nullptr; + ret = app_control_get_category(app_control_, &category); + std::unique_ptr category_ptr(category, std::free); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(std::string(category), "http://tizen.org/category/wearable_clock"); + + ret = app_control_set_category(app_control_, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + category_ptr.reset(nullptr); + category = nullptr; + + ret = app_control_get_category(app_control_, &category); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(category, nullptr); +} + +TEST_F(AppControlTest, app_control_set_category_N) { + int ret = app_control_set_category(nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_get_category_P) { + int ret = app_control_set_category(app_control_, + "http://tizen.org/category/wearable_clock"); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + + char* category = nullptr; + ret = app_control_get_category(app_control_, &category); + std::unique_ptr category_ptr(category, std::free); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(std::string(category), "http://tizen.org/category/wearable_clock"); +} + +TEST_F(AppControlTest, app_control_get_category_N) { + int ret = app_control_get_category(nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_set_app_id_P) { + int ret = app_control_set_app_id(app_control_, "org.example.hello"); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + + char* app_id = nullptr; + ret = app_control_get_app_id(app_control_, &app_id); + std::unique_ptr ptr(app_id, std::free); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(std::string(app_id), "org.example.hello"); + + ret = app_control_set_app_id(app_control_, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + ptr.reset(nullptr); + app_id = nullptr; + + ret = app_control_get_app_id(app_control_, &app_id); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(app_id, nullptr); +} + +TEST_F(AppControlTest, app_control_set_app_id_N) { + int ret = app_control_set_app_id(nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_get_app_id_P) { + int ret = app_control_set_app_id(app_control_, "org.example.hello"); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + + char* app_id = nullptr; + ret = app_control_get_app_id(app_control_, &app_id); + std::unique_ptr ptr(app_id, std::free); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(std::string(app_id), "org.example.hello"); +} + +TEST_F(AppControlTest, app_control_get_app_id_N) { + int ret = app_control_get_app_id(nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_clone_P) { + int ret = app_control_add_extra_data(app_control_, "key", "value"); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + + app_control_h handle = nullptr; + ret = app_control_clone(&handle, app_control_); + std::unique_ptr::type, + decltype(app_control_destroy)*> ptr(handle, app_control_destroy); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + + char* extra_data = nullptr; + ret = app_control_get_extra_data(handle, "key", &extra_data); + std::unique_ptr extra_data_ptr( + extra_data, std::free); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(std::string(extra_data), "value"); +} + +TEST_F(AppControlTest, app_control_clone_N) { + int ret = app_control_clone(nullptr, app_control_); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_set_launch_mode_P) { + int ret = app_control_set_launch_mode(app_control_, + APP_CONTROL_LAUNCH_MODE_GROUP); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + + app_control_launch_mode_e mode; + ret = app_control_get_launch_mode(app_control_, &mode); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(mode, APP_CONTROL_LAUNCH_MODE_GROUP); +} + +TEST_F(AppControlTest, app_control_set_launch_mode_N) { + int ret = app_control_set_launch_mode(nullptr, APP_CONTROL_LAUNCH_MODE_GROUP); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_get_launch_mode_P) { + app_control_launch_mode_e mode; + int ret = app_control_get_launch_mode(app_control_, &mode); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(mode, APP_CONTROL_LAUNCH_MODE_SINGLE); +} + +TEST_F(AppControlTest, app_control_get_launch_mode_N) { + int ret = app_control_get_launch_mode(nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_set_defapp_P) { + EXPECT_CALL(GetMock(), aul_set_default_app_by_operation(_)). + WillOnce(Invoke(fake_aul_set_default_app_by_operation_AUL_R_OK)); + + int ret = app_control_set_defapp(app_control_, "org.example.hello"); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); +} + +TEST_F(AppControlTest, app_control_set_defapp_N) { + int ret = app_control_set_defapp(nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); + + EXPECT_CALL(GetMock(), aul_set_default_app_by_operation(_)). + WillOnce(Invoke(fake_aul_set_default_app_by_operation_AUL_R_EILLACC)); + ret = app_control_set_defapp(app_control_, "org.example.hello"); + EXPECT_EQ(ret, APP_CONTROL_ERROR_PERMISSION_DENIED); + + EXPECT_CALL(GetMock(), aul_set_default_app_by_operation(_)). + WillOnce(Invoke(fake_aul_set_default_app_by_operation_AUL_R_ERROR)); + ret = app_control_set_defapp(app_control_, "org.example.hello"); + EXPECT_EQ(ret, APP_CONTROL_ERROR_IO_ERROR); +} + +TEST_F(AppControlTest, app_control_unset_defapp_P) { + EXPECT_CALL(GetMock(), aul_unset_default_app_by_operation(_)). + WillOnce(Invoke(fake_aul_unset_default_app_by_operation_AUL_R_OK)); + + int ret = app_control_unset_defapp("org.example.hello"); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); +} + +TEST_F(AppControlTest, app_control_unset_defapp_N) { + int ret = app_control_unset_defapp(nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); + + EXPECT_CALL(GetMock(), aul_unset_default_app_by_operation(_)). + WillOnce(Invoke(fake_aul_unset_default_app_by_operation_AUL_R_EILLACC)); + ret = app_control_unset_defapp("org.example.hello"); + EXPECT_EQ(ret, APP_CONTROL_ERROR_PERMISSION_DENIED); + + EXPECT_CALL(GetMock(), aul_unset_default_app_by_operation(_)). + WillOnce(Invoke(fake_aul_unset_default_app_by_operation_AUL_R_ERROR)); + ret = app_control_unset_defapp("org.example.hello"); + EXPECT_EQ(ret, APP_CONTROL_ERROR_IO_ERROR); +} + +TEST_F(AppControlTest, app_control_send_launch_request_P) { + int ret = app_control_set_app_id(app_control_, "org.example.hello"); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + + EXPECT_CALL(GetMock(), aul_svc_run_service_for_uid(_, _, _, _, _)). + WillOnce(Invoke(fake_aul_svc_run_service_for_uid_PID)); + ret = app_control_send_launch_request(app_control_, + [](app_control_h request, app_control_h reply, + app_control_result_e result, void* user_data) { + }, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); +} + +TEST_F(AppControlTest, app_control_send_launch_request_N) { + int ret = app_control_send_launch_request(nullptr, nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); + + ret = app_control_send_launch_request(app_control_, nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_APP_NOT_FOUND); + + app_control_set_app_id(app_control_, "org.example.hello"); + + EXPECT_CALL(GetMock(), aul_svc_run_service_for_uid(_, _, _, _, _)). + WillOnce(Invoke(fake_aul_svc_run_service_for_uid_AUL_SVC_RET_EILLACC)); + ret = app_control_send_launch_request(app_control_, nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_PERMISSION_DENIED); + + EXPECT_CALL(GetMock(), aul_svc_run_service_for_uid(_, _, _, _, _)). + WillOnce(Invoke(fake_aul_svc_run_service_for_uid_AUL_SVC_RET_ERROR)); + ret = app_control_send_launch_request(app_control_, nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_LAUNCH_REJECTED); + + app_control_set_operation(app_control_, + APP_CONTROL_OPERATION_LAUNCH_ON_EVENT); + ret = app_control_send_launch_request(app_control_, nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_LAUNCH_REJECTED); +} + +TEST_F(AppControlTest, app_control_send_terminate_request_P) { + EXPECT_CALL(GetMock(), aul_svc_run_service_for_uid(_, _, _, _, _)). + WillOnce(Invoke(fake_aul_svc_run_service_for_uid_PID)); + app_control_set_app_id(app_control_, "org.example.hello"); + app_control_send_launch_request(app_control_, nullptr, nullptr); + + EXPECT_CALL(GetMock(), aul_svc_subapp_terminate_request(_, _)). + WillOnce(Invoke(fake_aul_svc_subapp_terminate_request_AUL_SVC_RET_OK)); + + int ret = app_control_send_terminate_request(app_control_); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); +} + +TEST_F(AppControlTest, app_control_send_terminate_request_N) { + int ret = app_control_send_terminate_request(nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); + + ret = app_control_send_terminate_request(app_control_); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_reply_to_launch_request_P) { + app_control_h reply = nullptr; + int ret = app_control_create(&reply); + std::unique_ptr::type, + decltype(app_control_destroy)*> ptr(reply, app_control_destroy); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + + app_control_add_extra_data(reply, "key", "value"); + const char* value_array[] = { "value1", "value2" }; + app_control_add_extra_data_array(reply, "key_array", value_array, 2); + + EXPECT_CALL(GetMock(), aul_svc_create_result_bundle(_, _)). + WillOnce(Invoke(fake_aul_svc_create_result_bundle_AUL_SVC_RET_OK)); + EXPECT_CALL(GetMock(), aul_svc_send_result(_, _)). + WillOnce(Invoke(fake_aul_svc_send_result_AUL_SVC_RET_OK)); + + ret = app_control_reply_to_launch_request(app_control_, reply, + APP_CONTROL_RESULT_SUCCEEDED); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); +} + +TEST_F(AppControlTest, app_control_reply_to_launch_request_N) { + int ret = app_control_reply_to_launch_request(nullptr, nullptr, + APP_CONTROL_RESULT_SUCCEEDED); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); + + app_control_h reply = nullptr; + app_control_create(&reply); + std::unique_ptr::type, + decltype(app_control_destroy)*> ptr(reply, app_control_destroy); + + ret = app_control_reply_to_launch_request(app_control_, reply, + APP_CONTROL_RESULT_APP_STARTED); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); + + EXPECT_CALL(GetMock(), aul_svc_create_result_bundle(_, _)). + WillOnce(Invoke(fake_aul_svc_create_result_bundle_AUL_SVC_RET_ERROR)); + ret = app_control_reply_to_launch_request(app_control_, reply, + APP_CONTROL_RESULT_SUCCEEDED); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); + + EXPECT_CALL(GetMock(), aul_svc_create_result_bundle(_, _)). + WillOnce(Invoke(fake_aul_svc_create_result_bundle_AUL_SVC_RET_OK)); + EXPECT_CALL(GetMock(), aul_svc_send_result(_, _)). + WillOnce(Invoke(fake_aul_svc_send_result_AUL_SVC_RET_EINVAL)); + ret = app_control_reply_to_launch_request(app_control_, reply, + APP_CONTROL_RESULT_SUCCEEDED); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); + + EXPECT_CALL(GetMock(), aul_svc_create_result_bundle(_, _)). + WillOnce(Invoke(fake_aul_svc_create_result_bundle_AUL_SVC_RET_OK)); + EXPECT_CALL(GetMock(), aul_svc_send_result(_, _)). + WillOnce(Invoke(fake_aul_svc_send_result_AUL_SVC_RET_ERROR)); + ret = app_control_reply_to_launch_request(app_control_, reply, + APP_CONTROL_RESULT_SUCCEEDED); + EXPECT_EQ(ret, APP_CONTROL_ERROR_LAUNCH_REJECTED); +} + +TEST_F(AppControlTest, app_control_add_extra_data_P) { + int ret = app_control_add_extra_data(app_control_, "key", "value"); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + + char* value = nullptr; + ret = app_control_get_extra_data(app_control_, "key", &value); + std::unique_ptr ptr(value, std::free); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(std::string(value), "value"); +} + +TEST_F(AppControlTest, app_control_add_extra_data_N) { + int ret = app_control_add_extra_data(nullptr, nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); + + ret = app_control_add_extra_data(app_control_, "", ""); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); + + ret = app_control_add_extra_data(app_control_, "__AUL_K", "value"); + EXPECT_EQ(ret, APP_CONTROL_ERROR_KEY_REJECTED); +} + +TEST_F(AppControlTest, app_control_add_extra_data_array_P) { + const char* array_value[] = { "value1", "value2", "value3" }; + int ret = app_control_add_extra_data_array(app_control_, "array_key", + array_value, 3); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + + char** value = nullptr; + int length = 0; + ret = app_control_get_extra_data_array(app_control_, "array_key", &value, + &length); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(length, 3); + EXPECT_EQ(std::string(value[0]), "value1"); + EXPECT_EQ(std::string(value[1]), "value2"); + EXPECT_EQ(std::string(value[2]), "value3"); + + for (int i = 0; i < length; ++i) + std::free(value[i]); + std::free(value); +} + +TEST_F(AppControlTest, app_control_add_extra_data_array_N) { + int ret = app_control_add_extra_data_array(nullptr, nullptr, nullptr, 0); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); + + ret = app_control_add_extra_data_array(app_control_, "array_key", nullptr, 0); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); + + const char* array_value[] = { "value1", "value2", "value3" }; + ret = app_control_add_extra_data_array(app_control_, "__AUL_K", + array_value, 3); + EXPECT_EQ(ret, APP_CONTROL_ERROR_KEY_REJECTED); +} + +TEST_F(AppControlTest, app_control_remove_extra_data_P) { + app_control_add_extra_data(app_control_, "key", "value"); + const char* array_value[] = { "value1", "value2", "value3" }; + app_control_add_extra_data_array(app_control_, "array_key", array_value, 3); + + int ret = app_control_remove_extra_data(app_control_, "key"); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + + ret = app_control_remove_extra_data(app_control_, "array_key"); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); +} + +TEST_F(AppControlTest, app_control_remove_extra_data_N) { + int ret = app_control_remove_extra_data(nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); + + ret = app_control_remove_extra_data(app_control_, "__AUL_K"); + EXPECT_EQ(ret, APP_CONTROL_ERROR_KEY_REJECTED); + + ret = app_control_remove_extra_data(app_control_, "key"); + EXPECT_EQ(ret, APP_CONTROL_ERROR_KEY_NOT_FOUND); +} + +TEST_F(AppControlTest, app_control_get_extra_data_P) { + int ret = app_control_add_extra_data(app_control_, "key", "value"); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + + char* value = nullptr; + ret = app_control_get_extra_data(app_control_, "key", &value); + std::unique_ptr ptr(value, std::free); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(std::string(value), "value"); +} + +TEST_F(AppControlTest, app_control_get_extra_data_N) { + int ret = app_control_get_extra_data(nullptr, nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); + + char* value = nullptr; + ret = app_control_get_extra_data(app_control_, "__AUL_K", &value); + EXPECT_EQ(ret, APP_CONTROL_ERROR_KEY_REJECTED); + + ret = app_control_get_extra_data(app_control_, "key", &value); + EXPECT_EQ(ret, APP_CONTROL_ERROR_KEY_NOT_FOUND); +} + +TEST_F(AppControlTest, app_control_get_extra_data_array_P) { + const char* array_value[] = { "value1", "value2", "value3" }; + int ret = app_control_add_extra_data_array(app_control_, "array_key", + array_value, 3); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + + char** value = nullptr; + int length = 0; + ret = app_control_get_extra_data_array(app_control_, "array_key", &value, + &length); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(length, 3); + EXPECT_EQ(std::string(value[0]), "value1"); + EXPECT_EQ(std::string(value[1]), "value2"); + EXPECT_EQ(std::string(value[2]), "value3"); + + for (int i = 0; i < length; ++i) + std::free(value[i]); + std::free(value); +} + +TEST_F(AppControlTest, app_control_get_extra_data_array_N) { + int ret = app_control_get_extra_data_array(nullptr, nullptr, nullptr, + nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); + + ret = app_control_get_extra_data_array(app_control_, "array_key", nullptr, + nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); + + char** value = nullptr; + int length = 0; + ret = app_control_get_extra_data_array(app_control_, "__AUL_K", &value, + &length); + EXPECT_EQ(ret, APP_CONTROL_ERROR_KEY_REJECTED); + + ret = app_control_get_extra_data_array(app_control_, "array_key", &value, + &length); + EXPECT_EQ(ret, APP_CONTROL_ERROR_KEY_NOT_FOUND); +} + +TEST_F(AppControlTest, app_control_is_extra_data_array_P) { + const char* array_value[] = { "value1", "value2", "value3" }; + app_control_add_extra_data_array(app_control_, "array_key", array_value, 3); + app_control_add_extra_data(app_control_, "key", "value"); + + bool array = false; + int ret = app_control_is_extra_data_array(app_control_, "array_key", &array); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(array, true); + + ret = app_control_is_extra_data_array(app_control_, "key", &array); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(array, false); +} + +TEST_F(AppControlTest, app_control_is_extra_data_array_N) { + int ret = app_control_is_extra_data_array(nullptr, nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); + + bool array = false; + ret = app_control_is_extra_data_array(app_control_, "__AUL_K", &array); + EXPECT_EQ(ret, APP_CONTROL_ERROR_KEY_REJECTED); +} + +TEST_F(AppControlTest, app_control_foreach_extra_data_P) { + app_control_add_extra_data(app_control_, "key1", "value1"); + app_control_add_extra_data(app_control_, "key2", "value2"); + app_control_add_extra_data(app_control_, "key3", "value3"); + + int count = 0; + int ret = app_control_foreach_extra_data(app_control_, + [](app_control_h handle, const char* key, void* user_data) -> bool { + int* count = static_cast(user_data); + (*count)++; + return true; + }, static_cast(&count)); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(count, 3); +} + +TEST_F(AppControlTest, app_control_foreach_extra_data_N) { + int ret = app_control_foreach_extra_data(nullptr, nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_foreach_app_matched_P) { + app_control_set_operation(app_control_, APP_CONTROL_OPERATION_CALL); + app_control_set_uri(app_control_, "tel:010-2345-6789"); + + EXPECT_CALL(GetMock(), aul_svc_get_list_for_uid(_, _, _, _)). + WillOnce(Invoke(fake_aul_svc_get_list_for_uid_AUL_SVC_RET_OK)); + + bool touch = false; + int ret = app_control_foreach_app_matched(app_control_, + [](app_control_h handle, const char* app_id, void* user_data) -> bool { + bool* touch = static_cast(user_data); + *touch = true; + return true; + }, static_cast(&touch)); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(touch, true); +} + +TEST_F(AppControlTest, app_control_foreach_app_matched_N) { + int ret = app_control_foreach_app_matched(nullptr, nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_get_caller_P) { + char* caller = nullptr; + int ret = app_control_get_caller(app_control_event_, &caller); + std::unique_ptr ptr(caller, std::free); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(std::string(caller), "org.example.caller"); +} + +TEST_F(AppControlTest, app_control_get_caller_N) { + int ret = app_control_get_caller(nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); + + char* caller = nullptr; + ret = app_control_get_caller(app_control_, &caller); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_is_reply_requested_P) { + bool requested = false; + int ret = app_control_is_reply_requested(app_control_event_, &requested); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(requested, true); +} + +TEST_F(AppControlTest, app_control_is_reply_requested_N) { + int ret = app_control_is_reply_requested(nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); + + bool requested = false; + ret = app_control_is_reply_requested(app_control_, &requested); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_import_from_bundle_P) { + bundle* data = bundle_create(); + std::unique_ptr ptr(data, bundle_free); + EXPECT_NE(data, nullptr); + int ret = bundle_add_str(data, "key", "value"); + EXPECT_EQ(ret, BUNDLE_ERROR_NONE); + + ret = app_control_import_from_bundle(app_control_, data); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + + char* value = nullptr; + ret = app_control_get_extra_data(app_control_, "key", &value); + std::unique_ptr value_ptr(value, std::free); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(std::string(value), "value"); +} + +TEST_F(AppControlTest, app_control_import_from_bundle_N) { + int ret = app_control_import_from_bundle(nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_export_as_bundle_P) { + app_control_add_extra_data(app_control_, "key1", "value1"); + app_control_add_extra_data(app_control_, "key2", "value2"); + app_control_add_extra_data(app_control_, "key3", "value3"); + + bundle* data = nullptr; + int ret = app_control_export_as_bundle(app_control_, &data); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_NE(data, nullptr); + + char* value1 = nullptr; + char* value2 = nullptr; + char* value3 = nullptr; + bundle_get_str(data, "key1", &value1); + EXPECT_EQ(std::string(value1), "value1"); + bundle_get_str(data, "key2", &value2); + EXPECT_EQ(std::string(value2), "value2"); + bundle_get_str(data, "key3", &value3); + EXPECT_EQ(std::string(value3), "value3"); +} + +TEST_F(AppControlTest, app_control_export_as_bundle_N) { + int ret = app_control_export_as_bundle(nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_enable_app_started_result_event_P) { + int ret = app_control_enable_app_started_result_event(app_control_); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); +} + +TEST_F(AppControlTest, app_control_enable_app_started_result_event_N) { + int ret = app_control_enable_app_started_result_event(nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_set_instance_id_P) { + int ret = app_control_set_instance_id(app_control_, + "instance@org.example.hello"); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + + char* instance_id = nullptr; + ret = app_control_get_instance_id(app_control_, &instance_id); + std::unique_ptr ptr(instance_id, std::free); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(std::string(instance_id), "instance@org.example.hello"); +} + +TEST_F(AppControlTest, app_control_set_instance_id_N) { + int ret = app_control_set_instance_id(nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_get_instance_id_P) { + int ret = app_control_set_instance_id(app_control_, + "instance@org.example.hello"); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + + char* instance_id = nullptr; + ret = app_control_get_instance_id(app_control_, &instance_id); + std::unique_ptr ptr(instance_id, std::free); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(std::string(instance_id), "instance@org.example.hello"); +} + +TEST_F(AppControlTest, app_control_get_instance_id_N) { + int ret = app_control_get_instance_id(nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); + + char* instance_id = nullptr; + ret = app_control_get_instance_id(app_control_, &instance_id); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_send_launch_request_async_P) { + EXPECT_CALL(GetMock(), + aul_svc_send_launch_request_for_uid(_, _, _, _, _, _)). + WillOnce(Invoke( + fake_aul_svc_send_launch_request_for_uid_AUL_SVC_RET_OK)); + + app_control_set_app_id(app_control_, "org.example.hello"); + g_idle_add([](gpointer data) -> gboolean { + auto* handle = static_cast(data); + handle->result_ = app_control_send_launch_request_async( + handle->app_control_, + [](app_control_h request, app_control_error_e result, + void* user_data) { + std::cout << "app_control_result_cb()" << std::endl; + }, + [](app_control_h request, app_control_h reply, + app_control_result_e result, void* user_data) { + std::cout << "app_control_reply_cb()" << std::endl; + auto* handle = static_cast(user_data); + handle->QuitLoop(); + }, data); + return G_SOURCE_REMOVE; + }, this); + RunLoop(); + EXPECT_EQ(result_, APP_CONTROL_ERROR_NONE); +} + +TEST_F(AppControlTest, app_control_send_launch_request_async_N) { + int ret = app_control_send_launch_request_async(nullptr, nullptr, nullptr, + nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_send_launch_request_sync_P) { + EXPECT_CALL(GetMock(), + aul_svc_send_launch_request_sync_for_uid(_, _, _, _, _)). + WillOnce(Invoke(fake_aul_svc_send_launch_request_sync_for_uid_PID)); + + app_control_set_app_id(app_control_, "org.example.hello"); + + app_control_h reply = nullptr; + app_control_result_e result; + int ret = app_control_send_launch_request_sync(app_control_, &reply, &result); + std::unique_ptr::type, + decltype(app_control_destroy)*> ptr(reply, app_control_destroy); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_NE(reply, nullptr); + EXPECT_EQ(result, APP_CONTROL_RESULT_SUCCEEDED); +} + +TEST_F(AppControlTest, app_control_send_launch_request_sync_N) { + int ret = app_control_send_launch_request_sync(nullptr, nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_add_action_handler_P) { + EXPECT_CALL(GetMock(), appcore_base_control_add(_, _, _, _)). + WillOnce(Invoke(fake_appcore_base_control_add_APPCORE_BASE_ERROR_NONE)); + EXPECT_CALL(GetMock(), appcore_base_control_remove(_)). + WillOnce(Invoke(fake_appcore_base_control_remove_APPCORE_BASE_ERROR_NONE)); + + result_ = -1; + app_control_action_h handle = nullptr; + int ret = app_control_add_action_handler("action", + [](const char* action, app_control_h app_control, void* user_data) { + auto* handle = static_cast(user_data); + handle->result_ = 0; + handle->QuitLoop(); + }, this, &handle); + std::unique_ptr::type, + decltype(app_control_remove_action_handler)*> ptr( + handle, app_control_remove_action_handler); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + RunLoop(); + EXPECT_EQ(result_, 0); +} + +TEST_F(AppControlTest, app_control_add_action_handler_N) { + int ret = app_control_add_action_handler(nullptr, nullptr, nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); + + EXPECT_CALL(GetMock(), appcore_base_control_add(_, _, _, _)). + WillOnce(Invoke( + fake_appcore_base_control_add_APPCORE_BASE_ERROR_INVALID_PARAMETER)); + app_control_action_h handle = nullptr; + ret = app_control_add_action_handler("action", + [](const char* action, app_control_h app_control, void* user_data) { + }, this, &handle); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); + + EXPECT_CALL(GetMock(), appcore_base_control_add(_, _, _, _)). + WillOnce(Invoke( + fake_appcore_base_control_add_APPCORE_BASE_ERROR_KEY_NOT_FOUND)); + ret = app_control_add_action_handler("action", + [](const char* action, app_control_h app_control, void* user_data) { + }, this, &handle); + EXPECT_EQ(ret, APP_CONTROL_ERROR_KEY_NOT_FOUND); + + EXPECT_CALL(GetMock(), appcore_base_control_add(_, _, _, _)). + WillOnce(Invoke( + fake_appcore_base_control_add_APPCORE_BASE_ERROR_IO_ERROR)); + ret = app_control_add_action_handler("action", + [](const char* action, app_control_h app_control, void* user_data) { + }, this, &handle); + EXPECT_EQ(ret, APP_CONTROL_ERROR_IO_ERROR); +} + +TEST_F(AppControlTest, app_control_remove_action_handler_P) { + EXPECT_CALL(GetMock(), appcore_base_control_add(_, _, _, _)). + WillOnce(Invoke(fake_appcore_base_control_add_APPCORE_BASE_ERROR_NONE)); + EXPECT_CALL(GetMock(), appcore_base_control_remove(_)). + WillOnce(Invoke(fake_appcore_base_control_remove_APPCORE_BASE_ERROR_NONE)); + + app_control_action_h handle = nullptr; + app_control_add_action_handler("action", + [](const char* action, app_control_h app_control, void* user_data) { + auto* handle = static_cast(user_data); + handle->QuitLoop(); + }, this, &handle); + RunLoop(); + + int ret = app_control_remove_action_handler(handle); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); +} + +TEST_F(AppControlTest, app_control_remove_action_handler_N) { + int ret = app_control_remove_action_handler(nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_set_caller_instance_id_P) { + int ret = app_control_set_caller_instance_id(app_control_, "instance"); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + + ret = app_control_set_caller_instance_id(app_control_, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); +} + +TEST_F(AppControlTest, app_control_set_caller_instance_id_N) { + int ret = app_control_set_caller_instance_id(nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_set_component_id_P) { + int ret = app_control_set_component_id(app_control_, + "org.example.frame-component"); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + + char* component_id = nullptr; + ret = app_control_get_component_id(app_control_, &component_id); + std::unique_ptr ptr(component_id, std::free); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + + ret = app_control_set_component_id(app_control_, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + ptr.reset(nullptr); + component_id = nullptr; + + ret = app_control_get_component_id(app_control_, &component_id); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(component_id, nullptr); +} + +TEST_F(AppControlTest, app_control_set_component_id_N) { + int ret = app_control_set_component_id(nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_get_component_id_P) { + int ret = app_control_set_component_id(app_control_, + "org.example.frame-component"); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + + char* component_id = nullptr; + ret = app_control_get_component_id(app_control_, &component_id); + std::unique_ptr ptr(component_id, std::free); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + + ret = app_control_set_component_id(app_control_, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + ptr.reset(nullptr); + component_id = nullptr; + + ret = app_control_get_component_id(app_control_, &component_id); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); + EXPECT_EQ(component_id, nullptr); +} + +TEST_F(AppControlTest, app_control_get_component_id_N) { + int ret = app_control_get_component_id(nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} + +TEST_F(AppControlTest, app_control_send_resume_request_P) { + EXPECT_CALL(GetMock(), + aul_svc_send_resume_request_for_uid(_, _, _, _, _)). + WillOnce(Invoke( + fake_aul_svc_send_resume_request_for_uid_AUL_SVC_RET_OK)); + + app_control_set_app_id(app_control_, "org.example.hello"); + g_idle_add([](gpointer data) -> gboolean { + auto* handle = static_cast(data); + handle->result_ = app_control_send_resume_request(handle->app_control_, + [](app_control_h request, app_control_error_e result, + void* user_data) { + std::cout << "app_control_result_cb()" << std::endl; + auto* handle = static_cast(user_data); + handle->QuitLoop(); + }, data); + return G_SOURCE_REMOVE; + }, this); + RunLoop(); + EXPECT_EQ(result_, APP_CONTROL_ERROR_NONE); +} + +TEST_F(AppControlTest, app_control_send_resume_request_N) { + int ret = app_control_send_resume_request(nullptr, nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); + + ret = app_control_send_resume_request(app_control_, + [](app_control_h request, app_control_error_e result, void* user_data) { + }, this); + EXPECT_EQ(ret, APP_CONTROL_ERROR_APP_NOT_FOUND); +} + +TEST_F(AppControlTest, app_control_prepare_app_defined_loader_P) { + EXPECT_CALL(GetMock(), aul_prepare_app_defined_loader(_)). + WillOnce(Invoke(fake_aul_prepare_app_defined_loader_LOADER_ID)); + + int ret = app_control_prepare_app_defined_loader(app_control_, + "custom-loader"); + EXPECT_EQ(ret, APP_CONTROL_ERROR_NONE); +} + +TEST_F(AppControlTest, app_control_prepare_app_defined_loader_N) { + int ret = app_control_prepare_app_defined_loader(nullptr, nullptr); + EXPECT_EQ(ret, APP_CONTROL_ERROR_INVALID_PARAMETER); +} diff --git a/test/unit_tests/mock/appcore_base_mock.cc b/test/unit_tests/mock/appcore_base_mock.cc new file mode 100644 index 0000000..d4cbbc0 --- /dev/null +++ b/test/unit_tests/mock/appcore_base_mock.cc @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2021 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 "unit_tests/mock/appcore_base_mock.hh" +#include "unit_tests/mock/mock_hook.hh" +#include "unit_tests/mock/test_fixture.hh" + +extern "C" int appcore_base_control_add(const char* id, + appcore_base_control_cb callback, void* user_data, + appcore_base_control_h *h) { + return MOCK_HOOK_P4(AppCoreBaseMock, appcore_base_control_add, + id, callback, user_data, h); +} + +extern "C" int appcore_base_control_remove(appcore_base_control_h h) { + return MOCK_HOOK_P1(AppCoreBaseMock, appcore_base_control_remove, h); +} diff --git a/test/unit_tests/mock/appcore_base_mock.hh b/test/unit_tests/mock/appcore_base_mock.hh new file mode 100644 index 0000000..b7ff967 --- /dev/null +++ b/test/unit_tests/mock/appcore_base_mock.hh @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2021 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 UNIT_TESTS_MOCK_APPCORE_BASE_MOCK_HH_ +#define UNIT_TESTS_MOCK_APPCORE_BASE_MOCK_HH_ + +#include +#include + +#include "unit_tests/mock/module_mock.hh" + +class AppCoreBaseMock : public virtual ModuleMock { + public: + virtual ~AppCoreBaseMock() {} + + MOCK_METHOD4(appcore_base_control_add, + int (const char*, appcore_base_control_cb, void*, appcore_base_control_h*)); + MOCK_METHOD1(appcore_base_control_remove, int (appcore_base_control_h)); +}; + +#endif // UNIT_TESTS_MOCK_APPCORE_BASE_MOCK_HH_ diff --git a/test/unit_tests/mock/aul_mock.cc b/test/unit_tests/mock/aul_mock.cc new file mode 100644 index 0000000..a534066 --- /dev/null +++ b/test/unit_tests/mock/aul_mock.cc @@ -0,0 +1,73 @@ +/* + * Copyright (c) 2021 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 "unit_tests/mock/aul_mock.hh" +#include "unit_tests/mock/mock_hook.hh" +#include "unit_tests/mock/test_fixture.hh" + +extern "C" int aul_set_default_app_by_operation(bundle* data) { + return MOCK_HOOK_P1(AulMock, aul_set_default_app_by_operation, data); +} + +extern "C" int aul_unset_default_app_by_operation(const char* app_id) { + return MOCK_HOOK_P1(AulMock, aul_unset_default_app_by_operation, app_id); +} + +extern "C" int aul_svc_send_launch_request_for_uid(bundle* data, + int id, aul_svc_res_fn res_fn, aul_svc_err_cb err_cb, void* user_data, + uid_t uid) { + return MOCK_HOOK_P6(AulMock, aul_svc_send_launch_request_for_uid, + data, id, res_fn, err_cb, user_data, uid); +} + +extern "C" int aul_svc_run_service_for_uid(bundle* data, + int id, aul_svc_res_fn res_fn, void* user_data, uid_t uid) { + return MOCK_HOOK_P5(AulMock, aul_svc_run_service_for_uid, + data, id, res_fn, user_data, uid); +} + +extern "C" int aul_svc_subapp_terminate_request(bundle* b, int pid) { + return MOCK_HOOK_P2(AulMock, aul_svc_subapp_terminate_request, b, pid); +} + +extern "C" int aul_svc_create_result_bundle(bundle* inb, bundle** outb) { + return MOCK_HOOK_P2(AulMock, aul_svc_create_result_bundle, inb, outb); +} + +extern "C" int aul_svc_send_result(bundle* b, aul_svc_result_val result) { + return MOCK_HOOK_P2(AulMock, aul_svc_send_result, b, result); +} + +extern "C" int aul_svc_get_list_for_uid(bundle* b, aul_svc_info_iter_fn iter_fn, + void* data, uid_t uid) { + return MOCK_HOOK_P4(AulMock, aul_svc_get_list_for_uid, b, iter_fn, data, uid); +} + +extern "C" int aul_svc_send_launch_request_sync_for_uid(bundle* b, int id, + bundle** reply_b, aul_svc_result_val* result, uid_t uid) { + return MOCK_HOOK_P5(AulMock, aul_svc_send_launch_request_sync_for_uid, b, id, + reply_b, result, uid); +} + +extern "C" int aul_svc_send_resume_request_for_uid(bundle* b, int id, + aul_svc_err_cb err_cb, void* user_data, uid_t uid) { + return MOCK_HOOK_P5(AulMock, aul_svc_send_resume_request_for_uid, b, id, + err_cb, user_data, uid); +} + +extern "C" int aul_prepare_app_defined_loader(const char* loader_name) { + return MOCK_HOOK_P1(AulMock, aul_prepare_app_defined_loader, loader_name); +} diff --git a/test/unit_tests/mock/aul_mock.hh b/test/unit_tests/mock/aul_mock.hh new file mode 100644 index 0000000..73e86b9 --- /dev/null +++ b/test/unit_tests/mock/aul_mock.hh @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2021 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 UNIT_TESTS_MOCK_AUL_MOCK_HH_ +#define UNIT_TESTS_MOCK_AUL_MOCK_HH_ + +#include +#include +#include +#include + +#include "unit_tests/mock/module_mock.hh" + +class AulMock : public virtual ModuleMock { + public: + virtual ~AulMock() {} + + MOCK_METHOD1(aul_set_default_app_by_operation, int (bundle*)); + MOCK_METHOD1(aul_unset_default_app_by_operation, int (const char*)); + MOCK_METHOD6(aul_svc_send_launch_request_for_uid, + int (bundle *, int, aul_svc_res_fn, aul_svc_err_cb, void*, uid_t)); + MOCK_METHOD5(aul_svc_run_service_for_uid, + int (bundle*, int, aul_svc_res_fn, void*, uid_t)); + MOCK_METHOD2(aul_svc_subapp_terminate_request, int (bundle*, int)); + MOCK_METHOD2(aul_svc_create_result_bundle, int (bundle*, bundle**)); + MOCK_METHOD2(aul_svc_send_result, int (bundle*, aul_svc_result_val)); + MOCK_METHOD4(aul_svc_get_list_for_uid, + int (bundle*, aul_svc_info_iter_fn, void*, uid_t)); + MOCK_METHOD5(aul_svc_send_launch_request_sync_for_uid, + int (bundle*, int, bundle**, aul_svc_result_val*, uid_t)); + MOCK_METHOD5(aul_svc_send_resume_request_for_uid, + int (bundle*, int , aul_svc_err_cb, void*, uid_t)); + MOCK_METHOD1(aul_prepare_app_defined_loader, int (const char*)); +}; + +#endif // UNIT_TESTS_MOCK_AUL_MOCK_HH_ diff --git a/test/unit_tests/mock/mock_hook.hh b/test/unit_tests/mock/mock_hook.hh new file mode 100644 index 0000000..fa943c7 --- /dev/null +++ b/test/unit_tests/mock/mock_hook.hh @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2021 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 UNIT_TESTS_MOCK_MOCK_HOOK_HH_ +#define UNIT_TESTS_MOCK_MOCK_HOOK_HH_ + +#define MOCK_HOOK_P0(MOCK_CLASS, f) \ + TestFixture::GetMock().f() +#define MOCK_HOOK_P1(MOCK_CLASS, f, p1) \ + TestFixture::GetMock().f(p1) +#define MOCK_HOOK_P2(MOCK_CLASS, f, p1, p2) \ + TestFixture::GetMock().f(p1, p2) +#define MOCK_HOOK_P3(MOCK_CLASS, f, p1, p2, p3) \ + TestFixture::GetMock().f(p1, p2, p3) +#define MOCK_HOOK_P4(MOCK_CLASS, f, p1, p2, p3, p4) \ + TestFixture::GetMock().f(p1, p2, p3, p4) +#define MOCK_HOOK_P5(MOCK_CLASS, f, p1, p2, p3, p4, p5) \ + TestFixture::GetMock().f(p1, p2, p3, p4, p5) +#define MOCK_HOOK_P6(MOCK_CLASS, f, p1, p2, p3, p4, p5, p6) \ + TestFixture::GetMock().f(p1, p2, p3, p4, p5, p6) +#define MOCK_HOOK_P7(MOCK_CLASS, f, p1, p2, p3, p4, p5, p6, p7) \ + TestFixture::GetMock().f(p1, p2, p3, p4, p5, p6, p7) +#define MOCK_HOOK_P8(MOCK_CLASS, f, p1, p2, p3, p4, p5, p6, p7, p8) \ + TestFixture::GetMock().f(p1, p2, p3, p4, p5, p6, p7, p8) +#define MOCK_HOOK_P9(MOCK_CLASS, f, p1, p2, p3, p4, p5, p6, p7, p8, p9) \ + TestFixture::GetMock().f(p1, p2, p3, p4, p5, p6, p7, p8, p9) +#define MOCK_HOOK_P10(MOCK_CLASS, f, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) \ + TestFixture::GetMock().f(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) + +#endif // UNIT_TESTS_MOCK_MOCK_HOOK_HH_ diff --git a/test/unit_tests/mock/module_mock.hh b/test/unit_tests/mock/module_mock.hh new file mode 100644 index 0000000..a79584e --- /dev/null +++ b/test/unit_tests/mock/module_mock.hh @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2021 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 UNIT_TESTS_MOCK_MODULE_MOCK_HH_ +#define UNIT_TESTS_MOCK_MODULE_MOCK_HH_ + +class ModuleMock { + public: + virtual ~ModuleMock() {} +}; + +#endif // UNIT_TESTS_MOCK_MODULE_MOCK_HH_ diff --git a/test/unit_tests/mock/test_fixture.cc b/test/unit_tests/mock/test_fixture.cc new file mode 100644 index 0000000..23f907d --- /dev/null +++ b/test/unit_tests/mock/test_fixture.cc @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2021 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 + +#include "unit_tests/mock/test_fixture.hh" + +std::unique_ptr TestFixture::mock_; diff --git a/test/unit_tests/mock/test_fixture.hh b/test/unit_tests/mock/test_fixture.hh new file mode 100644 index 0000000..000f709 --- /dev/null +++ b/test/unit_tests/mock/test_fixture.hh @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2021 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 UNIT_TESTS_MOCK_TEST_FIXTURE_HH_ +#define UNIT_TESTS_MOCK_TEST_FIXTURE_HH_ + +#include + +#include +#include +#include +#include + +#include "unit_tests/mock/module_mock.hh" + +class TestFixture : public ::testing::Test { + public: + explicit TestFixture(std::unique_ptr&& mock) { + mock_ = std::move(mock); + } + virtual ~TestFixture() { + mock_.reset(); + } + + virtual void SetUp() {} + virtual void TearDown() {} + + template + static T& GetMock() { + auto ptr = dynamic_cast(mock_.get()); + if (!ptr) { + throw std::invalid_argument("The test does not provide mock of \"" + + std::string(typeid(T).name()) + "\""); + } + + return *ptr; + } + + static std::unique_ptr mock_; +}; + +#endif // UNIT_TESTS_MOCK_TEST_FIXTURE_HH_ -- 2.34.1