From: JinWang An Date: Wed, 22 Jul 2020 17:25:12 +0000 (+0900) Subject: Add unit test to increase coverage X-Git-Tag: submit/tizen/20200810.135017~1 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Fchanges%2F70%2F239170%2F4;p=platform%2Fcore%2Fapi%2Fsystem-settings.git Add unit test to increase coverage Change-Id: I79d77c39cecde9fb345f584389823ab88ec35336 Signed-off-by: JinWang An --- 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 aa82a58..0000000 Binary files a/tests/res/bg_test.png and /dev/null differ diff --git a/tests/scripts/ringtone_files.sh b/tests/scripts/ringtone_files.sh deleted file mode 100755 index 6230f01..0000000 --- a/tests/scripts/ringtone_files.sh +++ /dev/null @@ -1,24 +0,0 @@ -#!/bin/bash - -ARG=$1 -CURRENT_DIR="$( cd "$(dirname $(readlink -f "$0"))" ; pwd -P )" -RINGTONE_FILENAME="$CURRENT_DIR/ringtone_sdk.mp3" - -echo $ARG -echo $BASE_PATH - -if [[ $ARG == "create" ]]; then - cp -rf "$RINGTONE_FILENAME" "$CURRENT_DIR/Over the horizon.mp3" - cp -rf "$RINGTONE_FILENAME" "$CURRENT_DIR/big_buck_bunny.mp3" - cp -rf "$RINGTONE_FILENAME" "$CURRENT_DIR/daliTestVideo.mp3" - cp -rf "$RINGTONE_FILENAME" "$CURRENT_DIR/sound_5.mp3" - cp -rf "$RINGTONE_FILENAME" "$CURRENT_DIR/tct-content-tizen-tests_video.mp3" -fi - -if [[ $ARG == "del" ]]; then - rm "$CURRENT_DIR/Over the horizon.mp3" - rm "$CURRENT_DIR/big_buck_bunny.mp3" - rm "$CURRENT_DIR/daliTestVideo.mp3" - rm "$CURRENT_DIR/sound_5.mp3" - rm "$CURRENT_DIR/tct-content-tizen-tests_video.mp3" -fi diff --git a/tests/sst_gtest_api.cpp b/tests/sst_gtest_api.cpp index c8103c2..445a33d 100644 --- a/tests/sst_gtest_api.cpp +++ b/tests/sst_gtest_api.cpp @@ -17,8 +17,10 @@ #include #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; -}