src/unit_tests/unit_test.cc

   1 // Copyright (c) 2018 Samsung Electronics Co., Ltd All Rights Reserved
   2 // Use of this source code is governed by a apache 2.0 license that can be
   3 // found in the LICENSE file.
   4
   5 #include <gtest/gtest.h>
   6
   7 #include <string>
   8
   9 #include "include/capability_manager.h"
  10 #include "src/utils/logging.h"
  11
  12 namespace {
  13
  14 int DeviceForeachCbForSetup(const capmgr_device_h device, void* user_data) {
  15   capmgr_device_h* clone = reinterpret_cast<capmgr_device_h*>(user_data);
  16   int ret = capmgr_device_clone(device, clone);
  17   if (ret != CAPMGR_ERROR_NONE)
  18     return 0;
  19   // use the first device
  20   else
  21     return 1;
  22 }
  23
  24 int ApplicationForeachCbForSetup(
  25     const capmgr_application_info_h remote_app_info, void* user_data) {
  26   capmgr_application_info_h* clone =
  27       reinterpret_cast<capmgr_application_info_h*>(user_data);
  28   int ret = capmgr_application_info_clone(remote_app_info, clone);
  29   if (ret != CAPMGR_ERROR_NONE)
  30     return 0;
  31   // use the first app
  32   else
  33     return 1;
  34 }
  35
  36 int DeviceForeachCb(const capmgr_device_h device, void* user_data) {
  37   bool* is_hit = reinterpret_cast<bool*>(user_data);
  38   *is_hit = true;
  39   return 1;
  40 }
  41
  42 int ApplicationForeachCb(const capmgr_application_info_h remote_app_info,
  43     void* user_data) {
  44   bool* is_hit = reinterpret_cast<bool*>(user_data);
  45   *is_hit = true;
  46
  47   char* appid;
  48   capmgr_application_info_get_appid(remote_app_info, &appid);
  49   free(appid);
  50   LOG(INFO) << appid;
  51   return 0;
  52 }
  53
  54 const char kExtraDataKeyStr[] = "extra_key";
  55 const char kExtraDataValueStr[] = "extra_value";
  56
  57 class TestEnvironment : public ::testing::Environment {
  58  public:
  59   TestEnvironment() : device_(nullptr), app_control_(nullptr),
  60       app_(nullptr) {}
  61   void SetUp() override {
  62     ASSERT_EQ(capmgr_device_foreach_devices(DeviceForeachCbForSetup, &device_),
  63         CAPMGR_ERROR_NONE) << "Failed to init test environment!";
  64     ASSERT_NE(device_, nullptr);
  65     char* device_id;
  66     capmgr_device_get_device_id(device_, &device_id);
  67     LOG(INFO) << "Selected device id is: " << device_id;
  68     free(device_id);
  69     ASSERT_EQ(capmgr_app_control_create(&app_control_), CAPMGR_ERROR_NONE);
  70     ASSERT_NE(app_control_, nullptr);
  71     ASSERT_EQ(capmgr_app_control_set_device(app_control_, device_),
  72         CAPMGR_ERROR_NONE);
  73     ASSERT_EQ(capmgr_app_control_set_operation(app_control_, "operation"),
  74         CAPMGR_ERROR_NONE);
  75     ASSERT_EQ(capmgr_app_control_set_uri(app_control_, "uri"),
  76         CAPMGR_ERROR_NONE);
  77     ASSERT_EQ(capmgr_app_control_set_mime(app_control_, "mime"),
  78         CAPMGR_ERROR_NONE);
  79     ASSERT_EQ(capmgr_app_control_set_appid(app_control_, "appid"),
  80         CAPMGR_ERROR_NONE);
  81     ASSERT_EQ(capmgr_app_control_add_extra_data(app_control_, kExtraDataKeyStr,
  82             kExtraDataValueStr), CAPMGR_ERROR_NONE);
  83     ASSERT_EQ(capmgr_application_info_foreach_applications(device_,
  84             ApplicationForeachCbForSetup, &app_), CAPMGR_ERROR_NONE);
  85   }
  86   void TearDown() override {
  87     capmgr_application_info_destroy(app_);
  88     capmgr_app_control_destroy(app_control_);
  89     capmgr_device_destroy(device_);
  90   }
  91
  92   capmgr_device_h device_;
  93   capmgr_app_control_h app_control_;
  94   capmgr_application_info_h app_;
  95 };
  96
  97 TestEnvironment* env = nullptr;
  98
  99 }  // namespace
 100
 101 namespace capmgr {
 102
 103 class UnitTest : public ::testing::Test {
 104  protected:
 105   virtual void SetUp() {}
 106   virtual void TearDown() {}
 107 };
 108
 109 TEST_F(UnitTest, DeviceForeachDevicesPositiveTest) {
 110   bool is_hit = false;
 111   ASSERT_EQ(capmgr_device_foreach_devices(DeviceForeachCb, &is_hit),
 112       CAPMGR_ERROR_NONE);
 113   ASSERT_TRUE(is_hit);
 114 }
 115
 116 TEST_F(UnitTest, DeviceForeachDevicesNegativeTest) {
 117   ASSERT_EQ(capmgr_device_foreach_devices(nullptr, nullptr),
 118       CAPMGR_ERROR_INVALID_PARAMETER);
 119 }
 120
 121 TEST_F(UnitTest, DeviceClonePositiveTest) {
 122   // need to get device
 123   capmgr_device_h clone;
 124   ASSERT_EQ(capmgr_device_clone(env->device_, &clone), CAPMGR_ERROR_NONE);
 125 }
 126
 127 TEST_F(UnitTest, DeviceCloneNegativeTest) {
 128   capmgr_device_h clone;
 129   ASSERT_EQ(capmgr_device_clone(nullptr, &clone),
 130       CAPMGR_ERROR_INVALID_PARAMETER);
 131   ASSERT_EQ(capmgr_device_clone(env->device_, nullptr),
 132       CAPMGR_ERROR_INVALID_PARAMETER);
 133 }
 134
 135 TEST_F(UnitTest, DeviceDestroyPositiveTest) {
 136   capmgr_device_h clone;
 137   ASSERT_EQ(capmgr_device_clone(env->device_, &clone),
 138       CAPMGR_ERROR_NONE);
 139   ASSERT_EQ(capmgr_device_destroy(clone), CAPMGR_ERROR_NONE);
 140 }
 141
 142 TEST_F(UnitTest, DeviceDestroyNegativeTest) {
 143   ASSERT_EQ(capmgr_device_destroy(nullptr), CAPMGR_ERROR_INVALID_PARAMETER);
 144 }
 145
 146 #define DEVICE_GET_TEST_BLOCK(POSITIVE_TESTNAME, NEGATIVE_TESTNAME, ATTR)      \
 147 TEST_F(UnitTest, POSITIVE_TESTNAME) {                                          \
 148   char* ATTR = nullptr;                                                        \
 149   ASSERT_EQ(capmgr_device_get_##ATTR(env->device_, &ATTR), CAPMGR_ERROR_NONE); \
 150   ASSERT_NE(ATTR, nullptr);                                                    \
 151   free(ATTR);                                                                  \
 152 }                                                                              \
 153                                                                                \
 154 TEST_F(UnitTest, NEGATIVE_TESTNAME) {                                          \
 155   char* ATTR;                                                                  \
 156   ASSERT_EQ(capmgr_device_get_##ATTR(nullptr, &ATTR),                          \
 157       CAPMGR_ERROR_INVALID_PARAMETER);                                         \
 158   ASSERT_EQ(capmgr_device_get_##ATTR(env->device_, nullptr),                   \
 159       CAPMGR_ERROR_INVALID_PARAMETER);                                         \
 160 }                                                                              \
 161
 162 DEVICE_GET_TEST_BLOCK(DeviceGetDeviceIdPositiveTest,
 163     DeviceGetDeviceIdNegativeTest, device_id)
 164
 165 DEVICE_GET_TEST_BLOCK(DeviceGetModelNamePositiveTest,
 166     DeviceGetModelNameNegativeTest, model_name)
 167
 168 DEVICE_GET_TEST_BLOCK(DeviceGetDeviceNamePositiveTest,
 169     DeviceGetDeviceNameNegativeTest, device_name)
 170
 171 DEVICE_GET_TEST_BLOCK(DeviceGetPlatformVerPositiveTest,
 172     DeviceGetPlatformVerNegativeTest, platform_ver)
 173
 174 DEVICE_GET_TEST_BLOCK(DeviceGetProfilePositiveTest,
 175     DeviceGetProfileNegativeTest, profile)
 176
 177 DEVICE_GET_TEST_BLOCK(DeviceGetSWVerPositiveTest,
 178     DeviceGetSWVerNegativeTest, sw_ver)
 179
 180 TEST_F(UnitTest, AppControlCreatePositiveTest) {
 181   capmgr_app_control_h app_control;
 182   ASSERT_EQ(capmgr_app_control_create(&app_control), CAPMGR_ERROR_NONE);
 183   capmgr_app_control_destroy(app_control);
 184 }
 185
 186 TEST_F(UnitTest, AppControlCreateNegativeTest) {
 187   ASSERT_EQ(capmgr_app_control_create(nullptr), CAPMGR_ERROR_INVALID_PARAMETER);
 188 }
 189
 190 TEST_F(UnitTest, AppControlDestroyPositiveTest) {
 191   capmgr_app_control_h app_control;
 192   ASSERT_EQ(capmgr_app_control_create(&app_control), CAPMGR_ERROR_NONE);
 193   ASSERT_EQ(capmgr_app_control_destroy(app_control), CAPMGR_ERROR_NONE);
 194 }
 195
 196 TEST_F(UnitTest, AppControlDestroyNegativeTest) {
 197   ASSERT_EQ(capmgr_app_control_destroy(nullptr),
 198       CAPMGR_ERROR_INVALID_PARAMETER);
 199 }
 200
 201 TEST_F(UnitTest, AppControlGetDevicePositiveTest) {
 202   capmgr_device_h device;
 203   ASSERT_EQ(capmgr_app_control_get_device(env->app_control_, &device),
 204       CAPMGR_ERROR_NONE);
 205   capmgr_device_destroy(device);
 206 }
 207
 208 TEST_F(UnitTest, AppControlGetDeviceNegativeTest) {
 209   capmgr_device_h device;
 210   ASSERT_EQ(capmgr_app_control_get_device(nullptr, &device),
 211       CAPMGR_ERROR_INVALID_PARAMETER);
 212   ASSERT_EQ(capmgr_app_control_get_device(env->app_control_, nullptr),
 213       CAPMGR_ERROR_INVALID_PARAMETER);
 214 }
 215
 216 #define APP_CONTROL_GET_TEST_BLOCK(POSITIVE_TESTNAME, NEGATIVE_TESTNAME, ATTR) \
 217 TEST_F(UnitTest, POSITIVE_TESTNAME) {                                          \
 218   char* ATTR = nullptr;                                                        \
 219   ASSERT_EQ(capmgr_app_control_get_##ATTR(env->app_control_, &ATTR),           \
 220       CAPMGR_ERROR_NONE);                                                      \
 221   ASSERT_NE(ATTR, nullptr);                                                    \
 222   free(ATTR);                                                                  \
 223 }                                                                              \
 224                                                                                \
 225 TEST_F(UnitTest, NEGATIVE_TESTNAME) {                                          \
 226   char* ATTR;                                                                  \
 227   ASSERT_EQ(capmgr_app_control_get_##ATTR(nullptr, &ATTR),                     \
 228       CAPMGR_ERROR_INVALID_PARAMETER);                                         \
 229   ASSERT_EQ(capmgr_app_control_get_##ATTR(env->app_control_, nullptr),         \
 230       CAPMGR_ERROR_INVALID_PARAMETER);                                         \
 231 }                                                                              \
 232
 233 APP_CONTROL_GET_TEST_BLOCK(AppControlGetOperationPositiveTest,
 234     AppControlGetOperationNegativeTest, operation)
 235
 236 APP_CONTROL_GET_TEST_BLOCK(AppControlGetUriPositiveTest,
 237     AppControlGetUriNegativeTest, uri)
 238
 239 APP_CONTROL_GET_TEST_BLOCK(AppControlGetMimePositiveTest,
 240     AppControlGetMimeNegativeTest, mime)
 241
 242 APP_CONTROL_GET_TEST_BLOCK(AppControlGetAppidPositiveTest,
 243     AppControlGetAppidNegativeTest, appid)
 244
 245 TEST_F(UnitTest, AppControlGetExtraDataPositiveTest) {
 246   char* value = nullptr;
 247   ASSERT_EQ(capmgr_app_control_get_extra_data(env->app_control_,
 248       kExtraDataKeyStr, &value), CAPMGR_ERROR_NONE);
 249   ASSERT_NE(value, nullptr);
 250   free(value);
 251 }
 252
 253 TEST_F(UnitTest, AppControlGetExtraDataNegativeTest) {
 254   char* value;
 255   ASSERT_EQ(capmgr_app_control_get_extra_data(nullptr,
 256       kExtraDataKeyStr, &value), CAPMGR_ERROR_INVALID_PARAMETER);
 257   ASSERT_EQ(capmgr_app_control_get_extra_data(env->app_control_,
 258       nullptr, &value), CAPMGR_ERROR_INVALID_PARAMETER);
 259   ASSERT_EQ(capmgr_app_control_get_extra_data(env->app_control_,
 260       kExtraDataKeyStr, nullptr), CAPMGR_ERROR_INVALID_PARAMETER);
 261 }
 262
 263 TEST_F(UnitTest, AppControlSetDevicePositiveTest) {
 264   ASSERT_EQ(capmgr_app_control_set_device(env->app_control_, env->device_),
 265       CAPMGR_ERROR_NONE);
 266 }
 267
 268 TEST_F(UnitTest, AppControlSetDeviceNegativeTest) {
 269   ASSERT_EQ(capmgr_app_control_set_device(nullptr, env->device_),
 270       CAPMGR_ERROR_INVALID_PARAMETER);
 271   ASSERT_EQ(capmgr_app_control_set_device(env->app_control_, nullptr),
 272       CAPMGR_ERROR_INVALID_PARAMETER);
 273 }
 274
 275 #define APP_CONTROL_SET_TEST_BLOCK(POSITIVE_TESTNAME, NEGATIVE_TESTNAME, ATTR) \
 276 TEST_F(UnitTest, POSITIVE_TESTNAME) {                                          \
 277   ASSERT_EQ(capmgr_app_control_set_##ATTR(env->app_control_, "value"),         \
 278       CAPMGR_ERROR_NONE);                                                      \
 279 }                                                                              \
 280                                                                                \
 281 TEST_F(UnitTest, NEGATIVE_TESTNAME) {                                          \
 282   ASSERT_EQ(capmgr_app_control_set_##ATTR(nullptr, "value"),                   \
 283       CAPMGR_ERROR_INVALID_PARAMETER);                                         \
 284   ASSERT_EQ(capmgr_app_control_set_##ATTR(env->app_control_, nullptr),         \
 285       CAPMGR_ERROR_INVALID_PARAMETER);                                         \
 286 }                                                                              \
 287
 288 APP_CONTROL_SET_TEST_BLOCK(AppControlSetOperationPositiveTest,
 289     AppControlSetOperationNegativeTest, operation)
 290
 291 APP_CONTROL_SET_TEST_BLOCK(AppControlSetUriPositiveTest,
 292     AppControlSetUriNegativeTest, uri)
 293
 294 APP_CONTROL_SET_TEST_BLOCK(AppControlSetMimePositiveTest,
 295     AppControlSetMimeNegativeTest, mime)
 296
 297 APP_CONTROL_SET_TEST_BLOCK(AppControlSetAppidPositiveTest,
 298     AppControlSetAppidNegativeTest, appid)
 299
 300 TEST_F(UnitTest, AppControlAddExtraDataPositiveTest) {
 301   ASSERT_EQ(
 302       capmgr_app_control_add_extra_data(env->app_control_, "key", "value"),
 303       CAPMGR_ERROR_NONE);
 304 }
 305
 306 TEST_F(UnitTest, AppControlAddExtraDataNegativeTest) {
 307   ASSERT_EQ(
 308       capmgr_app_control_add_extra_data(nullptr, "key", "value"),
 309       CAPMGR_ERROR_INVALID_PARAMETER);
 310   ASSERT_EQ(
 311       capmgr_app_control_add_extra_data(env->app_control_, nullptr, "value"),
 312       CAPMGR_ERROR_INVALID_PARAMETER);
 313   ASSERT_EQ(
 314       capmgr_app_control_add_extra_data(env->app_control_, "key", nullptr),
 315       CAPMGR_ERROR_INVALID_PARAMETER);
 316 }
 317
 318 TEST_F(UnitTest, AppControlRemoveExtraDataPositiveTest) {
 319   ASSERT_EQ(
 320       capmgr_app_control_add_extra_data(env->app_control_, "key2", "value2"),
 321       CAPMGR_ERROR_NONE);
 322   ASSERT_EQ(
 323       capmgr_app_control_remove_extra_data(env->app_control_, "key2"),
 324       CAPMGR_ERROR_NONE);
 325   // should return such as CAPMGR_ERROR_NO_SUCH_KEY?
 326   char* value;
 327   ASSERT_EQ(capmgr_app_control_get_extra_data(env->app_control_,
 328       "key2", &value), CAPMGR_ERROR_INVALID_PARAMETER);
 329 }
 330
 331 TEST_F(UnitTest, AppControlRemoveExtraDataNegativeTest) {
 332   char* value;
 333   ASSERT_EQ(capmgr_app_control_get_extra_data(nullptr,
 334       kExtraDataKeyStr, &value), CAPMGR_ERROR_INVALID_PARAMETER);
 335   ASSERT_EQ(capmgr_app_control_get_extra_data(env->app_control_,
 336       nullptr, &value), CAPMGR_ERROR_INVALID_PARAMETER);
 337   ASSERT_EQ(capmgr_app_control_get_extra_data(env->app_control_,
 338       kExtraDataKeyStr, nullptr), CAPMGR_ERROR_INVALID_PARAMETER);
 339 }
 340
 341 // TODO(jeremy.jang)
 342 /*
 343 TEST_F(UnitTest, AppControlSendPositiveTest) {
 344 }
 345
 346 TEST_F(UnitTest, AppControlSendNegativeTest) {
 347 }
 348 */
 349
 350 TEST_F(UnitTest, ApplicationInfoForeachPackagesPositiveTest) {
 351   bool is_hit = false;
 352   ASSERT_EQ(capmgr_application_info_foreach_applications(env->device_,
 353           ApplicationForeachCb, &is_hit), CAPMGR_ERROR_NONE);
 354   ASSERT_TRUE(is_hit);
 355 }
 356
 357 TEST_F(UnitTest, ApplicationInfoForeachPackagesNegativeTest) {
 358   ASSERT_EQ(capmgr_application_info_foreach_applications(nullptr,
 359           ApplicationForeachCb, nullptr), CAPMGR_ERROR_INVALID_PARAMETER);
 360   ASSERT_EQ(capmgr_application_info_foreach_applications(env->device_,
 361           nullptr, nullptr), CAPMGR_ERROR_INVALID_PARAMETER);
 362 }
 363
 364 #define APPLICATION_INFO_GET_TEST_BLOCK(                                       \
 365     POSITIVE_TESTNAME, NEGATIVE_TESTNAME, ATTR)                                \
 366 TEST_F(UnitTest, POSITIVE_TESTNAME) {                                          \
 367   char* ATTR = nullptr;                                                        \
 368   ASSERT_EQ(capmgr_application_info_get_##ATTR(env->app_, &ATTR),              \
 369       CAPMGR_ERROR_NONE);                                                      \
 370   ASSERT_NE(ATTR, nullptr);                                                    \
 371   free(ATTR);                                                                  \
 372 }                                                                              \
 373                                                                                \
 374 TEST_F(UnitTest, NEGATIVE_TESTNAME) {                                          \
 375   char* ATTR;                                                                  \
 376   ASSERT_EQ(capmgr_application_info_get_##ATTR(nullptr, &ATTR),                \
 377       CAPMGR_ERROR_INVALID_PARAMETER);                                         \
 378   ASSERT_EQ(capmgr_application_info_get_##ATTR(env->app_, nullptr),            \
 379       CAPMGR_ERROR_INVALID_PARAMETER);                                         \
 380 }                                                                              \
 381
 382 APPLICATION_INFO_GET_TEST_BLOCK(ApplicationInfoGetAppidPositiveTest,
 383     ApplicationInfoGetAppidNegativeTest, appid)
 384
 385 APPLICATION_INFO_GET_TEST_BLOCK(ApplicationInfoGetPkgidPositiveTest,
 386     ApplicationInfoGetPkgidNegativeTest, pkgid)
 387
 388 APPLICATION_INFO_GET_TEST_BLOCK(ApplicationInfoGetLabelPositiveTest,
 389     ApplicationInfoGetLabelNegativeTest, label)
 390
 391 APPLICATION_INFO_GET_TEST_BLOCK(ApplicationInfoGetVersionPositiveTest,
 392     ApplicationInfoGetVersionNegativeTest, version)
 393
 394 }  // namespace capmgr
 395
 396 int main(int argc, char* argv[]) {
 397   ::testing::InitGoogleTest(&argc, argv);
 398   ::env = static_cast<TestEnvironment*>(
 399       ::testing::AddGlobalTestEnvironment(new TestEnvironment));
 400   return RUN_ALL_TESTS();
 401 }