tests/sst_gtest_normal_font.cpp

   1 /*
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <string.h>
  18 #include <glib.h>
  19 #include <gtest/gtest.h>
  20 #include <vconf.h>
  21 #include <dlfcn.h>
  22
  23 #include "system_settings.h"
  24 #include "mocks/sstt_mock.h"
  25 #define FONT_SCALE_CONF_PATH "conf_example/font_scale.json"
  26
  27 extern "C" {
  28 #include "sst.h"
  29 #include "sst_font.h"
  30 #include "sst_vconf.h"
  31 #include "sst_interface.h"
  32
  33 typedef struct __font_size_info {
  34         int small;
  35         int normal;
  36         int large;
  37         int huge;
  38         int giant;
  39 } font_size_info;
  40 }
  41
  42 TEST(SstFontTest, getDefaultfontERR)
  43 {
  44         char *val;
  45         sst_interface *iface;
  46         int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_DEFAULT_FONT_TYPE, &iface);
  47         EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret);
  48
  49         sstm_dlopen_setup(false);
  50         ret = sst_font_get_default_type(iface, &val);
  51         EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret);
  52 }
  53
  54 TEST(SstFontTest, getFontTypeERR)
  55 {
  56         char *val = NULL;
  57         sst_interface *iface;
  58
  59         sstm_system_info_get_platform_bool_setup(true);
  60         sstm_dlopen_setup(true);
  61
  62         sstm_vconf_get_str_setup(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME, "Default", -1);
  63
  64         int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_FONT_TYPE, &iface);
  65         EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret);
  66         ret = sst_font_get_type(iface, &val);
  67         EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret);
  68
  69         sstm_vconf_get_str_setup(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME, "Default", 0);
  70         sstm_dlopen_setup(false);
  71         ret = sst_font_get_type(iface, &val);
  72         EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret);
  73 }
  74
  75
  76 TEST(SstFontTest, setFontTypeERR)
  77 {
  78         const char *setVal = "BreezeSans";
  79         sst_interface *iface;
  80         int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_FONT_TYPE, &iface);
  81         EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret);
  82
  83         sstm_dlopen_setup(false);
  84         ret = sst_font_set_type(iface, setVal);
  85         EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret);
  86
  87         sstm_dlopen_setup(true);
  88         sstm_xmlSaveFormatFile_setup(true);
  89         sstm_eext_config_font_set_setup(false);
  90         ret = sst_font_set_type(iface, setVal);
  91         EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret);
  92
  93         sstm_xmlSaveFormatFile_setup(false);
  94         sstm_xmlParseFile_setup(false);
  95         ret = sst_font_set_type(iface, setVal);
  96         EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret);
  97
  98         sstm_xmlParseFile_setup(false);
  99         sstm_vconf_get_int_setup(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME, 0, -1);
 100         ret = sst_font_set_type(iface, setVal);
 101         EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret);
 102 }
 103
 104 TEST(SstFontTest, setFontSizeERR)
 105 {
 106         sst_interface *iface;
 107
 108         int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_FONT_SIZE, &iface);
 109         EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret);
 110
 111         sstm_vconf_set_int_setup(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, -1);
 112         ret = sst_font_set_size(iface, SYSTEM_SETTINGS_FONT_SIZE_NORMAL);
 113         EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret);
 114 }
 115
 116 TEST(SstFontTest, getFontType)
 117 {
 118         char *val = NULL;
 119         char *defaultfont_val = NULL;
 120         const char *setVal = "BreezeSans";
 121         sst_interface *iface;
 122         sst_interface *defaultfont_iface;
 123
 124         sstm_system_info_get_platform_bool_setup(true);
 125         sstm_dlopen_setup(true);
 126
 127         sstm_vconf_get_str_setup(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME, setVal, 0);
 128
 129         int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_FONT_TYPE, &iface);
 130         EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret);
 131         ret = sst_font_get_type(iface, &val);
 132         EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret);
 133         EXPECT_STREQ(setVal, val);
 134         free(val);
 135         val = NULL;
 136
 137         sstm_vconf_get_str_setup(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME, "Default", 0);
 138
 139         ret = sst_get_interface(SYSTEM_SETTINGS_KEY_DEFAULT_FONT_TYPE, &defaultfont_iface);
 140         EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret);
 141         ret = sst_font_get_default_type(defaultfont_iface, &defaultfont_val);
 142         EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret);
 143         ret = sst_font_get_type(iface, &val);
 144         EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret);
 145         EXPECT_STREQ(defaultfont_val, val);
 146         free(defaultfont_val);
 147         free(val);
 148 }
 149
 150 static void* _utils_load_lib()
 151 {
 152         const char* const path = SETTING_UTILS_SO_FILE_PATH;
 153         void *handle = dlopen(path, RTLD_LAZY | RTLD_GLOBAL);
 154         if (NULL == handle)
 155                 ERR("dlopen(%s) Fail", path);
 156
 157         return handle;
 158 }
 159
 160 TEST(SstFontTest,loadFontSizeInfo)
 161 {
 162         font_size_info info;
 163         void *handle = _utils_load_lib();
 164         EXPECT_NE((void*)NULL, handle);
 165
 166         typedef int (*fn_impl)(font_size_info *info, const char *path);
 167         fn_impl load_font_size_info = NULL;
 168
 169         load_font_size_info = (fn_impl)dlsym(handle, "load_font_size_info");
 170         char *error = dlerror();
 171         EXPECT_EQ(0, error);
 172
 173         int ret = load_font_size_info(&info, FONT_SCALE_CONF_PATH);
 174         EXPECT_EQ(0, ret);
 175
 176         EXPECT_EQ(-80, info.small);
 177         EXPECT_EQ(-150, info.large);
 178         EXPECT_EQ(-100, info.normal);
 179         EXPECT_EQ(-190, info.huge);
 180         EXPECT_EQ(-250, info.giant);
 181
 182         dlclose(handle);
 183         handle = NULL;
 184 }
 185
 186 TEST(SstFontTest, getDefaultfont)
 187 {
 188         char *val = NULL;
 189         sst_interface *iface;
 190
 191         sstm_system_info_get_platform_bool_setup(true);
 192         sstm_dlopen_setup(true);
 193
 194         int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_FONT_TYPE, &iface);
 195         EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret);
 196         ret = sst_font_get_default_type(iface, &val);
 197         EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret);
 198         free(val);
 199 }
 200
 201 TEST(SstFontTest, setFontType)
 202 {
 203         char *getVal = NULL;
 204         const char *eVal = "WrongFontName";
 205         const char *setVal = "BreezeSans";
 206         sst_interface *iface;
 207
 208         sstm_system_info_get_platform_bool_setup(true);
 209         sstm_dlopen_setup(true);
 210         sstm_xmlParseFile_setup(true);
 211         sstm_xmlSaveFormatFile_setup(true);
 212         sstm_eext_config_font_set_setup(true);
 213
 214         int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_FONT_TYPE, &iface);
 215         EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret);
 216
 217         sstm_vconf_set_int_setup(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, 0);
 218         sstm_vconf_set_str_setup(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME, 0);
 219
 220         ret = sst_font_set_type(iface, eVal);
 221         EXPECT_EQ(SYSTEM_SETTINGS_ERROR_IO_ERROR, ret);
 222         ret = sst_font_set_type(iface, setVal);
 223         EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret);
 224         ret = sst_vconf_get_str(iface, &getVal);
 225         EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret);
 226         EXPECT_STREQ(setVal, getVal);
 227
 228         free(getVal);
 229 }
 230
 231 TEST(SstFontTest, setFontSize)
 232 {
 233         int fontSize[] = {
 234                 SYSTEM_SETTINGS_FONT_SIZE_SMALL,
 235                 SYSTEM_SETTINGS_FONT_SIZE_NORMAL,
 236                 SYSTEM_SETTINGS_FONT_SIZE_LARGE,
 237                 SYSTEM_SETTINGS_FONT_SIZE_HUGE,
 238                 SYSTEM_SETTINGS_FONT_SIZE_GIANT
 239         };
 240         int fsCnt = sizeof(fontSize) / sizeof(fontSize[0]);
 241         int getVal;
 242         int setVal;
 243         sst_interface *iface;
 244
 245         sstm_system_info_get_platform_bool_setup(true);
 246         sstm_dlopen_setup(true);
 247         sstm_vconf_get_str_setup(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME, "BreezeSans", 0);
 248         sstm_vconf_set_int_setup(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, 0);
 249
 250         int ret = sst_get_interface(SYSTEM_SETTINGS_KEY_FONT_SIZE, &iface);
 251         EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret);
 252
 253         for (int i = 0; i < fsCnt; i++) {
 254                 setVal = fontSize[i];
 255                 ret = sst_font_set_size(iface, setVal);
 256                 EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret);
 257                 ret = sst_vconf_get_int(iface, &getVal);
 258                 EXPECT_EQ(SYSTEM_SETTINGS_ERROR_NONE, ret);
 259                 EXPECT_EQ(setVal, getVal);
 260         }
 261 }