From da2615c4c4075811173d6e843ae722d83c426319 Mon Sep 17 00:00:00 2001 From: Inkyun Kil Date: Wed, 19 Aug 2020 08:40:32 +0900 Subject: [PATCH] Adds new unittest - for rua.h, rua_manager.h rua_info.h Change-Id: Ifdf8778ab1eb39118bb220e83c03ea285ac8b606 Signed-off-by: Inkyun Kil --- tests/mock/aul_mock.cc | 28 ++- tests/mock/aul_mock.h | 8 +- tests/mock/gio_mock.cc | 42 ++++ tests/mock/gio_mock.h | 40 +++ tests/mock/pkgmgr_info_mock.cc | 39 +++ tests/mock/pkgmgr_info_mock.h | 36 +++ tests/mock/sqlite3_mock.cc | 73 ++++++ tests/mock/sqlite3_mock.h | 47 ++++ tests/unittest/CMakeLists.txt | 2 +- tests/unittest/rua_manager_unit_test.cc | 417 ++++++++++++++++++++++++++++++++ tests/unittest/rua_unit_test.cc | 175 +++++++++++++- 11 files changed, 899 insertions(+), 8 deletions(-) create mode 100644 tests/mock/gio_mock.cc create mode 100755 tests/mock/gio_mock.h create mode 100644 tests/mock/pkgmgr_info_mock.cc create mode 100644 tests/mock/pkgmgr_info_mock.h create mode 100644 tests/mock/sqlite3_mock.cc create mode 100644 tests/mock/sqlite3_mock.h create mode 100644 tests/unittest/rua_manager_unit_test.cc diff --git a/tests/mock/aul_mock.cc b/tests/mock/aul_mock.cc index ab22c6d..c716fc5 100644 --- a/tests/mock/aul_mock.cc +++ b/tests/mock/aul_mock.cc @@ -21,7 +21,31 @@ #include "aul_mock.h" -extern "C" int aul_add_rua_history_for_uid( - bundle* arg0, uid_t arg1) { +extern "C" int aul_add_rua_history_for_uid(bundle* arg0, uid_t arg1) { return MOCK_HOOK_P2(AulMock, aul_add_rua_history_for_uid, arg0, arg1); } + +extern "C" int aul_delete_rua_history_for_uid(bundle* arg0, uid_t arg1) { + return MOCK_HOOK_P2(AulMock, aul_delete_rua_history_for_uid, arg0, arg1); +} + +extern "C" int aul_comp_info_create(const char* arg0, aul_comp_info_h* arg1) { + return MOCK_HOOK_P2(AulMock, aul_comp_info_create, arg0, arg1); +} + +extern "C" int aul_comp_info_destroy( + aul_comp_info_h arg0) { + return MOCK_HOOK_P1(AulMock, aul_comp_info_destroy, arg0); +} + +extern "C" int aul_comp_info_clone(aul_comp_info_h arg0, aul_comp_info_h* arg1) { + return MOCK_HOOK_P2(AulMock, aul_comp_info_clone, arg0, arg1); +} + +extern "C" int aul_comp_info_is_taskmanage(aul_comp_info_h arg0, bool* arg1) { + return MOCK_HOOK_P2(AulMock, aul_comp_info_is_taskmanage, arg0, arg1); +} + +extern "C" int aul_comp_info_get_label(aul_comp_info_h arg0, const char** arg1) { + return MOCK_HOOK_P2(AulMock, aul_comp_info_get_label, arg0, arg1); +} \ No newline at end of file diff --git a/tests/mock/aul_mock.h b/tests/mock/aul_mock.h index da623ae..8b2c922 100644 --- a/tests/mock/aul_mock.h +++ b/tests/mock/aul_mock.h @@ -19,6 +19,7 @@ #include #include +#include #include #include "module_mock.h" @@ -28,7 +29,12 @@ class AulMock : public virtual ModuleMock { virtual ~AulMock() {} MOCK_METHOD2(aul_add_rua_history_for_uid, int(bundle*, uid_t)); - + MOCK_METHOD2(aul_delete_rua_history_for_uid, int(bundle*, uid_t)); + MOCK_METHOD2(aul_comp_info_create, int(const char*, aul_comp_info_h*)); + MOCK_METHOD2(aul_comp_info_clone, int(aul_comp_info_h, aul_comp_info_h*)); + MOCK_METHOD1(aul_comp_info_destroy, int(aul_comp_info_h)); + MOCK_METHOD2(aul_comp_info_is_taskmanage, int(aul_comp_info_h, bool*)); + MOCK_METHOD2(aul_comp_info_get_label, int(aul_comp_info_h, const char**)); }; #endif // UNIT_TESTS_MOCK_AUL_MOCK_H_ diff --git a/tests/mock/gio_mock.cc b/tests/mock/gio_mock.cc new file mode 100644 index 0000000..9d01fbc --- /dev/null +++ b/tests/mock/gio_mock.cc @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2020 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 "gio_mock.h" + +#include + +#include "mock_hook.h" +#include "test_fixture.h" + +extern "C" guint g_dbus_connection_signal_subscribe(GDBusConnection* arg0, + const gchar* arg1, const gchar* arg2, const gchar* arg3, const gchar* arg4, + const gchar* arg5, GDBusSignalFlags arg6, GDBusSignalCallback arg7, + gpointer arg8, GDestroyNotify arg9) { + return MOCK_HOOK_P10(GioMock, g_dbus_connection_signal_subscribe, + arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); +} + +extern "C" gboolean g_dbus_connection_emit_signal(GDBusConnection* arg0, + const gchar* arg1, const gchar* arg2, const gchar* arg3, const gchar* arg4, + GVariant* arg5, GError** arg6) { + return MOCK_HOOK_P7(GioMock, g_dbus_connection_emit_signal, + arg0, arg1, arg2, arg3, arg4, arg5, arg6); +} + +extern "C" gboolean g_dbus_connection_flush_sync(GDBusConnection* arg0, + GCancellable* arg1, GError** arg2) { + return MOCK_HOOK_P3(GioMock, g_dbus_connection_flush_sync, arg0, arg1, arg2); +} diff --git a/tests/mock/gio_mock.h b/tests/mock/gio_mock.h new file mode 100755 index 0000000..fda9c6a --- /dev/null +++ b/tests/mock/gio_mock.h @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2020 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_GIO_MOCK_H_ +#define UNIT_TESTS_MOCK_GIO_MOCK_H_ + +#include +#include + +#include "module_mock.h" + +class GioMock : public virtual ModuleMock { + public: + virtual ~GioMock() {} + + MOCK_METHOD10(g_dbus_connection_signal_subscribe, + guint(GDBusConnection*, const gchar*, const gchar*, const gchar*, + const gchar*, const gchar*, GDBusSignalFlags, GDBusSignalCallback, + gpointer, GDestroyNotify)); + MOCK_METHOD7(g_dbus_connection_emit_signal, + gboolean(GDBusConnection*, const gchar*, const gchar*, const gchar*, + const gchar*, GVariant*, GError**)); + MOCK_METHOD3(g_dbus_connection_flush_sync, + gboolean(GDBusConnection*, GCancellable*, GError**)); +}; + +#endif // UNIT_TESTS_MOCK_GIO_MOCK_H_ diff --git a/tests/mock/pkgmgr_info_mock.cc b/tests/mock/pkgmgr_info_mock.cc new file mode 100644 index 0000000..268c8d9 --- /dev/null +++ b/tests/mock/pkgmgr_info_mock.cc @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2020 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 "pkgmgr_info_mock.h" + +#include "mock_hook.h" +#include "test_fixture.h" + +extern "C" int pkgmgrinfo_appinfo_get_appinfo(const char* arg0, + pkgmgrinfo_appinfo_h* arg1) { + return MOCK_HOOK_P2(PkgmgrInfoMock, pkgmgrinfo_appinfo_get_appinfo, arg0, + arg1); +} + +extern "C" int pkgmgrinfo_appinfo_destroy_appinfo( + pkgmgrinfo_appinfo_h arg0) { + return MOCK_HOOK_P1(PkgmgrInfoMock, pkgmgrinfo_appinfo_destroy_appinfo, + arg0); +} + + +extern "C" int pkgmgrinfo_appinfo_clone_appinfo(pkgmgrinfo_appinfo_h arg0, + pkgmgrinfo_appinfo_h* arg1) { + return MOCK_HOOK_P2(PkgmgrInfoMock, pkgmgrinfo_appinfo_clone_appinfo, arg0, + arg1); +} \ No newline at end of file diff --git a/tests/mock/pkgmgr_info_mock.h b/tests/mock/pkgmgr_info_mock.h new file mode 100644 index 0000000..311d4a7 --- /dev/null +++ b/tests/mock/pkgmgr_info_mock.h @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2020 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_PKGMGR_INFO_MOCK_H_ +#define UNIT_TESTS_MOCK_PKGMGR_INFO_MOCK_H_ + +#include +#include + +#include "module_mock.h" + +class PkgmgrInfoMock : public virtual ModuleMock { + public: + virtual ~PkgmgrInfoMock() {} + + MOCK_METHOD2(pkgmgrinfo_appinfo_get_appinfo, + int(const char*, pkgmgrinfo_appinfo_h*)); + MOCK_METHOD1(pkgmgrinfo_appinfo_destroy_appinfo, int(pkgmgrinfo_appinfo_h)); + MOCK_METHOD2(pkgmgrinfo_appinfo_clone_appinfo, int(pkgmgrinfo_appinfo_h, + pkgmgrinfo_appinfo_h*)); +}; + +#endif // UNIT_TESTS_MOCK_PKGMGR_INFO_MOCK_H_ diff --git a/tests/mock/sqlite3_mock.cc b/tests/mock/sqlite3_mock.cc new file mode 100644 index 0000000..83629a0 --- /dev/null +++ b/tests/mock/sqlite3_mock.cc @@ -0,0 +1,73 @@ +/* + * Copyright (c) 2020 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 "mock_hook.h" +#include "test_fixture.h" +#include "sqlite3_mock.h" + +typedef int(*cb)(void*, int); +typedef int(*execcb)(void*, int, char**, char**); +typedef void(*bindcb)(void*); + +extern "C" int sqlite3_open_v2(const char* arg0, + sqlite3** arg1, int arg2, const char* arg3) { + return MOCK_HOOK_P4(SqlMock, sqlite3_open_v2, arg0, arg1, arg2, arg3); +} + +extern "C" int sqlite3_close_v2(sqlite3* arg0) { + return MOCK_HOOK_P1(SqlMock, sqlite3_close_v2, arg0); +} + +extern "C" void sqlite3_free_table(char** arg0) { + return MOCK_HOOK_P1(SqlMock, sqlite3_free_table, arg0); +} + +extern "C" int sqlite3_busy_handler(sqlite3* arg0, cb arg1, void* arg2) { + return MOCK_HOOK_P3(SqlMock, sqlite3_busy_handler, arg0, arg1, arg2); +} + +extern "C" int sqlite3_get_table(sqlite3* arg0, const char* arg1, + char*** arg2, int* arg3, int* arg4, char** arg5) { + return MOCK_HOOK_P6(SqlMock, sqlite3_get_table, arg0, arg1, arg2, arg3, + arg4, arg5); +} + +extern "C" int sqlite3_exec(sqlite3* arg0, const char* arg1, + execcb arg2, void* arg3, char** arg4) { + return MOCK_HOOK_P5(SqlMock, sqlite3_exec, arg0, arg1, arg2, arg3, arg4); +} + +extern "C" int sqlite3_prepare_v2(sqlite3* arg0, const char* arg1, + int arg2, sqlite3_stmt** arg3, const char** arg4) { + return MOCK_HOOK_P5(SqlMock, sqlite3_prepare_v2, arg0, arg1, arg2, arg3, arg4); +} + +extern "C" int sqlite3_bind_text(sqlite3_stmt* arg0, int arg1, const char* arg2, + int arg3, bindcb arg4) { + return MOCK_HOOK_P5(SqlMock, sqlite3_bind_text, arg0, arg1, arg2, arg3, arg4); +} + +extern "C" int sqlite3_bind_int(sqlite3_stmt* arg0, int arg1, int arg2) { + return MOCK_HOOK_P3(SqlMock, sqlite3_bind_int, arg0, arg1, arg2); +} + +extern "C" int sqlite3_step(sqlite3_stmt* arg0) { + return MOCK_HOOK_P1(SqlMock, sqlite3_step, arg0); +} + +extern "C" int sqlite3_finalize(sqlite3_stmt* arg0) { + return MOCK_HOOK_P1(SqlMock, sqlite3_finalize, arg0); +} \ No newline at end of file diff --git a/tests/mock/sqlite3_mock.h b/tests/mock/sqlite3_mock.h new file mode 100644 index 0000000..ab62a24 --- /dev/null +++ b/tests/mock/sqlite3_mock.h @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2020 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_SQLITE3_MOCK_H_ +#define UNIT_TESTS_MOCK_SQLITE3_MOCK_H_ + +#include +#include + +#include "module_mock.h" + +class SqlMock : public virtual ModuleMock { + public: + virtual ~SqlMock() {} + + MOCK_METHOD1(sqlite3_free_table, void(char**)); + MOCK_METHOD1(sqlite3_close_v2, int(sqlite3*)); + MOCK_METHOD3(sqlite3_busy_handler, int(sqlite3*, int(*)(void*, int), void*)); + MOCK_METHOD4(sqlite3_open_v2, int(const char*, sqlite3**, int, const char*)); + MOCK_METHOD6(sqlite3_get_table, int (sqlite3*, const char*, char***, + int*, int*, char**)); + MOCK_METHOD5(sqlite3_exec, int(sqlite3*, const char*, + int(*)(void*, int, char**, char**), void*, char**)); + MOCK_METHOD5(sqlite3_prepare_v2, int(sqlite3*, const char*, + int, sqlite3_stmt**, const char**)); + MOCK_METHOD5(sqlite3_bind_text, int(sqlite3_stmt*, int, const char*, + int, void(*)(void*))); + MOCK_METHOD3(sqlite3_bind_int, int(sqlite3_stmt*, int, int)); + MOCK_METHOD1(sqlite3_step, int(sqlite3_stmt*)); + MOCK_METHOD1(sqlite3_finalize, int(sqlite3_stmt*)); + +}; + +#endif // UNIT_TESTS_MOCK_SQLITE3_MOCK_H_ diff --git a/tests/unittest/CMakeLists.txt b/tests/unittest/CMakeLists.txt index d4677ec..7cf505e 100644 --- a/tests/unittest/CMakeLists.txt +++ b/tests/unittest/CMakeLists.txt @@ -16,7 +16,7 @@ INCLUDE(FindPkgConfig) PKG_CHECK_MODULES(gtest_pkgs REQUIRED gmock) TARGET_LINK_LIBRARIES(${TARGET_RUA_UNIT_TEST} PUBLIC ${gtest_pkgs_LDFLAGS} ${PROJECT_NAME}) -SET_TARGET_PROPERTIES(${TARGET_RUA_UNIT_TEST} PROPERTIES COMPILE_FLAGS "-fPIE") +SET_TARGET_PROPERTIES(${TARGET_RUA_UNIT_TEST} PROPERTIES COMPILE_FLAGS "-fPIE -fvisibility=default") SET_TARGET_PROPERTIES(${TARGET_RUA_UNIT_TEST} PROPERTIES LINK_FLAGS "-pie") ADD_TEST( diff --git a/tests/unittest/rua_manager_unit_test.cc b/tests/unittest/rua_manager_unit_test.cc new file mode 100644 index 0000000..cc4289a --- /dev/null +++ b/tests/unittest/rua_manager_unit_test.cc @@ -0,0 +1,417 @@ +/* + * Copyright (c) 2020 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 +#include + +#include +#include +#include + +#include "aul_mock.h" +#include "sqlite3_mock.h" +#include "pkgmgr_info_mock.h" +#include "test_fixture.h" + +using ::testing::_; +using ::testing::DoAll; +using ::testing::SetArgPointee; +using ::testing::Return; + +static bool __rua_info_cb(rua_info_h info, void* user_data) { + if (user_data) { + rua_info_h* cloned = (rua_info_h*)user_data; + rua_info_clone(info, cloned); + } + + return false; +} + +static char** __create_table(void) { + char** table = (char** )calloc(10, sizeof(char*)); + table[0] = strdup("pkgname"); + if (table[0] == nullptr) { + goto out; + } + + table[1] = strdup("apppath"); + if (table[1] == nullptr) { + goto out; + } + + table[2] = strdup("arg"); + if (table[2] == nullptr) { + goto out; + } + + table[3] = strdup("122232"); + if (table[3] == nullptr) { + goto out; + } + + table[4] = strdup("instance_id"); + if (table[4] == nullptr) { + goto out; + } + + table[5] = strdup("instance_name"); + if (table[5] == nullptr) { + goto out; + } + + table[6] = strdup("icon"); + if (table[6] == nullptr) { + goto out; + } + + table[7] = strdup("uri"); + if (table[7] == nullptr) { + goto out; + } + + table[8] = strdup("image"); + if (table[8] == nullptr) { + goto out; + } + + table[9] = strdup("compid"); + if (table[9] == nullptr) { + goto out; + } + + return table; + +out: + for (int i = 0; i < 10; i++) { + if (table[i]) + free(table[i]); + } + + return nullptr; +} + +class ManagerMocks : public ::testing::NiceMock, + public ::testing::NiceMock, + public ::testing::NiceMock {}; + +class RuaManagerTest : public TestFixture { + public: + RuaManagerTest() : TestFixture(std::make_unique()) {} + virtual ~RuaManagerTest() {} + + virtual void SetUp() { + table_ = __create_table(); + if (table_ == nullptr) + return; + + temp_ = (void*)malloc(1); + if (temp_ == nullptr) + return; + + EXPECT_CALL(GetMock(), + sqlite3_open_v2(_, _, _, _)).WillRepeatedly(Return(0)); + EXPECT_CALL(GetMock(), + sqlite3_close_v2(_)).WillRepeatedly(Return(0)); + EXPECT_CALL(GetMock(), + sqlite3_free_table(_)); + EXPECT_CALL(GetMock(), + sqlite3_busy_handler(_, _, _)).WillRepeatedly(Return(0)); + EXPECT_CALL(GetMock(), + sqlite3_get_table(_, _, _, _, _, _)). + WillOnce(DoAll(SetArgPointee<2>(table_), + SetArgPointee<3>(1), + SetArgPointee<4>(0), (Return(0)))); + EXPECT_CALL(GetMock(), + pkgmgrinfo_appinfo_get_appinfo(_, _)). + WillOnce(DoAll(SetArgPointee<1>(temp_),Return(0))); + EXPECT_CALL(GetMock(), + aul_comp_info_create(_, _)). + WillOnce(DoAll(SetArgPointee<1>(temp_),Return(0))); + EXPECT_CALL(GetMock(), + aul_comp_info_destroy(_)). + WillRepeatedly(Return(0)); + EXPECT_CALL(GetMock(), + pkgmgrinfo_appinfo_destroy_appinfo(_)). + WillRepeatedly(Return(0)); + EXPECT_CALL(GetMock(), + pkgmgrinfo_appinfo_clone_appinfo(_, _)). + WillOnce(DoAll(SetArgPointee<1>(temp_),Return(0))); + EXPECT_CALL(GetMock(), + aul_comp_info_clone(_, _)). + WillOnce(DoAll(SetArgPointee<1>(temp_),Return(0))); + + rua_manager_foreach_rua_info(__rua_info_cb, &info_); + } + + virtual void TearDown() { + if (table_) { + for (int i = 0; i < 10; i++) + free(table_[i]); + free(table_); + } + if (temp_) + free(temp_); + + rua_info_destroy(info_); + } + + public: + rua_info_h info_ = nullptr; + + private: + char** table_ = nullptr; + void* temp_ = nullptr; +}; + +TEST_F(RuaManagerTest, rua_manager_delete_rua_info) { + EXPECT_CALL(GetMock(), + aul_delete_rua_history_for_uid(_, _)). + WillOnce(Return(0)); + + int ret = rua_manager_delete_rua_info(info_); + EXPECT_EQ(ret, 0); +} + +TEST_F(RuaManagerTest, rua_manager_delete_all_rua_info) { + EXPECT_CALL(GetMock(), + aul_delete_rua_history_for_uid(_, _)). + WillOnce(Return(0)); + + int ret = rua_manager_delete_all_rua_info(); + EXPECT_EQ(ret, 0); +} + +TEST_F(RuaManagerTest, rua_manager_get_app_control_from_rua_info_N) { + app_control_h ac; + + int ret = rua_manager_get_app_control_from_rua_info(info_, &ac); + EXPECT_NE(ret, 0); +} + +TEST_F(RuaManagerTest, rua_manager_get_rua_context_from_rua_info) { + rua_context_h ctx; + + int ret = rua_manager_get_rua_context_from_rua_info(info_, &ctx); + EXPECT_EQ(ret, 0); + + ret = rua_context_destroy(ctx); + EXPECT_EQ(ret, 0); +} + + +TEST_F(RuaManagerTest, rua_manager_is_running_N) { + rua_context_h ctx; + bool running; + + int ret = rua_manager_get_rua_context_from_rua_info(info_, &ctx); + EXPECT_EQ(ret, 0); + + ret = rua_manager_is_running(ctx, &running); + EXPECT_NE(ret, 0); + + ret = rua_context_destroy(ctx); + EXPECT_EQ(ret, 0); +} + +TEST_F(RuaManagerTest, rua_manager_resume_N) { + rua_context_h ctx; + + int ret = rua_manager_get_rua_context_from_rua_info(info_, &ctx); + EXPECT_EQ(ret, 0); + + ret = rua_manager_resume(ctx); + EXPECT_NE(ret, 0); + + ret = rua_context_destroy(ctx); + EXPECT_EQ(ret, 0); +} + +TEST_F(RuaManagerTest, rua_manager_terminate_N) { + rua_context_h ctx; + + int ret = rua_manager_get_rua_context_from_rua_info(info_, &ctx); + EXPECT_EQ(ret, 0); + + ret = rua_manager_terminate(ctx); + EXPECT_NE(ret, 0); + + ret = rua_context_destroy(ctx); + EXPECT_EQ(ret, 0); +} + +TEST_F(RuaManagerTest, rua_context_get_app_id) { + rua_context_h ctx; + char* appid; + + int ret = rua_manager_get_rua_context_from_rua_info(info_, &ctx); + EXPECT_EQ(ret, 0); + + ret = rua_context_get_app_id(ctx, &appid); + EXPECT_EQ(ret, 0); + EXPECT_EQ(appid, std::string("pkgname")); + + free(appid); +} + +TEST_F(RuaManagerTest, rua_context_get_instance_id) { + rua_context_h ctx; + char* instanceid; + + int ret = rua_manager_get_rua_context_from_rua_info(info_, &ctx); + EXPECT_EQ(ret, 0); + + ret = rua_context_get_instance_id(ctx, &instanceid); + EXPECT_EQ(ret, 0); + EXPECT_EQ(instanceid, std::string("instance_id")); + + free(instanceid); +} + +TEST_F(RuaManagerTest, rua_context_get_component_id) { + rua_context_h ctx; + char* compid; + + int ret = rua_manager_get_rua_context_from_rua_info(info_, &ctx); + EXPECT_EQ(ret, 0); + + ret = rua_context_get_component_id(ctx, &compid); + EXPECT_EQ(ret, 0); + EXPECT_EQ(compid, std::string("compid")); + + free(compid); +} + +TEST_F(RuaManagerTest, rua_info_get_app_id) { + char* app_id; + + int ret = rua_info_get_app_id(info_, &app_id); + EXPECT_EQ(ret, 0); + EXPECT_EQ(app_id, std::string("pkgname")); + + free(app_id); +} + +TEST_F(RuaManagerTest, rua_info_get_app_path) { + char* app_path; + + int ret = rua_info_get_app_path(info_, &app_path); + EXPECT_EQ(ret, 0); + EXPECT_EQ(app_path, std::string("apppath")); + + free(app_path); +} + +TEST_F(RuaManagerTest, rua_info_get_args) { + char* args; + + int ret = rua_info_get_args(info_, &args); + EXPECT_EQ(ret, 0); + EXPECT_EQ(args, std::string("arg")); + + free(args); +} + +TEST_F(RuaManagerTest, rua_info_get_launch_time) { + time_t launch_time; + + int ret = rua_info_get_launch_time(info_, &launch_time); + EXPECT_EQ(ret, 0); + EXPECT_EQ(launch_time, 122232); +} + +TEST_F(RuaManagerTest, rua_info_get_instance_id) { + char* instance_id; + + int ret = rua_info_get_instance_id(info_, &instance_id); + EXPECT_EQ(ret, 0); + EXPECT_EQ(instance_id, std::string("instance_id")); + + free(instance_id); +} + +TEST_F(RuaManagerTest, rua_info_get_instance_name) { + char* instance_name; + + int ret = rua_info_get_instance_name(info_, &instance_name); + EXPECT_EQ(ret, 0); + EXPECT_EQ(instance_name, std::string("instance_name")); + + free(instance_name); +} + +TEST_F(RuaManagerTest, rua_info_get_icon) { + char* icon; + + int ret = rua_info_get_icon(info_, &icon); + EXPECT_EQ(ret, 0); + EXPECT_EQ(icon, std::string("icon")); + + free(icon); +} + +TEST_F(RuaManagerTest, rua_info_get_uri) { + char* uri; + + int ret = rua_info_get_uri(info_, &uri); + EXPECT_EQ(ret, 0); + EXPECT_EQ(uri, std::string("uri")); + + free(uri); +} + +TEST_F(RuaManagerTest, rua_info_get_image) { + char* image; + + int ret = rua_info_get_image(info_, &image); + EXPECT_EQ(ret, 0); + EXPECT_EQ(image, std::string("image")); + + free(image); +} + +TEST_F(RuaManagerTest, rua_info_get_component_id) { + char* comp_id; + + int ret = rua_info_get_component_id(info_, &comp_id); + EXPECT_EQ(ret, 0); + EXPECT_EQ(comp_id, std::string("compid")); + + free(comp_id); +} + +TEST_F(RuaManagerTest, rua_info_is_managed_by_task_manager) { + EXPECT_CALL(GetMock(), + aul_comp_info_is_taskmanage(_, _)). + WillOnce(Return(0)); + + bool managed; + + int ret = rua_info_is_managed_by_task_manager(info_, &managed); + EXPECT_EQ(ret, 0); +} + +TEST_F(RuaManagerTest, rua_info_get_label) { + EXPECT_CALL(GetMock(), + aul_comp_info_get_label(_, _)). + WillOnce(Return(0)); + + char* label; + + int ret = rua_info_get_label(info_, &label); + EXPECT_EQ(ret, 0); +} \ No newline at end of file diff --git a/tests/unittest/rua_unit_test.cc b/tests/unittest/rua_unit_test.cc index ccffbb9..1bbc61f 100644 --- a/tests/unittest/rua_unit_test.cc +++ b/tests/unittest/rua_unit_test.cc @@ -20,14 +20,21 @@ #include #include +#include #include "aul_mock.h" +#include "sqlite3_mock.h" +#include "gio_mock.h" #include "test_fixture.h" using ::testing::_; +using ::testing::DoAll; +using ::testing::SetArgPointee; using ::testing::Return; -class Mocks : public ::testing::NiceMock{}; +class Mocks : public ::testing::NiceMock, + public ::testing::NiceMock, + public ::testing::NiceMock {}; class RuaTest : public TestFixture { public: @@ -41,19 +48,179 @@ class RuaTest : public TestFixture { } }; +static void __rua_history_update_cb(char** table, int nrows, int ncols, + void* user_data) { +} + TEST_F(RuaTest, rua_add_history_for_uid) { EXPECT_CALL(GetMock(), aul_add_rua_history_for_uid(_, _)). WillOnce(Return(0)); + int ret = rua_add_history_for_uid("test", "/app_path", "arg", 5001); + EXPECT_EQ(ret, 0); +} + +TEST_F(RuaTest, rua_delete_history_with_pkgname) { + EXPECT_CALL(GetMock(), + aul_delete_rua_history_for_uid(_, _)). + WillOnce(Return(0)); + + int ret = rua_delete_history_with_pkgname("test"); + EXPECT_EQ(ret, 0); +} + +TEST_F(RuaTest, rua_delete_history_with_apppath) { + EXPECT_CALL(GetMock(), + aul_delete_rua_history_for_uid(_, _)). + WillOnce(Return(0)); + + int ret = rua_delete_history_with_apppath("/app_path"); + EXPECT_EQ(ret, 0); +} + +TEST_F(RuaTest, rua_clear_history) { + EXPECT_CALL(GetMock(), + aul_delete_rua_history_for_uid(_, _)). + WillOnce(Return(0)); + + int ret = rua_clear_history(); + EXPECT_EQ(ret, 0); +} + +TEST_F(RuaTest, rua_history_load_db_N) { + int ret, nrows, ncols; + ret = rua_history_load_db(NULL, &nrows, &ncols); + EXPECT_NE(ret, 0); +} + +TEST_F(RuaTest, rua_register_update_cb_N) { + EXPECT_CALL(GetMock(), + g_dbus_connection_signal_subscribe(_, _, _, _, _, _, _, _, _, _)). + WillOnce(Return(0)); + + int id; + int ret = rua_register_update_cb(__rua_history_update_cb, NULL, &id); + EXPECT_NE(ret, 0); +} + +TEST_F(RuaTest, rua_unregister_update_cb_N) { + int ret = rua_unregister_update_cb(1); + EXPECT_NE(ret, 0); +} + +static char** __create_table(void) { + char** table = (char** )calloc(10, sizeof(char*)); + table[0] = strdup("pkgname"); + if (table[0] == nullptr) { + goto out; + } + + table[1] = strdup("apppath"); + if (table[1] == nullptr) { + goto out; + } + + table[2] = strdup("arg"); + if (table[2] == nullptr) { + goto out; + } + + table[3] = strdup("122232"); + if (table[3] == nullptr) { + goto out; + } + + table[4] = strdup("instance_id"); + if (table[4] == nullptr) { + goto out; + } + + table[5] = strdup("instance_name"); + if (table[5] == nullptr) { + goto out; + } + + table[6] = strdup("icon"); + if (table[6] == nullptr) { + goto out; + } + + table[7] = strdup("uri"); + if (table[7] == nullptr) { + goto out; + } + + table[8] = strdup("image"); + if (table[8] == nullptr) { + goto out; + } + + table[9] = strdup("compid"); + if (table[9] == nullptr) { + goto out; + } + + return table; + +out: + for (int i = 0; i < 10; i++) { + if (table[i]) + free(table[i]); + } + + return nullptr; +} + +TEST_F(RuaTest, rua_history_get_rec) { + char** table = __create_table(); + ASSERT_TRUE(table != NULL); + + EXPECT_CALL(GetMock(), + sqlite3_open_v2(_, _, _, _)).WillOnce(Return(0)); + EXPECT_CALL(GetMock(), + sqlite3_close_v2(_)).WillOnce(Return(0)); + EXPECT_CALL(GetMock(), + sqlite3_free_table(_)); + EXPECT_CALL(GetMock(), + sqlite3_busy_handler(_, _, _)).WillOnce(Return(0)); + EXPECT_CALL(GetMock(), + sqlite3_get_table(_, _, _, _, _, _)). + WillOnce(DoAll(SetArgPointee<2>(table), + SetArgPointee<3>(1), + SetArgPointee<4>(0), (Return(0)))); + + char** get_table = NULL; + int rows = 0; + int cols = 0; + struct rua_rec record; int ret; - ret = rua_add_history_for_uid("test", "/app_path", "arg", 5001); + ret = rua_history_load_db(&get_table, &rows, &cols); EXPECT_EQ(ret, 0); + EXPECT_TRUE(get_table != NULL); + + ret = rua_history_get_rec(&record, get_table, rows, cols, 0); + EXPECT_EQ(ret, 0); + + rua_history_unload_db(&get_table); + + for (int i = 0; i < 10; i++) + free(table[i]); + free(table); } -TEST_F(RuaTest, rua_delete_history_with_pkgname_N) { +TEST_F(RuaTest, rua_is_latest_app_N) { int ret; - ret = rua_delete_history_with_pkgname("test"); + ret = rua_is_latest_app("pkgname"); EXPECT_NE(ret, 0); } +TEST_F(RuaTest, rua_delete_history_with_instance_id) { + EXPECT_CALL(GetMock(), + aul_delete_rua_history_for_uid(_, _)). + WillOnce(Return(0)); + + int ret; + ret = rua_delete_history_with_instance_id("appid", "instanceid"); + EXPECT_EQ(ret, 0); +} \ No newline at end of file -- 2.7.4