From e3ba8b6bce64fc66461d55070512526d901f697f Mon Sep 17 00:00:00 2001 From: hyunho Date: Mon, 19 Oct 2020 12:20:30 +0900 Subject: [PATCH] Implement additional unit tests Change-Id: I5f999ea6615656fefda8eaad7563fe7d08e6cdf5 Signed-off-by: hyunho --- CMakeLists.txt | 99 +++---- cmake/Modules/ApplyPkgConfig.cmake | 35 +++ packaging/badge.spec | 7 +- src/CMakeLists.txt | 33 +++ src/badge_internal.c | 1 - tests/unit_tests/CMakeLists.txt | 68 ++--- tests/unit_tests/data/test.sql | 51 ++++ tests/unit_tests/src/test_badge.cc | 565 +++++++++++++++++++++++++++++++++---- tool/CMakeLists.txt | 29 ++ {src => tool}/badge_init.c | 0 10 files changed, 718 insertions(+), 170 deletions(-) create mode 100644 cmake/Modules/ApplyPkgConfig.cmake create mode 100644 src/CMakeLists.txt create mode 100644 tests/unit_tests/data/test.sql create mode 100644 tool/CMakeLists.txt rename {src => tool}/badge_init.c (100%) diff --git a/CMakeLists.txt b/CMakeLists.txt index 541863a..f392d2e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,73 +1,50 @@ -CMAKE_MINIMUM_REQUIRED(VERSION 2.6) -PROJECT(badge C) +CMAKE_MINIMUM_REQUIRED(VERSION 2.8.12) -SET(CMAKE_SKIP_BUILD_RPATH true) +PROJECT(badge-capi) SET(PREFIX ${CMAKE_INSTALL_PREFIX}) -SET(EXEC_PREFIX "\${prefix}") +SET(BINDIR "${CMAKE_INSTALL_PREFIX}/bin") SET(LIBDIR ${LIB_INSTALL_DIR}) -SET(INCLUDEDIR "\${prefix}/include/${PROJECT_NAME}") +SET(INCLUDEDIR "\${prefix}/include") -SET(INIT-SRCS - src/badge_init.c -) +## Compiler flags +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden -g -Wall -Werror") +SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CFLAGS} -std=c++14 -Wall -Werror") +SET(CMAKE_CXX_FLAGS_DEBUG "-O0 -g") +SET(CMAKE_CXX_FLAGS_RELEASE "-O2") -INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/include) -AUX_SOURCE_DIRECTORY(src SRCS) -LIST(REMOVE_ITEM SRCS ${INIT-SRCS}) +## Linker flags +SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed,--gc-sections -pie") -INCLUDE(FindPkgConfig) -pkg_check_modules(pkgs REQUIRED - aul - dlog - dbus-1 - vconf - capi-appfw-package-manager - capi-system-info - db-util - libtzplatform-config - pkgmgr-info - libsmack -) - -FOREACH(flag ${pkgs_CFLAGS}) - SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}") -ENDFOREACH(flag) +SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/") -SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -fvisibility=hidden -g -Wall -Werror -Wno-error=deprecated-declarations -O2") -SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIE") +## Targets +SET(TARGET_BADGE "badge") +SET(TARGET_BADGE_INIT "badge_init") +ENABLE_TESTING() +SET(TARGET_BADGE_UNIT_TEST "badge_unittests") ADD_DEFINITIONS("-DBADGE_USE_DLOG") -ADD_LIBRARY(${PROJECT_NAME} SHARED ${SRCS}) - -SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES SOVERSION ${MAJORVER}) -SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES VERSION ${FULLVER}) -TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${pkgs_LDFLAGS}) - -ADD_EXECUTABLE(badge_init ${INIT-SRCS}) -TARGET_LINK_LIBRARIES(badge_init ${pkgs_LDFLAGS} badge "-pie") - -INSTALL(TARGETS ${PROJECT_NAME} DESTINATION ${LIB_INSTALL_DIR}) - -CONFIGURE_FILE(${PROJECT_NAME}.pc.in ${PROJECT_NAME}.pc @ONLY) -SET_DIRECTORY_PROPERTIES(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "${PROJECT_NAME}.pc") -INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc DESTINATION ${LIB_INSTALL_DIR}/pkgconfig) -INSTALL(DIRECTORY ${CMAKE_SOURCE_DIR}/include/ - DESTINATION include/${PROJECT_NAME} - FILES_MATCHING - PATTERN "*_log.h" EXCLUDE - PATTERN "*_private.h" EXCLUDE - PATTERN "*.h") - -INSTALL(FILES ${CMAKE_BINARY_DIR}/11_badge-add.post DESTINATION ${SYSCONF_INSTALL_DIR}/gumd/useradd.d/) -INSTALL(TARGETS badge_init DESTINATION bin) - -IF(NOT DEFINED MINIMUM_BUILD) +INCLUDE(FindPkgConfig) +INCLUDE(ApplyPkgConfig) + +## Find all needed packages once +PKG_CHECK_MODULES(AUL_DEP REQUIRED aul) +PKG_CHECK_MODULES(DLOG_DEPS REQUIRED dlog) +PKG_CHECK_MODULES(VCONF_DEPS REQUIRED vconf) +PKG_CHECK_MODULES(PKGMGR_DEPS REQUIRED capi-appfw-package-manager) +PKG_CHECK_MODULES(SYSTEM_INFO_DEPS REQUIRED capi-system-info) +PKG_CHECK_MODULES(DB_UTIL_DEPS REQUIRED db-util) +PKG_CHECK_MODULES(PLATFORM_CONFIG_DEPS REQUIRED libtzplatform-config) +PKG_CHECK_MODULES(PKGMGR_INFO_DEPS REQUIRED pkgmgr-info) +PKG_CHECK_MODULES(SMACK_DEPS REQUIRED libsmack) +PKG_CHECK_MODULES(GLIB_DEPS REQUIRED glib-2.0) +PKG_CHECK_MODULES(GIO_DEPS REQUIRED gio-2.0) +PKG_CHECK_MODULES(GOBJECT_DEPS REQUIRED gobject-2.0) +PKG_CHECK_MODULES(BUNDLE_DEPS REQUIRED bundle) +PKG_CHECK_MODULES(GMOCK_DEPS REQUIRED gmock) + +ADD_SUBDIRECTORY(src) +ADD_SUBDIRECTORY(tool) ADD_SUBDIRECTORY(tests) -ENABLE_TESTING() -SET(BADGE_UNIT_TESTS badge_unittests) -ADD_TEST(NAME ${BADGE_UNIT_TESTS} COMMAND ${BADGE_UNIT_TESTS}) - -ADD_DEPENDENCIES(${BADGE_UNIT_TESTS} badge) -ENDIF(NOT DEFINED MINIMUM_BUILD) diff --git a/cmake/Modules/ApplyPkgConfig.cmake b/cmake/Modules/ApplyPkgConfig.cmake new file mode 100644 index 0000000..97679d7 --- /dev/null +++ b/cmake/Modules/ApplyPkgConfig.cmake @@ -0,0 +1,35 @@ +# Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +# +# This function applies external (out of source tree) dependencies +# to given target. Arguments are: +# TARGET - valid cmake target +# PRIVACY - dependency can be inherited by dependent targets or not: +# PUBLIC - this should be used by default, cause compile/link flags passing +# PRIVATE - do not passes any settings to dependent targets, +# may be usefull for static libraries from the inside of the project +# Argument ARGV2 and following are supposed to be names of checked pkg config +# packages. This function will use variables created by check_pkg_modules(). +# - ${DEP_NAME}_LIBRARIES +# - ${DEP_NAME}_INCLUDE_DIRS +# - ${DEP_NAME}_CFLAGS +# +FUNCTION(APPLY_PKG_CONFIG TARGET PRIVACY) + MATH(EXPR DEST_INDEX "${ARGC}-1") + FOREACH(I RANGE 2 ${DEST_INDEX}) + IF(NOT ${ARGV${I}}_FOUND) + MESSAGE(FATAL_ERROR "Not found dependency - ${ARGV${I}}_FOUND") + ENDIF(NOT ${ARGV${I}}_FOUND) + TARGET_LINK_LIBRARIES(${TARGET} ${PRIVACY} "${${ARGV${I}}_LIBRARIES}") + TARGET_INCLUDE_DIRECTORIES(${TARGET} ${PRIVACY} SYSTEM "${${ARGV${I}}_INCLUDE_DIRS}") + STRING(REPLACE ";" " " CFLAGS_STR "${${ARGV${I}}_CFLAGS}") + SET(CFLAGS_LIST ${CFLAGS_STR}) + SEPARATE_ARGUMENTS(CFLAGS_LIST) + FOREACH(OPTION ${CFLAGS_LIST}) + TARGET_COMPILE_OPTIONS(${TARGET} ${PRIVACY} ${OPTION}) + ENDFOREACH(OPTION) + SET_TARGET_PROPERTIES(${TARGET} PROPERTIES SKIP_BUILD_RPATH true) + ENDFOREACH(I RANGE 2 ${DEST_INDEX}) +ENDFUNCTION(APPLY_PKG_CONFIG TARGET PRIVACY) diff --git a/packaging/badge.spec b/packaging/badge.spec index 234b925..43e1f3c 100644 --- a/packaging/badge.spec +++ b/packaging/badge.spec @@ -94,6 +94,7 @@ find . -name '*.gcno' -exec cp '{}' gcov-obj ';' %endif %check +export LD_LIBRARY_PATH=../../src ctest -V %if 0%{?gcov:1} lcov -c --ignore-errors graph --no-external -q -d . -o badge.info @@ -148,12 +149,6 @@ fi %{_libdir}/libbadge.so ################################################# -# badge_unittests -################################################# -%files -n badge_unittests -%{_bindir}/badge_unittests - -################################################# # badge-gcov ################################################# %if 0%{?gcov:1} diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt new file mode 100644 index 0000000..0a55216 --- /dev/null +++ b/src/CMakeLists.txt @@ -0,0 +1,33 @@ +AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} BADGE_SRCS) + +ADD_LIBRARY(${TARGET_BADGE} SHARED ${BADGE_SRCS}) +SET_TARGET_PROPERTIES(${TARGET_BADGE} PROPERTIES SOVERSION ${MAJORVER}) +SET_TARGET_PROPERTIES(${TARGET_BADGE} PROPERTIES VERSION ${FULLVER}) +TARGET_LINK_LIBRARIES(${TARGET_BADGE} ${pkgs_LDFLAGS}) +TARGET_INCLUDE_DIRECTORIES(${TARGET_BADGE} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../include/) + +APPLY_PKG_CONFIG(${TARGET_BADGE} PUBLIC + AUL_DEP + DLOG_DEPS + VCONF_DEPS + PKGMGR_DEPS + SYSTEM_INFO_DEPS + DB_UTIL_DEPS + PLATFORM_CONFIG_DEPS + PKGMGR_INFO_DEPS + SMACK_DEPS + GLIB_DEPS + GIO_DEPS +) + +CONFIGURE_FILE(../${TARGET_BADGE}.pc.in ../${TARGET_BADGE}.pc @ONLY) +INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/../${TARGET_BADGE}.pc DESTINATION ${LIB_INSTALL_DIR}/pkgconfig) +INSTALL(DIRECTORY ${CMAKE_SOURCE_DIR}/include/ + DESTINATION include/${TARGET_BADGE} + FILES_MATCHING + PATTERN "*_log.h" EXCLUDE + PATTERN "*_private.h" EXCLUDE + PATTERN "*.h") + +INSTALL(TARGETS ${TARGET_BADGE} DESTINATION ${LIB_INSTALL_DIR}) +INSTALL(FILES ${CMAKE_BINARY_DIR}/11_badge-add.post DESTINATION ${SYSCONF_INSTALL_DIR}/gumd/useradd.d/) diff --git a/src/badge_internal.c b/src/badge_internal.c index 5c32943..b9c77e4 100644 --- a/src/badge_internal.c +++ b/src/badge_internal.c @@ -22,7 +22,6 @@ #include #include #include -#include #include #include #include diff --git a/tests/unit_tests/CMakeLists.txt b/tests/unit_tests/CMakeLists.txt index 74d7b75..ead859a 100644 --- a/tests/unit_tests/CMakeLists.txt +++ b/tests/unit_tests/CMakeLists.txt @@ -1,48 +1,36 @@ -CMAKE_MINIMUM_REQUIRED(VERSION 2.8) -PROJECT(badge_unittests) - -INCLUDE(FindPkgConfig) -PKG_CHECK_MODULES(badge_unittests REQUIRED - gmock - aul - dlog - dbus-1 - vconf - capi-appfw-package-manager - capi-system-info - db-util - libtzplatform-config - pkgmgr-info - libsmack - gio-2.0 +AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/src UNIT_TESTS_SRCS) +AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/../mock/ UNIT_TESTS_SRCS) +ADD_EXECUTABLE(${TARGET_BADGE_UNIT_TEST} + ${UNIT_TESTS_SRCS} ) -FOREACH(flag ${badge_unittests_CFLAGS}) - SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}") -ENDFOREACH(flag) -SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -fvisibility=hidden -Wall -Werror") - -SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CFLAGS} -std=c++14") -SET(CMAKE_CXX_FLAGS_DEBUG "-O0 -g") -SET(CMAKE_CXX_FLAGS_RELEASE "-O2") +TARGET_INCLUDE_DIRECTORIES(${TARGET_BADGE_UNIT_TEST} PUBLIC + "${CMAKE_CURRENT_SOURCE_DIR}/../../include" + "${CMAKE_CURRENT_SOURCE_DIR}/../mock" +) -INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../../include) -INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../../src) -INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../mock) +APPLY_PKG_CONFIG(${TARGET_BADGE_UNIT_TEST} PUBLIC + GLIB_DEPS + GMOCK_DEPS + BUNDLE_DEPS + GOBJECT_DEPS + SYSTEM_INFO_DEPS +) -AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/src SOURCES) -AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/../mock MOCK_SOURCES) -AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/../../src LIB_SOURCES) -list(REMOVE_ITEM LIB_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/../../src/badge_init.c") +TARGET_LINK_LIBRARIES(${TARGET_BADGE_UNIT_TEST} PUBLIC ${TARGET_BADGE}) +SET_TARGET_PROPERTIES(${TARGET_BADGE_UNIT_TEST} PROPERTIES COMPILE_FLAGS "-fPIE") +SET_TARGET_PROPERTIES(${TARGET_BADGE_UNIT_TEST} PROPERTIES LINK_FLAGS "-pie") -ADD_EXECUTABLE(${PROJECT_NAME} - ${SOURCES} - ${MOCK_SOURCES} - ${LIB_SOURCES} +SET(TESTDB "badge.db") +SET(TARGET_TESTDB "badge-test-db") +ADD_CUSTOM_COMMAND(OUTPUT ${TESTDB} + COMMAND sqlite3 ${TESTDB} < data/test.sql + COMMENT " Generate test database for ${TARGET_BADGE_UNIT_TEST}" ) +ADD_CUSTOM_TARGET(${TARGET_TESTDB} DEPENDS ${TESTDB}) +ADD_DEPENDENCIES(${TARGET_BADGE_UNIT_TEST} ${TARGET_TESTDB}) -TARGET_LINK_LIBRARIES(${PROJECT_NAME} - ${badge_unittests_LDFLAGS} +ADD_TEST( + NAME ${TARGET_BADGE_UNIT_TEST} + COMMAND ${TARGET_BADGE_UNIT_TEST} ) - -INSTALL(TARGETS ${PROJECT_NAME} DESTINATION /usr/bin/) diff --git a/tests/unit_tests/data/test.sql b/tests/unit_tests/data/test.sql new file mode 100644 index 0000000..7e7c6b5 --- /dev/null +++ b/tests/unit_tests/data/test.sql @@ -0,0 +1,51 @@ +CREATE TABLE IF NOT EXISTS badge_data ( + uid INTEGER, + pkgname TEXT NOT NULL, + writable_pkgs TEXT, + badge INTEGER DEFAULT 0, + rowid INTEGER PRIMARY KEY AUTOINCREMENT, + UNIQUE (uid, pkgname) +); +CREATE TABLE IF NOT EXISTS badge_option ( + uid INTEGER, + pkgname TEXT NOT NULL, + display INTEGER DEFAULT 1, + UNIQUE (uid, pkgname) +); +CREATE TABLE IF NOT EXISTS badge_setting ( + uid INTEGER, + pkgname TEXT NOT NULL, + appid TEXT NOT NULL, + allow_to_display INTEGER DEFAULT 1, + UNIQUE (uid, pkgname, appid) +); + +INSERT INTO badge_setting ( + uid, pkgname, appid) VALUES ( + 1000, + 'pkgname', + 'pkgname' +); + + +INSERT INTO badge_setting ( + uid, pkgname, appid) VALUES ( + 1000, + 'pkgname2', + 'pkgname2' +); + +INSERT INTO badge_data ( + uid, pkgname, writable_pkgs, badge) VALUES ( + 1000, + 'pkgname', + 'writable_pkgs', + 1 +); + +INSERT INTO badge_option ( + uid, pkgname, display) VALUES ( + 1000, + 'pkgname', + 1 +); \ No newline at end of file diff --git a/tests/unit_tests/src/test_badge.cc b/tests/unit_tests/src/test_badge.cc index 0288c18..c9092c9 100644 --- a/tests/unit_tests/src/test_badge.cc +++ b/tests/unit_tests/src/test_badge.cc @@ -16,7 +16,12 @@ #include #include +#include #include "badge.h" +#include "badge_db.h" +#include "badge_internal.h" +#include "badge_setting.h" +#include "badge_setting_service.h" #include @@ -30,6 +35,41 @@ using ::testing::_; using ::testing::DoAll; using ::testing::Return; using ::testing::SetArgPointee; +using ::testing::Invoke; + + +typedef enum { + LOG_ID_INVALID = -1, + LOG_ID_MAIN, + LOG_ID_RADIO, + LOG_ID_SYSTEM, + LOG_ID_APPS, + LOG_ID_KMSG, + LOG_ID_SYSLOG, + LOG_ID_MAX +} log_id_t; + +extern "C" int __dlog_print( + log_id_t log_id, int prio, const char* tag, const char* fmt, ...) { + va_list ap; + va_start(ap, fmt); + vprintf(fmt, ap); + va_end(ap); + printf("\n"); + + return 0; +} + +extern "C" int __dlog_sec_print( + log_id_t log_id, int prio, const char* tag, const char* fmt, ...) { + va_list ap; + va_start(ap, fmt); + vprintf(fmt, ap); + va_end(ap); + printf("\n"); + + return 0; +} class Mocks : public ::testing::NiceMock, public ::testing::NiceMock, @@ -42,19 +82,29 @@ class BadgeTest : public TestFixture { virtual ~BadgeTest() {} virtual void SetUp() { + pkgid_ = const_cast("mypkgid"); + pkgid2_ = const_cast("pkgname"); + pkgid3_ = const_cast("pkgname2"); + conn_ = static_cast(g_object_new(G_TYPE_OBJECT, NULL)); + msg_ = static_cast(g_object_new(G_TYPE_OBJECT, NULL)); + msg2_ = static_cast(g_object_new(G_TYPE_OBJECT, NULL)); + } virtual void TearDown() { } + + char* pkgid_ = nullptr; + char* pkgid2_ = nullptr; + char* pkgid3_ = nullptr; + GDBusConnection* conn_ = nullptr; + GDBusMessage* msg_ = nullptr; + GDBusMessage* msg2_ = nullptr; }; TEST_F(BadgeTest, badge_new) { int ret; bool is_supported = true; - char *_pkgid = (char *)"mypkgid"; - GDBusConnection *_conn = (GDBusConnection*)g_object_new(G_TYPE_OBJECT, NULL); - GDBusMessage *_msg = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL); - GDBusMessage *_msg2 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL); EXPECT_CALL(GetMock(), system_info_get_platform_bool(_, _)). @@ -63,21 +113,21 @@ TEST_F(BadgeTest, badge_new) { EXPECT_CALL(GetMock(), aul_app_get_pkgname_bypid(_, _, _)). - WillOnce(DoAll(SetArgPointee<1>(*_pkgid), + WillOnce(DoAll(SetArgPointee<1>(*pkgid_), Return(0))); EXPECT_CALL(GetMock(), g_bus_get_sync(_, _, _)). - WillOnce(Return(_conn)); + WillOnce(Return(conn_)); EXPECT_CALL(GetMock(), g_dbus_message_new_method_call(_, _, _, _)). - WillOnce(Return(_msg)); + WillOnce(Return(msg_)); EXPECT_CALL(GetMock(), g_dbus_connection_send_message_with_reply_sync( _, _, _, _, _, _, _)). - WillOnce(Return(_msg2)); + WillOnce(Return(msg2_)); EXPECT_CALL(GetMock(), g_dbus_message_to_gerror(_, _)). @@ -85,7 +135,7 @@ TEST_F(BadgeTest, badge_new) { ret = badge_new("testappid"); - g_object_unref(_conn); + g_object_unref(conn_); EXPECT_EQ(ret, BADGE_ERROR_NONE); } @@ -93,10 +143,8 @@ TEST_F(BadgeTest, badge_new) { TEST_F(BadgeTest, badge_add) { int ret; bool is_supported = true; - char *_pkgid = (char *)"mypkgid"; - package_manager_compare_result_type_e comp_ret = PACKAGE_MANAGER_COMPARE_MATCH; - GDBusMessage *_msg = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL); - GDBusMessage *_msg2 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL); + package_manager_compare_result_type_e comp_ret = + PACKAGE_MANAGER_COMPARE_MATCH; EXPECT_CALL(GetMock(), system_info_get_platform_bool(_, _)). @@ -105,7 +153,7 @@ TEST_F(BadgeTest, badge_add) { EXPECT_CALL(GetMock(), aul_app_get_pkgname_bypid(_, _, _)). - WillOnce(DoAll(SetArgPointee<1>(*_pkgid), + WillOnce(DoAll(SetArgPointee<1>(*pkgid_), Return(0))); EXPECT_CALL(GetMock(), @@ -115,12 +163,12 @@ TEST_F(BadgeTest, badge_add) { EXPECT_CALL(GetMock(), g_dbus_message_new_method_call(_, _, _, _)). - WillOnce(Return(_msg)); + WillOnce(Return(msg_)); EXPECT_CALL(GetMock(), g_dbus_connection_send_message_with_reply_sync( _, _, _, _, _, _, _)). - WillOnce(Return(_msg2)); + WillOnce(Return(msg2_)); EXPECT_CALL(GetMock(), g_dbus_message_to_gerror(_, _)). @@ -134,9 +182,6 @@ TEST_F(BadgeTest, badge_add) { TEST_F(BadgeTest, badge_remove) { int ret; bool is_supported = true; - char *_pkgid = (char *)"mypkgid"; - GDBusMessage *_msg = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL); - GDBusMessage *_msg2 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL); EXPECT_CALL(GetMock(), system_info_get_platform_bool(_, _)). @@ -145,17 +190,17 @@ TEST_F(BadgeTest, badge_remove) { EXPECT_CALL(GetMock(), aul_app_get_pkgname_bypid(_, _, _)). - WillOnce(DoAll(SetArgPointee<1>(*_pkgid), + WillOnce(DoAll(SetArgPointee<1>(*pkgid_), Return(0))); EXPECT_CALL(GetMock(), g_dbus_message_new_method_call(_, _, _, _)). - WillOnce(Return(_msg)); + WillOnce(Return(msg_)); EXPECT_CALL(GetMock(), g_dbus_connection_send_message_with_reply_sync( _, _, _, _, _, _, _)). - WillOnce(Return(_msg2)); + WillOnce(Return(msg2_)); EXPECT_CALL(GetMock(), g_dbus_message_to_gerror(_, _)). @@ -169,9 +214,6 @@ TEST_F(BadgeTest, badge_remove) { TEST_F(BadgeTest, badge_set_count) { int ret; bool is_supported = true; - char *_pkgid = (char *)"mypkgid"; - GDBusMessage *_msg = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL); - GDBusMessage *_msg2 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL); EXPECT_CALL(GetMock(), system_info_get_platform_bool(_, _)). @@ -180,17 +222,17 @@ TEST_F(BadgeTest, badge_set_count) { EXPECT_CALL(GetMock(), aul_app_get_pkgname_bypid(_, _, _)). - WillOnce(DoAll(SetArgPointee<1>(*_pkgid), + WillOnce(DoAll(SetArgPointee<1>(*pkgid_), Return(0))); EXPECT_CALL(GetMock(), g_dbus_message_new_method_call(_, _, _, _)). - WillOnce(Return(_msg)); + WillOnce(Return(msg_)); EXPECT_CALL(GetMock(), g_dbus_connection_send_message_with_reply_sync( _, _, _, _, _, _, _)). - WillOnce(Return(_msg2)); + WillOnce(Return(msg2_)); EXPECT_CALL(GetMock(), g_dbus_message_to_gerror(_, _)). @@ -205,9 +247,7 @@ TEST_F(BadgeTest, badge_get_count) { int ret; bool is_supported = true; unsigned int count = 0; - GVariant *body = g_variant_new("(i)", 3); - GDBusMessage *_msg = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL); - GDBusMessage *_msg2 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL); + GVariant* body = g_variant_new("(i)", 3); EXPECT_CALL(GetMock(), system_info_get_platform_bool(_, _)). @@ -216,12 +256,12 @@ TEST_F(BadgeTest, badge_get_count) { EXPECT_CALL(GetMock(), g_dbus_message_new_method_call(_, _, _, _)). - WillOnce(Return(_msg)); + WillOnce(Return(msg_)); EXPECT_CALL(GetMock(), g_dbus_connection_send_message_with_reply_sync( _, _, _, _, _, _, _)). - WillOnce(Return(_msg2)); + WillOnce(Return(msg2_)); EXPECT_CALL(GetMock(), g_dbus_message_get_body(_)). @@ -242,9 +282,6 @@ TEST_F(BadgeTest, badge_get_count) { TEST_F(BadgeTest, badge_set_display) { int ret; bool is_supported = true; - char *_pkgid = (char *)"mypkgid"; - GDBusMessage *_msg = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL); - GDBusMessage *_msg2 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL); EXPECT_CALL(GetMock(), system_info_get_platform_bool(_, _)). @@ -253,17 +290,17 @@ TEST_F(BadgeTest, badge_set_display) { EXPECT_CALL(GetMock(), aul_app_get_pkgname_bypid(_, _, _)). - WillOnce(DoAll(SetArgPointee<1>(*_pkgid), + WillOnce(DoAll(SetArgPointee<1>(*pkgid_), Return(0))); EXPECT_CALL(GetMock(), g_dbus_message_new_method_call(_, _, _, _)). - WillOnce(Return(_msg)); + WillOnce(Return(msg_)); EXPECT_CALL(GetMock(), g_dbus_connection_send_message_with_reply_sync( _, _, _, _, _, _, _)). - WillOnce(Return(_msg2)); + WillOnce(Return(msg2_)); EXPECT_CALL(GetMock(), g_dbus_message_to_gerror(_, _)). @@ -278,9 +315,7 @@ TEST_F(BadgeTest, badge_get_display) { int ret; bool is_supported = true; unsigned int is_display = 0; - GVariant *body = g_variant_new("(i)", 1); - GDBusMessage *_msg = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL); - GDBusMessage *_msg2 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL); + GVariant* body = g_variant_new("(i)", 1); EXPECT_CALL(GetMock(), system_info_get_platform_bool(_, _)). @@ -289,12 +324,12 @@ TEST_F(BadgeTest, badge_get_display) { EXPECT_CALL(GetMock(), g_dbus_message_new_method_call(_, _, _, _)). - WillOnce(Return(_msg)); + WillOnce(Return(msg_)); EXPECT_CALL(GetMock(), g_dbus_connection_send_message_with_reply_sync( _, _, _, _, _, _, _)). - WillOnce(Return(_msg2)); + WillOnce(Return(msg2_)); EXPECT_CALL(GetMock(), g_dbus_message_get_body(_)). @@ -312,16 +347,15 @@ TEST_F(BadgeTest, badge_get_display) { EXPECT_EQ(ret, BADGE_ERROR_NONE); } -bool _badge_foreach_cb(const char *app_id, unsigned int count, void *user_data) { +bool _badge_foreach_cb( + const char* app_id, unsigned int count, void* user_data) { return true; } TEST_F(BadgeTest, badge_foreach) { int ret; bool is_supported = true; - GVariant *body = g_variant_new("(a(v))", NULL); - GDBusMessage *_msg = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL); - GDBusMessage *_msg2 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL); + GVariant* body = g_variant_new("(a(v))", NULL); EXPECT_CALL(GetMock(), system_info_get_platform_bool(_, _)). @@ -330,12 +364,12 @@ TEST_F(BadgeTest, badge_foreach) { EXPECT_CALL(GetMock(), g_dbus_message_new_method_call(_, _, _, _)). - WillOnce(Return(_msg)); + WillOnce(Return(msg_)); EXPECT_CALL(GetMock(), g_dbus_connection_send_message_with_reply_sync( _, _, _, _, _, _, _)). - WillOnce(Return(_msg2)); + WillOnce(Return(msg2_)); EXPECT_CALL(GetMock(), g_dbus_message_get_body(_)). @@ -350,38 +384,48 @@ TEST_F(BadgeTest, badge_foreach) { EXPECT_EQ(ret, BADGE_ERROR_NONE); } -void _badge_change_cb(unsigned int action, const char *app_id, - unsigned int count, void *user_data) { +void _badge_change_cb(unsigned int action, const char* app_id, + unsigned int count, void* user_data) { +} + +guint _signal_subscribe(GDBusConnection* connection, const gchar* sender, + const gchar* interface_name, const gchar* member, + const gchar* object_path, const gchar* arg0, GDBusSignalFlags flags, + GDBusSignalCallback callback, gpointer user_data, + GDestroyNotify user_data_free_func) { + + GVariant* parameters = g_variant_new("(si)", "pkgname", 1000); + callback(nullptr, "", "", "", "insert_badge_notify", parameters, nullptr); + return 99; } TEST_F(BadgeTest, badge_register_changed_cb) { int ret; bool is_supported = true; - GDBusMessage *_msg = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL); - GDBusMessage *_msg2 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL); - GDBusMessage *_msg3 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL); - GDBusMessage *_msg4 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL); + GDBusMessage* msg3 = static_cast( + g_object_new(G_TYPE_OBJECT, NULL)); + GDBusMessage* msg4 = static_cast( + g_object_new(G_TYPE_OBJECT, NULL)); EXPECT_CALL(GetMock(), system_info_get_platform_bool(_, _)). WillRepeatedly(DoAll(SetArgPointee<1>(is_supported), Return(0))); - EXPECT_CALL(GetMock(), g_dbus_connection_signal_subscribe( _, _, _, _, _, _, _, _, _, _)). - WillOnce(Return(99)); + WillOnce(Invoke(_signal_subscribe)); EXPECT_CALL(GetMock(), g_dbus_message_new_method_call(_, _, _, _)). - WillOnce(Return(_msg)). - WillOnce(Return(_msg2)); + WillOnce(Return(msg_)). + WillOnce(Return(msg2_)); EXPECT_CALL(GetMock(), g_dbus_connection_send_message_with_reply_sync( _, _, _, _, _, _, _)). - WillOnce(Return(_msg3)). - WillOnce(Return(_msg4)); + WillOnce(Return(msg3)). + WillOnce(Return(msg4)); EXPECT_CALL(GetMock(), g_dbus_message_to_gerror(_, _)). @@ -418,3 +462,400 @@ TEST_F(BadgeTest, badge_unregister_changed_cb) { EXPECT_EQ(ret, BADGE_ERROR_NONE); } + +extern "C" const char* tzplatform_mkpath( + enum tzplatform_variable id, const char* path) { + return "badge.db"; +} + +TEST_F(BadgeTest, badge_db_is_existing) { + bool existing; + badge_db_init(); + int ret = badge_db_is_existing("test", &existing, getuid()); + EXPECT_EQ(ret, BADGE_ERROR_NONE); +} + +TEST_F(BadgeTest, badge_db_insert) { + EXPECT_CALL(GetMock(), + aul_app_get_pkgname_bypid(_, _, _)). + WillOnce(DoAll(SetArgPointee<1>(*pkgid_), + Return(0))); + int ret = badge_db_insert(pkgid3_, "writable_pkg", "caller", 1000); + EXPECT_EQ(ret, BADGE_ERROR_NONE); +} + +TEST_F(BadgeTest, badge_db_get_list) { + GList* list = nullptr; + int ret = badge_db_get_list(&list, 1000); + EXPECT_EQ(ret, BADGE_ERROR_NONE); +} + +TEST_F(BadgeTest, badge_db_delete) { + int ret = badge_db_delete(pkgid2_, "writable_pkgs", getuid(), getpid()); + EXPECT_EQ(ret, BADGE_ERROR_NONE); +} + +TEST_F(BadgeTest, badge_db_delete_by_pkgname) { + EXPECT_CALL(GetMock(), + aul_app_get_pkgname_bypid(_, _, _)). + WillOnce(DoAll(SetArgPointee<1>(*pkgid_), + Return(0))); + int ret = badge_db_insert(pkgid2_, "writable_pkg", "caller", 1000); + ret = badge_db_delete_by_pkgname(pkgid2_, 1000); + EXPECT_EQ(ret, BADGE_ERROR_NONE); +} + +TEST_F(BadgeTest, badge_db_set_count) { + int ret = badge_db_set_count(pkgid3_, "caller", 2, getuid(), getpid()); + EXPECT_EQ(ret, BADGE_ERROR_NONE); +} + +TEST_F(BadgeTest, badge_db_get_count) { + unsigned int cnt; + int ret = badge_db_get_count(pkgid3_, &cnt, getuid()); + EXPECT_EQ(ret, BADGE_ERROR_NONE); +} + +TEST_F(BadgeTest, badge_db_set_display_option) { + int ret = badge_db_set_display_option(pkgid3_, 1, getuid()); + EXPECT_EQ(ret, BADGE_ERROR_NONE); +} + +TEST_F(BadgeTest, badge_db_get_display_option) { + unsigned int is_display; + int ret = badge_db_get_display_option(pkgid3_, &is_display, getuid()); + EXPECT_EQ(ret, BADGE_ERROR_NONE); +} + +TEST_F(BadgeTest, badge_create_for_uid) { + EXPECT_CALL(GetMock(), + system_info_get_platform_bool(_, _)). + WillOnce(DoAll( + SetArgPointee<1>(true), + Return(0))); + + EXPECT_CALL(GetMock(), + aul_app_get_pkgname_bypid(_, _, _)). + WillOnce(DoAll(SetArgPointee<1>(*pkgid_), + Return(0))); + EXPECT_CALL(GetMock(), + g_dbus_message_new_method_call(_, _, _, _)). + WillOnce(Return(msg_)); + + EXPECT_CALL(GetMock(), + g_dbus_connection_send_message_with_reply_sync( + _, _, _, _, _, _, _)). + WillOnce(Return(msg2_)); + + EXPECT_CALL(GetMock(), + g_dbus_message_to_gerror(_, _)). + WillOnce(Return(FALSE)); + int ret = badge_create_for_uid(pkgid3_, "writable_pkg", 1000); + EXPECT_EQ(ret, BADGE_ERROR_NONE); +} + +TEST_F(BadgeTest, badge_new_for) { + EXPECT_CALL(GetMock(), + system_info_get_platform_bool(_, _)). + WillRepeatedly(DoAll( + SetArgPointee<1>(true), + Return(0))); + + EXPECT_CALL(GetMock(), + aul_app_get_pkgname_bypid(_, _, _)). + WillOnce(DoAll(SetArgPointee<1>(*pkgid_), + Return(0))); + EXPECT_CALL(GetMock(), + g_dbus_message_new_method_call(_, _, _, _)). + WillOnce(Return(msg_)); + + EXPECT_CALL(GetMock(), + g_dbus_connection_send_message_with_reply_sync( + _, _, _, _, _, _, _)). + WillOnce(Return(msg2_)); + + EXPECT_CALL(GetMock(), + g_dbus_message_to_gerror(_, _)). + WillOnce(Return(FALSE)); + int ret = badge_new_for(nullptr, "writable_pkg"); + EXPECT_EQ(ret, BADGE_ERROR_NONE); +} + +extern "C" GVariant* g_dbus_connection_call_sync( + GDBusConnection* connection, const gchar* bus_name, + const gchar* object_path, const gchar* interface_name, + const gchar* method_name, GVariant* parameters, + const GVariantType* reply_type, GDBusCallFlags flags, + gint timeout_msec, GCancellable* cancellable, GError** error) { + return g_variant_new("(b)", 1); +} + +TEST_F(BadgeTest, badge_is_service_ready) { + EXPECT_CALL(GetMock(), + system_info_get_platform_bool(_, _)). + WillOnce(DoAll( + SetArgPointee<1>(true), + Return(0))); + + int ret = badge_is_service_ready(); + EXPECT_EQ(ret, 1); +} + +void _deferred_task(void* data) { +} + +TEST_F(BadgeTest, badge_add_deferred_task) { + EXPECT_CALL(GetMock(), + system_info_get_platform_bool(_, _)). + WillOnce(DoAll( + SetArgPointee<1>(true), + Return(0))); + int ret = badge_add_deferred_task(_deferred_task, nullptr); + EXPECT_EQ(ret, BADGE_ERROR_NONE); +} + +TEST_F(BadgeTest, badge_del_deferred_task) { + EXPECT_CALL(GetMock(), + system_info_get_platform_bool(_, _)). + WillOnce(DoAll( + SetArgPointee<1>(true), + Return(0))); + int ret = badge_del_deferred_task(_deferred_task); + EXPECT_EQ(ret, BADGE_ERROR_NONE); +} + +TEST_F(BadgeTest, badge_is_existing) { + EXPECT_CALL(GetMock(), + system_info_get_platform_bool(_, _)). + WillRepeatedly(DoAll( + SetArgPointee<1>(true), + Return(0))); + + EXPECT_CALL(GetMock(), + g_dbus_message_new_method_call(_, _, _, _)). + WillOnce(Return(msg_)); + + EXPECT_CALL(GetMock(), + g_dbus_connection_send_message_with_reply_sync( + _, _, _, _, _, _, _)). + WillOnce(Return(msg2_)); + + EXPECT_CALL(GetMock(), + g_dbus_message_to_gerror(_, _)). + WillOnce(Return(FALSE)); + bool existing; + int ret = badge_is_existing(pkgid3_, &existing); + EXPECT_EQ(ret, BADGE_ERROR_NONE); +} + +TEST_F(BadgeTest, badge_create) { + EXPECT_CALL(GetMock(), + system_info_get_platform_bool(_, _)). + WillRepeatedly(DoAll( + SetArgPointee<1>(true), + Return(0))); + + EXPECT_CALL(GetMock(), + aul_app_get_pkgname_bypid(_, _, _)). + WillOnce(DoAll(SetArgPointee<1>(*pkgid_), + Return(0))); + EXPECT_CALL(GetMock(), + g_dbus_message_new_method_call(_, _, _, _)). + WillOnce(Return(msg_)); + + EXPECT_CALL(GetMock(), + g_dbus_connection_send_message_with_reply_sync( + _, _, _, _, _, _, _)). + WillOnce(Return(msg2_)); + + EXPECT_CALL(GetMock(), + g_dbus_message_to_gerror(_, _)). + WillOnce(Return(FALSE)); + int ret = badge_create("pkgname3", "writable"); + EXPECT_EQ(ret, BADGE_ERROR_NONE); +} + +TEST_F(BadgeTest, badge_setting_positive) { + badge_setting_h setting; + GVariant* reply_body = g_variant_new("(v)", + g_variant_new("(ssi)", pkgid2_, "appid", 1)); + auto v_ptr = + std::unique_ptr( + reply_body, g_object_unref); + + EXPECT_CALL(GetMock(), + system_info_get_platform_bool(_, _)). + WillRepeatedly(DoAll(SetArgPointee<1>(true), + Return(0))); + EXPECT_CALL(GetMock(), + g_dbus_message_new_method_call(_, _, _, _)). + WillRepeatedly(Return(msg_)); + + EXPECT_CALL(GetMock(), + g_dbus_connection_send_message_with_reply_sync( + _, _, _, _, _, _, _)). + WillRepeatedly(Return(msg_)); + + EXPECT_CALL(GetMock(), + g_dbus_message_get_body(_)). + WillRepeatedly(Return(reply_body)); + + EXPECT_CALL(GetMock(), + g_dbus_message_to_gerror(_, _)). + WillRepeatedly(Return(FALSE)); + + int ret = badge_setting_get_setting_by_appid(&setting, "appid"); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + + char* pkgname; + ret = badge_setting_get_pkgname(setting, &pkgname); + if (pkgname) + free(pkgname); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + + char* appid; + ret = badge_setting_get_appid(setting, &appid); + if (appid) + free(appid); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + + ret = badge_setting_set_allow_to_display(setting, true); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + + bool allow; + ret = badge_setting_get_allow_to_display(setting, &allow); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + + ret = badge_setting_update_setting(setting); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + + ret = badge_setting_free_setting(setting); + EXPECT_EQ(ret, BADGE_ERROR_NONE); +} + +TEST_F(BadgeTest, badge_setting_negative) { + int ret = badge_setting_get_setting_by_appid(nullptr, nullptr); + EXPECT_EQ(ret, BADGE_ERROR_INVALID_PARAMETER); + + char* pkgname; + ret = badge_setting_get_pkgname(nullptr, &pkgname); + EXPECT_EQ(ret, BADGE_ERROR_INVALID_PARAMETER); + + char* appid; + ret = badge_setting_get_appid(nullptr, &appid); + EXPECT_EQ(ret, BADGE_ERROR_INVALID_PARAMETER); + + ret = badge_setting_set_allow_to_display(nullptr, true); + EXPECT_EQ(ret, BADGE_ERROR_INVALID_PARAMETER); + + bool allow; + ret = badge_setting_get_allow_to_display(nullptr, &allow); + EXPECT_EQ(ret, BADGE_ERROR_INVALID_PARAMETER); + + ret = badge_setting_update_setting(nullptr); + EXPECT_EQ(ret, BADGE_ERROR_INVALID_PARAMETER); + + ret = badge_setting_free_setting(nullptr); + EXPECT_EQ(ret, BADGE_ERROR_INVALID_PARAMETER); +} + +TEST_F(BadgeTest, badge_db_get_setting_by_appid) { + badge_setting_h setting; + int ret = badge_db_get_setting_by_appid(pkgid3_, &setting, 1000); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + badge_setting_free_setting(setting); +} + +TEST_F(BadgeTest, badge_db_update_setting) { + int ret = badge_db_update_setting(pkgid3_, pkgid3_, 1, 1000); + EXPECT_EQ(ret, BADGE_ERROR_NONE); +} + +TEST_F(BadgeTest, badge_db_get_allow_to_display_by_appid) { + int allow_to_display; + int ret = badge_db_get_allow_to_display_by_appid( + pkgid3_, &allow_to_display, 1000); + EXPECT_EQ(ret, BADGE_ERROR_NONE); +} + +TEST_F(BadgeTest, badge_db_update_app_disabled) { + int ret = badge_db_update_app_disabled( + pkgid3_, true, 1000); + EXPECT_EQ(ret, BADGE_ERROR_NONE); +} + +TEST_F(BadgeTest, badge_db_update_pkg_disabled) { + int ret = badge_db_update_pkg_disabled( + pkgid3_, true, 1000); + EXPECT_EQ(ret, BADGE_ERROR_NONE); +} + +extern "C" int pkgmgrinfo_pkginfo_filter_create( + pkgmgrinfo_pkginfo_filter_h* handle) { + return PMINFO_R_OK; +} + +extern "C" int pkgmgrinfo_pkginfo_filter_add_string( + pkgmgrinfo_pkginfo_filter_h handle, const char* property, + const char* value) { + return PMINFO_R_OK; +} + +extern "C" int pkgmgrinfo_appinfo_filter_add_bool( + pkgmgrinfo_appinfo_filter_h handle, + const char* property, const bool value) { + return PMINFO_R_OK; +} + +extern "C" int pkgmgrinfo_pkginfo_get_pkgname( + pkgmgrinfo_pkginfo_h handle, char** pkg_name) { + *pkg_name = const_cast("pkgname"); + return PMINFO_R_OK; +} + +extern "C" int pkgmgrinfo_appinfo_filter_create( + pkgmgrinfo_appinfo_filter_h* handle) { + return PMINFO_R_OK; +} + +extern "C" int pkgmgrinfo_appinfo_filter_add_string( + pkgmgrinfo_appinfo_filter_h handle, const char* property, + const char* value) { + return PMINFO_R_OK; +} + +extern "C" int pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo( + pkgmgrinfo_pkginfo_filter_h handle, + pkgmgrinfo_pkg_list_cb pkg_cb, void* user_data, uid_t uid) { + pkg_cb(nullptr, user_data); + return PMINFO_R_OK; +} + +extern "C" int pkgmgrinfo_appinfo_usr_filter_foreach_appinfo( + pkgmgrinfo_appinfo_filter_h handle, + pkgmgrinfo_app_list_cb app_cb, void* user_data, uid_t uid) { + + return PMINFO_R_OK; +} + +extern "C" int pkgmgrinfo_appinfo_get_appid( + pkgmgrinfo_appinfo_h handle, char** appid) { + *appid = const_cast("pkgname"); + return PMINFO_R_OK; +} + +extern "C" int pkgmgrinfo_appinfo_get_pkgname( + pkgmgrinfo_appinfo_h handle, char** pkg_name) { + *pkg_name = const_cast("pkgname"); + return PMINFO_R_OK; +} + +TEST_F(BadgeTest, badge_setting_insert_package_for_uid) { + int ret = badge_setting_insert_package_for_uid(pkgid2_, 1000); + EXPECT_EQ(ret, BADGE_ERROR_NONE); +} + +TEST_F(BadgeTest, badge_setting_delete_package_for_uid) { + int ret = badge_setting_delete_package_for_uid(pkgid2_, 1000); + EXPECT_EQ(ret, BADGE_ERROR_NONE); +} diff --git a/tool/CMakeLists.txt b/tool/CMakeLists.txt new file mode 100644 index 0000000..7b9dae5 --- /dev/null +++ b/tool/CMakeLists.txt @@ -0,0 +1,29 @@ +AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/ BADGE_INIT_SRCS) +ADD_EXECUTABLE(${TARGET_BADGE_INIT} + ${BADGE_INIT_SRCS} +) + +TARGET_INCLUDE_DIRECTORIES(${TARGET_BADGE_INIT} PUBLIC + "${CMAKE_CURRENT_SOURCE_DIR}/../include" +) + +APPLY_PKG_CONFIG(${TARGET_BADGE_INIT} PUBLIC + AUL_DEP + DLOG_DEPS + VCONF_DEPS + PKGMGR_DEPS + SYSTEM_INFO_DEPS + DB_UTIL_DEPS + PLATFORM_CONFIG_DEPS + PKGMGR_INFO_DEPS + SMACK_DEPS + GLIB_DEPS + GIO_DEPS +) + + +TARGET_LINK_LIBRARIES(${TARGET_BADGE_INIT} PUBLIC ${TARGET_BADGE}) +SET_TARGET_PROPERTIES(${TARGET_BADGE_INIT} PROPERTIES COMPILE_FLAGS "-fPIE") +SET_TARGET_PROPERTIES(${TARGET_BADGE_INIT} PROPERTIES LINK_FLAGS "-pie") + +INSTALL(TARGETS badge_init DESTINATION bin) \ No newline at end of file diff --git a/src/badge_init.c b/tool/badge_init.c similarity index 100% rename from src/badge_init.c rename to tool/badge_init.c -- 2.7.4