unittest/src/test-watchface-complication-provider.cc

   1 /*
   2  * Copyright (c) 2019 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 <gtest/gtest.h>
  18 #include <gmock/gmock.h>
  19 #include <watchface-complication-provider.h>
  20 #include <watchface-complication-provider-internal.h>
  21 #include <app_control_internal.h>
  22
  23 #include "watchface-common/include/watchface-common-internal.h"
  24 #include "watchface-complication/design-element.hh"
  25 #include "watchface-complication/editables-container.hh"
  26 #include "watchface-complication/received-editable.hh"
  27 #include "watchface-common/db-manager.hh"
  28
  29 #include "mock/system_info_mock.h"
  30 #include "mock/tzplatform_config_mock.h"
  31 #include "mock/app_common.h"
  32 #include "mock/mock_util.h"
  33 #include "mock/pkgmgr_mock.h"
  34 #include "mock/gio/gio.h"
  35 #include "mock/aul_mock.h"
  36 #include "mock/cynara_mock.h"
  37
  38
  39 using namespace std;
  40 using namespace tizen_base;
  41 using namespace watchface_complication;
  42 namespace {
  43
  44 unsigned int event_timer__;
  45 GMainLoop* loop_ = nullptr;
  46 int __fake_system_info_get_platform_bool(const char* key, bool* value) {
  47   *value = true;
  48   return 0;
  49 }
  50
  51 int __cynara_initialize(
  52       cynara** c, const cynara_configuration* conf) {
  53   return 0;
  54 }
  55
  56 int __cynara_finish(
  57       cynara* c) {
  58   return 0;
  59 }
  60
  61 int __cynara_check(cynara* c, const char* client, const char* client_session,
  62     const char* user,
  63     const char* privilege) {
  64   return CYNARA_API_ACCESS_ALLOWED;
  65 }
  66
  67 int __cynara_creds_gdbus_get_user(GDBusConnection* connection,
  68     const gchar* uniqueName, enum cynara_user_creds method, gchar** user) {
  69   return CYNARA_API_SUCCESS;
  70 }
  71
  72 int __cynara_creds_gdbus_get_client(GDBusConnection* connection,
  73     const gchar* uniqueName, enum cynara_client_creds method, gchar** client) {
  74   return CYNARA_API_SUCCESS;
  75 }
  76
  77 gboolean __fake_g_dbus_connection_emit_signal(GDBusConnection * connection,
  78                                const gchar* destination_bus_name,
  79                                const gchar* object_path,
  80                                const gchar* interface_name,
  81                                const gchar* signal_name,
  82                                GVariant* parameters,
  83                                GError** error) {
  84   return TRUE;
  85 }
  86
  87 guint __fake_signal_subscribe_on_update(GDBusConnection* connection,
  88                                     const gchar* sender,
  89                                     const gchar* interface_name,
  90                                     const gchar* member,
  91                                     const gchar* object_path,
  92                                     const gchar* arg0,
  93                                     GDBusSignalFlags     flags,
  94                                     GDBusSignalCallback  callback,
  95                                     gpointer             user_data,
  96                                     GDestroyNotify       user_data_free_func) {
  97   if (event_timer__ != 0)
  98     g_source_remove(event_timer__);
  99
 100   event_timer__ = g_timeout_add(500, [](gpointer user_data)->gboolean {
 101     IGDBus::IGDBusEvent* rs = static_cast<IGDBus::IGDBusEvent*>(user_data);
 102     Bundle b;
 103     string sender_name = "org.tizen.gmock_comp_provider2";
 104     b.Add("context", "test");
 105
 106     GVariant* parameters = g_variant_new("(siis)",
 107         "org.tizen.gmock_comp_provider2", 1, Icon, b.ToRaw().first.get());
 108     rs->OnSignal(nullptr, sender_name,
 109                         "test path",
 110                         "test interface",
 111                         "__COMP_UPDATE_REQUEST__",
 112                         parameters);
 113     g_variant_unref(parameters);
 114
 115     parameters = g_variant_new("(siii)",
 116         "org.tizen.gmock_comp_provider2", Icon, 1, 1);
 117     rs->OnSignal(nullptr, sender_name,
 118                         "test path",
 119                         "test interface",
 120                         "__COMP_NOTIFY_LISTENING_STATUS__",
 121                         parameters);
 122     g_variant_unref(parameters);
 123
 124     parameters = g_variant_new("(siii)",
 125         "org.tizen.gmock_comp_provider2", Icon, 1, 0);
 126     rs->OnSignal(nullptr, sender_name,
 127                         "test path",
 128                         "test interface",
 129                         "__COMP_NOTIFY_LISTENING_STATUS__",
 130                         parameters);
 131     g_variant_unref(parameters);
 132
 133     rs->OnVanish("org.tizen.watchface_complication._384a702381f61e7c1466cda88f001d28");
 134
 135     if (g_main_loop_is_running(loop_))
 136       g_main_loop_quit(loop_);
 137
 138     return G_SOURCE_CONTINUE;
 139   }, reinterpret_cast<gpointer>(user_data));
 140
 141   return 1;
 142 }
 143
 144 int __fake_aul_app_get_appid_bypid(int pid, char* appid, int size) {
 145   snprintf(appid, size, "%s", "org.tizen.gmock_comp_provider2");
 146   return 0;
 147 }
 148
 149 int __fake_aul_get_app_shared_resource_path_by_appid(const char* appid,
 150     char** path) {
 151   *path = strdup("/opt/usr/share/org.tizen.gmock_comp_provider2/");
 152   return 0;
 153 }
 154
 155 void __all_provider_foreach_cb(const provider_info_h info, void *user_data) {
 156   int* count = static_cast<int*>(user_data);
 157   (*count)++;
 158 }
 159
 160 void __provider_foreach_cb(const provider_info_h info, void *user_data) {
 161   char* str_value = nullptr;
 162   int types, ret;
 163   watchface_complication_provider_info_get_id(info, &str_value);
 164   unique_ptr<char, decltype(free)*> ptr(str_value, free);
 165   EXPECT_STREQ(ptr.get(), "org.tizen.gmock_comp_provider/test");
 166   ret = watchface_complication_provider_info_get_id(info, nullptr);
 167   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 168
 169   str_value = nullptr;
 170   watchface_complication_provider_info_get_app_id(info, &str_value);
 171   ptr.reset(str_value);
 172   EXPECT_STREQ(ptr.get(), "org.tizen.gmock_comp_provider");
 173   ret = watchface_complication_provider_info_get_app_id(info, nullptr);
 174   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 175
 176   str_value = nullptr;
 177   watchface_complication_provider_info_get_label(info, &str_value);
 178   ptr.reset(str_value);
 179   EXPECT_STREQ(ptr.get(), "provider_label");
 180   ret =   watchface_complication_provider_info_get_label(info, nullptr);
 181   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 182
 183   str_value = nullptr;
 184   watchface_complication_provider_info_get_icon(info, &str_value);
 185   ptr.reset(str_value);
 186   EXPECT_STREQ(ptr.get(), "icon_path");
 187   ret = watchface_complication_provider_info_get_icon(info, nullptr);
 188   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 189
 190   watchface_complication_provider_info_get_types(info, &types);
 191   EXPECT_EQ(WATCHFACE_COMPLICATION_TYPE_SHORT_TEXT |
 192                 WATCHFACE_COMPLICATION_TYPE_LONG_TEXT |
 193                 WATCHFACE_COMPLICATION_TYPE_RANGED_VALUE |
 194                 WATCHFACE_COMPLICATION_TYPE_TIME |
 195                 WATCHFACE_COMPLICATION_TYPE_ICON |
 196                 WATCHFACE_COMPLICATION_TYPE_IMAGE |
 197                 WATCHFACE_COMPLICATION_TYPE_SMALL_IMAGE,
 198                 types);
 199
 200   ret = watchface_complication_provider_info_get_types(info, nullptr);
 201   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 202 }
 203
 204 class CWCP : public ::testing::Test {
 205  public:
 206   void RunLoop() {
 207     g_main_loop_run(loop_);
 208   }
 209   virtual void SetUp() {
 210     system_info_get_platform_bool_fake.custom_fake = __fake_system_info_get_platform_bool;
 211     g_dbus_connection_signal_subscribe_fake.custom_fake = __fake_signal_subscribe_on_update;
 212     aul_app_get_appid_bypid_fake.custom_fake = __fake_aul_app_get_appid_bypid;
 213     aul_get_app_shared_resource_path_by_appid_fake.custom_fake =
 214         __fake_aul_get_app_shared_resource_path_by_appid;
 215     g_dbus_connection_emit_signal_fake.custom_fake =
 216       __fake_g_dbus_connection_emit_signal;
 217     cynara_initialize_fake.custom_fake = __cynara_initialize;
 218     cynara_finish_fake.custom_fake = __cynara_finish;
 219     cynara_check_fake.custom_fake = __cynara_check;
 220     cynara_creds_gdbus_get_user_fake.custom_fake = __cynara_creds_gdbus_get_user;
 221     cynara_creds_gdbus_get_client_fake.custom_fake = __cynara_creds_gdbus_get_client;
 222     loop_ = g_main_loop_new(nullptr, FALSE);
 223   }
 224
 225   virtual void TearDown(){
 226     if (event_timer__ != 0) {
 227       g_source_remove(event_timer__);
 228       event_timer__ = 0;
 229     }
 230     g_main_loop_quit(loop_);
 231     g_main_loop_unref(loop_);
 232     loop_ = nullptr;
 233   }
 234 };
 235
 236 void _update_requested_cb(
 237       const char* provider_id, const char* req_appid,
 238       watchface_complication_type_e type, const bundle* context,
 239       bundle* share_data, void* user_data) {
 240   int ret;
 241   ret = watchface_complication_provider_data_set_type(
 242       share_data, WATCHFACE_COMPLICATION_TYPE_ICON);
 243   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
 244
 245   ret = watchface_complication_provider_data_set_icon_path(
 246       share_data, nullptr);
 247   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 248   ret = watchface_complication_provider_data_set_icon_path(
 249       share_data, "data/icon.png");
 250   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
 251
 252   watchface_complication_provider_data_set_type(
 253       share_data, WATCHFACE_COMPLICATION_TYPE_NO_DATA);
 254 }
 255
 256 void _consumer_status_cb(const char *provider_id,
 257       const char *request_appid,
 258       watchface_complication_consumer_status_e status,
 259       void *user_data) {
 260 }
 261
 262 TEST_F(CWCP, watchface_complication_provider_add_update_requested_cb)
 263 {
 264   int ret = watchface_complication_provider_add_update_requested_cb(
 265       "org.tizen.gmock_comp_provider2/test",
 266       _update_requested_cb, nullptr);
 267   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
 268   ret = watchface_complication_provider_add_update_requested_cb(
 269       "org.tizen.gmock_comp_provider2/test",
 270       _update_requested_cb, nullptr);
 271   EXPECT_EQ( WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 272
 273   watchface_complication_provider_set_consumer_status_cb(
 274     _consumer_status_cb, nullptr);
 275
 276   /* already registered callback check*/
 277   watchface_complication_provider_set_consumer_status_cb(
 278     _consumer_status_cb, nullptr);
 279
 280   ret = watchface_complication_provider_notify_update(
 281       "org.tizen.gmock_comp_provider2/test");
 282   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
 283   ret = watchface_complication_provider_notify_update(
 284       "org.tizen");
 285   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 286
 287   RunLoop();
 288   ret = watchface_complication_provider_remove_update_requested_cb(
 289       "org.tizen.gmock_comp_provider2/test",
 290       _update_requested_cb);
 291   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
 292   ret = watchface_complication_provider_remove_update_requested_cb(
 293       "org.tizen.gmock_comp_provider2/test",
 294       _update_requested_cb);
 295   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 296 }
 297
 298 TEST_F(CWCP, watchface_complication_provider_setup_reply_to_editor)
 299 {
 300   app_control_h service;
 301   app_control_create(&service);
 302   app_control_add_extra_data(service,
 303       "__SETUP_EDITOR_APPID_KEY__", "org.test.editor");
 304   app_control_add_extra_data(service, "__SETUP_EDITABLE_ID_KEY__", "10");
 305   bundle* context = bundle_create();
 306
 307   int ret = watchface_complication_provider_setup_reply_to_editor(
 308       service, context);
 309   bundle_free(context);
 310   app_control_destroy(service);
 311   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
 312 }
 313
 314 TEST_F(CWCP, watchface_complication_provider_setup_is_editing)
 315 {
 316   app_control_h service;
 317   app_control_create(&service);
 318
 319   bool is_editing = false;
 320   int ret = watchface_complication_provider_setup_is_editing(
 321          service, &is_editing);
 322   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
 323   EXPECT_EQ(false, is_editing);
 324
 325   app_control_add_extra_data(service,
 326       "__SETUP_EDITOR_APPID_KEY__", "org.test.editor");
 327
 328   ret = watchface_complication_provider_setup_is_editing(
 329       service, &is_editing);
 330   app_control_destroy(service);
 331   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
 332
 333   ret = watchface_complication_provider_setup_is_editing(nullptr, nullptr);
 334   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 335 }
 336
 337 TEST_F(CWCP, watchface_complication_provider_setup_get_context)
 338 {
 339   app_control_h service;
 340   app_control_create(&service);
 341   app_control_add_extra_data(service,
 342       "__SETUP_EDITOR_APPID_KEY__", "org.test.editor");
 343   bundle* context;
 344   int ret = watchface_complication_provider_setup_get_context(
 345       service, &context);
 346   EXPECT_EQ(nullptr, context);
 347
 348   bundle* context_test = bundle_create();
 349   bundle_raw* r;
 350   int len;
 351   bundle_encode(context_test, &r, &len);
 352   app_control_add_extra_data(service, "__SETUP_CONTEXT_DATA_KEY__",
 353           (const char *)r);
 354   bundle_free(context_test);
 355   free(r);
 356   ret = watchface_complication_provider_setup_get_context(
 357          service, &context);
 358   bundle_free(context);
 359   app_control_destroy(service);
 360   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
 361
 362   ret = watchface_complication_provider_setup_get_context(nullptr, nullptr);
 363   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 364 }
 365
 366 TEST_F(CWCP, watchface_complication_provider_data_set_type)
 367 {
 368   bundle* shared = bundle_create();
 369   int ret = watchface_complication_provider_data_set_type(
 370       shared, WATCHFACE_COMPLICATION_TYPE_LONG_TEXT);
 371   bundle_free(shared);
 372   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
 373
 374   ret = watchface_complication_provider_data_set_type(
 375       nullptr, WATCHFACE_COMPLICATION_TYPE_LONG_TEXT);
 376   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 377 }
 378
 379 TEST_F(CWCP, watchface_complication_provider_data_is_valid)
 380 {
 381   bundle* shared = bundle_create();
 382   bool is_valid;
 383   int ret = watchface_complication_provider_data_set_type(
 384       nullptr, WATCHFACE_COMPLICATION_TYPE_LONG_TEXT);
 385   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 386   ret = watchface_complication_provider_data_set_type(
 387       shared, (watchface_complication_type_e)-1);
 388   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 389   ret = watchface_complication_provider_data_is_valid(shared, nullptr);
 390   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 391
 392   /* WATCHFACE_COMPLICATION_TYPE_SHORT_TEXT */
 393   watchface_complication_provider_data_set_type(
 394       shared, WATCHFACE_COMPLICATION_TYPE_SHORT_TEXT);
 395   ret = watchface_complication_provider_data_set_short_text(shared, "t");
 396   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
 397   ret = watchface_complication_provider_data_is_valid(shared, &is_valid);
 398   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
 399   EXPECT_EQ(is_valid, true);
 400   ret = watchface_complication_provider_data_set_small_image_path_with_aod(shared, "t", "t");
 401   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 402   ret = watchface_complication_provider_data_set_small_image_path(shared, "t");
 403   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 404
 405   /* WATCHFACE_COMPLICATION_TYPE_LONG_TEXT */
 406   watchface_complication_provider_data_set_type(
 407       shared, WATCHFACE_COMPLICATION_TYPE_LONG_TEXT);
 408   ret = watchface_complication_provider_data_set_title(shared, "title");
 409   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
 410   ret = watchface_complication_provider_data_is_valid(shared, &is_valid);
 411   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
 412   EXPECT_EQ(is_valid, false);
 413   ret = watchface_complication_provider_data_set_image_path_with_aod(shared, "t", "t");
 414   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 415   ret = watchface_complication_provider_data_set_short_text(shared, "t");
 416   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 417
 418   /* WATCHFACE_COMPLICATION_TYPE_RANGED_VALUE */
 419   watchface_complication_provider_data_set_type(
 420       shared, WATCHFACE_COMPLICATION_TYPE_RANGED_VALUE);
 421   ret = watchface_complication_provider_data_set_ranged_value(
 422       shared, 10.0, 0.0, 100.0);
 423   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
 424   ret = watchface_complication_provider_data_is_valid(shared, &is_valid);
 425   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
 426   EXPECT_EQ(is_valid, true);
 427   ret = watchface_complication_provider_data_set_icon_path_with_aod(shared, "t", "t");
 428   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 429   ret = watchface_complication_provider_data_set_icon_path(shared, "t");
 430   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 431   ret = watchface_complication_provider_data_set_small_image_path_with_aod(shared, "t", "t");
 432   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 433   ret = watchface_complication_provider_data_set_small_image_path(shared, "t");
 434   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 435
 436   /* WATCHFACE_COMPLICATION_TYPE_TIME */
 437   watchface_complication_provider_data_set_type(
 438       shared, WATCHFACE_COMPLICATION_TYPE_TIME);
 439   watchface_complication_provider_data_set_timestamp(shared, 10.0);
 440   ret = watchface_complication_provider_data_is_valid(shared, &is_valid);
 441   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
 442   EXPECT_EQ(is_valid, true);
 443   ret = watchface_complication_provider_data_set_small_image_path_with_aod(shared, "t", "t");
 444   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 445   ret = watchface_complication_provider_data_set_small_image_path(shared, "t");
 446   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 447
 448   /* WATCHFACE_COMPLICATION_TYPE_ICON */
 449   watchface_complication_provider_data_set_type(
 450       shared, WATCHFACE_COMPLICATION_TYPE_ICON);
 451   ret = watchface_complication_provider_data_set_icon_path(shared, "res/data.png");
 452   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
 453   ret = watchface_complication_provider_data_is_valid(shared, &is_valid);
 454   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
 455   EXPECT_EQ(is_valid, true);
 456   ret = watchface_complication_provider_data_set_small_image_path_with_aod(shared, "t", "t");
 457   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 458   ret = watchface_complication_provider_data_set_small_image_path(shared, "t");
 459   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 460   ret = watchface_complication_provider_data_set_title(shared, "t");
 461   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 462   ret = watchface_complication_provider_data_set_short_text(shared, "t");
 463   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 464
 465   /* WATCHFACE_COMPLICATION_TYPE_IMAGE */
 466   watchface_complication_provider_data_set_type(
 467       shared, WATCHFACE_COMPLICATION_TYPE_IMAGE);
 468   watchface_complication_provider_data_set_image_path(shared, "res/data.png");
 469   ret = watchface_complication_provider_data_is_valid(shared, &is_valid);
 470   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
 471   EXPECT_EQ(is_valid, true);
 472   ret = watchface_complication_provider_data_set_icon_path_with_aod(shared, "t", "t");
 473   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 474   ret = watchface_complication_provider_data_set_small_image_path_with_aod(shared, "t", "t");
 475   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 476   ret = watchface_complication_provider_data_set_title(shared, "t");
 477   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 478   ret = watchface_complication_provider_data_set_short_text(shared, "t");
 479   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 480   ret = watchface_complication_provider_data_set_small_image_path(shared, "t");
 481   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 482   ret = watchface_complication_provider_data_set_icon_path(shared, "t");
 483   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 484
 485   /* WATCHFACE_COMPLICATION_TYPE_SMALL_IMAGE */
 486   watchface_complication_provider_data_set_type(shared,
 487     static_cast<watchface_complication_type_e>(WATCHFACE_COMPLICATION_TYPE_SMALL_IMAGE));
 488   watchface_complication_provider_data_set_small_image_path(shared, "res/data.png");
 489   ret = watchface_complication_provider_data_is_valid(shared, &is_valid);
 490   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
 491   EXPECT_EQ(is_valid, true);
 492   ret = watchface_complication_provider_data_set_icon_path_with_aod(shared, "t", "t");
 493   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 494   ret = watchface_complication_provider_data_set_title(shared, "t");
 495   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 496   ret = watchface_complication_provider_data_set_short_text(shared, "t");
 497   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 498   ret = watchface_complication_provider_data_set_icon_path(shared, "t");
 499   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 500   ret = watchface_complication_provider_data_set_long_text(shared, "t");
 501   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 502   ret = watchface_complication_provider_data_set_timestamp(shared, 0);
 503   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 504   ret = watchface_complication_provider_data_set_image_path(shared, "t");
 505   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 506
 507   bundle_free(shared);
 508 }
 509
 510  TEST_F(CWCP, negative_test)
 511 {
 512   bundle* shared = bundle_create();
 513   int ret;
 514
 515   ret = watchface_complication_provider_data_set_icon_path(shared, nullptr);
 516   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 517   ret = watchface_complication_provider_data_set_image_path(shared, nullptr);
 518   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 519   ret = watchface_complication_provider_data_set_small_image_path(shared, nullptr);
 520   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 521   ret = watchface_complication_provider_data_set_ranged_value(
 522   shared, 10.0, 100.0, 0.0);
 523   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 524   ret = watchface_complication_provider_data_set_title(shared, nullptr);
 525   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 526   ret = watchface_complication_provider_data_set_short_text(shared, nullptr);
 527   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 528   ret = watchface_complication_provider_data_set_icon_path_with_aod(shared, nullptr, "t");
 529   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 530   ret = watchface_complication_provider_data_set_image_path_with_aod(shared, nullptr, "t");
 531   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 532   ret = watchface_complication_provider_data_set_small_image_path_with_aod(shared, nullptr, "t");
 533   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 534   ret = watchface_complication_provider_data_set_long_text(shared, nullptr);
 535   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 536   ret = watchface_complication_provider_data_set_timestamp(nullptr, 0);
 537   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 538   ret = watchface_complication_provider_timeinfo_create(nullptr);
 539   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 540
 541   complication_time_info_h info;
 542   watchface_complication_provider_timeinfo_create(&info);
 543   ret = watchface_complication_provider_timeinfo_set_timezone(info, nullptr);
 544   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 545   ret = watchface_complication_provider_timeinfo_set_timezone_id(info, nullptr);
 546   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 547   ret = watchface_complication_provider_timeinfo_set_timezone_country(info, nullptr);
 548   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 549   ret = watchface_complication_provider_timeinfo_set_timezone_city(info, nullptr);
 550   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 551   ret = watchface_complication_provider_data_set_timeinfo(nullptr, info);
 552   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 553   ret = watchface_complication_provider_timeinfo_destroy(nullptr);
 554   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 555   ret = watchface_complication_provider_data_set_extra_data(shared, nullptr);
 556   watchface_complication_provider_timeinfo_destroy(info);
 557
 558   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 559   ret = watchface_complication_provider_data_set_screen_reader_text(shared, nullptr);
 560   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 561
 562   bundle_free(shared);
 563 }
 564
 565 TEST_F(CWCP, watchface_complication_provider_event_get_type)
 566 {
 567   bundle* shared = bundle_create();
 568   bundle_add_str(shared, "__AUL_COMPLICATION_MODE__", "true");
 569
 570   bundle* touch_data = bundle_create();
 571   bundle_add_str(touch_data, "__TOUCH_LAUNCH_EVENT_KEY__", "2");
 572
 573   int str_len = 0;
 574   bundle_raw* raw_data = NULL;
 575   bundle_encode(touch_data, &raw_data, &str_len);
 576   bundle_add_str(shared, "__TOUCH_LAUNCH_DATA_KEY__",
 577       reinterpret_cast<const char*>(raw_data));
 578
 579   app_control_h service;
 580   watchface_complication_event_type_e type;
 581   app_control_create(&service);
 582   app_control_import_from_bundle(service, shared);
 583   int ret = watchface_complication_provider_event_get_type(
 584       service, &type);
 585   bundle_free(shared);
 586   bundle_free(touch_data);
 587   free(raw_data);
 588   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
 589   EXPECT_EQ(type, WATCHFACE_COMPLICATION_EVENT_TAP);
 590
 591   ret = watchface_complication_provider_event_get_type(
 592         service, nullptr);
 593   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 594   app_control_destroy(service);
 595 }
 596
 597 TEST_F(CWCP, watchface_complication_provider_event_get_provider_id)
 598 {
 599   bundle* shared = bundle_create();
 600   bundle_add_str(shared, "__AUL_COMPLICATION_MODE__", "true");
 601
 602   bundle* touch_data = bundle_create();
 603   bundle_add_str(touch_data, "__TOUCH_LAUNCH_PROVIDER_ID_KEY__",
 604       "org.tizen.provider");
 605   int str_len = 0;
 606   bundle_raw* raw_data = NULL;
 607   bundle_encode(touch_data, &raw_data, &str_len);
 608   bundle_add_str(shared, "__TOUCH_LAUNCH_DATA_KEY__",
 609       reinterpret_cast<const char*>(raw_data));
 610
 611   app_control_h service;
 612   app_control_create(&service);
 613   app_control_import_from_bundle(service, shared);
 614   char* ret_provider;
 615   int ret = watchface_complication_provider_event_get_provider_id(
 616       service, &ret_provider);
 617
 618   bundle_free(shared);
 619   bundle_free(touch_data);
 620   free(raw_data);
 621   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
 622   EXPECT_STREQ(ret_provider, "org.tizen.provider");
 623   free(ret_provider);
 624
 625   ret = watchface_complication_provider_event_get_provider_id(
 626       service, nullptr);
 627   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 628   app_control_destroy(service);
 629 }
 630
 631 TEST_F(CWCP, watchface_complication_provider_event_get_complication_type)
 632 {
 633   bundle* shared = bundle_create();
 634   bundle_add_str(shared, "__AUL_COMPLICATION_MODE__", "true");
 635
 636   bundle* touch_data = bundle_create();
 637   bundle_add_str(touch_data, "__TOUCH_LAUNCH_PROVIDER_ID_KEY__",
 638       "org.tizen.provider");
 639   bundle_add_str(touch_data, "__TOUCH_LAUNCH_TYPE_KEY__", "2");
 640
 641   int str_len = 0;
 642   bundle_raw* raw_data = NULL;
 643   bundle_encode(touch_data, &raw_data, &str_len);
 644   bundle_add_str(shared, "__TOUCH_LAUNCH_DATA_KEY__",
 645       reinterpret_cast<const char*>(raw_data));
 646
 647   app_control_h service;
 648   watchface_complication_type_e type;
 649   app_control_create(&service);
 650   app_control_import_from_bundle(service, shared);
 651   int ret = watchface_complication_provider_event_get_complication_type(
 652       service, &type);
 653
 654   bundle_free(shared);
 655   bundle_free(touch_data);
 656   free(raw_data);
 657   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
 658   EXPECT_EQ(type, WATCHFACE_COMPLICATION_TYPE_SHORT_TEXT);
 659
 660   ret = watchface_complication_provider_event_get_complication_type(
 661       service, nullptr);
 662   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 663   app_control_destroy(service);
 664 }
 665
 666 TEST_F(CWCP, watchface_complication_provider_event_get_context)
 667 {
 668   bundle* shared = bundle_create();
 669   bundle* context = bundle_create();
 670   int str_len = 0;
 671   bundle_raw* raw_data = NULL;
 672   bundle_encode(context, &raw_data, &str_len);
 673   bundle_add_str(shared, "__AUL_COMPLICATION_MODE__", "true");
 674
 675   bundle* touch_data = bundle_create();
 676   bundle_add_str(touch_data, "__TOUCH_LAUNCH_PROVIDER_ID_KEY__",
 677       "org.tizen.provider");
 678   bundle_add_str(touch_data, "__TOUCH_LAUNCH_CONTEXT_KEY__",
 679       reinterpret_cast<const char*>(raw_data));
 680   free(raw_data);
 681
 682   bundle_raw* raw = NULL;
 683   int ret = bundle_encode(touch_data, &raw, &str_len);
 684   EXPECT_EQ(BUNDLE_ERROR_NONE, ret);
 685   bundle_add_str(shared, "__TOUCH_LAUNCH_DATA_KEY__",
 686       reinterpret_cast<const char*>(raw));
 687   free(raw);
 688
 689   app_control_h service;
 690   bundle* ret_context;
 691   app_control_create(&service);
 692   app_control_import_from_bundle(service, shared);
 693   ret = watchface_complication_provider_event_get_context(
 694       service, &ret_context);
 695   bundle_free(touch_data);
 696   bundle_free(shared);
 697   bundle_free(context);
 698   if (ret == WATCHFACE_COMPLICATION_ERROR_NONE)
 699     bundle_free(ret_context);
 700   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
 701
 702   ret = watchface_complication_provider_event_get_context(
 703       service, nullptr);
 704   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 705   app_control_destroy(service);
 706 }
 707
 708 TEST_F(CWCP, watchface_complication_provider_foreach_info)
 709 {
 710   int ret, count = 0;
 711
 712   ret = watchface_complication_provider_foreach_info(
 713           nullptr, __all_provider_foreach_cb, &count);
 714   EXPECT_EQ(6, count);
 715   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
 716
 717   ret = watchface_complication_provider_foreach_info(
 718           "org.tizen.gmock_comp_provider", __provider_foreach_cb, nullptr);
 719   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
 720
 721   ret = watchface_complication_provider_foreach_info(
 722           nullptr, nullptr, &count);
 723   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER, ret);
 724 }
 725 }