Release Tizen2.0 beta

diff --git a/CMakeLists.txt b/CMakeLists.txt
index cb93c23..8496e40 100755 (executable)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -61,7 +61,7 @@ CONFIGURE_FILE(
 )
 INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${fw_name}.pc DESTINATION lib/pkgconfig)
 
-#ADD_SUBDIRECTORY(test)
+ADD_SUBDIRECTORY(test)
 
 IF(UNIX)
 

diff --git a/TC/_export_env.sh b/TC/_export_env.sh
new file mode 100755 (executable)
index 0000000..72a11ec
--- /dev/null
+++ b/TC/_export_env.sh
@@ -0,0 +1,8 @@
+#!/bin/sh
+
+. ./config
+export TET_INSTALL_PATH=$TET_INSTALL_HOST_PATH # tetware root path
+export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-target # tetware target path
+export PATH=$TET_TARGET_PATH/bin:$PATH
+export LD_LIBRARY_PATH=$TET_TARGET_PATH/lib/tet3:$LD_LIBRARY_PATH
+export TET_ROOT=$TET_TARGET_PATH

diff --git a/TC/_export_target_env.sh b/TC/_export_target_env.sh
new file mode 100755 (executable)
index 0000000..5ddaa53
--- /dev/null
+++ b/TC/_export_target_env.sh
@@ -0,0 +1,7 @@
+#!/bin/sh
+. ./config
+export TET_INSTALL_PATH=$TET_INSTALL_TARGET_PATH # path to path
+export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-target
+export PATH=$TET_TARGET_PATH/bin:$PATH
+export LD_LIBRARY_PATH=$TET_TARGET_PATH/lib/tet3:$LD_LIBRARY_PATH
+export TET_ROOT=$TET_TARGET_PATH

diff --git a/TC/build.sh b/TC/build.sh
new file mode 100755 (executable)
index 0000000..72aad6c
--- /dev/null
+++ b/TC/build.sh
@@ -0,0 +1,16 @@
+#!/bin/sh
+
+. ./_export_env.sh                              # setting environment variables
+
+export TET_SUITE_ROOT=`pwd`
+FILE_NAME_EXTENSION=`date +%s`
+
+RESULT_DIR=results
+HTML_RESULT=$RESULT_DIR/build-tar-result-$FILE_NAME_EXTENSION.html
+JOURNAL_RESULT=$RESULT_DIR/build-tar-result-$FILE_NAME_EXTENSION.journal
+
+mkdir -p $RESULT_DIR
+
+tcc -c -p ./
+tcc -b -j $JOURNAL_RESULT -p ./
+grw -c 7 -f chtml -o $HTML_RESULT $JOURNAL_RESULT

diff --git a/TC/clean.sh b/TC/clean.sh
new file mode 100755 (executable)
index 0000000..29743e0
--- /dev/null
+++ b/TC/clean.sh
@@ -0,0 +1,11 @@
+#!/bin/sh
+
+. ./_export_env.sh                              # setting environment variables
+
+export TET_SUITE_ROOT=`pwd`
+RESULT_DIR=results
+
+tcc -c -p ./                                # executing tcc, with clean option (-c)
+rm -r $RESULT_DIR
+rm -r tet_tmp_dir
+rm testcase/tet_captured

diff --git a/TC/config b/TC/config
new file mode 100755 (executable)
index 0000000..04684f0
--- /dev/null
+++ b/TC/config
@@ -0,0 +1,2 @@
+TET_INSTALL_HOST_PATH=/home/rookiejava/dts_tool/TETware
+TET_INSTALL_TARGET_PATH=/mnt/nfs/dts_tool/TETware

diff --git a/TC/execute.sh b/TC/execute.sh
new file mode 100755 (executable)
index 0000000..a4f6095
--- /dev/null
+++ b/TC/execute.sh
@@ -0,0 +1,15 @@
+#!/bin/sh
+
+. ./_export_target_env.sh                    # setting environment variables
+
+export TET_SUITE_ROOT=`pwd`
+FILE_NAME_EXTENSION=`date +%s`
+
+RESULT_DIR=results
+HTML_RESULT=$RESULT_DIR/exec-tar-result-$FILE_NAME_EXTENSION.html
+JOURNAL_RESULT=$RESULT_DIR/exec-tar-result-$FILE_NAME_EXTENSION.journal
+
+mkdir -p $RESULT_DIR
+
+tcc -e -j $JOURNAL_RESULT -p ./
+grw -c 3 -f chtml -o $HTML_RESULT $JOURNAL_RESULT

diff --git a/TC/testcase/Makefile b/TC/testcase/Makefile
new file mode 100755 (executable)
index 0000000..90e77f6
--- /dev/null
+++ b/TC/testcase/Makefile
@@ -0,0 +1,25 @@
+CC ?= gcc
+
+C_FILES = $(shell ls *.c)
+
+PKGS = capi-location-poi dlog glib-2.0 gthread-2.0
+
+LDFLAGS = `pkg-config --libs $(PKGS)`
+LDFLAGS += $(TET_ROOT)/lib/tet3/tcm_s.o
+LDFLAGS += -L$(TET_ROOT)/lib/tet3 -ltcm_s
+LDFLAGS += -L$(TET_ROOT)/lib/tet3 -lapi_s
+
+CFLAGS = -I. `pkg-config --cflags $(PKGS)`
+CFLAGS += -I$(TET_ROOT)/inc/tet3
+CFLAGS += -Wall
+
+#TARGETS = $(C_FILES:%.c=tc-%)
+TCS := $(shell ls -1 *.c | cut -d. -f1)
+
+all: $(TCS)
+
+%: %.c
+       $(CC) -o $@ $< $(CFLAGS) $(LDFLAGS)
+
+clean:
+       rm -f $(TCS)

diff --git a/TC/testcase/tslist b/TC/testcase/tslist
new file mode 100755 (executable)
index 0000000..d494023
--- /dev/null
+++ b/TC/testcase/tslist
@@ -0,0 +1,2 @@
+/testcase/utc_location_poi
+/testcase/utc_location_poi_callback

diff --git a/TC/testcase/utc_location_poi.c b/TC/testcase/utc_location_poi.c
new file mode 100755 (executable)
index 0000000..aa8c6f9
--- /dev/null
+++ b/TC/testcase/utc_location_poi.c
@@ -0,0 +1,2228 @@
+/*
+* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include <tet_api.h>
+#include <poi.h>
+#include <glib.h>
+#include <location/location.h>
+
+enum {
+       POSITIVE_TC_IDX = 0x01,
+       NEGATIVE_TC_IDX,
+};
+
+static void startup(void);
+static void cleanup(void);
+
+void (*tet_startup)(void) = startup;
+void (*tet_cleanup)(void) = cleanup;
+
+static void utc_poi_service_create_p(void);
+static void utc_poi_service_create_n(void);
+static void utc_poi_service_destroy_p(void);
+static void utc_poi_service_destroy_n(void);
+static void utc_poi_service_get_preference_p(void);
+static void utc_poi_service_get_preference_n(void);
+static void utc_poi_service_get_preference_n_02(void);
+static void utc_poi_service_set_preference_p(void);
+static void utc_poi_service_set_preference_n(void);
+static void utc_poi_service_set_preference_n_02(void);
+static void utc_poi_service_search_p(void);
+static void utc_poi_service_search_n(void);
+static void utc_poi_service_search_n_02(void);
+static void utc_poi_service_search_n_03(void);
+static void utc_poi_service_search_n_04(void);
+static void utc_poi_service_search_n_05(void);
+static void utc_poi_service_search_by_area_p(void);
+static void utc_poi_service_search_by_area_n(void);
+static void utc_poi_service_search_by_area_n_02(void);
+static void utc_poi_service_search_by_area_n_03(void);
+static void utc_poi_service_search_by_area_n_04(void);
+static void utc_poi_service_search_by_address_p(void);
+static void utc_poi_service_search_by_address_n(void);
+static void utc_poi_service_search_by_address_n_02(void);
+static void utc_poi_service_search_by_address_n_03(void);
+static void utc_poi_service_search_by_address_n_04(void);
+static void utc_poi_service_cancel_p(void);
+static void utc_poi_service_cancel_n(void);
+static void utc_poi_service_cancel_n_02(void);
+static void utc_poi_preference_create_p(void);
+static void utc_poi_preference_create_n(void);
+static void utc_poi_preference_destroy_p(void);
+static void utc_poi_preference_destroy_n(void);
+static void utc_poi_preference_get_p(void);
+static void utc_poi_preference_get_n(void);
+static void utc_poi_preference_get_n_02(void);
+static void utc_poi_preference_get_n_03(void);
+static void utc_poi_preference_set_p(void);
+static void utc_poi_preference_set_n(void);
+static void utc_poi_preference_set_n_02(void);
+static void utc_poi_preference_set_n_03(void);
+static void utc_poi_preference_set_max_result_p(void);
+static void utc_poi_preference_set_max_result_n(void);
+static void utc_poi_preference_set_max_result_n_02(void);
+static void utc_poi_preference_get_max_result_p(void);
+static void utc_poi_preference_get_max_result_n(void);
+static void utc_poi_preference_get_max_result_n_02(void);
+static void utc_poi_preference_foreach_sortable_field_p(void);
+static void utc_poi_preference_foreach_sortable_field_n(void);
+static void utc_poi_preference_foreach_sortable_field_n_02(void);
+static void utc_poi_preference_set_sort_p(void);
+static void utc_poi_preference_set_sort_n(void);
+static void utc_poi_preference_set_sort_n_02(void);
+static void utc_poi_preference_set_sort_n_03(void);
+static void utc_poi_preference_get_sort_p(void);
+static void utc_poi_preference_get_sort_n(void);
+static void utc_poi_preference_get_sort_n_02(void);
+static void utc_poi_preference_get_sort_n_03(void);
+static void utc_poi_preference_foreach_properties_p(void);
+static void utc_poi_preference_foreach_properties_n(void);
+static void utc_poi_preference_foreach_properties_n_02(void);
+static void utc_poi_preference_foreach_available_keys_p(void);
+static void utc_poi_preference_foreach_available_keys_n(void);
+static void utc_poi_preference_foreach_available_keys_n_02(void);
+static void utc_poi_preference_foreach_available_values_p(void);
+static void utc_poi_preference_foreach_available_values_n(void);
+static void utc_poi_preference_foreach_available_values_n_02(void);
+static void utc_poi_preference_foreach_available_values_n_03(void);
+static void utc_poi_filter_create_p(void);
+static void utc_poi_filter_create_n(void);
+static void utc_poi_filter_destroy_p(void);
+static void utc_poi_filter_destroy_n(void);
+static void utc_poi_filter_set_p(void);
+static void utc_poi_filter_set_n(void);
+static void utc_poi_filter_set_n_02(void);
+static void utc_poi_filter_set_n_03(void);
+static void utc_poi_filter_get_p(void);
+static void utc_poi_filter_get_n(void);
+static void utc_poi_filter_get_n_02(void);
+static void utc_poi_filter_get_n_03(void);
+static void utc_poi_filter_foreach_properties_p(void);
+static void utc_poi_filter_foreach_properties_n(void);
+static void utc_poi_filter_foreach_properties_n_02(void);
+static void utc_poi_filter_foreach_available_keys_p(void);
+static void utc_poi_filter_foreach_available_keys_n(void);
+static void utc_poi_filter_foreach_available_keys_n_02(void);
+static void utc_poi_filter_foreach_available_values_p(void);
+static void utc_poi_filter_foreach_available_values_n(void);
+static void utc_poi_filter_foreach_available_values_n_02(void);
+static void utc_poi_filter_foreach_available_values_n_03(void);
+
+struct tet_testlist tet_testlist[] = {
+       { utc_poi_service_create_p, POSITIVE_TC_IDX },
+       { utc_poi_service_create_n, NEGATIVE_TC_IDX },
+       { utc_poi_service_destroy_p, POSITIVE_TC_IDX },
+       { utc_poi_service_destroy_n, NEGATIVE_TC_IDX },
+       { utc_poi_service_get_preference_p, POSITIVE_TC_IDX },
+       { utc_poi_service_get_preference_n, NEGATIVE_TC_IDX },
+       { utc_poi_service_get_preference_n_02, NEGATIVE_TC_IDX },
+       { utc_poi_service_set_preference_p, POSITIVE_TC_IDX },
+       { utc_poi_service_set_preference_n, NEGATIVE_TC_IDX },
+       { utc_poi_service_set_preference_n_02, NEGATIVE_TC_IDX },
+       { utc_poi_service_search_p, POSITIVE_TC_IDX },
+       { utc_poi_service_search_n, NEGATIVE_TC_IDX },
+       { utc_poi_service_search_n_02, NEGATIVE_TC_IDX },
+       { utc_poi_service_search_n_03, NEGATIVE_TC_IDX },
+       { utc_poi_service_search_n_04, NEGATIVE_TC_IDX },
+       //{ utc_poi_service_search_n_05, NEGATIVE_TC_IDX }, // It is not a negative TC.
+       { utc_poi_service_search_by_area_p, POSITIVE_TC_IDX },
+       { utc_poi_service_search_by_area_n, NEGATIVE_TC_IDX },
+       { utc_poi_service_search_by_area_n_02, NEGATIVE_TC_IDX },
+       { utc_poi_service_search_by_area_n_03, NEGATIVE_TC_IDX },
+       //{ utc_poi_service_search_by_area_n_04, NEGATIVE_TC_IDX }, // It is not a negative TC.
+       { utc_poi_service_search_by_address_p, POSITIVE_TC_IDX },
+       { utc_poi_service_search_by_address_n, NEGATIVE_TC_IDX },
+       { utc_poi_service_search_by_address_n_02, NEGATIVE_TC_IDX },
+       { utc_poi_service_search_by_address_n_03, NEGATIVE_TC_IDX },
+       //{ utc_poi_service_search_by_address_n_04, NEGATIVE_TC_IDX }, // It is not a negative TC.
+       { utc_poi_service_cancel_p, POSITIVE_TC_IDX },
+       { utc_poi_service_cancel_n, NEGATIVE_TC_IDX },
+       //{ utc_poi_service_cancel_n_02, NEGATIVE_TC_IDX },     // It is not a negative TC.
+       { utc_poi_preference_create_p, POSITIVE_TC_IDX },
+       { utc_poi_preference_create_n, NEGATIVE_TC_IDX },
+       { utc_poi_preference_destroy_p, POSITIVE_TC_IDX },
+       { utc_poi_preference_destroy_n, NEGATIVE_TC_IDX },
+       { utc_poi_preference_get_p, POSITIVE_TC_IDX },
+       { utc_poi_preference_get_n, NEGATIVE_TC_IDX },
+       { utc_poi_preference_get_n_02, NEGATIVE_TC_IDX },
+       { utc_poi_preference_get_n_03, NEGATIVE_TC_IDX },
+       { utc_poi_preference_set_p, POSITIVE_TC_IDX },
+       { utc_poi_preference_set_n, NEGATIVE_TC_IDX },
+       { utc_poi_preference_set_n_02, NEGATIVE_TC_IDX },
+//     { utc_poi_preference_set_n_03, NEGATIVE_TC_IDX },               // TODO: Check
+       { utc_poi_preference_set_max_result_p, POSITIVE_TC_IDX },
+       { utc_poi_preference_set_max_result_n, NEGATIVE_TC_IDX },
+//     { utc_poi_preference_set_max_result_n_02, NEGATIVE_TC_IDX },    //TODO: Check range
+       { utc_poi_preference_get_max_result_p, POSITIVE_TC_IDX },
+       { utc_poi_preference_get_max_result_n, NEGATIVE_TC_IDX },
+       { utc_poi_preference_get_max_result_n_02, NEGATIVE_TC_IDX },
+       { utc_poi_preference_foreach_sortable_field_p, POSITIVE_TC_IDX },
+       { utc_poi_preference_foreach_sortable_field_n, NEGATIVE_TC_IDX },
+       { utc_poi_preference_foreach_sortable_field_n_02, NEGATIVE_TC_IDX },
+       { utc_poi_preference_set_sort_p, POSITIVE_TC_IDX },
+       { utc_poi_preference_set_sort_n, NEGATIVE_TC_IDX },
+       { utc_poi_preference_set_sort_n_02, NEGATIVE_TC_IDX },
+//     { utc_poi_preference_set_sort_n_03, NEGATIVE_TC_IDX },          //TODO: Check range
+       { utc_poi_preference_get_sort_p, POSITIVE_TC_IDX },
+       { utc_poi_preference_get_sort_n, NEGATIVE_TC_IDX },
+       { utc_poi_preference_get_sort_n_02, NEGATIVE_TC_IDX },
+       { utc_poi_preference_get_sort_n_03, NEGATIVE_TC_IDX },
+       { utc_poi_preference_foreach_properties_p, POSITIVE_TC_IDX },
+       { utc_poi_preference_foreach_properties_n, NEGATIVE_TC_IDX },
+       { utc_poi_preference_foreach_properties_n_02, NEGATIVE_TC_IDX },
+       { utc_poi_preference_foreach_available_keys_p, POSITIVE_TC_IDX },
+       { utc_poi_preference_foreach_available_keys_n, NEGATIVE_TC_IDX },
+       { utc_poi_preference_foreach_available_keys_n_02, NEGATIVE_TC_IDX },
+       //{ utc_poi_preference_foreach_available_values_p, POSITIVE_TC_IDX }, // It is not a negative TC. value can be NULL.
+       //{ utc_poi_preference_foreach_available_values_n, NEGATIVE_TC_IDX },
+       //{ utc_poi_preference_foreach_available_values_n_02, NEGATIVE_TC_IDX },
+       //{ utc_poi_preference_foreach_available_values_n_03, NEGATIVE_TC_IDX },
+       { utc_poi_filter_create_p, POSITIVE_TC_IDX },
+       { utc_poi_filter_create_n, NEGATIVE_TC_IDX },
+       { utc_poi_filter_destroy_p, POSITIVE_TC_IDX },
+       { utc_poi_filter_destroy_n, NEGATIVE_TC_IDX },
+       { utc_poi_filter_set_p, POSITIVE_TC_IDX },
+       { utc_poi_filter_set_n, NEGATIVE_TC_IDX },
+       { utc_poi_filter_set_n_02, NEGATIVE_TC_IDX },
+       //{ utc_poi_filter_set_n_03, NEGATIVE_TC_IDX }, // It is not a negative TC. value can be NULL.
+       { utc_poi_filter_get_p, POSITIVE_TC_IDX },
+       { utc_poi_filter_get_n, NEGATIVE_TC_IDX },
+       { utc_poi_filter_get_n_02, NEGATIVE_TC_IDX },
+       { utc_poi_filter_get_n_03, NEGATIVE_TC_IDX },
+       { utc_poi_filter_foreach_properties_p, POSITIVE_TC_IDX },
+       { utc_poi_filter_foreach_properties_n, NEGATIVE_TC_IDX },
+       { utc_poi_filter_foreach_properties_n_02, NEGATIVE_TC_IDX },
+       { utc_poi_filter_foreach_available_keys_p, POSITIVE_TC_IDX },
+       { utc_poi_filter_foreach_available_keys_n, NEGATIVE_TC_IDX },
+       { utc_poi_filter_foreach_available_keys_n_02, NEGATIVE_TC_IDX }, 
+       //{ utc_poi_filter_foreach_available_values_p, POSITIVE_TC_IDX }, //It is not implemented yet.
+       //{ utc_poi_filter_foreach_available_values_n, NEGATIVE_TC_IDX },
+       //{ utc_poi_filter_foreach_available_values_n_02, NEGATIVE_TC_IDX },
+       //{ utc_poi_filter_foreach_available_values_n_03, NEGATIVE_TC_IDX },
+       { NULL, 0 },
+};
+
+
+static GMainLoop *g_mainloop = NULL;
+static GThread *event_thread;
+
+gpointer GmainThread(gpointer data){
+       g_mainloop = g_main_loop_new (NULL, 0);
+       g_main_loop_run (g_mainloop);
+
+       return NULL;
+}
+
+
+static void validate_and_next(char* api_name,int act_ret, int ext_ret, char* fail_msg)
+{
+       dts_message(api_name, "Actual Result : %d, Expected Result : %d", act_ret,ext_ret);
+       if (act_ret != ext_ret)
+       {
+               dts_message(api_name, "Fail Message: %s", fail_msg);
+               dts_fail(api_name);
+       }
+}
+
+static void validate_eq(char* api_name,int act_ret, int ext_ret)
+{
+       dts_message(api_name, "Actual Result : %d, Expected Result : %d", act_ret,ext_ret);
+       if (act_ret == ext_ret) {
+               dts_pass(api_name);
+       } else {
+               dts_fail(api_name);
+       }
+}
+
+
+static void startup(void)
+{
+       g_setenv("PKG_NAME", "org.tizen.capi-location-poi-test", 1);
+       g_setenv("LOCATION_TEST_ENABLE", "1", 1);
+
+#if !GLIB_CHECK_VERSION (2, 31, 0)
+       if( !g_thread_supported() )
+       {
+               g_thread_init(NULL);
+       }
+#endif
+
+       GError *gerr = NULL;
+       event_thread = g_thread_create(GmainThread, NULL, 1, &gerr);
+}
+
+static void cleanup(void)
+{
+
+       g_main_loop_quit (g_mainloop);
+       g_thread_join(event_thread);
+}
+
+static void utc_poi_service_create_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_NONE);
+}
+
+static void utc_poi_service_create_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       ret = poi_service_create(NULL);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_service_destroy_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       ret = poi_service_destroy(poi_manager);
+       validate_eq(__func__, ret, POI_ERROR_NONE);
+}
+
+static void utc_poi_service_destroy_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       ret = poi_service_destroy(NULL);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_service_get_preference_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+
+       poi_preference_h preference;
+       ret = poi_service_get_preference(poi_manager, &preference);
+
+       if (poi_manager) {
+               // free pref also
+               poi_service_destroy(poi_manager);
+       }
+
+
+       validate_eq(__func__, ret, POI_ERROR_NONE);
+}
+
+static void utc_poi_service_get_preference_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_preference_h preference;
+       ret = poi_service_get_preference(NULL, &preference);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_service_get_preference_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       ret = poi_service_get_preference(poi_manager, NULL);
+
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+
+static void utc_poi_service_set_preference_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+
+       ret = poi_service_set_preference(poi_manager, pref);
+
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+
+       validate_eq(__func__, ret, POI_ERROR_NONE);
+}
+
+static void utc_poi_service_set_preference_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+
+       ret = poi_service_set_preference(NULL, pref);
+
+       if (pref) {
+               poi_preference_destroy(pref);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_service_set_preference_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       ret = poi_service_set_preference(poi_manager, NULL);
+
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+
+static bool capi_service_search_cb(poi_error_e error, int request_id , int index, int length , poi_h poi , void * user_data)
+{
+       dts_message(__func__, "capi_service_search_cb : error %d, index : %d", error, index);
+
+       return true;
+}
+
+static void utc_poi_service_search_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+       ret = poi_filter_set(filter, "CATEGORY", "restaurant");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+       location_coords_s pos = {37.771008, -122.41175};
+
+       ret = poi_service_search(poi_manager, pos, 100, filter, capi_service_search_cb , NULL, NULL);
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_NONE);
+}
+
+static void utc_poi_service_search_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+       ret = poi_filter_set(filter, "CATEGORY", "restaurant");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+       location_coords_s pos = {37.771008, -122.41175};
+
+       ret = poi_service_search(NULL, pos, 100, filter, capi_service_search_cb , NULL, NULL);
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_service_search_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+       ret = poi_filter_set(filter, "CATEGORY", "restaurant");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+       location_coords_s pos = {91, 181};
+
+       ret = poi_service_search(poi_manager, pos, 100, filter, capi_service_search_cb , NULL, NULL);
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_service_search_n_03(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+       ret = poi_filter_set(filter, "CATEGORY", "restaurant");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+       location_coords_s pos = {37.771008, -122.41175};
+
+       ret = poi_service_search(poi_manager, pos, -1, filter, capi_service_search_cb , NULL, NULL);
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_service_search_n_04(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+       location_coords_s pos = {37.771008, -122.41175};
+
+       ret = poi_service_search(poi_manager, pos, 100, NULL, capi_service_search_cb , NULL, NULL);
+
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_service_search_n_05(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+       ret = poi_filter_set(filter, "CATEGORY", "restaurant");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+       location_coords_s pos = {37.771008, -122.41175};
+
+       ret = poi_service_search(poi_manager, pos, 100, filter, NULL , NULL, NULL);
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+
+
+static void utc_poi_service_search_by_area_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+       ret = poi_filter_set(filter, "CATEGORY", "restaurant");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+
+       location_coords_s center;
+       center.latitude = 37.336723;
+       center.longitude = -121.889555;
+       double radius = 30;
+       location_bounds_h bounds_circle = NULL;
+       ret = location_bounds_create_circle(center, radius, &bounds_circle);
+       validate_and_next(__func__, ret, LOCATION_BOUNDS_ERROR_NONE, "location_bounds_create_circle() is failed");
+
+       ret = poi_service_search_by_area(poi_manager, bounds_circle, filter, capi_service_search_cb, NULL, NULL);
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+       if (bounds_circle) {
+               location_bounds_destroy(bounds_circle);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_NONE);
+}
+
+static void utc_poi_service_search_by_area_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+       ret = poi_filter_set(filter, "CATEGORY", "restaurant");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+
+       location_coords_s center;
+       center.latitude = 37.336723;
+       center.longitude = -121.889555;
+       double radius = 30;
+       location_bounds_h bounds_circle;
+       ret = location_bounds_create_circle(center, radius, &bounds_circle);
+       validate_and_next(__func__, ret, LOCATION_BOUNDS_ERROR_NONE, "location_bounds_create_circle() is failed");
+
+       ret = poi_service_search_by_area(NULL, bounds_circle, filter, capi_service_search_cb, NULL, NULL);
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+       if (bounds_circle) {
+               location_bounds_destroy(bounds_circle);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_service_search_by_area_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+       ret = poi_filter_set(filter, "CATEGORY", "restaurant");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+
+       ret = poi_service_search_by_area(poi_manager, NULL, filter, capi_service_search_cb, NULL, NULL);
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_service_search_by_area_n_03(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+
+       location_coords_s center;
+       center.latitude = 37.336723;
+       center.longitude = -121.889555;
+       double radius = 30;
+       location_bounds_h bounds_circle;
+       ret = location_bounds_create_circle(center, radius, &bounds_circle);
+       validate_and_next(__func__, ret, LOCATION_BOUNDS_ERROR_NONE, "location_bounds_create_circle() is failed");
+
+       ret = poi_service_search_by_area(poi_manager, bounds_circle, NULL, capi_service_search_cb, NULL, NULL);
+
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+       if (bounds_circle) {
+               location_bounds_destroy(bounds_circle);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_service_search_by_area_n_04(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+       ret = poi_filter_set(filter, "CATEGORY", "restaurant");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+
+       location_coords_s center;
+       center.latitude = 37.336723;
+       center.longitude = -121.889555;
+       double radius = 30;
+       location_bounds_h bounds_circle;
+       ret = location_bounds_create_circle(center, radius, &bounds_circle);
+       validate_and_next(__func__, ret, LOCATION_BOUNDS_ERROR_NONE, "location_bounds_create_circle() is failed");
+
+       ret = poi_service_search_by_area(poi_manager, bounds_circle, filter, NULL, NULL, NULL);
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+       if (bounds_circle) {
+               location_bounds_destroy(bounds_circle);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_service_search_by_address_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+       ret = poi_filter_set(filter, "KEYWORD", "restaurant");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+
+       char *addr = strdup("North Second St.");
+       ret = poi_service_search_by_address(poi_manager, addr, NULL, filter, capi_service_search_cb, NULL, NULL);
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_NONE);
+}
+
+static void utc_poi_service_search_by_address_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+       ret = poi_filter_set(filter, "KEYWORD", "restaurant");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+
+       char *addr = strdup("North Second St.");
+       ret = poi_service_search_by_address(NULL, addr, NULL, filter, capi_service_search_cb, NULL, NULL);
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_service_search_by_address_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+       ret = poi_filter_set(filter, "KEYWORD", "restaurant");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+
+       ret = poi_service_search_by_address(poi_manager, NULL, NULL, filter, capi_service_search_cb, NULL, NULL);
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+
+static void utc_poi_service_search_by_address_n_03(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+
+       char *addr = strdup("North Second St.");
+       ret = poi_service_search_by_address(poi_manager, addr, NULL, NULL, capi_service_search_cb, NULL, NULL);
+
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_service_search_by_address_n_04(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+       ret = poi_filter_set(filter, "KEYWORD", "restaurant");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+
+       char *addr = strdup("North Second St.");
+       ret = poi_service_search_by_address(poi_manager, addr, NULL, filter, NULL, NULL, NULL);
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_service_cancel_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       int request_id = 1;
+       ret = poi_service_cancel(poi_manager, request_id);
+
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_NONE);
+}
+
+static void utc_poi_service_cancel_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       int request_id = 1;
+       ret = poi_service_cancel(NULL, request_id);
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+
+}
+
+static void utc_poi_service_cancel_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       ret = poi_service_cancel(poi_manager, -1);
+
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+
+}
+
+static void utc_poi_preference_create_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+
+       if (pref) {
+               poi_preference_destroy(pref);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_NONE);
+
+}
+
+static void utc_poi_preference_create_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       ret = poi_preference_create(NULL);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+
+}
+
+
+
+static void utc_poi_preference_destroy_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+
+       ret = poi_preference_destroy(pref);
+
+       validate_eq(__func__, ret, POI_ERROR_NONE);
+}
+
+static void utc_poi_preference_destroy_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       ret = poi_preference_destroy(NULL);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+
+}
+
+static void utc_poi_preference_get_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+
+       ret = poi_preference_set(pref, "LandmarkName", "cafe");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set() is failed");
+
+       char *value;
+       ret = poi_preference_get(pref, "LandmarkName", &value);
+
+       if (pref) {
+               poi_preference_destroy(pref);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_NONE);
+}
+
+static void utc_poi_preference_get_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       char *value;
+       ret = poi_preference_get(NULL, "LandmarkName", &value);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+
+}
+
+static void utc_poi_preference_get_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+
+       ret = poi_preference_set(pref, "LandmarkName", "cafe");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set() is failed");
+
+       char *value;
+       ret = poi_preference_get(pref, NULL, &value);
+
+       if (pref) {
+               poi_preference_destroy(pref);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+
+}
+
+static void utc_poi_preference_get_n_03(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+
+       ret = poi_preference_set(pref, "LandmarkName", "cafe");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set() is failed");
+
+       ret = poi_preference_get(pref, "LandmarkName", NULL);
+
+       if (pref) {
+               poi_preference_destroy(pref);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+
+}
+
+
+static void utc_poi_preference_set_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+
+       ret = poi_preference_set(pref, "LandmarkName", "cafe");
+
+       if (pref) {
+               poi_preference_destroy(pref);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_NONE);
+}
+
+static void utc_poi_preference_set_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       char *value;
+       ret = poi_preference_set(NULL, "LandmarkName", "cafe");
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+
+}
+
+static void utc_poi_preference_set_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+
+       ret = poi_preference_set(pref, NULL, "cafe");
+
+       if (pref) {
+               poi_preference_destroy(pref);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+
+}
+
+static void utc_poi_preference_set_n_03(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+
+       ret = poi_preference_set(pref, "LandmarkName", NULL);
+
+       if (pref) {
+               poi_preference_destroy(pref);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+
+}
+
+static void utc_poi_preference_set_max_result_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+
+       ret = poi_preference_set_max_result(pref, 5);
+
+       if (pref) {
+               poi_preference_destroy(pref);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_NONE);
+}
+
+static void utc_poi_preference_set_max_result_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       ret = poi_preference_set_max_result(NULL, 5);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+
+}
+
+static void utc_poi_preference_set_max_result_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+
+       ret = poi_preference_set_max_result(pref, -1);
+
+       if (pref) {
+               poi_preference_destroy(pref);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+
+}
+
+static void utc_poi_preference_get_max_result_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+
+       int max_result;
+       ret = poi_preference_get_max_result(pref, &max_result);
+
+       if (pref) {
+               poi_preference_destroy(pref);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_NONE);
+}
+
+static void utc_poi_preference_get_max_result_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       int max_result;
+       ret = poi_preference_get_max_result(NULL, &max_result);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+
+}
+
+static void utc_poi_preference_get_max_result_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+
+       ret = poi_preference_get_max_result(pref, NULL);
+
+       if (pref) {
+               poi_preference_destroy(pref);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+
+}
+
+static bool capi_poi_preference_sortable_field_cb(const char *field , void *user_data)
+{
+       return true;
+}
+
+static void utc_poi_preference_foreach_sortable_field_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+
+       ret = poi_preference_foreach_sortable_field(poi_manager, capi_poi_preference_sortable_field_cb, NULL);
+
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_NONE);
+}
+
+static void utc_poi_preference_foreach_sortable_field_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       ret = poi_preference_foreach_sortable_field(NULL, capi_poi_preference_sortable_field_cb, NULL);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+
+}
+
+
+static void utc_poi_preference_foreach_sortable_field_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+
+       ret = poi_preference_foreach_sortable_field(poi_manager, NULL, NULL);
+
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+
+}
+
+static void utc_poi_preference_set_sort_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+
+       if (pref) {
+               poi_preference_destroy(pref);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_NONE);
+}
+
+static void utc_poi_preference_set_sort_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       ret = poi_preference_set_sort(NULL, "Distance", POI_SORTORDER_ASC);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+
+}
+
+
+static void utc_poi_preference_set_sort_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+
+       ret = poi_preference_set_sort(pref, NULL, POI_SORTORDER_ASC);
+
+       if (pref) {
+               poi_preference_destroy(pref);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+
+}
+
+static void utc_poi_preference_set_sort_n_03(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+
+       ret = poi_preference_set_sort(pref, "Distance", (poi_sort_order_e)5);
+
+       if (pref) {
+               poi_preference_destroy(pref);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+
+}
+
+static void utc_poi_preference_get_sort_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+
+       poi_sort_order_e order;
+       char *sort_item = NULL;
+       ret = poi_preference_get_sort(pref, &sort_item, &order);
+
+       if (pref) {
+               poi_preference_destroy(pref);
+       }
+       if (sort_item) free(sort_item);
+
+       validate_eq(__func__, ret, POI_ERROR_NONE);
+}
+
+static void utc_poi_preference_get_sort_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_sort_order_e order;
+       char *sort_item = NULL;
+       ret = poi_preference_get_sort(NULL, &sort_item, &order);
+       if (sort_item) free(sort_item);
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+
+}
+
+static void utc_poi_preference_get_sort_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+
+       poi_sort_order_e order;
+       ret = poi_preference_get_sort(pref, NULL, &order);
+
+       if (pref) {
+               poi_preference_destroy(pref);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+
+}
+
+static void utc_poi_preference_get_sort_n_03(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+
+       poi_sort_order_e order;
+       char *sort_item = NULL;
+       ret = poi_preference_get_sort(pref, &sort_item, NULL);
+
+       if (pref) {
+               poi_preference_destroy(pref);
+       }
+
+       if (sort_item) free(sort_item);
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+
+}
+
+static bool capi_poi_preference_properties_cb(const char *key , const char *value,  void *user_data)
+{
+       return true;
+}
+
+static void utc_poi_preference_foreach_properties_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+
+       ret = poi_preference_set(pref, "LandmarkName", "cafe");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set() is failed");
+
+       ret = poi_preference_set(pref, "LandmarkType", "restaurant");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set() is failed");
+
+       ret = poi_preference_foreach_properties(pref, capi_poi_preference_properties_cb, NULL);
+
+       if (pref) {
+               poi_preference_destroy(pref);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_NONE);
+}
+
+static void utc_poi_preference_foreach_properties_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       ret = poi_preference_foreach_properties(NULL, capi_poi_preference_properties_cb, NULL);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+
+}
+
+static void utc_poi_preference_foreach_properties_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+
+       ret = poi_preference_set(pref, "LandmarkName", "cafe");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set() is failed");
+
+       ret = poi_preference_set(pref, "LandmarkType", "restaurant");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set() is failed");
+
+       ret = poi_preference_foreach_properties(pref, NULL, NULL);
+
+       if (pref) {
+               poi_preference_destroy(pref);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+
+}
+
+static bool capi_poi_preference_available_key_cb(const char *key , void *user_data)
+{
+       return true;
+}
+
+static void utc_poi_preference_foreach_available_keys_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+
+       ret = poi_preference_foreach_available_keys(poi_manager, capi_poi_preference_available_key_cb, NULL);
+
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_NONE);
+}
+
+static void utc_poi_preference_foreach_available_keys_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       ret = poi_preference_foreach_available_keys(NULL, capi_poi_preference_available_key_cb, NULL);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+
+}
+
+static void utc_poi_preference_foreach_available_keys_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+
+       ret = poi_preference_foreach_available_keys(poi_manager, NULL, NULL);
+
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+
+}
+
+
+static bool capi_poi_preference_available_value_cb(const char *value , void *user_data)
+{
+       return true;
+}
+
+static void utc_poi_preference_foreach_available_values_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+
+       ret = poi_preference_foreach_available_values(poi_manager, "KEYWORD", capi_poi_preference_available_value_cb, NULL);
+
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_NONE);
+}
+
+static void utc_poi_preference_foreach_available_values_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       ret = poi_preference_foreach_available_values(NULL, "KEYWORD", capi_poi_preference_available_value_cb, NULL);
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+
+}
+
+static void utc_poi_preference_foreach_available_values_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+
+       ret = poi_preference_foreach_available_values(poi_manager, NULL, capi_poi_preference_available_value_cb, NULL);
+
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+
+}
+
+static void utc_poi_preference_foreach_available_values_n_03(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+
+       ret = poi_preference_foreach_available_values(poi_manager, "KEYWORD", NULL, NULL);
+
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+
+}
+
+
+static void utc_poi_filter_create_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_NONE);
+}
+
+static void utc_poi_filter_create_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       ret = poi_filter_create(NULL);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_filter_destroy_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+
+       ret = poi_filter_destroy(filter);
+       validate_eq(__func__, ret, POI_ERROR_NONE);
+}
+
+static void utc_poi_filter_destroy_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       ret = poi_filter_destroy(NULL);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_filter_set_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+
+       // "CATEGORY", "KEYWORD", "POINAME"
+       ret = poi_filter_set(filter, "KEYWORD", "cafe");
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_NONE);
+}
+
+static void utc_poi_filter_set_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       ret = poi_filter_set(NULL, "KEYWORD", "cafe");
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_filter_set_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+
+       ret = poi_filter_set(filter, NULL, "cafe");
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_filter_set_n_03(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+
+       ret = poi_filter_set(filter, "KEYWORD", NULL);
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_filter_get_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+
+       // "CATEGORY", "KEYWORD", "POINAME"
+       ret = poi_filter_set(filter, "KEYWORD", "cafe");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       char *value;
+       ret = poi_filter_get(filter, "KEYWORD", &value);
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_NONE);
+}
+
+static void utc_poi_filter_get_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       char *value;
+       ret = poi_filter_get(NULL, "KEYWORD", &value);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_filter_get_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+
+       // "CATEGORY", "KEYWORD", "POINAME"
+       ret = poi_filter_set(filter, "KEYWORD", "cafe");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       char *value;
+       ret = poi_filter_get(filter, NULL, &value);
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_filter_get_n_03(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+
+       // "CATEGORY", "KEYWORD", "POINAME"
+       ret = poi_filter_set(filter, "KEYWORD", "cafe");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       char *value;
+       ret = poi_filter_get(filter, "KEYWORD", NULL);
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static bool capi_poi_filter_properties_cb(const char *key , const char *value , void *user_data)
+{
+       return true;
+}
+
+static void utc_poi_filter_foreach_properties_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+
+       // "CATEGORY", "KEYWORD", "POINAME"
+       ret = poi_filter_set(filter, "KEYWORD", "cafe");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       ret = poi_filter_set(filter, "CATEGORY", "restaurant");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       ret = poi_filter_foreach_properties(filter, capi_poi_filter_properties_cb, NULL);
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_NONE);
+}
+
+static void utc_poi_filter_foreach_properties_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       ret = poi_filter_foreach_properties(NULL, capi_poi_filter_properties_cb, NULL);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_filter_foreach_properties_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+
+       // "CATEGORY", "KEYWORD", "POINAME"
+       ret = poi_filter_set(filter, "KEYWORD", "cafe");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       ret = poi_filter_set(filter, "CATEGORY", "restaurant");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       ret = poi_filter_foreach_properties(filter, NULL, NULL);
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static bool capi_poi_filter_available_key_cb(const char *key , void *user_data)
+{
+       return true;
+}
+
+static void utc_poi_filter_foreach_available_keys_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+
+       ret = poi_filter_foreach_available_keys(poi_manager, capi_poi_filter_available_key_cb, NULL);
+
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_NONE);
+}
+
+static void utc_poi_filter_foreach_available_keys_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+
+       ret = poi_filter_foreach_available_keys(poi_manager, NULL, NULL);
+
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_filter_foreach_available_keys_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       ret = poi_filter_foreach_available_keys(NULL, capi_poi_filter_available_key_cb, NULL);
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+
+static bool capi_poi_filter_available_value_cb(const char *value , void *user_data)
+{
+       return true;
+}
+
+static void utc_poi_filter_foreach_available_values_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+
+       ret = poi_filter_foreach_available_values(poi_manager, "KEYWORD", capi_poi_filter_available_value_cb, NULL);
+
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_NONE);
+}
+
+static void utc_poi_filter_foreach_available_values_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+
+       ret = poi_filter_foreach_available_values(poi_manager, NULL, capi_poi_filter_available_value_cb, NULL);
+
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_filter_foreach_available_values_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+
+       ret = poi_filter_foreach_available_values(poi_manager, "KEYWORD", NULL, NULL);
+
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_filter_foreach_available_values_n_03(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       ret = poi_filter_foreach_available_values(NULL, "KEYWORD", capi_poi_filter_available_value_cb, NULL);
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+
+

diff --git a/TC/testcase/utc_location_poi_callback.c b/TC/testcase/utc_location_poi_callback.c
new file mode 100755 (executable)
index 0000000..59f6fba
--- /dev/null
+++ b/TC/testcase/utc_location_poi_callback.c
@@ -0,0 +1,1572 @@
+/*
+* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include <tet_api.h>
+#include <poi.h>
+#include <glib.h>
+#include <location/location.h>
+
+enum {
+       POSITIVE_TC_IDX = 0x01,
+       NEGATIVE_TC_IDX,
+};
+
+static void startup(void);
+static void cleanup(void);
+
+void (*tet_startup)(void) = startup;
+void (*tet_cleanup)(void) = cleanup;
+
+
+static void utc_poi_create_p(void);
+static void utc_poi_create_n(void);
+static void utc_poi_destroy_p(void);
+static void utc_poi_destroy_n(void);
+static void utc_poi_clone_p(void);
+static void utc_poi_clone_n(void);
+static void utc_poi_clone_n_02(void);
+static void utc_poi_get_id_p(void);
+static void utc_poi_get_id_n(void);
+static void utc_poi_get_id_n_02(void);
+static void utc_poi_get_name_p(void);
+static void utc_poi_get_name_n(void);
+static void utc_poi_get_name_n_02(void);
+static void utc_poi_get_position_p(void);
+static void utc_poi_get_position_n(void);
+static void utc_poi_get_position_n_02(void);
+static void utc_poi_get_address_p(void);
+static void utc_poi_get_address_n(void);
+static void utc_poi_get_address_n_02(void);
+static void utc_poi_get_address_n_03(void);
+static void utc_poi_get_address_n_04(void);
+static void utc_poi_get_address_n_05(void);
+static void utc_poi_get_address_n_06(void);
+static void utc_poi_get_address_n_07(void);
+static void utc_poi_get_address_n_08(void);
+static void utc_poi_get_description_p(void);
+static void utc_poi_get_description_n(void);
+static void utc_poi_get_description_n_02(void);
+static void utc_poi_get_timestamp_p(void);
+static void utc_poi_get_timestamp_n(void);
+static void utc_poi_get_timestamp_n_02(void);
+static void utc_poi_get_bounding_rect_p(void);
+static void utc_poi_get_bounding_rect_n(void);
+static void utc_poi_get_bounding_rect_n_02(void);
+static void utc_poi_get_bounding_rect_n_03(void);
+static void utc_poi_get_author_p(void);
+static void utc_poi_get_author_n(void);
+static void utc_poi_get_author_n_02(void);
+static void utc_poi_get_phone_number_p(void);
+static void utc_poi_get_phone_number_n(void);
+static void utc_poi_get_phone_number_n_02(void);
+static void utc_poi_foreach_urls_p(void);
+static void utc_poi_foreach_urls_n(void);
+static void utc_poi_foreach_urls_n_02(void);
+static void utc_poi_foreach_properties_p(void);
+static void utc_poi_foreach_properties_n(void);
+static void utc_poi_foreach_properties_n_02(void);
+static void utc_poi_foreach_categories_p(void);
+static void utc_poi_foreach_categories_n(void);
+static void utc_poi_foreach_categories_n_02(void);
+
+
+struct tet_testlist tet_testlist[] = {
+
+       { utc_poi_create_p, POSITIVE_TC_IDX },
+       { utc_poi_create_n, NEGATIVE_TC_IDX },
+       { utc_poi_destroy_p, POSITIVE_TC_IDX },
+       { utc_poi_destroy_n, NEGATIVE_TC_IDX },
+       { utc_poi_clone_p, POSITIVE_TC_IDX },
+       { utc_poi_clone_n, NEGATIVE_TC_IDX },
+       { utc_poi_clone_n_02, NEGATIVE_TC_IDX },
+       { utc_poi_get_id_p, POSITIVE_TC_IDX },
+       { utc_poi_get_id_n, NEGATIVE_TC_IDX },
+       { utc_poi_get_id_n_02, NEGATIVE_TC_IDX },
+       { utc_poi_get_name_p, POSITIVE_TC_IDX },
+       { utc_poi_get_name_n, NEGATIVE_TC_IDX },
+       { utc_poi_get_name_n_02, NEGATIVE_TC_IDX },
+       { utc_poi_get_position_p, POSITIVE_TC_IDX },
+       { utc_poi_get_position_n, NEGATIVE_TC_IDX },
+       { utc_poi_get_position_n_02, NEGATIVE_TC_IDX },
+       { utc_poi_get_address_p, POSITIVE_TC_IDX },
+       { utc_poi_get_address_n, NEGATIVE_TC_IDX },
+//     { utc_poi_get_address_n_02, NEGATIVE_TC_IDX },   // Not negative case
+//     { utc_poi_get_address_n_03, NEGATIVE_TC_IDX },  // Not negative case
+//     { utc_poi_get_address_n_04, NEGATIVE_TC_IDX },
+//     { utc_poi_get_address_n_05, NEGATIVE_TC_IDX },
+//     { utc_poi_get_address_n_06, NEGATIVE_TC_IDX },
+//     { utc_poi_get_address_n_07, NEGATIVE_TC_IDX },
+//     { utc_poi_get_address_n_08, NEGATIVE_TC_IDX },
+       { utc_poi_get_description_p, POSITIVE_TC_IDX },
+       { utc_poi_get_description_n, NEGATIVE_TC_IDX },
+       { utc_poi_get_description_n_02, NEGATIVE_TC_IDX },
+       { utc_poi_get_timestamp_p, POSITIVE_TC_IDX },
+       { utc_poi_get_timestamp_n, NEGATIVE_TC_IDX },
+       { utc_poi_get_timestamp_n_02, NEGATIVE_TC_IDX },
+//     { utc_poi_get_bounding_rect_p, POSITIVE_TC_IDX },       // bbox is not supported yet in provider
+       { utc_poi_get_bounding_rect_n, NEGATIVE_TC_IDX },
+       { utc_poi_get_bounding_rect_n_02, NEGATIVE_TC_IDX },
+       { utc_poi_get_bounding_rect_n_03, NEGATIVE_TC_IDX },
+       { utc_poi_get_author_p, POSITIVE_TC_IDX },
+       { utc_poi_get_author_n, NEGATIVE_TC_IDX },
+       { utc_poi_get_author_n_02, NEGATIVE_TC_IDX },
+       { utc_poi_get_phone_number_p, POSITIVE_TC_IDX },
+       { utc_poi_get_phone_number_n, NEGATIVE_TC_IDX },
+       { utc_poi_get_phone_number_n_02, NEGATIVE_TC_IDX },
+       { utc_poi_foreach_urls_p, POSITIVE_TC_IDX },
+       { utc_poi_foreach_urls_n, NEGATIVE_TC_IDX },
+       { utc_poi_foreach_urls_n_02, NEGATIVE_TC_IDX },
+       { utc_poi_foreach_properties_p, POSITIVE_TC_IDX },
+       { utc_poi_foreach_properties_n, NEGATIVE_TC_IDX },
+       { utc_poi_foreach_properties_n_02, NEGATIVE_TC_IDX },
+       { utc_poi_foreach_categories_p, POSITIVE_TC_IDX },
+       { utc_poi_foreach_categories_n, NEGATIVE_TC_IDX },
+       { utc_poi_foreach_categories_n_02, NEGATIVE_TC_IDX },
+
+       { NULL, 0 },
+};
+
+static GMainLoop *g_mainloop = NULL;
+static GThread *event_thread;
+
+gpointer GmainThread(gpointer data){
+       g_mainloop = g_main_loop_new (NULL, 0);
+       g_main_loop_run (g_mainloop);
+
+       return NULL;
+}
+
+static bool poi_service_search_cb_called = false;
+
+static void validate_and_next(char* api_name,int act_ret, int ext_ret, char* fail_msg)
+{
+       dts_message(api_name, "Actual Result : %d, Expected Result : %d", act_ret,ext_ret);
+       if (act_ret != ext_ret)
+       {
+               dts_message(api_name, "Fail Message: %s", fail_msg);
+               dts_fail(api_name);
+       }
+}
+
+static void validate_eq(char* api_name,int act_ret, int ext_ret)
+{
+       dts_message(api_name, "Actual Result : %d, Expected Result : %d", act_ret,ext_ret);
+       if (act_ret == ext_ret) {
+               dts_pass(api_name);
+       } else {
+               dts_fail(api_name);
+       }
+}
+
+static void wait_for_poi_service_search(char* api_name)
+{
+       dts_message(api_name, "wait for poi service search");
+       int timeout = 0;
+       for (timeout ; timeout < 60 * 10; timeout++)
+       {
+               if(poi_service_search_cb_called)
+               {
+                               dts_message(api_name, "POI service search callback called!!!!");
+                               break;
+               }
+               else
+               {
+                       dts_message(api_name, "No POI service search callback!!!!");
+                       sleep(1);
+               }
+       }
+}
+
+
+static void startup(void)
+{
+       g_setenv("PKG_NAME", "org.tizen.capi-location-poi-callback-test", 1);
+       g_setenv("LOCATION_TEST_ENABLE", "1", 1);
+
+#if !GLIB_CHECK_VERSION (2, 31, 0)
+       if( !g_thread_supported() )
+       {
+               g_thread_init(NULL);
+       }
+#endif
+
+       GError *gerr = NULL;
+       event_thread = g_thread_create(GmainThread, NULL, 1, &gerr);
+}
+
+static void cleanup(void)
+{
+
+       g_main_loop_quit (g_mainloop);
+       g_thread_join(event_thread);
+}
+
+
+static void utc_poi_create_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_h poi;
+       ret = poi_create(&poi);
+
+       if (poi) {
+               poi_destroy(poi);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_NONE);
+}
+
+static void utc_poi_create_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       ret = poi_create(NULL);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_destroy_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_h poi;
+       ret = poi_create(&poi);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_create() is failed");
+
+       ret = poi_destroy(poi);
+       validate_eq(__func__, ret, POI_ERROR_NONE);
+}
+
+static void utc_poi_destroy_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       ret = poi_destroy(NULL);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_clone_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_h poi;
+       ret = poi_create(&poi);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_create() is failed");
+
+       poi_h poi_02;
+       ret = poi_clone(&poi_02, poi);
+
+       if (poi) {
+               poi_destroy(poi);
+       }
+       if (poi_02) {
+               poi_destroy(poi);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_NONE);
+}
+
+static void utc_poi_clone_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_h poi;
+       ret = poi_create(&poi);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_create() is failed");
+
+       ret = poi_clone(NULL, poi);
+
+       if (poi) {
+               poi_destroy(poi);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_clone_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_h poi_02;
+       ret = poi_clone(&poi_02, NULL);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static bool poi_get_id_success = false;
+
+static bool capi_poi_get_id_cb(poi_error_e error, int request_id , int index, int length , poi_h poi , void * user_data)
+{
+       dts_message(__func__, "capi_poi_get_id_cb : error %d, index : %d", error, index);
+       poi_service_search_cb_called = true;
+
+       int ret = POI_ERROR_NONE;
+       int id;
+       ret = poi_get_id(poi, &id);
+       if (ret == POI_ERROR_NONE) {
+               poi_get_id_success = true;
+       }
+
+       return true;
+}
+
+static void utc_poi_get_id_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+       ret = poi_filter_set(filter, "CATEGORY", "restaurant");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+       location_coords_s pos = {37.771008, -122.41175};
+
+       poi_service_search_cb_called = false;
+       poi_get_id_success = false;
+       ret = poi_service_search(poi_manager, pos, 100, filter, capi_poi_get_id_cb , NULL, NULL);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_search() is failed");
+
+       wait_for_poi_service_search(__func__);
+       validate_and_next(__func__, poi_service_search_cb_called, true, "capi_poi_get_id_cb() is NOT called!");
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+       if (poi_manager) {
+               //free pref also
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, poi_get_id_success, true);
+}
+
+static void utc_poi_get_id_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       int id;
+       ret = poi_get_id(NULL, &id);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_get_id_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_h poi;
+       ret = poi_create(&poi);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_create() is failed");
+
+       ret = poi_get_id(poi, NULL);
+
+       if (poi) {
+               poi_destroy(poi);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+
+static bool poi_get_name_success = false;
+
+static bool capi_poi_get_name_cb(poi_error_e error, int request_id , int index, int length , poi_h poi , void * user_data)
+{
+       dts_message(__func__, "capi_poi_get_name_cb : error %d, index : %d", error, index);
+       poi_service_search_cb_called = true;
+
+       int ret = POI_ERROR_NONE;
+       char *name = NULL;
+       ret = poi_get_name(poi, &name);
+       if (ret == POI_ERROR_NONE) {
+               poi_get_name_success = true;
+       }
+
+       if (name) {
+               free(name);
+       }
+
+       return true;
+}
+
+static void utc_poi_get_name_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+       ret = poi_filter_set(filter, "CATEGORY", "restaurant");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+       location_coords_s pos = {37.771008, -122.41175};
+
+       poi_service_search_cb_called = false;
+       poi_get_name_success = false;
+       ret = poi_service_search(poi_manager, pos, 100, filter, capi_poi_get_name_cb , NULL, NULL);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_search() is failed");
+
+       wait_for_poi_service_search(__func__);
+       validate_and_next(__func__, poi_service_search_cb_called, true, "capi_poi_get_name_cb() is NOT called!");
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, poi_get_name_success, true);
+}
+
+static void utc_poi_get_name_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       char *name = NULL;
+       ret = poi_get_name(NULL, &name);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_get_name_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_h poi;
+       ret = poi_create(&poi);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_create() is failed");
+
+       ret = poi_get_name(poi, NULL);
+
+       if (poi) {
+               poi_destroy(poi);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static bool poi_get_position_success = false;
+
+static bool capi_poi_get_position_cb(poi_error_e error, int request_id , int index, int length , poi_h poi , void * user_data)
+{
+       dts_message(__func__, "capi_poi_get_position_cb : error %d, index : %d", error, index);
+       poi_service_search_cb_called = true;
+
+       int ret = POI_ERROR_NONE;
+       location_coords_s coords;
+       ret = poi_get_position(poi, &coords);
+       if (ret == POI_ERROR_NONE) {
+               poi_get_position_success = true;
+       }
+
+       return true;
+}
+
+static void utc_poi_get_position_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+       ret = poi_filter_set(filter, "CATEGORY", "restaurant");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+       location_coords_s pos = {37.771008, -122.41175};
+
+       poi_service_search_cb_called = false;
+       poi_get_position_success = false;
+       ret = poi_service_search(poi_manager, pos, 100, filter, capi_poi_get_position_cb , NULL, NULL);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_search() is failed");
+
+       wait_for_poi_service_search(__func__);
+       validate_and_next(__func__, poi_service_search_cb_called, true, "capi_poi_get_position_cb() is NOT called!");
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, poi_get_position_success, true);
+}
+
+static void utc_poi_get_position_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       location_coords_s *coords;
+       ret = poi_get_position(NULL, &coords);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_get_position_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_h poi;
+       ret = poi_create(&poi);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_create() is failed");
+
+       ret = poi_get_position(poi, NULL);
+
+       if (poi) {
+               poi_destroy(poi);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static bool poi_get_address_success = false;
+
+static bool capi_poi_get_address_cb(poi_error_e error, int request_id , int index, int length , poi_h poi , void * user_data)
+{
+       dts_message(__func__, "capi_poi_get_address_cb : error %d, index : %d", error, index);
+       poi_service_search_cb_called = true;
+       poi_service_h poi_manager = (poi_service_h) user_data;
+
+       int ret = POI_ERROR_NONE;
+       char *building_number = NULL;
+       char *postal_code = NULL;
+       char *street = NULL;
+       char *city = NULL;
+       char *district = NULL;
+       char *state = NULL;
+       char *country_code = NULL;
+       ret = poi_get_address(poi, &building_number, &postal_code, &street, &city, &district, &state, &country_code);
+       if (ret == POI_ERROR_NONE) {
+               poi_get_address_success = true;
+       }
+
+       if (building_number) {
+               free(building_number);
+       }
+       if (postal_code) {
+               free(postal_code);
+       }
+       if (street) {
+               free(street);
+       }
+       if (city) {
+               free(city);
+       }
+       if (district) {
+               free(district);
+       }
+       if (state) {
+               free(state);
+       }
+       if (country_code) {
+               free(country_code);
+       }
+
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       return false;
+}
+
+static void utc_poi_get_address_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+       ret = poi_filter_set(filter, "CATEGORY", "restaurant");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+       location_coords_s pos = {37.771008, -122.41175};
+
+       poi_service_search_cb_called = false;
+       poi_get_address_success = false;
+       ret = poi_service_search(poi_manager, pos, 100, filter, capi_poi_get_address_cb , poi_manager, NULL);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_search() is failed");
+
+       wait_for_poi_service_search(__func__);
+       validate_and_next(__func__, poi_service_search_cb_called, true, "capi_poi_get_address_cb() is NOT called!");
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+
+       validate_eq(__func__, poi_get_address_success, true);
+}
+
+static void utc_poi_get_address_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       char *building_number = NULL;
+       char *postal_code = NULL;
+       char *street = NULL;
+       char *city = NULL;
+       char *district = NULL;
+       char *state = NULL;
+       char *country_code = NULL;
+       ret = poi_get_address(NULL, &building_number, &postal_code, &street, &city, &district, &state, &country_code);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_get_address_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_h poi;
+       ret = poi_create(&poi);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_create() is failed");
+
+       char *postal_code = NULL;
+       char *street = NULL;
+       char *city = NULL;
+       char *district = NULL;
+       char *state = NULL;
+       char *country_code = NULL;
+       ret = poi_get_address(poi, NULL, &postal_code, &street, &city, &district, &state, &country_code);
+
+       if (poi) {
+               poi_destroy(poi);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_get_address_n_03(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_h poi;
+       ret = poi_create(&poi);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_create() is failed");
+
+       char *building_number = NULL;
+       char *street = NULL;
+       char *city = NULL;
+       char *district = NULL;
+       char *state = NULL;
+       char *country_code = NULL;
+       ret = poi_get_address(poi, &building_number, NULL, &street, &city, &district, &state, &country_code);
+
+       if (poi) {
+               poi_destroy(poi);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_get_address_n_04(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_h poi;
+       ret = poi_create(&poi);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_create() is failed");
+
+       char *building_number = NULL;
+       char *postal_code = NULL;
+       char *city = NULL;
+       char *district = NULL;
+       char *state = NULL;
+       char *country_code = NULL;
+       ret = poi_get_address(poi, &building_number, &postal_code, NULL, &city, &district, &state, &country_code);
+
+       if (poi) {
+               poi_destroy(poi);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_get_address_n_05(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_h poi;
+       ret = poi_create(&poi);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_create() is failed");
+
+       char *building_number = NULL;
+       char *postal_code = NULL;
+       char *street = NULL;
+       char *district = NULL;
+       char *state = NULL;
+       char *country_code = NULL;
+       ret = poi_get_address(poi, &building_number, &postal_code, &street, NULL, &district, &state, &country_code);
+
+       if (poi) {
+               poi_destroy(poi);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_get_address_n_06(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_h poi;
+       ret = poi_create(&poi);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_create() is failed");
+
+       char *building_number = NULL;
+       char *postal_code = NULL;
+       char *street = NULL;
+       char *city = NULL;
+       char *state = NULL;
+       char *country_code = NULL;
+       ret = poi_get_address(poi, &building_number, &postal_code, &street, &city, NULL, &state, &country_code);
+
+       if (poi) {
+               poi_destroy(poi);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_get_address_n_07(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_h poi;
+       ret = poi_create(&poi);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_create() is failed");
+
+       char *building_number = NULL;
+       char *postal_code = NULL;
+       char *street = NULL;
+       char *city = NULL;
+       char *district = NULL;
+       char *country_code = NULL;
+       ret = poi_get_address(poi, &building_number, &postal_code, &street, &city, &district, NULL, &country_code);
+
+       if (poi) {
+               poi_destroy(poi);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_get_address_n_08(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_h poi;
+       ret = poi_create(&poi);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_create() is failed");
+
+       char *building_number = NULL;
+       char *postal_code = NULL;
+       char *street = NULL;
+       char *city = NULL;
+       char *district = NULL;
+       char *state = NULL;
+       ret = poi_get_address(poi, &building_number, &postal_code, &street, &city, &district, &state, NULL);
+
+       if (poi) {
+               poi_destroy(poi);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static bool poi_get_description_success = false;
+
+static bool capi_poi_get_description_cb(poi_error_e error, int request_id , int index, int length , poi_h poi , void * user_data)
+{
+       dts_message(__func__, "capi_poi_get_description_cb : error %d, index : %d", error, index);
+       poi_service_search_cb_called = true;
+
+       int ret = POI_ERROR_NONE;
+       char *description = NULL;
+       ret = poi_get_description(poi, &description);
+       if (ret == POI_ERROR_NONE) {
+               poi_get_description_success = true;
+       }
+
+       if (description) {
+               free(description);
+       }
+
+       return true;
+}
+
+static void utc_poi_get_description_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+       ret = poi_filter_set(filter, "CATEGORY", "restaurant");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+       location_coords_s pos = {37.771008, -122.41175};
+
+       poi_service_search_cb_called = false;
+       poi_get_description_success = false;
+       ret = poi_service_search(poi_manager, pos, 100, filter, capi_poi_get_description_cb , NULL, NULL);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_search() is failed");
+
+       wait_for_poi_service_search(__func__);
+       validate_and_next(__func__, poi_service_search_cb_called, true, "capi_poi_get_description_cb() is NOT called!");
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, poi_get_description_success, true);
+}
+
+static void utc_poi_get_description_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       char *description = NULL;
+       ret = poi_get_description(NULL, &description);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_get_description_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_h poi;
+       ret = poi_create(&poi);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_create() is failed");
+
+       ret = poi_get_description(poi, NULL);
+
+       if (poi) {
+               poi_destroy(poi);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static bool poi_get_timestamp_success = false;
+
+static bool capi_poi_get_timestamp_cb(poi_error_e error, int request_id , int index, int length , poi_h poi , void * user_data)
+{
+       dts_message(__func__, "capi_poi_get_timestamp_cb : error %d, index : %d", error, index);
+       poi_service_search_cb_called = true;
+
+       int ret = POI_ERROR_NONE;
+       char *timestamp = NULL;
+       ret = poi_get_timestamp(poi, &timestamp);
+       if (ret == POI_ERROR_NONE) {
+               poi_get_timestamp_success = true;
+       }
+
+       if (timestamp) {
+               free(timestamp);
+       }
+
+       return true;
+}
+
+static void utc_poi_get_timestamp_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+       ret = poi_filter_set(filter, "CATEGORY", "restaurant");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+       location_coords_s pos = {37.771008, -122.41175};
+
+       poi_service_search_cb_called = false;
+       poi_get_timestamp_success = false;
+       ret = poi_service_search(poi_manager, pos, 100, filter, capi_poi_get_timestamp_cb , NULL, NULL);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_search() is failed");
+
+       wait_for_poi_service_search(__func__);
+       validate_and_next(__func__, poi_service_search_cb_called, true, "capi_poi_get_timestamp_cb() is NOT called!");
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, poi_get_timestamp_success, true);
+}
+
+static void utc_poi_get_timestamp_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       char *timestamp = NULL;
+       ret = poi_get_timestamp(NULL, &timestamp);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_get_timestamp_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_h poi;
+       ret = poi_create(&poi);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_create() is failed");
+
+       ret = poi_get_timestamp(poi, NULL);
+
+       if (poi) {
+               poi_destroy(poi);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static bool poi_get_bounding_rect_success = false;
+
+static bool capi_poi_get_bounding_rect_cb(poi_error_e error, int request_id , int index, int length , poi_h poi , void * user_data)
+{
+       dts_message(__func__, "capi_poi_get_bounding_rect_cb : error %d, index : %d", error, index);
+       poi_service_search_cb_called = true;
+
+       int ret = POI_ERROR_NONE;
+       location_coords_s left_top;
+       location_coords_s right_bottom;
+       ret = poi_get_bounding_rect(poi, &left_top, &right_bottom);
+       if (ret == POI_ERROR_NONE) {
+               poi_get_bounding_rect_success = true;
+       }
+
+       return true;
+}
+
+static void utc_poi_get_bounding_rect_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+       ret = poi_filter_set(filter, "CATEGORY", "restaurant");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+       location_coords_s pos = {37.771008, -122.41175};
+
+       poi_service_search_cb_called = false;
+       poi_get_bounding_rect_success = false;
+       ret = poi_service_search(poi_manager, pos, 100, filter, capi_poi_get_bounding_rect_cb , NULL, NULL);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_search() is failed");
+
+       wait_for_poi_service_search(__func__);
+       validate_and_next(__func__, poi_service_search_cb_called, true, "capi_poi_get_bounding_rect_cb() is NOT called!");
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, poi_get_bounding_rect_success, true);
+}
+
+static void utc_poi_get_bounding_rect_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       location_coords_s left_top;
+       location_coords_s right_bottom;
+       ret = poi_get_bounding_rect(NULL, &left_top, &right_bottom);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_get_bounding_rect_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_h poi;
+       ret = poi_create(&poi);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_create() is failed");
+
+       location_coords_s right_bottom;
+       ret = poi_get_bounding_rect(poi, NULL, &right_bottom);
+
+       if (poi) {
+               poi_destroy(poi);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_get_bounding_rect_n_03(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_h poi;
+       ret = poi_create(&poi);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_create() is failed");
+
+       location_coords_s left_top;
+       ret = poi_get_bounding_rect(poi, &left_top, NULL);
+
+       if (poi) {
+               poi_destroy(poi);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+
+static bool poi_get_author_success = false;
+
+static bool capi_poi_get_author_cb(poi_error_e error, int request_id , int index, int length , poi_h poi , void * user_data)
+{
+       dts_message(__func__, "capi_poi_get_author_cb : error %d, index : %d", error, index);
+       poi_service_search_cb_called = true;
+
+       int ret = POI_ERROR_NONE;
+       char *author = NULL;
+       ret = poi_get_author(poi, &author);
+       if (ret == POI_ERROR_NONE) {
+               poi_get_author_success = true;
+       }
+
+       if (author) {
+               free(author);
+       }
+
+       return true;
+}
+
+static void utc_poi_get_author_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+       ret = poi_filter_set(filter, "CATEGORY", "restaurant");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+       location_coords_s pos = {37.771008, -122.41175};
+
+       poi_service_search_cb_called = false;
+       poi_get_author_success = false;
+       ret = poi_service_search(poi_manager, pos, 100, filter, capi_poi_get_author_cb , NULL, NULL);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_search() is failed");
+
+       wait_for_poi_service_search(__func__);
+       validate_and_next(__func__, poi_service_search_cb_called, true, "capi_poi_get_author_cb() is NOT called!");
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, poi_get_author_success, true);
+}
+
+static void utc_poi_get_author_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       char *author = NULL;
+       ret = poi_get_author(NULL, &author);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_get_author_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_h poi;
+       ret = poi_create(&poi);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_create() is failed");
+
+       ret = poi_get_author(poi, NULL);
+
+       if (poi) {
+               poi_destroy(poi);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static bool poi_get_phone_number_success = false;
+
+static bool capi_poi_get_phone_number_cb(poi_error_e error, int request_id , int index, int length , poi_h poi , void * user_data)
+{
+       dts_message(__func__, "capi_poi_get_author_cb : error %d, index : %d", error, index);
+       poi_service_search_cb_called = true;
+
+       int ret = POI_ERROR_NONE;
+       char *phone_number = NULL;
+       ret = poi_get_phone_number(poi, &phone_number);
+       if (ret == POI_ERROR_NONE) {
+               poi_get_phone_number_success = true;
+       }
+
+       if (phone_number) {
+               free(phone_number);
+       }
+
+       return true;
+}
+
+static void utc_poi_get_phone_number_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+       ret = poi_filter_set(filter, "CATEGORY", "restaurant");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+       location_coords_s pos = {37.771008, -122.41175};
+
+       poi_service_search_cb_called = false;
+       poi_get_phone_number_success = false;
+       ret = poi_service_search(poi_manager, pos, 100, filter, capi_poi_get_phone_number_cb , NULL, NULL);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_search() is failed");
+
+       wait_for_poi_service_search(__func__);
+       validate_and_next(__func__, poi_service_search_cb_called, true, "capi_poi_get_phone_number_cb() is NOT called!");
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, poi_get_phone_number_success, true);
+}
+
+static void utc_poi_get_phone_number_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       char *phone_number = NULL;
+       ret = poi_get_phone_number(NULL, &phone_number);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_get_phone_number_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_h poi;
+       ret = poi_create(&poi);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_create() is failed");
+
+       ret = poi_get_phone_number(poi, NULL);
+
+       if (poi) {
+               poi_destroy(poi);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static bool poi_foreach_urls_success = false;
+
+static bool capi_poi_urls_cb(const char *url , const char *description, void *user_data)
+{
+       return true;
+}
+
+static bool capi_poi_foreach_urls_cb(poi_error_e error, int request_id , int index, int length , poi_h poi , void * user_data)
+{
+       dts_message(__func__, "capi_poi_foreach_urlsr_cb : error %d, index : %d", error, index);
+       poi_service_search_cb_called = true;
+
+       int ret = POI_ERROR_NONE;
+       ret = poi_foreach_urls(poi, capi_poi_urls_cb , NULL);
+       if (ret == POI_ERROR_NONE) {
+               poi_foreach_urls_success = true;
+       }
+
+       return true;
+}
+
+static void utc_poi_foreach_urls_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+       ret = poi_filter_set(filter, "CATEGORY", "restaurant");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+       location_coords_s pos = {37.771008, -122.41175};
+
+       poi_service_search_cb_called = false;
+       poi_foreach_urls_success = false;
+       ret = poi_service_search(poi_manager, pos, 100, filter, capi_poi_foreach_urls_cb , NULL, NULL);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_search() is failed");
+
+       wait_for_poi_service_search(__func__);
+       validate_and_next(__func__, poi_service_search_cb_called, true, "capi_poi_foreach_urls_cb() is NOT called!");
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, poi_foreach_urls_success, true);
+}
+
+static void utc_poi_foreach_urls_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       ret = poi_foreach_urls(NULL, capi_poi_urls_cb , NULL);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_foreach_urls_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_h poi;
+       ret = poi_create(&poi);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_create() is failed");
+
+       ret = poi_foreach_urls(poi, NULL , NULL);
+
+       if (poi) {
+               poi_destroy(poi);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static bool poi_foreach_properties_success = false;
+
+static bool capi_poi_properties_cb(const char *key, const char* value, void *user_data)
+{
+       return true;
+}
+
+static bool capi_poi_foreach_properties_cb(poi_error_e error, int request_id , int index, int length , poi_h poi , void * user_data)
+{
+       dts_message(__func__, "capi_poi_foreach_properties_cb : error %d, index : %d", error, index);
+       poi_service_search_cb_called = true;
+
+       int ret = POI_ERROR_NONE;
+       ret = poi_foreach_properties(poi, capi_poi_properties_cb , NULL);
+       if (ret == POI_ERROR_NONE) {
+               poi_foreach_properties_success = true;
+       }
+
+       return true;
+}
+
+static void utc_poi_foreach_properties_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+       ret = poi_filter_set(filter, "CATEGORY", "restaurant");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+       location_coords_s pos = {37.771008, -122.41175};
+
+       poi_service_search_cb_called = false;
+       poi_foreach_properties_success = false;
+       ret = poi_service_search(poi_manager, pos, 100, filter, capi_poi_foreach_properties_cb , NULL, NULL);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_search() is failed");
+
+       wait_for_poi_service_search(__func__);
+       validate_and_next(__func__, poi_service_search_cb_called, true, "capi_poi_foreach_properties_cb() is NOT called!");
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, poi_foreach_properties_success, true);
+}
+
+static void utc_poi_foreach_properties_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       ret = poi_foreach_properties(NULL, capi_poi_properties_cb , NULL);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_foreach_properties_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_h poi;
+       ret = poi_create(&poi);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_create() is failed");
+
+       ret = poi_foreach_properties(poi, NULL , NULL);
+
+       if (poi) {
+               poi_destroy(poi);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static bool poi_foreach_categories_success = false;
+
+static bool capi_poi_categories_cb(const char *category, void *user_data)
+{
+       return true;
+}
+
+static bool capi_poi_foreach_categories_cb(poi_error_e error, int request_id , int index, int length , poi_h poi , void * user_data)
+{
+       dts_message(__func__, "capi_poi_foreach_categories_cb : error %d, index : %d", error, index);
+       poi_service_search_cb_called = true;
+
+       int ret = POI_ERROR_NONE;
+       ret = poi_foreach_categories(poi, capi_poi_categories_cb , NULL);
+       if (ret == POI_ERROR_NONE) {
+               poi_foreach_categories_success = true;
+       }
+
+       return true;
+}
+
+static void utc_poi_foreach_categories_p(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_service_h poi_manager ;
+       ret = poi_service_create(&poi_manager);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_create() is failed");
+
+       poi_filter_h filter;
+       ret = poi_filter_create(&filter);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_create() is failed");
+       ret = poi_filter_set(filter, "CATEGORY", "restaurant");
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_filter_set() is failed");
+
+       poi_preference_h pref;
+       ret = poi_preference_create(&pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_create() is failed");
+       ret = poi_preference_set_max_result(pref, 5);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_max_result() is failed");
+       ret = poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_preference_set_sort() is failed");
+       ret = poi_service_set_preference(poi_manager, pref);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_set_preference() is failed");
+       location_coords_s pos = {37.771008, -122.41175};
+
+       poi_service_search_cb_called = false;
+       poi_foreach_categories_success = false;
+       ret = poi_service_search(poi_manager, pos, 100, filter, capi_poi_foreach_categories_cb , NULL, NULL);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_service_search() is failed");
+
+       wait_for_poi_service_search(__func__);
+       validate_and_next(__func__, poi_service_search_cb_called, true, "capi_poi_foreach_categories_cb() is NOT called!");
+
+       if (filter) {
+               poi_filter_destroy(filter);
+       }
+       if (poi_manager) {
+               poi_service_destroy(poi_manager);
+       }
+
+       validate_eq(__func__, poi_foreach_categories_success, true);
+}
+
+static void utc_poi_foreach_categories_n(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       ret = poi_foreach_categories(NULL, capi_poi_categories_cb , NULL);
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+static void utc_poi_foreach_categories_n_02(void)
+{
+       int ret = POI_ERROR_NONE;
+
+       poi_h poi;
+       ret = poi_create(&poi);
+       validate_and_next(__func__, ret, POI_ERROR_NONE, "poi_create() is failed");
+
+       ret = poi_foreach_categories(poi, NULL , NULL);
+
+       if (poi) {
+               poi_destroy(poi);
+       }
+
+       validate_eq(__func__, ret, POI_ERROR_INVALID_PARAMETER);
+}
+
+

diff --git a/TC/tet_scen b/TC/tet_scen
new file mode 100755 (executable)
index 0000000..03f029a
--- /dev/null
+++ b/TC/tet_scen
@@ -0,0 +1,7 @@
+all
+       ^TEST
+##### Scenarios for TEST #####
+
+# Test scenario
+TEST
+       :include:/testcase/tslist

diff --git a/TC/tetbuild.cfg b/TC/tetbuild.cfg
new file mode 100755 (executable)
index 0000000..f7eda55
--- /dev/null
+++ b/TC/tetbuild.cfg
@@ -0,0 +1,5 @@
+TET_OUTPUT_CAPTURE=True # capture option for build operation checking
+TET_BUILD_TOOL=make # build with using make command
+TET_BUILD_FILE=-f Makefile # execution file (Makefile) for build
+TET_API_COMPLIANT=True # use TET API in Test Case ?
+TET_PASS_TC_NAME=True # report passed TC name in Journal file?

diff --git a/TC/tetclean.cfg b/TC/tetclean.cfg
new file mode 100755 (executable)
index 0000000..02d7030
--- /dev/null
+++ b/TC/tetclean.cfg
@@ -0,0 +1,5 @@
+TET_OUTPUT_CAPTURE=True # capture option
+TET_CLEAN_TOOL= make clean # clean tool
+TET_CLEAN_FILE= Makefile # file for clean
+TET_API_COMPLIANT=True # TET API useage 
+TET_PASS_TC_NAME=True # showing name , passed TC

diff --git a/TC/tetexec.cfg b/TC/tetexec.cfg
new file mode 100755 (executable)
index 0000000..ef3e452
--- /dev/null
+++ b/TC/tetexec.cfg
@@ -0,0 +1,5 @@
+TET_OUTPUT_CAPTURE=True # capturing execution or not
+TET_EXEC_TOOL=  # ex) exec : execution tool set up/ Optional
+TET_EXEC_FILE=   # ex) exectool : execution file/ Optional
+TET_API_COMPLIANT=True # Test case or Tool usesTET API?
+TET_PASS_TC_NAME=True # showing Passed TC name ?

diff --git a/debian/changelog b/debian/changelog
index 9d5c0e8..c9a3350 100755 (executable)
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,7 +1,27 @@
+capi-location-poi (0.1.0-5) unstable; urgency=low
+
+  * Seperate map service from location service
+  * Tag: capi-location-poi_0.1.0-5
+
+ -- Minjune Kim <sena06.kim@samsung.com>  Fri, 27 Jul 2012 20:08:43 +0900
+
+capi-location-poi (0.1.0-4) unstable; urgency=low
+
+  * Support developer mode
+  * Tag: capi-location-poi_0.1.0-4
+
+ -- Minjune Kim <sena06.kim@samsung.com>  Thu, 19 Jul 2012 19:51:04 +0900
+
+capi-location-poi (0.1.0-3) unstable; urgency=low
+
+  * Fix the failed cases on TC
+  * Tag: capi-location-poi_0.1.0-3
+
+ -- Minjune Kim <sena06.kim@samsung.com>  Thu, 12 Apr 2012 20:20:41 +0900
+
 capi-location-poi (0.1.0-2) unstable; urgency=low
 
   * update POI
-  * Git: slp-source.sec.samsung.net:slp/api/poi
   * Tag: capi-location-poi_0.1.0-2
 
  -- Seungkeun Lee <sngn.lee@samsung.com>  Wed, 21 Mar 2012 11:36:19 +0900
@@ -9,7 +29,6 @@ capi-location-poi (0.1.0-2) unstable; urgency=low
 capi-location-poi (0.1.0-1) unstable; urgency=low
 
   * initial release
-  * Git: slp-source.sec.samsung.net:slp/api/poi
   * Tag: capi-location-poi_0.1.0-1
 
  -- Seungkeun Lee <sngn.lee@samsung.com>  Tue, 14 Feb 2012 17:55:34 +0900

diff --git a/include/poi_private.h b/include/poi_private.h
index df85bdc..286efda 100755 (executable)
--- a/include/poi_private.h
+++ b/include/poi_private.h
@@ -26,7 +26,7 @@ extern "C" {
 
 
 typedef struct _poi_service_s{
-       LocationObject* object;
+       LocationMapObject* object;
        poi_preference_h preference;
 
 } poi_service_s;

diff --git a/packaging/capi-location-poi.spec b/packaging/capi-location-poi.spec
index 0b9bf70..cafcc6c 100755 (executable)
--- a/packaging/capi-location-poi.spec
+++ b/packaging/capi-location-poi.spec
@@ -1,7 +1,7 @@
 Name:       capi-location-poi
 Summary:    A Location POI library in Tizen Native API
 Version:    0.1.0
-Release:    2
+Release:    1
 Group:      TO_BE/FILLED_IN
 License:    TO BE FILLED IN
 Source0:    %{name}-%{version}.tar.gz

diff --git a/src/poi.c b/src/poi.c
index ea5df04..42e45d9 100755 (executable)
--- a/src/poi.c
+++ b/src/poi.c
@@ -16,6 +16,7 @@
 
 
 #include <location/location.h>
+#include <location/location-map-service.h>
 #include <poi.h>
 #include <poi_private.h>
 
@@ -142,11 +143,11 @@ int poi_service_create( poi_service_h *poi)
                POI_PRINT_ERROR_CODE_RETURN(POI_ERROR_OUT_OF_MEMORY);
        }
 
-       handle->object = location_new(LOCATION_METHOD_HYBRID);
+       handle->object = location_map_new(NULL);
        if(handle->object  == NULL)
        {
                free(handle);
-               LOGE("[%s] POI_ERROR_SERVICE_NOT_AVAILABLE(0x%08x) : fail to location_new", __FUNCTION__, POI_ERROR_SERVICE_NOT_AVAILABLE);
+               LOGE("[%s] POI_ERROR_SERVICE_NOT_AVAILABLE(0x%08x) : fail to location_map_new", __FUNCTION__, POI_ERROR_SERVICE_NOT_AVAILABLE);
                return POI_ERROR_SERVICE_NOT_AVAILABLE;
        }       
 
@@ -167,7 +168,7 @@ int poi_service_destroy(poi_service_h poi)
                handle->preference = NULL;
        }
 
-       int ret = location_free(handle->object);
+       int ret = location_map_free(handle->object);
        if(ret!= POI_ERROR_NONE)
        {
                return _convert_error_code(ret,__FUNCTION__);
@@ -240,7 +241,7 @@ int poi_service_search(poi_service_h poi, location_coords_s position, int distan
        }
 
 
-       ret = location_search_poi (handle->object , (LocationPOIFilter*)filter , &pos, (LocationPOIPreference *)handle->preference, __LocationPOICB, calldata, &reqid);
+       ret = location_map_search_poi (handle->object , (LocationPOIFilter*)filter , &pos, (LocationPOIPreference *)handle->preference, __LocationPOICB, calldata, &reqid);
        if( ret != 0 ){
                free(calldata);
                return _convert_error_code(ret, __func__);
@@ -266,13 +267,13 @@ int poi_service_search_by_area (poi_service_h poi, location_bounds_h boundary ,
        location_bounds_get_type(boundary, &bound_type);
        
        if( bound_type == LOCATION_BOUNDS_RECT ){
-               if( !location_is_supported_map_provider_capability(handle->object , MAP_SERVICE_POI_SEARCH_BY_RECT_BOUNDARY) )
+               if( !location_map_is_supported_provider_capability(handle->object , MAP_SERVICE_POI_SEARCH_BY_RECT_BOUNDARY) )
                        return POI_ERROR_SERVICE_NOT_AVAILABLE;
        }else if(bound_type == LOCATION_BOUNDS_CIRCLE){
-               if( !location_is_supported_map_provider_capability(handle->object , MAP_SERVICE_POI_SEARCH_BY_CIRCLE_BOUNDARY) )
+               if( !location_map_is_supported_provider_capability(handle->object , MAP_SERVICE_POI_SEARCH_BY_CIRCLE_BOUNDARY) )
                        return POI_ERROR_SERVICE_NOT_AVAILABLE; 
        }else if(bound_type == LOCATION_BOUNDS_CIRCLE){
-               if( !location_is_supported_map_provider_capability(handle->object , MAP_SERVICE_POI_SEARCH_BY_POLYGON_BOUNDARY) )
+               if( !location_map_is_supported_provider_capability(handle->object , MAP_SERVICE_POI_SEARCH_BY_POLYGON_BOUNDARY) )
                        return POI_ERROR_SERVICE_NOT_AVAILABLE;         
        }
        
@@ -285,7 +286,7 @@ int poi_service_search_by_area (poi_service_h poi, location_bounds_h boundary ,
 
        poi_preference_set(handle->preference, "Distance", NULL);
 
-       ret = location_search_poi_by_area (handle->object , (LocationPOIFilter*)filter , (LocationBoundary *)boundary, (LocationPOIPreference *)handle->preference, __LocationPOICB, calldata, &reqid);
+       ret = location_map_search_poi_by_area (handle->object , (LocationPOIFilter*)filter , (LocationBoundary *)boundary, (LocationPOIPreference *)handle->preference, __LocationPOICB, calldata, &reqid);
        if( ret != 0 ){
                free(calldata);
                return _convert_error_code(ret, __func__);
@@ -323,7 +324,7 @@ int poi_service_search_by_address(poi_service_h poi, const char* address, int di
                poi_preference_set(handle->preference, "Distance", NULL);
        }       
 
-       ret = location_search_poi_by_freeformed_address (handle->object , (LocationPOIFilter*)filter , address, (LocationPOIPreference *)handle->preference, __LocationPOICB, calldata, &reqid);
+       ret = location_map_search_poi_by_freeformed_address (handle->object , (LocationPOIFilter*)filter , address, (LocationPOIPreference *)handle->preference, __LocationPOICB, calldata, &reqid);
 
        if( ret != 0 ){
                free(calldata);
@@ -341,7 +342,7 @@ int poi_service_cancel(poi_service_h service, int request_id)
        POI_NULL_ARG_CHECK(service);
 
        poi_service_s *handle = (poi_service_s*)service;
-       return _convert_error_code(location_cancel_poi_request(handle->object, request_id), __func__);
+       return _convert_error_code(location_map_cancel_poi_request(handle->object, request_id), __func__);
 }
 
 int poi_filter_create(poi_filter_h *filter)
@@ -404,7 +405,7 @@ int poi_filter_foreach_available_keys( poi_service_h poi, poi_filter_available_k
        POI_NULL_ARG_CHECK(callback);
 
        GList *keys=NULL;
-       location_get_map_provider_capability_key((LocationObject*)poi, MAP_SERVICE_POI_FILTER, &keys);
+       location_map_get_provider_capability_key((LocationMapObject*)poi, MAP_SERVICE_POI_FILTER, &keys);
        if( keys == NULL )
                return POI_ERROR_RESULT_NOT_FOUND;
 
@@ -467,7 +468,7 @@ int poi_preference_foreach_available_keys( poi_service_h poi,  poi_preference_av
        POI_NULL_ARG_CHECK(callback);
 
        GList *keys=NULL;
-       location_get_map_provider_capability_key((LocationObject*)poi, MAP_SERVICE_POI_PREF_PROPERTY, &keys);
+       location_map_get_provider_capability_key((LocationMapObject*)poi, MAP_SERVICE_POI_PREF_PROPERTY, &keys);
        if( keys == NULL )
                return POI_ERROR_RESULT_NOT_FOUND;
 
@@ -539,7 +540,7 @@ int poi_preference_foreach_sortable_field( poi_service_h poi, poi_preference_sor
        POI_NULL_ARG_CHECK(callback);
 
        GList *keys=NULL;
-       location_get_map_provider_capability_key((LocationObject*)poi, MAP_SERVICE_POI_PREF_SORT_BY, &keys);
+       location_map_get_provider_capability_key((LocationMapObject*)poi, MAP_SERVICE_POI_PREF_SORT_BY, &keys);
        if( keys == NULL )
                return POI_ERROR_RESULT_NOT_FOUND;
 

diff --git a/test/location_poi_test.c b/test/location_poi_test.c
index 2d53ce7..34f8548 100755 (executable)
--- a/test/location_poi_test.c
+++ b/test/location_poi_test.c
@@ -14,8 +14,10 @@
 * limitations under the License.
 */
 #include <stdio.h>
+#include <unistd.h>
 #include <glib.h>
 #include <poi.h>
+#include <location_bounds.h>
 
 static GMainLoop *g_mainloop = NULL;
 
@@ -50,6 +52,13 @@ int poi_test(){
        poi_preference_h pref;
        poi_service_create(&poi_manager);
 
+       location_bounds_h bound;
+
+       location_coords_s pos = {37.336723, -121.889555};
+       location_bounds_create_circle(pos, 400, &bound);
+
+       char * addr = "N SAN PEDRO ST CA SANTA CLARA SAN JOSE 95110";
+
        poi_filter_create(&filter);
        //poi_filter_set(filter, "KEYWORD", "pizza");
        poi_filter_set(filter, "CATEGORY", "restaurant");
@@ -57,18 +66,112 @@ int poi_test(){
        poi_preference_set_max_result(pref, 5);
        poi_preference_set_sort(pref, "Distance", POI_SORTORDER_ASC);
        poi_service_set_preference(poi_manager, pref);
-       location_coords_s pos = {37.771008, -122.41175};
 
         int ret;
        //printf("request search!!!\n");
        ret = poi_service_search(poi_manager,pos , 100, filter, _service_search_cb , NULL, NULL);
-       printf("ret = %d\n", ret);
+       printf("ret = category, poi_service_search : %d\n", ret);
+
+       sleep(3);
+
+       poi_filter_create(&filter);
+       poi_filter_set(filter, "KEYWORD", "pizza");
+       poi_preference_create(&pref);
+       poi_preference_set_max_result(pref, 5);
+       poi_preference_set_sort(pref, "Distance", POI_SORTORDER_DESC);
+       poi_service_set_preference(poi_manager, pref);
+
+       ret = poi_service_search(poi_manager,pos , 100, filter, _service_search_cb , NULL, NULL);
+       printf("ret = keyword, poi_service_search : %d\n", ret);
+
+
+       sleep(3);
+
+       poi_filter_create(&filter);
+       poi_filter_set(filter, "POIName", "pizza");
+       poi_preference_create(&pref);
+       poi_preference_set_max_result(pref, 5);
+       poi_preference_set_sort(pref, "Distance", POI_SORTORDER_DESC);
+       poi_service_set_preference(poi_manager, pref);
+
+       ret = poi_service_search(poi_manager,pos , 100, filter, _service_search_cb , NULL, NULL);
+       printf("ret = POIName, poi_service_search : %d\n", ret);
+
+       sleep(3);
+
+       poi_filter_create(&filter);
+       poi_filter_set(filter, "CATEGORY", "restaurant");
+       poi_preference_create(&pref);
+       poi_preference_set_max_result(pref, 5);
+       poi_preference_set_sort(pref, "Distance", POI_SORTORDER_DESC);
+       poi_service_set_preference(poi_manager, pref);
+
+       ret = poi_service_search_by_area(poi_manager, bound, filter, _service_search_cb , NULL, NULL);
+       printf("ret = category, poi_service_search_by_area : %d\n", ret);
 
 
-       //ret = poi_service_search_by_address(poi_manager,"Seoul, Korea", 100, filter, _service_search_cb , NULL, NULL);
-       //printf("ret = %d\n", ret);
+       sleep(3);
+
+       poi_filter_create(&filter);
+       poi_filter_set(filter, "KEYWORD", "pizza");
+       poi_preference_create(&pref);
+       poi_preference_set_max_result(pref, 5);
+       poi_preference_set_sort(pref, "Distance", POI_SORTORDER_DESC);
+       poi_service_set_preference(poi_manager, pref);
+
+       ret = poi_service_search_by_area(poi_manager, bound, filter, _service_search_cb , NULL, NULL);
+       printf("ret = keyword, poi_service_search_by_area : %d\n", ret);
+
+       sleep(3);
+
+       poi_filter_create(&filter);
+       poi_preference_create(&pref);
+       poi_filter_set(filter, "POIName", "pizza");
+       poi_preference_set_max_result(pref, 5);
+       poi_preference_set_sort(pref, "Distance", POI_SORTORDER_DESC);
+       poi_service_set_preference(poi_manager, pref);
+
+       ret = poi_service_search_by_area(poi_manager, bound, filter, _service_search_cb , NULL, NULL);
+       printf("ret = poi name, poi_service_search_by_area : %d\n", ret);
+
+       sleep(3);
+
+       poi_filter_create(&filter);
+       poi_filter_set(filter, "CATEGORY", "restaurant");
+       poi_preference_create(&pref);
+       poi_preference_set_max_result(pref, 5);
+       poi_preference_set_sort(pref, "Distance", POI_SORTORDER_DESC);
+       poi_service_set_preference(poi_manager, pref);
+
+       ret = poi_service_search_by_address(poi_manager, addr, 100, filter, _service_search_cb , NULL, NULL);
+       printf("ret = category, poi_service_search_by_address : %d\n", ret);
+
+
+       sleep(10);
+
+       poi_filter_create(&filter);
+       poi_filter_set(filter, "KEYWORD", "cafe");
+       poi_preference_create(&pref);
+       poi_preference_set_max_result(pref, 5);
+       poi_preference_set_sort(pref, "Distance", POI_SORTORDER_DESC);
+       poi_service_set_preference(poi_manager, pref);
+
+       ret = poi_service_search_by_address(poi_manager, addr, 400, filter, _service_search_cb , NULL, NULL);
+       printf("ret = keyword, poi_service_search_by_address : %d\n", ret);
+
+       sleep(10);
+
+       poi_filter_create(&filter);
+       poi_filter_set(filter, "POIName", "cafe");
+       poi_preference_create(&pref);
+       poi_preference_set_max_result(pref, 5);
+       poi_preference_set_sort(pref, "Distance", POI_SORTORDER_DESC);
+       poi_service_set_preference(poi_manager, pref);
 
+       ret = poi_service_search_by_address(poi_manager, addr, 400, filter, _service_search_cb , NULL, NULL);
+       printf("ret = POIName, poi_service_search_by_address : %d\n", ret);
 
+       sleep(10);
        return 0;
 }
 
@@ -78,10 +181,12 @@ int main(){
        // If application is executed by AUL, this is not needed.
        g_setenv("PKG_NAME", "com.samsung.location-api-test", 1);
 
+#if !GLIB_CHECK_VERSION (2, 31, 0)
        if( !g_thread_supported() )
        {
                g_thread_init(NULL);
        }
+#endif
 
        GThread *g_main;
        g_main = g_thread_create(GmainThread, NULL, TRUE, &gerr);