gtest/unittest.cpp

   1 /*
   2  * Copyright (c) 2014 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 <gmock/gmock.h>
  18 #include <gtest/gtest.h>
  19 #include <unistd.h>
  20 #include <iostream>
  21 #include <stdio.h>
  22 #include <glib.h>
  23 #include <sys/time.h>
  24
  25 #include <tcore.h>
  26 #include <server.h>
  27 #include <plugin.h>
  28 #include <core_object.h>
  29 #include <at.h>
  30 #include <hal.h>
  31 #include <queue.h>
  32 #include <user_request.h>
  33 #include <manager.h>
  34 #include <communicator.h>
  35 #include <storage.h>
  36
  37
  38 using ::testing::EmptyTestEventListener;
  39 using ::testing::InitGoogleTest;
  40 using ::testing::Test;
  41 using ::testing::TestCase;
  42 using ::testing::TestEventListeners;
  43 using ::testing::TestInfo;
  44 using ::testing::TestPartResult;
  45 using ::testing::UnitTest;
  46
  47 void tcore_log(enum tcore_log_type type, enum tcore_log_priority priority, const char *tag, const char *fmt, ...)
  48 {
  49 }
  50
  51
  52 /* Plug-in descriptor */
  53 struct tcore_plugin_define_desc test_plugin_define_desc = {
  54         .name = "TEST_PLUGIN",
  55         .priority = TCORE_PLUGIN_PRIORITY_MID,
  56         .version = 1,
  57         .load = NULL,
  58         .init = NULL,
  59         .unload = NULL
  60 };
  61
  62 static enum tcore_hook_return __on_request_hook_callback(Server *s, UserRequest *ur, void *user_data)
  63 {
  64         std::cout <<"   __on_request_hook_callback()" << std::endl;
  65
  66         return TCORE_HOOK_RETURN_CONTINUE;
  67 }
  68
  69 static enum tcore_hook_return __on_notification_hook_callback(Server *s, CoreObject *source,
  70         enum tcore_notification_command command,
  71         unsigned int data_len, void *data, void *user_data)
  72 {
  73         std::cout <<"   __on_notification_hook_callback()" << std::endl;
  74
  75         return TCORE_HOOK_RETURN_CONTINUE;
  76 }
  77
  78 static TReturn __on_test_comm_send_response(Communicator *comm, UserRequest *ur,
  79         enum tcore_response_command command, unsigned int data_len, const void *data)
  80 {
  81         std::cout <<"   __on_test_comm_send_response()" << std::endl;
  82         return TCORE_RETURN_SUCCESS;
  83 }
  84
  85 static TReturn __on_test_comm_send_notification(Communicator *comm, CoreObject *source,
  86         enum tcore_notification_command command, unsigned int data_len, const void *data)
  87 {
  88         std::cout <<"   __on_test_comm_send_notification()" << std::endl;
  89         return TCORE_RETURN_SUCCESS;
  90 }
  91
  92 /*
  93  * communicator operations
  94  */
  95 struct tcore_communicator_operations test_communicator_ops = {
  96         .send_response = __on_test_comm_send_response,
  97         .send_notification = __on_test_comm_send_notification,
  98 };
  99
 100 TEST(LIBTCORE_SERVER, test_server)
 101 {
 102         Server *s;
 103         Manager *m;
 104         TcorePlugin *p, *modem_plugin;
 105         Communicator *c;
 106         TcoreHal *h;
 107         Storage *strg;
 108         TReturn ret;
 109
 110         /* create sever handle */
 111         s = tcore_server_new();
 112         ASSERT_TRUE(s);
 113
 114         /* add plugin */
 115         p = tcore_plugin_new(s, &test_plugin_define_desc, "test_plugin", NULL);
 116         ASSERT_TRUE(p);
 117         ret = tcore_server_add_plugin(s, p);
 118         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
 119         EXPECT_TRUE(tcore_server_ref_plugins(s));
 120         EXPECT_EQ(tcore_plugin_ref_server(p), s);
 121
 122         TcorePlugin *ref_plugin = tcore_server_search_plugin_list(s, "TEST_PLUGIN");
 123         EXPECT_EQ(ref_plugin, p);
 124
 125         /* add manager */
 126         m = tcore_manager_new(p);
 127         ASSERT_TRUE(m);
 128         ret = tcore_server_set_manager(s, m);
 129         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
 130         EXPECT_TRUE(tcore_server_ref_manager(s));
 131
 132         /* add communicator */
 133         c = tcore_communicator_new(p, "test_communicator", &test_communicator_ops);
 134         ASSERT_TRUE(c);
 135
 136         EXPECT_EQ(tcore_communicator_ref_plugin(c), p);
 137         std::cout << "  [communicator] name: " << tcore_communicator_ref_name(c) << std::endl;
 138
 139         char comm_data[] = "comm_data";
 140         ret = tcore_communicator_link_user_data(c, comm_data);
 141         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
 142         std::cout << "  [communicator] user_data: " << (char *)tcore_communicator_ref_user_data(c)<< std::endl;
 143
 144         ret = tcore_server_add_communicator(s, c);
 145         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
 146         EXPECT_TRUE(tcore_server_ref_communicators(s));
 147         EXPECT_EQ(tcore_server_find_communicator(s, "test_communicator"), c);
 148
 149         ret = tcore_communicator_send_response(c, NULL, TRESP_CUSTOM, 0, NULL);
 150         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
 151
 152         ret = tcore_communicator_send_notification(c, NULL, TNOTI_CUSTOM, 0, NULL);
 153         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
 154
 155         UserRequest *ur_comm;
 156
 157         ur_comm = tcore_user_request_new(c, "test_modem_plugin");
 158         ASSERT_TRUE(ur_comm);
 159
 160         ret = tcore_user_request_set_command(ur_comm, TREQ_CUSTOM);
 161         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
 162
 163         tcore_communicator_dispatch_request(c, ur_comm);
 164
 165         ret = tcore_server_remove_communicator(s, c);
 166         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
 167         tcore_communicator_free(c);
 168
 169         /* add storage */
 170         strg = tcore_storage_new(NULL, "test_storage", NULL);
 171         ASSERT_TRUE(strg);
 172         ret = tcore_server_add_storage(s, strg);
 173         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
 174         EXPECT_TRUE(tcore_server_ref_storages(s));
 175
 176         /* find storage */
 177         Storage *ref_strg = tcore_server_find_storage(s, "test_storage");
 178         EXPECT_EQ(ref_strg, strg);
 179
 180         /* add Hal */
 181         h = tcore_hal_new(NULL, "test_hal", NULL, TCORE_HAL_MODE_CUSTOM);
 182         ASSERT_TRUE(h);
 183         ret = tcore_server_add_hal(s, h);
 184         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
 185         EXPECT_TRUE(tcore_server_ref_hals(s));
 186
 187         /* find Hal */
 188         TcoreHal *ref_hal = tcore_server_find_hal(s, "test_hal");
 189         EXPECT_EQ(ref_hal, h);
 190
 191         /* remove Hal */
 192         ret = tcore_server_remove_hal(s, h);
 193         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
 194         tcore_hal_free(h);
 195         h = NULL;
 196
 197         /* register modem plugin*/
 198         modem_plugin = tcore_plugin_new(s, NULL, "test_modem_plugin", NULL);
 199         ASSERT_TRUE(modem_plugin);
 200         TcoreModem *modem = tcore_server_register_modem(s, modem_plugin);
 201         ASSERT_TRUE(modem);
 202
 203         /* Get modem count */
 204         gint modem_count = tcore_server_get_modems_count(s);
 205         std::cout << "  [server] modem count: " << modem_count << std::endl;
 206
 207         EXPECT_TRUE(tcore_server_get_cp_name_list(s));
 208         tcore_server_print_modems(s);
 209
 210         /* Add hook function */
 211         ret = tcore_server_add_request_hook(s, TREQ_CUSTOM, __on_request_hook_callback, NULL);
 212         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
 213         ret = tcore_server_add_notification_hook(s, TNOTI_CUSTOM, __on_notification_hook_callback, NULL);
 214         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
 215
 216         /* dispatch user request */
 217         UserRequest * ur;
 218         ur = tcore_user_request_new(NULL, "test_modem_plugin");
 219         ASSERT_TRUE(ur);
 220         ret = tcore_user_request_set_command(ur, TREQ_CUSTOM);
 221         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
 222         tcore_server_dispatch_request(s, ur);
 223
 224         /* send notification */
 225         tcore_server_send_notification(s, NULL, TNOTI_CUSTOM, 0, NULL);
 226
 227         /* Remove hook function */
 228         ret = tcore_server_remove_request_hook(s, __on_request_hook_callback);
 229         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
 230         ret = tcore_server_remove_notification_hook(s, __on_notification_hook_callback);
 231         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
 232
 233         /* unregister modem plugin */
 234         tcore_server_unload_modem_plugin(s, modem);
 235
 236         /* free server */
 237         tcore_server_free(s);
 238
 239 }
 240
 241 TEST(LIBTCORE_OBJECT, test_object_new)
 242 {
 243         TReturn ret;
 244         CoreObject *co;
 245         TcorePlugin *test_plugin = tcore_plugin_new(NULL, NULL, NULL, NULL) ;
 246         EXPECT_TRUE(test_plugin);
 247
 248         co = tcore_object_new(test_plugin, "test1", NULL);
 249         ASSERT_TRUE(co) << "tcore_object_new() failed" << std::endl;
 250
 251         ret = tcore_object_set_free_hook(co, NULL);
 252         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS) << "tcore_object_set_free_hook() is failed" << std::endl;
 253
 254         EXPECT_EQ(tcore_object_ref_subscription_type(co) , TELEPHONY_SUBSCRIPTION_TYPE_DEFAULT) << "subscription type is not matched" << std::endl;
 255         EXPECT_TRUE(tcore_object_ref_plugin(co));
 256
 257         EXPECT_EQ(tcore_plugin_ref_core_object(test_plugin, CORE_OBJECT_TYPE_DEFAULT), co);
 258         EXPECT_TRUE(tcore_plugin_get_core_objects(test_plugin));
 259         EXPECT_TRUE(tcore_plugin_get_core_objects_bytype(test_plugin, CORE_OBJECT_TYPE_DEFAULT));
 260
 261         char po[] = "test_object";
 262         char *ref_po = NULL;
 263
 264         ret = tcore_object_link_object(co, po);
 265         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS) << "tcore_object_link_object() is failed" << std::endl;
 266         ref_po = (char *)tcore_object_ref_object(co);
 267         std::cout << "  ref_object: " << ref_po << std::endl;
 268         EXPECT_EQ(strcmp(po, ref_po), 0) << "object is not matched" << std::endl;
 269
 270         ret = tcore_object_set_hal(co, NULL);
 271         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS) << "tcore_object_set_hal() is failed" << std::endl;
 272         tcore_object_get_hal(co);
 273
 274         char userdata[] = "test_userdata";
 275         char *ref_userdata = NULL;
 276         ret = tcore_object_link_user_data(co, userdata);
 277         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS) << "tcore_object_link_user_data() is failed" << std::endl;
 278         ref_userdata = (char *)tcore_object_ref_user_data(co);
 279         std::cout << "  ref_userdata: " << ref_userdata<< std::endl;
 280         EXPECT_EQ(strcmp(userdata, ref_userdata), 0) << "userdata is not matched" << std::endl;
 281
 282         ret = tcore_object_set_name(co, "test2");
 283         EXPECT_EQ(TCORE_RETURN_SUCCESS, ret) << "tcore_object_set_name() is failed" << std::endl;
 284
 285         std::cout << "  Name: " << tcore_object_ref_name(co) << std::endl;
 286         EXPECT_EQ(strcmp(tcore_object_ref_name(co), "test2"), 0) << "object name is not matched" << std::endl;
 287
 288         tcore_object_set_type(co, CORE_OBJECT_TYPE_CUSTOM);
 289         EXPECT_EQ(tcore_object_get_type(co) , CORE_OBJECT_TYPE_CUSTOM) << "object type is not matched" << std::endl;
 290
 291         tcore_object_free(co);
 292 }
 293
 294 static int _event1_count = 0;
 295 static int _event2_count = 0;
 296
 297 static gboolean __on_event1(CoreObject *o, const void *event_info, void *user_data)
 298 {
 299         _event1_count++;
 300
 301         EXPECT_TRUE(o);
 302         EXPECT_TRUE(event_info);
 303         EXPECT_EQ((char *)event_info, "ok");
 304
 305         return TRUE;
 306 }
 307 static gboolean __on_event2(CoreObject *o, const void *event_info, void *user_data)
 308 {
 309         _event2_count++;
 310
 311         EXPECT_TRUE(o);
 312         EXPECT_TRUE(event_info);
 313         EXPECT_EQ((char *)event_info, "ok");
 314
 315         return TRUE;
 316 }
 317
 318 static gboolean __on_event3(CoreObject *o, const void *event_info, void *user_data)
 319 {
 320         _event2_count++;
 321
 322         EXPECT_TRUE(o);
 323         EXPECT_TRUE(event_info);
 324         EXPECT_EQ((char *)event_info, "ok");
 325
 326         return TRUE;
 327 }
 328
 329
 330 TEST(LIBTCORE_OBJECT, test_object_callback)
 331 {
 332         CoreObject *co;
 333         TReturn ret;
 334
 335         co = tcore_object_new(NULL, "test", NULL);
 336         ASSERT_TRUE(co) << "tcore_object_new() failed" << std::endl;
 337
 338         /* lifetime: unlimit */
 339         _event1_count = 0;
 340         ret = tcore_object_add_callback(co, "event1", __on_event1, NULL);
 341         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS) << "tcore_object_add_callback() is failed" << std::endl;
 342
 343         ret = tcore_object_emit_callback(co, "event1", "ok");
 344         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS) << "tcore_object_emit_callback() is failed" << std::endl;
 345
 346         ret = tcore_object_emit_callback(co, "event1", "ok");
 347         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS) << "tcore_object_emit_callback() is failed" << std::endl;
 348
 349         EXPECT_EQ(_event1_count, 2) << "_event1_count is not matched" << std::endl;
 350
 351         _event2_count = 0;
 352         ret = tcore_object_add_callback(co, "event2", __on_event2, NULL);
 353         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS) << "tcore_object_add_callback() is failed" << std::endl;
 354
 355         ret = tcore_object_emit_callback(co, "event2", "ok");
 356         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS) << "tcore_object_emit_callback() is failed" << std::endl;
 357
 358         ret = tcore_object_del_callback(co, "event1", __on_event1);
 359         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS) << "tcore_object_del_callback() is failed" << std::endl;
 360
 361         ret = tcore_object_override_callback(co, "event1", __on_event3, NULL);
 362         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS) << "tcore_object_override_callback() is failed" << std::endl;
 363
 364         tcore_object_free(co);
 365 }
 366
 367
 368 static gboolean on_prop_changed(CoreObject *co, const void *event_info, void *user_data)
 369 {
 370         int *mode = (int *)user_data;
 371         GSList *key = (GSList *)event_info;
 372         const char *data;
 373
 374         switch (*mode) {
 375         case 1:
 376                 g_assert(g_slist_length(key) == 1);
 377                 g_assert_cmpstr((char *)key->data, ==, "qqq");
 378                 data = tcore_object_ref_property(co, "qqq");
 379                 g_assert_cmpstr(data, ==, "1234");
 380         break;
 381
 382         case 2:
 383                 g_assert(g_slist_length(key) == 1);
 384                 g_assert_cmpstr((char *)key->data, ==, "qqq");
 385                 data = tcore_object_ref_property(co, "qqq");
 386                 g_assert(data == NULL);
 387         break;
 388
 389         case 3:
 390                 g_assert(g_slist_length(key) == 1);
 391                 g_assert_cmpstr((char *)key->data, ==, "www");
 392                 data = tcore_object_ref_property(co, "www");
 393                 g_assert_cmpstr(data, ==, "heap");
 394         break;
 395
 396         case 4:
 397                 g_assert(g_slist_length(key) == 1);
 398                 g_assert_cmpstr((char *)key->data, ==, "www");
 399                 data = tcore_object_ref_property(co, "www");
 400                 g_assert(data == NULL);
 401         break;
 402
 403         case 5:
 404                 g_assert(g_slist_length(key) == 1);
 405                 g_assert_cmpstr((char *)key->data, ==, "key");
 406                 data = tcore_object_ref_property(co, "key");
 407                 g_assert_cmpstr(data, ==, "1");
 408         break;
 409
 410         case 6:
 411                 g_assert(g_slist_length(key) == 1);
 412                 g_assert_cmpstr((char *)key->data, ==, "key");
 413                 data = tcore_object_ref_property(co, "key");
 414                 g_assert_cmpstr(data, ==, "2");
 415         break;
 416
 417         case 7:
 418                 g_assert(FALSE);
 419         break;
 420
 421         case 8:
 422                 g_assert(g_slist_length(key) == 1);
 423                 g_assert_cmpstr((char *)key->data, ==, "key");
 424                 data = tcore_object_ref_property(co, "key");
 425                 g_assert_cmpstr(data, ==, "2");
 426         break;
 427
 428         case 9:
 429                 g_assert(g_slist_length(key) == 2);
 430                 g_assert_cmpstr((char *)key->data, ==, "foo");
 431                 g_assert_cmpstr((char *)key->next->data, ==, "bar");
 432                 data = tcore_object_ref_property(co, "foo");
 433                 g_assert_cmpstr(data, ==, "1");
 434                 data = tcore_object_ref_property(co, "bar");
 435                 g_assert_cmpstr(data, ==, "2");
 436         break;
 437
 438         case 10:
 439                 g_assert(g_slist_length(key) == 1);
 440                 g_assert_cmpstr((char *)key->data, ==, "foo");
 441                 data = tcore_object_ref_property(co, "foo");
 442                 g_assert(data == NULL);
 443         break;
 444
 445         case 11:
 446                 g_assert(g_slist_length(key) == 2);
 447                 g_assert(g_slist_find_custom(key, "foo", (GCompareFunc)g_strcmp0) != NULL);
 448                 g_assert(CORE_OBJECT_KEY_FIND(key, "bar") != NULL);
 449                 data = tcore_object_ref_property(co, "foo");
 450                 g_assert_cmpstr(data, ==, "1");
 451                 data = tcore_object_ref_property(co, "bar");
 452                 g_assert(data == NULL);
 453         break;
 454
 455         default:
 456                 g_assert(FALSE);
 457         break;
 458         }
 459
 460         /* Set flag to callback invocation success */
 461         *mode = 0;
 462
 463         return TRUE;
 464 }
 465
 466 TEST(LIBTCORE_OBJECT, test_object_property)
 467 {
 468         CoreObject *co;
 469         const char *data;
 470         char *test;
 471         GHashTable *raw;
 472         int mode = 0;
 473         GSList *tmp_list;
 474
 475         co = tcore_object_new(NULL, "test", NULL);
 476         EXPECT_TRUE(co);
 477
 478         tcore_object_add_callback(co, CORE_OBJECT_EVENT_PROPERTY_CHANGED, on_prop_changed, &mode);
 479
 480         raw = tcore_object_ref_property_hash(co);
 481         EXPECT_TRUE(raw);
 482
 483         /* Case: Basic property set */
 484         mode = 1;
 485         tcore_object_set_property(co, "qqq", "1234");
 486         EXPECT_EQ(g_hash_table_size(raw), 1);
 487         EXPECT_EQ(mode, 0);
 488
 489         data = tcore_object_ref_property(co, "qqq");
 490         g_assert_cmpstr(data, ==, "1234");
 491
 492         /* Case: Basic property remove */
 493         mode = 2;
 494         tcore_object_set_property(co, "qqq", NULL);
 495         EXPECT_EQ(g_hash_table_size(raw), 0);
 496         EXPECT_EQ(mode, 0);
 497
 498         data = tcore_object_ref_property(co, "qqq");
 499         EXPECT_TRUE(!data);
 500
 501         /* Case: Malloc property set */
 502         mode = 3;
 503         test = strdup("heap");
 504         tcore_object_set_property(co, "www", test);
 505         EXPECT_EQ(g_hash_table_size(raw), 1);
 506         EXPECT_EQ(mode, 0);
 507         free(test);
 508
 509         data = tcore_object_ref_property(co, "www");
 510         g_assert_cmpstr(data, ==, "heap");
 511
 512         /* Case: Malloc property remove */
 513         mode = 4;
 514         tcore_object_set_property(co, "www", NULL);
 515         EXPECT_EQ(g_hash_table_size(raw), 0);
 516         EXPECT_EQ(mode, 0);
 517
 518         data = tcore_object_ref_property(co, "www");
 519         EXPECT_TRUE(!data);
 520
 521         /* Case: Same key & Different value set */
 522         mode = 5;
 523         tcore_object_set_property(co, "key", "1");
 524         EXPECT_EQ(g_hash_table_size(raw), 1);
 525         EXPECT_EQ(mode, 0);
 526
 527         mode = 6;
 528         tcore_object_set_property(co, "key", "2");
 529         EXPECT_EQ(g_hash_table_size(raw), 1);
 530         EXPECT_EQ(mode, 0);
 531
 532         /* Case: Same key & Same value set => No callback invocation */
 533         mode = 7;
 534         tcore_object_set_property(co, "key", "2");
 535         EXPECT_EQ(g_hash_table_size(raw), 1);
 536         EXPECT_EQ(mode, 7);
 537
 538         /* Case: Same key & Same value set & force event invocation */
 539         mode = 8;
 540         tcore_object_set_property(co, "key", "2");
 541         EXPECT_EQ(g_hash_table_size(raw), 1);
 542
 543         tmp_list = g_slist_append(NULL, (char *)"key");
 544         tcore_object_emit_callback(co, CORE_OBJECT_EVENT_PROPERTY_CHANGED, tmp_list);
 545         EXPECT_EQ(mode, 0);
 546         g_slist_free(tmp_list);
 547
 548         /* Case: Multiple property set */
 549         mode = 9;
 550         tcore_object_set_property(co, "foo", "1", "bar", "2");
 551         EXPECT_EQ(g_hash_table_size(raw), 3);
 552         EXPECT_EQ(mode, 0);
 553
 554         /* Case: Set key without value => same as key with NULL: remove key */
 555         mode = 10;
 556         tcore_object_set_property(co, "foo");
 557         EXPECT_EQ(g_hash_table_size(raw), 2);
 558         EXPECT_EQ(mode, 0);
 559
 560         /* Case: Multiple property set with unset (foo set, bar unset) */
 561         mode = 11;
 562         tcore_object_set_property(co, "foo", "1", "bar");
 563         EXPECT_EQ(g_hash_table_size(raw), 2);
 564         EXPECT_EQ(mode, 0);
 565
 566         tcore_object_free(co);
 567 }
 568
 569 TEST(LIBTCORE_UTIL, test_util_marshal)
 570 {
 571         GHashTable *list;
 572         int value_int;
 573
 574         list = tcore_util_marshal_create();
 575         ASSERT_TRUE(list) << "tcore_util_marshal_create() failed" << std::endl;
 576
 577         value_int = 1;
 578         tcore_util_marshal_add_data(list, "key1", &value_int, TCORE_UTIL_MARSHAL_DATA_INT_TYPE);
 579         ASSERT_TRUE(tcore_util_marshal_get_int(list, "key1") == value_int);
 580
 581         value_int = 2;
 582         tcore_util_marshal_add_data(list, "key2", &value_int, TCORE_UTIL_MARSHAL_DATA_INT_TYPE);
 583         ASSERT_TRUE(tcore_util_marshal_get_int(list, "key2") == value_int);
 584
 585         tcore_util_marshal_destory(list);
 586 }
 587
 588 TEST(LIBTCORE_UTIL, test_util_marshal_serialize)
 589 {
 590         GHashTable *list;
 591         GHashTable *item;
 592         GHashTable *tmp;
 593         gchar *serialized;
 594         int i;
 595         char buf[255];
 596         int value_int;
 597
 598         list = tcore_util_marshal_create();
 599         ASSERT_TRUE(list);
 600
 601         value_int = 1;
 602         tcore_util_marshal_add_data(list, "key1", &value_int, TCORE_UTIL_MARSHAL_DATA_INT_TYPE);
 603         ASSERT_TRUE(tcore_util_marshal_get_int(list, "key1") == value_int);
 604
 605         value_int = 2;
 606         tcore_util_marshal_add_data(list, "key2", &value_int, TCORE_UTIL_MARSHAL_DATA_INT_TYPE);
 607         ASSERT_TRUE(tcore_util_marshal_get_int(list, "key2") == value_int);
 608
 609         const char str[] = "key_string";
 610         tcore_util_marshal_add_data(list, "key3", str, TCORE_UTIL_MARSHAL_DATA_STRING_TYPE);
 611         ASSERT_TRUE(strcmp(tcore_util_marshal_get_string(list, "key3"), str) == 0);
 612
 613         item = tcore_util_marshal_create();
 614         ASSERT_TRUE(item);
 615         tcore_util_marshal_add_data(list, "key_object", item, TCORE_UTIL_MARSHAL_DATA_OBJECT_TYPE);
 616
 617         for (i = 0; i < 3; i++) {
 618                 item = tcore_util_marshal_create();
 619                 ASSERT_TRUE(item);
 620
 621                 value_int = i * 10;
 622                 snprintf(buf, 255, "sub-%d", i);
 623                 tcore_util_marshal_add_data(item, buf, &value_int, TCORE_UTIL_MARSHAL_DATA_INT_TYPE);
 624                 ASSERT_TRUE(tcore_util_marshal_get_int(item, buf) == value_int);
 625
 626                 tcore_util_marshal_add_data(list, buf, item, TCORE_UTIL_MARSHAL_DATA_OBJECT_TYPE);
 627         }
 628
 629         serialized = tcore_util_marshal_serialize(list);
 630         ASSERT_TRUE(serialized);
 631         tcore_util_marshal_destory(list);
 632
 633         tmp = tcore_util_marshal_deserialize_string(serialized);
 634         ASSERT_TRUE(tmp);
 635
 636         free(serialized);
 637
 638         ASSERT_TRUE(tcore_util_marshal_get_int(tmp, "key1") == 1);
 639         ASSERT_TRUE(tcore_util_marshal_get_int(tmp, "key2") == 2);
 640
 641         tcore_util_marshal_destory(tmp);
 642 }
 643
 644 TEST(LIBTCORE_UTIL, test_util_decode_hex)
 645 {
 646         char *hex = (char *)"1A2B3C4D5E6F";
 647         unsigned char expected[] = { 0x1A, 0x2B, 0x3C, 0x4D, 0x5E, 0x6F };
 648         unsigned char *dest;
 649
 650         dest = tcore_util_decode_hex(hex, strlen(hex));
 651         ASSERT_TRUE(memcmp(dest, expected, strlen((char *)dest)) == 0);
 652         free(dest);
 653 }
 654
 655 TEST(LIBTCORE_UTIL, test_util_hex_dump)
 656 {
 657         /* AT+CRSM=command>[, <fileid>[, <P1>, <P2>, <P3>[, <data>[, <pathid>]]]] */
 658         char *cmd_str = g_strdup_printf("AT+CRSM=192, 28482");
 659
 660         tcore_util_hex_dump("    ", strlen(cmd_str), (void *)cmd_str);
 661
 662         /* Free resources */
 663         g_free(cmd_str);
 664
 665 }
 666
 667 TEST(LIBTCORE_UTIL, test_util_gsm7bit)
 668 {
 669         unsigned char *dest;
 670         unsigned char packed[] = { 0xE8, 0x32, 0x9B, 0xFD, 0x06, 0x00 };
 671
 672         std::cout << std::endl;
 673         /* unpack packed-data('hello') */
 674         dest = tcore_util_unpack_gsm7bit(packed, 0x05);
 675         g_assert_cmpstr((char *)dest, ==, "hello");
 676         free(dest);
 677
 678         /* pack 'hello' */
 679         dest = tcore_util_pack_gsm7bit((unsigned char *)"hello", strlen("hello"));
 680
 681         if (dest) {
 682                 g_assert(memcmp(packed, dest, strlen((char *)dest)) == 0);
 683                 free(dest);
 684         }
 685 }
 686
 687 TEST(LIBTCORE_UTIL, test_util_get_version)
 688 {
 689         char *version;
 690
 691         version = tcore_util_get_version();
 692         ASSERT_TRUE(version) << "tcore_util_get_version() failed" << std::endl;
 693
 694         if (version) {
 695                 std::cout << "  libtcore version: " << version << std::endl;
 696                 free(version);
 697         }
 698 }
 699
 700 TEST(LIBTCORE_UTIL, test_util_set_log)
 701 {
 702         tcore_util_set_log(FALSE);
 703         tcore_util_set_log(TRUE);
 704 }
 705
 706 TEST(LIBTCORE_UTIL, test_util_is_country_NA)
 707 {
 708         char plmn1[] = "31033";
 709         ASSERT_TRUE(tcore_util_is_country_NA(plmn1) == TRUE);
 710
 711         char plmn2[] = "45001";
 712         ASSERT_TRUE(tcore_util_is_country_NA(plmn2) == FALSE);
 713 }
 714
 715 TEST(LIBTCORE_AT, test_at_buf_write)
 716 {
 717 #define BUF_SIZE 1024
 718         TcoreAT *at;
 719         TReturn ret;
 720         char *msg_1 = (char *)"ATOZ";
 721         char msg_2[BUF_SIZE + 1];
 722
 723         at = tcore_at_new(NULL);
 724         ASSERT_TRUE(at);
 725
 726         ret = tcore_at_buf_write(at, strlen(msg_1), msg_1);
 727         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS) << "tcore_at_buf_write() is failed" << std::endl;
 728
 729         memset(msg_2, '1', BUF_SIZE);
 730         msg_2[BUF_SIZE] = '\0';
 731         ret = tcore_at_buf_write(at, strlen(msg_2), msg_2);
 732         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS) << "tcore_at_buf_write() is failed" << std::endl;
 733
 734         tcore_at_free(at);
 735 }
 736
 737 TEST(LIBTCORE_AT, test_at_tok)
 738 {
 739         GSList *tokens;
 740         char *buf;
 741
 742         /* test unsolicited message */
 743         tokens = tcore_at_tok_new("CSQ: 31, 99");
 744         EXPECT_TRUE(tokens);
 745
 746         g_assert_cmpstr((char *)g_slist_nth_data(tokens, 0), ==, "31");
 747         g_assert_cmpstr(tcore_at_tok_nth(tokens, 1), ==, "99");;
 748         EXPECT_TRUE(!g_slist_nth_data(tokens, 2));
 749
 750         tcore_at_tok_free(tokens);
 751
 752         /* test sub token (list type) */
 753         tokens = tcore_at_tok_new("(2, \"T-Meego\", \"TTAU\", \"23401\", 2)");
 754         ASSERT_TRUE(tokens);
 755
 756         g_assert_cmpstr((char *)g_slist_nth_data(tokens, 0), ==, "2");
 757         g_assert_cmpstr(tcore_at_tok_nth(tokens, 1), ==, "\"T-Meego\"");
 758         g_assert_cmpstr(tcore_at_tok_nth(tokens, 2), ==, "\"TTAU\"");
 759         g_assert_cmpstr(tcore_at_tok_nth(tokens, 3), ==, "\"23401\"");
 760         g_assert_cmpstr(tcore_at_tok_nth(tokens, 4), ==, "2");
 761
 762         /* test extract */
 763         buf = tcore_at_tok_extract(tcore_at_tok_nth(tokens, 2));
 764         EXPECT_TRUE(buf);
 765         g_assert_cmpstr(buf, ==, "TTAU");
 766         free(buf);
 767
 768         tcore_at_tok_free(tokens);
 769
 770         /* test extract */
 771         buf = tcore_at_tok_extract("(haha)");
 772         EXPECT_TRUE(buf);
 773         g_assert_cmpstr(buf, ==, "haha");
 774         free(buf);
 775
 776         /* test extract */
 777         buf = tcore_at_tok_extract("(a)");
 778         EXPECT_TRUE(buf);
 779         g_assert_cmpstr(buf, ==, "a");
 780         free(buf);
 781
 782         /* test extract */
 783         buf = tcore_at_tok_extract("()");
 784         EXPECT_TRUE(buf);
 785         g_assert_cmpstr(buf, ==, "");
 786         free(buf);
 787
 788         /* test extract */
 789         buf = tcore_at_tok_extract("(");
 790         EXPECT_TRUE(buf);
 791         g_assert_cmpstr(buf, ==, "(");
 792         free(buf);
 793
 794         /* test extract */
 795         buf = tcore_at_tok_extract(")");
 796         EXPECT_TRUE(buf);
 797         g_assert_cmpstr(buf, ==, ")");
 798         free(buf);
 799
 800         /* test extract */
 801         buf = tcore_at_tok_extract("");
 802         EXPECT_TRUE(buf);
 803         g_assert_cmpstr(buf, ==, "");
 804         free(buf);
 805 }
 806
 807 TEST(LIBTCORE_AT, test_at_reqeust)
 808 {
 809         TcoreAT *at;
 810         TcoreATRequest *req;
 811         TReturn ret;
 812         char *msg;
 813         gboolean bSuccess;
 814
 815         at = tcore_at_new(NULL);
 816         ASSERT_TRUE(at);
 817
 818         req = tcore_at_request_new("AT+CMGR=1", "+CMGR", TCORE_AT_PDU);
 819         ASSERT_TRUE(req);
 820
 821         ret = tcore_at_set_request(at, req, FALSE);
 822         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
 823
 824         TcoreATRequest *getReq = tcore_at_get_request(at);
 825         if (getReq && getReq->cmd)
 826                 std::cout << "  ATRequest->cmd : " << getReq->cmd << std::endl;
 827         else
 828                 std::cout << "  ATRequest is none" << std::endl;
 829
 830         msg = (char *)"+CMGR: 1,,105\r\n12345678901234567890\r\nOK\r\n";
 831         bSuccess = tcore_at_process(at, strlen(msg), msg);
 832         EXPECT_EQ(bSuccess, TRUE);
 833
 834         TcoreATResponse *getResp = tcore_at_get_response(at);
 835         if (getResp && getResp->final_response)
 836                 std::cout << "  ATResponse->final_response : " << getResp->final_response<< std::endl;
 837         else
 838                 std::cout << "  ATResponse is none" << std::endl;
 839
 840         tcore_at_free(at);
 841 }
 842
 843 static gboolean __on_atcmd_cmti(TcoreAT *at, const GSList *lines, void *user_data)
 844 {
 845         int *checked = (int *)user_data;
 846
 847         *checked = 1;
 848
 849         std::cout <<"   data = " << (char *)lines->data << std::endl;
 850
 851         return TRUE;
 852 }
 853
 854 static gboolean __on_atcmd_cmt(TcoreAT *at, const GSList *lines, void *user_data)
 855 {
 856         int *checked = (int *)user_data;
 857
 858         if (g_slist_length((GSList *)lines) != 2) {
 859                 printf("invalid message\n");
 860                 return TRUE;
 861         }
 862
 863         *checked = 2;
 864
 865         std::cout <<"   data1 = " << (char *)lines->data << std::endl;
 866         std::cout <<"   data2 = " << (char *)lines->next->data << std::endl;
 867
 868         return TRUE;
 869 }
 870
 871 static gboolean __on_atcmd_test(TcoreAT *at, const GSList *lines, void *user_data)
 872 {
 873         std::cout <<"   __on_atcmd_test() data = " << (char *)lines->data << std::endl;
 874
 875         return TRUE;
 876 }
 877
 878
 879 TEST(LIBTCORE_AT, test_at_notificatoin)
 880 {
 881         TcoreAT *at;
 882         TReturn ret;
 883         int checked = 0;
 884         char *msg = NULL;
 885         gboolean bRet;
 886
 887         at = tcore_at_new(NULL);
 888         ASSERT_TRUE(at);
 889
 890         ret = tcore_at_add_notification(at, "+CMTI:", FALSE, __on_atcmd_cmti, &checked);
 891         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
 892
 893         ret = tcore_at_add_notification(at, "+CMT:", TRUE, __on_atcmd_cmt, &checked);
 894         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
 895
 896         /* Non type PDU message */
 897         msg = (char *)"+CMTI: \"SM\", 1\r\n";
 898         bRet = tcore_at_process(at, strlen(msg), msg);
 899         EXPECT_EQ(bRet, FALSE);
 900
 901         /* callback check */
 902         EXPECT_EQ(checked, 1);
 903
 904         /* Completed PDU message */
 905         msg = (char *)"+CMT: 19\r\n038121F3100481214301112170137192410404F17B590E\r\n";
 906         bRet = tcore_at_process(at, strlen(msg), msg);
 907         EXPECT_EQ(bRet, FALSE);
 908
 909         /* callback check */
 910         EXPECT_EQ(checked, 2);
 911
 912
 913         /* Split PDU message */
 914         checked = 0;
 915         msg = (char *)"+CMT: 19\r\n";
 916         bRet = tcore_at_process(at, strlen(msg), msg);
 917         EXPECT_EQ(bRet, FALSE);
 918
 919         /* callback check */
 920         EXPECT_EQ(checked, 0);
 921
 922         msg = (char *)"038121F310";
 923         bRet = tcore_at_process(at, strlen(msg), msg);
 924         EXPECT_EQ(bRet, FALSE);
 925
 926         /* callback check */
 927         EXPECT_EQ(checked, 0);
 928
 929         msg = (char *)"0481214301112170137192410404F17B590E\r\n";
 930         bRet = tcore_at_process(at, strlen(msg), msg);
 931         EXPECT_EQ(bRet, FALSE);
 932
 933         ret = tcore_at_add_notification(at, "+test:", FALSE, __on_atcmd_test, NULL);
 934         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
 935
 936         /* Non type PDU message */
 937         msg = (char *)"+test: \"TEST\", 1\r\n";
 938         bRet = tcore_at_process(at, strlen(msg), msg);
 939         EXPECT_EQ(bRet, FALSE);
 940
 941         ret = tcore_at_remove_notification(at, "+test:", __on_atcmd_test);
 942
 943         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
 944
 945         /* callback check */
 946         EXPECT_EQ(checked, 2);
 947
 948 }
 949
 950 static enum tcore_hook_return __on_send_hook(TcoreHal *hal, guint data_len, void *data, void *user_data)
 951 {
 952         std::cout << "  __on__send_hook()" << std::endl;
 953         return TCORE_HOOK_RETURN_CONTINUE;
 954 }
 955
 956 int g_flag;
 957 static void  __on_recv_callback(TcoreHal *h, unsigned int data_len, const void *data, void *user_data)
 958 {
 959         g_assert(data_len == 3);
 960         g_assert_cmpstr((char *)data, ==, "123");
 961         std::cout << "  hal_recv_callback()" << std::endl;
 962
 963         g_flag++;
 964 }
 965
 966
 967 TEST(LIBTCORE_HAL, test_hal_callback)
 968 {
 969         TcoreHal *h;
 970
 971         h = tcore_hal_new(NULL, "test_hal", NULL, TCORE_HAL_MODE_CUSTOM);
 972         ASSERT_TRUE(h);
 973
 974         TReturn ret;
 975         ret = tcore_hal_set_name(h, "test_device1");
 976         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
 977
 978         char *hal_name = tcore_hal_get_name(h);
 979         if(hal_name) {
 980                 std::cout << "  HAL name : " << hal_name << std::endl;
 981                 free(hal_name);
 982                 hal_name = NULL;
 983         }
 984
 985         ret = tcore_hal_set_name(h, "test_device2");
 986         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
 987
 988         hal_name = tcore_hal_ref_name(h);
 989         if(hal_name)
 990                 std::cout << "  HAL name : " << hal_name << std::endl;
 991
 992
 993         TcoreAT *hal_at = tcore_hal_get_at(h);
 994         EXPECT_TRUE(!hal_at);
 995
 996         ret = tcore_hal_set_mode(h, TCORE_HAL_MODE_AT);
 997         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
 998
 999         int hal_mode = tcore_hal_get_mode(h);
1000         EXPECT_EQ(hal_mode, TCORE_HAL_MODE_AT);
1001         std::cout << "  HAL mode : TCORE_HAL_MODE_AT" << std::endl;
1002
1003         ret = tcore_hal_set_mode(h, TCORE_HAL_MODE_CUSTOM);
1004         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1005         std::cout << "  HAL mode : TCORE_HAL_MODE_CUSTOM" << std::endl;
1006
1007         hal_mode = tcore_hal_get_mode(h);
1008         EXPECT_EQ(hal_mode, TCORE_HAL_MODE_CUSTOM);
1009
1010         char userdata[] = "haltest_userdata";
1011         char *ref_userdata = NULL;
1012         ret = tcore_hal_link_user_data(h, userdata);
1013         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS) << "tcore_hal_link_user_data() is failed" << std::endl;
1014
1015         ref_userdata = (char *)tcore_hal_ref_user_data(h);
1016         std::cout << "  ref_userdata: " << ref_userdata<< std::endl;
1017         EXPECT_EQ(strcmp(userdata, ref_userdata), 0) << "userdata is not matched" << std::endl;
1018
1019         ret = tcore_hal_set_power_state(h, TRUE);
1020         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1021
1022         gboolean power_state = tcore_hal_get_power_state(h);
1023         EXPECT_EQ(power_state, TRUE);
1024         std::cout << "  HAL power state : " <<power_state << std::endl;
1025
1026         tcore_hal_add_recv_callback(h, __on_recv_callback, NULL);
1027
1028         g_flag = 0;
1029         tcore_hal_emit_recv_callback(h, 3, "123");
1030         EXPECT_EQ(g_flag, 1);
1031
1032         tcore_hal_remove_recv_callback(h, __on_recv_callback);
1033
1034         g_flag = 0;
1035         tcore_hal_emit_recv_callback(h, 3, "123");
1036         EXPECT_EQ(g_flag, 0);
1037
1038         tcore_hal_free(h);
1039 }
1040
1041 static TReturn __hal_power(TcoreHal *hal, gboolean enable)
1042 {
1043         std::cout << "  __hal_power(): enable = " << enable << std::endl;
1044         return TCORE_RETURN_SUCCESS;
1045 }
1046
1047 static TReturn __hal_send(TcoreHal *hal, unsigned int data_len, void *data)
1048 {
1049         std::cout << "  __hal_send()" << std::endl;
1050         return TCORE_RETURN_SUCCESS;
1051 }
1052
1053 static TReturn __hal_setup_netif(CoreObject *co, TcoreHalSetupNetifCallback func, void *user_data,
1054         guint cid, gboolean enable)
1055 {
1056         std::cout << "  __hal_setup_netif()" << std::endl;
1057         return TCORE_RETURN_SUCCESS;
1058 }
1059
1060 static TReturn __hal_control_nvdata(TcoreHal *hal, int option)
1061 {
1062         std::cout << "  __hal_control_nvdata() : option = " << option << std::endl;
1063         return TCORE_RETURN_SUCCESS;
1064 }
1065
1066 static TReturn __hal_reset(TcoreHal *hal, int option)
1067 {
1068         std::cout << "  __hal_reset(): option = " << option << std::endl;
1069         return TCORE_RETURN_SUCCESS;
1070 }
1071
1072 static struct tcore_hal_operations test_hal_ops = {
1073         .power = __hal_power,
1074         .send = __hal_send,
1075         .setup_netif = __hal_setup_netif,
1076         .control_nvdata = __hal_control_nvdata,
1077         .reset = __hal_reset,
1078 };
1079
1080
1081 TEST(LIBTCORE_HAL, test_hal_pending)
1082 {
1083         TcoreHal *h;
1084         TcorePending *pending1;
1085         TcorePending *pending2;
1086         TcorePending *pending3;
1087         TcorePending *pending = NULL;
1088         TReturn ret;
1089
1090         h = tcore_hal_new(NULL, "test_hal_queue", &test_hal_ops, TCORE_HAL_MODE_CUSTOM);
1091         ASSERT_TRUE(h);
1092
1093         ret = tcore_hal_set_power_state(h, TRUE);
1094         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1095
1096         /* first item */
1097         pending1 = tcore_pending_new(NULL, 1);
1098         ASSERT_TRUE(pending1);
1099
1100         /* set priority */
1101         tcore_pending_set_priority(pending1, TCORE_PENDING_PRIORITY_IMMEDIATELY);
1102
1103         /* get priority */
1104         enum tcore_pending_priority result_priority;
1105         ret = tcore_pending_get_priority(pending1,  &result_priority);
1106         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1107         EXPECT_EQ(result_priority, TCORE_PENDING_PRIORITY_IMMEDIATELY);
1108
1109         /* get pending id */
1110         unsigned int id = tcore_pending_get_id(pending1);
1111         std::cout << "  pending1 id = " << id << std::endl;
1112
1113         /* get pending send status */
1114         gboolean send_status;
1115         ret = tcore_pending_get_send_status(pending1, &send_status);
1116         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1117         std::cout << "  pending1 send_status = " << send_status << std::endl;
1118
1119         /* second item */
1120         pending2 = tcore_pending_new(NULL, 1);
1121         ASSERT_TRUE(pending2);
1122         tcore_pending_set_auto_free_status_after_sent(pending2, TRUE);
1123
1124         gboolean auto_free_status = tcore_pending_get_auto_free_status_after_sent(pending2);
1125         std::cout << "  pending2 audo_free_status = " << auto_free_status << std::endl;
1126         EXPECT_EQ(auto_free_status, TRUE);
1127
1128         /* set pending data */
1129         char pending_data1[] = "pending_data1";
1130         ret = tcore_pending_set_request_data(pending2, strlen(pending_data1), pending_data1);
1131         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1132
1133         /* get pending data */
1134         unsigned int data_len;
1135         char *ref_data = (char *)tcore_pending_ref_request_data(pending2, &data_len);
1136         EXPECT_EQ(strcmp(pending_data1, ref_data), 0);
1137         std::cout << "  pending2 data = " << ref_data << std::endl;
1138
1139         /* set pending data */
1140         char pending_data2[] = "pending_data2";
1141         ret = tcore_pending_set_request_data(pending2, strlen(pending_data2), pending_data2);
1142         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1143
1144         /* get pending data */
1145         ref_data = (char *)tcore_pending_ref_request_data(pending2, &data_len);
1146         EXPECT_EQ(strcmp(pending_data2, ref_data), 0);
1147         std::cout << "  pending2 data = " << ref_data << std::endl;
1148
1149         /* third item */
1150         pending3 = tcore_pending_new(NULL, 1);
1151         ASSERT_TRUE(pending3);
1152         tcore_pending_set_priority(pending3, TCORE_PENDING_PRIORITY_IMMEDIATELY);
1153
1154         ret = tcore_pending_set_timeout(pending3, 5000);
1155         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1156
1157         unsigned int timeout = tcore_pending_get_timeout(pending3);
1158         EXPECT_EQ(timeout, 5000);
1159         std::cout << "  pending3 timeout = " << timeout << std::endl;
1160
1161         /* send pending1 */
1162         ret = tcore_hal_send_request(h, pending1);
1163         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1164
1165         /* send pending2 -> queue */
1166         ret = tcore_hal_send_request(h, pending2);
1167         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1168
1169         ret = tcore_hal_add_send_hook(h, __on_send_hook, NULL);
1170         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1171
1172         EXPECT_EQ(tcore_hal_send_data(h, 0, NULL), TCORE_RETURN_SUCCESS);
1173
1174         ret = tcore_hal_remove_send_hook(h, __on_send_hook);
1175         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1176
1177         /* remove pending1 */
1178         ret = tcore_hal_dispatch_response_data(h, 1, 0, NULL);
1179         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1180
1181         /* check next pending */
1182         pending = tcore_queue_ref_pending_by_id(tcore_hal_ref_queue(h), 1);
1183         EXPECT_EQ(pending, pending2);
1184
1185         /* force send */
1186         tcore_hal_send_force(h);
1187
1188         /* check next pending (pending2 is auto free) */
1189         pending = tcore_queue_ref_pending_by_id(tcore_hal_ref_queue(h), 1);
1190         EXPECT_TRUE(!pending);
1191
1192         /* send pending3 */
1193         ret = tcore_hal_send_request(h, pending3);
1194         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1195
1196         pending = tcore_queue_ref_pending_by_id(tcore_hal_ref_queue(h), 1);
1197         EXPECT_EQ(pending, pending3);
1198
1199         /* remove pending3 */
1200         ret = tcore_hal_dispatch_response_data(h, 1, 0, NULL);
1201         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1202
1203         /* check next pending (no more pending) */
1204         pending = tcore_queue_ref_pending_by_id(tcore_hal_ref_queue(h), 1);
1205         EXPECT_TRUE(!pending);
1206
1207         ret = tcore_hal_setup_netif(h, NULL, NULL, NULL, 0, FALSE);
1208         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1209
1210         ret = tcore_hal_set_power(h, TRUE);
1211         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1212
1213         ret = tcore_hal_control_nvdata(h, 2);
1214         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1215
1216         ret = tcore_hal_reset(h, 1);
1217         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1218
1219         TcorePlugin *ref_plugin = tcore_hal_ref_plugin(h);
1220         EXPECT_TRUE(!ref_plugin);
1221
1222         tcore_hal_free(h);
1223 }
1224
1225 TEST(LIBTCORE_QUEUE, test_queue_push)
1226 {
1227         TcoreHal *h;
1228         TcoreQueue *q;
1229         TcorePending *pending1;
1230         TcorePending *pending2;
1231         TcorePending *pending3;
1232         TcorePending *pending4;
1233         TcorePending *pending5;
1234         TcorePending *pending = NULL;
1235         TReturn ret;
1236
1237         h = tcore_hal_new(NULL, "test_hal_for_queue", NULL, TCORE_HAL_MODE_CUSTOM);
1238         ASSERT_TRUE(h);
1239
1240         q = tcore_queue_new(h);
1241         ASSERT_TRUE(q);
1242
1243         TcoreHal *ref_hal = tcore_queue_ref_hal(q);
1244         EXPECT_EQ(ref_hal, h);
1245         std::cout << "  q's reference hal is matched with h " << std::endl;
1246
1247         /* first item */
1248         pending1 = tcore_pending_new(NULL, 1);
1249         ASSERT_TRUE(pending1);
1250         tcore_pending_set_priority(pending1, TCORE_PENDING_PRIORITY_IMMEDIATELY);
1251
1252         ret = tcore_queue_push(q, pending1);
1253         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1254         std::cout << "  pending1 is pushed into queue successufully " << std::endl;
1255
1256         /* second item */
1257         pending2 = tcore_pending_new(NULL, 1);
1258         ASSERT_TRUE(pending2);
1259
1260         ret = tcore_queue_push(q, pending2);
1261         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1262         std::cout << "  pending2 is pushed into queue successufully " << std::endl;
1263
1264         /* third item, but push to second item position */
1265         pending3 = tcore_pending_new(NULL, 1);
1266         ASSERT_TRUE(pending3);
1267         tcore_pending_set_priority(pending3, TCORE_PENDING_PRIORITY_IMMEDIATELY);
1268
1269         ret = tcore_queue_push(q, pending3);
1270         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1271         std::cout << "  pending3 is pushed into queue successufully " << std::endl;
1272
1273         pending = tcore_queue_ref_next_pending(q);
1274         EXPECT_EQ(pending, pending1);
1275         std::cout << "  tcore_queue_ref_next_pending is pending1" << std::endl;
1276
1277         TcorePending *head = tcore_queue_ref_head(q);
1278         EXPECT_EQ(head, pending1);
1279         std::cout << "  head is pending1" << std::endl;
1280
1281         TcorePending *tail = tcore_queue_ref_tail(q);
1282         EXPECT_EQ(tail, pending2);
1283         std::cout << "  tail is pending2" << std::endl;
1284
1285         unsigned int q_len = tcore_queue_get_length(q);
1286         std::cout << "  queue length is " << q_len << std::endl;
1287
1288         unsigned int q_normal_len = tcore_queue_get_normal_length(q);
1289         std::cout << "  queue normal length is " << q_normal_len << std::endl;
1290
1291         /* pop test (order by priority) */
1292         pending = tcore_queue_pop_by_id(q, 1);
1293         EXPECT_EQ(pending, pending1);
1294         std::cout << "  pending1 is poped from queue successufully " << std::endl;
1295         tcore_pending_free(pending);
1296
1297         pending = tcore_queue_pop_by_id(q, 1);
1298         EXPECT_EQ(pending, pending3);
1299         std::cout << "  pending3 is poped from queue successufully " << std::endl;
1300         tcore_pending_free(pending);
1301
1302         pending = tcore_queue_pop_by_id(q, 1);
1303         EXPECT_EQ(pending, pending2);
1304         std::cout << "  pending2 is poped from queue successufully " << std::endl;
1305         tcore_pending_free(pending);
1306
1307         /* 4th item push */
1308         pending4 = tcore_pending_new(NULL, 1);
1309         ASSERT_TRUE(pending4);
1310
1311         ret = tcore_queue_push(q, pending4);
1312         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1313         std::cout << "  pending4 is pushed into queue successufully " << std::endl;
1314         TcorePlugin *ref_plugin = tcore_pending_ref_plugin(pending4);
1315         EXPECT_TRUE(!ref_plugin);
1316         CoreObject *ref_co = tcore_pending_ref_core_object(pending4);
1317         EXPECT_TRUE(!ref_co);
1318
1319         /* 5th item push */
1320         pending5 = tcore_pending_new(NULL, 1);
1321         ASSERT_TRUE(pending5);
1322
1323         ret = tcore_queue_push(q, pending5);
1324         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1325         std::cout << "  pending5 is pushed into queue successufully " << std::endl;
1326
1327         /* pop by pending */
1328         pending = tcore_queue_pop_by_pending(q, pending4);
1329         EXPECT_EQ(pending, pending4);
1330         std::cout << "  pending4 is poped from queue successufully " << std::endl;
1331         tcore_pending_free(pending);
1332
1333         /* pop head pending */
1334         pending = tcore_queue_pop(q);
1335         EXPECT_EQ(pending, pending5);
1336         std::cout << "  pending5 is poped from queue successufully " << std::endl;
1337         tcore_pending_free(pending);
1338
1339         tcore_queue_free(q);
1340         tcore_hal_free(h);
1341 }
1342
1343 TEST(LIBTCORE_QUEUE, test_user_request_new)
1344 {
1345         UserRequest *ur;
1346         TReturn ret;
1347
1348         ur = tcore_user_request_new(NULL, "test_user_request");
1349         ASSERT_TRUE(ur);
1350
1351         /* ref user request */
1352         tcore_user_request_ref(ur);
1353
1354         /* unref user request */
1355         tcore_user_request_unref(ur);
1356
1357         /* get modem name of user request */
1358         char *modem_name = tcore_user_request_get_modem_name(ur);
1359         std::cout << "  ur modem name = " << modem_name << std::endl;
1360
1361         /* set userinfo of user request */
1362         char user_info[] = "test_userinfo";
1363         ret = tcore_user_request_set_user_info(ur, user_info);
1364         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1365
1366         /* get userinfo */
1367         char *ref_user_info = (char *)tcore_user_request_ref_user_info(ur);
1368         std::cout << "  ur user_info = " << ref_user_info << std::endl;
1369
1370         /* set data of user request */
1371         char data[] = "test_data";
1372         ret = tcore_user_request_set_data(ur, strlen(data), data);
1373         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1374
1375         /* get data */
1376         unsigned int data_len;
1377         char *ref_data = (char *)tcore_user_request_ref_data(ur, &data_len);
1378         std::cout << "  ur data_length = " << data_len << " data = " << ref_data << std::endl;
1379
1380         /* set metainfo of user request */
1381         char metainfo[] = "test_metainfo";
1382         ret = tcore_user_request_set_metainfo(ur, strlen(metainfo), metainfo);
1383         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1384
1385         /* get metainfo */
1386         unsigned int metainfo_len;
1387         char *ref_metainfo = (char *)tcore_user_request_ref_metainfo(ur, &metainfo_len);
1388         std::cout<< "   ur metainfo_len = " << metainfo_len << " metainfo = " << ref_metainfo << std::endl;
1389
1390         tcore_user_request_free(ur);
1391
1392 }
1393
1394 static void __on_pending_send_callback(TcorePending *pending, gboolean result, void *user_data)
1395 {
1396         std::cout << "  __on_pending_send_callback() result =" << result << std::endl;
1397 }
1398
1399 int g_response_flag = 0;
1400 static void __on_pending_response_callback(TcorePending *pending, int data_len, const void *data, void *user_data)
1401 {
1402         std::cout << "  __on_pending_response_callback()" << std::endl;
1403         g_response_flag++;
1404
1405         if (data_len > 0 && data) {
1406                 char *resp_data = (char *)data;
1407                 std::cout << "  response data = " << resp_data << std::endl;
1408         }
1409 }
1410
1411 static void __on_pending_timeout_callback(TcorePending *p, void *user_data)
1412 {
1413         std::cout << "  __on_pending_timeout_callback()" << std::endl;
1414 }
1415
1416 static void __on_ur_free_hook(UserRequest *ur)
1417 {
1418         struct dbus_request_info *user_info;
1419
1420         std::cout << "  _on_ur_free_hook()" << std::endl;
1421
1422         user_info = (struct dbus_request_info *)tcore_user_request_ref_user_info(ur);
1423         if (user_info)
1424                 free(user_info);
1425 }
1426
1427 static void __on_ur_response_hook(UserRequest *ur, enum tcore_response_command command,
1428                                   unsigned int data_len, const void *data, void *user_data)
1429 {
1430         std::cout << "  __on_ur_response_hook()" << std::endl;
1431
1432         if (data_len > 0 && data) {
1433                 char *resp_data = (char *)data;
1434                 std::cout << "  response data = " << resp_data << std::endl;
1435         }
1436 }
1437
1438 TEST(LIBTCORE_QUEUE, test_hal_queue_callback)
1439 {
1440         TcoreHal *h;
1441         TcorePending *pending1;
1442         TcorePending *pending2;
1443         TcorePending *pending3;
1444         TcorePending *p;
1445         TReturn ret;
1446         UserRequest *ur1;
1447         UserRequest *ur2;
1448
1449         h = tcore_hal_new(NULL, "test_hal_queue_callback", &test_hal_ops, TCORE_HAL_MODE_CUSTOM);
1450         ASSERT_TRUE(h);
1451
1452         ret = tcore_hal_set_power_state(h, TRUE);
1453         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1454
1455         /* first item */
1456         ur1 = tcore_user_request_new(NULL, NULL);
1457         ASSERT_TRUE(ur1);
1458
1459         ret = tcore_user_request_set_command(ur1, TREQ_NETWORK_SEARCH);
1460         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1461
1462         pending1 = tcore_pending_new(NULL, 1);
1463         ASSERT_TRUE(pending1);
1464
1465         tcore_pending_set_response_callback(pending1, __on_pending_response_callback, NULL);
1466         tcore_pending_link_user_request(pending1, ur1);
1467
1468         ret = tcore_hal_send_request(h, pending1);
1469         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1470
1471         /* set send callback */
1472         ret = tcore_pending_set_send_callback(pending1, __on_pending_send_callback, NULL);
1473         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1474
1475         /* force update send state */
1476         ret = tcore_pending_emit_send_callback(pending1, TRUE);
1477         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1478
1479         /* set timeout callback */
1480         ret = tcore_pending_set_timeout_callback(pending1, __on_pending_timeout_callback, NULL);
1481         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1482
1483         /* emit timeout callback */
1484         ret = tcore_pending_emit_timeout_callback(pending1);
1485         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1486
1487         /* second item */
1488         ur2 = tcore_user_request_new(NULL, NULL);
1489         ASSERT_TRUE(ur2);
1490
1491         /* set command on user_request */
1492         ret = tcore_user_request_set_command(ur2, TREQ_NETWORK_SEARCH);
1493         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1494
1495         /* get command */
1496         EXPECT_EQ(tcore_user_request_get_command(ur2), TREQ_NETWORK_SEARCH);
1497         std::cout << "  ur2 command  = TREQ_NETWORK_SEARCH" << std::endl;
1498
1499         pending2 = tcore_pending_new(NULL, 1);
1500         ASSERT_TRUE(pending2);
1501
1502         ret = tcore_pending_set_response_callback(pending2, __on_pending_response_callback, NULL);
1503         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1504
1505         char test_emit_resp[] = "test_emit_response";
1506         ret = tcore_pending_emit_response_callback(pending2, strlen(test_emit_resp), test_emit_resp);
1507         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1508
1509         ret = tcore_pending_link_user_request(pending2, ur2);
1510         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1511
1512         UserRequest *ref_ur = tcore_pending_ref_user_request(pending2);
1513         EXPECT_EQ(ref_ur, ur2);
1514
1515         /* set free hook callback */
1516         ret = tcore_user_request_set_free_hook(ur2, __on_ur_free_hook);
1517         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1518
1519         /* set response hook callback */
1520         ret = tcore_user_request_set_response_hook(ur2, __on_ur_response_hook, NULL);
1521         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1522
1523         /* ref communicator */
1524         EXPECT_TRUE(!tcore_user_request_ref_communicator(ur2));
1525
1526         ret = tcore_hal_send_request(h, pending2);
1527         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1528
1529         /* third item */
1530         pending3 = tcore_pending_new(NULL, 1);
1531         ASSERT_TRUE(pending3);
1532
1533         ret = tcore_hal_send_request(h, pending3);
1534         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1535
1536
1537         /* search */
1538         p = tcore_queue_search_by_command(tcore_hal_ref_queue(h), TREQ_NETWORK_SEARCH, TRUE);
1539         EXPECT_EQ(p, pending1);
1540
1541         p = tcore_queue_search_by_command(tcore_hal_ref_queue(h), TREQ_NETWORK_SEARCH, FALSE);
1542         EXPECT_EQ(p, pending2);
1543
1544         char resp_custom[] = "test_resp";
1545         ret = tcore_user_request_send_response(ur2, TRESP_CUSTOM, strlen(resp_custom), resp_custom);
1546         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1547
1548         /* cancel */
1549         g_response_flag = 0;
1550         ret = tcore_queue_cancel_pending_by_command(tcore_hal_ref_queue(h), TREQ_NETWORK_SEARCH);
1551         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1552
1553         EXPECT_EQ(g_response_flag, 2);
1554
1555         tcore_hal_free(h);
1556
1557 }
1558
1559 static enum tcore_manager_return __on_manager_request_handler(Manager *manager, UserRequest *ur)
1560 {
1561         struct dbus_request_info *user_info;
1562
1563         std::cout << "  __on_manager_request_handler()" << std::endl;
1564
1565         user_info = (struct dbus_request_info *)tcore_user_request_ref_user_info(ur);
1566         if (user_info)
1567                 free(user_info);
1568
1569         return TCORE_MANAGER_RETURN_CONTINUE;
1570
1571 }
1572
1573 static enum tcore_manager_return __on_manager_notification_handler(Manager *manager,
1574                 CoreObject *source,
1575                 enum tcore_notification_command command,
1576                 unsigned int data_len, void *data)
1577 {
1578         std::cout << "  __on_manager_notification_handler()" << std::endl;
1579         if (command == TNOTI_CUSTOM)
1580                 std::cout  << " command = TNOTI_CUSTOM" << std::endl;
1581
1582         if (data_len > 0 && data) {
1583                 char *noti_data = (char *)data;
1584                 std::cout << "  noti data = " << noti_data << std::endl;
1585         }
1586
1587         return TCORE_MANAGER_RETURN_CONTINUE;
1588 }
1589
1590 TEST(LIBTCORE_MANAGER, test_manager)
1591 {
1592         TcorePlugin *p;
1593         Manager *m;
1594         TReturn ret;
1595
1596         p = tcore_plugin_new(NULL, &test_plugin_define_desc, "test_plugin", NULL);
1597         ASSERT_TRUE(p);
1598
1599         EXPECT_TRUE(tcore_plugin_get_description(p));
1600         std::cout << "  tcore_plugin_get_filename() = " << tcore_plugin_get_filename(p) << std::endl;
1601         std::cout << "  tcore_plugin_ref_plugin_name() = " << tcore_plugin_ref_plugin_name(p) << std::endl;
1602
1603         char plugin_data[] = "plugin_data";
1604         ret = tcore_plugin_link_user_data(p, plugin_data);
1605         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1606         std::cout << "  tcore_plugin_ref_user_data() = " << (char *)tcore_plugin_ref_user_data(p) << std::endl;
1607
1608         int *smsp_record_len = NULL;
1609         /* Storing smsp record length */
1610         smsp_record_len = (int *)g_try_malloc0(sizeof(int));
1611         ASSERT_TRUE(smsp_record_len);
1612         *smsp_record_len = 100;
1613         tcore_plugin_link_property(p, "SMSPRECORDLEN", smsp_record_len);
1614         int *ref_property = (int *)tcore_plugin_ref_property(p, "SMSPRECORDLEN");
1615         EXPECT_TRUE(ref_property);
1616         std::cout << "  SMSPRECORDLEN = " << *ref_property << std::endl;
1617
1618         m = tcore_manager_new(p);
1619         ASSERT_TRUE(m);
1620
1621         TcorePlugin *ref_plugin = tcore_manager_get_plugin(m);
1622         EXPECT_EQ(ref_plugin, p);
1623
1624         ret = tcore_manager_set_request_dispatcher(m, __on_manager_request_handler);
1625         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1626
1627         ret = tcore_manager_set_notification_handler(m, __on_manager_notification_handler);
1628         EXPECT_EQ(ret, TCORE_RETURN_SUCCESS);
1629
1630         enum tcore_manager_return mgr_ret;
1631         mgr_ret = tcore_manager_dispatch_request(m, NULL);
1632         std::cout << "  tcore_manager_dispatch_request() return = " << mgr_ret << std::endl;
1633
1634         char noti_data[] = "manager_noti_data";
1635         mgr_ret = tcore_manager_send_notification(m, NULL, TNOTI_CUSTOM, strlen(noti_data), noti_data);
1636         std::cout << "  tcore_manager_send_notification() return = " << mgr_ret << std::endl;
1637
1638
1639         tcore_manager_free(p, m);
1640         tcore_plugin_free(p);
1641 }
1642
1643 static void *__create_handle(Storage *strg, const char *path)
1644 {
1645         std::cout << "  __create_handle()" << std::endl;
1646
1647         void *tmp = NULL;
1648         if (!strg)
1649                 return NULL;
1650
1651         tmp = malloc(sizeof(char));
1652         return tmp;
1653 }
1654 static gboolean __remove_handle(Storage *strg, void *handle)
1655 {
1656         std::cout << "  __remove_handle()" << std::endl;
1657
1658         if (!strg || !handle)
1659                 return FALSE;
1660
1661         free(handle);
1662         return TRUE;
1663 }
1664 static gboolean __set_int(Storage *strg, enum tcore_storage_key key, int value)
1665 {
1666         std::cout << "  __set_int() :" << value << std::endl;
1667         return TRUE;
1668 }
1669 static gboolean __set_bool(Storage *strg, enum tcore_storage_key key, gboolean value)
1670 {
1671         std::cout << "  __set_bool() : " << value << std::endl;
1672         return TRUE;
1673 }
1674 static gboolean __set_string(Storage *strg, enum tcore_storage_key key, const char *value)
1675 {
1676         std::cout << "  __set_string() : " << value <<  std::endl;
1677         return TRUE;
1678 }
1679 static int __get_int(Storage *strg, enum tcore_storage_key key)
1680 {
1681         std::cout << "  __get_int()" << std::endl;
1682         return 0;
1683 }
1684 static gboolean __get_bool(Storage *strg, enum tcore_storage_key key)
1685 {
1686         std::cout << "  __get_bool()" << std::endl;
1687         return TRUE;
1688 }
1689 static char * __get_string(Storage *strg, enum tcore_storage_key key)
1690 {
1691         std::cout << "  __get_string()" << std::endl;
1692         return NULL;
1693 }
1694 static gboolean __set_key_callback(Storage *strg,
1695         enum tcore_storage_key key, TcoreStorageDispatchCallback cb)
1696 {
1697         std::cout << "  __set_key_callback()" << std::endl;
1698         return TRUE;
1699 }
1700 static gboolean __remove_key_callback(Storage *strg,
1701         enum tcore_storage_key key)
1702 {
1703         std::cout << "  __remove_key_callback()" << std::endl;
1704         return TRUE;
1705 }
1706 static gboolean __update_query_database(Storage *strg, void *handle, const char *query, GHashTable *in_param)
1707 {
1708         std::cout << "  __update_query_database()" << std::endl;
1709         return TRUE;
1710 }
1711 static gboolean __read_query_database(Storage *strg, void *handle, const char *query, GHashTable *in_param,
1712                 GHashTable **out_param, int out_param_cnt)
1713 {
1714         std::cout << "  __read_query_database()" << std::endl;
1715         return TRUE;
1716 }
1717 static gboolean __read_query_database_in_order(Storage *strg, void *handle, const char *query, GHashTable *in_param,
1718                 GSList **out_param, int out_param_cnt)
1719 {
1720         std::cout << "  __read_query_database_in_order()" << std::endl;
1721         return TRUE;
1722 }
1723 static gboolean __insert_query_database(Storage *strg, void *handle, const char *query, GHashTable *in_param)
1724 {
1725         std::cout << "  __insert_query_database()" << std::endl;
1726         return TRUE;
1727 }
1728 static gboolean __remove_query_database(Storage *strg, void *handle, const char *query, GHashTable *in_param)
1729 {
1730         std::cout << "  __remove_query_database()" << std::endl;
1731         return TRUE;
1732 }
1733
1734 static struct storage_operations test_strg_ops = {
1735         .create_handle = __create_handle,
1736         .remove_handle = __remove_handle,
1737         .set_int = __set_int,
1738         .set_string = __set_string,
1739         .set_bool = __set_bool,
1740         .get_int = __get_int,
1741         .get_string = __get_string,
1742         .get_bool = __get_bool,
1743         .set_key_callback = __set_key_callback,
1744         .remove_key_callback = __remove_key_callback,
1745         .update_query_database = __update_query_database,
1746         .read_query_database = __read_query_database,
1747         .read_query_database_in_order = __read_query_database_in_order,
1748         .insert_query_database = __insert_query_database,
1749         .remove_query_database = __remove_query_database,
1750 };
1751
1752 void __storage_key_callback(enum tcore_storage_key key, void *value, void *user_data)
1753 {
1754         std::cout << "  __storage_key_callback()" << std::endl;
1755 }
1756
1757 TEST(LIBTCORE_STORAGE, test_storage)
1758 {
1759         Storage *strg;
1760         void *handle;
1761
1762         strg = tcore_storage_new(NULL, "test_storage", &test_strg_ops);
1763         ASSERT_TRUE(strg);
1764         std::cout << "  storage name = " << tcore_storage_ref_name(strg) << std::endl;
1765
1766         handle = tcore_storage_create_handle(strg, "test_storage.db");
1767         tcore_storage_set_key_callback(strg, STORAGE_KEY_TELEPHONY_INT, __storage_key_callback, NULL);
1768
1769         tcore_storage_set_int(strg, STORAGE_KEY_TELEPHONY_INT, 100);
1770         tcore_storage_get_int(strg, STORAGE_KEY_TELEPHONY_INT);
1771         tcore_storage_set_bool(strg, STORAGE_KEY_TELEPHONY_BOOL, 1);
1772         tcore_storage_get_bool(strg, STORAGE_KEY_TELEPHONY_BOOL);
1773         tcore_storage_set_string(strg, STORAGE_KEY_TELEPHONY_STRING, "test_strg_string");
1774         tcore_storage_get_string(strg, STORAGE_KEY_TELEPHONY_STRING);
1775
1776         tcore_storage_update_query_database(strg, handle, "update", NULL);
1777         tcore_storage_read_query_database(strg, handle, "read", NULL, NULL, 1);
1778         tcore_storage_read_query_database_in_order(strg, handle, "read_in_order", NULL, NULL, 1);
1779         tcore_storage_insert_query_database(strg, handle, "insert", NULL);
1780         tcore_storage_remove_query_database(strg, handle, "remove", NULL);
1781
1782         tcore_storage_remove_key_callback(strg, STORAGE_KEY_TELEPHONY_INT, __storage_key_callback);
1783         tcore_storage_remove_handle(strg, handle);
1784         tcore_storage_free(strg);
1785
1786 }
1787
1788 int main(int argc, char **argv)
1789 {
1790         int ret = -1;
1791
1792         try {
1793                 testing::InitGoogleTest(&argc, argv);
1794         } catch(...) {
1795                 std::cout << "Exception occurred." << std::endl;
1796         }
1797         try {
1798                 ret = RUN_ALL_TESTS();
1799         } catch (const ::testing::internal::GoogleTestFailureException& e) {
1800                 ret = -1;
1801                 std::cout << "GoogleTestFailureException was thrown:" << e.what() << std::endl;
1802         }
1803         return ret;
1804 }
1805