/*
- * 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.
* limitations under the License.
*/
-#include <stdlib.h>
+#include <aul.h>
+#include <aul_svc.h>
+#include <bundle_cpp.h>
+#include <glib.h>
+#include <gmock/gmock.h>
#include <gtest/gtest.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <unistd.h>
#include <iostream>
#include <memory>
+#include <string>
#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<CbInfo*>(data);
+ info->err_cb_(info->id_, getpid(), info->data_);
+ return G_SOURCE_REMOVE;
+ }, info);
+ g_idle_add([](gpointer data) -> gboolean {
+ auto* info = static_cast<CbInfo*>(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<ActionCbInfo*>(data);
+ bundle* b = bundle_create();
+ info->cb_(b, info->data_);
+ bundle_free(b);
+ return G_SOURCE_REMOVE;
+ }, info);
+ *h = static_cast<appcore_base_control_h>(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<ActionCbInfo*>(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<CbInfo*>(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<AulMock>,
+ public ::testing::NiceMock<AppCoreBaseMock> {};
+
+class AppControlTest : public TestFixture {
public:
+ AppControlTest() : TestFixture(std::make_unique<Mocks>()) {}
+
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);
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<void, decltype(app_control_uri_builder_destroy)*>(
- builder_, app_control_uri_builder_destroy);
+ app_control_uri_builder_destroy(builder_);
builder_ = nullptr;
}
+
if (uri_ != nullptr) {
- auto uri = std::unique_ptr<void, decltype(app_control_uri_destroy)*>(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);
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);
auto value = std::unique_ptr<char, decltype(std::free)*>(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<std::remove_pointer<app_control_h>::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<std::remove_pointer<app_control_h>::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<std::remove_pointer<app_control_h>::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<char, decltype(std::free)*> 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<char, decltype(std::free)*> 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<char, decltype(std::free)*> 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<char, decltype(std::free)*> 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<char, decltype(std::free)*> 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<char, decltype(std::free)*> 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<std::remove_pointer<app_control_h>::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<char, decltype(std::free)*> 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<char, decltype(std::free)*> 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<char, decltype(std::free)*> 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<char, decltype(std::free)*> 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<char, decltype(std::free)*> 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<char, decltype(std::free)*> 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<char, decltype(std::free)*> 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<char, decltype(std::free)*> 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<char, decltype(std::free)*> 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<char, decltype(std::free)*> 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<std::remove_pointer<app_control_h>::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<char, decltype(std::free)*> 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<AulMock>(), 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<AulMock>(), 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<AulMock>(), 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<AulMock>(), 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<AulMock>(), 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<AulMock>(), 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<AulMock>(), 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<AulMock>(), 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<AulMock>(), 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<AulMock>(), 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<AulMock>(), 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<std::remove_pointer<app_control_h>::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<AulMock>(), aul_svc_create_result_bundle(_, _)).
+ WillOnce(Invoke(fake_aul_svc_create_result_bundle_AUL_SVC_RET_OK));
+ EXPECT_CALL(GetMock<AulMock>(), 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<std::remove_pointer<app_control_h>::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<AulMock>(), 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<AulMock>(), aul_svc_create_result_bundle(_, _)).
+ WillOnce(Invoke(fake_aul_svc_create_result_bundle_AUL_SVC_RET_OK));
+ EXPECT_CALL(GetMock<AulMock>(), 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<AulMock>(), aul_svc_create_result_bundle(_, _)).
+ WillOnce(Invoke(fake_aul_svc_create_result_bundle_AUL_SVC_RET_OK));
+ EXPECT_CALL(GetMock<AulMock>(), 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<char, decltype(std::free)*> 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<char, decltype(std::free)*> 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<int*>(user_data);
+ (*count)++;
+ return true;
+ }, static_cast<void*>(&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<AulMock>(), 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<bool*>(user_data);
+ *touch = true;
+ return true;
+ }, static_cast<void*>(&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<char, decltype(std::free)*> 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<bundle, decltype(bundle_free)*> 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<char, decltype(std::free)*> 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<char, decltype(std::free)*> 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<char, decltype(std::free)*> 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<AulMock>(),
+ 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<AppControlTest*>(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<AppControlTest*>(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<AulMock>(),
+ 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<std::remove_pointer<app_control_h>::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<AppCoreBaseMock>(), appcore_base_control_add(_, _, _, _)).
+ WillOnce(Invoke(fake_appcore_base_control_add_APPCORE_BASE_ERROR_NONE));
+ EXPECT_CALL(GetMock<AppCoreBaseMock>(), 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<AppControlTest*>(user_data);
+ handle->result_ = 0;
+ handle->QuitLoop();
+ }, this, &handle);
+ std::unique_ptr<std::remove_pointer<app_control_action_h>::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<AppCoreBaseMock>(), 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<AppCoreBaseMock>(), 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<AppCoreBaseMock>(), 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<AppCoreBaseMock>(), appcore_base_control_add(_, _, _, _)).
+ WillOnce(Invoke(fake_appcore_base_control_add_APPCORE_BASE_ERROR_NONE));
+ EXPECT_CALL(GetMock<AppCoreBaseMock>(), 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<AppControlTest*>(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<char, decltype(std::free)*> 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<char, decltype(std::free)*> 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<AulMock>(),
+ 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<AppControlTest*>(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<AppControlTest*>(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<AulMock>(), 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);
+}
projects / platform / core / api / app-control.git / commitdiff