From a749308f60e860e33779a07db450319327089a70 Mon Sep 17 00:00:00 2001 From: JinWang An Date: Thu, 23 Jul 2020 02:25:12 +0900 Subject: [PATCH] Add unit test to increase coverage Change-Id: I79d77c39cecde9fb345f584389823ab88ec35336 Signed-off-by: JinWang An --- packaging/capi-system-system-settings.spec | 10 +- tests/CMakeLists.txt | 36 ++- tests/mocks/alarmmgr.c | 32 +++ tests/mocks/efl.c | 19 +- tests/mocks/libc.c | 46 +++ tests/mocks/pkgmgrinfo_appinfo.c | 67 ++++- tests/mocks/sstt_mock.h | 62 ++++ tests/mocks/system_info.c | 21 ++ tests/mocks/vconf.cpp | 448 +++++++++++------------------ tests/mocks/xml.c | 47 +++ tests/res/99-tizen.conf | 82 ++++++ tests/res/bg_test.png | Bin 22369 -> 0 bytes tests/scripts/ringtone_files.sh | 24 -- tests/sst_gtest_api.cpp | 158 ++++++++-- tests/sst_gtest_err_interface.cpp | 57 ++++ tests/sst_gtest_font.cpp | 82 +++++- tests/sst_gtest_interface.cpp | 8 +- tests/sst_gtest_misc.cpp | 113 +++++++- tests/sst_gtest_screen.cpp | 167 +++++++++-- tests/sst_gtest_sound.cpp | 187 ++++++++++-- tests/sst_gtest_time_N_locale.cpp | 163 +++++++++-- tests/sst_gtest_vconf.cpp | 168 +++++++++-- tests/sstt.h | 127 -------- tests/sstt_main.c | 132 --------- 24 files changed, 1528 insertions(+), 728 deletions(-) create mode 100644 tests/mocks/alarmmgr.c create mode 100644 tests/mocks/sstt_mock.h create mode 100644 tests/mocks/xml.c create mode 100644 tests/res/99-tizen.conf delete mode 100644 tests/res/bg_test.png delete mode 100755 tests/scripts/ringtone_files.sh create mode 100644 tests/sst_gtest_err_interface.cpp delete mode 100644 tests/sstt.h delete mode 100644 tests/sstt_main.c diff --git a/packaging/capi-system-system-settings.spec b/packaging/capi-system-system-settings.spec index 598ce02..b4b3e44 100644 --- a/packaging/capi-system-system-settings.spec +++ b/packaging/capi-system-system-settings.spec @@ -129,8 +129,9 @@ tar xf %{name}-gcov.tar -C %{buildroot}%{_datadir}/gcov/obj %endif %check -bash tests/scripts/vconf_golden_master.sh -LD_LIBRARY_PATH=.:tests:libutil LD_PRELOAD=tests/libsys-settings-mock.so tests/sst-unit-test +#bash tests/scripts/vconf_golden_master.sh +LD_LIBRARY_PATH=.:tests:libutil tests/sst-unit-test-err-interface +LD_LIBRARY_PATH=.:tests:libutil tests/sst-unit-test %if 0%{?gcov:1} lcov -c --ignore-errors graph --no-external -b . -d . -o %{name}.info genhtml %{name}.info -o out --legend --show-details @@ -138,14 +139,9 @@ genhtml %{name}.info -o out --legend --show-details %post -p /sbin/ldconfig %post util-lib -p /sbin/ldconfig -%post unittests -bash %{sys_setting_test_dir}/ringtone_files.sh create -XDG_RUNTIME_DIR=/run %{sys_setting_test_dir}/sst-unit-test %postun -p /sbin/ldconfig %postun util-lib -p /sbin/ldconfig -%postun unittests -bash %{sys_setting_test_dir}/ringtone/ringtone_files.sh del %files %manifest %{name}.manifest diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index c3cd93e..95aef25 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -3,14 +3,17 @@ SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIE") SET(SST_SRC_DIR ${CMAKE_SOURCE_DIR}/src) SET(SST_UTIL_DIR ${CMAKE_SOURCE_DIR}/libutil) +FILE(GLOB SSTT_COMMON_SRC + ${SST_SRC_DIR}/*.c + ${SST_SRC_DIR}/standard_excl/*.c + sst_gtest_main.cpp + ) + ADD_DEFINITIONS("-DSST_TEST") ADD_DEFINITIONS("-DN_THREADS=${N_THREADS}") ADD_DEFINITIONS(-DSYS_SETTINGS_TEST_DIR=\"${TEST_INSTALL_DIR}\") -INSTALL(DIRECTORY res/ DESTINATION ${TEST_INSTALL_DIR}) -INSTALL(FILES scripts/ringtone_files.sh DESTINATION ${TEST_INSTALL_DIR}) - -pkg_check_modules(gtest_pkgs REQUIRED gmock) +pkg_check_modules(gtest_pkgs REQUIRED gmock json-glib-1.0) INCLUDE_DIRECTORIES(${gtest_pkgs_INCLUDE_DIRS}) INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/src) LINK_DIRECTORIES(${gtest_pkgs_LIBRARY_DIRS}) @@ -20,10 +23,23 @@ FILE(GLOB MOCK_SRCS mocks/*.c mocks/*.cpp) ADD_LIBRARY(${MOCK_LIB} SHARED ${MOCK_SRCS}) SET(SSTT_GTEST "sst-unit-test") -FILE(GLOB SSTT_GTEST_SRC - ${SST_SRC_DIR}/*.c - ${SST_SRC_DIR}/standard_excl/*.c - *.cpp) -ADD_EXECUTABLE(${SSTT_GTEST} ${SRC} ${SSTT_GTEST_SRC}) -TARGET_LINK_LIBRARIES(${SSTT_GTEST} ${gtest_pkgs_LIBRARIES} ${pkgs_LIBRARIES} dl) +SET(SSTT_GTEST_SRC sst_gtest_api.cpp + sst_gtest_font.cpp + sst_gtest_misc.cpp + sst_gtest_screen.cpp + sst_gtest_sound.cpp + sst_gtest_time_N_locale.cpp + sst_gtest_interface.cpp + sst_gtest_vconf.cpp) +ADD_EXECUTABLE(${SSTT_GTEST} ${SSTT_COMMON_SRC} ${SSTT_GTEST_SRC}) +TARGET_LINK_LIBRARIES(${SSTT_GTEST} ${MOCK_LIB} ${gtest_pkgs_LIBRARIES} ${pkgs_LIBRARIES} dl) INSTALL(TARGETS ${SSTT_GTEST} DESTINATION ${TEST_INSTALL_DIR}) + + +SET(SSTT_GTEST_INTERFACE "sst-unit-test-err-interface") +SET(SSTT_GTEST_INTERFACE_SRC sst_gtest_err_interface.cpp) +ADD_EXECUTABLE(${SSTT_GTEST_INTERFACE} ${SSTT_COMMON_SRC} ${SSTT_GTEST_INTERFACE_SRC}) +TARGET_LINK_LIBRARIES(${SSTT_GTEST_INTERFACE} ${MOCK_LIB} ${gtest_pkgs_LIBRARIES} ${pkgs_LIBRARIES} dl) +INSTALL(TARGETS ${SSTT_GTEST_INTERFACE} DESTINATION ${TEST_INSTALL_DIR}) + + diff --git a/tests/mocks/alarmmgr.c b/tests/mocks/alarmmgr.c new file mode 100644 index 0000000..94790aa --- /dev/null +++ b/tests/mocks/alarmmgr.c @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved + * + * 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 "sst.h" +#include "sstt_mock.h" + +static int sstm_alarmmgr_set_timezone = ALARMMGR_RESULT_SUCCESS; + +API void sstm_alarmmgr_set_timezone_setup(int result) +{ + sstm_alarmmgr_set_timezone = result; +} + +API int alarmmgr_set_timezone(char *tzpath_str) +{ + return sstm_alarmmgr_set_timezone; +} diff --git a/tests/mocks/efl.c b/tests/mocks/efl.c index 1edd937..8a9f73f 100644 --- a/tests/mocks/efl.c +++ b/tests/mocks/efl.c @@ -17,14 +17,27 @@ #include #include #include "sst.h" +#include "sstt_mock.h" + +static bool sstm_eext_config_font_set = true; +static int sstm_evas_object_image_load_error_get = 0; + +API void sstm_eext_config_font_set_setup(bool result) +{ + sstm_eext_config_font_set = result; +} + +API void sstm_evas_object_image_load_error_setup(int result) +{ + sstm_evas_object_image_load_error_get = result; +} API bool eext_config_font_set(char *name, int size) { - return true; + return sstm_eext_config_font_set; } API int evas_object_image_load_error_get(void *img) { - INFO("Enter return 0"); - return 0; + return sstm_evas_object_image_load_error_get; } diff --git a/tests/mocks/libc.c b/tests/mocks/libc.c index 4f02b8b..b193440 100644 --- a/tests/mocks/libc.c +++ b/tests/mocks/libc.c @@ -20,9 +20,38 @@ #include #include #include "sst.h" +#include "sstt_mock.h" + +static bool sstm_access_enable = true; +static bool sstm_readlink_enable = true; +static bool sstm_opendir_enable = true; +static bool sstm_dlopen_enable = true; + +API void sstm_access_setup(bool enable) +{ + sstm_access_enable = enable; +} + +API void sstm_readlink_setup(bool enable) +{ + sstm_readlink_enable = enable; +} + +API void sstm_opendir_setup(bool enable) +{ + sstm_opendir_enable = enable; +} + +API void sstm_dlopen_setup(bool enable) +{ + sstm_dlopen_enable = enable; +} API int access(const char *pathname, int mode) { + if (false == sstm_access_enable) + return -1; + if (0 == strcmp(pathname, SYS_SETTINGS_TEST_DIR"/ringtone_sdk.mp3")) return 0; if (0 == strcmp(pathname, SYS_SETTINGS_TEST_DIR"/Over the horizon.mp3")) @@ -48,6 +77,10 @@ API int access(const char *pathname, int mode) API ssize_t readlink(const char *restrict path, char *restrict buf, size_t len) { const char *local = "/usr/share/zoneinfo/Asia/Seoul"; + + if (false == sstm_readlink_enable) + return -1; + if (0 == strcmp(path, "/opt/etc/localtime")) { strncpy(buf, local, len); return (sizeof(local) - 1); @@ -61,6 +94,9 @@ API ssize_t readlink(const char *restrict path, char *restrict buf, size_t len) API DIR *opendir(const char *name) { DIR *(*org_fn)(const char *); + if (false == sstm_opendir_enable) + return NULL; + org_fn = dlsym(RTLD_NEXT, "opendir"); if (0 == strcmp(name, SST_RES_DIR"/Ringtones")) { @@ -70,3 +106,13 @@ API DIR *opendir(const char *name) return org_fn(name); } + +API void* dlopen(const char *filename, int flag) +{ + if (false == sstm_dlopen_enable) + return NULL; + + void *(*org_fn)(const char *filename, int flag); + org_fn = dlsym(RTLD_NEXT, "dlopen"); + return org_fn(filename, flag); +} diff --git a/tests/mocks/pkgmgrinfo_appinfo.c b/tests/mocks/pkgmgrinfo_appinfo.c index 6d29f08..0db14c9 100644 --- a/tests/mocks/pkgmgrinfo_appinfo.c +++ b/tests/mocks/pkgmgrinfo_appinfo.c @@ -13,25 +13,78 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +#include +#include #include +#include +#include #include "sst.h" +#include "sstt_mock.h" + +static int sstm_pkgmgrinfo_appinfo_get_appinfo = PMINFO_R_OK; +static int sstm_pkgmgrinfo_appinfo_foreach_category = PMINFO_R_OK; +static bool sstm_pkgmgrinfo_appinfo_foreach_category_lockscreen = false; +static int sstm_pkgmgrinfo_appinfo_destroy_appinfo = PMINFO_R_OK; +static int sstm_package_manager_get_package_id_by_app_id = PACKAGE_MANAGER_ERROR_NONE; +static char sstm_package_manager_get_package_id[256] = {0, }; +static int sstm_app_manager_get_app_id = APP_MANAGER_ERROR_NONE; + +API void sstm_pkgmgrinfo_appinfo_get_appinfo_setup(int result) +{ + sstm_pkgmgrinfo_appinfo_get_appinfo = result; +} + +API void sstm_pkgmgrinfo_appinfo_foreach_category_setup(int result, bool lockscreen) +{ + sstm_pkgmgrinfo_appinfo_foreach_category = result; + sstm_pkgmgrinfo_appinfo_foreach_category_lockscreen = lockscreen; +} + +API void sstm_pkgmgrinfo_appinfo_destroy_appinfo_setup(int result) +{ + sstm_pkgmgrinfo_appinfo_destroy_appinfo = result; +} + +API void sstm_app_manager_get_app_id_setup(int result) +{ + sstm_app_manager_get_app_id = result; +} + +API void sstm_package_manager_get_package_id_by_app_id_setup(const char *package_id, int result) +{ + snprintf(sstm_package_manager_get_package_id, sizeof(sstm_package_manager_get_package_id) - 1, "%s", package_id); + sstm_package_manager_get_package_id_by_app_id = result; +} API int pkgmgrinfo_appinfo_get_appinfo(const char *appid, pkgmgrinfo_appinfo_h *handle) { - return PMINFO_R_OK; + return sstm_pkgmgrinfo_appinfo_get_appinfo; } API int pkgmgrinfo_appinfo_foreach_category(pkgmgrinfo_appinfo_h handle, pkgmgrinfo_app_category_list_cb category_func, void *user_data) { - if (!category_func) - return PMINFO_R_OK; - category_func("wall-screen", user_data); - category_func("lock-screen", user_data); - return PMINFO_R_OK; + if (category_func) { + if (true == sstm_pkgmgrinfo_appinfo_foreach_category_lockscreen) + category_func("lock-screen", user_data); + else + category_func("wall-screen", user_data); + } + return sstm_pkgmgrinfo_appinfo_foreach_category; } API int pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo_h handle) { - return PMINFO_R_OK; + return sstm_pkgmgrinfo_appinfo_destroy_appinfo; +} + +API int app_manager_get_app_id(pid_t pid, char **app_id) +{ + return sstm_app_manager_get_app_id; +} + +API int package_manager_get_package_id_by_app_id(const char *app_id, char **package_id) +{ + *package_id = strdup(sstm_package_manager_get_package_id); + return sstm_package_manager_get_package_id_by_app_id; } diff --git a/tests/mocks/sstt_mock.h b/tests/mocks/sstt_mock.h new file mode 100644 index 0000000..9a098c1 --- /dev/null +++ b/tests/mocks/sstt_mock.h @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved + * + * 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 + +#ifdef __cplusplus +extern "C" +{ +#endif +void sstt_set_error(bool flag); +bool sstt_get_error(); +void sstt_efl_set_error(bool flag); +bool sstt_efl_get_error(); + +void sstm_access_setup(bool enable); +void sstm_readlink_setup(bool enable); +void sstm_opendir_setup(bool enable); +void sstm_dlopen_setup(bool enable); + +void sstm_eext_config_font_set_setup(bool result); +void sstm_evas_object_image_load_error_setup(int result); + +void sstm_pkgmgrinfo_appinfo_get_appinfo_setup(int result); +void sstm_pkgmgrinfo_appinfo_foreach_category_setup(int result, bool lockscreen); +void sstm_pkgmgrinfo_appinfo_destroy_appinfo_setup(int result); +void sstm_app_manager_get_app_id_setup(int result); + +void sstm_package_manager_get_package_id_by_app_id_setup(const char *package_id, int result); + +void sstm_alarmmgr_set_timezone_setup(int result); + +void sstm_xmlParseFile_setup(bool enable); + +void sstm_vconf_get_int_setup(const char *key, int val, int ret); +void sstm_vconf_get_bool_setup(const char *key, bool val, int ret); +void sstm_vconf_get_str_setup(const char *key, const char *val, int ret); +void sstm_vconf_set_int_setup(const char *key, int ret); +void sstm_vconf_set_bool_setup(const char *key, int ret); +void sstm_vconf_set_str_setup(const char *key, int ret); +void sstm_vconf_clear_str(const char *key); +void sstm_vconf_notify_key_changed_setup(bool enable); +void sstm_vconf_ignore_key_changed_setup(bool enable); + +void sstm_system_info_get_platform_string_setup(bool enable); +void sstm_system_info_get_platform_bool_setup(bool enable); + +#ifdef __cplusplus +} +#endif diff --git a/tests/mocks/system_info.c b/tests/mocks/system_info.c index b82121b..5fba95b 100644 --- a/tests/mocks/system_info.c +++ b/tests/mocks/system_info.c @@ -17,10 +17,28 @@ #include #include #include +#include #include "sst.h" +#include "sstt_mock.h" + +static bool sstm_system_info_get_platform_string_enable = true; +static bool sstm_system_info_get_platform_bool_enable = true; + +API void sstm_system_info_get_platform_string_setup(bool enable) +{ + sstm_system_info_get_platform_string_enable = enable; +} + +API void sstm_system_info_get_platform_bool_setup(bool enable) +{ + sstm_system_info_get_platform_bool_enable = enable; +} API int system_info_get_platform_bool(const char *key, bool *value) { + if (false == sstm_system_info_get_platform_bool_enable) + return TIZEN_ERROR_IO_ERROR; + if (0 == strcmp(key, "tizen.org/feature/systemsetting.font")) { *value = true; return 0; @@ -69,6 +87,9 @@ API int system_info_get_platform_bool(const char *key, bool *value) API int system_info_get_platform_string(const char *key, char **value) { + if (false == sstm_system_info_get_platform_string_enable) + return TIZEN_ERROR_IO_ERROR; + if (0 == strcmp(key, "tizen.org/feature/profile")) { *value = strdup("wearable"); return 0; diff --git a/tests/mocks/vconf.cpp b/tests/mocks/vconf.cpp index 20022c7..d999d65 100644 --- a/tests/mocks/vconf.cpp +++ b/tests/mocks/vconf.cpp @@ -13,18 +13,13 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - #include #include #include -#include -#include -#include - -#include #include #include #include "sst.h" +#include "sstt_mock.h" using namespace std; @@ -37,69 +32,142 @@ extern "C" { #define VCONF_OK 0 #define VCONF_ERROR -1 -#define VCONF_ERROR_WRONG_PREFIX -2 -#define VCONF_ERROR_WRONG_TYPE -3 -#define VCONF_ERROR_WRONG_VALUE -4 -#define VCONF_ERROR_NOT_INITIALIZED -5 -#define VCONF_ERROR_NO_MEM -6 -#define VCONF_ERROR_FILE_PERM -11 -#define VCONF_ERROR_FILE_BUSY -12 -#define VCONF_ERROR_FILE_NO_MEM -13 -#define VCONF_ERROR_FILE_NO_ENT -14 -#define VCONF_ERROR_FILE_OPEN -21 -#define VCONF_ERROR_FILE_FREAD -22 -#define VCONF_ERROR_FILE_FGETS -23 -#define VCONF_ERROR_FILE_WRITE -24 -#define VCONF_ERROR_FILE_SYNC -25 -#define VCONF_ERROR_FILE_CLOSE -26 -#define VCONF_ERROR_FILE_ACCESS -27 -#define VCONF_ERROR_FILE_CHMOD -28 -#define VCONF_ERROR_FILE_LOCK -29 -#define VCONF_ERROR_FILE_REMOVE -30 -#define VCONF_ERROR_FILE_SEEK -31 -#define VCONF_ERROR_FILE_TRUNCATE -32 -#define VCONF_ERROR_NOT_SUPPORTED -33 - -#define MAX_BUF_LEN 2048 -#define DB_NAME "./vconf.db" - -enum get_option_t { - VCONF_GET_KEY = 0, /**< Get only keys */ - VCONF_GET_ALL, /**< Get keys and directories */ - VCONF_GET_DIR /**< Get only directories */ -}; -typedef enum get_option_t get_option_t; + enum vconf_t { - VCONF_TYPE_NONE = 0, /**< Vconf none type for Error detection */ VCONF_TYPE_STRING = 40, /**< Vconf string type */ VCONF_TYPE_INT = 41, /**< Vconf integer type */ - VCONF_TYPE_DOUBLE = 42, /**< Vconf double type */ VCONF_TYPE_BOOL = 43, /**< Vconf boolean type */ - VCONF_TYPE_DIR /**< Vconf directory type */ }; +typedef struct { + int getRet; + int setRet; +} retData; + +typedef struct { + char *val; + retData ret; +} strData; + +typedef struct { + int val; + retData ret; +} intData; + typedef struct _keynode_t { char *keyname; /**< Keyname for keynode */ int type; /**< Keynode type */ union { int i; /**< Integer type */ int b; /**< Bool type */ - double d; /**< Double type */ char *s; /**< String type */ } value; /**< Value for keynode */ } keynode_t; -typedef struct _keylist_t keylist_t; typedef void(*vconf_callback_fn) (keynode_t *node, void *user_data); -union UnionValue { - int i; /**< Integer type */ - int b; /**< Bool type */ - double d; /**< Double type */ - char *s; /**< String type */ -}; /**< Value for keynode */ +std::map vconfStrMap; +std::map vconfIntMap; +std::map vconfBoolMap; + +static bool sstm_vconf_notify_key_changed_enable = true; +static bool sstm_vconf_ignore_key_changed_enable = true; + +API void sstm_vconf_get_int_setup(const char *key, int val, int ret) +{ + intData data = { + .val = val, + .ret = { + .getRet = ret, + .setRet = 0 + } + }; + vconfIntMap[key] = data; + DBG("get int setup key(%s) val(%d) ret(%d)", key, vconfIntMap[key].val, vconfIntMap[key].ret.getRet); +} + +API void sstm_vconf_get_bool_setup(const char *key, bool val, int ret) +{ + intData data = { + .val = val, + .ret = { + .getRet = ret, + .setRet = 0 + } + }; + vconfBoolMap[key] = data; + DBG("get bool setup key(%s) val(%d) ret(%d)", key, vconfBoolMap[key].val, vconfBoolMap[key].ret.getRet); +} + +API void sstm_vconf_get_str_setup(const char *key, const char *val, int ret) +{ + strData data = { + .val = strdup(val), + .ret = { + .getRet = ret, + .setRet = 0 + } + }; + vconfStrMap[key] = data; + DBG("get str setup key(%s) val(%s) ret(%d)", key, vconfStrMap[key].val, vconfStrMap[key].ret.getRet); +} + +API void sstm_vconf_set_int_setup(const char *key, int ret) +{ + intData data = { + .val = 0, + .ret = { + .getRet = 0, + .setRet = ret + } + }; + vconfIntMap[key] = data; + DBG("set int setup key(%s) val(%d) ret(%d)", key, vconfIntMap[key].val, vconfIntMap[key].ret.setRet); +} + +API void sstm_vconf_set_bool_setup(const char *key, int ret) +{ + intData data = { + .val = 0, + .ret = { + .getRet = 0, + .setRet = ret + } + }; + vconfBoolMap[key] = data; + DBG("set bool setup key(%s) val(%d) ret(%d)", key, vconfBoolMap[key].val, vconfBoolMap[key].ret.setRet); +} + +API void sstm_vconf_set_str_setup(const char *key, int ret) +{ + strData data = { + .val = NULL, + .ret = { + .getRet = 0, + .setRet = ret + } + }; + vconfStrMap[key] = data; + DBG("set str setup key(%s) val(%s) ret(%d)", key, vconfStrMap[key].val, vconfStrMap[key].ret.setRet); +} + +API void sstm_vconf_clear_str(const char *key) +{ + free(vconfStrMap[key].val); + vconfStrMap[key].val = NULL; +} + +API void sstm_vconf_notify_key_changed_setup(bool enable) +{ + sstm_vconf_notify_key_changed_enable = enable; +} + +API void sstm_vconf_ignore_key_changed_setup(bool enable) +{ + sstm_vconf_ignore_key_changed_enable = enable; +} -void checkNotifyCallBack(const char *in_key, int type, UnionValue *value) +void checkNotifyCallBack(const char *in_key, int type, void *val) { string str; str = in_key; @@ -117,280 +185,88 @@ void checkNotifyCallBack(const char *in_key, int type, UnionValue *value) node.type = type; switch (node.type) { case VCONF_TYPE_STRING: - node.value.s = value->s; + node.value.s = strdup((char*)val); break; case VCONF_TYPE_INT: - node.value.i = value->i; - break; - case VCONF_TYPE_DOUBLE: - node.value.d = value->d; + node.value.i = *(int*)val; break; case VCONF_TYPE_BOOL: - node.value.b = value->b; + node.value.b = *(int*)val; break; default: DBG("invalid type [%d] ", node.type); return; } cb(&node, user_data); + if (VCONF_TYPE_STRING == node.type) + free(node.value.s); } } } -static sqlite3 *db = NULL; - -static void _sqlite_close() -{ - if (db != NULL) { - sqlite3_close(db); - db = NULL; - } -} - -static int _sqlite_connect() -{ - if (db != NULL) - return VCONF_OK; - - int rc = sqlite3_open(DB_NAME, &db); - if (rc != SQLITE_OK) { - ERR("sqlite3_open() Fail(%d) sqlerrcode[%d] sqlexterrcode[%d] sqlmessage[%s]", rc, sqlite3_errcode(db), sqlite3_extended_errcode(db), sqlite3_errmsg(db)); - _sqlite_close(); - return VCONF_ERROR; - } - return VCONF_OK; -} - -/************************************************ - * setting APIs * - ************************************************/ - -static int _vconf_set_str(const char *in_key, const char *strval) -{ - int rc; - char *err_msg = 0; - char sql[MAX_BUF_LEN + 1]; - sqlite3_stmt *stmt = NULL; - - rc = _sqlite_connect(); - if (rc != SQLITE_OK) { - _sqlite_close(); - return VCONF_ERROR; - } - - /* journal mode */ - { - DBG("key[%s] value[%s]", in_key, strval); - snprintf(sql, MAX_BUF_LEN, "PRAGMA JOURNAL_MODE=MEMORY"); - - rc = sqlite3_exec(db, sql, 0, 0, &err_msg); - if (rc != SQLITE_OK) { - ERR("sqlite3_exec() Fail(%d) sqlerrcode[%d] sqlexterrcode[%d] sqlmessage[%s]", rc, sqlite3_errcode(db), sqlite3_extended_errcode(db), err_msg); - sqlite3_free(err_msg); - _sqlite_close(); - return VCONF_ERROR; - } - } - - /* insert key with parameter */ - do { - DBG("key[%s] value[%s]", in_key, strval); - snprintf(sql, MAX_BUF_LEN, "INSERT OR REPLACE INTO vconf ( layer, key, value ) " - "VALUES ( \"%s\", ?, ?);", "system"); - - rc = sqlite3_prepare(db, sql, strlen(sql), &stmt, 0); - if (rc != SQLITE_OK) { - ERR("sqlite3_prepare() Fail(%s)", sqlite3_errmsg(db)); - break; - } - - rc = sqlite3_bind_text(stmt, 1, in_key, strlen(in_key), SQLITE_STATIC); - if (rc != SQLITE_OK) { - ERR("sqlite3_bind_text() Fail(%d) : %s", rc, sqlite3_errmsg(db)); - break; - } - - rc = sqlite3_bind_text(stmt, 2, strval, strlen(strval), SQLITE_STATIC); - if (rc != SQLITE_OK) { - ERR("sqlite3_bind_text() Fail(%d) : %s", rc, sqlite3_errmsg(db)); - break; - } - - rc = sqlite3_step(stmt); - if (rc != SQLITE_DONE) { - ERR("sqlite3_step() Fail(%s)", sqlite3_errmsg(db)); - break; - } - } while (0); - sqlite3_finalize(stmt); - _sqlite_close(); - - if (rc == SQLITE_DONE || rc == SQLITE_OK) - return VCONF_OK; - else - return VCONF_ERROR; -} -API int vconf_set_int(const char *in_key, const int intval) +API int vconf_set_int(const char *key, const int val) { - int rc; - char buf[MAX_BUF_LEN + 1]; - snprintf(buf, MAX_BUF_LEN, "%d", intval); - - rc = _vconf_set_str(in_key, buf); - if (rc != VCONF_OK) { - ERR("_vconf_set_str() Fail"); - return VCONF_ERROR; - } - - UnionValue uValue; - uValue.i = intval; - checkNotifyCallBack(in_key, VCONF_TYPE_INT, &uValue); - - return VCONF_OK; + vconfIntMap[key].val = val; + DBG("set int key(%s) val(%d) ret(%d)", key, vconfIntMap[key].val, vconfIntMap[key].ret.setRet); + checkNotifyCallBack(key, VCONF_TYPE_INT, &vconfIntMap[key].val); + return vconfIntMap[key].ret.setRet; } -API int vconf_set_bool(const char *in_key, const int boolval) +API int vconf_set_bool(const char *key, const int val) { - int rc; - char buf[MAX_BUF_LEN + 1]; - snprintf(buf, MAX_BUF_LEN, "%d", boolval); - - rc = _vconf_set_str(in_key, buf); - if (rc != VCONF_OK) { - ERR("_vconf_set_str() Fail"); - return VCONF_ERROR; - } - - UnionValue uValue; - uValue.b = boolval; - checkNotifyCallBack(in_key, VCONF_TYPE_BOOL, &uValue); - - return VCONF_OK; + vconfBoolMap[key].val = val; + DBG("set bool key(%s) val(%d) ret(%d)", key, vconfBoolMap[key].val, vconfBoolMap[key].ret.setRet); + checkNotifyCallBack(key, VCONF_TYPE_BOOL, &vconfBoolMap[key].val); + return vconfBoolMap[key].ret.setRet; } -API int vconf_set_str(const char *in_key, const char *strval) +API int vconf_set_str(const char *key, const char *val) { - int rc; - - rc = _vconf_set_str(in_key, strval); - if (rc != VCONF_OK) { - ERR("_vconf_set_str() Fail"); - return VCONF_ERROR; - } - - UnionValue uValue; - uValue.s = (char*)strval; - checkNotifyCallBack(in_key, VCONF_TYPE_STRING, &uValue); - - return VCONF_OK; + free(vconfStrMap[key].val); + vconfStrMap[key].val = strdup(val); + checkNotifyCallBack(key, VCONF_TYPE_STRING, vconfStrMap[key].val); + return vconfStrMap[key].ret.setRet; } -API char *vconf_get_str(const char *in_key) +API char* vconf_get_str(const char *key) { - int rc; - char sql[MAX_BUF_LEN + 1]; - char *str = NULL; - - DBG("start! key [%s] ", in_key); - - rc = _sqlite_connect(); - if (rc != SQLITE_OK) { - _sqlite_close(); + RETV_IF(NULL == key, NULL); + DBG("get key(%s) val(%s) ret(%d)", key, vconfStrMap[key].val, vconfStrMap[key].ret.getRet); + if (VCONF_OK == vconfStrMap[key].ret.getRet) + return strdup(vconfStrMap[key].val); + else return NULL; - } - - sqlite3_stmt *stmt = NULL; - snprintf(sql, MAX_BUF_LEN, "SELECT layer, key, value, type read_privilege, write_privilege FROM vconf WHERE key = ? and layer = 'system'"); - - int count = 0; - do { - rc = sqlite3_prepare(db, sql, strlen(sql), &stmt, 0); - if (rc != SQLITE_OK) { - ERR("sqltie3_prepare() Fail(%d) : %s", rc, sqlite3_errmsg(db)); - - if (count >= 5) { - _sqlite_close(); - return NULL; - } - - count++; - usleep(1000000); - } else { - break; - } - } while (1); - - do { - rc = sqlite3_bind_text(stmt, 1, in_key, strlen(in_key), SQLITE_STATIC); - if (rc != SQLITE_OK) { - ERR("sqlite3_bind_text() Fail(%d) : %s", rc, sqlite3_errmsg(db)); - break; - } - rc = sqlite3_step(stmt); - if (rc != SQLITE_ROW) { - ERR("sqlite3_step() Fail(%s)", in_key); - break; - } - - DBG("vconf get: layer[%s] key[%s], value[%s]", - sqlite3_column_text(stmt, 0), - sqlite3_column_text(stmt, 1), - sqlite3_column_text(stmt, 2)); - - const unsigned char *sq_str = sqlite3_column_text(stmt, 2); - if (NULL == sq_str) { - ERR("sqlite3_column_text() Fail() : %s", sqlite3_errmsg(db)); - break; - } - str = strdup((const char*)sq_str); - - DBG("vconf get: key[%s], value[%s]", in_key, str); - } while (0); - - sqlite3_finalize(stmt); - _sqlite_close(); - - return str; } -API int vconf_get_int(const char *in_key, int *intval) +API int vconf_get_int(const char *key, int *val) { - char *value = vconf_get_str(in_key); - - if (value == NULL) - return VCONF_ERROR; - - *intval = atoi(value); + RETV_IF(NULL == key, VCONF_ERROR); + RETV_IF(NULL == val, VCONF_ERROR); - free(value); - return VCONF_OK; + DBG("get key(%s) val(%d) ret(%d)", key, vconfIntMap[key].val, vconfIntMap[key].ret.getRet); + *val = vconfIntMap[key].val; + return vconfIntMap[key].ret.getRet; } -API int vconf_get_bool(const char *in_key, int *boolval) +API int vconf_get_bool(const char *key, int *val) { - DBG("start! key [%s] ", in_key); - - char *value = vconf_get_str(in_key); - - if (value == NULL) { - ERR("NULL value"); - return VCONF_ERROR; - } - - if (*value == '0') - *boolval = 0; - else - *boolval = 1; + RETV_IF(NULL == key, VCONF_ERROR); + RETV_IF(NULL == val, VCONF_ERROR); - free(value); - return VCONF_OK; + DBG("get bool key(%s) val(%d) ret(%d)", key, vconfBoolMap[key].val, vconfBoolMap[key].ret.getRet); + *val = vconfBoolMap[key].val; + return vconfBoolMap[key].ret.getRet; } API int vconf_notify_key_changed(const char *in_key, vconf_callback_fn cb, void *user_data) { string str; + + if (false == sstm_vconf_notify_key_changed_enable) + return VCONF_ERROR; + str = in_key; notifyCallBackMap.insert(make_pair(str, make_pair((void*)cb, user_data))); @@ -400,6 +276,10 @@ API int vconf_notify_key_changed(const char *in_key, vconf_callback_fn cb, API int vconf_ignore_key_changed(const char *in_key, vconf_callback_fn cb) { string str; + + if (false == sstm_vconf_ignore_key_changed_enable) + return VCONF_ERROR; + str = in_key; notifyCallBackMap.erase(notifyCallBackMap.find(str)); diff --git a/tests/mocks/xml.c b/tests/mocks/xml.c new file mode 100644 index 0000000..eb74c98 --- /dev/null +++ b/tests/mocks/xml.c @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved + * + * 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. + */ +#define _GNU_SOURCE +#include +#include +#include +#include +#include "sst.h" +#include "sstt_mock.h" + +#define TEST_FONT_CONF_FILE "./tests/res/99-tizen.conf" + +static bool sstm_xmlParseFile_enable = true; + +API void sstm_xmlParseFile_setup(bool enable) +{ + sstm_xmlParseFile_enable = enable; +} + +API xmlDocPtr xmlParseFile(const char *filename) +{ + if (false == sstm_xmlParseFile_enable) + return NULL; + + xmlDocPtr (*org_fn)(const char *path); + if (0 == strcmp(filename, SETTING_FONT_CONF_FILE)) { + INFO("try xmlParseFile(%s)", TEST_FONT_CONF_FILE); + org_fn = dlsym(RTLD_NEXT, "xmlParseFile"); + return org_fn(TEST_FONT_CONF_FILE); + } + + org_fn = dlsym(RTLD_NEXT, "xmlParseFile"); + return org_fn(filename); +} diff --git a/tests/res/99-tizen.conf b/tests/res/99-tizen.conf new file mode 100644 index 0000000..88e0b09 --- /dev/null +++ b/tests/res/99-tizen.conf @@ -0,0 +1,82 @@ + + + + + + + + + Tizen + + + BreezeSans + + + + + BreezeSans + + BreezeSans + + + TizenDefaultFont + + + + + TizenSans + + TizenSans + + + TizenDefaultFont + + + + + TizenDefaultFont + + BreezeSans + BreezeSansKorean + BreezeSansChinese + BreezeSansJapanese + BreezeSansThai + BreezeSansArabic + BreezeColorEmoji + BreezeSansFallback + + + + + + ja + + + BreezeSansChinese + + + BreezeSansJapanese + + + + diff --git a/tests/res/bg_test.png b/tests/res/bg_test.png deleted file mode 100644 index aa82a583abbdcdbe4fa5b9304512cda273778cbb..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 22369 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 #include #include +#include #include "system_settings.h" +#include "mocks/sstt_mock.h" extern "C" { #include "sst.h" @@ -29,6 +31,7 @@ int system_settings_unsubscribe_changes(system_settings_key_e key, system_settings_cb_id id); } +#define SST_DEPRECATED_KEY ((int)SYSTEM_SETTINGS_KEY_3G_DATA_NETWORK_ENABLED + 1) class SstApiCBTest : public ::testing::Test { protected: @@ -127,78 +130,118 @@ int SstApiCBTest::resultCB = 0; TEST(SstApiTest, getValueInt) { int val; + sstm_vconf_get_int_setup(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, 60, 0); int ret = system_settings_get_value_int(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, &val); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + ret = system_settings_get_value_int((system_settings_key_e)SST_DEPRECATED_KEY, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); + + sstm_vconf_get_bool_setup(VCONFKEY_SETAPPL_MOTION_ACTIVATION, false, 0); + ret = system_settings_get_value_int(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); } TEST(SstApiTest, setValueInt) { - int oldVal; int getVal; int setVal = 60; - int ret = system_settings_get_value_int(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, &oldVal); - EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); - ret = system_settings_set_value_int(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, setVal); + + sstm_vconf_set_int_setup(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, 0); + int ret = system_settings_set_value_int(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, setVal); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); ret = system_settings_get_value_int(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, &getVal); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); EXPECT_EQ(setVal, getVal); - ret = system_settings_set_value_int(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, oldVal); - EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + ret = system_settings_set_value_int((system_settings_key_e)SST_DEPRECATED_KEY, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); + ret = system_settings_set_value_int(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); + ret = system_settings_set_value_int(SYSTEM_SETTINGS_KEY_TIME_CHANGED, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED, ret); } TEST(SstApiTest, getValueBool) { bool val; + sstm_vconf_get_bool_setup(VCONFKEY_SETAPPL_MOTION_ACTIVATION, false, 0); int ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, &val); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + ret = system_settings_get_value_bool((system_settings_key_e)SST_DEPRECATED_KEY, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); + ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); } TEST(SstApiTest, setValueBool) { - bool oldVal; bool getVal; bool setVal = false; - int ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, &oldVal); - EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, setVal); + sstm_vconf_set_bool_setup(VCONFKEY_SETAPPL_MOTION_ACTIVATION, 0); + int ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, setVal); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, &getVal); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); EXPECT_EQ(setVal, getVal); - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, oldVal); - EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + ret = system_settings_set_value_bool((system_settings_key_e)SST_DEPRECATED_KEY, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); + ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); + ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_SOUND_LOCK, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED, ret); } TEST(SstApiTest, getValueString) { char *val; + sstm_vconf_get_str_setup(VCONFKEY_REGIONFORMAT, "ko", 0); int ret = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, &val); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); free(val); + + ret = system_settings_get_value_string((system_settings_key_e)SST_DEPRECATED_KEY, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); + ret = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); + ret = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_ULTRA_DATA_SAVE_PKG_LIST, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED, ret); + + sstm_vconf_clear_str(VCONFKEY_REGIONFORMAT); } TEST(SstApiTest, setValueString) { - char *oldVal; char *getVal; const char *setVal = "ko_KR"; - int ret = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, &oldVal); - EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); - ret = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, setVal); + sstm_vconf_set_str_setup(VCONFKEY_REGIONFORMAT, 0); + int ret = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, setVal); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); ret = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, &getVal); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); EXPECT_STREQ(setVal, getVal); free(getVal); - ret = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, oldVal); - EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); - free(oldVal); + + ret = system_settings_set_value_string((system_settings_key_e)SST_DEPRECATED_KEY, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); + ret = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); + ret = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_ULTRA_DATA_SAVE_PKG_LIST, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED, ret); + + sstm_vconf_clear_str(VCONFKEY_REGIONFORMAT); } TEST_F(SstApiCBTest, setUnsetChangedCallback) { bool oldVal; + + sstm_vconf_notify_key_changed_setup(true); + sstm_vconf_ignore_key_changed_setup(true); + sstm_vconf_get_bool_setup(VCONFKEY_SETAPPL_MOTION_ACTIVATION, false, 0); + int ret = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, changedCallback, NULL); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); resultCB = -1; @@ -207,19 +250,55 @@ TEST_F(SstApiCBTest, setUnsetChangedCallback) EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, resultCB); ret = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, oldVal); - EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + ret = system_settings_set_changed_cb((system_settings_key_e)SST_DEPRECATED_KEY, changedCallback, NULL); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); + ret = system_settings_unset_changed_cb((system_settings_key_e)SST_DEPRECATED_KEY); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); } +TEST_F(SstApiCBTest, setUnsetChangedCallbackERR) +{ + sstm_vconf_notify_key_changed_setup(false); + int ret = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, changedCallback, NULL); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + sstm_vconf_ignore_key_changed_setup(false); + ret = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); + +} + + TEST_F(SstApiCBTest, addDeleteForeachValueString) { + sstm_access_setup(true); + sstm_vconf_get_str_setup(VCONFKEY_SETAPPL_CALL_RINGTONE_USER_LIST, "[]", 0); g_idle_add(checkRingtoneIdle, NULL); g_main_loop_run(loop); + + sstm_vconf_clear_str(VCONFKEY_SETAPPL_CALL_RINGTONE_USER_LIST); +} + +TEST_F(SstApiCBTest, ForeachValueString) +{ + sstm_access_setup(true); + sstm_vconf_get_str_setup(VCONFKEY_SETAPPL_CALL_RINGTONE_USER_LIST, "[]", 0); + + sstm_opendir_setup(false); + int ret = system_settings_foreach_value_string(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, ringtoneListCallback, NULL); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + sstm_vconf_clear_str(VCONFKEY_SETAPPL_CALL_RINGTONE_USER_LIST); + sstm_opendir_setup(true); } TEST_F(SstApiCBTest, addDeleteChangedCallback) { bool oldVal; + + sstm_vconf_notify_key_changed_setup(true); + sstm_vconf_ignore_key_changed_setup(true); + sstm_vconf_get_bool_setup(VCONFKEY_SETAPPL_MOTION_ACTIVATION, false, 0); + int ret = system_settings_add_changed_cb(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, changedMultiCallback1, NULL); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); ret = system_settings_add_changed_cb(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, changedMultiCallback2, NULL); @@ -234,12 +313,33 @@ TEST_F(SstApiCBTest, addDeleteChangedCallback) EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, oldVal); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + ret = system_settings_add_changed_cb((system_settings_key_e)SST_DEPRECATED_KEY, changedMultiCallback1, NULL); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); + ret = system_settings_remove_changed_cb((system_settings_key_e)SST_DEPRECATED_KEY, changedMultiCallback1); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); +} + +TEST_F(SstApiCBTest, addDeleteChangedCallbackERR) +{ + sstm_vconf_notify_key_changed_setup(false); + int ret = system_settings_add_changed_cb(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, changedCallback, NULL); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + sstm_vconf_ignore_key_changed_setup(false); + ret = system_settings_remove_changed_cb(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, changedCallback); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); } + TEST_F(SstApiCBTest, subUnsubscribeCallback) { bool oldVal; system_settings_cb_id cb[2]; + + sstm_vconf_notify_key_changed_setup(true); + sstm_vconf_ignore_key_changed_setup(true); + sstm_vconf_get_bool_setup(VCONFKEY_SETAPPL_MOTION_ACTIVATION, false, 0); + int ret = system_settings_subscribe_changes(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, changedMultiCallback1, NULL, &cb[0]); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); ret = system_settings_subscribe_changes(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, changedMultiCallback2, NULL, &cb[1]); @@ -254,4 +354,20 @@ TEST_F(SstApiCBTest, subUnsubscribeCallback) EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, oldVal); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + ret = system_settings_subscribe_changes((system_settings_key_e)SST_DEPRECATED_KEY, changedMultiCallback1, NULL, &cb[0]); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); + ret = system_settings_unsubscribe_changes((system_settings_key_e)SST_DEPRECATED_KEY, cb[0]); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); +} + +TEST_F(SstApiCBTest, subUnsubscribeCallbackERR) +{ + system_settings_cb_id cb; + sstm_vconf_notify_key_changed_setup(false); + int ret = system_settings_subscribe_changes(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, changedCallback, NULL, &cb); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + sstm_vconf_ignore_key_changed_setup(false); + ret = system_settings_unsubscribe_changes(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, cb); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); } diff --git a/tests/sst_gtest_err_interface.cpp b/tests/sst_gtest_err_interface.cpp new file mode 100644 index 0000000..1da79b7 --- /dev/null +++ b/tests/sst_gtest_err_interface.cpp @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved + * + * 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 "system_settings.h" +#include "mocks/sstt_mock.h" + +extern "C" { +#include "sst_interface.h" +#include "sst.h" +} + +TEST(SstInterfaceTest, getInterfaceERR) +{ + system_settings_key_e key[] = { + SYSTEM_SETTINGS_KEY_WALLPAPER_HOME_SCREEN, + SYSTEM_SETTINGS_KEY_WALLPAPER_LOCK_SCREEN, + SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, + SYSTEM_SETTINGS_KEY_SOUND_NOTIFICATION, + SYSTEM_SETTINGS_KEY_EMAIL_ALERT_RINGTONE, + SYSTEM_SETTINGS_KEY_DEFAULT_FONT_TYPE, + SYSTEM_SETTINGS_KEY_NETWORK_WIFI_NOTIFICATION, + SYSTEM_SETTINGS_KEY_ULTRA_DATA_SAVE, + SYSTEM_SETTINGS_KEY_ACCESSIBILITY_GRAYSCALE, + SYSTEM_SETTINGS_KEY_ACCESSIBILITY_NEGATIVE_COLOR, + SYSTEM_SETTINGS_KEY_ROTARY_EVENT_ENABLED + }; + int cnt = sizeof(key) / sizeof(system_settings_key_e); + sst_interface *iface; + + sstm_system_info_get_platform_string_setup(false); + sstm_system_info_get_platform_bool_setup(false); + for (int i = 0; i < cnt; i++) { + int ret = sst_get_interface(key[i], &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED, ret); + } + sstm_system_info_get_platform_string_setup(true); + sstm_system_info_get_platform_bool_setup(true); +} + diff --git a/tests/sst_gtest_font.cpp b/tests/sst_gtest_font.cpp index 2ba5ba2..9ea597d 100644 --- a/tests/sst_gtest_font.cpp +++ b/tests/sst_gtest_font.cpp @@ -17,8 +17,10 @@ #include #include #include +#include #include "system_settings.h" +#include "mocks/sstt_mock.h" extern "C" { #include "sst.h" @@ -27,13 +29,61 @@ extern "C" { #include "sst_interface.h" } +TEST(SstFontTest, getDefaultfontERR) +{ + char *val; + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_DEFAULT_FONT_TYPE, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_dlopen_setup(false); + ret = sst_font_get_default_type(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); +} + +TEST(SstFontTest, setFontTypeERR) +{ + const char *setVal = "BreezeSans"; + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_FONT_TYPE, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_dlopen_setup(false); + ret = sst_font_set_type(iface, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_dlopen_setup(true); + sstm_eext_config_font_set_setup(false); + ret = sst_font_set_type(iface, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_xmlParseFile_setup(false); + sstm_vconf_get_int_setup(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME, 0, -1); + ret = sst_font_set_type(iface, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); +} + +TEST(SstFontTest, setFontSizeERR) +{ + sst_interface *iface; + + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_FONT_SIZE, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_vconf_set_int_setup(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, -1); + ret = sst_font_set_size(iface, SYSTEM_SETTINGS_FONT_SIZE_NORMAL); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); +} TEST(SstFontTest, getDefaultfont) { char *val; sst_interface *iface; + + sstm_system_info_get_platform_bool_setup(true); + sstm_dlopen_setup(true); + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_FONT_TYPE, &iface); - if (SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED == ret) - return; + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); ret = sst_font_get_default_type(iface, &val); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); free(val); @@ -45,13 +95,20 @@ TEST(SstFontTest, setFontType) const char *eVal = "WrongFontName"; const char *setVal = "BreezeSans"; sst_interface *iface; + + sstm_system_info_get_platform_bool_setup(true); + sstm_dlopen_setup(true); + sstm_xmlParseFile_setup(true); + sstm_eext_config_font_set_setup(true); + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_FONT_TYPE, &iface); - if (SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED == ret) - return; EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + sstm_vconf_set_int_setup(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, 0); + sstm_vconf_set_str_setup(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME, 0); + ret = sst_font_set_type(iface, eVal); - EXPECT_NE(SYSTEM_SETTINGS_ERROR_NONE, ret); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); ret = sst_font_set_type(iface, setVal); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); ret = sst_vconf_get_str(iface, &getVal); @@ -59,6 +116,8 @@ TEST(SstFontTest, setFontType) EXPECT_STREQ(setVal, getVal); free(getVal); + + sstm_vconf_clear_str(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME); } TEST(SstFontTest, setFontSize) @@ -72,15 +131,15 @@ TEST(SstFontTest, setFontSize) }; int fsCnt = sizeof(fontSize) / sizeof(fontSize[0]); int getVal; - int oldVal; int setVal; sst_interface *iface; + sstm_system_info_get_platform_bool_setup(true); + sstm_dlopen_setup(true); + sstm_vconf_get_str_setup(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME, "BreezeSans", 0); + sstm_vconf_set_int_setup(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, 0); + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_FONT_SIZE, &iface); - if (SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED == ret) - return; - EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); - ret = sst_vconf_get_int(iface, &oldVal); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); for (int i = 0; i < fsCnt; i++) { @@ -92,6 +151,5 @@ TEST(SstFontTest, setFontSize) EXPECT_EQ(setVal, getVal); } - ret = sst_font_set_size(iface, oldVal); - EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + sstm_vconf_clear_str(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME); } diff --git a/tests/sst_gtest_interface.cpp b/tests/sst_gtest_interface.cpp index cddaa34..39c0965 100644 --- a/tests/sst_gtest_interface.cpp +++ b/tests/sst_gtest_interface.cpp @@ -17,8 +17,10 @@ #include #include #include +#include #include "system_settings.h" +#include "mocks/sstt_mock.h" extern "C" { #include "sst_interface.h" @@ -31,6 +33,10 @@ TEST(SstInterfaceTest, getInterfaceOk) { sst_interface *iface; int key = (int)SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE; + + sstm_system_info_get_platform_string_setup(true); + sstm_system_info_get_platform_bool_setup(true); + for ( ; key < (int)SYSTEM_SETTINGS_KEY_MAX; key++) { if (key == SST_DEPRECATED_KEY) { continue; @@ -40,7 +46,7 @@ TEST(SstInterfaceTest, getInterfaceOk) } } -TEST(SstInterfaceTest, getInterfaceError) +TEST(SstInterfaceTest, getInterfaceERRInput) { sst_interface *iface; int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_MAX, &iface); diff --git a/tests/sst_gtest_misc.cpp b/tests/sst_gtest_misc.cpp index dc1e02f..8401e8a 100644 --- a/tests/sst_gtest_misc.cpp +++ b/tests/sst_gtest_misc.cpp @@ -16,10 +16,11 @@ #include #include -#include #include +#include #include "system_settings.h" +#include "mocks/sstt_mock.h" extern "C" { #include "sst.h" @@ -29,6 +30,7 @@ extern "C" { TEST(SstMisc, fileExists) { + sstm_access_setup(true); bool ret = sst_misc_file_exists(SYS_SETTINGS_TEST_DIR"/tct-content-tizen-tests_video.mp3"); EXPECT_EQ(true, ret); @@ -41,14 +43,24 @@ TEST(SstMisc, getWifiQSNoti) bool val = NULL; sst_interface *iface; int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_NETWORK_WIFI_NOTIFICATION, &iface); - if (SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED == ret) - return; EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + sstm_vconf_get_int_setup(VCONFKEY_WIFI_ENABLE_QS, VCONFKEY_WIFI_QS_ENABLE, 0); ret = sst_misc_get_wifi_QS_noti(iface, &val); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); } +TEST(SstMisc, getWifiQSNotiERR) +{ + bool val = NULL; + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_NETWORK_WIFI_NOTIFICATION, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + sstm_vconf_get_int_setup(VCONFKEY_WIFI_ENABLE_QS, VCONFKEY_WIFI_QS_ENABLE, -1); + ret = sst_misc_get_wifi_QS_noti(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); +} + TEST(SstMisc, getAdsID) { char *val = NULL; @@ -56,14 +68,40 @@ TEST(SstMisc, getAdsID) int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_ADS_ID, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + sstm_vconf_get_int_setup(VCONFKEY_SETAPPL_AD_ID_OPT_OUT, 1, 0); + sstm_vconf_get_str_setup(VCONFKEY_SETAPPL_AD_ID, "00000000-0000-0000-000000000000", 0); + ret = sst_misc_get_ads_id(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + free(val); + + sstm_vconf_get_int_setup(VCONFKEY_SETAPPL_AD_ID_OPT_OUT, 1, 0); + ret = vconf_set_int(VCONFKEY_SETAPPL_AD_ID_OPT_OUT, 0); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); ret = sst_misc_get_ads_id(iface, &val); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); free(val); + + sstm_vconf_clear_str(VCONFKEY_SETAPPL_AD_ID); +} + +TEST(SstMisc, getAdsIDERR) +{ + char *val = NULL; + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_ADS_ID, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_vconf_get_int_setup(VCONFKEY_SETAPPL_AD_ID_OPT_OUT, 0, 0); + sstm_vconf_get_str_setup(VCONFKEY_SETAPPL_AD_ID, "00000000-0000-0000-000000000000", -1); + + ret = sst_misc_get_ads_id(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_vconf_clear_str(VCONFKEY_SETAPPL_AD_ID); } TEST(SstMisc, setAdsID) { - char *oldVal = NULL; char *getVal = NULL; const char *setVal = "00000215-0156-0133-0034-000000000102"; @@ -71,10 +109,9 @@ TEST(SstMisc, setAdsID) int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_ADS_ID, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); - ret = sst_misc_get_ads_id(iface, &oldVal); - EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + sstm_vconf_set_str_setup(VCONFKEY_SETAPPL_AD_ID, 0); + sstm_vconf_get_int_setup(VCONFKEY_SETAPPL_AD_ID_OPT_OUT, 0, 0); - vconf_set_int(VCONFKEY_SETAPPL_AD_ID_OPT_OUT, 0); ret = sst_misc_set_ads_id(iface, setVal); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); @@ -82,12 +119,24 @@ TEST(SstMisc, setAdsID) EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); EXPECT_STREQ(setVal, getVal); - ret = sst_misc_set_ads_id(iface, oldVal); + free(getVal); + + sstm_vconf_clear_str(VCONFKEY_SETAPPL_AD_ID); +} + +TEST(SstMisc, setAdsIDERR) +{ + const char *setVal = "00000215-0156-0133-0034-000000000102"; + + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_ADS_ID, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); - vconf_set_int(VCONFKEY_SETAPPL_AD_ID_OPT_OUT, 1); - free(oldVal); - free(getVal); + sstm_vconf_set_str_setup(VCONFKEY_SETAPPL_AD_ID, -1); + ret = sst_misc_set_ads_id(iface, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_vconf_clear_str(VCONFKEY_SETAPPL_AD_ID); } TEST(SstMisc, getUltraDataSaveState) @@ -95,10 +144,48 @@ TEST(SstMisc, getUltraDataSaveState) int val; sst_interface *iface; int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_ULTRA_DATA_SAVE, &iface); - if (SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED == ret) - return; EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + sstm_vconf_get_int_setup(VCONFKEY_SETAPPL_UDSM, 1, 0); + sstm_vconf_get_str_setup(VCONFKEY_SETAPPL_UDSM_PKGID_LIST, "org.tizen.setting", 0); + sstm_app_manager_get_app_id_setup(0); + sstm_package_manager_get_package_id_by_app_id_setup("org.tizen.setting", 0); + + ret = sst_misc_get_uds_state(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_vconf_clear_str(VCONFKEY_SETAPPL_UDSM_PKGID_LIST); +} + +TEST(SstMisc, getUltraDataSaveStateERR) +{ + int val; + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_ULTRA_DATA_SAVE, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_vconf_get_int_setup(VCONFKEY_SETAPPL_UDSM, 1, 0); + sstm_vconf_get_str_setup(VCONFKEY_SETAPPL_UDSM_PKGID_LIST, "org.tizen.setting", 0); + sstm_app_manager_get_app_id_setup(0); + sstm_package_manager_get_package_id_by_app_id_setup("org.tizen.setting", 0); ret = sst_misc_get_uds_state(iface, &val); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_package_manager_get_package_id_by_app_id_setup("org.tizen.setting", -1); + ret = sst_misc_get_uds_state(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_app_manager_get_app_id_setup(-1); + ret = sst_misc_get_uds_state(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_vconf_get_str_setup(VCONFKEY_SETAPPL_UDSM_PKGID_LIST, "NONE", -1); + ret = sst_misc_get_uds_state(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_vconf_get_int_setup(VCONFKEY_SETAPPL_UDSM, 0, -1); + ret = sst_misc_get_uds_state(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_vconf_clear_str(VCONFKEY_SETAPPL_UDSM_PKGID_LIST); } diff --git a/tests/sst_gtest_screen.cpp b/tests/sst_gtest_screen.cpp index 4dbec6d..730e904 100644 --- a/tests/sst_gtest_screen.cpp +++ b/tests/sst_gtest_screen.cpp @@ -17,8 +17,10 @@ #include #include #include +#include #include "system_settings.h" +#include "mocks/sstt_mock.h" extern "C" { #include "sst.h" @@ -33,14 +35,15 @@ TEST(SstScreenTest, getHomeWallPaper) { char *val = NULL; sst_interface *iface; - int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_FONT_TYPE, &iface); - if (SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED == ret) - return; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_WALLPAPER_HOME_SCREEN, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + sstm_vconf_get_str_setup(VCONFKEY_BGSET, "test.png", 0); ret = sst_vconf_get_str(iface, &val); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); free(val); + + sstm_vconf_clear_str(VCONFKEY_BGSET); } TEST(SstScreenTest, setHomeWallPaper) @@ -48,27 +51,46 @@ TEST(SstScreenTest, setHomeWallPaper) char *getVal = NULL; sst_interface *iface; int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_WALLPAPER_HOME_SCREEN, &iface); - if (SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED == ret) - return; EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + sstm_evas_object_image_load_error_setup(0); + sstm_vconf_set_str_setup(VCONFKEY_BGSET, 0); ret = sst_screen_set_home_wallpaper(iface, sstBgPath); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); ret = sst_vconf_get_str(iface, &getVal); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); EXPECT_STREQ(sstBgPath, getVal); free(getVal); + + sstm_vconf_clear_str(VCONFKEY_BGSET); } +TEST(SstScreenTest, setHomeWallPaperERR) +{ + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_WALLPAPER_HOME_SCREEN, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_evas_object_image_load_error_setup(0); + sstm_vconf_set_str_setup(VCONFKEY_BGSET, -1); + ret = sst_screen_set_home_wallpaper(iface, sstBgPath); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_evas_object_image_load_error_setup(-1); + ret = sst_screen_set_home_wallpaper(iface, "test.png"); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); +} + + TEST(SstScreenTest, setLockWallPaper) { char *getVal = NULL; sst_interface *iface; int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_WALLPAPER_LOCK_SCREEN, &iface); - if (SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED == ret) - return; EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + sstm_evas_object_image_load_error_setup(0); + sstm_vconf_set_str_setup(VCONFKEY_IDLE_LOCK_BGSET, 0); ret = sst_screen_set_lock_wallpaper(iface, sstBgPath); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); ret = sst_vconf_get_str(iface, &getVal); @@ -76,6 +98,25 @@ TEST(SstScreenTest, setLockWallPaper) EXPECT_STREQ(sstBgPath, getVal); free(getVal); + sstm_vconf_clear_str(VCONFKEY_IDLE_LOCK_BGSET); +} + +TEST(SstScreenTest, setLockWallPaperERR) +{ + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_WALLPAPER_LOCK_SCREEN, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_evas_object_image_load_error_setup(0); + sstm_vconf_set_str_setup(VCONFKEY_IDLE_LOCK_BGSET, -1); + ret = sst_screen_set_lock_wallpaper(iface, sstBgPath); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_evas_object_image_load_error_setup(-1); + ret = sst_screen_set_lock_wallpaper(iface, "test.png"); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); + + sstm_vconf_clear_str(VCONFKEY_IDLE_LOCK_BGSET); } TEST(SstScreenTest, getLockScreen) @@ -83,57 +124,133 @@ TEST(SstScreenTest, getLockScreen) char *val = NULL; sst_interface *iface; int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCKSCREEN_APP, &iface); - if (SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED == ret) - return; EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + sstm_vconf_get_int_setup(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, SETTING_SCREEN_LOCK_TYPE_NONE, 0); + sstm_vconf_get_str_setup(VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR, "com.samsung.lockscreen", 0); ret = sst_screen_get_lockscreen(iface, &val); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); free(val); + + sstm_vconf_clear_str(VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR); +} + +TEST(SstScreenTest, getLockScreenERR) +{ + char *val = NULL; + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCKSCREEN_APP, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_vconf_get_int_setup(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, SETTING_SCREEN_LOCK_TYPE_PASSWORD, 0); + sstm_vconf_get_str_setup(VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR, "com.samsung.lockscreen", 0); + ret = sst_screen_get_lockscreen(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_LOCKSCREEN_APP_PASSWORD_MODE, ret); + + sstm_vconf_get_str_setup(VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR, "com.samsung.lockscreen", -1); + ret = sst_screen_get_lockscreen(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_vconf_get_int_setup(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, SETTING_SCREEN_LOCK_TYPE_PASSWORD, -1); + ret = sst_screen_get_lockscreen(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_vconf_clear_str(VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR); } TEST(SstScreenTest, setLockScreen) { - char *oldVal = NULL; char *getVal = NULL; const char *setVal = "org.tizen.voice-control-panel"; sst_interface *iface; int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCKSCREEN_APP, &iface); - if (SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED == ret) - return; EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); - ret = sst_screen_get_lockscreen(iface, &oldVal); + sstm_pkgmgrinfo_appinfo_get_appinfo_setup(0); + sstm_pkgmgrinfo_appinfo_foreach_category_setup(0, true); + sstm_pkgmgrinfo_appinfo_destroy_appinfo_setup(0); + sstm_vconf_get_int_setup(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, SETTING_SCREEN_LOCK_TYPE_NONE, 0); + sstm_vconf_set_str_setup(VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR, 0); + sstm_vconf_set_int_setup(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, 0); + + ret = sst_screen_set_lockscreen(iface, "com.samsung.lockscreen"); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); ret = sst_screen_set_lockscreen(iface, setVal); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); - ret = sst_screen_get_lockscreen(iface, &getVal); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); EXPECT_STREQ(setVal, getVal); - free(oldVal); + ret = vconf_set_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, SETTING_SCREEN_LOCK_TYPE_PASSWORD); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + ret = sst_screen_set_lockscreen(iface, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_LOCKSCREEN_APP_PASSWORD_MODE, ret); + free(getVal); + + sstm_vconf_clear_str(VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR); +} + +TEST(SstScreenTest, setLockScreenERR) +{ + const char *setVal = "com.samsung.lockscreen"; + + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCKSCREEN_APP, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_pkgmgrinfo_appinfo_get_appinfo_setup(0); + sstm_pkgmgrinfo_appinfo_foreach_category_setup(0, true); + sstm_pkgmgrinfo_appinfo_destroy_appinfo_setup(0); + sstm_vconf_get_int_setup(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, SETTING_SCREEN_LOCK_TYPE_NONE, 0); + sstm_vconf_get_str_setup(VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR, "com.samsung.lockscreen", 0); + sstm_vconf_set_int_setup(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, -1); + ret = sst_screen_set_lockscreen(iface, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_vconf_set_str_setup(VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR, -1); + ret = sst_screen_set_lockscreen(iface, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_vconf_get_int_setup(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, SETTING_SCREEN_LOCK_TYPE_PASSWORD, 0); + ret = sst_screen_set_lockscreen(iface, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_LOCKSCREEN_APP_PASSWORD_MODE, ret); + + sstm_vconf_get_int_setup(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, SETTING_SCREEN_LOCK_TYPE_NONE, -1); + ret = sst_screen_set_lockscreen(iface, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_pkgmgrinfo_appinfo_foreach_category_setup(0, false); + ret = sst_screen_set_lockscreen(iface, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_pkgmgrinfo_appinfo_foreach_category_setup(-1, false); + ret = sst_screen_set_lockscreen(iface, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); + + sstm_pkgmgrinfo_appinfo_get_appinfo_setup(-1); + ret = sst_screen_set_lockscreen(iface, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); + + sstm_vconf_clear_str(VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR); } TEST(SstScreenTest, setBackLightTime) { - int oldVal; int getVal; sst_interface *iface; int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); - ret = sst_vconf_get_int(iface, &oldVal); - EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + sstm_vconf_set_int_setup(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, 0); ret = sst_screen_set_backlight_time(iface, -5); - EXPECT_NE(SYSTEM_SETTINGS_ERROR_NONE, ret); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); ret = sst_screen_set_backlight_time(iface, 601); - EXPECT_NE(SYSTEM_SETTINGS_ERROR_NONE, ret); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); ret = sst_screen_set_backlight_time(iface, 300); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); @@ -141,7 +258,15 @@ TEST(SstScreenTest, setBackLightTime) ret = sst_vconf_get_int(iface, &getVal); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); EXPECT_EQ(getVal, 300); +} - ret = sst_screen_set_backlight_time(iface, oldVal); +TEST(SstScreenTest, setBackLightTimeERR) +{ + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_vconf_set_int_setup(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, -1); + ret = sst_screen_set_backlight_time(iface, 300); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); } diff --git a/tests/sst_gtest_sound.cpp b/tests/sst_gtest_sound.cpp index 85b708a..234975d 100644 --- a/tests/sst_gtest_sound.cpp +++ b/tests/sst_gtest_sound.cpp @@ -17,8 +17,11 @@ #include #include #include +#include #include "system_settings.h" +#include "mocks/sstt_mock.h" + extern "C" { #include "sst.h" #include "sst_sound.h" @@ -90,27 +93,42 @@ TEST_F(SstSoundTest, getCallRingtone) char *val = NULL; sst_interface *iface; int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, &iface); - if (SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED == ret) - return; EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + sstm_vconf_get_str_setup(VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR, ringtonePath, 0); ret = sst_sound_get_call_ringtone(iface, &val); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); free(val); + + sstm_vconf_clear_str(VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR); +} + +TEST_F(SstSoundTest, getCallRingtoneERR) +{ + char *val = NULL; + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_vconf_get_str_setup(VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR, "error", -1); + ret = sst_sound_get_call_ringtone(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_vconf_clear_str(VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR); } TEST_F(SstSoundTest, setCallRingtone) { - char *oldVal = NULL; char *getVal = NULL; sst_interface *iface; int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, &iface); - if (SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED == ret) - return; EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); - ret = sst_sound_get_call_ringtone(iface, &oldVal); - EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + sstm_access_setup(true); + sstm_vconf_set_str_setup(VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR, 0); + + ret = sst_sound_set_call_ringtone(iface, "not_exist.mp3"); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); ret = sst_sound_set_call_ringtone(iface, ringtonePath); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); @@ -119,17 +137,33 @@ TEST_F(SstSoundTest, setCallRingtone) EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); EXPECT_STREQ(ringtonePath, getVal); - ret = sst_sound_set_call_ringtone(iface, oldVal); + free(getVal); + + sstm_vconf_clear_str(VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR); +} + +TEST_F(SstSoundTest, setCallRingtoneERR) +{ + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); - free(oldVal); - free(getVal); + sstm_access_setup(true); + sstm_vconf_set_str_setup(VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR, -1); + ret = sst_sound_set_call_ringtone(iface, ringtonePath); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_vconf_clear_str(VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR); } TEST_F(SstSoundTest, addDelGetRingtone) { + sstm_access_setup(true); + sstm_vconf_get_str_setup(VCONFKEY_SETAPPL_CALL_RINGTONE_USER_LIST, "[]", 0); g_idle_add(checkRingtoneIdle, NULL); g_main_loop_run(loop); + + sstm_vconf_clear_str(VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR); } @@ -138,27 +172,51 @@ TEST_F(SstSoundTest, getEmailAlert) char *val = NULL; sst_interface *iface; int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_EMAIL_ALERT_RINGTONE, &iface); - if (SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED == ret) - return; EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + sstm_vconf_get_str_setup(VCONFKEY_SETAPPL_NOTI_RINGTONE_DEFAULT_PATH_STR, ringtonePath, 0); + sstm_vconf_get_str_setup(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR, "test.mp3", 0); + ret = sst_sound_get_email_alert(iface, &val); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); free(val); + + sstm_vconf_get_str_setup(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR, ringtonePath, 0); + + ret = sst_sound_get_email_alert(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + free(val); + + sstm_vconf_clear_str(VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR); + sstm_vconf_clear_str(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR); +} + +TEST_F(SstSoundTest, getEmailAlertERR) +{ + char *val = NULL; + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_EMAIL_ALERT_RINGTONE, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_vconf_get_str_setup(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR, ringtonePath, -1); + ret = sst_sound_get_email_alert(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_vconf_clear_str(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR); } TEST_F(SstSoundTest, setEmailAlert) { - char *oldVal = NULL; char *getVal = NULL; sst_interface *iface; int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_EMAIL_ALERT_RINGTONE, &iface); - if (SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED == ret) - return; EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); - ret = sst_sound_get_email_alert(iface, &oldVal); - EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + sstm_access_setup(true); + sstm_vconf_set_str_setup(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR, 0); + + ret = sst_sound_set_email_alert(iface, "not_exist.mp3"); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); ret = sst_sound_set_email_alert(iface, ringtonePath); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); @@ -167,25 +225,42 @@ TEST_F(SstSoundTest, setEmailAlert) EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); EXPECT_STREQ(ringtonePath, getVal); - ret = sst_sound_set_email_alert(iface, oldVal); + free(getVal); + + sstm_vconf_clear_str(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR); +} + +TEST_F(SstSoundTest, setEmailAlertERR) +{ + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_EMAIL_ALERT_RINGTONE, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); - free(oldVal); - free(getVal); + sstm_access_setup(true); + sstm_vconf_set_str_setup(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR, -1); + ret = sst_sound_set_email_alert(iface, ringtonePath); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_access_setup(false); + ret = sst_sound_set_email_alert(iface, ringtonePath); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); + sstm_access_setup(true); + + sstm_vconf_clear_str(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR); } TEST_F(SstSoundTest, setNotification) { - char *oldVal = NULL; char *getVal = NULL; sst_interface *iface; int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_SOUND_NOTIFICATION, &iface); - if (SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED == ret) - return; EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); - ret = sst_vconf_get_str(iface, &oldVal); - EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + sstm_access_setup(true); + sstm_vconf_set_str_setup(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR, 0); + + ret = sst_sound_set_notification(iface, "not_exist.mp3"); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); ret = sst_sound_set_notification(iface, ringtonePath); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); @@ -194,11 +269,28 @@ TEST_F(SstSoundTest, setNotification) EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); EXPECT_STREQ(ringtonePath, getVal); - ret = sst_sound_set_notification(iface, oldVal); + free(getVal); + + sstm_vconf_clear_str(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR); +} + +TEST_F(SstSoundTest, setNotificationERR) +{ + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_SOUND_NOTIFICATION, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); - free(oldVal); - free(getVal); + sstm_access_setup(true); + sstm_vconf_set_str_setup(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR, -1); + ret = sst_sound_set_notification(iface, ringtonePath); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_access_setup(false); + ret = sst_sound_set_notification(iface, ringtonePath); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + sstm_access_setup(true); + + sstm_vconf_clear_str(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR); } TEST_F(SstSoundTest, getSlientMode) @@ -208,10 +300,30 @@ TEST_F(SstSoundTest, getSlientMode) int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_SOUND_SILENT_MODE, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + sstm_vconf_get_bool_setup(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, false, 0); + sstm_vconf_get_bool_setup(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, false, 0); + ret = sst_sound_get_silent_mode(iface, &val); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); } +TEST_F(SstSoundTest, getSlientModeERR) +{ + bool val; + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_SOUND_SILENT_MODE, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_vconf_get_bool_setup(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, false, 0); + sstm_vconf_get_bool_setup(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, false, -1); + ret = sst_sound_get_silent_mode(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_vconf_get_bool_setup(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, false, -1); + ret = sst_sound_get_silent_mode(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); +} + TEST_F(SstSoundTest, setSlientMode) { bool getVal; @@ -220,6 +332,9 @@ TEST_F(SstSoundTest, setSlientMode) int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_SOUND_SILENT_MODE, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + sstm_vconf_get_bool_setup(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, false, 0); + sstm_vconf_get_bool_setup(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, false, 0); + ret = sst_sound_get_silent_mode(iface, &getVal); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); setVal = !getVal; @@ -234,3 +349,19 @@ TEST_F(SstSoundTest, setSlientMode) ret = sst_sound_set_silent_mode(iface, !getVal); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); } + +TEST_F(SstSoundTest, setSlientModeERR) +{ + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_SOUND_SILENT_MODE, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_vconf_set_bool_setup(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, 0); + sstm_vconf_set_bool_setup(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, -1); + ret = sst_sound_set_silent_mode(iface, true); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_vconf_set_bool_setup(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, -1); + ret = sst_sound_set_silent_mode(iface, true); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); +} diff --git a/tests/sst_gtest_time_N_locale.cpp b/tests/sst_gtest_time_N_locale.cpp index 87aa6b7..8dea20d 100644 --- a/tests/sst_gtest_time_N_locale.cpp +++ b/tests/sst_gtest_time_N_locale.cpp @@ -17,8 +17,10 @@ #include #include #include +#include #include "system_settings.h" +#include "mocks/sstt_mock.h" extern "C" { #include "sst.h" @@ -33,14 +35,34 @@ TEST(SstTimeNLocaleTest, getCountry) int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + sstm_vconf_get_str_setup(VCONFKEY_REGIONFORMAT, "ko", 0); ret = sst_locale_get_country(iface, &val); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); free(val); + + sstm_vconf_clear_str(VCONFKEY_REGIONFORMAT); +} + +TEST(SstTimeNLocaleTest, getCountryERR) +{ + char *val = NULL; + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_vconf_get_str_setup(VCONFKEY_REGIONFORMAT, "012345678901234567890", 0); + ret = sst_locale_get_country(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_vconf_get_str_setup(VCONFKEY_REGIONFORMAT, "ko", -1); + ret = sst_locale_get_country(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_vconf_clear_str(VCONFKEY_REGIONFORMAT); } TEST(SstTimeNLocaleTest, setCountry) { - char *oldVal = NULL; char *getVal = NULL; const char *setVal = "ko_KR"; @@ -48,8 +70,7 @@ TEST(SstTimeNLocaleTest, setCountry) int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); - ret = sst_locale_get_country(iface, &oldVal); - EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + sstm_vconf_set_str_setup(VCONFKEY_REGIONFORMAT, 0); ret = sst_locale_set_country(iface, setVal); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); @@ -58,11 +79,23 @@ TEST(SstTimeNLocaleTest, setCountry) EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); EXPECT_STREQ(setVal, getVal); - ret = sst_locale_set_country(iface, oldVal); + free(getVal); + + sstm_vconf_clear_str(VCONFKEY_REGIONFORMAT); +} + +TEST(SstTimeNLocaleTest, setCountryERR) +{ + const char *setVal = "ko_KR"; + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); - free(oldVal); - free(getVal); + sstm_vconf_set_str_setup(VCONFKEY_REGIONFORMAT, -1); + ret = sst_locale_set_country(iface, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_vconf_clear_str(VCONFKEY_REGIONFORMAT); } TEST(SstTimeNLocaleTest, getLanguage) @@ -72,14 +105,35 @@ TEST(SstTimeNLocaleTest, getLanguage) int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + sstm_vconf_get_str_setup(VCONFKEY_LANGSET, "ko", 0); + ret = sst_locale_get_language(iface, &val); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); free(val); + + sstm_vconf_clear_str(VCONFKEY_LANGSET); +} + +TEST(SstTimeNLocaleTest, getLanguageERR) +{ + char *val = NULL; + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_vconf_get_str_setup(VCONFKEY_LANGSET, "012345678901234567890", 0); + ret = sst_locale_get_language(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_vconf_get_str_setup(VCONFKEY_LANGSET, "ko", -1); + ret = sst_locale_get_language(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_vconf_clear_str(VCONFKEY_LANGSET); } TEST(SstTimeNLocaleTest, setLanguage) { - char *oldVal = NULL; char *getVal = NULL; const char *setVal = "ko_KR"; @@ -87,8 +141,7 @@ TEST(SstTimeNLocaleTest, setLanguage) int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); - ret = sst_locale_get_language(iface, &oldVal); - EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + sstm_vconf_set_str_setup(VCONFKEY_LANGSET, 0); ret = sst_locale_set_language(iface, setVal); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); @@ -97,8 +150,24 @@ TEST(SstTimeNLocaleTest, setLanguage) EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); EXPECT_STREQ(setVal, getVal); - free(oldVal); free(getVal); + + sstm_vconf_clear_str(VCONFKEY_LANGSET); +} + +TEST(SstTimeNLocaleTest, setLanguageERR) +{ + const char *setVal = "ko_KR"; + + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_vconf_set_str_setup(VCONFKEY_LANGSET, -1); + ret = sst_locale_set_language(iface, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_vconf_clear_str(VCONFKEY_LANGSET); } TEST(SstTimeNLocaleTest, getTimeformat24Hour) @@ -108,10 +177,23 @@ TEST(SstTimeNLocaleTest, getTimeformat24Hour) int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + sstm_vconf_get_int_setup(VCONFKEY_REGIONFORMAT_TIME1224, false, 0); ret = sst_locale_get_timeformat_24hour(iface, &val); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); } +TEST(SstTimeNLocaleTest, getTimeformat24HourERR) +{ + bool val = NULL; + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_vconf_get_int_setup(VCONFKEY_REGIONFORMAT_TIME1224, false, -1); + ret = sst_locale_get_timeformat_24hour(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); +} + TEST(SstTimeNLocaleTest, setTimeformat24Hour) { bool getVal; @@ -120,6 +202,7 @@ TEST(SstTimeNLocaleTest, setTimeformat24Hour) int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + sstm_vconf_set_int_setup(VCONFKEY_REGIONFORMAT_TIME1224, 0); ret = sst_locale_get_timeformat_24hour(iface, &getVal); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); setVal = !getVal; @@ -135,6 +218,17 @@ TEST(SstTimeNLocaleTest, setTimeformat24Hour) EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); } +TEST(SstTimeNLocaleTest, setTimeformat24HourERR) +{ + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_vconf_set_int_setup(VCONFKEY_REGIONFORMAT_TIME1224, -1); + ret = sst_locale_set_timeformat_24hour(iface, true); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); +} + TEST(SstTimeNLocaleTest, getTimeZone) { char *val = NULL; @@ -142,14 +236,27 @@ TEST(SstTimeNLocaleTest, getTimeZone) int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCALE_TIMEZONE, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + sstm_readlink_setup(true); ret = sst_locale_get_timezone(iface, &val); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); free(val); } +TEST(SstTimeNLocaleTest, getTimeZoneERR) +{ + char *val = NULL; + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCALE_TIMEZONE, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_readlink_setup(false); + ret = sst_locale_get_timezone(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + sstm_readlink_setup(true); +} + TEST(SstTimeNLocaleTest, setTimeZone) { - char *oldVal = NULL; char *getVal = NULL; const char *setVal = "Asia/Seoul"; @@ -157,8 +264,9 @@ TEST(SstTimeNLocaleTest, setTimeZone) int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCALE_TIMEZONE, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); - ret = sst_locale_get_timezone(iface, &oldVal); - EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + sstm_access_setup(true); + sstm_alarmmgr_set_timezone_setup(true); + sstm_vconf_set_str_setup(VCONFKEY_SETAPPL_TIMEZONE_ID, 0); ret = sst_locale_set_timezone(iface, setVal); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); @@ -167,11 +275,34 @@ TEST(SstTimeNLocaleTest, setTimeZone) EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); EXPECT_STREQ(setVal, getVal); - ret = sst_locale_set_timezone(iface, oldVal); + free(getVal); + + sstm_vconf_clear_str(VCONFKEY_SETAPPL_TIMEZONE_ID); +} + +TEST(SstTimeNLocaleTest, setTimeZoneERR) +{ + const char *setVal = "Asia/Seoul"; + + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCALE_TIMEZONE, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); - free(oldVal); - free(getVal); + sstm_access_setup(true); + sstm_alarmmgr_set_timezone_setup(true); + sstm_vconf_set_str_setup(VCONFKEY_SETAPPL_TIMEZONE_ID, -1); + ret = sst_locale_set_timezone(iface, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_alarmmgr_set_timezone_setup(false); + ret = sst_locale_set_timezone(iface, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_access_setup(false); + ret = sst_locale_set_timezone(iface, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); + sstm_access_setup(true); + sstm_vconf_clear_str(VCONFKEY_SETAPPL_TIMEZONE_ID); } TEST(SstTimeNLocaleTest, getTimeChanged) diff --git a/tests/sst_gtest_vconf.cpp b/tests/sst_gtest_vconf.cpp index 67c80ae..56a8fb7 100644 --- a/tests/sst_gtest_vconf.cpp +++ b/tests/sst_gtest_vconf.cpp @@ -17,8 +17,10 @@ #include #include #include +#include #include "system_settings.h" +#include "mocks/sstt_mock.h" extern "C" { #include "sst.h" @@ -41,10 +43,10 @@ protected: static gboolean checkCallbackIdle(gpointer data) { - bool *oldVal = (bool*)data; - int ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, oldVal); + bool *val = (bool*)data; + int ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, val); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, !(*oldVal)); + ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, !(*val)); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); return G_SOURCE_REMOVE; @@ -87,28 +89,50 @@ TEST(SstVconfTest, getValueInt) sst_interface *iface; int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_vconf_get_int_setup(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, 60, 0); ret = sst_vconf_get_int(iface, &val); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); } +TEST(SstVconfTest, getValueIntERR) +{ + int val; + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_vconf_get_int_setup(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, 60, -1); + ret = sst_vconf_get_int(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); +} + TEST(SstVconfTest, setValueInt) { - int oldVal; int getVal; int setVal = 60; sst_interface *iface; int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); - ret = sst_vconf_get_int(iface, &oldVal); - EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_vconf_set_int_setup(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, 0); ret = sst_vconf_set_int(iface, setVal); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); ret = sst_vconf_get_int(iface, &getVal);; EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); EXPECT_EQ(setVal, getVal); - ret = sst_vconf_set_int(iface, oldVal); +} + +TEST(SstVconfTest, setValueIntERR) +{ + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_vconf_set_int_setup(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, -1); + ret = sst_vconf_set_int(iface, 60); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); } TEST(SstVconfTest, getValueBool) @@ -117,10 +141,24 @@ TEST(SstVconfTest, getValueBool) sst_interface *iface; int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_vconf_get_bool_setup(VCONFKEY_SETAPPL_MOTION_ACTIVATION, false, 0); ret = sst_vconf_get_bool(iface, &val); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); } +TEST(SstVconfTest, getValueBoolERR) +{ + bool val; + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_vconf_get_bool_setup(VCONFKEY_SETAPPL_MOTION_ACTIVATION, false, -1); + ret = sst_vconf_get_bool(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); +} + TEST(SstVconfTest, setValueBool) { bool getVal; @@ -128,6 +166,8 @@ TEST(SstVconfTest, setValueBool) sst_interface *iface; int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_vconf_set_bool_setup(VCONFKEY_SETAPPL_MOTION_ACTIVATION, 0); ret = sst_vconf_get_bool(iface, &getVal); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); setVal = !getVal; @@ -140,61 +180,111 @@ TEST(SstVconfTest, setValueBool) EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); } +TEST(SstVconfTest, setValueBoolERR) +{ + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_vconf_set_bool_setup(VCONFKEY_SETAPPL_MOTION_ACTIVATION, -1); + ret = sst_vconf_set_bool(iface, false); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); +} + TEST(SstVconfTest, getValueString) { char *val; sst_interface *iface; int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_vconf_get_str_setup(VCONFKEY_REGIONFORMAT, "ko", 0); ret = sst_vconf_get_str(iface, &val); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); free(val); + + sstm_vconf_clear_str(VCONFKEY_REGIONFORMAT); +} + +TEST(SstVconfTest, getValueStringERR) +{ + char *val; + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_vconf_get_str_setup(VCONFKEY_REGIONFORMAT, "ko", -1); + ret = sst_vconf_get_str(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + + sstm_vconf_clear_str(VCONFKEY_REGIONFORMAT); } TEST(SstVconfTest, setValueString) { - char *oldVal; char *getVal; const char *setVal = "ko_KR"; sst_interface *iface; int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); - ret = sst_vconf_get_str(iface, &oldVal); - EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + sstm_vconf_set_str_setup(VCONFKEY_REGIONFORMAT, 0); ret = sst_vconf_set_str(iface, setVal); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); ret = sst_vconf_get_str(iface, &getVal); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); EXPECT_STREQ(setVal, getVal); free(getVal); - ret = sst_vconf_set_str(iface, oldVal); - EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); - free(oldVal); + + sstm_vconf_clear_str(VCONFKEY_REGIONFORMAT); } TEST_F(SstVconfCBTest, setUnsetChangedCallback) { - bool oldVal; + bool val; sst_interface *iface; int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + sstm_vconf_notify_key_changed_setup(true); + sstm_vconf_ignore_key_changed_setup(true); + sstm_vconf_get_bool_setup(VCONFKEY_SETAPPL_MOTION_ACTIVATION, false, 0); + ret = sst_vconf_set_cb(iface, changedCallback, NULL); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); resultCB = -1; - g_idle_add(checkCallbackIdle, &oldVal); + g_idle_add(checkCallbackIdle, &val); g_main_loop_run(loop); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, resultCB); ret = sst_vconf_unset_cb(iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, oldVal); +} + +TEST_F(SstVconfCBTest, setUnsetChangedCallbackERR) +{ + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + ret = sst_vconf_set_cb(iface, NULL, NULL); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); + + sstm_vconf_notify_key_changed_setup(false); + ret = sst_vconf_set_cb(iface, changedCallback, NULL); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + sstm_vconf_ignore_key_changed_setup(false); + ret = sst_vconf_unset_cb(iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); } TEST_F(SstVconfCBTest, addDeleteChangedCallback) { - bool oldVal; + bool val; sst_interface *iface; + + sstm_vconf_notify_key_changed_setup(true); + sstm_vconf_ignore_key_changed_setup(true); + sstm_vconf_get_bool_setup(VCONFKEY_SETAPPL_MOTION_ACTIVATION, false, 0); + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); ret = sst_vconf_add_multi_cb(iface, changedMultiCallback1, NULL); @@ -202,22 +292,41 @@ TEST_F(SstVconfCBTest, addDeleteChangedCallback) ret = sst_vconf_add_multi_cb(iface, changedMultiCallback2, NULL); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); resultCB = 0; - g_idle_add(checkCallbackIdle, &oldVal); + g_idle_add(checkCallbackIdle, &val); g_main_loop_run(loop); EXPECT_EQ(0x11, resultCB); ret = sst_vconf_del_multi_cb(iface, changedMultiCallback1); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); ret = sst_vconf_del_multi_cb(iface, changedMultiCallback2); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, oldVal); +} + +TEST_F(SstVconfCBTest, addDeleteChangedCallbackERR) +{ + sst_interface *iface; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + ret = sst_vconf_add_multi_cb(iface, NULL, NULL); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); + + sstm_vconf_notify_key_changed_setup(false); + ret = sst_vconf_add_multi_cb(iface, changedCallback, NULL); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + sstm_vconf_ignore_key_changed_setup(false); + ret = sst_vconf_del_multi_cb(iface, changedCallback); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); } TEST_F(SstVconfCBTest, subscribeUnsubscribe) { - bool oldVal; + bool val; sst_interface *iface; system_settings_cb_id cb[2]; + + sstm_vconf_notify_key_changed_setup(true); + sstm_vconf_ignore_key_changed_setup(true); + sstm_vconf_get_bool_setup(VCONFKEY_SETAPPL_MOTION_ACTIVATION, false, 0); + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); ret = sst_vconf_subscribe(iface, changedMultiCallback1, NULL, &cb[0]); @@ -225,13 +334,28 @@ TEST_F(SstVconfCBTest, subscribeUnsubscribe) ret = sst_vconf_subscribe(iface, changedMultiCallback2, NULL, &cb[1]); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); resultCB = 0; - g_idle_add(checkCallbackIdle, &oldVal); + g_idle_add(checkCallbackIdle, &val); g_main_loop_run(loop); EXPECT_EQ(0x11, resultCB); ret = sst_vconf_unsubscribe(iface, cb[0]); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); ret = sst_vconf_unsubscribe(iface, cb[1]); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, oldVal); +} + +TEST_F(SstVconfCBTest, subscribeUnsubscribeERR) +{ + sst_interface *iface; + system_settings_cb_id cb; + int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, &iface); EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + ret = sst_vconf_subscribe(iface, NULL, NULL, &cb); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, ret); + + sstm_vconf_notify_key_changed_setup(false); + ret = sst_vconf_subscribe(iface, changedCallback, NULL, &cb); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret); + sstm_vconf_ignore_key_changed_setup(false); + ret = sst_vconf_unsubscribe(iface, cb); + changedCallback(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, NULL); } diff --git a/tests/sstt.h b/tests/sstt.h deleted file mode 100644 index 4686fa1..0000000 --- a/tests/sstt.h +++ /dev/null @@ -1,127 +0,0 @@ -/* - * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved - * - * 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. - */ -#pragma once - -#include -#include -#include - -void add_test_func(char *test_name, GTestFunc func_pointer); -void unittest_api(); - -#ifndef SYS_SETTINGS_TEST_DIR -#define SYS_SETTINGS_TEST_DIR "/usr/bin/sys-settings" -#warning "SYS_SETTINGS_TEST_DIR is redefined" -#endif - -#define GLIB_MODE - -#ifdef GLIB_MODE -#define RETTYPE void -#define RETURN(a) return -#else -#define RETTYPE int -#define RETURN(a) return a -#endif - -#ifndef N_THREADS -#define N_THERADS 0 -#endif - -#define MAX_TEST_CASE 1000 - -#ifndef GLIB_MODE -#define assert(exp) \ - do { \ - if (!(exp)) { \ - fprintf(stderr, \ - "\\n[TCT][%s][Line : %d] Assert Fail; Following expression is not true: %s\\n", \ - __FILE__, __LINE__, #exp); \ - return 1; \ - } \ - } while (0) - -#define assert_eq(var, ref) \ - do { \ - if (var != ref) { \ - fprintf(stderr, \ - "\\n[TCT][%s][Line : %d] Assert fail; Values (%s == 0x%x) and (%s == 0x%x) are not equal\\n", \ - __FILE__, __LINE__, #var, (int)var, #ref, (int)ref); \ - return 1; \ - } \ - } while (0) - -#define assert_neq(var, ref) \ - do { \ - if (var == ref) { \ - fprintf(stderr, \ - "\\n[TCT][%s][Line : %d] Assert fail; Values (%s == 0x%x) and (%s == 0x%x) are equal\\n", \ - __FILE__, __LINE__, #var, (int)var, #ref, (int)ref); \ - return 1; \ - } \ - } while (0) - -#define assert_gt(var, ref) \ - do { \ - if (var <= ref) { \ - fprintf(stderr, \ - "\\n[TCT][%s][Line : %d] Assert fail; Values (%s == 0x%x) is not greater than (%s == 0x%x)\\n", \ - __FILE__, __LINE__, #var, (int)var, #ref, (int)ref); \ - return 1; \ - } \ - } while (0) - -#define assert_geq(var, ref) \ - do { \ - if (var < ref) { \ - fprintf(stderr, \ - "\\n[TCT][%s][Line : %d] Assert fail; Values (%s == 0x%x) is not greater than or equal to (%s == 0x%x)\\n", \ - __FILE__, __LINE__, #var, (int)var, #ref, (int)ref); \ - return 1; \ - } \ - } while (0) - -#define assert_lt(var, ref) \ - do { \ - if (var >= ref) { \ - fprintf(stderr, \ - "\\n[TCT][%s][Line : %d] Assert fail; Values (%s == 0x%x) is not lower than (%s == 0x%x)\\n", \ - __FILE__, __LINE__, #var, (int)var, #ref, (int)ref); \ - return 1; \ - } \ - } while (0) - -#define assert_leq(var, ref) \ - do { \ - if (var > ref) { \ - fprintf(stderr, \ - "\\n[TCT][%s][Line : %d] Assert fail; Values (%s == 0x%x) is not lower than or equal to (%s == 0x%x)\\n", \ - __FILE__, __LINE__, #var, (int)var, #ref, (int)ref); \ - return 1; \ - } \ - } while (0) - -#else //GLIB_MODE - -#define assert(exp) g_assert(exp) -#define assert_eq(var, ref) g_assert(var == ref) -#define assert_neq(var, ref) g_assert(var != ref) -#define assert_gt(var, ref) g_assert(var > ref) -#define assert_geq(var, ref) g_assert(var >= ref) -#define assert_lt(var, ref) g_assert(var < ref) -#define assert_leq(var, ref) g_assert(var <= ref) - -#endif //GLIB_MODE diff --git a/tests/sstt_main.c b/tests/sstt_main.c deleted file mode 100644 index 2bffe7a..0000000 --- a/tests/sstt_main.c +++ /dev/null @@ -1,132 +0,0 @@ -/* - * Copyright (c) 2017-2020 Samsung Electronics Co., Ltd All Rights Reserved - * - * 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 "sst.h" -#include "sstt.h" - -typedef struct __thread_test_table { - char * test_name; - GTestFunc t_func; -} thread_test_node; - -static GThread *my_thread = NULL; -static GMainLoop *main_loop = NULL; -static thread_test_node thread_test_table[1000] = { 0 }; -static int thread_test_idx = 0; -static int loop = 100; -static int thread_sw = 1; - -static void *thread_function(void *data) -{ - int cnt = 0; - int test_idx = GPOINTER_TO_INT(data); - - while (thread_sw) { - if (cnt > loop) - break; - cnt++; - thread_test_table[test_idx].t_func(); - sleep(0); - } - - return 0; - -} - -static GThread **unit_test_thread_start(int test_num) -{ - int i; - GThread **thread_list = (GThread **)calloc(sizeof(GThread*), N_THREADS); - for (i = 0; i < N_THREADS; i++) - thread_list[i] = g_thread_new(NULL, thread_function, GINT_TO_POINTER(test_num)); - - return thread_list; -} - -static void unit_test_thread_stop(GThread **thread_list) -{ - int i; - for (i = 0; i < N_THREADS; i++) - g_thread_join(thread_list[i]); - - g_free(thread_list); -} - -static void unit_thread_test() -{ - int i; - GThread **thread_test[MAX_TEST_CASE]; - - printf("START!!!! thread test for system-settings %d tests\n", thread_test_idx); - - thread_sw = 1; - for (i = 0; i < thread_test_idx; i++) { - thread_test[i] = unit_test_thread_start(i); - printf("%3d %s:start!\n", i, thread_test_table[i].test_name); - - unit_test_thread_stop(thread_test[i]); - printf("%3d %s:OK\n", i, thread_test_table[i].test_name); - } - - printf("END!!!! thread test for system-settings\n"); -} - -static gpointer loop_func(gpointer data) -{ - g_main_loop_run(main_loop); - return NULL; -} - -static void start_main_loop_thread() -{ - my_thread = g_thread_new(NULL, loop_func, NULL); -} - -static void stop_main_loop_thread() -{ - g_main_loop_quit(main_loop); - g_thread_join(my_thread); - g_main_loop_unref(main_loop); -} - -void add_test_func(char *test_name, GTestFunc func_pointer) -{ - g_test_add_func(test_name, func_pointer); - - thread_test_table[thread_test_idx].test_name = test_name; - thread_test_table[thread_test_idx].t_func = func_pointer; - - thread_test_idx++; -} - -int main(int argc, char **argv) -{ - main_loop = g_main_loop_new(NULL, FALSE); - - g_test_init(&argc, &argv, NULL); - g_test_set_nonfatal_assertions(); - - start_main_loop_thread(); - - unittest_api(); - - g_test_run(); - unit_thread_test(); - - stop_main_loop_thread(); - return 0; -} -- 2.7.4