test/unit_tests/test_theme.cc

   1 /*
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd.
   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 <stdlib.h>
  18 #include <gtest/gtest.h>
  19
  20 #include <iostream>
  21 #include <memory>
  22
  23 #include "api/theme.h"
  24 #include "api/theme_error.h"
  25 #include "theme/loader/theme_info.h"
  26
  27 using ttm::loader::ThemeInfo;
  28
  29 class ThemeTest : public testing::Test {
  30  public:
  31   virtual ~ThemeTest() {}
  32
  33   virtual void SetUp() {
  34     std::vector<std::string> ar = {"str1", "str2"};
  35     b_.Add("id", "testid");
  36     b_.Add("version", "1.0");
  37     b_.Add("tool_version", "1.1");
  38     b_.Add("title", "Test");
  39     b_.Add("resolution", "360X360");
  40     b_.Add("preview", "shared/res/preview.png");
  41     b_.Add("description", "test");
  42     b_.Add("stringkey", "value");
  43     b_.Add("intkey", "1");
  44     b_.Add("floatkey", "2.0");
  45     b_.Add("boolkey", "true");
  46     b_.Add("arraykey", ar);
  47   }
  48
  49   virtual void TearDown() {
  50   }
  51
  52   tizen_base::Bundle b_;
  53 };
  54
  55 TEST_F(ThemeTest, Theme_GetId) {
  56   std::shared_ptr<ThemeInfo> info(
  57       new ThemeInfo(b_));
  58   theme_h handle = static_cast<void*>(&info);
  59   char *id;
  60   int ret = theme_get_id(handle, &id);
  61
  62   EXPECT_EQ(ret, THEME_MANAGER_ERROR_NONE);
  63   EXPECT_EQ(std::string(id), "testid");
  64
  65   free(id);
  66 }
  67
  68 TEST_F(ThemeTest, Theme_GetId_N) {
  69   char *id;
  70   int ret = theme_get_id(nullptr, &id);
  71
  72   EXPECT_EQ(ret, THEME_MANAGER_ERROR_INVALID_PARAMETER);
  73 }
  74
  75 TEST_F(ThemeTest, Theme_GetVersion) {
  76   std::shared_ptr<ThemeInfo> info(
  77       new ThemeInfo(b_));
  78   theme_h handle = static_cast<void*>(&info);
  79   char *version;
  80   int ret = theme_get_version(handle, &version);
  81
  82   EXPECT_EQ(ret, THEME_MANAGER_ERROR_NONE);
  83   EXPECT_EQ(std::string(version), "1.0");
  84
  85   free(version);
  86 }
  87
  88 TEST_F(ThemeTest, Theme_GetVersion_N) {
  89   char *version;
  90   int ret = theme_get_version(nullptr, &version);
  91
  92   EXPECT_EQ(ret, THEME_MANAGER_ERROR_INVALID_PARAMETER);
  93 }
  94
  95 TEST_F(ThemeTest, Theme_GetToolVersion) {
  96   std::shared_ptr<ThemeInfo> info(
  97       new ThemeInfo(b_));
  98
  99   theme_h handle = static_cast<void*>(&info);
 100   char *version;
 101   int ret = theme_get_tool_version(handle, &version);
 102
 103   EXPECT_EQ(ret, THEME_MANAGER_ERROR_NONE);
 104   EXPECT_EQ(std::string(version), "1.1");
 105
 106   free(version);
 107 }
 108
 109 TEST_F(ThemeTest, Theme_GetToolVersion_N) {
 110   char *version;
 111   int ret = theme_get_tool_version(nullptr, &version);
 112
 113   EXPECT_EQ(ret, THEME_MANAGER_ERROR_INVALID_PARAMETER);
 114 }
 115
 116 TEST_F(ThemeTest, Theme_GetTitle) {
 117   std::shared_ptr<ThemeInfo> info(
 118       new ThemeInfo(b_));
 119
 120   theme_h handle = static_cast<void*>(&info);
 121   char *title;
 122   int ret = theme_get_title(handle, &title);
 123
 124   EXPECT_EQ(ret, THEME_MANAGER_ERROR_NONE);
 125   EXPECT_EQ(std::string(title), "Test");
 126
 127   free(title);
 128 }
 129
 130
 131 TEST_F(ThemeTest, Theme_GetTitle_N) {
 132   char *title;
 133   int ret = theme_get_title(nullptr, &title);
 134
 135   EXPECT_EQ(ret, THEME_MANAGER_ERROR_INVALID_PARAMETER);
 136 }
 137
 138 TEST_F(ThemeTest, Theme_GetResolution) {
 139   std::shared_ptr<ThemeInfo> info(
 140       new ThemeInfo(b_));
 141
 142   theme_h handle = static_cast<void*>(&info);
 143   char *resolution;
 144   int ret = theme_get_resolution(handle, &resolution);
 145
 146   EXPECT_EQ(ret, THEME_MANAGER_ERROR_NONE);
 147   EXPECT_EQ(std::string(resolution), "360X360");
 148 }
 149
 150 TEST_F(ThemeTest, Theme_GetResolution_N) {
 151   char *resolution;
 152   int ret = theme_get_title(nullptr, &resolution);
 153
 154   EXPECT_EQ(ret, THEME_MANAGER_ERROR_INVALID_PARAMETER);
 155 }
 156
 157 TEST_F(ThemeTest, Theme_GetPreview) {
 158   std::shared_ptr<ThemeInfo> info(
 159       new ThemeInfo(b_));
 160
 161   theme_h handle = static_cast<void*>(&info);
 162   char *preview;
 163   int ret = theme_get_preview(handle, &preview);
 164
 165   EXPECT_EQ(ret, THEME_MANAGER_ERROR_NONE);
 166   EXPECT_EQ(std::string(preview), "shared/res/preview.png");
 167
 168   free(preview);
 169 }
 170
 171 TEST_F(ThemeTest, Theme_GetPreview_N) {
 172   char *preview;
 173   int ret = theme_get_preview(nullptr, &preview);
 174
 175   EXPECT_EQ(ret, THEME_MANAGER_ERROR_INVALID_PARAMETER);
 176 }
 177
 178 TEST_F(ThemeTest, Theme_GetDescription) {
 179   std::shared_ptr<ThemeInfo> info(
 180       new ThemeInfo(b_));
 181
 182   theme_h handle = static_cast<void*>(&info);
 183   char *description;
 184   int ret = theme_get_description(handle, &description);
 185
 186   EXPECT_EQ(ret, THEME_MANAGER_ERROR_NONE);
 187   EXPECT_EQ(std::string(description), "test");
 188
 189   free(description);
 190 }
 191
 192 TEST_F(ThemeTest, Theme_GetDescription_N) {
 193   char *description;
 194   int ret = theme_get_description(nullptr, &description);
 195
 196   EXPECT_EQ(ret, THEME_MANAGER_ERROR_INVALID_PARAMETER);
 197 }
 198
 199 TEST_F(ThemeTest, Theme_GetString) {
 200   std::shared_ptr<ThemeInfo> info(
 201       new ThemeInfo(b_));
 202
 203   theme_h handle = static_cast<void*>(&info);
 204   char *str;
 205   int ret = theme_get_string(handle, "stringkey", &str);
 206
 207   EXPECT_EQ(ret, THEME_MANAGER_ERROR_NONE);
 208   EXPECT_EQ(std::string(str), "value");
 209
 210   free(str);
 211 }
 212
 213 TEST_F(ThemeTest, Theme_GetString_N) {
 214   char *str;
 215   int ret = theme_get_string(nullptr, "stringkey", &str);
 216
 217   EXPECT_EQ(ret, THEME_MANAGER_ERROR_INVALID_PARAMETER);
 218 }
 219
 220 TEST_F(ThemeTest, Theme_GetStringArray) {
 221   std::shared_ptr<ThemeInfo> info(
 222       new ThemeInfo(b_));
 223
 224   theme_h handle = static_cast<void*>(&info);
 225   char **strarr;
 226   int count;
 227   int ret = theme_get_string_array(handle, "arraykey", &strarr, &count);
 228
 229   EXPECT_EQ(ret, THEME_MANAGER_ERROR_NONE);
 230   EXPECT_EQ(std::string(strarr[0]), "str1");
 231   EXPECT_EQ(std::string(strarr[1]), "str2");
 232   EXPECT_EQ(count, 2);
 233
 234   free(strarr);
 235 }
 236
 237 TEST_F(ThemeTest, Theme_GetStringArray_N) {
 238   char **strarr;
 239   int count;
 240   int ret = theme_get_string_array(nullptr, "arraykey", &strarr, &count);
 241
 242   EXPECT_EQ(ret, THEME_MANAGER_ERROR_INVALID_PARAMETER);
 243 }
 244
 245 TEST_F(ThemeTest, Theme_GetInt) {
 246   std::shared_ptr<ThemeInfo> info(
 247       new ThemeInfo(b_));
 248
 249   theme_h handle = static_cast<void*>(&info);
 250   int val;
 251   int ret = theme_get_int(handle, "intkey", &val);
 252
 253   EXPECT_EQ(ret, THEME_MANAGER_ERROR_NONE);
 254   EXPECT_EQ(val, 1);
 255 }
 256
 257 TEST_F(ThemeTest, Theme_GetInt_N) {
 258   int val;
 259   int ret = theme_get_int(nullptr, "intkey", &val);
 260
 261   EXPECT_EQ(ret, THEME_MANAGER_ERROR_INVALID_PARAMETER);
 262 }
 263
 264 TEST_F(ThemeTest, Theme_GetFloat) {
 265   std::shared_ptr<ThemeInfo> info(
 266       new ThemeInfo(b_));
 267
 268   theme_h handle = static_cast<void*>(&info);
 269   float val;
 270   int ret = theme_get_float(handle, "floatkey", &val);
 271
 272   EXPECT_EQ(ret, THEME_MANAGER_ERROR_NONE);
 273   EXPECT_EQ(val, 2.0);
 274 }
 275
 276 TEST_F(ThemeTest, Theme_GetFloat_N) {
 277   float val;
 278   int ret = theme_get_float(nullptr, "floatkey", &val);
 279
 280   EXPECT_EQ(ret, THEME_MANAGER_ERROR_INVALID_PARAMETER);
 281 }
 282
 283 TEST_F(ThemeTest, Theme_GetBool) {
 284   std::shared_ptr<ThemeInfo> info(
 285       new ThemeInfo(b_));
 286
 287   theme_h handle = static_cast<void*>(&info);
 288   bool val;
 289   int ret = theme_get_bool(handle, "boolkey", &val);
 290
 291   EXPECT_EQ(ret, THEME_MANAGER_ERROR_NONE);
 292   EXPECT_EQ(val, true);
 293 }
 294
 295 TEST_F(ThemeTest, Theme_GetBool_N1) {
 296   bool val;
 297   int ret = theme_get_bool(nullptr, "boolkey", &val);
 298
 299   EXPECT_EQ(ret, THEME_MANAGER_ERROR_INVALID_PARAMETER);
 300 }
 301
 302 TEST_F(ThemeTest, Theme_GetBool_N2) {
 303   std::shared_ptr<ThemeInfo> info(
 304       new ThemeInfo(b_));
 305
 306   theme_h handle = static_cast<void*>(&info);
 307   bool val;
 308   int ret = theme_get_bool(handle, "boolkey_n", &val);
 309
 310   EXPECT_EQ(ret, THEME_MANAGER_ERROR_NONE);
 311   EXPECT_EQ(val, false);
 312 }