From: JinWang An Date: Tue, 30 Jun 2020 17:05:37 +0000 (+0900) Subject: Revise UnitTest of system-settings with GTEST X-Git-Tag: submit/tizen/20200716.163529^0 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=1a76c66c7015e13f53c687547831b893275a7d1f;p=platform%2Fcore%2Fapi%2Fsystem-settings.git Revise UnitTest of system-settings with GTEST Change-Id: Iff12c0242d70e96d2ace210f93419e472c8d5838 Signed-off-by: JinWang An --- diff --git a/packaging/capi-system-system-settings.spec b/packaging/capi-system-system-settings.spec index a93457b..b1c53ae 100644 --- a/packaging/capi-system-system-settings.spec +++ b/packaging/capi-system-system-settings.spec @@ -29,6 +29,7 @@ BuildRequires: pkgconfig(capi-appfw-app-manager) BuildRequires: pkgconfig(capi-appfw-package-manager) BuildRequires: pkgconfig(ecore-evas) BuildRequires: pkgconfig(efl-extension) +BuildRequires: pkgconfig(gmock) Requires(post): /sbin/ldconfig Requires(postun): /sbin/ldconfig BuildRequires: pkgconfig(sqlite3) @@ -129,7 +130,14 @@ tar xf %{name}-gcov.tar -C %{buildroot}%{_datadir}/gcov/obj %check bash tests/scripts/vconf_golden_master.sh -LD_LIBRARY_PATH=.:tests:libutil LD_PRELOAD=tests/libsys-settings-mock.so tests/sys-settings-test +LD_LIBRARY_PATH=.:tests:libutil LD_PRELOAD=tests/libsys-settings-mock.so tests/sst-gtest-api +LD_LIBRARY_PATH=.:tests:libutil LD_PRELOAD=tests/libsys-settings-mock.so tests/sst-gtest-vconf +LD_LIBRARY_PATH=.:tests:libutil LD_PRELOAD=tests/libsys-settings-mock.so tests/sst-gtest-font +LD_LIBRARY_PATH=.:tests:libutil LD_PRELOAD=tests/libsys-settings-mock.so tests/sst-gtest-interface +LD_LIBRARY_PATH=.:tests:libutil LD_PRELOAD=tests/libsys-settings-mock.so tests/sst-gtest-sound +LD_LIBRARY_PATH=.:tests:libutil LD_PRELOAD=tests/libsys-settings-mock.so tests/sst-gtest-screen +LD_LIBRARY_PATH=.:tests:libutil LD_PRELOAD=tests/libsys-settings-mock.so tests/sst-gtest-time-n-locale +LD_LIBRARY_PATH=.:tests:libutil LD_PRELOAD=tests/libsys-settings-mock.so tests/sst-gtest-misc %if 0%{?gcov:1} lcov -c --ignore-errors graph --no-external -b . -d . -o %{name}.info genhtml %{name}.info -o out --legend --show-details @@ -138,13 +146,21 @@ 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}/sys-settings-test +bash %{sys_setting_test_dir}/ringtone/ringtone_files.sh create +XDG_RUNTIME_DIR=/run %{sys_setting_test_dir}/sst-gtest-api +XDG_RUNTIME_DIR=/run %{sys_setting_test_dir}/sst-gtest-vconf +XDG_RUNTIME_DIR=/run %{sys_setting_test_dir}/sst-gtest-font +XDG_RUNTIME_DIR=/run %{sys_setting_test_dir}/sst-gtest-interface +XDG_RUNTIME_DIR=/run %{sys_setting_test_dir}/sst-gtest-sound +XDG_RUNTIME_DIR=/run %{sys_setting_test_dir}/sst-gtest-screen +XDG_RUNTIME_DIR=/run %{sys_setting_test_dir}/sst-gtest-time-n-locale +XDG_RUNTIME_DIR=/run %{sys_setting_test_dir}/sst-gtest-misc + %postun -p /sbin/ldconfig %postun util-lib -p /sbin/ldconfig %postun unittests -bash %{sys_setting_test_dir}/ringtone_files.sh del +bash %{sys_setting_test_dir}/ringtone/ringtone_files.sh del %files %manifest %{name}.manifest diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 35072b3..4db67a0 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -1,19 +1,103 @@ -SET(UNITTEST "sys-settings-test") SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIE") SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIE") +SET(SST_SRC_DIR ${CMAKE_SOURCE_DIR}/src) +SET(SST_UTIL_DIR ${CMAKE_SOURCE_DIR}/libutil) +SET(SRC "sst_gtest_main.cpp") + ADD_DEFINITIONS("-DSST_TEST") +ADD_DEFINITIONS("-DN_THREADS=${N_THREADS}") +ADD_DEFINITIONS(-DSYS_SETTINGS_TEST_DIR=\"${TEST_INSTALL_DIR}\") +ADD_DEFINITIONS(-DSYS_SETTINGS_TEST_RINGTONE_DIR=\"${TEST_INSTALL_DIR}/ringtone\") + +FILE(GLOB TEST_RES RECURSE res/*) +FOREACH(RES_ITEM ${TEST_RES}) + IF( IS_DIRECTORY "${RES_ITEM}" ) + LIST( APPEND RES_DIRS "${RES_ITEM}" ) + ELSE() + LIST( APPEND RES_FILES "${RES_ITEM}" ) + ENDIF() +ENDFOREACH() +INSTALL(DIRECTORY ${RES_DIRS} DESTINATION ${TEST_INSTALL_DIR}) +INSTALL(FILES ${RES_FILES} DESTINATION ${TEST_INSTALL_DIR}) +INSTALL(FILES scripts/ringtone_files.sh DESTINATION ${TEST_INSTALL_DIR}/ringtone) + +pkg_check_modules(gtest_pkgs REQUIRED gmock) +INCLUDE_DIRECTORIES(${gtest_pkgs_INCLUDE_DIRS}) +INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/src) +LINK_DIRECTORIES(${gtest_pkgs_LIBRARY_DIRS}) SET(MOCK_LIB "sys-settings-mock") FILE(GLOB MOCK_SRCS mocks/*.c mocks/*.cpp) ADD_LIBRARY(${MOCK_LIB} SHARED ${MOCK_SRCS}) -FILE(GLOB TEST_SRCS *.c) -ADD_DEFINITIONS("-DN_THREADS=${N_THREADS}") -ADD_DEFINITIONS(-DSYS_SETTINGS_TEST_DIR=\"${TEST_INSTALL_DIR}\") -ADD_EXECUTABLE(${UNITTEST} ${TEST_SRCS}) -TARGET_LINK_LIBRARIES(${UNITTEST} ${PROJECT_NAME} dl) -INSTALL(TARGETS ${UNITTEST} DESTINATION ${TEST_INSTALL_DIR}) +SET(SST_API_GTEST "sst-gtest-api") +FILE(GLOB SST_API_GTEST_SRC + ${SST_SRC_DIR}/*.c + ${SST_SRC_DIR}/standard_excl/*.c + sst_gtest_api.cpp) +ADD_EXECUTABLE(${SST_API_GTEST} ${SRC} ${SST_API_GTEST_SRC}) +TARGET_LINK_LIBRARIES(${SST_API_GTEST} ${gtest_pkgs_LIBRARIES} ${pkgs_LIBRARIES} dl) +INSTALL(TARGETS ${SST_API_GTEST} DESTINATION ${TEST_INSTALL_DIR}) + +SET(SST_VCONF_GTEST "sst-gtest-vconf") +FILE(GLOB SST_VCONF_GTEST_SRCS + ${SST_SRC_DIR}/*.c + ${SST_SRC_DIR}/standard_excl/*.c + sst_gtest_vconf.cpp) +ADD_EXECUTABLE(${SST_VCONF_GTEST} ${SRC} ${SST_VCONF_GTEST_SRCS}) +TARGET_LINK_LIBRARIES(${SST_VCONF_GTEST} ${gtest_pkgs_LIBRARIES} ${pkgs_LIBRARIES} dl) +INSTALL(TARGETS ${SST_VCONF_GTEST} DESTINATION ${TEST_INSTALL_DIR}) + +SET(SST_FONT_GTEST "sst-gtest-font") +FILE(GLOB SST_FONT_GTEST_SRCS + ${SST_SRC_DIR}/*.c + ${SST_SRC_DIR}/standard_excl/*.c + sst_gtest_font.cpp) +ADD_EXECUTABLE(${SST_FONT_GTEST} ${SRC} ${SST_FONT_GTEST_SRCS}) +TARGET_LINK_LIBRARIES(${SST_FONT_GTEST} ${gtest_pkgs_LIBRARIES} ${pkgs_LIBRARIES} dl) +INSTALL(TARGETS ${SST_FONT_GTEST} DESTINATION ${TEST_INSTALL_DIR}) + +SET(SST_INTERFACE_GTEST "sst-gtest-interface") +FILE(GLOB SST_INTERFACE_GTEST_SRCS + ${SST_SRC_DIR}/*.c + ${SST_SRC_DIR}/standard_excl/*.c + sst_gtest_interface.cpp) +ADD_EXECUTABLE(${SST_INTERFACE_GTEST} ${SRC} ${SST_INTERFACE_GTEST_SRCS}) +TARGET_LINK_LIBRARIES(${SST_INTERFACE_GTEST} ${gtest_pkgs_LIBRARIES} ${pkgs_LIBRARIES} dl) +INSTALL(TARGETS ${SST_INTERFACE_GTEST} DESTINATION ${TEST_INSTALL_DIR}) + +SET(SST_SOUND_GTEST "sst-gtest-sound") +FILE(GLOB SST_SOUND_GTEST_SRCS + ${SST_SRC_DIR}/*.c + ${SST_SRC_DIR}/standard_excl/*.c + sst_gtest_sound.cpp) +ADD_EXECUTABLE(${SST_SOUND_GTEST} ${SRC} ${SST_SOUND_GTEST_SRCS}) +TARGET_LINK_LIBRARIES(${SST_SOUND_GTEST} ${gtest_pkgs_LIBRARIES} ${pkgs_LIBRARIES} dl) +INSTALL(TARGETS ${SST_SOUND_GTEST} DESTINATION ${TEST_INSTALL_DIR}) + +SET(SST_SCREEN_GTEST "sst-gtest-screen") +FILE(GLOB SST_SCREEN_GTEST_SRCS + ${SST_SRC_DIR}/*.c + ${SST_SRC_DIR}/standard_excl/*.c + sst_gtest_screen.cpp) +ADD_EXECUTABLE(${SST_SCREEN_GTEST} ${SRC} ${SST_SCREEN_GTEST_SRCS}) +TARGET_LINK_LIBRARIES(${SST_SCREEN_GTEST} ${gtest_pkgs_LIBRARIES} ${pkgs_LIBRARIES} dl) +INSTALL(TARGETS ${SST_SCREEN_GTEST} DESTINATION ${TEST_INSTALL_DIR}) + +SET(SST_TIME_N_LOCALE_GTEST "sst-gtest-time-n-locale") +FILE(GLOB SST_TIME_N_LOCALE_GTEST_SRCS + ${SST_SRC_DIR}/*.c + ${SST_SRC_DIR}/standard_excl/*.c + sst_gtest_time_N_locale.cpp) +ADD_EXECUTABLE(${SST_TIME_N_LOCALE_GTEST} ${SRC} ${SST_TIME_N_LOCALE_GTEST_SRCS}) +TARGET_LINK_LIBRARIES(${SST_TIME_N_LOCALE_GTEST} ${gtest_pkgs_LIBRARIES} ${pkgs_LIBRARIES} dl) +INSTALL(TARGETS ${SST_TIME_N_LOCALE_GTEST} DESTINATION ${TEST_INSTALL_DIR}) -FILE(GLOB TEST_RES res/*) -INSTALL(FILES ${TEST_RES} DESTINATION ${TEST_INSTALL_DIR}) -INSTALL(FILES scripts/ringtone_files.sh DESTINATION ${TEST_INSTALL_DIR}) +SET(SST_MISC_GTEST "sst-gtest-misc") +FILE(GLOB SST_MISC_GTEST_SRCS + ${SST_SRC_DIR}/*.c + ${SST_SRC_DIR}/standard_excl/*.c + sst_gtest_misc.cpp) +ADD_EXECUTABLE(${SST_MISC_GTEST} ${SRC} ${SST_MISC_GTEST_SRCS}) +TARGET_LINK_LIBRARIES(${SST_MISC_GTEST} ${gtest_pkgs_LIBRARIES} ${pkgs_LIBRARIES} dl) +INSTALL(TARGETS ${SST_MISC_GTEST} DESTINATION ${TEST_INSTALL_DIR}) diff --git a/tests/mocks/efl-extension.c b/tests/mocks/efl-extension.c deleted file mode 100644 index 53a720d..0000000 --- a/tests/mocks/efl-extension.c +++ /dev/null @@ -1,24 +0,0 @@ -/* - * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#include -#include -#include -#include "sst.h" - -API bool eext_config_font_set(char *name, int size) -{ - return true; -} diff --git a/tests/mocks/efl.c b/tests/mocks/efl.c new file mode 100644 index 0000000..1edd937 --- /dev/null +++ b/tests/mocks/efl.c @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include +#include +#include +#include "sst.h" + +API bool eext_config_font_set(char *name, int size) +{ + return true; +} + +API int evas_object_image_load_error_get(void *img) +{ + INFO("Enter return 0"); + return 0; +} diff --git a/tests/mocks/libc.c b/tests/mocks/libc.c index b381e11..f619d3b 100644 --- a/tests/mocks/libc.c +++ b/tests/mocks/libc.c @@ -23,17 +23,21 @@ API int access(const char *pathname, int mode) { - if (0 == strcmp(pathname, SYS_SETTINGS_TEST_DIR"/ringtone_sdk.mp3")) + if (0 == strcmp(pathname, SYS_SETTINGS_TEST_RINGTONE_DIR"/ringtone_sdk.mp3")) return 0; - if (0 == strcmp(pathname, SYS_SETTINGS_TEST_DIR"/Over the horizon.mp3")) + if (0 == strcmp(pathname, SYS_SETTINGS_TEST_RINGTONE_DIR"/Over the horizon.mp3")) return 0; - if (0 == strcmp(pathname, SYS_SETTINGS_TEST_DIR"/big_buck_bunny.mp3")) + if (0 == strcmp(pathname, SYS_SETTINGS_TEST_RINGTONE_DIR"/big_buck_bunny.mp3")) return 0; - if (0 == strcmp(pathname, SYS_SETTINGS_TEST_DIR"/daliTestVideo.mp3")) + if (0 == strcmp(pathname, SYS_SETTINGS_TEST_RINGTONE_DIR"/daliTestVideo.mp3")) return 0; - if (0 == strcmp(pathname, SYS_SETTINGS_TEST_DIR"/sound_5.mp3")) + if (0 == strcmp(pathname, SYS_SETTINGS_TEST_RINGTONE_DIR"/sound_5.mp3")) return 0; - if (0 == strcmp(pathname, SYS_SETTINGS_TEST_DIR"/tct-content-tizen-tests_video.mp3")) + if (0 == strcmp(pathname, SYS_SETTINGS_TEST_RINGTONE_DIR"/tct-content-tizen-tests_video.mp3")) + return 0; + if (0 == strcmp(pathname, "/opt/usr/data/settings/Alerts/General notification_sdk.wav")) + return 0; + if (0 == strcmp(pathname, "/opt/usr/data/settings/Ringtones/ringtone_sdk.mp3")) return 0; int (*org_fn)(const char *, int); diff --git a/tests/mocks/pkgmgrinfo_appinfo.c b/tests/mocks/pkgmgrinfo_appinfo.c index 55e572e..6d29f08 100644 --- a/tests/mocks/pkgmgrinfo_appinfo.c +++ b/tests/mocks/pkgmgrinfo_appinfo.c @@ -24,6 +24,10 @@ API int pkgmgrinfo_appinfo_get_appinfo(const char *appid, pkgmgrinfo_appinfo_h * 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; } diff --git a/tests/mocks/system_info.c b/tests/mocks/system_info.c index c52197d..b82121b 100644 --- a/tests/mocks/system_info.c +++ b/tests/mocks/system_info.c @@ -70,7 +70,7 @@ API int system_info_get_platform_bool(const char *key, bool *value) API int system_info_get_platform_string(const char *key, char **value) { if (0 == strcmp(key, "tizen.org/feature/profile")) { - *value = strdup("mobile"); + *value = strdup("wearable"); return 0; } diff --git a/tests/mocks/vconf.cpp b/tests/mocks/vconf.cpp index 253656a..a2442da 100644 --- a/tests/mocks/vconf.cpp +++ b/tests/mocks/vconf.cpp @@ -160,6 +160,7 @@ static int _sqlite_connect() return VCONF_OK; } +#if 0 /************************************************ * keynode handling APIs * ************************************************/ @@ -256,6 +257,7 @@ API int vconf_keylist_del(keylist_t *keylist, const char *keyname) return 0; } +#endif /************************************************ * setting APIs * ************************************************/ @@ -376,10 +378,12 @@ static int _vconf_set_str(const char *in_key, const char *strval) return VCONF_ERROR; } +#if 0 API int vconf_set(keylist_t *keylist) { return 0; } +#endif API int vconf_set_int(const char *in_key, const int intval) { @@ -419,6 +423,7 @@ API int vconf_set_bool(const char *in_key, const int boolval) return VCONF_OK; } +#if 0 API int vconf_set_dbl(const char *in_key, const double dblval) { int rc; @@ -437,6 +442,7 @@ API int vconf_set_dbl(const char *in_key, const double dblval) return VCONF_OK; } +#endif API int vconf_set_str(const char *in_key, const char *strval) { @@ -455,10 +461,12 @@ API int vconf_set_str(const char *in_key, const char *strval) return VCONF_OK; } +#if 0 API int vconf_get(keylist_t *keylist, const char *in_parentDIR, get_option_t option) { return 0; } +#endif API char *vconf_get_str(const char *in_key) { @@ -561,6 +569,7 @@ API int vconf_get_bool(const char *in_key, int *boolval) return VCONF_OK; } +#if 0 API int vconf_get_dbl(const char *in_key, double *dblval) { char *value = vconf_get_str(in_key); @@ -589,6 +598,7 @@ API int vconf_unset_recursive(const char *in_dir) { return 0; } +#endif API int vconf_notify_key_changed(const char *in_key, vconf_callback_fn cb, void *user_data) @@ -615,10 +625,12 @@ API int vconf_ignore_key_changed(const char *in_key, vconf_callback_fn cb) return VCONF_OK; } +#if 0 API int vconf_get_ext_errno(void) { return 0; } +#endif #ifdef __cplusplus } diff --git a/tests/res/bg_test.png b/tests/res/bg_test.png new file mode 100644 index 0000000..aa82a58 Binary files /dev/null and b/tests/res/bg_test.png differ diff --git a/tests/res/ringtone/ringtone_sdk.mp3 b/tests/res/ringtone/ringtone_sdk.mp3 new file mode 100644 index 0000000..f159e35 Binary files /dev/null and b/tests/res/ringtone/ringtone_sdk.mp3 differ diff --git a/tests/res/ringtone_sdk.mp3 b/tests/res/ringtone_sdk.mp3 deleted file mode 100644 index f159e35..0000000 Binary files a/tests/res/ringtone_sdk.mp3 and /dev/null differ diff --git a/tests/sst_gtest_api.cpp b/tests/sst_gtest_api.cpp new file mode 100644 index 0000000..c41b2d8 --- /dev/null +++ b/tests/sst_gtest_api.cpp @@ -0,0 +1,262 @@ +/* + * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include + +extern "C" { +#include "system_settings.h" +#include "sst.h" +int system_settings_subscribe_changes(system_settings_key_e key, + system_settings_changed_cb callback, + void *user_data, system_settings_cb_id *id); +int system_settings_unsubscribe_changes(system_settings_key_e key, + system_settings_cb_id id); +} + + +class SstApiTest : public ::testing::Test { +protected: + void SetUp() override + { + loop = g_main_loop_new(NULL, FALSE); + } + + void TearDown() override + { + g_main_loop_unref(loop); + loop = NULL; + } + + static gboolean checkCallbackIdle(gpointer data) + { + int ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, true); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + return G_SOURCE_REMOVE; + } + + static void changedMultiCallback1(system_settings_key_e key, void *user_data) + { + INFO("changedMultiCallback1 called!"); + result = 0x1; + if (0x11 == result) + g_main_loop_quit(loop); + } + + static void changedMultiCallback2(system_settings_key_e key, void *user_data) + { + INFO("changedMultiCallback2 called!"); + result = result | 0x10; + if (0x11 == result) + g_main_loop_quit(loop); + } + + static void changedCallback(system_settings_key_e key, void *user_data) + { + INFO("Callback called!"); + result = SYSTEM_SETTINGS_ERROR_NONE; + g_main_loop_quit(loop); + } + + static bool ringtoneListCallback(int index, const char *data, void *user_data) + { + INFO("filename(%s)", data); + int *ringtone_num = (int*)user_data; + *ringtone_num += 1; + return true; + } + + static gboolean checkRingtoneIdle(gpointer data) + { + int ringtone_num = 0; + int cur_cnt = 0; + result = system_settings_foreach_value_string(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, ringtoneListCallback, &cur_cnt); + + for (int i = 0; i < ringtoneFilesCnt; i++) { + result = system_settings_add_value_string(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, ringtoneFiles[i]); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + } + result = system_settings_foreach_value_string(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, ringtoneListCallback, &ringtone_num); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + for (int i = ringtoneFilesCnt - 1; i >= 0; i--) { + result = system_settings_delete_value_string(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, ringtoneFiles[i]); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + } + EXPECT_EQ(ringtone_num - cur_cnt, ringtoneFilesCnt); + g_main_loop_quit(loop); + return G_SOURCE_REMOVE; + } + + static int result; + static GMainLoop *loop; + static const char *ringtoneFiles[]; + static int ringtoneFilesCnt; +}; + +const char *SstApiTest::ringtoneFiles[] = { + SYS_SETTINGS_TEST_RINGTONE_DIR"/Over the horizon.mp3", + SYS_SETTINGS_TEST_RINGTONE_DIR"/big_buck_bunny.mp3", + SYS_SETTINGS_TEST_RINGTONE_DIR"/daliTestVideo.mp3", + SYS_SETTINGS_TEST_RINGTONE_DIR"/sound_5.mp3", + SYS_SETTINGS_TEST_RINGTONE_DIR"/tct-content-tizen-tests_video.mp3" +}; +int SstApiTest::ringtoneFilesCnt = sizeof(ringtoneFiles)/sizeof(const char*); +GMainLoop *SstApiTest::loop = NULL; +int SstApiTest::result = 0; + +TEST_F(SstApiTest, getValueInt) +{ + int val; + result = system_settings_get_value_int(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); +} + +TEST_F(SstApiTest, setValueInt) +{ + int bkVal; + int getVal; + int setVal = 60; + result = system_settings_get_value_int(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, &bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = system_settings_set_value_int(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = system_settings_get_value_int(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, &getVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + EXPECT_EQ(setVal, getVal); + result = system_settings_set_value_int(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); +} + +TEST_F(SstApiTest, getValueBool) +{ + bool val; + result = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); +} + +TEST_F(SstApiTest, setValueBool) +{ + bool bkVal; + bool getVal; + bool setVal = false; + result = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, &bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, &getVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + EXPECT_EQ(setVal, getVal); + result = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); +} + +TEST_F(SstApiTest, getValueString) +{ + char *val; + result = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + free(val); +} + +TEST_F(SstApiTest, setValueString) +{ + char *bkVal; + char *getVal; + const char *setVal = "ko_KR"; + result = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, &bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, &getVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + EXPECT_STREQ(setVal, getVal); + free(getVal); + result = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + free(bkVal); +} + +TEST_F(SstApiTest, setUnsetChangedCallback) +{ + bool bkVal; + result = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, &bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, false); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, changedCallback, NULL); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = -1; + g_idle_add(checkCallbackIdle, NULL); + g_main_loop_run(loop); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); +} + +TEST_F(SstApiTest, addDeleteForeachValueString) +{ + g_idle_add(checkRingtoneIdle, NULL); + g_main_loop_run(loop); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); +} + +TEST_F(SstApiTest, addDeleteChangedCallback) +{ + bool bkVal; + result = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, &bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, false); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = system_settings_add_changed_cb(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, changedMultiCallback1, NULL); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = system_settings_add_changed_cb(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, changedMultiCallback2, NULL); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = -1; + g_idle_add(checkCallbackIdle, NULL); + g_main_loop_run(loop); + EXPECT_EQ(0x11, result); + result = system_settings_remove_changed_cb(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, changedMultiCallback1); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = system_settings_remove_changed_cb(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, changedMultiCallback2); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); +} + +TEST_F(SstApiTest, subUnsubscribeCallback) +{ + system_settings_cb_id id; + bool bkVal; + result = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, &bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, false); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = system_settings_subscribe_changes(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, changedCallback, NULL, &id); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = -1; + g_idle_add(checkCallbackIdle, NULL); + g_main_loop_run(loop); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = system_settings_unsubscribe_changes(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, id); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); +} diff --git a/tests/sst_gtest_font.cpp b/tests/sst_gtest_font.cpp new file mode 100644 index 0000000..9993d6e --- /dev/null +++ b/tests/sst_gtest_font.cpp @@ -0,0 +1,102 @@ +/* + * 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 "sst_tests.h" + +#include +#include +#include + +extern "C" { +#include "system_settings.h" +#include "sst.h" +#include "sst_font.h" +#include "sst_vconf.h" +#include "sst_interface.h" +} + +class SstFontTest : public ::testing::Test { +protected: + static int result; +}; + +int SstFontTest::result = 0; + +TEST_F(SstFontTest, getDefaultfont) +{ + char *val; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_FONT_TYPE, &iface); + SST_TEST_CHECK_NOT_SUPPORTED(result); + result = sst_font_get_default_type(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + free(val); +} + +TEST_F(SstFontTest, setFontType) +{ + char *getVal = NULL; + const char *eVal = "WrongFontName"; + const char *setVal = "BreezeSans"; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_FONT_TYPE, &iface); + SST_TEST_CHECK_NOT_SUPPORTED(result); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_font_set_type(iface, eVal); + EXPECT_NE(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_font_set_type(iface, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_get_str(iface, &getVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + EXPECT_STREQ(setVal, getVal); + + free(getVal); +} + +TEST_F(SstFontTest, setFontSize) +{ + int fontSize[] = { + SYSTEM_SETTINGS_FONT_SIZE_SMALL, + SYSTEM_SETTINGS_FONT_SIZE_NORMAL, + SYSTEM_SETTINGS_FONT_SIZE_LARGE, + SYSTEM_SETTINGS_FONT_SIZE_HUGE, + SYSTEM_SETTINGS_FONT_SIZE_GIANT + }; + int fsCnt = sizeof(fontSize) / sizeof(fontSize[0]); + int getVal; + int bkVal; + int setVal; + sst_interface *iface; + + result = sst_get_interface(SYSTEM_SETTINGS_KEY_FONT_SIZE, &iface); + SST_TEST_CHECK_NOT_SUPPORTED(result); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_get_int(iface, &bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + for (int i = 0; i < fsCnt; i++) { + setVal = fontSize[i]; + result = sst_font_set_size(iface, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_get_int(iface, &getVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + EXPECT_EQ(setVal, getVal); + } + + result = sst_font_set_size(iface, bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); +} diff --git a/tests/sst_gtest_interface.cpp b/tests/sst_gtest_interface.cpp new file mode 100644 index 0000000..84c759c --- /dev/null +++ b/tests/sst_gtest_interface.cpp @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include + +extern "C" { +#include "system_settings.h" +#include "sst_interface.h" +#include "sst.h" +} +class SstInterfaceTest : public ::testing::Test { +protected:; + static const int deprecatedKey; + static int result; +}; + +int SstInterfaceTest::result = 0; +const int SstInterfaceTest::deprecatedKey = (int)SYSTEM_SETTINGS_KEY_3G_DATA_NETWORK_ENABLED + 1; + +TEST_F(SstInterfaceTest, getInterfaceOk) +{ + sst_interface *iface; + for (int key = (int)SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE; + key < (int)SYSTEM_SETTINGS_KEY_MAX; key++) { + if (key == deprecatedKey) { + continue; + } + result = sst_get_interface((system_settings_key_e)key, &iface); + EXPECT_TRUE((SYSTEM_SETTINGS_ERROR_NONE == result) || (SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED == result)); + } +} + +TEST_F(SstInterfaceTest, getInterfaceError) +{ + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_MAX, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, result); + + result = sst_get_interface((system_settings_key_e)deprecatedKey, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER, result); +} diff --git a/tests/sst_gtest_main.cpp b/tests/sst_gtest_main.cpp new file mode 100644 index 0000000..70b941d --- /dev/null +++ b/tests/sst_gtest_main.cpp @@ -0,0 +1,21 @@ +/* + * 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 + +int main(int argc, char **argv) { + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} diff --git a/tests/sst_gtest_misc.cpp b/tests/sst_gtest_misc.cpp new file mode 100644 index 0000000..c723690 --- /dev/null +++ b/tests/sst_gtest_misc.cpp @@ -0,0 +1,110 @@ +/* + * 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 "sst_tests.h" + +#include +#include +#include + +extern "C" { +#include "system_settings.h" +#include "sst.h" +#include "sst_interface.h" +#include "sst_misc.h" +#include +} + +class SstMisc : public ::testing::Test { +protected: + static int result; +}; + +int SstMisc::result = 0; + +TEST_F(SstMisc, fileExists) +{ + bool ret = sst_misc_file_exists(SYS_SETTINGS_TEST_RINGTONE_DIR"/tct-content-tizen-tests_video.mp3"); + EXPECT_EQ(true, ret); + + ret = sst_misc_file_exists("file.not_exist"); + EXPECT_EQ(false, ret); +} + +TEST_F(SstMisc, getWifiQSNoti) +{ + bool val = NULL; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_NETWORK_WIFI_NOTIFICATION, &iface); + SST_TEST_CHECK_NOT_SUPPORTED(result); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_misc_get_wifi_QS_noti(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); +} + +TEST_F(SstMisc, getAdsID) +{ + char *val = NULL; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_ADS_ID, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_misc_get_ads_id(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + free(val); +} + +TEST_F(SstMisc, setAdsID) +{ + char *bkVal = NULL; + char *getVal = NULL; + const char *setVal = "00000215-0156-0133-0034-000000000102"; + + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_ADS_ID, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_misc_get_ads_id(iface, &bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + vconf_set_int(VCONFKEY_SETAPPL_AD_ID_OPT_OUT, 0); + result = sst_misc_set_ads_id(iface, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_misc_get_ads_id(iface, &getVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + EXPECT_STREQ(setVal, getVal); + + result = sst_misc_set_ads_id(iface, bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + vconf_set_int(VCONFKEY_SETAPPL_AD_ID_OPT_OUT, 1); + + free(bkVal); + free(getVal); +} + +TEST_F(SstMisc, getUltraDataSaveState) +{ + int val; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_ULTRA_DATA_SAVE, &iface); + SST_TEST_CHECK_NOT_SUPPORTED(result); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_misc_get_uds_state(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); +} diff --git a/tests/sst_gtest_screen.cpp b/tests/sst_gtest_screen.cpp new file mode 100644 index 0000000..e48f8c1 --- /dev/null +++ b/tests/sst_gtest_screen.cpp @@ -0,0 +1,154 @@ +/* + * 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 "sst_tests.h" + +#include +#include +#include + +extern "C" { +#include "system_settings.h" +#include "sst.h" +#include "sst_vconf.h" +#include "sst_interface.h" +#include "sst_screen.h" +} + +class SstScreenTest : public ::testing::Test { +protected: + static int result; + static const char *bgPath; +}; + +int SstScreenTest::result = 0; +const char *SstScreenTest::bgPath = SYS_SETTINGS_TEST_DIR"/bg_test.png"; + +TEST_F(SstScreenTest, getHomeWallPaper) +{ + char *val = NULL; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_FONT_TYPE, &iface); + if (SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED == result) + return; + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_vconf_get_str(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + free(val); +} + +TEST_F(SstScreenTest, setHomeWallPaper) +{ + char *getVal = NULL; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_WALLPAPER_HOME_SCREEN, &iface); + SST_TEST_CHECK_NOT_SUPPORTED(result); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_screen_set_home_wallpaper(iface, bgPath); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_get_str(iface, &getVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + EXPECT_STREQ(bgPath, getVal); + free(getVal); +} + +TEST_F(SstScreenTest, setLockWallPaper) +{ + char *getVal = NULL; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_WALLPAPER_LOCK_SCREEN, &iface); + SST_TEST_CHECK_NOT_SUPPORTED(result); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_screen_set_lock_wallpaper(iface, bgPath); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_get_str(iface, &getVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + EXPECT_STREQ(bgPath, getVal); + free(getVal); + +} + +TEST_F(SstScreenTest, getLockScreen) +{ + char *val = NULL; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCKSCREEN_APP, &iface); + SST_TEST_CHECK_NOT_SUPPORTED(result); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_screen_get_lockscreen(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + free(val); +} + +TEST_F(SstScreenTest, setLockScreen) +{ + char *bkVal = NULL; + char *getVal = NULL; + const char *setVal = "org.tizen.voice-control-panel"; + + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCKSCREEN_APP, &iface); + SST_TEST_CHECK_NOT_SUPPORTED(result); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_screen_get_lockscreen(iface, &bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_screen_set_lockscreen(iface, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_screen_get_lockscreen(iface, &getVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + EXPECT_STREQ(setVal, getVal); + + free(bkVal); + free(getVal); +} + +TEST_F(SstScreenTest, setBackLightTime) +{ + int bkVal; + int getVal; + int setVal = 300; + int eMinVal = -5; + int eMaxVal = 601; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_vconf_get_int(iface, &bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_screen_set_backlight_time(iface, eMinVal); + EXPECT_NE(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_screen_set_backlight_time(iface, eMaxVal); + EXPECT_NE(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_screen_set_backlight_time(iface, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_vconf_get_int(iface, &getVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + EXPECT_EQ(getVal, setVal); + + result = sst_screen_set_backlight_time(iface, bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); +} diff --git a/tests/sst_gtest_sound.cpp b/tests/sst_gtest_sound.cpp new file mode 100644 index 0000000..3dba6f3 --- /dev/null +++ b/tests/sst_gtest_sound.cpp @@ -0,0 +1,235 @@ +/* + * 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 "sst_tests.h" + +#include +#include +#include + +extern "C" { +#include "system_settings.h" +#include "sst.h" +#include "sst_sound.h" +#include "sst_vconf.h" +#include "sst_interface.h" +} + +class SstSoundTest : public ::testing::Test { +protected: + void SetUp() override + { + loop = g_main_loop_new(NULL, FALSE); + } + + void TearDown() override + { + g_main_loop_unref(loop); + loop = NULL; + } + + static bool ringtoneListCallback(int index, const char *data, void *user_data) + { + INFO("filename(%s)", data); + int *ringtone_num = (int*)user_data; + *ringtone_num += 1; + return true; + } + + static gboolean checkRingtoneIdle(gpointer data) + { + int ringtone_num = 0; + int cur_cnt = 0; + result = sst_sound_get_call_ringtone_list(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, ringtoneListCallback, &cur_cnt); + + for (int i = 0; i < ringtoneFilesCnt; i++) { + result = sst_sound_add_call_ringtone(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, ringtoneFiles[i]); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + } + result = sst_sound_get_call_ringtone_list(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, ringtoneListCallback, &ringtone_num); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + for (int i = ringtoneFilesCnt - 1; i >= 0; i--) { + result = sst_sound_del_call_ringtone(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, ringtoneFiles[i]); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + } + EXPECT_EQ(ringtone_num - cur_cnt, ringtoneFilesCnt); + g_main_loop_quit(loop); + return G_SOURCE_REMOVE; + } + static int result; + static GMainLoop *loop; + static const char *ringtonePath; + static int ringtoneFilesCnt; + static const char *ringtoneFiles[]; +}; + +const char *SstSoundTest::ringtonePath = SYS_SETTINGS_TEST_RINGTONE_DIR "/ringtone_sdk.mp3"; +const char *SstSoundTest::ringtoneFiles[] = { + SYS_SETTINGS_TEST_RINGTONE_DIR"/Over the horizon.mp3", + SYS_SETTINGS_TEST_RINGTONE_DIR"/sound_5.mp3", + SYS_SETTINGS_TEST_RINGTONE_DIR"/big_buck_bunny.mp3", + SYS_SETTINGS_TEST_RINGTONE_DIR"/daliTestVideo.mp3", + SYS_SETTINGS_TEST_RINGTONE_DIR"/tct-content-tizen-tests_video.mp3" +}; +int SstSoundTest::ringtoneFilesCnt = sizeof(ringtoneFiles)/sizeof(const char*); +GMainLoop *SstSoundTest::loop = NULL; +int SstSoundTest::result = 0; + +TEST_F(SstSoundTest, getCallRingtone) +{ + char *val = NULL; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, &iface); + SST_TEST_CHECK_NOT_SUPPORTED(result); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_sound_get_call_ringtone(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + free(val); +} + +TEST_F(SstSoundTest, setCallRingtone) +{ + char *bkVal = NULL; + char *getVal = NULL; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, &iface); + SST_TEST_CHECK_NOT_SUPPORTED(result); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_sound_get_call_ringtone(iface, &bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_sound_set_call_ringtone(iface, ringtonePath); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_sound_get_call_ringtone(iface, &getVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + EXPECT_STREQ(ringtonePath, getVal); + + result = sst_sound_set_call_ringtone(iface, bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + free(bkVal); + free(getVal); +} + +TEST_F(SstSoundTest, addDelGetRingtone) +{ + g_idle_add(checkRingtoneIdle, NULL); + g_main_loop_run(loop); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); +} + + +TEST_F(SstSoundTest, getEmailAlert) +{ + char *val = NULL; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_EMAIL_ALERT_RINGTONE, &iface); + SST_TEST_CHECK_NOT_SUPPORTED(result); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_sound_get_email_alert(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + free(val); +} + +TEST_F(SstSoundTest, setEmailAlert) +{ + char *bkVal = NULL; + char *getVal = NULL; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_EMAIL_ALERT_RINGTONE, &iface); + SST_TEST_CHECK_NOT_SUPPORTED(result); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_sound_get_email_alert(iface, &bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_sound_set_email_alert(iface, ringtonePath); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_sound_get_email_alert(iface, &getVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + EXPECT_STREQ(ringtonePath, getVal); + + result = sst_sound_set_email_alert(iface, bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + free(bkVal); + free(getVal); +} + +TEST_F(SstSoundTest, setNotification) +{ + char *bkVal = NULL; + char *getVal = NULL; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_SOUND_NOTIFICATION, &iface); + SST_TEST_CHECK_NOT_SUPPORTED(result); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_vconf_get_str(iface, &bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_sound_set_notification(iface, ringtonePath); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_vconf_get_str(iface, &getVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + EXPECT_STREQ(ringtonePath, getVal); + + result = sst_sound_set_notification(iface, bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + free(bkVal); + free(getVal); +} + +TEST_F(SstSoundTest, getSlientMode) +{ + bool val = false; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_SOUND_SILENT_MODE, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_sound_get_silent_mode(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); +} + +TEST_F(SstSoundTest, setSlientMode) +{ + bool bkVal = false; + bool getVal = false; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_SOUND_SILENT_MODE, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_sound_get_silent_mode(iface, &bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_sound_set_silent_mode(iface, true); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_sound_get_silent_mode(iface, &getVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + EXPECT_EQ(getVal, true); + + result = sst_sound_set_silent_mode(iface, bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); +} diff --git a/tests/sst_gtest_time_N_locale.cpp b/tests/sst_gtest_time_N_locale.cpp new file mode 100644 index 0000000..cb5d723 --- /dev/null +++ b/tests/sst_gtest_time_N_locale.cpp @@ -0,0 +1,193 @@ +/* + * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include + +extern "C" { +#include "system_settings.h" +#include "sst.h" +#include "sst_interface.h" +#include "sst_time_N_locale.h" +} + +class SstTimeNLocaleTest : public ::testing::Test { +protected: + static int result; +}; + +int SstTimeNLocaleTest::result = 0; + +TEST_F(SstTimeNLocaleTest, getCountry) +{ + char *val = NULL; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_locale_get_country(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + free(val); +} + +TEST_F(SstTimeNLocaleTest, setCountry) +{ + char *bkVal = NULL; + char *getVal = NULL; + const char *setVal = "ko_KR"; + + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_locale_get_country(iface, &bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_locale_set_country(iface, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_locale_get_country(iface, &getVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + EXPECT_STREQ(setVal, getVal); + + result = sst_locale_set_country(iface, bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + free(bkVal); + free(getVal); +} + +TEST_F(SstTimeNLocaleTest, getLanguage) +{ + char *val = NULL; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_locale_get_language(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + free(val); +} + +TEST_F(SstTimeNLocaleTest, setLanguage) +{ + char *bkVal = NULL; + char *getVal = NULL; + const char *setVal = "ko_KR"; + + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_locale_get_language(iface, &bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_locale_set_language(iface, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_locale_get_language(iface, &getVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + EXPECT_STREQ(setVal, getVal); + + free(bkVal); + free(getVal); +} + +TEST_F(SstTimeNLocaleTest, getTimeformat24Hour) +{ + bool val = NULL; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_locale_get_timeformat_24hour(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); +} + +TEST_F(SstTimeNLocaleTest, setTimeformat24Hour) +{ + bool bkVal; + bool getVal; + bool setVal; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_locale_get_timeformat_24hour(iface, &bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + setVal = !bkVal; + + result = sst_locale_set_timeformat_24hour(iface, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_locale_get_timeformat_24hour(iface, &getVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + EXPECT_EQ(getVal, setVal); + + result = sst_locale_set_timeformat_24hour(iface, bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); +} + +TEST_F(SstTimeNLocaleTest, getTimeZone) +{ + char *val = NULL; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCALE_TIMEZONE, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_locale_get_timezone(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + free(val); +} + +TEST_F(SstTimeNLocaleTest, setTimeZone) +{ + char *bkVal = NULL; + char *getVal = NULL; + const char *setVal = "Asia/Seoul"; + + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCALE_TIMEZONE, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_locale_get_timezone(iface, &bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_locale_set_timezone(iface, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_locale_get_timezone(iface, &getVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + EXPECT_STREQ(setVal, getVal); + + result = sst_locale_set_timezone(iface, bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + free(bkVal); + free(getVal); +} + +TEST_F(SstTimeNLocaleTest, getTimeChanged) +{ + int val; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_TIME_CHANGED, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_time_get_changed(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); +} diff --git a/tests/sst_gtest_vconf.cpp b/tests/sst_gtest_vconf.cpp new file mode 100644 index 0000000..c4bce06 --- /dev/null +++ b/tests/sst_gtest_vconf.cpp @@ -0,0 +1,248 @@ +/* + * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include + +extern "C" { +#include "system_settings.h" +#include "sst.h" +#include "sst_vconf.h" +#include "sst_interface.h" +} + +class SstVconfTest : public ::testing::Test { +protected: + void SetUp() override + { + loop = g_main_loop_new(NULL, FALSE); + } + + void TearDown() override + { + g_main_loop_unref(loop); + loop = NULL; + } + + static gboolean checkCallbackIdle(gpointer data) + { + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + int ret = sst_vconf_set_bool(iface, true); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret); + + return G_SOURCE_REMOVE; + } + + static void changedMultiCallback1(system_settings_key_e key, void *user_data) + { + INFO("changedMultiCallback1 called!"); + result = 0x1; + if (0x11 == result) + g_main_loop_quit(loop); + } + + static void changedMultiCallback2(system_settings_key_e key, void *user_data) + { + INFO("changedMultiCallback2 called!"); + result = result | 0x10; + if (0x11 == result) + g_main_loop_quit(loop); + } + + static void changedCallback(system_settings_key_e key, void *user_data) + { + INFO("Callback called!"); + result = SYSTEM_SETTINGS_ERROR_NONE; + g_main_loop_quit(loop); + } + + static int result; + static GMainLoop *loop; + static const char *ringtoneFiles[]; +}; + +GMainLoop *SstVconfTest::loop = NULL; +int SstVconfTest::result = 0; + +TEST_F(SstVconfTest, getValueInt) +{ + int val; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_get_int(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); +} + +TEST_F(SstVconfTest, setValueInt) +{ + int bkVal; + int getVal; + int setVal = 60; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_get_int(iface, &bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_vconf_set_int(iface, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_get_int(iface, &getVal);; + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + EXPECT_EQ(setVal, getVal); + result = sst_vconf_set_int(iface, bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); +} + +TEST_F(SstVconfTest, getValueBool) +{ + bool val; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_get_bool(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); +} + +TEST_F(SstVconfTest, setValueBool) +{ + bool bkVal; + bool getVal; + bool setVal = false; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_get_bool(iface, &bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_set_bool(iface, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_get_bool(iface, &getVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + EXPECT_EQ(setVal, getVal); + result = sst_vconf_set_bool(iface, bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); +} + +TEST_F(SstVconfTest, getValueString) +{ + char *val; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_get_str(iface, &val); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + free(val); +} + +TEST_F(SstVconfTest, setValueString) +{ + char *bkVal; + char *getVal; + const char *setVal = "ko_KR"; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + + result = sst_vconf_get_str(iface, &bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_set_str(iface, setVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_get_str(iface, &getVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + EXPECT_STREQ(setVal, getVal); + free(getVal); + result = sst_vconf_set_str(iface, bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + free(bkVal); +} + +TEST_F(SstVconfTest, setUnsetChangedCallback) +{ + bool bkVal; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_get_bool(iface, &bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_set_bool(iface, false); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_set_cb(iface, changedCallback, NULL); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = -1; + g_idle_add(checkCallbackIdle, NULL); + g_main_loop_run(loop); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_unset_cb(iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_set_bool(iface, bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); +} + +TEST_F(SstVconfTest, addDeleteChangedCallback) +{ + bool bkVal; + sst_interface *iface; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_get_bool(iface, &bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_set_bool(iface, false); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_add_multi_cb(iface, changedMultiCallback1, NULL); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_add_multi_cb(iface, changedMultiCallback2, NULL); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = -1; + g_idle_add(checkCallbackIdle, NULL); + g_main_loop_run(loop); + EXPECT_EQ(0x11, result); + result = sst_vconf_del_multi_cb(iface, changedMultiCallback1); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_del_multi_cb(iface, changedMultiCallback2); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_set_bool(iface, bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); +} + +TEST_F(SstVconfTest, subscribeUnsubscribe) +{ + bool bkVal; + sst_interface *iface; + system_settings_cb_id cb[2]; + result = sst_get_interface(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, &iface); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_get_bool(iface, &bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_set_bool(iface, false); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_subscribe(iface, changedMultiCallback1, NULL, &cb[0]); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_subscribe(iface, changedMultiCallback2, NULL, &cb[1]); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = -1; + g_idle_add(checkCallbackIdle, NULL); + g_main_loop_run(loop); + EXPECT_EQ(0x11, result); + result = sst_vconf_unsubscribe(iface, cb[0]); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_unsubscribe(iface, cb[1]); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); + result = sst_vconf_set_bool(iface, bkVal); + EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, result); +} diff --git a/tests/sst_tests.h b/tests/sst_tests.h new file mode 100644 index 0000000..1b9375f --- /dev/null +++ b/tests/sst_tests.h @@ -0,0 +1,4 @@ +#define SST_TEST_CHECK_NOT_SUPPORTED(result) do { \ + if (SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED == result) \ + return; \ + } while(0) diff --git a/tests/sstt_test.c b/tests/sstt_test.c deleted file mode 100644 index 1c5f800..0000000 --- a/tests/sstt_test.c +++ /dev/null @@ -1,3208 +0,0 @@ -/* - * Copyright (c) 2017-2020 Samsung Electronics Co., Ltd All Rights Reserved - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#include -#include - -#include "sst.h" -#include "sstt.h" - -void unit_test_callback0(system_settings_key_e key, void *user_data) { } -void unit_test_callback1(system_settings_key_e key, void *user_data) { } -void unit_test_callback2(system_settings_key_e key, void *user_data) { } -void unit_test_callback3(system_settings_key_e key, void *user_data) { } -void unit_test_callback4(system_settings_key_e key, void *user_data) { } -void unit_test_callback5(system_settings_key_e key, void *user_data) { } -void unit_test_callback6(system_settings_key_e key, void *user_data) { } -void unit_test_callback7(system_settings_key_e key, void *user_data) { } -void unit_test_callback8(system_settings_key_e key, void *user_data) { } -void unit_test_callback9(system_settings_key_e key, void *user_data) { } -void unit_test_callback10(system_settings_key_e key, void *user_data) { } -void unit_test_callback11(system_settings_key_e key, void *user_data) { } -void unit_test_callback12(system_settings_key_e key, void *user_data) { } -void unit_test_callback13(system_settings_key_e key, void *user_data) { } -void unit_test_callback14(system_settings_key_e key, void *user_data) { } -void unit_test_callback15(system_settings_key_e key, void *user_data) { } -void unit_test_callback16(system_settings_key_e key, void *user_data) { } -void unit_test_callback17(system_settings_key_e key, void *user_data) { } -void unit_test_callback18(system_settings_key_e key, void *user_data) { } -void unit_test_callback19(system_settings_key_e key, void *user_data) { } -void unit_test_callback20(system_settings_key_e key, void *user_data) { } -void unit_test_callback21(system_settings_key_e key, void *user_data) { } -void unit_test_callback22(system_settings_key_e key, void *user_data) { } -void unit_test_callback23(system_settings_key_e key, void *user_data) { } -void unit_test_callback24(system_settings_key_e key, void *user_data) { } -void unit_test_callback25(system_settings_key_e key, void *user_data) { } -void unit_test_callback26(system_settings_key_e key, void *user_data) { } -void unit_test_callback27(system_settings_key_e key, void *user_data) { } -void unit_test_callback28(system_settings_key_e key, void *user_data) { } -void unit_test_callback29(system_settings_key_e key, void *user_data) { } -void unit_test_callback30(system_settings_key_e key, void *user_data) { } -void unit_test_callback31(system_settings_key_e key, void *user_data) { } -void unit_test_callback32(system_settings_key_e key, void *user_data) { } -void unit_test_callback33(system_settings_key_e key, void *user_data) { } -void unit_test_callback34(system_settings_key_e key, void *user_data) { } -void unit_test_callback35(system_settings_key_e key, void *user_data) { } -void unit_test_callback36(system_settings_key_e key, void *user_data) { } -void unit_test_callback37(system_settings_key_e key, void *user_data) { } -void unit_test_callback38(system_settings_key_e key, void *user_data) { } -void unit_test_callback39(system_settings_key_e key, void *user_data) { } -void unit_test_callback40(system_settings_key_e key, void *user_data) { } -void unit_test_callback41(system_settings_key_e key, void *user_data) { } -void unit_test_callback42(system_settings_key_e key, void *user_data) { } -void unit_test_callback43(system_settings_key_e key, void *user_data) { } -void unit_test_callback44(system_settings_key_e key, void *user_data) { } -void unit_test_callback45(system_settings_key_e key, void *user_data) { } -void unit_test_callback46(system_settings_key_e key, void *user_data) { } -void unit_test_callback47(system_settings_key_e key, void *user_data) { } -void unit_test_callback48(system_settings_key_e key, void *user_data) { } -void unit_test_callback49(system_settings_key_e key, void *user_data) { } -void unit_test_callback50(system_settings_key_e key, void *user_data) { } -void unit_test_callback51(system_settings_key_e key, void *user_data) { } -void unit_test_callback52(system_settings_key_e key, void *user_data) { } -void unit_test_callback53(system_settings_key_e key, void *user_data) { } -void unit_test_callback54(system_settings_key_e key, void *user_data) { } -void unit_test_callback55(system_settings_key_e key, void *user_data) { } -void unit_test_callback56(system_settings_key_e key, void *user_data) { } -void unit_test_callback57(system_settings_key_e key, void *user_data) { } -void unit_test_callback58(system_settings_key_e key, void *user_data) { } -void unit_test_callback59(system_settings_key_e key, void *user_data) { } - -#if 0 -static int my_assert_ret(int retcode) -{ - if (retcode != SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED) { - if (retcode != SYSTEM_SETTINGS_ERROR_NONE) - printf("Error!!\n"); - assert(retcode == SYSTEM_SETTINGS_ERROR_NONE); - } - return 1; -} - -static int my_assert_ret_eq_bool(int retcode, bool a, bool b) -{ - if (retcode != SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED) { - if (retcode != SYSTEM_SETTINGS_ERROR_NONE) - printf("Error!!\n"); - assert(retcode == SYSTEM_SETTINGS_ERROR_NONE); - assert_eq(a, b); - } - return 1; -} -#else -#define my_assert_ret(retcode) do { \ - if (retcode != SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED) { \ - if (retcode != SYSTEM_SETTINGS_ERROR_NONE) \ - printf("Error!!(%d)\n", retcode); \ - assert(retcode == SYSTEM_SETTINGS_ERROR_NONE); \ - } \ -} while (0) - -#define my_assert_ret_eq_bool(retcode, a, b) do { \ - if (retcode != SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED) { \ - if (retcode != SYSTEM_SETTINGS_ERROR_NONE) \ - printf("Error!!\n"); \ - assert(retcode == SYSTEM_SETTINGS_ERROR_NONE); \ - assert_eq(a, b); \ - } \ -} while (0) -#endif - -static char *sst_ringtone_test_files[] = { - SYS_SETTINGS_TEST_DIR"/Over the horizon.mp3", - SYS_SETTINGS_TEST_DIR"/big_buck_bunny.mp3", - SYS_SETTINGS_TEST_DIR"/daliTestVideo.mp3", - SYS_SETTINGS_TEST_DIR"/sound_5.mp3", - SYS_SETTINGS_TEST_DIR"/tct-content-tizen-tests_video.mp3" -}; - -system_settings_changed_cb get_system_settings_test_callback() -{ - static system_settings_changed_cb func_array[] = { - unit_test_callback0, - unit_test_callback1, - unit_test_callback2, - unit_test_callback3, - unit_test_callback4, - unit_test_callback5, - unit_test_callback6, - unit_test_callback7, - unit_test_callback8, - unit_test_callback9, - unit_test_callback10, - unit_test_callback11, - unit_test_callback12, - unit_test_callback13, - unit_test_callback14, - unit_test_callback15, - unit_test_callback16, - unit_test_callback17, - unit_test_callback18, - unit_test_callback19, - unit_test_callback20, - unit_test_callback21, - unit_test_callback22, - unit_test_callback23, - unit_test_callback24, - unit_test_callback25, - unit_test_callback26, - unit_test_callback27, - unit_test_callback28, - unit_test_callback29, - unit_test_callback30, - unit_test_callback31, - unit_test_callback32, - unit_test_callback33, - unit_test_callback34, - unit_test_callback35, - unit_test_callback36, - unit_test_callback37, - unit_test_callback38, - unit_test_callback39, - unit_test_callback40, - unit_test_callback41, - unit_test_callback42, - unit_test_callback43, - unit_test_callback44, - unit_test_callback45, - unit_test_callback46, - unit_test_callback47, - unit_test_callback48, - unit_test_callback49, - unit_test_callback50, - unit_test_callback51, - unit_test_callback52, - unit_test_callback53, - unit_test_callback54, - unit_test_callback55, - unit_test_callback56, - unit_test_callback57, - unit_test_callback58, - unit_test_callback59 - }; - - static int func_num = 0; - func_num++; - if (func_num > 61) - func_num = 0; - int slot = func_num % 60; - return func_array[slot]; -} - -static bool _callback_called = false; -static char *new_ringtonepath = SYS_SETTINGS_TEST_DIR "/ringtone_sdk.mp3"; - -/** - * @function utc_system_settings_startup - * @description Called before each test - * @parameter NA - * @return NA - */ -RETTYPE utc_system_settings_startup(void) -{ - RETURN(0); -} - -/** - * @function utc_system_settings_cleanup - * @description Called after each test - * @parameter NA - * @return NA - */ -RETTYPE utc_system_settings_cleanup(void) -{ - RETURN(0); -} - -/** - * TEST GETTING SYSTEM_SETTINGS_KEY_DEFAULT_FONT_TYPE - */ -/** - * @testcase utc_system_settings_get_value_string_p1 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_DEFAULT_FONT_TYPE is able to get the property - */ -RETTYPE utc_system_settings_get_value_string_p1(void) -{ - char *value = NULL; - - int retcode = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_DEFAULT_FONT_TYPE, &value); - //assert_eq(retcode, SYSTEM_SETTINGS_ERROR_NONE); - my_assert_ret(retcode); - assert(value != NULL); - free(value); - RETURN(0); -} - -/** - * TEST GETTING SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY - */ -/** - * @testcase utc_system_settings_get_value_string_p2 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY is able to get the property - */ -RETTYPE utc_system_settings_get_value_string_p2(void) -{ - char *value = NULL; - - int retcode = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, &value); - //assert_eq(retcode, SYSTEM_SETTINGS_ERROR_NONE); - my_assert_ret(retcode); - assert(value != NULL); - free(value); - RETURN(0); -} - -/** - * TEST GETTING SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE - */ -/** - * @testcase utc_system_settings_get_value_string_p3 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE is able to get the property - */ -RETTYPE utc_system_settings_get_value_string_p3(void) -{ - char *value = NULL; - - int retcode = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE, &value); - //assert_eq(retcode, SYSTEM_SETTINGS_ERROR_NONE); - my_assert_ret(retcode); - assert(value != NULL); - free(value); - RETURN(0); -} - -/** - * TEST GETTING SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE - */ -/** - * @testcase utc_system_settings_get_value_string_p4 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE is able to get the property - */ -RETTYPE utc_system_settings_get_value_string_p4(void) -{ - char *value = NULL; - - int retcode = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, &value); - //assert_eq(retcode, SYSTEM_SETTINGS_ERROR_NONE); - my_assert_ret(retcode); - assert(value != NULL); - free(value); - RETURN(0); -} - -/** - * TEST SETTING SYSTEM_SETTINGS_KEY_WALLPAPER_HOME_SCREEN - */ -/** - * @testcase utc_system_settings_get_value_string_p5 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_WALLPAPER_HOME_SCREEN is able to get the property. - */ -RETTYPE utc_system_settings_get_value_string_p5(void) -{ - char *value = NULL; - - int retcode = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_WALLPAPER_HOME_SCREEN, &value); - //assert_eq(retcode, SYSTEM_SETTINGS_ERROR_NONE); - my_assert_ret(retcode); - assert(value != NULL); - free(value); - RETURN(0); -} - -/** - * @testcase utc_system_settings_get_value_string_p11 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_DEVICE_NAME is able to get the property. - */ -RETTYPE utc_system_settings_get_value_string_p11(void) -{ - char *value = NULL; - - int retcode = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_DEVICE_NAME, &value); - //assert_eq(retcode, SYSTEM_SETTINGS_ERROR_NONE); - my_assert_ret(retcode); - assert(value != NULL); - free(value); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_get_value_string_p7 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_SOUND_NOTIFICATION is able to get the property. - */ -RETTYPE utc_system_settings_get_value_string_p7(void) -{ - char *value = NULL; - - int retcode = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_SOUND_NOTIFICATION, &value); - my_assert_ret(retcode); - free(value); - RETURN(0); -} - -/** - * @testcase utc_system_settings_get_value_string_p6 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_LOCALE_TIMEZON is able to get the property. - */ -RETTYPE utc_system_settings_get_value_string_p6(void) -{ - char *value = NULL; - int retcode = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_LOCALE_TIMEZONE, &value); - my_assert_ret(retcode); - free(value); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_get_value_string_p10 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_WALLPAPER_LOCK_SCREEN is able to get the property. - */ -RETTYPE utc_system_settings_get_value_string_p10(void) -{ - char *value = NULL; - - int retcode = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_WALLPAPER_LOCK_SCREEN, &value); - my_assert_ret(retcode); - if (retcode == SYSTEM_SETTINGS_ERROR_NONE) - assert(value != NULL); - free(value); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_get_value_string_p8 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_FONT_TYPE is able to get the property. - */ -RETTYPE utc_system_settings_get_value_string_p8(void) -{ - char *value = NULL; - - int retcode = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_FONT_TYPE, &value); - my_assert_ret(retcode); - assert(value != NULL); - free(value); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_get_value_string_p9 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_EMAIL_ALERT_RINGTONE is able to get the property. - */ -RETTYPE utc_system_settings_get_value_string_p9(void) -{ - char *value = NULL; - - int retcode = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_EMAIL_ALERT_RINGTONE, &value); - my_assert_ret(retcode); - if (retcode == SYSTEM_SETTINGS_ERROR_NONE) - assert(value != NULL); - free(value); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_get_value_string_n - * @since_tizen 2.3 - * @description check if system_settings_get_value_string is able to handle invalid parameters. - */ -RETTYPE utc_system_settings_get_value_string_n(void) -{ - int retcode = system_settings_get_value_string(-1, NULL); - //assert_neq(retcode, SYSTEM_SETTINGS_ERROR_NONE); - assert(retcode != SYSTEM_SETTINGS_ERROR_NONE); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_get_value_bool_p1 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_NETWORK_WIFI_NOTIFICATION is able to get the property. - */ -RETTYPE utc_system_settings_get_value_bool_p1(void) -{ - bool value = false; - - int retcode = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_NETWORK_WIFI_NOTIFICATION, &value); - my_assert_ret(retcode); - RETURN(0); - -} - - -/** - * @testcase utc_system_settings_get_value_bool_p2 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_3G_DATA_NETWORK_ENABLED is able to get the property. - */ -RETTYPE utc_system_settings_get_value_bool_p2(void) -{ - bool value = false; - - int retcode = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_3G_DATA_NETWORK_ENABLED, &value); - my_assert_ret(retcode); - RETURN(0); - -} - - -/** - * @testcase utc_system_settings_get_value_bool_p3 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_SOUND_LOCK is able to get the property. - */ -RETTYPE utc_system_settings_get_value_bool_p3(void) -{ - bool value = false; - - int retcode = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_SOUND_LOCK, &value); - my_assert_ret(retcode); - RETURN(0); - -} - - -/** - * @testcase utc_system_settings_get_value_bool_p4 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_DISPLAY_SCREEN_ROTATION_AUTO is able to get the property. - */ -RETTYPE utc_system_settings_get_value_bool_p4(void) -{ - bool value = false; - - int retcode = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_DISPLAY_SCREEN_ROTATION_AUTO, &value); - my_assert_ret(retcode); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_get_value_bool_p5 - * @since_tizen 2.3 - * check if SYSTEM_SETTINGS_KEY_SOUND_TOUCH is able to get the property. - */ -RETTYPE utc_system_settings_get_value_bool_p5(void) -{ - bool value = false; - - int retcode = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_SOUND_TOUCH, &value); - my_assert_ret(retcode); - RETURN(0); - -} - - -/** - * @testcase utc_system_settings_get_value_bool_p6 - * @since_tizen 2.3 - * check if SYSTEM_SETTINGS_KEY_SOUND_SILENT_MODE is able to get the property. - */ -RETTYPE utc_system_settings_get_value_bool_p6(void) -{ - bool value = false; - - int retcode = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_SOUND_SILENT_MODE, &value); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_get_value_bool_p7 - * @since_tizen 2.3 - * check if SYSTEM_SETTINGS_KEY_NETWORK_FLIGHT_MODE is able to get the property. - */ -RETTYPE utc_system_settings_get_value_bool_p7(void) -{ - bool value = false; - - int retcode = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_NETWORK_FLIGHT_MODE, &value); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_get_value_bool_p8 - * @since_tizen 2.3 - * check if SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION is able to get the property. - */ -RETTYPE utc_system_settings_get_value_bool_p8(void) -{ - bool value = false; - - int retcode = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, &value); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_get_value_bool_p9 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_MOTION_ENABLED is able to get the property. - */ -RETTYPE utc_system_settings_get_value_bool_p9(void) -{ - bool value = false; - - int retcode = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ENABLED, &value); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_get_value_bool_p10 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_USB_DEBUGGING_ENABLED is able to get the property. - */ -RETTYPE utc_system_settings_get_value_bool_p10(void) -{ - bool value = false; - - int retcode = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_USB_DEBUGGING_ENABLED, &value); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_get_value_bool_n - * @since_tizen 2.3 - * @description check if system_settings_get_value_bool is able to handle invalid parameters. - */ -RETTYPE utc_system_settings_get_value_bool_n(void) -{ - int retcode = system_settings_get_value_bool(-1, NULL); - //assert_neq(retcode, SYSTEM_SETTINGS_ERROR_NONE); - assert(retcode != SYSTEM_SETTINGS_ERROR_NONE); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_get_value_int_p1 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_SOUND_NOTIFICATION_REPETITION_PERIOD is able to get the property. - */ -RETTYPE utc_system_settings_get_value_int_p1(void) -{ - int value = 0; - - int retcode = system_settings_get_value_int(SYSTEM_SETTINGS_KEY_SOUND_NOTIFICATION_REPETITION_PERIOD, &value); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_get_value_int_p2 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_FONT_SIZE is able to get the property. - */ -RETTYPE utc_system_settings_get_value_int_p2(void) -{ - int font_size = 0; - - int retcode = system_settings_get_value_int(SYSTEM_SETTINGS_KEY_FONT_SIZE, &font_size); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_get_value_n - * @since_tizen 2.3 - * @description check if system_settings_get_value_int is able to handle invalid parameters. - */ -RETTYPE utc_system_settings_get_value_n(void) -{ - int retcode = system_settings_get_value_int(-1, NULL); - //assert_neq(retcode, SYSTEM_SETTINGS_ERROR_NONE); - assert(retcode != SYSTEM_SETTINGS_ERROR_NONE); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_get_value_int_p3 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME is able to get the property. - */ -RETTYPE utc_system_settings_get_value_int_p3(void) -{ - int value; - int nRetVal = system_settings_get_value_int(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, &value); - my_assert_ret(nRetVal); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_get_value_bool_p11 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR is able to get the property - */ -RETTYPE utc_system_settings_get_value_bool_p11(void) -{ - bool value = false; - - int retcode = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR, &value); - my_assert_ret(retcode); - - RETURN(0); -} - -/** - * @testcase utc_system_settings_get_value_bool_p12 - * @since_tizen 5.5 - * @description check if SYSTEM_SETTINGS_KEY_ACCESSIBILITY_GRAYSCALE is able to get the property - */ -RETTYPE utc_system_settings_get_value_bool_p12(void) -{ - bool value = false; - - int retcode = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_ACCESSIBILITY_GRAYSCALE, &value); - my_assert_ret(retcode); - - RETURN(0); -} - -/** - * @testcase utc_system_settings_get_value_bool_p13 - * @since_tizen 5.5 - * @description check if SYSTEM_SETTINGS_KEY_ACCESSIBILITY_NEGATIVE_COLOR is able to get the property - */ -RETTYPE utc_system_settings_get_value_bool_p13(void) -{ - bool value = false; - - int retcode = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_ACCESSIBILITY_NEGATIVE_COLOR, &value); - my_assert_ret(retcode); - - RETURN(0); -} - -/** - * @testcase utc_system_settings_get_value_bool_p14 - * @since_tizen 5.5 - * @description check if SYSTEM_SETTINGS_KEY_ROTARY_EVENT_ENABLED is able to get the property - */ -RETTYPE utc_system_settings_get_value_bool_p14(void) -{ - bool value = false; - - int retcode = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_ROTARY_EVENT_ENABLED, &value); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_changed_cb_p1 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_SOUND_NOTIFICATION is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p1(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, - callback, NULL); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p1 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p1(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_changed_cb_p2 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p2(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, - callback, NULL); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p2 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p2(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_changed_cb_p3 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_WALLPAPER_HOME_SCREEN is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p3(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_WALLPAPER_HOME_SCREEN, - callback, NULL); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p3 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_WALLPAPER_HOME_SCREEN is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_WALLPAPER_HOME_SCREEN is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p3(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_WALLPAPER_HOME_SCREEN, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_WALLPAPER_HOME_SCREEN); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_changed_cb_p4 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_WALLPAPER_LOCK_SCREEN is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p4(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_WALLPAPER_LOCK_SCREEN, - callback, NULL); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_LOCK_SCREEN_unset_changed_cb_p - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_WALLPAPER is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_WALLPAPER is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_LOCK_SCREEN_unset_changed_cb_p(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_WALLPAPER_LOCK_SCREEN, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_WALLPAPER_LOCK_SCREEN); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_changed_cb_p5 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_FONT_SIZE is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p5(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_FONT_SIZE, - callback, NULL); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p4 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_FONT_SIZE is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_FONT_SIZE is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p4(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_FONT_SIZE, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_FONT_SIZE); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_changed_cb_p6 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_FONT_TYPE is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p6(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_FONT_TYPE, - callback, NULL); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p5 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_FONT_TYPE is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_FONT_TYPE is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p5(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_FONT_TYPE, - callback, NULL); - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_FONT_TYPE); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_changed_cb_p7 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_EMAIL_ALERT_RINGTONE is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p7(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_EMAIL_ALERT_RINGTONE, - callback, NULL); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p6 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_EMAIL_ALERT_RINGTONE is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_EMAIL_ALERT_RINGTONE is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p6(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_EMAIL_ALERT_RINGTONE, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_EMAIL_ALERT_RINGTONE); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_changed_cb_p8 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_USB_DEBUGGING_ENABLED is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p8(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_USB_DEBUGGING_ENABLED, - callback, NULL); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p7 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_USB_DEBUGGING_ENABLED is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_USB_DEBUGGING_ENABLED is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p7(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_USB_DEBUGGING_ENABLED, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_USB_DEBUGGING_ENABLED); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_changed_cb_p9 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_3G_DATA_NETWORK_ENABLED is able to set callback for getting notification of change - */ -RETTYPE utc_system_settings_set_changed_cb_p9(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_3G_DATA_NETWORK_ENABLED, - callback, NULL); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p8 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_3G_DATA_NETWORK_ENABLED is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_3G_DATA_NETWORK_ENABLED is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p8(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_3G_DATA_NETWORK_ENABLED, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_3G_DATA_NETWORK_ENABLED); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_changed_cb_p10 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_LOCKSCREEN_APP is able to set callback for getting notification of change - */ -RETTYPE utc_system_settings_set_changed_cb_p10(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_LOCKSCREEN_APP, - callback, NULL); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p9 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_LOCKSCREEN_APP is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_LOCKSCREEN_APP is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p9(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_LOCKSCREEN_APP, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_LOCKSCREEN_APP); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_changed_cb_p11 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY is able to set callback for getting notification of change - */ -RETTYPE utc_system_settings_set_changed_cb_p11(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, - callback, NULL); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p10 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY is able to set callback for getting notification of change and unset doing - */ -RETTYPE utc_system_settings_unset_changed_cb_p10(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_changed_cb_p12 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p12(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE, - callback, NULL); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p11 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p11(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_changed_cb_p13 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p13(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR, - callback, NULL); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR - */ -/** - * @testcase utc_system_settings_unset_changed_cb_p12 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p12(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_changed_cb_p14 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_TIME_CHANGED is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p14(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_TIME_CHANGED, - callback, NULL); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p13 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_TIME_CHANGED is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_TIME_CHANGED is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p13(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_TIME_CHANGED, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_TIME_CHANGED); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_changed_cb_p15 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_SOUND_LOCK is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p15(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_SOUND_LOCK, - callback, NULL); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p14 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_SOUND_LOCK is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_SOUND_LOCK is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p14(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_SOUND_LOCK, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_SOUND_LOCK); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_changed_cb_p16 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_SOUND_SILENT_MODE is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p16(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_SOUND_SILENT_MODE, - callback, NULL); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p15 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_SOUND_SILENT_MODE is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_SOUND_SILENT_MODE is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p15(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_SOUND_SILENT_MODE, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_SOUND_SILENT_MODE); - my_assert_ret(retcode); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_changed_cb_p17 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_SOUND_TOUCH is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p17(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_SOUND_TOUCH, - callback, NULL); - my_assert_ret(retcode); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p16 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_SOUND_TOUCH is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_SOUND_TOUCH is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p16(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_SOUND_TOUCH, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_SOUND_TOUCH); - my_assert_ret(retcode); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_changed_cb_p18 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_DISPLAY_SCREEN_ROTATION_AUTO is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p18(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_DISPLAY_SCREEN_ROTATION_AUTO, - callback, NULL); - my_assert_ret(retcode); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p17 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_DISPLAY_SCREEN_ROTATION_AUTO is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_DISPLAY_SCREEN_ROTATION_AUTO is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p17(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_DISPLAY_SCREEN_ROTATION_AUTO, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_DISPLAY_SCREEN_ROTATION_AUTO); - my_assert_ret(retcode); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_changed_cb_p19 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p19(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, - callback, NULL); - my_assert_ret(retcode); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p18 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p18(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME); - my_assert_ret(retcode); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_changed_cb_p20 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_SOUND_NOTIFICATION is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p20(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_SOUND_NOTIFICATION, - callback, NULL); - my_assert_ret(retcode); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p19 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_SOUND_NOTIFICATION is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_SOUND_NOTIFICATION is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p19(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_SOUND_NOTIFICATION, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_SOUND_NOTIFICATION); - my_assert_ret(retcode); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_changed_cb_p21 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_SOUND_NOTIFICATION_REPETITION_PERIOD is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p21(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_SOUND_NOTIFICATION_REPETITION_PERIOD, - callback, NULL); - my_assert_ret(retcode); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p20 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_SOUND_NOTIFICATION_REPETITION_PERIOD is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_SOUND_NOTIFICATION_REPETITION_PERIOD is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p20(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_SOUND_NOTIFICATION_REPETITION_PERIOD, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_SOUND_NOTIFICATION_REPETITION_PERIOD); - my_assert_ret(retcode); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_changed_cb_p22 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_DEVICE_NAME is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p22(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_DEVICE_NAME, - callback, NULL); - my_assert_ret(retcode); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p21 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_DEVICE_NAME is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_DEVICE_NAME is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p21(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_DEVICE_NAME, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_DEVICE_NAME); - my_assert_ret(retcode); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_changed_cb_p23 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_MOTION_ENABLED is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p23(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_MOTION_ENABLED, - callback, NULL); - my_assert_ret(retcode); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p22 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_MOTION_ENABLED is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_MOTION_ENABLED is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p22(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_MOTION_ENABLED, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_MOTION_ENABLED); - my_assert_ret(retcode); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_changed_cb_p24 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_NETWORK_FLIGHT_MODE is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p24(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_NETWORK_FLIGHT_MODE, - callback, NULL); - my_assert_ret(retcode); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p23 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_NETWORK_FLIGHT_MODE is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_NETWORK_FLIGHT_MODE is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p23(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_NETWORK_FLIGHT_MODE, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_NETWORK_FLIGHT_MODE); - my_assert_ret(retcode); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_changed_cb_p25 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_NETWORK_WIFI_NOTIFICATION is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p25(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_NETWORK_WIFI_NOTIFICATION, - callback, NULL); - my_assert_ret(retcode); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p24 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_NETWORK_WIFI_NOTIFICATION is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_NETWORK_WIFI_NOTIFICATION is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p24(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_NETWORK_WIFI_NOTIFICATION, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_NETWORK_WIFI_NOTIFICATION); - my_assert_ret(retcode); - RETURN(0); -} - - - -/** - * @testcase utc_system_settings_set_value_string_p1 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE is able to get the property - */ -RETTYPE utc_system_settings_set_value_string_p1(void) -{ - int ret; - ret = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, new_ringtonepath); - my_assert_ret(ret); - - char *ret_ringtonepath = NULL; - ret = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, &ret_ringtonepath); - my_assert_ret(ret); - - if (ret == SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED) - RETURN(0); - - if (ret_ringtonepath != NULL && 0 == strcmp(ret_ringtonepath, new_ringtonepath)) - assert(1); - else - assert(0); - - RETURN(0); -} - - -/** - * TEST SETTING SYSTEM_SETTINGS_KEY_WALLPAPER_HOME_SCREEN - */ -/** - * @testcase utc_system_settings_set_value_string_n2 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_WALLPAPER_HOME_SCREEN is able to get the property. - * check if SYSTEM_SETTINGS_KEY_WALLPAPER_HOME_SCREEN is able to set the property in error-case. - */ -RETTYPE utc_system_settings_set_value_string_n2(void) -{ - int ret; - char *wallpaper = NULL; - - char *wrong_wallpaper_path = "/wrongpath/aaa.png"; - ret = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_WALLPAPER_HOME_SCREEN, wrong_wallpaper_path); - assert(ret != SYSTEM_SETTINGS_ERROR_NONE); - - ret = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_WALLPAPER_HOME_SCREEN, &wallpaper); - assert(ret == SYSTEM_SETTINGS_ERROR_NONE); - free(wallpaper); - RETURN(0); -} - -/** - * SYSTEM_SETTINGS_KEY_WALLPAPER_LOCK_SCREEN - */ -/** - * @testcase utc_system_settings_set_value_string_n3 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_WALLPAPER_LOCK_SCREEN is able to get the property. - * check if SYSTEM_SETTINGS_KEY_WALLPAPER_LOCK_SCREEN is able to set the property in error-case. - */ -RETTYPE utc_system_settings_set_value_string_n3(void) -{ - int ret; - char *wallpaper = NULL; - - char *wrong_wallpaper_path = "/wrongpath/aaa.png"; - ret = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_WALLPAPER_LOCK_SCREEN, wrong_wallpaper_path); - assert(ret != SYSTEM_SETTINGS_ERROR_NONE); - - ret = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_WALLPAPER_LOCK_SCREEN, &wallpaper); - //assert_eq(ret, SYSTEM_SETTINGS_ERROR_NONE); - free(wallpaper); - RETURN(0); -} - -/** - * SYSTEM_SETTINGS_KEY_FONT_TYPE - */ -/** - * @testcase utc_system_settings_set_value_string_n4 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_FONT_TYPE is able to get the property. - * check if SYSTEM_SETTINGS_KEY_FONT_TYPE is able to set the property in error-case. - */ -RETTYPE utc_system_settings_set_value_string_n4(void) -{ - int ret; - - char *wrong_font_name = "WrongFontName"; - ret = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_FONT_TYPE, wrong_font_name); - assert(ret != SYSTEM_SETTINGS_ERROR_NONE); - - char *font_name_set = "BreezeSans"; - ret = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_FONT_TYPE, font_name_set); - assert_eq(ret, SYSTEM_SETTINGS_ERROR_NONE); - - char *font_name = NULL; - ret = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_FONT_TYPE, &font_name); - assert_eq(ret, SYSTEM_SETTINGS_ERROR_NONE); - free(font_name); - RETURN(0); -} - - - -/** - * @testcase utc_system_settings_set_value_bool_n1 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_NETWORK_WIFI_NOTIFICATION is able to get the property. - * check if SYSTEM_SETTINGS_KEY_NETWORK_WIFI_NOTIFICATION is able to set the property in a normal-case. - */ -RETTYPE utc_system_settings_set_value_bool_n1(void) -{ - int ret; - /* get current state */ - bool cur_state = false; - ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_NETWORK_WIFI_NOTIFICATION, &cur_state); - my_assert_ret(ret); - - /* not support to set value */ - bool state = !cur_state; - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_NETWORK_WIFI_NOTIFICATION, state); - my_assert_ret(ret); - - - assert(state != cur_state); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_value_bool_n2 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_NETWORK_FLIGHT_MODE is able to get the property. - * check if SYSTEM_SETTINGS_KEY_NETWORK_FLIGHT_MODE is able to set the property in an exceptional-case. (not supported) - */ -RETTYPE utc_system_settings_set_value_bool_n2(void) -{ - int ret; - /* get current state */ - bool cur_state = false; - ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_NETWORK_FLIGHT_MODE, &cur_state); - my_assert_ret(ret); - - - /* not support to set value */ - bool state = !cur_state; - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_NETWORK_FLIGHT_MODE, state); - my_assert_ret(ret); - - assert(state != cur_state); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_value_bool_n3 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_MOTION_ENABLED is able to get the property. - * check if SYSTEM_SETTINGS_KEY_MOTION_ENABLED is able to set the property in an exceptional-case. (not supported) - */ -RETTYPE utc_system_settings_set_value_bool_n3(void) -{ - int ret; - /* get current state */ - bool cur_state = false; - ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ENABLED, &cur_state); - my_assert_ret(ret); - - - /* not support to set value */ - bool state = !cur_state; - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ENABLED, state); - my_assert_ret(ret); - - assert(state != cur_state); - RETURN(0); -} - -/** - * @testcase utc_system_settings_set_value_bool_n4 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_SOUND_TOUCH is able to get the property. - * check if SYSTEM_SETTINGS_KEY_SOUND_TOUCH is able to set the property in an exceptional-case. (not supported) - */ -RETTYPE utc_system_settings_set_value_bool_n4(void) -{ - int ret; - /* get current state */ - bool cur_state = false; - ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_SOUND_TOUCH, &cur_state); - my_assert_ret(ret); - - /* not support to set value */ - bool state = !cur_state; - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_SOUND_TOUCH, state); - my_assert_ret(ret); - - assert(state != cur_state); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_value_bool_n5 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_SOUND_LOCK is able to get the property. - * check if SYSTEM_SETTINGS_KEY_SOUND_LOCK is able to set the property in an exceptional-case. (not supported) - */ -RETTYPE utc_system_settings_set_value_bool_n5(void) -{ - int ret; - /* get current state */ - bool cur_state = false; - ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_SOUND_LOCK, &cur_state); - my_assert_ret(ret); - - - /* not support to set value */ - bool state = !cur_state; - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_SOUND_LOCK, state); - my_assert_ret(ret); - - assert(state != cur_state); - RETURN(0); -} - -/** - * @testcase utc_system_settings_set_value_string_n8 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_DEFAULT_FONT_TYPE is able to get the property. - * check if SYSTEM_SETTINGS_KEY_DEFAULT_FONT_TYPE is able to set the property in an exceptional-case. (not supported) - */ -RETTYPE utc_system_settings_set_value_string_n8(void) -{ - int ret; - char *new_font = "DefaultFontName"; - ret = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_DEFAULT_FONT_TYPE, new_font); - //my_assert_ret(ret); - assert_neq(ret, SYSTEM_SETTINGS_ERROR_NONE); - - char *ret_font = NULL; - ret = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_DEFAULT_FONT_TYPE, &ret_font); - assert_eq(ret, SYSTEM_SETTINGS_ERROR_NONE); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_value_string_n7 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_LOCALE_TIMEZONE is able to get the property. - * check if SYSTEM_SETTINGS_KEY_LOCALE_TIMEZONE is able to set the property in an exceptional-case. (not supported) - */ -RETTYPE utc_system_settings_set_value_string_n7(void) -{ - int ret; - char *new_zone = "Asia/Seoul"; - ret = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_LOCALE_TIMEZONE, new_zone); - my_assert_ret(ret); - - char *ret_device = NULL; - ret = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_LOCALE_TIMEZONE, &ret_device); - my_assert_ret(ret); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_value_int_n1 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_TIME_CHANGED is able to get the property. - * check if SYSTEM_SETTINGS_KEY_TIME_CHANGED is able to set the property in an exceptional-case. (not supported) - */ -RETTYPE utc_system_settings_set_value_int_n1(void) -{ - int ret; - int value = 3600; - ret = system_settings_set_value_int(SYSTEM_SETTINGS_KEY_TIME_CHANGED, value); - my_assert_ret(ret); - - int time_changed; - ret = system_settings_get_value_int(SYSTEM_SETTINGS_KEY_TIME_CHANGED, &time_changed); - my_assert_ret(ret); - - RETURN(0); -} - - -/** - * SYSTEM_SETTINGS_KEY_DEVICE_NAME - * check_SYSTEM_SETTINGS_ERROR_CALL_UNSUPPORTED_API - */ -/** - * @testcase utc_system_settings_set_value_string_n5 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_DEVICE_NAME is able to get the property. - * check if SYSTEM_SETTINGS_KEY_DEVICE_NAME is able to set the property in an exceptional-case. (not supported) - */ -RETTYPE utc_system_settings_set_value_string_n5(void) -{ - int ret; - char *new_device = "Tizen222"; - ret = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_DEVICE_NAME, new_device); - my_assert_ret(ret); - - char *ret_device = NULL; - ret = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_DEVICE_NAME, &ret_device); - - if (ret_device != NULL && 0 == strcmp(ret_device, new_device)) - assert(0); - else - assert(1); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_value_string_p2 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_EMAIL_ALERT_RINGTONE is able to get the property. - * check if SYSTEM_SETTINGS_KEY_EMAIL_ALERT_RINGTONE is able to set the property in a normal-case. - */ -RETTYPE utc_system_settings_set_value_string_p2(void) -{ - int ret; - ret = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_EMAIL_ALERT_RINGTONE, new_ringtonepath); - my_assert_ret(ret); - - char *ret_ringtonepath = NULL; - ret = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_EMAIL_ALERT_RINGTONE, &ret_ringtonepath); - - if (ret == SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED) - RETURN(0); - - if (ret_ringtonepath != NULL && 0 == strcmp(ret_ringtonepath, new_ringtonepath)) - assert(1); - else - assert(0); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_value_string_p3 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY is able to get the property. - * check if SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY is able to set the property in a normal-case. - */ -RETTYPE utc_system_settings_set_value_string_p3(void) -{ - int ret; - char *new_country = "ko_KR"; - - /* backup */ - char *backup = NULL; - ret = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, &backup); - my_assert_ret(ret); - - ret = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, new_country); - my_assert_ret(ret); - - char *ret_country = NULL; - ret = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, &ret_country); - my_assert_ret(ret); - - if (ret_country != NULL && 0 == strcmp(ret_country, new_country)) - assert(1); - else - assert(0); - - ret = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, backup); - my_assert_ret(ret); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_value_string_p4 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE is able to get the property. - * check if SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE is able to set the property in a normal-case. - */ -RETTYPE utc_system_settings_set_value_string_p4(void) -{ - int ret; - char *new_country = "ko_KR"; - - /* backup */ - char *backup = NULL; - ret = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE, &backup); - my_assert_ret(ret); - - ret = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE, new_country); - my_assert_ret(ret); - - char *ret_country = NULL; - ret = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE, &ret_country); - my_assert_ret(ret); - - if (ret_country != NULL && 0 == strcmp(ret_country, new_country)) { - assert(1); - } else { - printf("ret:%s new:%s not same\n", ret_country, new_country); - assert(0); - } - - ret = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE, backup); - my_assert_ret(ret); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_value_bool_p1 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_DISPLAY_SCREEN_ROTATION_AUTO is able to set the property. - * check if SYSTEM_SETTINGS_KEY_DISPLAY_SCREEN_ROTATION_AUTO is able to get the property. - */ -RETTYPE utc_system_settings_set_value_bool_p1(void) -{ - int ret; - - bool ret_state = false; - bool cur_state = false; - ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_DISPLAY_SCREEN_ROTATION_AUTO, &cur_state); - my_assert_ret(ret); - - bool state = !cur_state; - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_DISPLAY_SCREEN_ROTATION_AUTO, state); - my_assert_ret(ret); - - /* check current state */ - ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_DISPLAY_SCREEN_ROTATION_AUTO, &ret_state); - my_assert_ret_eq_bool(ret, state, ret_state); - - /* roll back */ - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_DISPLAY_SCREEN_ROTATION_AUTO, cur_state); - my_assert_ret(ret); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_value_bool_p2 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_SOUND_SILENT_MODE is able to set the property. - * check if SYSTEM_SETTINGS_KEY_SOUND_SILENT_MODE is able to get the property. - */ -RETTYPE utc_system_settings_set_value_bool_p2(void) -{ - int ret; - - bool ret_state = false; - bool cur_state = false; - ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_SOUND_SILENT_MODE, &cur_state); - my_assert_ret(ret); - - bool state = !cur_state; - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_SOUND_SILENT_MODE, state); - my_assert_ret(ret); - - /* check current state */ - ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_SOUND_SILENT_MODE, &ret_state); - my_assert_ret_eq_bool(ret, state, ret_state); - - /* roll back */ - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_SOUND_SILENT_MODE, cur_state); - my_assert_ret(ret); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_changed_cb_n - * @since_tizen 2.3 - * @description check if system_settings_set_changed_cb is able to handle invalid parameters. - */ -RETTYPE utc_system_settings_set_changed_cb_n(void) -{ - int retcode = system_settings_set_changed_cb(-1, NULL, NULL); - assert(retcode != SYSTEM_SETTINGS_ERROR_NONE); - RETURN(0); -} - - - -/** - * @testcase utc_system_settings_get_value_int_p4 - * @since_tizen 3.0 - * @description check if SYSTEM_SETTINGS_KEY_ULTRA_DATA_SAVE is able to get the property. - */ -RETTYPE utc_system_settings_get_value_int_p4(void) -{ - int value = 0; - int nRetVal = system_settings_get_value_int(SYSTEM_SETTINGS_KEY_ULTRA_DATA_SAVE, &value); - my_assert_ret(nRetVal); - RETURN(0); -} - - - -/** - * @testcase utc_system_settings_set_value_int_p1 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME is able to get the property. - */ -RETTYPE utc_system_settings_set_value_int_p1(void) -{ - int nRetVal = system_settings_set_value_int(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, 30); - my_assert_ret(nRetVal); - - int value; - nRetVal = system_settings_get_value_int(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, &value); - //assert_eq(value, 30); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_value_int_n2 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME is able to set the properties with exceptional cases. - */ -RETTYPE utc_system_settings_set_value_int_n2(void) -{ - int ret = system_settings_set_value_int(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, -5); - assert(ret == SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER); - - ret = system_settings_set_value_int(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, 601); - assert(ret == SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER); - - ret = system_settings_set_value_int(SYSTEM_SETTINGS_KEY_SCREEN_BACKLIGHT_TIME, 0); - assert(ret == SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER); - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_value_bool_p3 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR is able to set the property. - * check if SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR is able to get the property. - */ -RETTYPE utc_system_settings_set_value_bool_p3(void) -{ - int ret; - - bool ret_state = false; - bool cur_state = false; - ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR, &cur_state); - my_assert_ret(ret); - - bool state = !cur_state; - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR, state); - my_assert_ret(ret); - - /* check current state */ - ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR, &ret_state); - my_assert_ret_eq_bool(ret, state, ret_state); - - /* roll back */ - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR, cur_state); - my_assert_ret(ret); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_value_bool_p4 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_3G_DATA_NETWORK_ENABLED is able to set the property. - * check if SYSTEM_SETTINGS_KEY_3G_DATA_NETWORK_ENABLED is able to get the property. - */ -RETTYPE utc_system_settings_set_value_bool_p4(void) -{ - int ret; - - /* get current state */ - bool cur_state = false; - bool ret_state = false; - ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_3G_DATA_NETWORK_ENABLED, &cur_state); - my_assert_ret(ret); - - bool state = !cur_state; - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_3G_DATA_NETWORK_ENABLED, state); - my_assert_ret(ret); - - /* check current state */ - ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_3G_DATA_NETWORK_ENABLED, &ret_state); - my_assert_ret_eq_bool(ret, state, ret_state); - - /* roll back */ - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_3G_DATA_NETWORK_ENABLED, cur_state); - my_assert_ret(ret); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_value_bool_p5 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION is able to set the property. - * check if SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION is able to get the property. - */ -RETTYPE utc_system_settings_set_value_bool_p5(void) -{ - int ret; - - /* get current state */ - bool cur_state = false; - bool ret_state = false; - ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, &cur_state); - my_assert_ret(ret); - - bool state = !cur_state; - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, state); - my_assert_ret(ret); - - /* check current state */ - ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, &ret_state); - my_assert_ret_eq_bool(ret, state, ret_state); - - /* roll back */ - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, cur_state); - my_assert_ret(ret); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_value_bool_p6 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_VIBRATION is able to set the property. - * check if SYSTEM_SETTINGS_KEY_VIBRATION is able to get the property. - */ -RETTYPE utc_system_settings_set_value_bool_p6(void) -{ - int ret; - - /* get current state */ - bool cur_state = false; - bool ret_state = false; - ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_VIBRATION, &cur_state); - my_assert_ret(ret); - - bool state = !cur_state; - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_VIBRATION, state); - my_assert_ret(ret); - - /* check current state */ - ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_VIBRATION, &ret_state); - my_assert_ret_eq_bool(ret, state, ret_state); - - /* roll back */ - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_VIBRATION, cur_state); - my_assert_ret(ret); - - RETURN(0); -} - -/** - * @testcase utc_system_settings_set_value_bool_p7 - * @since_tizen 5.0 - * @description check if SYSTEM_SETTINGS_KEY_AUTOMATIC_TIME_UPDATE is able to set the property. - * check if SYSTEM_SETTINGS_KEY_AUTOMATIC_TIME_UPDATE is able to get the property. - */ -RETTYPE utc_system_settings_set_value_bool_p7(void) -{ - int ret; - - /* get current state */ - bool cur_state = false; - bool ret_state = false; - ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_AUTOMATIC_TIME_UPDATE, &cur_state); - my_assert_ret(ret); - - bool state = !cur_state; - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_AUTOMATIC_TIME_UPDATE, state); - my_assert_ret(ret); - - /* check current state */ - ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_AUTOMATIC_TIME_UPDATE, &ret_state); - my_assert_ret_eq_bool(ret, state, ret_state); - - /* roll back */ - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_AUTOMATIC_TIME_UPDATE, cur_state); - my_assert_ret(ret); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_value_bool_p8 - * @since_tizen 5.0 - * @description check if SYSTEM_SETTINGS_KEY_AUTOMATIC_TIME_UPDATE is able to set the property. - * check if SYSTEM_SETTINGS_KEY_AUTOMATIC_TIME_UPDATE is able to get the property. - */ -RETTYPE utc_system_settings_set_value_bool_p8(void) -{ - int ret; - - /* get current state */ - bool cur_state = false; - bool ret_state = false; - ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_DEVELOPER_OPTION_STATE, &cur_state); - my_assert_ret(ret); - - bool state = !cur_state; - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_DEVELOPER_OPTION_STATE, state); - my_assert_ret(ret); - - /* check current state */ - ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_DEVELOPER_OPTION_STATE, &ret_state); - my_assert_ret_eq_bool(ret, state, ret_state); - - /* roll back */ - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_DEVELOPER_OPTION_STATE, cur_state); - my_assert_ret(ret); - - RETURN(0); -} - -/** - * @testcase utc_system_settings_set_value_bool_p9 - * @since_tizen 5.5 - * @description check if SYSTEM_SETTINGS_KEY_ACCESSIBILITY_GRAYSCALE is able to set the property. - * check if SYSTEM_SETTINGS_KEY_ACCESSIBILITY_GRAYSCALE is able to get the property. - */ -RETTYPE utc_system_settings_set_value_bool_p9(void) -{ - int ret; - - /* get current state */ - bool cur_state = false; - bool ret_state = false; - ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_ACCESSIBILITY_GRAYSCALE, &cur_state); - my_assert_ret(ret); - - bool state = !cur_state; - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_ACCESSIBILITY_GRAYSCALE, state); - my_assert_ret(ret); - - /* check current state */ - ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_ACCESSIBILITY_GRAYSCALE, &ret_state); - my_assert_ret_eq_bool(ret, state, ret_state); - - /* roll back */ - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_ACCESSIBILITY_GRAYSCALE, cur_state); - my_assert_ret(ret); - - RETURN(0); -} - -/** - * @testcase utc_system_settings_set_value_bool_p10 - * @since_tizen 5.5 - * @description check if SYSTEM_SETTINGS_KEY_ACCESSIBILITY_NEGATIVE_COLOR is able to set the property. - * check if SYSTEM_SETTINGS_KEY_ACCESSIBILITY_NEGATIVE_COLOR is able to get the property. - */ -RETTYPE utc_system_settings_set_value_bool_p10(void) -{ - int ret; - - /* get current state */ - bool cur_state = false; - bool ret_state = false; - ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_ACCESSIBILITY_NEGATIVE_COLOR, &cur_state); - my_assert_ret(ret); - - bool state = !cur_state; - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_ACCESSIBILITY_NEGATIVE_COLOR, state); - my_assert_ret(ret); - - /* check current state */ - ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_ACCESSIBILITY_NEGATIVE_COLOR, &ret_state); - my_assert_ret_eq_bool(ret, state, ret_state); - - /* roll back */ - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_ACCESSIBILITY_NEGATIVE_COLOR, cur_state); - my_assert_ret(ret); - - RETURN(0); -} - -/** - * @testcase utc_system_settings_set_value_bool_p11 - * @since_tizen 5.5 - * @description check if SYSTEM_SETTINGS_KEY_ACCESSIBILITY_TTS is able to get the property. - * check if SYSTEM_SETTINGS_KEY_ACCESSIBILITY_TTS is able to set the property. - */ -RETTYPE utc_system_settings_set_value_bool_p11(void) -{ - int ret; - /* get current state */ - bool cur_state = false; - bool ret_state = false; - ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_ACCESSIBILITY_TTS, &cur_state); - my_assert_ret(ret); - - - bool state = !cur_state; - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_ACCESSIBILITY_TTS, state); - my_assert_ret(ret); - - /* check current state */ - ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_ACCESSIBILITY_TTS, &ret_state); - my_assert_ret_eq_bool(ret, state, ret_state); - - /* roll back */ - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_ACCESSIBILITY_TTS, cur_state); - my_assert_ret(ret); - - RETURN(0); -} - -/** - * @testcase utc_system_settings_set_value_bool_p12 - * @since_tizen 5.5 - * @description check if SYSTEM_SETTINGS_KEY_ROTARY_EVENT_ENABLED is able to set the property. - * check if SYSTEM_SETTINGS_KEY_ROTARY_EVENT_ENABLED is able to get the property. - */ -RETTYPE utc_system_settings_set_value_bool_p12(void) -{ - int ret; - - /* get current state */ - bool cur_state = false; - bool ret_state = false; - ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_ROTARY_EVENT_ENABLED, &cur_state); - my_assert_ret(ret); - - bool state = !cur_state; - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_ROTARY_EVENT_ENABLED, state); - my_assert_ret(ret); - - /* check current state */ - ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_ROTARY_EVENT_ENABLED, &ret_state); - my_assert_ret_eq_bool(ret, state, ret_state); - - /* roll back */ - ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_ROTARY_EVENT_ENABLED, cur_state); - my_assert_ret(ret); - - RETURN(0); -} - -/** - * @testcase utc_system_settings_set_value_int_p2 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_FONT_SIZE is able to set the property. - * check if SYSTEM_SETTINGS_KEY_FONT_SIZE is able to get the property. - */ -RETTYPE utc_system_settings_set_value_int_p2(void) -{ - int ret = -1; - int backup; - int arr[] = { - SYSTEM_SETTINGS_FONT_SIZE_SMALL, - SYSTEM_SETTINGS_FONT_SIZE_NORMAL, - SYSTEM_SETTINGS_FONT_SIZE_LARGE, - SYSTEM_SETTINGS_FONT_SIZE_HUGE, - SYSTEM_SETTINGS_FONT_SIZE_GIANT - }; - - unsigned int next_val = time(NULL); - int size = sizeof(arr) / sizeof(arr[0]); - int sel = rand_r(&next_val) % size; - - /* backup */ - ret = system_settings_get_value_int(SYSTEM_SETTINGS_KEY_FONT_SIZE, &backup); - my_assert_ret(ret); - - /* change font at random */ - ret = system_settings_set_value_int(SYSTEM_SETTINGS_KEY_FONT_SIZE, sel); - my_assert_ret(ret); - - /* check if selection and result are identical. */ - int after; - ret = system_settings_get_value_int(SYSTEM_SETTINGS_KEY_FONT_SIZE, &after); - //assert_eq(sel, after); - - /* roll back to backup */ - ret = system_settings_set_value_int(SYSTEM_SETTINGS_KEY_FONT_SIZE, backup); - my_assert_ret(ret); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_value_string_n6 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_SOUND_NOTIFICATION is able to set the property. - * check if SYSTEM_SETTINGS_KEY_SOUND_NOTIFICATION is able to get the property. - */ -RETTYPE utc_system_settings_set_value_string_n6(void) -{ - int ret; - ret = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_SOUND_NOTIFICATION, new_ringtonepath); - my_assert_ret(ret); - //assert_eq(ret, SYSTEM_SETTINGS_ERROR_NONE); - - char *ret_ringtonepath = NULL; - ret = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_SOUND_NOTIFICATION, &ret_ringtonepath); - - if (ret_ringtonepath != NULL && 0 == strcmp(ret_ringtonepath, new_ringtonepath)) - my_assert_ret(0); - else - my_assert_ret(1); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_n - * @since_tizen 2.3 - * @description check if system_settings_unset_changed_cb is able to handle invalid parameters. - */ -RETTYPE utc_system_settings_unset_changed_cb_n(void) -{ - int retcode = system_settings_unset_changed_cb(-1); - assert(retcode != SYSTEM_SETTINGS_ERROR_NONE); - RETURN(0); -} - - - -/** - * @testcase utc_system_settings_set_changed_cb_p27 - * @since_tizen 3.0 - * @description check if SYSTEM_SETTINGS_KEY_ULTRA_DATA_SAVE is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p27(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_ULTRA_DATA_SAVE, - callback, NULL); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p26 - * @since_tizen 3.0 - * @description check if SYSTEM_SETTINGS_KEY_ULTRA_DATA_SAVE is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_ULTRA_DATA_SAVE is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p26(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_ULTRA_DATA_SAVE, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_ULTRA_DATA_SAVE); - my_assert_ret(retcode); - - RETURN(0); -} - -/** - * @testcase utc_system_settings_set_changed_cb_p29 - * @since_tizen 3.0 - * @description check if SYSTEM_SETTINGS_KEY_ULTRA_DATA_SAVE_PKG_LIST is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p29(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_ULTRA_DATA_SAVE_PKG_LIST, - callback, NULL); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p28 - * @since_tizen 3.0 - * @description check if SYSTEM_SETTINGS_KEY_ULTRA_DATA_SAVE_PKG_LIST is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_ULTRA_DATA_SAVE_PKG_LIST is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p28(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_ULTRA_DATA_SAVE_PKG_LIST, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_ULTRA_DATA_SAVE_PKG_LIST); - my_assert_ret(retcode); - - RETURN(0); -} - -/** - * @testcase utc_system_settings_set_changed_cb_p31 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_ACCESSIBILITY_TTS is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p31(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_ACCESSIBILITY_TTS, - callback, NULL); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p30 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_ACCESSIBILITY_TTS is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_ACCESSIBILITY_TTS is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p30(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_ACCESSIBILITY_TTS, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_ACCESSIBILITY_TTS); - my_assert_ret(retcode); - - RETURN(0); -} - -/** - * @testcase utc_system_settings_set_changed_cb_p33 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_VIBRATION is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p33(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_VIBRATION, - callback, NULL); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p32 - * @since_tizen 2.3 - * @description check if SYSTEM_SETTINGS_KEY_VIBRATION is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_VIBRATION is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p32(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_VIBRATION, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_VIBRATION); - my_assert_ret(retcode); - - RETURN(0); -} - -static bool system_setting_get_ringtone_list_cb(int index, const char* data, void *user_data) -{ - int *ringtone_num = user_data; - *ringtone_num += 1; - return true; -} - -RETTYPE utc_system_settings_add_ringtone_list_p1(void) -{ - int retcode = -1; - int files_cnt = sizeof(sst_ringtone_test_files)/sizeof(char*); - int ringtone_num = 0; - for (int i = 0; i < files_cnt; i++) { - retcode = system_settings_add_value_string(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, sst_ringtone_test_files[i]); - my_assert_ret(retcode); - } - retcode = system_settings_foreach_value_string(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, system_setting_get_ringtone_list_cb, &ringtone_num); - my_assert_ret(retcode); - for (int i = files_cnt - 1; i >= 0; i--) { - retcode = system_settings_delete_value_string(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, sst_ringtone_test_files[i]); - my_assert_ret(retcode); - } - assert_eq(ringtone_num, files_cnt + 1); - RETURN(0); -} - -RETTYPE utc_system_settings_delete_ringtone_list_p1(void) -{ - int retcode = -1; - int files_cnt = sizeof(sst_ringtone_test_files)/sizeof(char*); - for (int i = 0; i < files_cnt; i++) { - retcode = system_settings_add_value_string(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, sst_ringtone_test_files[i]); - my_assert_ret(retcode); - } - for (int i = files_cnt - 1; i >= 0; i--) { - retcode = system_settings_delete_value_string(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, sst_ringtone_test_files[i]); - my_assert_ret(retcode); - } - RETURN(0); -} - -#include /* to use sleep */ -typedef struct __in_callback_test { - int call_cnt1; - int call_cnt2; -} __in_callback_data; - -static void utc_system_settings_changed_multi_callback1(system_settings_key_e key, void *user_data) -{ - __in_callback_data *cb_data = (__in_callback_data*)user_data; - if (!cb_data) - return; - cb_data->call_cnt1++; -} - -static void utc_system_settings_changed_multi_callback2(system_settings_key_e key, void *user_data) -{ - __in_callback_data *cb_data = (__in_callback_data*)user_data; - if (!cb_data) - return; - cb_data->call_cnt2++; -} - -static gpointer test_multi_callback_thread(gpointer arg) -{ - int retcode = system_settings_add_changed_cb(SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR, - utc_system_settings_changed_multi_callback1, arg); - my_assert_ret(retcode); - - retcode = system_settings_add_changed_cb(SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR, - utc_system_settings_changed_multi_callback1, arg); - - /* not support same callback about 1 system-settings key */ - assert_eq(retcode, SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER); - - retcode = system_settings_add_changed_cb(SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR, - utc_system_settings_changed_multi_callback2, arg); - - bool bk_state = false; - system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR, &bk_state); - - bool state = true; - system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR, state); - - sleep(1); - - my_assert_ret(retcode); - retcode = system_settings_remove_changed_cb(SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR, - utc_system_settings_changed_multi_callback1); - my_assert_ret(retcode); - retcode = system_settings_remove_changed_cb(SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR, - utc_system_settings_changed_multi_callback2); - my_assert_ret(retcode); - - system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR, bk_state); - - return 0; - -} -/** - * @testcase utc_system_settings_add_changed_cb_p1 - * @since_tizen 4.0 - * @description check if SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_add_changed_cb_p1(void) -{ - __in_callback_data *cb_data = calloc(sizeof(__in_callback_data), 1); - GThread *test_thread; - - test_thread = g_thread_new(NULL, test_multi_callback_thread, cb_data); - - g_thread_join(test_thread); - assert_eq(cb_data->call_cnt1, 1); - assert_eq(cb_data->call_cnt2, 1); - if (cb_data) - free(cb_data); - - RETURN(0); -} - - -RETTYPE utc_system_settings_changed_callback_1(system_settings_key_e key, void *user_data) -{ - _callback_called = true; -} - -RETTYPE utc_system_settings_changed_callback_2(system_settings_key_e key, void *user_data) -{ - _callback_called = true; -} - -RETTYPE utc_system_settings_add_remove_changed_cb_p1(void) -{ - int retcode = 0; - int key_idx = 0; - - for (key_idx = SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE; key_idx < SYSTEM_SETTINGS_KEY_MAX; key_idx++) { - system_settings_changed_cb callback_1 = get_system_settings_test_callback(); - system_settings_changed_cb callback_2 = get_system_settings_test_callback(); - - if (key_idx == SYSTEM_SETTINGS_KEY_3G_DATA_NETWORK_ENABLED + 1) - continue; /* skip removed system-setting key */ - - if (key_idx == SYSTEM_SETTINGS_KEY_DEFAULT_FONT_TYPE) - continue; /* skip not supported notification callback of system-setting key */ - - retcode = system_settings_add_changed_cb(key_idx, - callback_1, NULL); - - if (retcode == SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED) { - assert_eq(retcode, SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED); - } else { - if (retcode != SYSTEM_SETTINGS_ERROR_NONE) - printf("ERROR !! key =%d , ret = %d\n", key_idx, retcode); - } - - retcode = system_settings_remove_changed_cb(key_idx, - callback_1); - - if (retcode == SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED) { - assert_eq(retcode, SYSTEM_SETTINGS_ERROR_NOT_SUPPORTED); - } else { - if (retcode != SYSTEM_SETTINGS_ERROR_NONE) - printf("ERROR !! key =%d , ret = %d\n", key_idx, retcode); - } - - retcode = system_settings_add_changed_cb(key_idx, - callback_1, NULL); - my_assert_ret(retcode); - - retcode = system_settings_add_changed_cb(key_idx, - callback_2, NULL); - my_assert_ret(retcode); - - retcode = system_settings_remove_changed_cb(key_idx, - callback_1); - my_assert_ret(retcode); - - retcode = system_settings_remove_changed_cb(key_idx, - callback_2); - my_assert_ret(retcode); - } - - RETURN(0); -} - -RETTYPE utc_system_settings_ads_id_p1(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = 0; - char *ret_ads_id = NULL; - retcode = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_ADS_ID, &ret_ads_id); - - char *set_ads_id = "00000215-0156-0133-0034-000000000102"; - retcode = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_ADS_ID, set_ads_id); - my_assert_ret(retcode); - - system_settings_set_value_string(SYSTEM_SETTINGS_KEY_ADS_ID, ret_ads_id); - if (ret_ads_id) - free(ret_ads_id); - - retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_ADS_ID, - callback, NULL); - my_assert_ret(retcode); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_ADS_ID); - my_assert_ret(retcode); - RETURN(0); -} - -RETTYPE utc_system_settings_lock_screen_app_p1(void) -{ - int retcode = 0; - char *ret_lock_screen_id = NULL; - retcode = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_LOCKSCREEN_APP, &ret_lock_screen_id); - - char *set_lock_screen_id = "org.tizen.voice-control-panel"; - retcode = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_LOCKSCREEN_APP, set_lock_screen_id); - my_assert_ret(retcode); - - system_settings_set_value_string(SYSTEM_SETTINGS_KEY_LOCKSCREEN_APP, ret_lock_screen_id); - if (ret_lock_screen_id) - free(ret_lock_screen_id); - RETURN(0); -} - -/** - * @testcase utc_system_settings_set_changed_cb_p35 - * @since_tizen 5.0 - * @description check if SYSTEM_SETTINGS_KEY_AUTOMATIC_TIME_UPDATE is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p35(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_AUTOMATIC_TIME_UPDATE, - callback, NULL); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p34 - * @since_tizen 5.0 - * @description check if SYSTEM_SETTINGS_KEY_AUTOMATIC_TIME_UPDATE is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_AUTOMATIC_TIME_UPDATE is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p34(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_AUTOMATIC_TIME_UPDATE, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_AUTOMATIC_TIME_UPDATE); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_changed_cb_p37 - * @since_tizen 5.0 - * @description check if SYSTEM_SETTINGS_KEY_DEVELOPER_OPTION_STATE is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p37(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_DEVELOPER_OPTION_STATE, - callback, NULL); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p36 - * @since_tizen 5.0 - * @description check if SYSTEM_SETTINGS_KEY_DEVELOPER_OPTION_STATE is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_DEVELOPER_OPTION_STATE is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p36(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_DEVELOPER_OPTION_STATE, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_DEVELOPER_OPTION_STATE); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_set_changed_cb_p39 - * @since_tizen 5.5 - * @description check if SYSTEM_SETTINGS_KEY_ACCESSIBILITY_GRAYSCALE is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p39(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_ACCESSIBILITY_GRAYSCALE, - callback, NULL); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p38 - * @since_tizen 5.5 - * @description check if SYSTEM_SETTINGS_KEY_ACCESSIBILITY_GRAYSCALE is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_ACCESSIBILITY_GRAYSCALE is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p38(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_ACCESSIBILITY_GRAYSCALE, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_ACCESSIBILITY_GRAYSCALE); - my_assert_ret(retcode); - - RETURN(0); -} - -/** - * @testcase utc_system_settings_set_changed_cb_p41 - * @since_tizen 5.5 - * @description check if SYSTEM_SETTINGS_KEY_ACCESSIBILITY_NEGATIVE_COLOR is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p41(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_ACCESSIBILITY_NEGATIVE_COLOR, - callback, NULL); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p40 - * @since_tizen 5.5 - * @description check if SYSTEM_SETTINGS_KEY_ACCESSIBILITY_NEGATIVE_COLOR is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_ACCESSIBILITY_NEGATIVE_COLOR is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p40(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_ACCESSIBILITY_NEGATIVE_COLOR, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_ACCESSIBILITY_NEGATIVE_COLOR); - my_assert_ret(retcode); - - RETURN(0); -} - -/** - * @testcase utc_system_settings_set_changed_cb_p43 - * @since_tizen 5.5 - * @description check if SYSTEM_SETTINGS_KEY_ROTARY_EVENT_ENABLED is able to set the callback for change-notification. - */ -RETTYPE utc_system_settings_set_changed_cb_p43(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_ROTARY_EVENT_ENABLED, - callback, NULL); - my_assert_ret(retcode); - - RETURN(0); -} - - -/** - * @testcase utc_system_settings_unset_changed_cb_p42 - * @since_tizen 5.5 - * @description check if SYSTEM_SETTINGS_KEY_ROTARY_EVENT_ENABLED is able to set the callback for change-notification. - * check if SYSTEM_SETTINGS_KEY_ROTARY_EVENT_ENABLED is able to unset the callback for change-notification. - */ -RETTYPE utc_system_settings_unset_changed_cb_p42(void) -{ - system_settings_changed_cb callback = get_system_settings_test_callback(); - int retcode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_ROTARY_EVENT_ENABLED, - callback, NULL); - - retcode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_ROTARY_EVENT_ENABLED); - my_assert_ret(retcode); - - RETURN(0); -} - -void unittest_api() -{ - /* hook up your test functions */ - g_test_add_func("/utc_system_settings_add_changed_cb_p1", utc_system_settings_add_changed_cb_p1); - g_test_add_func("/utc_system_settings_add_remove_changed_cb_p1", utc_system_settings_add_remove_changed_cb_p1); - g_test_add_func("/utc_system_settings_ads_id_p1", utc_system_settings_ads_id_p1); - add_test_func("/utc_system_settings_lock_screen_app_p1", utc_system_settings_lock_screen_app_p1); - add_test_func("/utc_system_settings_get_value_string_p1", utc_system_settings_get_value_string_p1); - add_test_func("/utc_system_settings_get_value_string_p2", utc_system_settings_get_value_string_p2); - add_test_func("/utc_system_settings_get_value_string_p3", utc_system_settings_get_value_string_p3); - add_test_func("/utc_system_settings_get_value_string_p4", utc_system_settings_get_value_string_p4); - add_test_func("/utc_system_settings_get_value_string_p5", utc_system_settings_get_value_string_p5); - add_test_func("/utc_system_settings_get_value_string_p7", utc_system_settings_get_value_string_p7); - add_test_func("/utc_system_settings_get_value_string_p6", utc_system_settings_get_value_string_p6); - add_test_func("/utc_system_settings_get_value_string_p10", utc_system_settings_get_value_string_p10); - add_test_func("/utc_system_settings_get_value_string_p8", utc_system_settings_get_value_string_p8); - add_test_func("/utc_system_settings_get_value_string_p9", utc_system_settings_get_value_string_p9); - add_test_func("/utc_system_settings_get_value_string_p11", utc_system_settings_get_value_string_p11); - add_test_func("/utc_system_settings_get_value_string_n", utc_system_settings_get_value_string_n); - add_test_func("/utc_system_settings_get_value_bool_p1", utc_system_settings_get_value_bool_p1); - add_test_func("/utc_system_settings_get_value_bool_p2", utc_system_settings_get_value_bool_p2); - add_test_func("/utc_system_settings_get_value_bool_p3", utc_system_settings_get_value_bool_p3); - add_test_func("/utc_system_settings_get_value_bool_p4", utc_system_settings_get_value_bool_p4); - add_test_func("/utc_system_settings_get_value_bool_p5", utc_system_settings_get_value_bool_p5); - add_test_func("/utc_system_settings_get_value_bool_p6", utc_system_settings_get_value_bool_p6); - add_test_func("/utc_system_settings_get_value_bool_p7", utc_system_settings_get_value_bool_p7); - add_test_func("/utc_system_settings_get_value_bool_p8", utc_system_settings_get_value_bool_p8); - add_test_func("/utc_system_settings_get_value_bool_p9", utc_system_settings_get_value_bool_p9); - add_test_func("/utc_system_settings_get_value_bool_p10", utc_system_settings_get_value_bool_p10); - add_test_func("/utc_system_settings_get_value_bool_p11", utc_system_settings_get_value_bool_p11); - add_test_func("/utc_system_settings_get_value_bool_p12", utc_system_settings_get_value_bool_p12); - add_test_func("/utc_system_settings_get_value_bool_p13", utc_system_settings_get_value_bool_p13); - add_test_func("/utc_system_settings_get_value_bool_p14", utc_system_settings_get_value_bool_p14); - add_test_func("/utc_system_settings_get_value_bool_n", utc_system_settings_get_value_bool_n); - add_test_func("/utc_system_settings_get_value_int_p1", utc_system_settings_get_value_int_p1); - add_test_func("/utc_system_settings_get_value_int_p2", utc_system_settings_get_value_int_p2); - add_test_func("/utc_system_settings_get_value_n", utc_system_settings_get_value_n); - add_test_func("/utc_system_settings_get_value_int_p3", utc_system_settings_get_value_int_p3); - add_test_func("/utc_system_settings_get_value_int_p4", utc_system_settings_get_value_int_p4); - g_test_add_func("/utc_system_settings_set_value_string_n2", utc_system_settings_set_value_string_n2); - g_test_add_func("/utc_system_settings_set_value_string_n3", utc_system_settings_set_value_string_n3); - g_test_add_func("/utc_system_settings_set_value_string_n4", utc_system_settings_set_value_string_n4); - add_test_func("/utc_system_settings_set_value_string_n5", utc_system_settings_set_value_string_n5); - g_test_add_func("/utc_system_settings_set_value_string_n7", utc_system_settings_set_value_string_n7); - add_test_func("/utc_system_settings_set_value_string_n8", utc_system_settings_set_value_string_n8); - g_test_add_func("/utc_system_settings_set_changed_cb_p1", utc_system_settings_set_changed_cb_p1); - g_test_add_func("/utc_system_settings_unset_changed_cb_p1", utc_system_settings_unset_changed_cb_p1); - g_test_add_func("/utc_system_settings_set_changed_cb_p2", utc_system_settings_set_changed_cb_p2); - g_test_add_func("/utc_system_settings_unset_changed_cb_p2", utc_system_settings_unset_changed_cb_p2); - g_test_add_func("/utc_system_settings_set_changed_cb_p3", utc_system_settings_set_changed_cb_p3); - g_test_add_func("/utc_system_settings_unset_changed_cb_p3", utc_system_settings_unset_changed_cb_p3); - g_test_add_func("/utc_system_settings_set_changed_cb_p4", utc_system_settings_set_changed_cb_p4); - g_test_add_func("/utc_system_settings_LOCK_SCREEN_unset_changed_cb_p", utc_system_settings_LOCK_SCREEN_unset_changed_cb_p); - g_test_add_func("/utc_system_settings_set_changed_cb_p5", utc_system_settings_set_changed_cb_p5); - g_test_add_func("/utc_system_settings_unset_changed_cb_p4", utc_system_settings_unset_changed_cb_p4); - g_test_add_func("/utc_system_settings_set_changed_cb_p6", utc_system_settings_set_changed_cb_p6); - g_test_add_func("/utc_system_settings_unset_changed_cb_p5", utc_system_settings_unset_changed_cb_p5); - g_test_add_func("/utc_system_settings_set_changed_cb_p7", utc_system_settings_set_changed_cb_p7); - g_test_add_func("/utc_system_settings_unset_changed_cb_p6", utc_system_settings_unset_changed_cb_p6); - g_test_add_func("/utc_system_settings_set_changed_cb_p8", utc_system_settings_set_changed_cb_p8); - g_test_add_func("/utc_system_settings_unset_changed_cb_p7", utc_system_settings_unset_changed_cb_p7); - g_test_add_func("/utc_system_settings_set_changed_cb_p9", utc_system_settings_set_changed_cb_p9); - g_test_add_func("/utc_system_settings_unset_changed_cb_p8", utc_system_settings_unset_changed_cb_p8); - g_test_add_func("/utc_system_settings_set_changed_cb_p10", utc_system_settings_set_changed_cb_p10); - g_test_add_func("/utc_system_settings_unset_changed_cb_p9", utc_system_settings_unset_changed_cb_p9); - g_test_add_func("/utc_system_settings_set_changed_cb_p11", utc_system_settings_set_changed_cb_p11); - g_test_add_func("/utc_system_settings_unset_changed_cb_p10", utc_system_settings_unset_changed_cb_p10); - g_test_add_func("/utc_system_settings_set_changed_cb_p12", utc_system_settings_set_changed_cb_p12); - g_test_add_func("/utc_system_settings_unset_changed_cb_p11", utc_system_settings_unset_changed_cb_p11); - g_test_add_func("/utc_system_settings_set_changed_cb_p13", utc_system_settings_set_changed_cb_p13); - g_test_add_func("/utc_system_settings_unset_changed_cb_p12", utc_system_settings_unset_changed_cb_p12); - g_test_add_func("/utc_system_settings_set_changed_cb_p14", utc_system_settings_set_changed_cb_p14); - g_test_add_func("/utc_system_settings_unset_changed_cb_p13", utc_system_settings_unset_changed_cb_p13); - g_test_add_func("/utc_system_settings_set_changed_cb_p15", utc_system_settings_set_changed_cb_p15); - g_test_add_func("/utc_system_settings_unset_changed_cb_p14", utc_system_settings_unset_changed_cb_p14); - g_test_add_func("/utc_system_settings_set_changed_cb_p16", utc_system_settings_set_changed_cb_p16); - g_test_add_func("/utc_system_settings_unset_changed_cb_p15", utc_system_settings_unset_changed_cb_p15); - g_test_add_func("/utc_system_settings_set_changed_cb_p17", utc_system_settings_set_changed_cb_p17); - g_test_add_func("/utc_system_settings_unset_changed_cb_p16", utc_system_settings_unset_changed_cb_p16); - g_test_add_func("/utc_system_settings_set_changed_cb_p18", utc_system_settings_set_changed_cb_p18); - g_test_add_func("/utc_system_settings_unset_changed_cb_p17", utc_system_settings_unset_changed_cb_p17); - g_test_add_func("/utc_system_settings_set_changed_cb_p19", utc_system_settings_set_changed_cb_p19); - g_test_add_func("/utc_system_settings_unset_changed_cb_p18", utc_system_settings_unset_changed_cb_p18); - g_test_add_func("/utc_system_settings_set_changed_cb_p20", utc_system_settings_set_changed_cb_p20); - g_test_add_func("/utc_system_settings_unset_changed_cb_p19;", utc_system_settings_unset_changed_cb_p19); - g_test_add_func("/utc_system_settings_set_changed_cb_p21", utc_system_settings_set_changed_cb_p21); - g_test_add_func("/utc_system_settings_unset_changed_cb_p20", utc_system_settings_unset_changed_cb_p20); - g_test_add_func("/utc_system_settings_set_changed_cb_p22", utc_system_settings_set_changed_cb_p22); - g_test_add_func("/utc_system_settings_unset_changed_cb_p21", utc_system_settings_unset_changed_cb_p21); - g_test_add_func("/utc_system_settings_set_changed_cb_p23", utc_system_settings_set_changed_cb_p23); - g_test_add_func("/utc_system_settings_unset_changed_cb_p22", utc_system_settings_unset_changed_cb_p22); - g_test_add_func("/utc_system_settings_set_changed_cb_p24", utc_system_settings_set_changed_cb_p24); - g_test_add_func("/utc_system_settings_unset_changed_cb_p23", utc_system_settings_unset_changed_cb_p23); - g_test_add_func("/utc_system_settings_set_changed_cb_p25", utc_system_settings_set_changed_cb_p25); - g_test_add_func("/utc_system_settings_unset_changed_cb_p24", utc_system_settings_unset_changed_cb_p24); - g_test_add_func("/utc_system_settings_set_changed_cb_p27", utc_system_settings_set_changed_cb_p27); - g_test_add_func("/utc_system_settings_unset_changed_cb_p26", utc_system_settings_unset_changed_cb_p26); - g_test_add_func("/utc_system_settings_set_changed_cb_p29", utc_system_settings_set_changed_cb_p29); - g_test_add_func("/utc_system_settings_unset_changed_cb_p28", utc_system_settings_unset_changed_cb_p28); - g_test_add_func("/utc_system_settings_set_changed_cb_p31", utc_system_settings_set_changed_cb_p31); - g_test_add_func("/utc_system_settings_unset_changed_cb_p30", utc_system_settings_unset_changed_cb_p30); - g_test_add_func("/utc_system_settings_set_changed_cb_p33", utc_system_settings_set_changed_cb_p33); - g_test_add_func("/utc_system_settings_unset_changed_cb_p32", utc_system_settings_unset_changed_cb_p32); - g_test_add_func("/utc_system_settings_set_changed_cb_p35", utc_system_settings_set_changed_cb_p35); - g_test_add_func("/utc_system_settings_unset_changed_cb_p34", utc_system_settings_unset_changed_cb_p34); - g_test_add_func("/utc_system_settings_set_changed_cb_p37", utc_system_settings_set_changed_cb_p37); - g_test_add_func("/utc_system_settings_unset_changed_cb_p36", utc_system_settings_unset_changed_cb_p36); - g_test_add_func("/utc_system_settings_set_changed_cb_p39", utc_system_settings_set_changed_cb_p39); - g_test_add_func("/utc_system_settings_unset_changed_cb_p38", utc_system_settings_unset_changed_cb_p38); - g_test_add_func("/utc_system_settings_set_changed_cb_p41", utc_system_settings_set_changed_cb_p41); - g_test_add_func("/utc_system_settings_unset_changed_cb_p40", utc_system_settings_unset_changed_cb_p40); - g_test_add_func("/utc_system_settings_set_changed_cb_p43", utc_system_settings_set_changed_cb_p43); - g_test_add_func("/utc_system_settings_unset_changed_cb_p42", utc_system_settings_unset_changed_cb_p42); - g_test_add_func("/utc_system_settings_add_ringtone_list_p1", utc_system_settings_add_ringtone_list_p1); - g_test_add_func("/utc_system_settings_delete_ringtone_list_p1", utc_system_settings_delete_ringtone_list_p1); - add_test_func("/utc_system_settings_set_value_string_p1", utc_system_settings_set_value_string_p1); - add_test_func("/utc_system_settings_set_value_string_p2", utc_system_settings_set_value_string_p2); - g_test_add_func("/utc_system_settings_set_value_string_p3", utc_system_settings_set_value_string_p3); - g_test_add_func("/utc_system_settings_set_value_string_p4", utc_system_settings_set_value_string_p4); - add_test_func("/utc_system_settings_set_value_bool_n1", utc_system_settings_set_value_bool_n1); - add_test_func("/utc_system_settings_set_value_bool_n4", utc_system_settings_set_value_bool_n4); - add_test_func("/utc_system_settings_set_value_bool_n5", utc_system_settings_set_value_bool_n5); - add_test_func("/utc_system_settings_set_value_bool_p1", utc_system_settings_set_value_bool_p1); - add_test_func("/utc_system_settings_set_value_bool_p2", utc_system_settings_set_value_bool_p2); - add_test_func("/utc_system_settings_set_value_int_n1", utc_system_settings_set_value_int_n1); - g_test_add_func("/utc_system_settings_set_changed_cb_n", utc_system_settings_set_changed_cb_n); - add_test_func("/utc_system_settings_set_value_int_p1", utc_system_settings_set_value_int_p1); - add_test_func("/utc_system_settings_set_value_int_n2", utc_system_settings_set_value_int_n2); - add_test_func("/utc_system_settings_set_value_bool_p3", utc_system_settings_set_value_bool_p3); - add_test_func("/utc_system_settings_set_value_bool_p4", utc_system_settings_set_value_bool_p4); - add_test_func("/utc_system_settings_set_value_bool_p5", utc_system_settings_set_value_bool_p5); - add_test_func("/utc_system_settings_set_value_bool_p6", utc_system_settings_set_value_bool_p6); - add_test_func("/utc_system_settings_set_value_bool_p7", utc_system_settings_set_value_bool_p7); - add_test_func("/utc_system_settings_set_value_bool_p8", utc_system_settings_set_value_bool_p8); - add_test_func("/utc_system_settings_set_value_bool_p9", utc_system_settings_set_value_bool_p9); - add_test_func("/utc_system_settings_set_value_bool_p10", utc_system_settings_set_value_bool_p10); - add_test_func("/utc_system_settings_set_value_bool_p11", utc_system_settings_set_value_bool_p11); - add_test_func("/utc_system_settings_set_value_bool_p12", utc_system_settings_set_value_bool_p12); - add_test_func("/utc_system_settings_set_value_int_p2", utc_system_settings_set_value_int_p2); - add_test_func("/utc_system_settings_set_value_string_n6", utc_system_settings_set_value_string_n6); - g_test_add_func("/utc_system_settings_unset_changed_cb_n", utc_system_settings_unset_changed_cb_n); -}