%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
%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
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})
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})
+
+
--- /dev/null
+/*
+ * 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 <stdio.h>
+#include <string.h>
+#include <alarm.h>
+#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;
+}
#include <stdlib.h>
#include <stdbool.h>
#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;
}
#include <dirent.h>
#include <sys/types.h>
#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"))
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);
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")) {
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);
+}
* See the License for the specific language governing permissions and
* limitations under the License.
*/
+#include <stdio.h>
+#include <string.h>
#include <pkgmgr-info.h>
+#include <package_manager.h>
+#include <app_manager.h>
#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;
}
--- /dev/null
+/*
+ * 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 <stdbool.h>
+
+#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
#include <string.h>
#include <dlfcn.h>
#include <stdbool.h>
+#include <tizen.h>
#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;
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;
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
-#include <errno.h>
-#include <sqlite3.h>
-#include <unistd.h>
-
-#include <iostream>
#include <map>
#include <string>
#include "sst.h"
+#include "sstt_mock.h"
using namespace std;
#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<string, strData> vconfStrMap;
+std::map<string, intData> vconfIntMap;
+std::map<string, intData> 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;
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)));
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));
--- /dev/null
+/*
+ * 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 <stdio.h>
+#include <string.h>
+#include <dlfcn.h>
+#include <libxml/tree.h>
+#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);
+}
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE fontconfig SYSTEM "fonts.dtd">
+<!--
+ default-fonts-fc-sdk
+
+ Copyright (c) 2011 - 2014 Samsung Electronics Co., Ltd. All rights reserved.
+
+ Contact: Minsu Han <minsu81.han@samsung.com>
+
+ 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.
+-->
+<fontconfig>
+<!--
+ Accept deprecated 'Tizen' alias, replacing it with 'TizenSans'
+ -->
+ <match target="pattern">
+ <!-- check to see if the font is just regular -->
+ <test qual="any" name="family">
+ <string>Tizen</string>
+ </test>
+ <edit name="family" mode="assign">
+ <string>BreezeSans</string>
+ </edit>
+ </match>
+
+ <alias binding="strong">
+ <family>BreezeSans</family>
+ <prefer>
+ <family>BreezeSans</family>
+ </prefer>
+ <default>
+ <family>TizenDefaultFont</family>
+ </default>
+ </alias>
+
+ <alias binding="strong">
+ <family>TizenSans</family>
+ <prefer>
+ <family>TizenSans</family>
+ </prefer>
+ <default>
+ <family>TizenDefaultFont</family>
+ </default>
+ </alias>
+
+ <alias binding="strong">
+ <family>TizenDefaultFont</family>
+ <prefer>
+ <family>BreezeSans</family>
+ <family>BreezeSansKorean</family>
+ <family>BreezeSansChinese</family>
+ <family>BreezeSansJapanese</family>
+ <family>BreezeSansThai</family>
+ <family>BreezeSansArabic</family>
+ <family>BreezeColorEmoji</family>
+ <family>BreezeSansFallback</family>
+ </prefer>
+ </alias>
+
+ <match target="pattern">
+ <test qual="any" name="lang" compare="contains">
+ <string>ja</string>
+ </test>
+ <test name="family">
+ <string>BreezeSansChinese</string>
+ </test>
+ <edit name="family" mode="prepend" binding="strong">
+ <string>BreezeSansJapanese</string>
+ </edit>
+ </match>
+
+</fontconfig>
+++ /dev/null
-#!/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
#include <string.h>
#include <glib.h>
#include <gtest/gtest.h>
+#include <vconf.h>
#include "system_settings.h"
+#include "mocks/sstt_mock.h"
extern "C" {
#include "sst.h"
system_settings_cb_id id);
}
+#define SST_DEPRECATED_KEY ((int)SYSTEM_SETTINGS_KEY_3G_DATA_NETWORK_ENABLED + 1)
class SstApiCBTest : public ::testing::Test {
protected:
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;
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);
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]);
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);
}
--- /dev/null
+/*
+ * 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 <string.h>
+#include <glib.h>
+#include <gtest/gtest.h>
+#include <vconf.h>
+
+#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);
+}
+
#include <string.h>
#include <glib.h>
#include <gtest/gtest.h>
+#include <vconf.h>
#include "system_settings.h"
+#include "mocks/sstt_mock.h"
extern "C" {
#include "sst.h"
#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);
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);
EXPECT_STREQ(setVal, getVal);
free(getVal);
+
+ sstm_vconf_clear_str(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME);
}
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++) {
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);
}
#include <string.h>
#include <glib.h>
#include <gtest/gtest.h>
+#include <vconf.h>
#include "system_settings.h"
+#include "mocks/sstt_mock.h"
extern "C" {
#include "sst_interface.h"
{
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;
}
}
-TEST(SstInterfaceTest, getInterfaceError)
+TEST(SstInterfaceTest, getInterfaceERRInput)
{
sst_interface *iface;
int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_MAX, &iface);
#include <string.h>
#include <glib.h>
-#include <vconf.h>
#include <gtest/gtest.h>
+#include <vconf.h>
#include "system_settings.h"
+#include "mocks/sstt_mock.h"
extern "C" {
#include "sst.h"
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);
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;
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";
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);
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)
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);
}
#include <string.h>
#include <glib.h>
#include <gtest/gtest.h>
+#include <vconf.h>
#include "system_settings.h"
+#include "mocks/sstt_mock.h"
extern "C" {
#include "sst.h"
{
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)
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);
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)
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);
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);
}
#include <string.h>
#include <glib.h>
#include <gtest/gtest.h>
+#include <vconf.h>
#include "system_settings.h"
+#include "mocks/sstt_mock.h"
+
extern "C" {
#include "sst.h"
#include "sst_sound.h"
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);
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);
}
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);
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);
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)
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;
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;
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);
+}
#include <string.h>
#include <glib.h>
#include <gtest/gtest.h>
+#include <vconf.h>
#include "system_settings.h"
+#include "mocks/sstt_mock.h"
extern "C" {
#include "sst.h"
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";
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);
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)
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";
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);
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)
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;
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;
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;
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";
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);
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)
#include <string.h>
#include <glib.h>
#include <gtest/gtest.h>
+#include <vconf.h>
#include "system_settings.h"
+#include "mocks/sstt_mock.h"
extern "C" {
#include "sst.h"
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;
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)
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;
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;
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);
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]);
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);
}
+++ /dev/null
-/*
- * 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 <stdio.h>
-#include <stdlib.h>
-#include <glib.h>
-
-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
+++ /dev/null
-/*
- * 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 <unistd.h>
-
-#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;
-}
projects / platform / core / api / system-settings.git / commitdiff
