TC/testcase/utc_location_poi.c

   1 /*
   2 * Copyright (c) 2011 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 <tet_api.h>
  18 #include <poi.h>
  19 #include <glib.h>
  20 #include <location/location.h>
  21
  22 enum {
  23         POSITIVE_TC_IDX = 0x01,
  24         NEGATIVE_TC_IDX,
  25 };
  26
  27 static void startup(void);
  28 static void cleanup(void);
  29
  30 void (*tet_startup)(void) = startup;
  31 void (*tet_cleanup)(void) = cleanup;
  32
  33 static void utc_poi_service_create_p(void);
  34 static void utc_poi_service_create_n(void);
  35 static void utc_poi_service_destroy_p(void);
  36 static void utc_poi_service_destroy_n(void);
  37 static void utc_poi_service_get_preference_p(void);
  38 static void utc_poi_service_get_preference_n(void);
  39 static void utc_poi_service_get_preference_n_02(void);
  40 static void utc_poi_service_set_preference_p(void);
  41 static void utc_poi_service_set_preference_n(void);
  42 static void utc_poi_service_set_preference_n_02(void);
  43 static void utc_poi_service_search_p(void);
  44 static void utc_poi_service_search_n(void);
  45 static void utc_poi_service_search_n_02(void);
  46 static void utc_poi_service_search_n_03(void);
  47 static void utc_poi_service_search_n_04(void);
  48 static void utc_poi_service_search_n_05(void);
  49 static void utc_poi_service_search_by_area_p(void);
  50 static void utc_poi_service_search_by_area_n(void);
  51 static void utc_poi_service_search_by_area_n_02(void);
  52 static void utc_poi_service_search_by_area_n_03(void);
  53 static void utc_poi_service_search_by_area_n_04(void);
  54 static void utc_poi_service_search_by_address_p(void);
  55 static void utc_poi_service_search_by_address_n(void);
  56 static void utc_poi_service_search_by_address_n_02(void);
  57 static void utc_poi_service_search_by_address_n_03(void);
  58 static void utc_poi_service_search_by_address_n_04(void);
  59 static void utc_poi_service_cancel_p(void);
  60 static void utc_poi_service_cancel_n(void);
  61 static void utc_poi_service_cancel_n_02(void);
  62 static void utc_poi_preference_create_p(void);
  63 static void utc_poi_preference_create_n(void);
  64 static void utc_poi_preference_destroy_p(void);
  65 static void utc_poi_preference_destroy_n(void);
  66 static void utc_poi_preference_get_p(void);
  67 static void utc_poi_preference_get_n(void);
  68 static void utc_poi_preference_get_n_02(void);
  69 static void utc_poi_preference_get_n_03(void);
  70 static void utc_poi_preference_set_p(void);
  71 static void utc_poi_preference_set_n(void);
  72 static void utc_poi_preference_set_n_02(void);
  73 static void utc_poi_preference_set_n_03(void);
  74 static void utc_poi_preference_set_max_result_p(void);
  75 static void utc_poi_preference_set_max_result_n(void);
  76 static void utc_poi_preference_set_max_result_n_02(void);
  77 static void utc_poi_preference_get_max_result_p(void);
  78 static void utc_poi_preference_get_max_result_n(void);
  79 static void utc_poi_preference_get_max_result_n_02(void);
  80 static void utc_poi_preference_foreach_sortable_field_p(void);
  81 static void utc_poi_preference_foreach_sortable_field_n(void);
  82 static void utc_poi_preference_foreach_sortable_field_n_02(void);
  83 static void utc_poi_preference_set_sort_p(void);
  84 static void utc_poi_preference_set_sort_n(void);
  85 static void utc_poi_preference_set_sort_n_02(void);
  86 static void utc_poi_preference_set_sort_n_03(void);
  87 static void utc_poi_preference_get_sort_p(void);
  88 static void utc_poi_preference_get_sort_n(void);
  89 static void utc_poi_preference_get_sort_n_02(void);
  90 static void utc_poi_preference_get_sort_n_03(void);
  91 static void utc_poi_preference_foreach_properties_p(void);
  92 static void utc_poi_preference_foreach_properties_n(void);
  93 static void utc_poi_preference_foreach_properties_n_02(void);
  94 static void utc_poi_preference_foreach_available_keys_p(void);
  95 static void utc_poi_preference_foreach_available_keys_n(void);
  96 static void utc_poi_preference_foreach_available_keys_n_02(void);
  97 static void utc_poi_preference_foreach_available_values_p(void);
  98 static void utc_poi_preference_foreach_available_values_n(void);
  99 static void utc_poi_preference_foreach_available_values_n_02(void);
 100 static void utc_poi_preference_foreach_available_values_n_03(void);
 101 static void utc_poi_filter_create_p(void);
 102 static void utc_poi_filter_create_n(void);
 103 static void utc_poi_filter_destroy_p(void);
 104 static void utc_poi_filter_destroy_n(void);
 105 static void utc_poi_filter_set_p(void);
 106 static void utc_poi_filter_set_n(void);
 107 static void utc_poi_filter_set_n_02(void);
 108 static void utc_poi_filter_set_n_03(void);
 109 static void utc_poi_filter_get_p(void);
 110 static void utc_poi_filter_get_n(void);
 111 static void utc_poi_filter_get_n_02(void);
 112 static void utc_poi_filter_get_n_03(void);
 113 static void utc_poi_filter_foreach_properties_p(void);
 114 static void utc_poi_filter_foreach_properties_n(void);
 115 static void utc_poi_filter_foreach_properties_n_02(void);
 116 static void utc_poi_filter_foreach_available_keys_p(void);
 117 static void utc_poi_filter_foreach_available_keys_n(void);
 118 static void utc_poi_filter_foreach_available_keys_n_02(void);
 119 static void utc_poi_filter_foreach_available_values_p(void);
 120 static void utc_poi_filter_foreach_available_values_n(void);
 121 static void utc_poi_filter_foreach_available_values_n_02(void);
 122 static void utc_poi_filter_foreach_available_values_n_03(void);
 123
 124 struct tet_testlist tet_testlist[] = {
 125         { utc_poi_service_create_p, POSITIVE_TC_IDX },
 126         { utc_poi_service_create_n, NEGATIVE_TC_IDX },
 127         { utc_poi_service_destroy_p, POSITIVE_TC_IDX },
 128         { utc_poi_service_destroy_n, NEGATIVE_TC_IDX },
 129         { utc_poi_service_get_preference_p, POSITIVE_TC_IDX },
 130         { utc_poi_service_get_preference_n, NEGATIVE_TC_IDX },
 131         { utc_poi_service_get_preference_n_02, NEGATIVE_TC_IDX },
 132         { utc_poi_service_set_preference_p, POSITIVE_TC_IDX },
 133         { utc_poi_service_set_preference_n, NEGATIVE_TC_IDX },
 134         { utc_poi_service_set_preference_n_02, NEGATIVE_TC_IDX },
 135         { utc_poi_service_search_p, POSITIVE_TC_IDX },
 136         { utc_poi_service_search_n, NEGATIVE_TC_IDX },
 137         { utc_poi_service_search_n_02, NEGATIVE_TC_IDX },
 138         { utc_poi_service_search_n_03, NEGATIVE_TC_IDX },
 139         { utc_poi_service_search_n_04, NEGATIVE_TC_IDX },
 140         //{ utc_poi_service_search_n_05, NEGATIVE_TC_IDX }, // It is not a negative TC.
 141         { utc_poi_service_search_by_area_p, POSITIVE_TC_IDX },
 142         { utc_poi_service_search_by_area_n, NEGATIVE_TC_IDX },
 143         { utc_poi_service_search_by_area_n_02, NEGATIVE_TC_IDX },
 144         { utc_poi_service_search_by_area_n_03, NEGATIVE_TC_IDX },
 145         //{ utc_poi_service_search_by_area_n_04, NEGATIVE_TC_IDX }, // It is not a negative TC.
 146         { utc_poi_service_search_by_address_p, POSITIVE_TC_IDX },
 147         { utc_poi_service_search_by_address_n, NEGATIVE_TC_IDX },
 148         { utc_poi_service_search_by_address_n_02, NEGATIVE_TC_IDX },
 149         { utc_poi_service_search_by_address_n_03, NEGATIVE_TC_IDX },
 150         //{ utc_poi_service_search_by_address_n_04, NEGATIVE_TC_IDX }, // It is not a negative TC.
 151         { utc_poi_service_cancel_p, POSITIVE_TC_IDX },
 152         { utc_poi_service_cancel_n, NEGATIVE_TC_IDX },
 153         //{ utc_poi_service_cancel_n_02, NEGATIVE_TC_IDX },     // It is not a negative TC.
 154         { utc_poi_preference_create_p, POSITIVE_TC_IDX },
 155         { utc_poi_preference_create_n, NEGATIVE_TC_IDX },
 156         { utc_poi_preference_destroy_p, POSITIVE_TC_IDX },
 157         { utc_poi_preference_destroy_n, NEGATIVE_TC_IDX },
 158         { utc_poi_preference_get_p, POSITIVE_TC_IDX },
 159         { utc_poi_preference_get_n, NEGATIVE_TC_IDX },
 160         { utc_poi_preference_get_n_02, NEGATIVE_TC_IDX },
 161         { utc_poi_preference_get_n_03, NEGATIVE_TC_IDX },
 162         { utc_poi_preference_set_p, POSITIVE_TC_IDX },
 163         { utc_poi_preference_set_n, NEGATIVE_TC_IDX },
 164         { utc_poi_preference_set_n_02, NEGATIVE_TC_IDX },
 165 //      { utc_poi_preference_set_n_03, NEGATIVE_TC_IDX },               // TODO: Check
 166         { utc_poi_preference_set_max_result_p, POSITIVE_TC_IDX },
 167         { utc_poi_preference_set_max_result_n, NEGATIVE_TC_IDX },
 168 //      { utc_poi_preference_set_max_result_n_02, NEGATIVE_TC_IDX },    //TODO: Check range
 169         { utc_poi_preference_get_max_result_p, POSITIVE_TC_IDX },
 170         { utc_poi_preference_get_max_result_n, NEGATIVE_TC_IDX },
 171         { utc_poi_preference_get_max_result_n_02, NEGATIVE_TC_IDX },
 172         { utc_poi_preference_foreach_sortable_field_p, POSITIVE_TC_IDX },
 173         { utc_poi_preference_foreach_sortable_field_n, NEGATIVE_TC_IDX },
 174         { utc_poi_preference_foreach_sortable_field_n_02, NEGATIVE_TC_IDX },
 175         { utc_poi_preference_set_sort_p, POSITIVE_TC_IDX },
 176         { utc_poi_preference_set_sort_n, NEGATIVE_TC_IDX },
 177         { utc_poi_preference_set_sort_n_02, NEGATIVE_TC_IDX },
 178 //      { utc_poi_preference_set_sort_n_03, NEGATIVE_TC_IDX },          //TODO: Check range
 179         { utc_poi_preference_get_sort_p, POSITIVE_TC_IDX },
 180         { utc_poi_preference_get_sort_n, NEGATIVE_TC_IDX },
 181         { utc_poi_preference_get_sort_n_02, NEGATIVE_TC_IDX },
 182         { utc_poi_preference_get_sort_n_03, NEGATIVE_TC_IDX },
 183         { utc_poi_preference_foreach_properties_p, POSITIVE_TC_IDX },
 184         { utc_poi_preference_foreach_properties_n, NEGATIVE_TC_IDX },
 185         { utc_poi_preference_foreach_properties_n_02, NEGATIVE_TC_IDX },
 186         { utc_poi_preference_foreach_available_keys_p, POSITIVE_TC_IDX },
 187         { utc_poi_preference_foreach_available_keys_n, NEGATIVE_TC_IDX },
 188         { utc_poi_preference_foreach_available_keys_n_02, NEGATIVE_TC_IDX },
 189         //{ utc_poi_preference_foreach_available_values_p, POSITIVE_TC_IDX }, // It is not a negative TC. value can be NULL.
 190         //{ utc_poi_preference_foreach_available_values_n, NEGATIVE_TC_IDX },
 191         //{ utc_poi_preference_foreach_available_values_n_02, NEGATIVE_TC_IDX },
 192         //{ utc_poi_preference_foreach_available_values_n_03, NEGATIVE_TC_IDX },
 193         { utc_poi_filter_create_p, POSITIVE_TC_IDX },
 194         { utc_poi_filter_create_n, NEGATIVE_TC_IDX },
 195         { utc_poi_filter_destroy_p, POSITIVE_TC_IDX },
 196         { utc_poi_filter_destroy_n, NEGATIVE_TC_IDX },
 197         { utc_poi_filter_set_p, POSITIVE_TC_IDX },
 198         { utc_poi_filter_set_n, NEGATIVE_TC_IDX },
 199         { utc_poi_filter_set_n_02, NEGATIVE_TC_IDX },
 200         //{ utc_poi_filter_set_n_03, NEGATIVE_TC_IDX }, // It is not a negative TC. value can be NULL.
 201         { utc_poi_filter_get_p, POSITIVE_TC_IDX },
 202         { utc_poi_filter_get_n, NEGATIVE_TC_IDX },
 203         { utc_poi_filter_get_n_02, NEGATIVE_TC_IDX },
 204         { utc_poi_filter_get_n_03, NEGATIVE_TC_IDX },
 205         { utc_poi_filter_foreach_properties_p, POSITIVE_TC_IDX },
 206         { utc_poi_filter_foreach_properties_n, NEGATIVE_TC_IDX },
 207         { utc_poi_filter_foreach_properties_n_02, NEGATIVE_TC_IDX },
 208         { utc_poi_filter_foreach_available_keys_p, POSITIVE_TC_IDX },
 209         { utc_poi_filter_foreach_available_keys_n, NEGATIVE_TC_IDX },
 210         { utc_poi_filter_foreach_available_keys_n_02, NEGATIVE_TC_IDX },
 211         //{ utc_poi_filter_foreach_available_values_p, POSITIVE_TC_IDX }, //It is not implemented yet.
 212         //{ utc_poi_filter_foreach_available_values_n, NEGATIVE_TC_IDX },
 213         //{ utc_poi_filter_foreach_available_values_n_02, NEGATIVE_TC_IDX },
 214         //{ utc_poi_filter_foreach_available_values_n_03, NEGATIVE_TC_IDX },
 215         { NULL, 0 },
 216 };
 217
 218
 219 static GMainLoop *g_mainloop = NULL;
 220 static GThread *event_thread;
 221
 222 gpointer GmainThread(gpointer data){
 223         g_mainloop = g_main_loop_new (NULL, 0);
 224         g_main_loop_run (g_mainloop);
 225
 226         return NULL;
 227 }
 228
 229
 230 static void validate_and_next(char* api_name,int act_ret, int ext_ret, char* fail_msg)
 231 {
 232         dts_message(api_name, "Actual Result : %d, Expected Result : %d", act_ret,ext_ret);
 233         if (act_ret != ext_ret)
 234         {
 235                 dts_message(api_name, "Fail Message: %s", fail_msg);
 236                 dts_fail(api_name);
 237         }
 238 }
 239
 240 static void validate_eq(char* api_name,int act_ret, int ext_ret)
 241 {
 242         dts_message(api_name, "Actual Result : %d, Expected Result : %d", act_ret,ext_ret);
 243         if (act_ret == ext_ret) {
 244                 dts_pass(api_name);
 245         } else {
 246                 dts_fail(api_name);
 247         }
 248 }
 249
 250
 251 static void startup(void)
 252 {
 253         g_setenv("PKG_NAME", "org.tizen.capi-location-poi-test", 1);
 254         g_setenv("LOCATION_TEST_ENABLE", "1", 1);
 255
 256 #if !GLIB_CHECK_VERSION (2, 31, 0)
 257         if( !g_thread_supported() )
 258         {
 259                 g_thread_init(NULL);
 260         }
 261 #endif
 262
 263         GError *gerr = NULL;
 264         event_thread = g_thread_create(GmainThread, NULL, 1, &gerr);
 265 }
 266
 267 static void cleanup(void)
 268 {
 269
 270         g_main_loop_quit (g_mainloop);
 271         g_thread_join(event_thread);
 272 }
 273
 274 static void utc_poi_service_create_p(void)
 275 {
 276         int ret = POI_ERROR_NONE;
 277
 278         poi_service_h poi_manager ;
 279         ret = poi_service_create(&poi_manager);
 280
 281         if (poi_manager) {
 282                 poi_service_destroy(poi_manager);
 283         }
 284
 285         validate_eq(__func__, ret, POI_ERROR_NONE);
 286 }
 287
 288 static void utc_poi_service_create_n(void)
 289 {
 290         int ret = POI_ERROR_NONE;
 291
 292         ret = poi_service_create(NULL);
 293         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
 294 }
 295
 296 static void utc_poi_service_destroy_p(void)
 297 {
 298         int ret = POI_ERROR_NONE;
 299
 300         poi_service_h poi_manager ;
 301         ret = poi_service_create(&poi_manager);
 302         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
 303
 304         ret = poi_service_destroy(poi_manager);
 305         validate_eq(__func__, ret, POI_ERROR_NONE);
 306 }
 307
 308 static void utc_poi_service_destroy_n(void)
 309 {
 310         int ret = POI_ERROR_NONE;
 311
 312         ret = poi_service_destroy(NULL);
 313         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
 314 }
 315
 316 static void utc_poi_service_get_preference_p(void)
 317 {
 318         int ret = POI_ERROR_NONE;
 319
 320         poi_service_h poi_manager ;
 321         ret = poi_service_create(&poi_manager);
 322         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
 323
 324         poi_preference_h pref;
 325         ret = poi_preference_create(&pref);
 326         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
 327
 328         ret = poi_preference_set_max_result(pref, 5);
 329         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
 330
 331         ret = poi_service_set_preference(poi_manager, pref);
 332         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
 333
 334         poi_preference_h preference;
 335         ret = poi_service_get_preference(poi_manager, &preference);
 336
 337         if (poi_manager) {
 338                 // free pref also
 339                 poi_service_destroy(poi_manager);
 340         }
 341
 342
 343         validate_eq(__func__, ret, POI_ERROR_NONE);
 344 }
 345
 346 static void utc_poi_service_get_preference_n(void)
 347 {
 348         int ret = POI_ERROR_NONE;
 349
 350         poi_preference_h preference;
 351         ret = poi_service_get_preference(NULL, &preference);
 352         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
 353 }
 354
 355 static void utc_poi_service_get_preference_n_02(void)
 356 {
 357         int ret = POI_ERROR_NONE;
 358
 359         poi_service_h poi_manager ;
 360         ret = poi_service_create(&poi_manager);
 361         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
 362
 363         ret = poi_service_get_preference(poi_manager, NULL);
 364
 365         if (poi_manager) {
 366                 poi_service_destroy(poi_manager);
 367         }
 368
 369         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
 370 }
 371
 372
 373 static void utc_poi_service_set_preference_p(void)
 374 {
 375         int ret = POI_ERROR_NONE;
 376
 377         poi_service_h poi_manager ;
 378         ret = poi_service_create(&poi_manager);
 379         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
 380
 381         poi_preference_h pref;
 382         ret = poi_preference_create(&pref);
 383         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
 384
 385         ret = poi_preference_set_max_result(pref, 5);
 386         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
 387
 388         ret = poi_service_set_preference(poi_manager, pref);
 389
 390         if (poi_manager) {
 391                 poi_service_destroy(poi_manager);
 392         }
 393
 394
 395         validate_eq(__func__, ret, POI_ERROR_NONE);
 396 }
 397
 398 static void utc_poi_service_set_preference_n(void)
 399 {
 400         int ret = POI_ERROR_NONE;
 401
 402         poi_preference_h pref;
 403         ret = poi_preference_create(&pref);
 404         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
 405
 406         ret = poi_preference_set_max_result(pref, 5);
 407         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
 408
 409         ret = poi_service_set_preference(NULL, pref);
 410
 411         if (pref) {
 412                 poi_preference_destroy(pref);
 413         }
 414
 415         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
 416 }
 417
 418 static void utc_poi_service_set_preference_n_02(void)
 419 {
 420         int ret = POI_ERROR_NONE;
 421
 422         poi_service_h poi_manager ;
 423         ret = poi_service_create(&poi_manager);
 424         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
 425
 426         ret = poi_service_set_preference(poi_manager, NULL);
 427
 428         if (poi_manager) {
 429                 poi_service_destroy(poi_manager);
 430         }
 431
 432         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
 433 }
 434
 435
 436 static bool capi_service_search_cb(poi_error_e error, int request_id , int index, int length , poi_h poi , void * user_data)
 437 {
 438         dts_message(__func__, "capi_service_search_cb : error %d, index : %d", error, index);
 439
 440         return true;
 441 }
 442
 443 static void utc_poi_service_search_p(void)
 444 {
 445         int ret = POI_ERROR_NONE;
 446
 447         poi_service_h poi_manager ;
 448         ret = poi_service_create(&poi_manager);
 449         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
 450
 451         poi_filter_h filter;
 452         ret = poi_filter_create(&filter);
 453         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
 454         ret = poi_filter_set(filter, "CATEGORY", "restaurant");
 455         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
 456
 457         poi_preference_h pref;
 458         ret = poi_preference_create(&pref);
 459         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
 460         ret = poi_preference_set_max_result(pref, 5);
 461         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
 462         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
 463         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
 464         ret = poi_service_set_preference(poi_manager, pref);
 465         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
 466         location_coords_s pos = {37.771008, -122.41175};
 467
 468         ret = poi_service_search(poi_manager, pos, 100, filter, capi_service_search_cb , NULL, NULL);
 469
 470         if (filter) {
 471                 poi_filter_destroy(filter);
 472         }
 473         if (poi_manager) {
 474                 poi_service_destroy(poi_manager);
 475         }
 476
 477         validate_eq(__func__, ret, POI_ERROR_NONE);
 478 }
 479
 480 static void utc_poi_service_search_n(void)
 481 {
 482         int ret = POI_ERROR_NONE;
 483
 484         poi_service_h poi_manager ;
 485         ret = poi_service_create(&poi_manager);
 486         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
 487
 488         poi_filter_h filter;
 489         ret = poi_filter_create(&filter);
 490         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
 491         ret = poi_filter_set(filter, "CATEGORY", "restaurant");
 492         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
 493
 494         poi_preference_h pref;
 495         ret = poi_preference_create(&pref);
 496         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
 497         ret = poi_preference_set_max_result(pref, 5);
 498         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
 499         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
 500         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
 501         ret = poi_service_set_preference(poi_manager, pref);
 502         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
 503         location_coords_s pos = {37.771008, -122.41175};
 504
 505         ret = poi_service_search(NULL, pos, 100, filter, capi_service_search_cb , NULL, NULL);
 506
 507         if (filter) {
 508                 poi_filter_destroy(filter);
 509         }
 510         if (poi_manager) {
 511                 poi_service_destroy(poi_manager);
 512         }
 513
 514         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
 515 }
 516
 517 static void utc_poi_service_search_n_02(void)
 518 {
 519         int ret = POI_ERROR_NONE;
 520
 521         poi_service_h poi_manager ;
 522         ret = poi_service_create(&poi_manager);
 523         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
 524
 525         poi_filter_h filter;
 526         ret = poi_filter_create(&filter);
 527         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
 528         ret = poi_filter_set(filter, "CATEGORY", "restaurant");
 529         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
 530
 531         poi_preference_h pref;
 532         ret = poi_preference_create(&pref);
 533         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
 534         ret = poi_preference_set_max_result(pref, 5);
 535         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
 536         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
 537         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
 538         ret = poi_service_set_preference(poi_manager, pref);
 539         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
 540         location_coords_s pos = {91, 181};
 541
 542         ret = poi_service_search(poi_manager, pos, 100, filter, capi_service_search_cb , NULL, NULL);
 543
 544         if (filter) {
 545                 poi_filter_destroy(filter);
 546         }
 547         if (poi_manager) {
 548                 poi_service_destroy(poi_manager);
 549         }
 550
 551
 552
 553         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
 554 }
 555
 556 static void utc_poi_service_search_n_03(void)
 557 {
 558         int ret = POI_ERROR_NONE;
 559
 560         poi_service_h poi_manager ;
 561         ret = poi_service_create(&poi_manager);
 562         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
 563
 564         poi_filter_h filter;
 565         ret = poi_filter_create(&filter);
 566         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
 567         ret = poi_filter_set(filter, "CATEGORY", "restaurant");
 568         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
 569
 570         poi_preference_h pref;
 571         ret = poi_preference_create(&pref);
 572         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
 573         ret = poi_preference_set_max_result(pref, 5);
 574         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
 575         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
 576         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
 577         ret = poi_service_set_preference(poi_manager, pref);
 578         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
 579         location_coords_s pos = {37.771008, -122.41175};
 580
 581         ret = poi_service_search(poi_manager, pos, -1, filter, capi_service_search_cb , NULL, NULL);
 582
 583         if (filter) {
 584                 poi_filter_destroy(filter);
 585         }
 586         if (poi_manager) {
 587                 poi_service_destroy(poi_manager);
 588         }
 589
 590         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
 591 }
 592
 593 static void utc_poi_service_search_n_04(void)
 594 {
 595         int ret = POI_ERROR_NONE;
 596
 597         poi_service_h poi_manager ;
 598         ret = poi_service_create(&poi_manager);
 599         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
 600
 601         poi_preference_h pref;
 602         ret = poi_preference_create(&pref);
 603         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
 604         ret = poi_preference_set_max_result(pref, 5);
 605         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
 606         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
 607         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
 608         ret = poi_service_set_preference(poi_manager, pref);
 609         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
 610         location_coords_s pos = {37.771008, -122.41175};
 611
 612         ret = poi_service_search(poi_manager, pos, 100, NULL, capi_service_search_cb , NULL, NULL);
 613
 614         if (poi_manager) {
 615                 poi_service_destroy(poi_manager);
 616         }
 617
 618
 619         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
 620 }
 621
 622 static void utc_poi_service_search_n_05(void)
 623 {
 624         int ret = POI_ERROR_NONE;
 625
 626         poi_service_h poi_manager ;
 627         ret = poi_service_create(&poi_manager);
 628         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
 629
 630         poi_filter_h filter;
 631         ret = poi_filter_create(&filter);
 632         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
 633         ret = poi_filter_set(filter, "CATEGORY", "restaurant");
 634         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
 635
 636         poi_preference_h pref;
 637         ret = poi_preference_create(&pref);
 638         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
 639         ret = poi_preference_set_max_result(pref, 5);
 640         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
 641         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
 642         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
 643         ret = poi_service_set_preference(poi_manager, pref);
 644         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
 645         location_coords_s pos = {37.771008, -122.41175};
 646
 647         ret = poi_service_search(poi_manager, pos, 100, filter, NULL , NULL, NULL);
 648
 649         if (filter) {
 650                 poi_filter_destroy(filter);
 651         }
 652         if (poi_manager) {
 653                 poi_service_destroy(poi_manager);
 654         }
 655
 656         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
 657 }
 658
 659
 660
 661 static void utc_poi_service_search_by_area_p(void)
 662 {
 663         int ret = POI_ERROR_NONE;
 664
 665         poi_service_h poi_manager ;
 666         ret = poi_service_create(&poi_manager);
 667         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
 668
 669         poi_filter_h filter;
 670         ret = poi_filter_create(&filter);
 671         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
 672         ret = poi_filter_set(filter, "CATEGORY", "restaurant");
 673         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
 674
 675         poi_preference_h pref;
 676         ret = poi_preference_create(&pref);
 677         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
 678         ret = poi_preference_set_max_result(pref, 5);
 679         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
 680         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
 681         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
 682         ret = poi_service_set_preference(poi_manager, pref);
 683         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
 684
 685         location_coords_s center;
 686         center.latitude = 37.336723;
 687         center.longitude = -121.889555;
 688         double radius = 30;
 689         location_bounds_h bounds_circle = NULL;
 690         ret = location_bounds_create_circle(center, radius, &bounds_circle);
 691         validate_and_next(__func__, ret, LOCATION_BOUNDS_ERROR_NONE, "location_bounds_create_circle() is failed");
 692
 693         ret = poi_service_search_by_area(poi_manager, bounds_circle, filter, capi_service_search_cb, NULL, NULL);
 694
 695         if (filter) {
 696                 poi_filter_destroy(filter);
 697         }
 698         if (poi_manager) {
 699                 poi_service_destroy(poi_manager);
 700         }
 701         if (bounds_circle) {
 702                 location_bounds_destroy(bounds_circle);
 703         }
 704
 705         validate_eq(__func__, ret, POI_ERROR_NONE);
 706 }
 707
 708 static void utc_poi_service_search_by_area_n(void)
 709 {
 710         int ret = POI_ERROR_NONE;
 711
 712         poi_service_h poi_manager ;
 713         ret = poi_service_create(&poi_manager);
 714         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
 715
 716         poi_filter_h filter;
 717         ret = poi_filter_create(&filter);
 718         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
 719         ret = poi_filter_set(filter, "CATEGORY", "restaurant");
 720         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
 721
 722         poi_preference_h pref;
 723         ret = poi_preference_create(&pref);
 724         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
 725         ret = poi_preference_set_max_result(pref, 5);
 726         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
 727         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
 728         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
 729         ret = poi_service_set_preference(poi_manager, pref);
 730         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
 731
 732         location_coords_s center;
 733         center.latitude = 37.336723;
 734         center.longitude = -121.889555;
 735         double radius = 30;
 736         location_bounds_h bounds_circle;
 737         ret = location_bounds_create_circle(center, radius, &bounds_circle);
 738         validate_and_next(__func__, ret, LOCATION_BOUNDS_ERROR_NONE, "location_bounds_create_circle() is failed");
 739
 740         ret = poi_service_search_by_area(NULL, bounds_circle, filter, capi_service_search_cb, NULL, NULL);
 741
 742         if (filter) {
 743                 poi_filter_destroy(filter);
 744         }
 745         if (poi_manager) {
 746                 poi_service_destroy(poi_manager);
 747         }
 748         if (bounds_circle) {
 749                 location_bounds_destroy(bounds_circle);
 750         }
 751
 752         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
 753 }
 754
 755 static void utc_poi_service_search_by_area_n_02(void)
 756 {
 757         int ret = POI_ERROR_NONE;
 758
 759         poi_service_h poi_manager ;
 760         ret = poi_service_create(&poi_manager);
 761         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
 762
 763         poi_filter_h filter;
 764         ret = poi_filter_create(&filter);
 765         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
 766         ret = poi_filter_set(filter, "CATEGORY", "restaurant");
 767         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
 768
 769         poi_preference_h pref;
 770         ret = poi_preference_create(&pref);
 771         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
 772         ret = poi_preference_set_max_result(pref, 5);
 773         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
 774         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
 775         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
 776         ret = poi_service_set_preference(poi_manager, pref);
 777         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
 778
 779         ret = poi_service_search_by_area(poi_manager, NULL, filter, capi_service_search_cb, NULL, NULL);
 780
 781         if (filter) {
 782                 poi_filter_destroy(filter);
 783         }
 784         if (poi_manager) {
 785                 poi_service_destroy(poi_manager);
 786         }
 787
 788         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
 789 }
 790
 791 static void utc_poi_service_search_by_area_n_03(void)
 792 {
 793         int ret = POI_ERROR_NONE;
 794
 795         poi_service_h poi_manager ;
 796         ret = poi_service_create(&poi_manager);
 797         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
 798
 799         poi_preference_h pref;
 800         ret = poi_preference_create(&pref);
 801         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
 802         ret = poi_preference_set_max_result(pref, 5);
 803         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
 804         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
 805         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
 806         ret = poi_service_set_preference(poi_manager, pref);
 807         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
 808
 809         location_coords_s center;
 810         center.latitude = 37.336723;
 811         center.longitude = -121.889555;
 812         double radius = 30;
 813         location_bounds_h bounds_circle;
 814         ret = location_bounds_create_circle(center, radius, &bounds_circle);
 815         validate_and_next(__func__, ret, LOCATION_BOUNDS_ERROR_NONE, "location_bounds_create_circle() is failed");
 816
 817         ret = poi_service_search_by_area(poi_manager, bounds_circle, NULL, capi_service_search_cb, NULL, NULL);
 818
 819         if (poi_manager) {
 820                 poi_service_destroy(poi_manager);
 821         }
 822         if (bounds_circle) {
 823                 location_bounds_destroy(bounds_circle);
 824         }
 825
 826         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
 827 }
 828
 829 static void utc_poi_service_search_by_area_n_04(void)
 830 {
 831         int ret = POI_ERROR_NONE;
 832
 833         poi_service_h poi_manager ;
 834         ret = poi_service_create(&poi_manager);
 835         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
 836
 837         poi_filter_h filter;
 838         ret = poi_filter_create(&filter);
 839         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
 840         ret = poi_filter_set(filter, "CATEGORY", "restaurant");
 841         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
 842
 843         poi_preference_h pref;
 844         ret = poi_preference_create(&pref);
 845         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
 846         ret = poi_preference_set_max_result(pref, 5);
 847         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
 848         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
 849         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
 850         ret = poi_service_set_preference(poi_manager, pref);
 851         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
 852
 853         location_coords_s center;
 854         center.latitude = 37.336723;
 855         center.longitude = -121.889555;
 856         double radius = 30;
 857         location_bounds_h bounds_circle;
 858         ret = location_bounds_create_circle(center, radius, &bounds_circle);
 859         validate_and_next(__func__, ret, LOCATION_BOUNDS_ERROR_NONE, "location_bounds_create_circle() is failed");
 860
 861         ret = poi_service_search_by_area(poi_manager, bounds_circle, filter, NULL, NULL, NULL);
 862
 863         if (filter) {
 864                 poi_filter_destroy(filter);
 865         }
 866         if (poi_manager) {
 867                 poi_service_destroy(poi_manager);
 868         }
 869         if (bounds_circle) {
 870                 location_bounds_destroy(bounds_circle);
 871         }
 872
 873         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
 874 }
 875
 876 static void utc_poi_service_search_by_address_p(void)
 877 {
 878         int ret = POI_ERROR_NONE;
 879
 880         poi_service_h poi_manager ;
 881         ret = poi_service_create(&poi_manager);
 882         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
 883
 884         poi_filter_h filter;
 885         ret = poi_filter_create(&filter);
 886         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
 887         ret = poi_filter_set(filter, "KEYWORD", "restaurant");
 888         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
 889
 890         poi_preference_h pref;
 891         ret = poi_preference_create(&pref);
 892         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
 893         ret = poi_preference_set_max_result(pref, 5);
 894         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
 895         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
 896         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
 897         ret = poi_service_set_preference(poi_manager, pref);
 898         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
 899
 900         char *addr = strdup("North Second St.");
 901         ret = poi_service_search_by_address(poi_manager, addr, NULL, filter, capi_service_search_cb, NULL, NULL);
 902
 903         if (filter) {
 904                 poi_filter_destroy(filter);
 905         }
 906         if (poi_manager) {
 907                 poi_service_destroy(poi_manager);
 908         }
 909
 910         validate_eq(__func__, ret, POI_ERROR_NONE);
 911 }
 912
 913 static void utc_poi_service_search_by_address_n(void)
 914 {
 915         int ret = POI_ERROR_NONE;
 916
 917         poi_service_h poi_manager ;
 918         ret = poi_service_create(&poi_manager);
 919         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
 920
 921         poi_filter_h filter;
 922         ret = poi_filter_create(&filter);
 923         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
 924         ret = poi_filter_set(filter, "KEYWORD", "restaurant");
 925         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
 926
 927         poi_preference_h pref;
 928         ret = poi_preference_create(&pref);
 929         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
 930         ret = poi_preference_set_max_result(pref, 5);
 931         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
 932         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
 933         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
 934         ret = poi_service_set_preference(poi_manager, pref);
 935         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
 936
 937         char *addr = strdup("North Second St.");
 938         ret = poi_service_search_by_address(NULL, addr, NULL, filter, capi_service_search_cb, NULL, NULL);
 939
 940         if (filter) {
 941                 poi_filter_destroy(filter);
 942         }
 943         if (poi_manager) {
 944                 poi_service_destroy(poi_manager);
 945         }
 946
 947         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
 948 }
 949
 950 static void utc_poi_service_search_by_address_n_02(void)
 951 {
 952         int ret = POI_ERROR_NONE;
 953
 954         poi_service_h poi_manager ;
 955         ret = poi_service_create(&poi_manager);
 956         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
 957
 958         poi_filter_h filter;
 959         ret = poi_filter_create(&filter);
 960         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
 961         ret = poi_filter_set(filter, "KEYWORD", "restaurant");
 962         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
 963
 964         poi_preference_h pref;
 965         ret = poi_preference_create(&pref);
 966         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
 967         ret = poi_preference_set_max_result(pref, 5);
 968         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
 969         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
 970         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
 971         ret = poi_service_set_preference(poi_manager, pref);
 972         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
 973
 974         ret = poi_service_search_by_address(poi_manager, NULL, NULL, filter, capi_service_search_cb, NULL, NULL);
 975
 976         if (filter) {
 977                 poi_filter_destroy(filter);
 978         }
 979         if (poi_manager) {
 980                 poi_service_destroy(poi_manager);
 981         }
 982
 983         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
 984 }
 985
 986
 987 static void utc_poi_service_search_by_address_n_03(void)
 988 {
 989         int ret = POI_ERROR_NONE;
 990
 991         poi_service_h poi_manager ;
 992         ret = poi_service_create(&poi_manager);
 993         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
 994
 995         poi_preference_h pref;
 996         ret = poi_preference_create(&pref);
 997         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
 998         ret = poi_preference_set_max_result(pref, 5);
 999         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
1000         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
1001         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
1002         ret = poi_service_set_preference(poi_manager, pref);
1003         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
1004
1005         char *addr = strdup("North Second St.");
1006         ret = poi_service_search_by_address(poi_manager, addr, NULL, NULL, capi_service_search_cb, NULL, NULL);
1007
1008         if (poi_manager) {
1009                 poi_service_destroy(poi_manager);
1010         }
1011
1012         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1013 }
1014
1015 static void utc_poi_service_search_by_address_n_04(void)
1016 {
1017         int ret = POI_ERROR_NONE;
1018
1019         poi_service_h poi_manager ;
1020         ret = poi_service_create(&poi_manager);
1021         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
1022
1023         poi_filter_h filter;
1024         ret = poi_filter_create(&filter);
1025         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
1026         ret = poi_filter_set(filter, "KEYWORD", "restaurant");
1027         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
1028
1029         poi_preference_h pref;
1030         ret = poi_preference_create(&pref);
1031         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
1032         ret = poi_preference_set_max_result(pref, 5);
1033         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
1034         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
1035         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
1036         ret = poi_service_set_preference(poi_manager, pref);
1037         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
1038
1039         char *addr = strdup("North Second St.");
1040         ret = poi_service_search_by_address(poi_manager, addr, NULL, filter, NULL, NULL, NULL);
1041
1042         if (filter) {
1043                 poi_filter_destroy(filter);
1044         }
1045         if (poi_manager) {
1046                 poi_service_destroy(poi_manager);
1047         }
1048
1049         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1050 }
1051
1052 static void utc_poi_service_cancel_p(void)
1053 {
1054         int ret = POI_ERROR_NONE;
1055
1056         poi_service_h poi_manager ;
1057         ret = poi_service_create(&poi_manager);
1058         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
1059
1060         int request_id = 1;
1061         ret = poi_service_cancel(poi_manager, request_id);
1062
1063         if (poi_manager) {
1064                 poi_service_destroy(poi_manager);
1065         }
1066
1067         validate_eq(__func__, ret, POI_ERROR_NONE);
1068 }
1069
1070 static void utc_poi_service_cancel_n(void)
1071 {
1072         int ret = POI_ERROR_NONE;
1073
1074         int request_id = 1;
1075         ret = poi_service_cancel(NULL, request_id);
1076
1077         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1078
1079 }
1080
1081 static void utc_poi_service_cancel_n_02(void)
1082 {
1083         int ret = POI_ERROR_NONE;
1084
1085         poi_service_h poi_manager ;
1086         ret = poi_service_create(&poi_manager);
1087         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
1088
1089         ret = poi_service_cancel(poi_manager, -1);
1090
1091         if (poi_manager) {
1092                 poi_service_destroy(poi_manager);
1093         }
1094
1095         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1096
1097 }
1098
1099 static void utc_poi_preference_create_p(void)
1100 {
1101         int ret = POI_ERROR_NONE;
1102
1103         poi_preference_h pref;
1104         ret = poi_preference_create(&pref);
1105
1106         if (pref) {
1107                 poi_preference_destroy(pref);
1108         }
1109
1110         validate_eq(__func__, ret, POI_ERROR_NONE);
1111
1112 }
1113
1114 static void utc_poi_preference_create_n(void)
1115 {
1116         int ret = POI_ERROR_NONE;
1117
1118         ret = poi_preference_create(NULL);
1119         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1120
1121 }
1122
1123
1124
1125 static void utc_poi_preference_destroy_p(void)
1126 {
1127         int ret = POI_ERROR_NONE;
1128
1129         poi_preference_h pref;
1130         ret = poi_preference_create(&pref);
1131         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
1132
1133         ret = poi_preference_destroy(pref);
1134
1135         validate_eq(__func__, ret, POI_ERROR_NONE);
1136 }
1137
1138 static void utc_poi_preference_destroy_n(void)
1139 {
1140         int ret = POI_ERROR_NONE;
1141
1142         ret = poi_preference_destroy(NULL);
1143         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1144
1145 }
1146
1147 static void utc_poi_preference_get_p(void)
1148 {
1149         int ret = POI_ERROR_NONE;
1150
1151         poi_preference_h pref;
1152         ret = poi_preference_create(&pref);
1153         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
1154
1155         ret = poi_preference_set(pref, "LandmarkName", "cafe");
1156         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set() is failed");
1157
1158         char *value;
1159         ret = poi_preference_get(pref, "LandmarkName", &value);
1160
1161         if (pref) {
1162                 poi_preference_destroy(pref);
1163         }
1164
1165         validate_eq(__func__, ret, POI_ERROR_NONE);
1166 }
1167
1168 static void utc_poi_preference_get_n(void)
1169 {
1170         int ret = POI_ERROR_NONE;
1171
1172         char *value;
1173         ret = poi_preference_get(NULL, "LandmarkName", &value);
1174         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1175
1176 }
1177
1178 static void utc_poi_preference_get_n_02(void)
1179 {
1180         int ret = POI_ERROR_NONE;
1181
1182         poi_preference_h pref;
1183         ret = poi_preference_create(&pref);
1184         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
1185
1186         ret = poi_preference_set(pref, "LandmarkName", "cafe");
1187         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set() is failed");
1188
1189         char *value;
1190         ret = poi_preference_get(pref, NULL, &value);
1191
1192         if (pref) {
1193                 poi_preference_destroy(pref);
1194         }
1195
1196         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1197
1198 }
1199
1200 static void utc_poi_preference_get_n_03(void)
1201 {
1202         int ret = POI_ERROR_NONE;
1203
1204         poi_preference_h pref;
1205         ret = poi_preference_create(&pref);
1206         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
1207
1208         ret = poi_preference_set(pref, "LandmarkName", "cafe");
1209         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set() is failed");
1210
1211         ret = poi_preference_get(pref, "LandmarkName", NULL);
1212
1213         if (pref) {
1214                 poi_preference_destroy(pref);
1215         }
1216
1217         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1218
1219 }
1220
1221
1222 static void utc_poi_preference_set_p(void)
1223 {
1224         int ret = POI_ERROR_NONE;
1225
1226         poi_preference_h pref;
1227         ret = poi_preference_create(&pref);
1228         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
1229
1230         ret = poi_preference_set(pref, "LandmarkName", "cafe");
1231
1232         if (pref) {
1233                 poi_preference_destroy(pref);
1234         }
1235
1236         validate_eq(__func__, ret, POI_ERROR_NONE);
1237 }
1238
1239 static void utc_poi_preference_set_n(void)
1240 {
1241         int ret = POI_ERROR_NONE;
1242
1243         char *value;
1244         ret = poi_preference_set(NULL, "LandmarkName", "cafe");
1245         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1246
1247 }
1248
1249 static void utc_poi_preference_set_n_02(void)
1250 {
1251         int ret = POI_ERROR_NONE;
1252
1253         poi_preference_h pref;
1254         ret = poi_preference_create(&pref);
1255         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
1256
1257         ret = poi_preference_set(pref, NULL, "cafe");
1258
1259         if (pref) {
1260                 poi_preference_destroy(pref);
1261         }
1262
1263         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1264
1265 }
1266
1267 static void utc_poi_preference_set_n_03(void)
1268 {
1269         int ret = POI_ERROR_NONE;
1270
1271         poi_preference_h pref;
1272         ret = poi_preference_create(&pref);
1273         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
1274
1275         ret = poi_preference_set(pref, "LandmarkName", NULL);
1276
1277         if (pref) {
1278                 poi_preference_destroy(pref);
1279         }
1280
1281         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1282
1283 }
1284
1285 static void utc_poi_preference_set_max_result_p(void)
1286 {
1287         int ret = POI_ERROR_NONE;
1288
1289         poi_preference_h pref;
1290         ret = poi_preference_create(&pref);
1291         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
1292
1293         ret = poi_preference_set_max_result(pref, 5);
1294
1295         if (pref) {
1296                 poi_preference_destroy(pref);
1297         }
1298
1299         validate_eq(__func__, ret, POI_ERROR_NONE);
1300 }
1301
1302 static void utc_poi_preference_set_max_result_n(void)
1303 {
1304         int ret = POI_ERROR_NONE;
1305
1306         ret = poi_preference_set_max_result(NULL, 5);
1307         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1308
1309 }
1310
1311 static void utc_poi_preference_set_max_result_n_02(void)
1312 {
1313         int ret = POI_ERROR_NONE;
1314
1315         poi_preference_h pref;
1316         ret = poi_preference_create(&pref);
1317         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
1318
1319         ret = poi_preference_set_max_result(pref, -1);
1320
1321         if (pref) {
1322                 poi_preference_destroy(pref);
1323         }
1324
1325         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1326
1327 }
1328
1329 static void utc_poi_preference_get_max_result_p(void)
1330 {
1331         int ret = POI_ERROR_NONE;
1332
1333         poi_preference_h pref;
1334         ret = poi_preference_create(&pref);
1335         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
1336
1337         ret = poi_preference_set_max_result(pref, 5);
1338         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
1339
1340         int max_result;
1341         ret = poi_preference_get_max_result(pref, &max_result);
1342
1343         if (pref) {
1344                 poi_preference_destroy(pref);
1345         }
1346
1347         validate_eq(__func__, ret, POI_ERROR_NONE);
1348 }
1349
1350 static void utc_poi_preference_get_max_result_n(void)
1351 {
1352         int ret = POI_ERROR_NONE;
1353
1354         int max_result;
1355         ret = poi_preference_get_max_result(NULL, &max_result);
1356         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1357
1358 }
1359
1360 static void utc_poi_preference_get_max_result_n_02(void)
1361 {
1362         int ret = POI_ERROR_NONE;
1363
1364
1365         poi_preference_h pref;
1366         ret = poi_preference_create(&pref);
1367         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
1368
1369         ret = poi_preference_set_max_result(pref, 5);
1370         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
1371
1372         ret = poi_preference_get_max_result(pref, NULL);
1373
1374         if (pref) {
1375                 poi_preference_destroy(pref);
1376         }
1377
1378         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1379
1380 }
1381
1382 static bool capi_poi_preference_sortable_field_cb(const char *field , void *user_data)
1383 {
1384         return true;
1385 }
1386
1387 static void utc_poi_preference_foreach_sortable_field_p(void)
1388 {
1389         int ret = POI_ERROR_NONE;
1390
1391         poi_service_h poi_manager ;
1392         ret = poi_service_create(&poi_manager);
1393         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
1394
1395         poi_preference_h pref;
1396         ret = poi_preference_create(&pref);
1397         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
1398         ret = poi_preference_set_max_result(pref, 5);
1399         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
1400         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
1401         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
1402         ret = poi_service_set_preference(poi_manager, pref);
1403         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
1404
1405         ret = poi_preference_foreach_sortable_field(poi_manager, capi_poi_preference_sortable_field_cb, NULL);
1406
1407         if (poi_manager) {
1408                 poi_service_destroy(poi_manager);
1409         }
1410
1411         validate_eq(__func__, ret, POI_ERROR_NONE);
1412 }
1413
1414 static void utc_poi_preference_foreach_sortable_field_n(void)
1415 {
1416         int ret = POI_ERROR_NONE;
1417
1418         ret = poi_preference_foreach_sortable_field(NULL, capi_poi_preference_sortable_field_cb, NULL);
1419         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1420
1421 }
1422
1423
1424 static void utc_poi_preference_foreach_sortable_field_n_02(void)
1425 {
1426         int ret = POI_ERROR_NONE;
1427
1428         poi_service_h poi_manager ;
1429         ret = poi_service_create(&poi_manager);
1430         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
1431
1432         poi_preference_h pref;
1433         ret = poi_preference_create(&pref);
1434         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
1435         ret = poi_preference_set_max_result(pref, 5);
1436         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
1437         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
1438         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
1439         ret = poi_service_set_preference(poi_manager, pref);
1440         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
1441
1442         ret = poi_preference_foreach_sortable_field(poi_manager, NULL, NULL);
1443
1444         if (poi_manager) {
1445                 poi_service_destroy(poi_manager);
1446         }
1447
1448         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1449
1450 }
1451
1452 static void utc_poi_preference_set_sort_p(void)
1453 {
1454         int ret = POI_ERROR_NONE;
1455
1456         poi_preference_h pref;
1457         ret = poi_preference_create(&pref);
1458         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
1459
1460         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
1461
1462         if (pref) {
1463                 poi_preference_destroy(pref);
1464         }
1465
1466         validate_eq(__func__, ret, POI_ERROR_NONE);
1467 }
1468
1469 static void utc_poi_preference_set_sort_n(void)
1470 {
1471         int ret = POI_ERROR_NONE;
1472
1473         ret = poi_preference_set_sort(NULL, "Distance", POI_SORTORDER_ASC);
1474         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1475
1476 }
1477
1478
1479 static void utc_poi_preference_set_sort_n_02(void)
1480 {
1481         int ret = POI_ERROR_NONE;
1482
1483         poi_preference_h pref;
1484         ret = poi_preference_create(&pref);
1485         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
1486
1487         ret = poi_preference_set_sort(pref, NULL, POI_SORTORDER_ASC);
1488
1489         if (pref) {
1490                 poi_preference_destroy(pref);
1491         }
1492
1493         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1494
1495 }
1496
1497 static void utc_poi_preference_set_sort_n_03(void)
1498 {
1499         int ret = POI_ERROR_NONE;
1500
1501         poi_preference_h pref;
1502         ret = poi_preference_create(&pref);
1503         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
1504
1505         ret = poi_preference_set_sort(pref, "Distance", (poi_sort_order_e)5);
1506
1507         if (pref) {
1508                 poi_preference_destroy(pref);
1509         }
1510
1511         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1512
1513 }
1514
1515 static void utc_poi_preference_get_sort_p(void)
1516 {
1517         int ret = POI_ERROR_NONE;
1518
1519         poi_preference_h pref;
1520         ret = poi_preference_create(&pref);
1521         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
1522
1523         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
1524
1525         poi_sort_order_e order;
1526         char *sort_item = NULL;
1527         ret = poi_preference_get_sort(pref, &sort_item, &order);
1528
1529         if (pref) {
1530                 poi_preference_destroy(pref);
1531         }
1532         if (sort_item) free(sort_item);
1533
1534         validate_eq(__func__, ret, POI_ERROR_NONE);
1535 }
1536
1537 static void utc_poi_preference_get_sort_n(void)
1538 {
1539         int ret = POI_ERROR_NONE;
1540
1541         poi_sort_order_e order;
1542         char *sort_item = NULL;
1543         ret = poi_preference_get_sort(NULL, &sort_item, &order);
1544         if (sort_item) free(sort_item);
1545
1546         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1547
1548 }
1549
1550 static void utc_poi_preference_get_sort_n_02(void)
1551 {
1552         int ret = POI_ERROR_NONE;
1553
1554         poi_preference_h pref;
1555         ret = poi_preference_create(&pref);
1556         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
1557
1558         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
1559
1560         poi_sort_order_e order;
1561         ret = poi_preference_get_sort(pref, NULL, &order);
1562
1563         if (pref) {
1564                 poi_preference_destroy(pref);
1565         }
1566
1567         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1568
1569 }
1570
1571 static void utc_poi_preference_get_sort_n_03(void)
1572 {
1573         int ret = POI_ERROR_NONE;
1574
1575         poi_preference_h pref;
1576         ret = poi_preference_create(&pref);
1577         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
1578
1579         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
1580
1581         poi_sort_order_e order;
1582         char *sort_item = NULL;
1583         ret = poi_preference_get_sort(pref, &sort_item, NULL);
1584
1585         if (pref) {
1586                 poi_preference_destroy(pref);
1587         }
1588
1589         if (sort_item) free(sort_item);
1590
1591         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1592
1593 }
1594
1595 static bool capi_poi_preference_properties_cb(const char *key , const char *value,  void *user_data)
1596 {
1597         return true;
1598 }
1599
1600 static void utc_poi_preference_foreach_properties_p(void)
1601 {
1602         int ret = POI_ERROR_NONE;
1603
1604         poi_preference_h pref;
1605         ret = poi_preference_create(&pref);
1606         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
1607
1608         ret = poi_preference_set(pref, "LandmarkName", "cafe");
1609         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set() is failed");
1610
1611         ret = poi_preference_set(pref, "LandmarkType", "restaurant");
1612         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set() is failed");
1613
1614         ret = poi_preference_foreach_properties(pref, capi_poi_preference_properties_cb, NULL);
1615
1616         if (pref) {
1617                 poi_preference_destroy(pref);
1618         }
1619
1620         validate_eq(__func__, ret, POI_ERROR_NONE);
1621 }
1622
1623 static void utc_poi_preference_foreach_properties_n(void)
1624 {
1625         int ret = POI_ERROR_NONE;
1626
1627         ret = poi_preference_foreach_properties(NULL, capi_poi_preference_properties_cb, NULL);
1628         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1629
1630 }
1631
1632 static void utc_poi_preference_foreach_properties_n_02(void)
1633 {
1634         int ret = POI_ERROR_NONE;
1635
1636         poi_preference_h pref;
1637         ret = poi_preference_create(&pref);
1638         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
1639
1640         ret = poi_preference_set(pref, "LandmarkName", "cafe");
1641         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set() is failed");
1642
1643         ret = poi_preference_set(pref, "LandmarkType", "restaurant");
1644         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set() is failed");
1645
1646         ret = poi_preference_foreach_properties(pref, NULL, NULL);
1647
1648         if (pref) {
1649                 poi_preference_destroy(pref);
1650         }
1651
1652         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1653
1654 }
1655
1656 static bool capi_poi_preference_available_key_cb(const char *key , void *user_data)
1657 {
1658         return true;
1659 }
1660
1661 static void utc_poi_preference_foreach_available_keys_p(void)
1662 {
1663         int ret = POI_ERROR_NONE;
1664
1665         poi_service_h poi_manager ;
1666         ret = poi_service_create(&poi_manager);
1667         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
1668
1669         poi_preference_h pref;
1670         ret = poi_preference_create(&pref);
1671         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
1672         ret = poi_preference_set_max_result(pref, 5);
1673         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
1674         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
1675         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
1676         ret = poi_service_set_preference(poi_manager, pref);
1677         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
1678
1679         ret = poi_preference_foreach_available_keys(poi_manager, capi_poi_preference_available_key_cb, NULL);
1680
1681         if (poi_manager) {
1682                 poi_service_destroy(poi_manager);
1683         }
1684
1685         validate_eq(__func__, ret, POI_ERROR_NONE);
1686 }
1687
1688 static void utc_poi_preference_foreach_available_keys_n(void)
1689 {
1690         int ret = POI_ERROR_NONE;
1691
1692         ret = poi_preference_foreach_available_keys(NULL, capi_poi_preference_available_key_cb, NULL);
1693         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1694
1695 }
1696
1697 static void utc_poi_preference_foreach_available_keys_n_02(void)
1698 {
1699         int ret = POI_ERROR_NONE;
1700
1701         poi_service_h poi_manager ;
1702         ret = poi_service_create(&poi_manager);
1703         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
1704
1705         poi_preference_h pref;
1706         ret = poi_preference_create(&pref);
1707         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
1708         ret = poi_preference_set_max_result(pref, 5);
1709         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
1710         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
1711         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
1712         ret = poi_service_set_preference(poi_manager, pref);
1713         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
1714
1715         ret = poi_preference_foreach_available_keys(poi_manager, NULL, NULL);
1716
1717         if (poi_manager) {
1718                 poi_service_destroy(poi_manager);
1719         }
1720
1721         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1722
1723 }
1724
1725
1726 static bool capi_poi_preference_available_value_cb(const char *value , void *user_data)
1727 {
1728         return true;
1729 }
1730
1731 static void utc_poi_preference_foreach_available_values_p(void)
1732 {
1733         int ret = POI_ERROR_NONE;
1734
1735         poi_service_h poi_manager ;
1736         ret = poi_service_create(&poi_manager);
1737         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
1738
1739         poi_preference_h pref;
1740         ret = poi_preference_create(&pref);
1741         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
1742         ret = poi_preference_set_max_result(pref, 5);
1743         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
1744         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
1745         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
1746         ret = poi_service_set_preference(poi_manager, pref);
1747         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
1748
1749         ret = poi_preference_foreach_available_values(poi_manager, "KEYWORD", capi_poi_preference_available_value_cb, NULL);
1750
1751         if (poi_manager) {
1752                 poi_service_destroy(poi_manager);
1753         }
1754
1755         validate_eq(__func__, ret, POI_ERROR_NONE);
1756 }
1757
1758 static void utc_poi_preference_foreach_available_values_n(void)
1759 {
1760         int ret = POI_ERROR_NONE;
1761
1762         ret = poi_preference_foreach_available_values(NULL, "KEYWORD", capi_poi_preference_available_value_cb, NULL);
1763
1764         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1765
1766 }
1767
1768 static void utc_poi_preference_foreach_available_values_n_02(void)
1769 {
1770         int ret = POI_ERROR_NONE;
1771
1772         poi_service_h poi_manager ;
1773         ret = poi_service_create(&poi_manager);
1774         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
1775
1776         poi_preference_h pref;
1777         ret = poi_preference_create(&pref);
1778         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
1779         ret = poi_preference_set_max_result(pref, 5);
1780         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
1781         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
1782         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
1783         ret = poi_service_set_preference(poi_manager, pref);
1784         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
1785
1786         ret = poi_preference_foreach_available_values(poi_manager, NULL, capi_poi_preference_available_value_cb, NULL);
1787
1788         if (poi_manager) {
1789                 poi_service_destroy(poi_manager);
1790         }
1791
1792         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1793
1794 }
1795
1796 static void utc_poi_preference_foreach_available_values_n_03(void)
1797 {
1798         int ret = POI_ERROR_NONE;
1799
1800         poi_service_h poi_manager ;
1801         ret = poi_service_create(&poi_manager);
1802         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
1803
1804         poi_preference_h pref;
1805         ret = poi_preference_create(&pref);
1806         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
1807         ret = poi_preference_set_max_result(pref, 5);
1808         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
1809         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
1810         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
1811         ret = poi_service_set_preference(poi_manager, pref);
1812         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
1813
1814         ret = poi_preference_foreach_available_values(poi_manager, "KEYWORD", NULL, NULL);
1815
1816         if (poi_manager) {
1817                 poi_service_destroy(poi_manager);
1818         }
1819
1820         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1821
1822 }
1823
1824
1825 static void utc_poi_filter_create_p(void)
1826 {
1827         int ret = POI_ERROR_NONE;
1828
1829         poi_filter_h filter;
1830         ret = poi_filter_create(&filter);
1831
1832         if (filter) {
1833                 poi_filter_destroy(filter);
1834         }
1835
1836         validate_eq(__func__, ret, POI_ERROR_NONE);
1837 }
1838
1839 static void utc_poi_filter_create_n(void)
1840 {
1841         int ret = POI_ERROR_NONE;
1842
1843         ret = poi_filter_create(NULL);
1844         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1845 }
1846
1847 static void utc_poi_filter_destroy_p(void)
1848 {
1849         int ret = POI_ERROR_NONE;
1850
1851         poi_filter_h filter;
1852         ret = poi_filter_create(&filter);
1853         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
1854
1855         ret = poi_filter_destroy(filter);
1856         validate_eq(__func__, ret, POI_ERROR_NONE);
1857 }
1858
1859 static void utc_poi_filter_destroy_n(void)
1860 {
1861         int ret = POI_ERROR_NONE;
1862
1863         ret = poi_filter_destroy(NULL);
1864         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1865 }
1866
1867 static void utc_poi_filter_set_p(void)
1868 {
1869         int ret = POI_ERROR_NONE;
1870
1871         poi_filter_h filter;
1872         ret = poi_filter_create(&filter);
1873         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
1874
1875         // "CATEGORY", "KEYWORD", "POINAME"
1876         ret = poi_filter_set(filter, "KEYWORD", "cafe");
1877
1878         if (filter) {
1879                 poi_filter_destroy(filter);
1880         }
1881
1882         validate_eq(__func__, ret, POI_ERROR_NONE);
1883 }
1884
1885 static void utc_poi_filter_set_n(void)
1886 {
1887         int ret = POI_ERROR_NONE;
1888
1889         ret = poi_filter_set(NULL, "KEYWORD", "cafe");
1890         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1891 }
1892
1893 static void utc_poi_filter_set_n_02(void)
1894 {
1895         int ret = POI_ERROR_NONE;
1896
1897         poi_filter_h filter;
1898         ret = poi_filter_create(&filter);
1899         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
1900
1901         ret = poi_filter_set(filter, NULL, "cafe");
1902
1903         if (filter) {
1904                 poi_filter_destroy(filter);
1905         }
1906
1907         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1908 }
1909
1910 static void utc_poi_filter_set_n_03(void)
1911 {
1912         int ret = POI_ERROR_NONE;
1913
1914         poi_filter_h filter;
1915         ret = poi_filter_create(&filter);
1916         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
1917
1918         ret = poi_filter_set(filter, "KEYWORD", NULL);
1919
1920         if (filter) {
1921                 poi_filter_destroy(filter);
1922         }
1923
1924         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1925 }
1926
1927 static void utc_poi_filter_get_p(void)
1928 {
1929         int ret = POI_ERROR_NONE;
1930
1931         poi_filter_h filter;
1932         ret = poi_filter_create(&filter);
1933         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
1934
1935         // "CATEGORY", "KEYWORD", "POINAME"
1936         ret = poi_filter_set(filter, "KEYWORD", "cafe");
1937         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
1938
1939         char *value;
1940         ret = poi_filter_get(filter, "KEYWORD", &value);
1941
1942         if (filter) {
1943                 poi_filter_destroy(filter);
1944         }
1945
1946         validate_eq(__func__, ret, POI_ERROR_NONE);
1947 }
1948
1949 static void utc_poi_filter_get_n(void)
1950 {
1951         int ret = POI_ERROR_NONE;
1952
1953         char *value;
1954         ret = poi_filter_get(NULL, "KEYWORD", &value);
1955         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1956 }
1957
1958 static void utc_poi_filter_get_n_02(void)
1959 {
1960         int ret = POI_ERROR_NONE;
1961
1962         poi_filter_h filter;
1963         ret = poi_filter_create(&filter);
1964         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
1965
1966         // "CATEGORY", "KEYWORD", "POINAME"
1967         ret = poi_filter_set(filter, "KEYWORD", "cafe");
1968         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
1969
1970         char *value;
1971         ret = poi_filter_get(filter, NULL, &value);
1972
1973         if (filter) {
1974                 poi_filter_destroy(filter);
1975         }
1976
1977         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
1978 }
1979
1980 static void utc_poi_filter_get_n_03(void)
1981 {
1982         int ret = POI_ERROR_NONE;
1983
1984         poi_filter_h filter;
1985         ret = poi_filter_create(&filter);
1986         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
1987
1988         // "CATEGORY", "KEYWORD", "POINAME"
1989         ret = poi_filter_set(filter, "KEYWORD", "cafe");
1990         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
1991
1992         char *value;
1993         ret = poi_filter_get(filter, "KEYWORD", NULL);
1994
1995         if (filter) {
1996                 poi_filter_destroy(filter);
1997         }
1998
1999         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
2000 }
2001
2002 static bool capi_poi_filter_properties_cb(const char *key , const char *value , void *user_data)
2003 {
2004         return true;
2005 }
2006
2007 static void utc_poi_filter_foreach_properties_p(void)
2008 {
2009         int ret = POI_ERROR_NONE;
2010
2011         poi_filter_h filter;
2012         ret = poi_filter_create(&filter);
2013         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
2014
2015         // "CATEGORY", "KEYWORD", "POINAME"
2016         ret = poi_filter_set(filter, "KEYWORD", "cafe");
2017         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
2018
2019         ret = poi_filter_set(filter, "CATEGORY", "restaurant");
2020         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
2021
2022         ret = poi_filter_foreach_properties(filter, capi_poi_filter_properties_cb, NULL);
2023
2024         if (filter) {
2025                 poi_filter_destroy(filter);
2026         }
2027
2028         validate_eq(__func__, ret, POI_ERROR_NONE);
2029 }
2030
2031 static void utc_poi_filter_foreach_properties_n(void)
2032 {
2033         int ret = POI_ERROR_NONE;
2034
2035         ret = poi_filter_foreach_properties(NULL, capi_poi_filter_properties_cb, NULL);
2036         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
2037 }
2038
2039 static void utc_poi_filter_foreach_properties_n_02(void)
2040 {
2041         int ret = POI_ERROR_NONE;
2042
2043         poi_filter_h filter;
2044         ret = poi_filter_create(&filter);
2045         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
2046
2047         // "CATEGORY", "KEYWORD", "POINAME"
2048         ret = poi_filter_set(filter, "KEYWORD", "cafe");
2049         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
2050
2051         ret = poi_filter_set(filter, "CATEGORY", "restaurant");
2052         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
2053
2054         ret = poi_filter_foreach_properties(filter, NULL, NULL);
2055
2056         if (filter) {
2057                 poi_filter_destroy(filter);
2058         }
2059
2060         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
2061 }
2062
2063 static bool capi_poi_filter_available_key_cb(const char *key , void *user_data)
2064 {
2065         return true;
2066 }
2067
2068 static void utc_poi_filter_foreach_available_keys_p(void)
2069 {
2070         int ret = POI_ERROR_NONE;
2071
2072         poi_service_h poi_manager ;
2073         ret = poi_service_create(&poi_manager);
2074         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
2075
2076         poi_preference_h pref;
2077         ret = poi_preference_create(&pref);
2078         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
2079         ret = poi_preference_set_max_result(pref, 5);
2080         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
2081         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
2082         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
2083         ret = poi_service_set_preference(poi_manager, pref);
2084         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
2085
2086         ret = poi_filter_foreach_available_keys(poi_manager, capi_poi_filter_available_key_cb, NULL);
2087
2088         if (poi_manager) {
2089                 poi_service_destroy(poi_manager);
2090         }
2091
2092         validate_eq(__func__, ret, POI_ERROR_NONE);
2093 }
2094
2095 static void utc_poi_filter_foreach_available_keys_n(void)
2096 {
2097         int ret = POI_ERROR_NONE;
2098
2099         poi_service_h poi_manager ;
2100         ret = poi_service_create(&poi_manager);
2101         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
2102
2103         poi_preference_h pref;
2104         ret = poi_preference_create(&pref);
2105         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
2106         ret = poi_preference_set_max_result(pref, 5);
2107         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
2108         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
2109         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
2110         ret = poi_service_set_preference(poi_manager, pref);
2111         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
2112
2113         ret = poi_filter_foreach_available_keys(poi_manager, NULL, NULL);
2114
2115         if (poi_manager) {
2116                 poi_service_destroy(poi_manager);
2117         }
2118
2119         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
2120 }
2121
2122 static void utc_poi_filter_foreach_available_keys_n_02(void)
2123 {
2124         int ret = POI_ERROR_NONE;
2125
2126         ret = poi_filter_foreach_available_keys(NULL, capi_poi_filter_available_key_cb, NULL);
2127
2128         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
2129 }
2130
2131
2132 static bool capi_poi_filter_available_value_cb(const char *value , void *user_data)
2133 {
2134         return true;
2135 }
2136
2137 static void utc_poi_filter_foreach_available_values_p(void)
2138 {
2139         int ret = POI_ERROR_NONE;
2140
2141         poi_service_h poi_manager ;
2142         ret = poi_service_create(&poi_manager);
2143         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
2144
2145         poi_preference_h pref;
2146         ret = poi_preference_create(&pref);
2147         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
2148         ret = poi_preference_set_max_result(pref, 5);
2149         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
2150         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
2151         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
2152         ret = poi_service_set_preference(poi_manager, pref);
2153         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
2154
2155         ret = poi_filter_foreach_available_values(poi_manager, "KEYWORD", capi_poi_filter_available_value_cb, NULL);
2156
2157         if (poi_manager) {
2158                 poi_service_destroy(poi_manager);
2159         }
2160
2161         validate_eq(__func__, ret, POI_ERROR_NONE);
2162 }
2163
2164 static void utc_poi_filter_foreach_available_values_n(void)
2165 {
2166         int ret = POI_ERROR_NONE;
2167
2168         poi_service_h poi_manager ;
2169         ret = poi_service_create(&poi_manager);
2170         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
2171
2172         poi_preference_h pref;
2173         ret = poi_preference_create(&pref);
2174         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
2175         ret = poi_preference_set_max_result(pref, 5);
2176         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
2177         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
2178         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
2179         ret = poi_service_set_preference(poi_manager, pref);
2180         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
2181
2182         ret = poi_filter_foreach_available_values(poi_manager, NULL, capi_poi_filter_available_value_cb, NULL);
2183
2184         if (poi_manager) {
2185                 poi_service_destroy(poi_manager);
2186         }
2187
2188         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
2189 }
2190
2191 static void utc_poi_filter_foreach_available_values_n_02(void)
2192 {
2193         int ret = POI_ERROR_NONE;
2194
2195         poi_service_h poi_manager ;
2196         ret = poi_service_create(&poi_manager);
2197         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
2198
2199         poi_preference_h pref;
2200         ret = poi_preference_create(&pref);
2201         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
2202         ret = poi_preference_set_max_result(pref, 5);
2203         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
2204         ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
2205         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
2206         ret = poi_service_set_preference(poi_manager, pref);
2207         validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
2208
2209         ret = poi_filter_foreach_available_values(poi_manager, "KEYWORD", NULL, NULL);
2210
2211         if (poi_manager) {
2212                 poi_service_destroy(poi_manager);
2213         }
2214
2215         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
2216 }
2217
2218 static void utc_poi_filter_foreach_available_values_n_03(void)
2219 {
2220         int ret = POI_ERROR_NONE;
2221
2222         ret = poi_filter_foreach_available_values(NULL, "KEYWORD", capi_poi_filter_available_value_cb, NULL);
2223
2224         validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
2225 }
2226
2227
2228