tests/test/bt_unit_test.c

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *              http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 /**
  19  * @file       bt_unit_test.c
  20  * @brief      This is the source file for capi unit test.
  21  */
  22
  23 #include <sys/time.h>
  24 #include <stdio.h>
  25 #include <string.h>
  26 #include <fcntl.h>
  27 #include <unistd.h>
  28 #include <glib.h>
  29 #include <ctype.h>
  30 #ifdef ARCH64
  31 #include <stdint.h>
  32 #endif
  33 #include <sys/socket.h>
  34 #include <arpa/inet.h>
  35 #include <net/if.h>
  36 #include <netdb.h>
  37 #include <sys/types.h>
  38 #include <ifaddrs.h>
  39 #include <linux/if_link.h>
  40 #include <app_control.h>
  41 #include <system_info.h>
  42
  43 #include "bluetooth.h"
  44 #include "bluetooth_internal.h"
  45 #include "bluetooth_extension.h"
  46 #include "bluetooth_private.h"
  47 #include "bluetooth-telephony-api.h"
  48 #include "bt_unit_test.h"
  49
  50 const char *spp_uuid = "00001101-0000-1000-8000-00805F9B34FB";
  51 const char *hid_uuid = "00001124-0000-1000-8000-00805f9b34fb";
  52 const char *opp_uuid = "00001105-0000-1000-8000-00805f9b34fb";
  53 const char *custom_uuid = "fa87c0d0-afac-11de-8a39-0800200c9a66";
  54
  55 /* HPS UUIDs. defined by SIG */
  56 #define HPS_UUID "1823"
  57 #define HTTP_URI_UUID "2ab6"
  58 #define HTTP_HDR_UUID "2ab7"
  59 #define HTTP_ENTITY_UUID "2ab9"
  60 #define HTTP_CP_UUID "2aba"
  61 #define HTTP_STATUS_UUID "2ab8"
  62 #define HTTP_SECURITY_UUID "2abb"
  63 #define HTTP_STATUS_DESC_UUID "2902"
  64 #define IPSP_PORT 3344
  65 static bt_unit_test_table_e current_tc_table;
  66 static char remote_addr[18] = "F6:FB:8F:D8:C8:7C";
  67 static char ipsp_iface_name[17] = "";
  68 static bool input_automated_test_delay = false;
  69
  70 /* For HDP profile TEST */
  71 static char *appid = "/org/bluez/health_app_2";
  72 static char *data_hdp = "aaa";
  73 static unsigned channel_hdp = 0;
  74
  75 static bool need_to_set_params = false;
  76 static int g_test_id = -1;
  77 static tc_params_t g_test_param = {0,};
  78
  79 static int server_fd;
  80 static int client_fd;
  81 static int custom_server_fd;
  82 static int custom_client_fd;
  83 static int ipsp_server_sock = 0;
  84 static int ipsp_client_sock = 0;
  85
  86 static int bt_onoff_cnt = 0;
  87 static int bt_onoff_cnt_success = 0;
  88 static int bt_onoff_cnt_fail = 0;
  89 static int total_time = 0;
  90 static struct timeval check_time = {0,};
  91
  92 static int absolute_volume = 0;
  93
  94 int service_index;
  95 int char_service_index;
  96
  97 static bt_advertiser_h advertiser = NULL;
  98 static bt_advertiser_h advertiser_list[3] = {NULL, };
  99 static int advertiser_index = 0;
 100
 101 bt_gatt_client_h client = NULL;
 102 bt_gatt_client_h hps_client = NULL;
 103
 104 bt_gatt_server_h server = NULL;
 105 typedef struct {
 106         bt_gatt_h svc;
 107         bt_gatt_h chr;
 108         bt_gatt_h desc;
 109 } gatt_handle_t;
 110 gatt_handle_t battery_h;
 111 gatt_handle_t heart_rate_h;
 112 gatt_handle_t thermometer_h;
 113 gatt_handle_t custom_h;
 114 gatt_handle_t ipsp_h;
 115
 116 bt_proximity_reporter_h reporter;
 117 bt_proximity_monitor_h monitor;
 118 bt_scan_filter_h pxp_scan_filter;
 119
 120 bt_tds_provider_h provider;
 121 char *tds_act_address;
 122 bt_tds_seeker_h seeker;
 123
 124 bt_otp_client_h otp_client;
 125 bt_hrp_collector_h collector;
 126 bool set_notif = true;
 127
 128
 129 static unsigned char *hash = NULL;
 130 static unsigned char *randomizer = NULL;
 131 int hash_len;
 132 int rand_len;
 133
 134 bt_call_list_h call_list;
 135 GMainLoop *main_loop = NULL;
 136
 137 tc_table_t tc_main[] = {
 138         /* Categories */
 139         {"SET ADDRESS"
 140                 , BT_UNIT_TEST_FUNCTION_SET_ADDRESS},
 141         {"bt_initialize"
 142                 , BT_UNIT_TEST_FUNCTION_INITIALIZE},
 143         {"bt_deinitialize"
 144                 , BT_UNIT_TEST_FUNCTION_DEINITIALIZE},
 145         {"Adapter"
 146                 , BT_UNIT_TEST_TABLE_ADAPTER},
 147         {"Adapter LE"
 148                 , BT_UNIT_TEST_TABLE_ADAPTER_LE},
 149         {"Device"
 150                 , BT_UNIT_TEST_TABLE_DEVICE},
 151         {"Socket"
 152                 , BT_UNIT_TEST_TABLE_SOCKET},
 153         {"Opp"
 154                 , BT_UNIT_TEST_TABLE_OPP},
 155         {"Audio(ag, a2dp, call)"
 156                 , BT_UNIT_TEST_TABLE_AUDIO},
 157         {"Pan(nap, panu)"
 158                 , BT_UNIT_TEST_TABLE_PAN},
 159         {"Gatt"
 160                 , BT_UNIT_TEST_TABLE_GATT},
 161         {"HPS"
 162                 , BT_UNIT_TEST_TABLE_HPS},
 163         {"Avrcp"
 164                 , BT_UNIT_TEST_TABLE_AVRCP},
 165         {"Hid"
 166                 , BT_UNIT_TEST_TABLE_HID},
 167         {"IPSP"
 168                 , BT_UNIT_TEST_TABLE_IPSP},
 169         {"HDP"
 170                 , BT_UNIT_TEST_TABLE_HDP},
 171         {"DPM"
 172                 , BT_UNIT_TEST_TABLE_DPM},
 173         {"PXP"
 174                 , BT_UNIT_TEST_TABLE_PXP},
 175         {"HF Role"
 176                 , BT_UNIT_TEST_TABLE_HF},
 177         {"PBAP Client"
 178                 , BT_UNIT_TEST_TABLE_PBAP_CLIENT},
 179         {"etc.(Automated test, AppControl)"
 180                 , BT_UNIT_TEST_TABLE_ETC},
 181         {"TDS Provider"
 182                 , BT_UNIT_TEST_TABLE_TDS_PROVIDER},
 183         {"TDS Seeker"
 184                 , BT_UNIT_TEST_TABLE_TDS_SEEKER},
 185         {"OTP"
 186                 , BT_UNIT_TEST_TABLE_OTP},
 187         {"HRS"
 188                 , BT_UNIT_TEST_TABLE_HRP_SENSOR},
 189         {"HRC"
 190                 , BT_UNIT_TEST_TABLE_HRP_COLLECTOR},
 191         {"Initialize All"
 192                 , BT_UNIT_TEST_FUNCTION_INITIALIZE_ALL},
 193         {"FINISH"
 194                 , BT_UNIT_TEST_TABLE_FINISH},
 195         {NULL                                   , 0x0000},
 196 };
 197
 198 tc_table_t tc_adapter[] = {
 199         /* Adapter functions */
 200         {"BACK"
 201                 , BT_UNIT_TEST_FUNCTION_BACK},
 202         {"bt_adapter_get_state"
 203                 , BT_UNIT_TEST_FUNCTION_ADAPTER_GET_STATE},
 204         {"bt_adapter_enable"
 205                 , BT_UNIT_TEST_FUNCTION_ADAPTER_ENABLE},
 206         {"bt_adapter_disable"
 207                 , BT_UNIT_TEST_FUNCTION_ADAPTER_DISABLE},
 208         {"bt_adapter_recover"
 209                 , BT_UNIT_TEST_FUNCTION_ADAPTER_RECOVER},
 210         {"bt_adapter_start_device_discovery"
 211                 , BT_UNIT_TEST_FUNCTION_ADAPTER_START_DEVICE_DISCOVERY},
 212         {"bt_adapter_stop_device_discovery"
 213                 , BT_UNIT_TEST_FUNCTION_ADAPTER_STOP_DEVICE_DISCOVERY},
 214         {"bt_adapter_is_discovering"
 215                 , BT_UNIT_TEST_FUNCTION_ADAPTER_IS_DISCOVERING},
 216         {"bt_adapter_foreach_bonded_device"
 217                 , BT_UNIT_TEST_FUNCTION_ADAPTER_FOREACH_BONDED_DEVICE},
 218         {"bt_adapter_foreach_profile_connected_devices"
 219                 , BT_UNIT_TEST_FUNCTION_ADAPTER_FOREACH_PROFILE_CONNECTED_DEVICES},
 220         {"bt_adapter_get_bonded_device_info"
 221                 , BT_UNIT_TEST_FUNCTION_ADAPTER_GET_BONDED_DEVICE_INFO},
 222         {"bt_adapter_is_service_used"
 223                 , BT_UNIT_TEST_FUNCTION_ADAPTER_IS_SERVICE_USED},
 224         {"bt_adapter_get_visibility"
 225                 , BT_UNIT_TEST_FUNCTION_ADAPTER_GET_VISIBILITY},
 226         {"bt_adapter_set_visibility"
 227                 , BT_UNIT_TEST_FUNCTION_ADAPTER_SET_VISIBILITY},
 228         {"bt_adapter_set_device_discovery_state_changed_cb"
 229                 , BT_UNIT_TEST_FUNCTION_ADAPTER_SET_DEVICE_DISCOVERY_STATE_CHANGED_CB},
 230         {"bt_adapter_unset_device_discovery_state_changed_cb"
 231                 , BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_DEVICE_DISCOVERY_STATE_CHANGED_CB},
 232         {"bt_adapter_get_local_oob_data"
 233                 , BT_UNIT_TEST_FUNCTION_ADAPTER_GET_LOCAL_OOB_DATA},
 234         {"bt_adapter_set_remote_oob_data"
 235                 , BT_UNIT_TEST_FUNCTION_ADAPTER_SET_REMOTE_OOB_DATA},
 236         {"bt_adapter_remove_remote_oob_data"
 237                 , BT_UNIT_TEST_FUNCTION_ADAPTER_REMOVE_REMOTE_OOB_DATA},
 238         {"bt_adapter_get_local_oob_ext_data"
 239                 , BT_UNIT_TEST_FUNCTION_ADAPTER_GET_LOCAL_OOB_EXT_DATA},
 240         {"bt_adapter_set_remote_oob_ext_data"
 241                 , BT_UNIT_TEST_FUNCTION_ADAPTER_SET_REMOTE_OOB_EXT_DATA},
 242         {"bt_adapter_read_battery_info"
 243                 , BT_UNIT_TEST_FUNCTION_ADAPTER_READ_BATTERY_INFO},
 244         {"bt_adapter_init_battery_monitor"
 245                 , BT_UNIT_TEST_FUNCTION_ADAPTER_INIT_BATTERY_MONITOR},
 246         {"bt_adapter_deinit_battery_monitor"
 247                 , BT_UNIT_TEST_FUNCTION_ADAPTER_DEINIT_BATTERY_MONITOR},
 248         {"bt_adapter_set_visibility_mode_changed_cb"
 249                 , BT_UNIT_TEST_FUNCTION_ADAPTER_SET_VISIBILITY_MODE_CHANGED_CB},
 250         {"bt_adapter_unset_visibility_mode_changed_cb"
 251                 , BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_VISIBILITY_MODE_CHANGED_CB},
 252         {"bt_adapter_set_visibility_duration_changed_cb"
 253                 , BT_UNIT_TEST_FUNCTION_ADAPTER_SET_VISIBILITY_DURATION_CHANGED_CB},
 254         {"bt_adapter_unset_visibility_duration_changed_cb"
 255                 , BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_VISIBILITY_DURATION_CHANGED_CB},
 256         {"bt_adapter_set_connectable_changed_cb"
 257                 , BT_UNIT_TEST_FUNCTION_ADAPTER_SET_CONNECTABLE_CHANGED_CB},
 258         {"bt_adapter_unset_connectable_changed_cb"
 259                 , BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_CONNECTABLE_CHANGED_CB},
 260         {"bt_adapter_get_connectable"
 261                 , BT_UNIT_TEST_FUNCTION_ADAPTER_GET_CONNECTABLE},
 262         {"bt_adapter_set_connectable"
 263                 , BT_UNIT_TEST_FUNCTION_ADAPTER_SET_CONNECTABLE},
 264         {"bt_adapter_get_version"
 265                 , BT_UNIT_TEST_FUNCTION_ADAPTER_GET_VERSION},
 266         {"bt_adapter_get_local_info"
 267                 , BT_UNIT_TEST_FUNCTION_ADAPTER_GET_LOCAL_INFO},
 268         {"bt_adapter_set_manufacturer_data_changed_cb"
 269                 , BT_UNIT_TEST_FUNCTION_ADAPTER_SET_MANUFACTURER_DATA_CHANGED_CB},
 270         {"bt_adapter_unset_manufacturer_data_changed_cb"
 271                 , BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_MANUFACTURER_DATA_CHANGED_CB},
 272         {"bt_adapter_set_manufacturer_data"
 273                 , BT_UNIT_TEST_FUNCTION_ADAPTER_SET_MANUFACTURER_DATA},
 274         {"bt_adapter_set_authentication_req_cb"
 275                 , BT_UNIT_TEST_FUNCTION_ADAPTER_SET_AUTHENTICATION_REQUSET_CB},
 276         {"bt_adapter_set_authentication_request_cb"
 277                 , BT_UNIT_TEST_FUNCTION_ADAPTER_SET_AUTHENTICATION_REQUEST_CB_NEW},
 278         {"bt_adapter_unset_authentication_req_cb"
 279                 , BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_AUTHENTICATION_REQUSET_CB},
 280         {"bt_adapter_unset_authentication_request_cb"
 281                 , BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_AUTHENTICATION_REQUEST_CB_NEW},
 282         {"bt_adapter_passkey_reply(passkey, TRUE)"
 283                 , BT_UNIT_TEST_FUNCTION_ADAPTER_PASSKEY_REPLY_ACCEPT},
 284         {"bt_adapter_passkey_reply(passkey, FALSE)"
 285                 , BT_UNIT_TEST_FUNCTION_ADAPTER_PASSKEY_REPLY_CANCEL},
 286         {"bt_adapter_passkey_confirmation_reply(TRUE)"
 287                 , BT_UNIT_TEST_FUNCTION_ADAPTER_PASSKEY_CONFIRMATION_REPLY_ACCEPT},
 288         {"bt_adapter_passkey_confirmation_reply(FALSE)"
 289                 , BT_UNIT_TEST_FUNCTION_ADAPTER_PASSKEY_CONFIRMATION_REPLY_REJECT},
 290         {"Select this menu to set parameters and then select the function again."
 291                 , BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS},
 292         {NULL                                   , 0x0000},
 293 };
 294
 295 tc_table_t tc_adapter_le[] = {
 296         /* Adapter functions */
 297         {"BACK"
 298                 , BT_UNIT_TEST_FUNCTION_BACK},
 299         {"bt_adapter_le_get_state"
 300                 , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_GET_STATE},
 301         {"bt_adapter_le_enable"
 302                 , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_ENABLE},
 303         {"bt_adapter_le_disable"
 304                 , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_DISABLE},
 305         {"bt_adapter_le_set_scan_mode"
 306                 , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_SET_SCAN_MODE},
 307         {"bt_adapter_le_set_scan_type"
 308                 , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_SET_SCAN_TYPE},
 309         {"bt_adapter_le_set_customized_scan_mode"
 310                 , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_SET_SCAN_CUSTOMIZED},
 311         {"bt_adapter_le_start_scan"
 312                 , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_START_SCAN},
 313         {"bt_adapter_le_stop_scan"
 314                 , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_STOP_SCAN},
 315         {"bt_adapter_le_add_advertising_data"
 316                 , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_ADD_ADVERTISING_DATA},
 317         {"bt_adapter_le_set_advertising_mode"
 318                 , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_SET_ADVERTISING_MODE},
 319         {"bt_adapter_le_set_advertising_filter_policy"
 320                 , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_SET_ADVERTISING_FILTER_POLICY},
 321         {"bt_adapter_le_set_advertising_connectable"
 322                 , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_SET_ADVERTISING_CONNECTABLE},
 323         {"bt_adapter_le_set_advertising_custom_tx_power_level"
 324                 , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_SET_ADVERTISING_CUSTOM_TX_POWER},
 325         {"bt_adapter_le_start_advertising_new"
 326                 , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_START_ADVERTISING_NEW},
 327         {"bt_adapter_le_stop_advertising"
 328                 , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_STOP_ADVERTISING},
 329         {"bt_adapter_le_add_white_list"
 330                 , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_ADD_WHITE_LIST},
 331         {"bt_adapter_le_remove_white_list"
 332                 , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_REMOVE_WHITE_LIST},
 333         {"bt_adapter_le_enable_privacy"
 334                 , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_ENABLE_PRIVACY},
 335         {"bt_adapter_le_get_local_oob_ext_data"
 336                         , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_GET_LOCAL_OOB_EXT_DATA},
 337         {"bt_adapter_le_set_remote_oob_ext_data"
 338                         , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_SET_REMOTE_OOB_EXT_DATA},
 339         {"Register scan filter (Device Address)"
 340                 , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_REGISTER_SCAN_FILTER_DEVICE_ADDRESS},
 341         {"Register scan filter (Device Name)"
 342                 , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_REGISTER_SCAN_FILTER_DEVICE_NAME},
 343         {"Register scan filter (Service UUID)"
 344                 , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_REGISTER_SCAN_FILTER_SERVICE_UUID},
 345         {"Register scan filter (Service Solicitation UUID)"
 346                 , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_REGISTER_SCAN_FILTER_SERVICE_SOLICITATION_UUID},
 347         {"Register scan filter (Manufacturer DATA)"
 348                 , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_REGISTER_SCAN_FILTER_MANUFACTURER_DATA},
 349         {"Register iBeaconscan filter (Manufacturer DATA)"
 350                 , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_REGISTER_SCAN_FILTER_IBEACON_DATA},
 351         {"Unregister all scan filters"
 352                 , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_UNREGISTER_ALL_SCAN_FILTERS},
 353         {"bt_adater_le_read_maximum_data_length"
 354                 , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_READ_MAXIMUM_DATA_LENGTH},
 355         {"bt_adater_le_wite_host_suggested_def_data_length"
 356                 , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_WRITE_HOST_SUGGESTED_DEFAULT_DATA_LENGTH},
 357         {"bt_adater_le_read_host_suggested_def_data_length"
 358                 , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_READ_HOST_SUGGESTED_DEFAULT_DATA_LENGTH},
 359         {"bt_adapter_le_is_2m_phy_supported"
 360                 , BT_UNIT_TEST_FUNCTION_LE_2M_PHY_SUPPORT},
 361         {"bt_adapter_le_is_coded_phy_supported"
 362                 , BT_UNIT_TEST_FUNCTION_LE_CODED_PHY_SUPPORT},
 363         {"Select this menu to set parameters and then select the function again."
 364                 , BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS},
 365         {NULL                                   , 0x0000},
 366 };
 367
 368 tc_table_t tc_device[] = {
 369         /* Device functions */
 370         {"BACK"
 371                 , BT_UNIT_TEST_FUNCTION_BACK},
 372         {"bt_device_set_authorization (true)"
 373                 , BT_UNIT_TEST_FUNCTION_DEVICE_SET_AUTHORIZATION_TRUE},
 374         {"bt_device_set_authorization (false)"
 375                 , BT_UNIT_TEST_FUNCTION_DEVICE_SET_AUTHORIZATION_FALSE},
 376         {"bt_device_set_authorization_changed_cb"
 377                 , BT_UNIT_TEST_FUNCTION_DEVICE_SET_AUTHORIZATION_CHANGED_CB},
 378         {"bt_device_unset_authorization_changed_cb"
 379                 , BT_UNIT_TEST_FUNCTION_DEVICE_UNSET_AUTHORIZATION_CHANGED_CB},
 380         {"bt_device_set_connection_state_changed_cb"
 381                 , BT_UNIT_TEST_FUNCTION_DEVICE_SET_CONNECTION_STAET_CHANGED_CB},
 382         {"bt_device_unset_connection_state_changed_cb"
 383                 , BT_UNIT_TEST_FUNCTION_DEVICE_UNSET_CONNECTION_STAET_CHANGED_CB},
 384         {"bt_device_foreach_connected_profiles"
 385                 , BT_UNIT_TEST_FUNCTION_DEVICE_FOREACH_CONNECTED_PROFILES},
 386         {"bt_device_is_profile_connected"
 387                 , BT_UNIT_TEST_FUNCTION_DEVICE_IS_PROFILE_CONNECTED},
 388         {"bt_device_set_bond_created_cb"
 389                 , BT_UNIT_TEST_FUNCTION_DEVICE_SET_BOND_CREATED_CB},
 390         {"bt_device_set_bond_destroyed_cb"
 391                 , BT_UNIT_TEST_FUNCTION_DEVICE_SET_BOND_DESTROYED_CB},
 392         {"bt_device_disconnect"
 393                 , BT_UNIT_TEST_FUNCTION_DEVICE_DISCONNECT},
 394         {"bt_device_create_bond"
 395                 , BT_UNIT_TEST_FUNCTION_DEVICE_CREATE_BOND},
 396         {"bt_device_create_bond_by_type"
 397                 , BT_UNIT_TEST_FUNCTION_DEVICE_CREATE_BOND_BY_TYPE},
 398         {"bt_device_destroy_bond"
 399                 , BT_UNIT_TEST_FUNCTION_DEVICE_DESTROY_BOND},
 400         {"bt_device_update_le_connection_mode"
 401                 , BT_UNIT_TEST_FUNCTION_DEVICE_UPDATE_LE_CONNECTION_MODE},
 402         {"bt_device_le_conn_update"
 403                 , BT_UNIT_TEST_FUNCTION_DEVICE_UPDATE_LE_CONNECTION},
 404         {"bt_device_request_att_mtu"
 405                 , BT_UNIT_TEST_FUNCTION_DEVICE_REQUEST_ATT_MTU},
 406         {"bt_device_set_att_mtu_changed_cb"
 407                 , BT_UNIT_TEST_FUNCTION_DEVICE_SET_REQUEST_ATT_MTU_CHANGED_CB},
 408         {"bt_device_unset_att_mtu_changed_cb"
 409                 , BT_UNIT_TEST_FUNCTION_DEVICE_UNSET_REQUEST_ATT_MTU_CHANGED_CB},
 410         {"bt_device_get_att_mtu"
 411                                 , BT_UNIT_TEST_FUNCTION_DEVICE_GET_ATT_MTU},
 412         {"bt_device_le_set_data_length"
 413                 , BT_UNIT_TEST_FUNCTION_LE_DEVICE_SET_DATA_LENGTH},
 414         {"bt_device_le_data_length_changed_cb"
 415                 , BT_UNIT_TEST_FUNCTION_LE_DEVICE_DATA_LENGTH_CHANGED_CB},
 416         {"Select this menu to set parameters and then select the function again."
 417                 , BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS},
 418         {"bt_device_set_profile_trusted_A2DP(true)"
 419                 , BT_UNIT_TEST_FUNCTION_DEVICE_SET_PROFILE_TRUSTED_A2DP_TRUE},
 420         {"bt_device_set_profile_trusted_A2DP(false)"
 421                 , BT_UNIT_TEST_FUNCTION_DEVICE_SET_PROFILE_TRUSTED_A2DP_FALSE},
 422         {"bt_device_set_profile_trusted_HFP_HF(true)"
 423                 , BT_UNIT_TEST_FUNCTION_DEVICE_SET_PROFILE_TRUSTED_HFP_TRUE},
 424         {"bt_device_set_profile_trusted_HFP_HF(false)"
 425                 , BT_UNIT_TEST_FUNCTION_DEVICE_SET_PROFILE_TRUSTED_HFP_FALSE},
 426         {"bt_device_set_trusted_profile_cb"
 427                 , BT_UNIT_TEST_FUNCTION_DEVICE_SET_PROFILE_TRUSTED_CB},
 428         {"bt_device_unset_trusted_profile_cb"
 429                 , BT_UNIT_TEST_FUNCTION_DEVICE_UNSET_PROFILE_TRUSTED_CB},
 430         {NULL                                   , 0x0000},
 431 };
 432
 433 tc_table_t tc_socket[] = {
 434         /* Socket functions */
 435         {"BACK"
 436                 , BT_UNIT_TEST_FUNCTION_BACK},
 437         {"bt_socket_create_rfcomm"
 438                 , BT_UNIT_TEST_FUNCTION_SOCKET_CREATE_RFCOMM},
 439         {"bt_socket_destroy_rfcomm"
 440                 , BT_UNIT_TEST_FUNCTION_SOCKET_DESTROY_RFCOMM},
 441         {"bt_socket_listen_and_accept_rfcomm"
 442                 , BT_UNIT_TEST_FUNCTION_SOCKET_LISTEN_AND_ACCEPT_RFCOMM},
 443         {"bt_socket_listen"
 444                 , BT_UNIT_TEST_FUNCTION_SOCKET_LISTEN},
 445         {"bt_socket_accept"
 446                 , BT_UNIT_TEST_FUNCTION_SOCKET_ACCEPT},
 447         {"bt_socket_reject"
 448                 , BT_UNIT_TEST_FUNCTION_SOCKET_REJECT},
 449         {"bt_socket_connect_rfcomm"
 450                 , BT_UNIT_TEST_FUNCTION_SOCKET_CONNECT_RFCOMM},
 451         {"bt_socket_disconnect_rfcomm"
 452                 , BT_UNIT_TEST_FUNCTION_SOCKET_DISCONNECT_RFCOMM},
 453         {"bt_socket_send_data"
 454                 , BT_UNIT_TEST_FUNCTION_SOCKET_SEND_DATA},
 455         {"bt_socket_create_rfcomm with custom uuid"
 456                 , BT_UNIT_TEST_FUNCTION_SOCKET_CREATE_RFCOMM_CUSTOM_UUID},
 457         {"bt_socket_destroy_rfcomm with custom uuid"
 458                 , BT_UNIT_TEST_FUNCTION_SOCKET_DESTROY_RFCOMM_CUSTOM_UUID},
 459         {"bt_socket_listen_and_accept_rfcomm with custom uuid"
 460                 , BT_UNIT_TEST_FUNCTION_SOCKET_LISTEN_AND_ACCEPT_RFCOMM_CUSTOM_UUID},
 461         {"bt_socket_connect_rfcomm with custom uuid"
 462                 , BT_UNIT_TEST_FUNCTION_SOCKET_CONNECT_RFCOMM_CUSTOM_UUID},
 463         {"bt_socket_disconnect_rfcomm with custom uuid"
 464                 , BT_UNIT_TEST_FUNCTION_SOCKET_DISCONNECT_RFCOMM_CUSTOM_UUID},
 465         {"bt_socket_send_data with custom uuid"
 466                 , BT_UNIT_TEST_FUNCTION_SOCKET_SEND_DATA_CUSTOM_UUID},
 467         {"bt_socket_set_data_received_cb"
 468                 , BT_UNIT_TEST_FUNCTION_SOCKET_SET_DATA_RECEIVED_CB},
 469         {"bt_socket_unset_data_received_cb"
 470                 , BT_UNIT_TEST_FUNCTION_SOCKET_UNSET_DATA_RECEIVED_CB},
 471         {"bt_socket_set_connection_requested_cb"
 472                 , BT_UNIT_TEST_FUNCTION_SOCKET_SET_CONNECTION_REQUESTED_CB},
 473         {"bt_socket_unset_connection_requested_cb"
 474                 , BT_UNIT_TEST_FUNCTION_SOCKET_UNSET_CONNECTION_REQUESTED_CB},
 475         {"bt_socket_set_connection_state_changed_cb"
 476                 , BT_UNIT_TEST_FUNCTION_SOCKET_SET_CONNECTION_STATE_CHANGED_CB},
 477         {"bt_socket_unset_connection_state_changed_cb"
 478                 , BT_UNIT_TEST_FUNCTION_SOCKET_UNSET_CONNECTION_STATE_CHANGED_CB},
 479         {"Select this menu to set parameters and then select the function again."
 480                 , BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS},
 481         {NULL                                   , 0x0000},
 482 };
 483
 484 tc_table_t tc_opp[] = {
 485         /* OPP functions */
 486         {"BACK"
 487                 , BT_UNIT_TEST_FUNCTION_BACK},
 488         {"bt_opp_client_initialize"
 489                 , BT_UNIT_TEST_FUNCTION_OPP_CLIENT_INITIALIZE},
 490         {"bt_opp_client_deinitialize"
 491                 , BT_UNIT_TEST_FUNCTION_OPP_CLIENT_DEINITIALIZE},
 492         {"bt_opp_client_add_file"
 493                 , BT_UNIT_TEST_FUNCTION_OPP_CLIENT_ADD_FILE},
 494         {"bt_opp_client_clear_files"
 495                 , BT_UNIT_TEST_FUNCTION_OPP_CLIENT_CLEAR_FILES},
 496         {"bt_opp_client_push_files"
 497                 , BT_UNIT_TEST_FUNCTION_OPP_CLIENT_PUSH_FILES},
 498         {"bt_opp_client_cancel_push"
 499                 , BT_UNIT_TEST_FUNCTION_OPP_CLIENT_CANCEL_PUSH},
 500         {"Select this menu to set parameters and then select the function again."
 501                 , BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS},
 502         {NULL                                   , 0x0000},
 503 };
 504
 505 tc_table_t tc_audio[] = {
 506         /* AG functions */
 507         {"BACK"
 508                 , BT_UNIT_TEST_FUNCTION_BACK},
 509         {"bt_audio_initialize"
 510                 , BT_UNIT_TEST_FUNCTION_AUDIO_INITIALIZE},
 511         {"bt_audio_deinitialize"
 512                 , BT_UNIT_TEST_FUNCTION_AUDIO_DEINITIALIZE},
 513         {"bt_audio_connect"
 514                 , BT_UNIT_TEST_FUNCTION_AUDIO_CONNECT},
 515         {"bt_audio_disconnect"
 516                 , BT_UNIT_TEST_FUNCTION_AUDIO_DISCONNECT},
 517         {"bt_audio_sink_connect"
 518                 , BT_UNIT_TEST_FUNCTION_AUDIO_SINK_CONNECT},
 519         {"bt_audio_sink_disconnect"
 520                 , BT_UNIT_TEST_FUNCTION_AUDIO_SINK_DISCONNECT},
 521         {"bt_audio_set_connection_state_changed_cb"
 522                 , BT_UNIT_TEST_FUNCTION_AUDIO_SET_CONNECTION_STATE_CHANGED_CB},
 523         {"bt_audio_unset_connection_state_changed_cb"
 524                 , BT_UNIT_TEST_FUNCTION_AUDIO_UNSET_CONNECTION_STATE_CHANGED_CB},
 525         {"bt_ag_open_sco"
 526                 , BT_UNIT_TEST_FUNCTION_AG_OPEN_SCO},
 527         {"bt_ag_close_sco"
 528                 , BT_UNIT_TEST_FUNCTION_AG_CLOSE_SCO},
 529         {"bt_ag_is_sco_opened"
 530                 , BT_UNIT_TEST_FUNCTION_AG_IS_SCO_OPENED},
 531         {"bt_ag_set_sco_state_changed_cb"
 532                 , BT_UNIT_TEST_FUNCTION_AG_SET_SCO_STATE_CHANGED_CB},
 533         {"bt_ag_unset_sco_state_changed_cb"
 534                 , BT_UNIT_TEST_FUNCTION_AG_UNSET_SCO_STATE_CHANGED_CB},
 535         {"bt_ag_set_speaker_gain_changed_cb"
 536                 , BT_UNIT_TEST_FUNCTION_AG_SET_SPEAKER_GAIN_CHANGED_CB},
 537         {"bt_ag_unset_speaker_gain_changed_cb"
 538                 , BT_UNIT_TEST_FUNCTION_AG_UNSET_SPEAKER_GAIN_CHANGED_CB},
 539         {"bt_ag_set_microphone_gain_changed_cb"
 540                 , BT_UNIT_TEST_FUNCTION_AG_SET_MICRO_GAIN_CHANGED_CB},
 541         {"bt_ag_unset_microphone_gain_changed_cb"
 542                 , BT_UNIT_TEST_FUNCTION_AG_UNSET_MICRO_GAIN_CHANGED_CB},
 543         {"bt_ag_is_connected"
 544                 , BT_UNIT_TEST_FUNCTION_AG_IS_CONNECTED},
 545         {"BT_AG_CALL_EVENT_IDLE"
 546                 , BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_IDLE},
 547         {"BT_AG_CALL_EVENT_ANSWERED"
 548                 , BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_ANSWERED},
 549         {"BT_AG_CALL_EVENT_DIALING"
 550                 , BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_DIALING},
 551         {"BT_AG_CALL_EVENT_ALERTING"
 552                 , BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_ALERTING},
 553         {"BT_AG_CALL_EVENT_INCOMING"
 554                 , BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_INCOMING},
 555         {"bt_call_list_create"
 556                 , BT_UNIT_TEST_FUNCTION_CALL_LIST_CREATE},
 557         {"bt_call_list_destroy"
 558                 , BT_UNIT_TEST_FUNCTION_CALL_LIST_DESTROY},
 559         {"bt_call_list_reset"
 560                 , BT_UNIT_TEST_FUNCTION_CALL_LIST_RESET},
 561         {"bt_call_list_add"
 562                 , BT_UNIT_TEST_FUNCTION_CALL_LIST_ADD},
 563         {"bt_ag_notify_call_list"
 564                 , BT_UNIT_TEST_FUNCTION_AG_NOTIFY_CALL_LIST},
 565         {"bt_ag_set_call_handling_event_cb"
 566                 , BT_UNIT_TEST_FUNCTION_AG_SET_CALL_HANDLING_EVENT_CB},
 567         {"bt_ag_is_nrec_enabled"
 568                 , BT_UNIT_TEST_FUNCTION_AG_IS_NREC_ENABLED},
 569         {"bt_ag_switch_headset"
 570                 , BT_UNIT_TEST_FUNCTION_AG_SWITCH_HEADSET},
 571         {"bt_audio_select_role(source)"
 572                 , BT_UNIT_TEST_FUNCTION_A2DP_SOURCE_ROLE},
 573         {"bt_audio_select_role(sink)"
 574                 , BT_UNIT_TEST_FUNCTION_A2DP_SINK_ROLE},
 575         {"bt_audio_set_absolute_volume"
 576                 , BT_UNIT_TEST_FUNCTION_AUDIO_SET_ABSOLUTE_VOLUME},
 577         {"bt_audio_get_absolute_volume"
 578                 , BT_UNIT_TEST_FUNCTION_AUDIO_GET_ABSOLUTE_VOLUME},
 579         {"bt_audio_is_avc_activated"
 580                 , BT_UNIT_TEST_FUNCTION_AUDIO_IS_AVC_ACTIVATED},
 581         {"bt_audio_set_absolute_volume_changed_cb"
 582                 , BT_UNIT_TEST_FUNCTION_AUDIO_SET_ABSOLUTE_VOLUME_CHANGED_CB},
 583         {"bt_audio_unset_absolute_volume_changed_cb"
 584                 , BT_UNIT_TEST_FUNCTION_AUDIO_UNSET_ABSOLUTE_VOLUME_CHANGED_CB},
 585         {"bt_audio_set_avc_status_changed_cb"
 586                 , BT_UNIT_TEST_FUNCTION_AUDIO_SET_AVC_STATUE_CHANGED_CB},
 587         {"bt_audio_unset_avc_status_changed_cb"
 588                 , BT_UNIT_TEST_FUNCTION_AUDIO_UNSET_AVC_STATUE_CHANGED_CB},
 589         /* A2DP SCMS-T functions */
 590         {"Select this menu to set parameters and then select the function again."
 591                 , BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS},
 592         {NULL                                   , 0x0000},
 593 };
 594
 595 tc_table_t tc_pan[] = {
 596         /* Network functions */
 597         {"BACK"
 598                 , BT_UNIT_TEST_FUNCTION_BACK},
 599         {"bt_nap_activate"
 600                 , BT_UNIT_TEST_FUNCTION_NAP_ACTIVATE},
 601         {"bt_nap_deactivate"
 602                 , BT_UNIT_TEST_FUNCTION_NAP_DEACTIVATE},
 603         {"bt_nap_disconnect_all"
 604                 , BT_UNIT_TEST_FUNCTION_NAP_DISCONNECT_ALL},
 605         {"bt_nap_disconnect"
 606                 , BT_UNIT_TEST_FUNCTION_NAP_DISCONNECT},
 607         {"bt_panu_set_connection_state_changed_cb"
 608                 , BT_UNIT_TEST_FUNCTION_PANU_SET_CONNECTION_STATE_CHANGED_CB},
 609         {"bt_panu_connect"
 610                 , BT_UNIT_TEST_FUNCTION_PANU_CONNECT},
 611         {"Select this menu to set parameters and then select the function again."
 612                 , BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS},
 613         {NULL                                   , 0x0000},
 614 };
 615
 616 tc_table_t tc_gatt[] = {
 617         /* Gatt functions */
 618         {"BACK"
 619                 , BT_UNIT_TEST_FUNCTION_BACK},
 620         {"bt_gatt_connect"
 621                 , BT_UNIT_TEST_FUNCTION_GATT_CONNECT},
 622         {"bt_gatt_disconnect"
 623                 , BT_UNIT_TEST_FUNCTION_GATT_DISCONNECT},
 624         {"bt_gatt_set_connection_state_changed_cb"
 625                 , BT_UNIT_TEST_FUNCTION_SET_GATT_CONNECTION_STATE_CHANGED_CB},
 626         {"bt_gatt_unset_connection_state_changed_cb"
 627                 , BT_UNIT_TEST_FUNCTION_UNSET_GATT_CONNECTION_STATE_CHANGED_CB},
 628         {"bt_gatt_client_create"
 629                 , BT_UNIT_TEST_FUNCTION_GATT_CLIENT_CREATE},
 630         {"bt_gatt_client_destroy"
 631                 , BT_UNIT_TEST_FUNCTION_GATT_CLIENT_DESTROY},
 632         {"bt_gatt_client_get_remote_address"
 633                 , BT_UNIT_TEST_FUNCTION_GATT_CLIENT_GET_REMOTE_ADDRESS},
 634         {"bt_gatt_client_print_all"
 635                 , BT_UNIT_TEST_FUNCTION_GATT_CLIENT_PRINT_ALL},
 636         {"bt_gatt_client_read_value"
 637                 , BT_UNIT_TEST_FUNCTION_GATT_CLIENT_READ_VALUE},
 638         {"bt_gatt_client_write_value"
 639                 , BT_UNIT_TEST_FUNCTION_GATT_CLIENT_WRITE_VALUE},
 640         {"bt_gatt_client_set_char_value_changed_cb"
 641                 , BT_UNIT_TEST_FUNCTION_GATT_CLIENT_SET_CHAR_VALUE_CHANGED_CB},
 642         {"bt_gatt_client_unset_char_value_changed_cb"
 643                 , BT_UNIT_TEST_FUNCTION_GATT_CLIENT_UNSET_CHAR_VALUE_CHANGED_CB},
 644         {"bt_gatt_client_foreach_services"
 645                 , BT_UNIT_TEST_FUNCTION_GATT_CLIENT_FOREACH_SERVICES},
 646         {"bt_gatt_client_request_att_mtu_change"
 647                 , BT_UNIT_TEST_FUNCTION_GATT_CLIENT_REQUEST_ATT_MTU},
 648         {"bt_gatt_client_get_att_mtu"
 649                                 , BT_UNIT_TEST_FUNCTION_GATT_CLIENT_GET_ATT_MTU},
 650         {"bt_gatt_client_set_service_changed_cb"
 651                 , BT_UNIT_TEST_FUNCTION_GATT_CLIENT_SET_SERVICE_CHANGED_CB},
 652         {"bt_gatt_client_unset_service_changed_cb"
 653                 , BT_UNIT_TEST_FUNCTION_GATT_CLIENT_UNSET_SERVICE_CHANGED_CB},
 654         {"bt_gatt_client_set_att_mtu_changed_cb"
 655                 , BT_UNIT_TEST_FUNCTION_GATT_CLIENT_SET_ATT_MTU_CHANGED_CB},
 656         {"bt_gatt_client_unset_att_mtu_changed_cb"
 657                 , BT_UNIT_TEST_FUNCTION_GATT_CLIENT_UNSET_ATT_MTU_CHANGED_CB},
 658         {"bt_gatt_server_initialize"
 659                 , BT_UNIT_TEST_FUNCTION_GATT_SERVER_INITIALIZE},
 660         {"bt_gatt_server_deinitilaize"
 661                 , BT_UNIT_TEST_FUNCTION_GATT_SERVER_DEINITIALIZE},
 662         {"bt_gatt_server_unregister_all_services"
 663                 , BT_UNIT_TEST_FUNCTION_GATT_SERVER_UNREGISTER_ALL_SERVICES},
 664         {"bt_gatt_server_foreach_services"
 665                 , BT_UNIT_TEST_FUNCTION_GATT_SERVER_FOREACH_SERVICES},
 666         {"bt_gatt_server_get_device_mtu"
 667                 , BT_UNIT_TEST_FUNCTION_GATT_SERVER_GET_DEVICE_MTU},
 668         {"bt_gatt_server_set_att_mtu_changed_cb"
 669                 , BT_UNIT_TEST_FUNCTION_GATT_SERVER_SET_MTU_CHANGED_CB},
 670         {"Register Battery Service"
 671                 , BT_UNIT_TEST_FUNCTION_GATT_SERVER_REGISTER_BATTERY_SVC},
 672         {"Change Battery Level"
 673                 , BT_UNIT_TEST_FUNCTION_GATT_SERVER_CHANGE_BATTERY_LEVEL},
 674         {"Register Heart Rate Service"
 675                 , BT_UNIT_TEST_FUNCTION_GATT_SERVER_REGISTER_HEART_RATE_SVC},
 676         {"Notify Heart Rate Measurement"
 677                 , BT_UNIT_TEST_FUNCTION_GATT_SERVER_NOTIFY_HEART_RATE_MEASUREMENT},
 678         {"Register Thermometer Service"
 679                 , BT_UNIT_TEST_FUNCTION_GATT_SERVER_REGISTER_THERMOMETER_SVC},
 680         {"Change Thermometer Measurement"
 681                 , BT_UNIT_TEST_FUNCTION_GATT_SERVER_CHANGE_THERMOMETER_MEASUREMENT},
 682         {"Register Device Information Service"
 683                 , BT_UNIT_TEST_FUNCTION_GATT_SERVER_REGISTER_DEVICE_INFORMATION_SVC},
 684         {"Register Link Loss Service"
 685                 , BT_UNIT_TEST_FUNCTION_GATT_SERVER_REGISTER_LINK_LOSS_SVC},
 686         {"Register HID Over GATT Service"
 687                 , BT_UNIT_TEST_FUNCTION_GATT_SERVER_REGISTER_HOGP_SVC},
 688         {"Register Custom Service"
 689                 , BT_UNIT_TEST_FUNCTION_GATT_SERVER_REGISTER_CUSTOM_SVC},
 690         {"Change Custom Value"
 691                 , BT_UNIT_TEST_FUNCTION_GATT_SERVER_CHANGE_CUSTOM_VAL},
 692         {"Start Server"
 693                 , BT_UNIT_TEST_FUNCTION_GATT_START_SERVER},
 694         {"Get Specification Name from UUID"
 695                 , BT_UNIT_TEST_FUNCTION_GATT_GET_SPEC_NAME_FROM_UUID},
 696         {"ANCS (Pair)"
 697                 , BT_UNIT_TEST_FUNCTION_ANCS_PAIR},
 698         {"ANCS (Watch notification)"
 699                 , BT_UNIT_TEST_FUNCTION_ANCS_WATCH},
 700         {"ANCS (Positive action)"
 701                 , BT_UNIT_TEST_FUNCTION_ANCS_POSITIVE_ACTION},
 702         {"ANCS (Negative action)"
 703                 , BT_UNIT_TEST_FUNCTION_ANCS_NEGATIVE_ACTION},
 704         {"ANCS (Get Noti. Attr.)"
 705                 , BT_UNIT_TEST_FUNCTION_ANCS_GET_NOTI_ATTR},
 706         {"bt_gatt_get_available_data_batching_packets"
 707                 , BT_UNIT_TEST_FUNCTION_GATT_GET_DATA_BATCHING_AVAILABLE_PACKETS},
 708         {"bt_gatt_enable_data_batching"
 709                 , BT_UNIT_TEST_FUNCTION_GATT_ENABLE_DATA_BATCHING},
 710         {"bt_gatt_disable_data_batching"
 711                 , BT_UNIT_TEST_FUNCTION_GATT_DISABLE_DATA_BATCHING},
 712         {"Select this menu to set parameters and then select the function again."
 713                 , BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS},
 714         {NULL                                   , 0x0000},
 715 };
 716
 717 tc_table_t tc_hps[] = {
 718         /* HPS functions */
 719         {"BACK"
 720                 , BT_UNIT_TEST_FUNCTION_BACK},
 721         {"bt_hps_client_create"
 722                 , BT_UNIT_TEST_FUNCTION_HPS_CLIENT_CREATE},
 723         {"bt_hps_client_destroy"
 724                 , BT_UNIT_TEST_FUNCTION_HPS_CLIENT_DESTROY},
 725         {"bt_hps_client_print_all"
 726                 , BT_UNIT_TEST_FUNCTION_HPS_CLIENT_PRINT_ALL},
 727         {"bt_hps_client_read_value"
 728                 , BT_UNIT_TEST_FUNCTION_HPS_CLIENT_READ_VALUE},
 729         {"bt_hps_client_set_uri"
 730                 , BT_UNIT_TEST_FUNCTION_HPS_CLIENT_SET_URI},
 731         {"bt_hps_client_set_hdr"
 732                 , BT_UNIT_TEST_FUNCTION_HPS_CLIENT_SET_HDR},
 733         {"bt_hps_client_set_entity"
 734                 , BT_UNIT_TEST_FUNCTION_HPS_CLIENT_SET_ENTITY},
 735         {"bt_hps_client_set_cp"
 736                 , BT_UNIT_TEST_FUNCTION_HPS_CLIENT_SET_CP},
 737         {"bt_hps_client_get_uri"
 738                 , BT_UNIT_TEST_FUNCTION_HPS_CLIENT_GET_URI},
 739         {"bt_hps_client_get_hdr"
 740                 , BT_UNIT_TEST_FUNCTION_HPS_CLIENT_GET_HDR},
 741         {"bt_hps_client_get_entity"
 742                 , BT_UNIT_TEST_FUNCTION_HPS_CLIENT_GET_ENTITY},
 743         {"bt_hps_client_get_security"
 744                 , BT_UNIT_TEST_FUNCTION_HPS_CLIENT_GET_SECURITY},
 745         {"bt_hps_client_set_status_notification"
 746                 , BT_UNIT_TEST_FUNCTION_HPS_CLIENT_SET_STATUS_NOTIFICATION},
 747         {"bt_hps_client_unset_status_notification"
 748                 , BT_UNIT_TEST_FUNCTION_HPS_CLIENT_UNSET_STATUS_NOTIFICATION},
 749         {"Select this menu to set parameters and then select the function again."
 750                 , BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS},
 751         {NULL                                   , 0x0000},
 752 };
 753
 754 tc_table_t tc_pxp[] = {
 755         /* HPS functions */
 756         {"BACK"
 757                 , BT_UNIT_TEST_FUNCTION_BACK},
 758         {"Proximity Reporter(Register)"
 759                 , BT_UNIT_TEST_FUNCTION_PXP_REPORTER_REGISTER},
 760         {"Proximity Reporter(Unregister)"
 761                 , BT_UNIT_TEST_FUNCTION_PXP_REPORTER_UNREGISTER},
 762         {"Proximity Reporter(Start Advertising Proximity Reporter)"
 763                 , BT_UNIT_TEST_FUNCTION_PXP_REPORTER_START_ADVERTISING},
 764         {"Proximity Reporter (Set State Changed callback)"
 765                 , BT_UNIT_TEST_FUNCTION_PXP_REPORTER_SET_CONNECTION_STATE_CHANGED_CB},
 766         {"Proximity Reporter (UnSet State Changed callback)"
 767                 , BT_UNIT_TEST_FUNCTION_PXP_REPORTER_UNSET_CONNECTION_STATE_CHANGED_CB},
 768         {"Proximity Reporter (Set Property Changed callback)"
 769                 , BT_UNIT_TEST_FUNCTION_PXP_REPORTER_SET_PROPERTIES_CHANGED_CB},
 770         {"Proximity Reporter (UnSet Property Changed callback)"
 771                 , BT_UNIT_TEST_FUNCTION_PXP_REPORTER_UNSET_PROPERTIES_CHANGED_CB},
 772         {"Proximity Reporter(Read Linkloss Alert Level)"
 773                 , BT_UNIT_TEST_FUNCTION_PXP_REPORTER_READ_LINKLOSS_ALERT},
 774         {"Proximity Reporter(Read Immediate Alert Level)"
 775                 , BT_UNIT_TEST_FUNCTION_PXP_REPORTER_READ_IMMEDIATE_ALERT},
 776         {"Proximity Monitor(Create)"
 777                 , BT_UNIT_TEST_FUNCTION_PXP_MONITOR_CREATE},
 778         {"Proximity Monitor(Destroy)"
 779                 , BT_UNIT_TEST_FUNCTION_PXP_MONITOR_DESTROY},
 780         {"Proximity Monitor(Connect)"
 781                 , BT_UNIT_TEST_FUNCTION_PXP_MONITOR_CONNECT},
 782         {"Proximity Monitor(Disconnect)"
 783                 , BT_UNIT_TEST_FUNCTION_PXP_MONITOR_DISCONNECT},
 784         {"Proximity Monitor (Set State Changed callback)"
 785                 , BT_UNIT_TEST_FUNCTION_PXP_MONITOR_SET_CONNECTION_STATE_CHANGED_CB},
 786         {"Proximity Monitor (UnSet State Changed callback)"
 787                 , BT_UNIT_TEST_FUNCTION_PXP_MONITOR_UNSET_CONNECTION_STATE_CHANGED_CB},
 788         {"Proximity Monitor(Set LE Scan Filter for Proximity UUID)"
 789                 , BT_UNIT_TEST_FUNCTION_PXP_MONITOR_SET_SCAN_FILTER_SERVICE_UUID},
 790         {"Proximity Monitor(Unet LE Scan Filter for Proximity UUID)"
 791                 , BT_UNIT_TEST_FUNCTION_PXP_MONITOR_UNSET_SCAN_FILTER_SERVICE_UUID},
 792         {"Proximity Monitor(Write Linkloss Alert Level)"
 793                 , BT_UNIT_TEST_FUNCTION_PXP_MONITOR_WRITE_LINKLOSS_ALERT},
 794         {"Proximity Monitor(Write Immediate Alert Level)"
 795                 , BT_UNIT_TEST_FUNCTION_PXP_MONITOR_WRITE_IMMEDIATE_ALERT},
 796         {"Proximity Monitor(Read Linkloss Alert Level)"
 797                 , BT_UNIT_TEST_FUNCTION_PXP_MONITOR_READ_LINKLOSS_ALERT},
 798         {"Proximity Monitor(Read Immediate Alert Level)"
 799                 , BT_UNIT_TEST_FUNCTION_PXP_MONITOR_READ_IMMEDIATE_ALERT},
 800         {"Proximity Monitor(Read Signal Level)"
 801                 , BT_UNIT_TEST_FUNCTION_PXP_MONITOR_READ_SIGNAL_LEVEL},
 802         {"Select this menu to set parameters and then select the function again."
 803                 , BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS},
 804         {NULL                                   , 0x0000},
 805 };
 806
 807 tc_table_t tc_avrcp[] = {
 808         /* AVRCP functions */
 809         {"BACK"
 810                 , BT_UNIT_TEST_FUNCTION_BACK},
 811         {"bt_avrcp_target_initialize"
 812                 , BT_UNIT_TEST_FUNCTION_AVRCP_TARGET_INITIALIZE},
 813         {"bt_avrcp_target_deinitialize"
 814                 , BT_UNIT_TEST_FUNCTION_AVRCP_TARGET_DEINITIALIZE},
 815         {"bt_avrcp_set_equalizer_state_changed_cb"
 816                 , BT_UNIT_TEST_FUNCTION_AVRCP_SET_EQUALIZER_STATE_CHANGED_CB},
 817         {"bt_avrcp_set_repeat_mode_changed_cb"
 818                 , BT_UNIT_TEST_FUNCTION_AVRCP_SET_REPEAT_MODE_CHANGED_CB},
 819         {"bt_avrcp_set_shuffle_mode_changed_cb"
 820                 , BT_UNIT_TEST_FUNCTION_AVRCP_SET_SHUFFLE_MODE_CHANGED_CB},
 821         {"bt_avrcp_set_scan_mode_changed_cb"
 822                 , BT_UNIT_TEST_FUNCTION_AVRCP_SET_SCAN_MODE_CHANGED_CB},
 823         {"bt_avrcp_unset_equalizer_state_changed_cb"
 824                 , BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_EQUALIZER_STATE_CHANGED_CB},
 825         {"bt_avrcp_unset_repeat_mode_changed_cb"
 826                 , BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_REPEAT_MODE_CHANGED_CB},
 827         {"bt_avrcp_unset_shuffle_mode_changed_cb"
 828                 , BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_SHUFFLE_MODE_CHANGED_CB},
 829         {"bt_avrcp_unset_scan_mode_changed_cb"
 830                 , BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_SCAN_MODE_CHANGED_CB},
 831         {"bt_avrcp_control_initialize"
 832                 , BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_INITIALIZE},
 833         {"bt_avrcp_control_deinitialize"
 834                 , BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_DEINITIALIZE},
 835         {"bt_avrcp_control_connect"
 836                 , BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_CONNECT},
 837         {"bt_avrcp_control_disconnect"
 838                 , BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_DISCONNECT},
 839         {"bt_avrcp_control_player_PLAY"
 840                 , BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_PLAY},
 841         {"bt_avrcp_control_player_STOP"
 842                 , BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_STOP},
 843         {"bt_avrcp_control_player_PAUSE"
 844                 , BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_PAUSE},
 845         {"bt_avrcp_control_player_FF"
 846                 , BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_FF},
 847         {"bt_avrcp_control_player_RW"
 848                 , BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_RW},
 849         {"bt_avrcp_control_player_NEXT"
 850                 , BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_NEXT},
 851         {"bt_avrcp_control_player_PREV"
 852                 , BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_PREV},
 853         {"bt_avrcp_control_player_SET_ABSOLUTE_VOLUME"
 854                 , BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_SET_ABSOLUTE_VOLUME},
 855         {"bt_avrcp_control_player_VOLUME_UP"
 856                 , BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_VOLUME_UP},
 857         {"bt_avrcp_control_player_VOLUME_DOWN"
 858                 , BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_VOLUME_DOWN},
 859         {"bt_avrcp_control_player_GET_REPEAT"
 860                 , BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_GET_REPEAT},
 861         {"bt_avrcp_control_player_SET_REPEAT"
 862                 , BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_SET_REPEAT},
 863         {"bt_avrcp_control_player_GET_SHUFFLE"
 864                 , BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_GET_SHUFFLE},
 865         {"bt_avrcp_control_player_SET_SHUFFLE"
 866                 , BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_SET_SHUFFLE},
 867         {"bt_avrcp_control_player_GET_POSITION"
 868                 , BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_GET_POSITION},
 869         {"bt_avrcp_control_player_GET_PLAY STATUS"
 870                 , BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_GET_PLAY_STATUS},
 871         {"bt_avrcp_control_player_GET_TRACK_INFO"
 872                 , BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_GET_TRACK_INFO},
 873         {"bt_avrcp_set_position_changed_cb"
 874                 , BT_UNIT_TEST_FUNCTION_AVRCP_SET_SONG_POSITION_CHANGED_CB},
 875         {"bt_avrcp_set_play_status_changed_cb"
 876                 , BT_UNIT_TEST_FUNCTION_AVRCP_SET_PLAY_STATE_CHANGED_CB},
 877         {"bt_avrcp_set_track_info_changed_cb"
 878                 , BT_UNIT_TEST_FUNCTION_AVRCP_SET_TRACK_INFO_CHANGED_CB},
 879         {"bt_avrcp_unset_position_changed_cb"
 880                 , BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_SONG_POSITION_CHANGED_CB},
 881         {"bt_avrcp_unset_play_status_changed_cb"
 882                 , BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_PLAY_STATE_CHANGED_CB},
 883         {"bt_avrcp_unset_track_info_changed_cb"
 884                 , BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_TRACK_INFO_CHANGED_CB},
 885         {"Select this menu to set parameters and then select the function again."
 886                 , BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS},
 887         {NULL                                   , 0x0000},
 888 };
 889
 890 tc_table_t tc_hid[] = {
 891         /* HID functions */
 892         {"BACK"
 893                 , BT_UNIT_TEST_FUNCTION_BACK},
 894         {"bt_hid_host_initialize"
 895                 , BT_UNIT_TEST_FUNCTION_HID_HOST_INITIALIZE},
 896         {"bt_hid_host_deinitialize"
 897                 , BT_UNIT_TEST_FUNCTION_HID_HOST_DEINITIALIZE},
 898         {"bt_hid_host_connect"
 899                 , BT_UNIT_TEST_FUNCTION_HID_HOST_CONNECT},
 900         {"bt_hid_host_disconnect"
 901                 , BT_UNIT_TEST_FUNCTION_HID_HOST_DISCONNECT},
 902         {"bt_hid_device_activate"
 903                 , BT_UNIT_TEST_FUNCTION_HID_DEVICE_ACTIVATE},
 904         {"bt_hid_device_connect"
 905                 , BT_UNIT_TEST_FUNCTION_HID_DEVICE_CONNECT},
 906         {"bt_hid_device_disconnect"
 907                 , BT_UNIT_TEST_FUNCTION_HID_DEVICE_DISCONNECT},
 908         {"bt_hid_device_deactivate"
 909                 , BT_UNIT_TEST_FUCNTION_HID_DEVICE_DEACTIVATE},
 910         {"bt_hid_device_send_mouse_event"
 911                 , BT_UNIT_TEST_FUNCTION_HID_DEVICE_SEND_MOUSE_EVENT},
 912         {"bt_hid_device_send_key_event"
 913                 , BT_UNIT_TEST_FUNCTION_HID_DEVICE_SEND_KEY_EVENT},
 914         {"bt_hid_device_send_custom_event"
 915                 , BT_UNIT_TEST_FUNCTION_HID_DEVICE_SEND_RC_KEY_EVENT},
 916         {"bt_hid_device_set_data_received_cb"
 917                 , BT_UNIT_TEST_FUNCTION_HID_DEVICE_SET_DATA_RECEIVED_CB},
 918         {"bt_hid_device_unset_data_received_cd"
 919                 , BT_UNIT_TEST_FUNCTION_HID_DEVICE_UNSET_DATA_RECEIVED_CB},
 920         {"Select this menu to set parameters and then select the function again."
 921                 , BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS},
 922         {NULL                                   , 0x0000},
 923 };
 924
 925 tc_table_t tc_ipsp[] = {
 926         /* IPSP functions */
 927         {"BACK"
 928                                 , BT_UNIT_TEST_FUNCTION_BACK},
 929         {"bt_ipsp_register[Server role]"
 930                                 , BT_UNIT_TEST_FUNCTION_IPSP_REGISTER},
 931         {"bt_ipsp_unregister[Server role]"
 932                                 , BT_UNIT_TEST_FUNCTION_IPSP_UNREGISTER},
 933         {"bt_ipsp_initialize[Server role]"
 934                                 , BT_UNIT_TEST_FUNCTION_IPSP_INITIALIZE},
 935         {"bt_ipsp_deinitialize[Server role]"
 936                                 , BT_UNIT_TEST_FUNCTION_IPSP_DEINITIALIZE},
 937         {"bt_ipsp_connect[Client role]"
 938                                 , BT_UNIT_TEST_FUNCTION_IPSP_CONNECT},
 939         {"bt_ipsp_disconnect[Client role]"
 940                                 , BT_UNIT_TEST_FUNCTION_IPSP_DISCONNECT},
 941         {"bt_ipsp_start_advertising[Server role]"
 942                                 , BT_UNIT_TEST_FUNCTION_IPSP_START_ADVERTISING},
 943         {"bt_ipsp_set_connection_state_changed_cb[Client/Server role]"
 944                                 , BT_UNIT_TEST_FUNCTION_IPSP_SET_CONNECTION_STATE_CHANGED_CB},
 945         {"bt_ipsp_unset_connection_state_changed_cb[Client/Server role]"
 946                                 , BT_UNIT_TEST_FUNCTION_IPSP_UNSET_CONNECTION_STATE_CHANGED_CB},
 947         {"bt_ipsp_create_ipsp_app_server_socket[Server App role]"
 948                                 , BT_UNIT_TEST_FUNCTION_IPSP_CREATE_APP_SERVER_SOCKET},
 949         {"bt_ipsp_connect_with_ipsp_app_server_socket[Client App role]"
 950                                 , BT_UNIT_TEST_FUNCTION_IPSP_CONNECT_WITH_APP_SERVER_SOCKET},
 951         {"bt_ipsp_send_ipv6_application_data[Client/Server App role][Max 255 bytes]"
 952                                 , BT_UNIT_TEST_FUNCTION_IPSP_SEND_IPV6_APP_DATA},
 953         {"bt_ipsp_recv_ipv6_application_data[Client/Server App role]"
 954                                 , BT_UNIT_TEST_FUNCTION_IPSP_RECV_IPV6_APP_DATA},
 955         {"bt_ipsp_close_socket[Client/Server App role]"
 956                                 , BT_UNIT_TEST_FUNCTION_IPSP_CLOSE_SOCKET},
 957         {"Select this menu to set parameters and then select the function again."
 958                                 , BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS},
 959         {NULL                                   , 0x0000},
 960 };
 961
 962 tc_table_t tc_HDP[] = {
 963         /* HDP functions */
 964         {"BACK"
 965                 , BT_UNIT_TEST_FUNCTION_BACK},
 966         {"bt_hdp_register_sink_app"
 967                 , BT_UNIT_TEST_FUNCTION_HDP_REGISTER_SINK_APP},
 968         {"bt_hdp_unregister_sink_app"
 969                 , BT_UNIT_TEST_FUNCTION_HDP_UNREGISTER_SINK_APP},
 970         {"bt_hdp_connect_to_source"
 971                 , BT_UNIT_TEST_FUNCTION_HDP_CONNECT_TO_SOURCE},
 972         {"bt_hdp_disconnect"
 973                 , BT_UNIT_TEST_FUNCTION_HDP_DISCONNECT},
 974         {"bt_hdp_send_data"
 975                 , BT_UNIT_TEST_FUNCTION_HDP_SEND_DATA},
 976         {"bt_hdp_set_connection_state_changed_cb"
 977                 , BT_UNIT_TEST_FUNCTION_HDP_SET_CONNECTION_CB},
 978         {"bt_hdp_unset_connection_state_changed_cb"
 979                 , BT_UNIT_TEST_FUNCTION_HDP_UNSET_CONNECTION_CB},
 980         {"bt_hdp_set_data_received_cb"
 981                 , BT_UNIT_TEST_FUNCTION_HDP_SET_DATA_RECEIVED_CB},
 982         {"bt_hdp_unset_data_received_cb"
 983                 , BT_UNIT_TEST_FUNCTION_HDP_UNSET_DATA_RECEIVED_CB},
 984         {"Select this menu to set parameters and then select the function again."
 985                 , BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS},
 986         {NULL                                   , 0x0000},
 987 };
 988
 989 tc_table_t tc_DPM[] = {
 990         /* DPM functions */
 991         {"BACK"
 992                 , BT_UNIT_TEST_FUNCTION_BACK},
 993         {"bt_dpm_Set_default_policies"
 994         , BT_UNIT_TEST_FUNCTION_DPM_SET_DEFAULT_POLICIES},
 995         {"bt_dpm_set_allow_bluetooth_mode"
 996                 , BT_UNIT_TEST_FUNCTION_DPM_SET_ALLOW_BLUETOOTH_MODE},
 997         {"bt_dpm_get_allow_bluetooth_mode"
 998                 , BT_UNIT_TEST_FUNCTION_DPM_GET_ALLOW_BLUETOOTH_MODE},
 999         {"bt_dpm_activate_device_restriction"
1000                 , BT_UNIT_TEST_FUNCTION_DPM_ACTIVATE_DEVICE_RESTRICTION},
1001         {"bt_dpm_is_device_restriction_active"
1002                 , BT_UNIT_TEST_FUNCTION_DPM_IS_DEVICE_RESTRICTIO_ACTIVATE},
1003         {"bt_dpm_activate_bluetoooth_uuid_restriction"
1004                 , BT_UNIT_TEST_FUNCTION_DPM_ACTIVATE_UUID_RESTRICTION},
1005         {"bt_dpm_is_uuid_restriction_active"
1006                 , BT_UNIT_TEST_FUNCTION_DPM_IS_UUID_RESTRICTIO_ACTIVATE},
1007         {"bt_dpm_add_devices_to_blacklist"
1008                 , BT_UNIT_TEST_FUNCTION_DPM_ADD_DEVICES_TO_BLACKLIST},
1009         {"bt_dpm_add_devices_to_whitelist"
1010                 , BT_UNIT_TEST_FUNCTION_DPM_ADD_DEVICES_TO_WHITELIST},
1011         {"bt_dpm_add_uuids_to_blacklist"
1012                 , BT_UNIT_TEST_FUNCTION_DPM_ADD_UUIDS_TO_BLACKLIST},
1013         {"bt_dpm_add_uuids_to_whitelist"
1014                 , BT_UNIT_TEST_FUNCTION_DPM_ADD_UUIDS_TO_WHITELIST},
1015         {"bt_dpm_get_devices_from_blacklist"
1016                 , BT_UNIT_TEST_FUNCTION_DPM_GET_DEVICES_FROM_BLACKLIST},
1017         {"bt_dpm_get_devices_from_whitelist"
1018                 , BT_UNIT_TEST_FUNCTION_DPM_GET_DEVICES_FROM_WHITELIST},
1019         {"bt_dpm_get_uuids_from_blacklist"
1020                 , BT_UNIT_TEST_FUNCTION_DPM_GET_UUIDS_FROM_BLACKLIST},
1021         {"bt_dpm_get_uuids_from_whitelist"
1022                 , BT_UNIT_TEST_FUNCTION_DPM_GET_UUIDS_FROM_WHITELIST},
1023         {"bt_dpm_clear_devices_from_blacklist"
1024                 , BT_UNIT_TEST_FUNCTION_DPM_CLEAR_DEVICES_FROM_BLACKLIST},
1025         {"bt_dpm_clear_devices_from_whitelist"
1026                 , BT_UNIT_TEST_FUNCTION_DPM_CLEAR_DEVICES_FROM_WHITELIST},
1027         {"bt_dpm_clear_uuids_from_blacklist"
1028                 , BT_UNIT_TEST_FUNCTION_DPM_CLEAR_UUIDS_FROM_BLACKLIST},
1029         {"bt_dpm_clear_uuids_from_whitelist"
1030                 , BT_UNIT_TEST_FUNCTION_DPM_CLEAR_UUIDS_FROM_WHITELIST},
1031         {"bt_dpm_remove_device_from_blacklist"
1032                 , BT_UNIT_TEST_FUNCTION_DPM_REMOVE_DEVICE_FROM_BLACKLIST},
1033         {"bt_dpm_remove_device_from_whitelist"
1034                 , BT_UNIT_TEST_FUNCTION_DPM_REMOVE_DEVICE_FROM_WHITELIST},
1035         {"bt_dpm_remove_uuid_from_blacklist"
1036                 , BT_UNIT_TEST_FUNCTION_DPM_REMOVE_UUIDS_FROM_BLACKLIST},
1037         {"bt_dpm_remove_uuid_from_whitelist"
1038                 , BT_UNIT_TEST_FUNCTION_DPM_REMOVE_UUIDS_FROM_WHITELIST},
1039         {"bt_dpm_set_allow_outgoing_call"
1040                 , BT_UNIT_TEST_FUNCTION_DPM_SET_ALLOW_OUTGOING_CALL},
1041         {"bt_dpm_get_allow_outgoing_call"
1042                 , BT_UNIT_TEST_FUNCTION_DPM_GET_ALLOW_OUTGOING_CALL},
1043         {"bt_dpm_set_pairing_state"
1044                 , BT_UNIT_TEST_FUNCTION_DPM_SET_PAIRING_STATE},
1045         {"bt_dpm_get_pairing_state"
1046                 , BT_UNIT_TEST_FUNCTION_DPM_GET_PAIRING_STATE},
1047         {"bt_dpm_set_profile_state"
1048                 , BT_UNIT_TEST_FUNCTION_DPM_SET_PROFILE_STATE},
1049         {"bt_dpm_get_profile_state"
1050                 , BT_UNIT_TEST_FUNCTION_DPM_GET_PROFILE_STATE},
1051         {"bt_dpm_set_desktop_connectivity_state"
1052                 , BT_UNIT_TEST_FUNCTION_DPM_SET_DESKTOP_CONNECTIVITY_STATE},
1053         {"bt_dpm_get_desktop_connectivity_state"
1054                 , BT_UNIT_TEST_FUNCTION_DPM_GET_DESKTOP_CONNECTIVITY_STATE},
1055         {"bt_dpm_set_discoverable_state"
1056                 , BT_UNIT_TEST_FUNCTION_DPM_SET_DISCOVERABLE_STATE},
1057         {"bt_dpm_get_discoverable_state"
1058                 , BT_UNIT_TEST_FUNCTION_DPM_GET_DISCOVERABLE_STATE},
1059         {"bt_dpm_set_limited_discoverable_state"
1060                 , BT_UNIT_TEST_FUNCTION_DPM_SET_LIMITED_DISCOVERABLE_STATE},
1061         {"bt_dpm_get_limited_discoverable_state"
1062                 , BT_UNIT_TEST_FUNCTION_DPM_GET_LIMITED_DISCOVERABLE_STATE},
1063         {"bt_dpm_set_data_transfer_state"
1064                 , BT_UNIT_TEST_FUNCTION_DPM_SET_DATA_TRANSFER_STATE},
1065         {"bt_dpm_get_data_transfer_state"
1066                 , BT_UNIT_TEST_FUNCTION_DPM_GET_DATA_TRANSFER_STATE},
1067         {"Select this menu to set parameters and then select the function again."
1068                 , BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS},
1069         {NULL                                   , 0x0000},
1070 };
1071
1072 tc_table_t tc_hf[] = {
1073         /* Handsfree role functions */
1074         {"BACK"
1075                 , BT_UNIT_TEST_FUNCTION_BACK},
1076         {"bt_hf_initialize"
1077                 , BT_UNIT_TEST_FUNCTION_HF_INITIALIZE},
1078         {"bt_hf_deinitialize"
1079                 , BT_UNIT_TEST_FUNCTION_HF_DEINITIALIZE},
1080         {"(CALL Handling) bt_hf_notify_call_event(answer)"
1081                 , BT_UNIT_TEST_FUNCTION_HF_NOTIFY_CALL_ANSWER},
1082         {"(CALL Handling) bt_hf_notify_call_event(initiate)"
1083                 , BT_UNIT_TEST_FUNCTION_HF_NOTIFY_CALL_INIT},
1084         {"(CALL Handling) bt_hf_notify_call_event(terminate)"
1085                 , BT_UNIT_TEST_FUNCTION_HF_NOTIFY_CALL_TERM},
1086         {"(CALL Status) bt_hf_get_call_status_info_list"
1087                 , BT_UNIT_TEST_FUNCTION_HF_GET_CALL_STATUS_INFO_LIST},
1088         {"(CALL Status) bt_hf_request_call_status_info_list"
1089                 , BT_UNIT_TEST_FUNCTION_HF_REQUEST_CALL_STATUS_INFO_LIST},
1090         {"(CALL Status) bt_hf_set_call_handling_event_cb()"
1091                 , BT_UNIT_TEST_FUNCTION_HF_SET_CALL_EVENT_CB},
1092         {"(CALL Status) bt_hf_unset_call_handling_event_cb"
1093                 , BT_UNIT_TEST_FUNCTION_HF_UNSET_CALL_EVENT_CB},
1094         {"(CALL Status) bt_hf_set_call_status_updated_event_cb"
1095                 , BT_UNIT_TEST_FUNCTION_HF_SET_CALL_STATUS_UPDATED_EVENT_CB},
1096         {"(CALL Status) bt_hf_unset_call_status_updated_event_cb"
1097                 , BT_UNIT_TEST_FUNCTION_HF_UNSET_CALL_STATUS_UPDATED_EVENT_CB},
1098         {"(Volume) bt_hf_notify_speaker_gain"
1099                 , BT_UNIT_TEST_FUNCTION_HF_NOTIFY_SPEAKER_GAIN},
1100         {"(Volume) bt_hf_set_speaker_gain_changed_cb"
1101                 , BT_UNIT_TEST_FUNCTION_HF_SET_SPEAKER_GAIN_CB},
1102         {"(Volume) bt_hf_unset_speaker_gain_changed_cb"
1103                 , BT_UNIT_TEST_FUNCTION_HF_UNSET_SPEAKER_GAIN_CB},
1104         {"(Voice-recog) bt_hf_notify_voice_recognition_state(true)"
1105                 , BT_UNIT_TEST_FUNCTION_HF_NOTIFY_VOICE_REC_TRUE},
1106         {"(Voice-recog) bt_hf_notify_voice_recognition_state(false)"
1107                 , BT_UNIT_TEST_FUNCTION_HF_NOTIFY_VOICE_REC_FALSE},
1108         {"(SCO) bt_hf_is_sco_opened"
1109                 , BT_UNIT_TEST_FUNCTION_HF_IS_SCO_OPENED},
1110         {"(SCO) bt_hf_get_codec_id"
1111                 , BT_UNIT_TEST_FUNCTION_HF_GET_CODEC_ID},
1112         {"(SCO) bt_hf_set_sco_state_changed_cb()"
1113                 , BT_UNIT_TEST_FUNCTION_HF_SET_SCO_CHANGED_CB},
1114         {"(SCO) bt_hf_unset_sco_state_changed_cb()"
1115                 , BT_UNIT_TEST_FUNCTION_HF_UNSET_SCO_CHANGED_CB},
1116         {"Select this menu to set parameters and then select the function again."
1117                 , BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS},
1118         {NULL                                           , 0x0000},
1119 };
1120
1121 tc_table_t tc_pbap_client[] = {
1122         /* PBAP Functions*/
1123         {"BACK"
1124                 , BT_UNIT_TEST_FUNCTION_BACK},
1125         {"bt_pbap_client_initialize()"
1126                 , BT_UNIT_TEST_FUNCTION_PBAP_CLIENT_INITIALIZE},
1127         {"bt_pbap_client_deinitialize()"
1128                 , BT_UNIT_TEST_FUNCTION_PBAP_CLIENT_DEINITIALIZE},
1129         {"bt_pbap_client_set_connection_state_changed_cb()"
1130                 , BT_UNIT_TEST_FUNCTION_PBAP_CLIENT_SET_CONNECTION_STATE_CHANGED_CB},
1131         {"bt_pbap_client_unset_connection_state_changed_cb()"
1132                 , BT_UNIT_TEST_FUNCTION_PBAP_CLIENT_UNSET_CONNECTION_STATE_CHANGED_CB},
1133         {"bt_pbap_client_connect()"
1134                 , BT_UNIT_TEST_FUNCTION_PBAP_CLIENT_CONNECT},
1135         {"bt_pbap_client_disconnect()"
1136                 , BT_UNIT_TEST_FUNCTION_PBAP_CLIENT_DISCONNECT},
1137         {"bt_pbap_client_is_connected()"
1138                 , BT_UNIT_TEST_FUNCTION_PBAP_CLIENT_IS_CONNECTED},
1139         {"bt_pbap_client_get_phone_book_size()"
1140                 , BT_UNIT_TEST_FUNCTION_PBAP_CLIENT_GETSIZE},
1141         {"bt_pbap_client_get_phone_book()"
1142                 , BT_UNIT_TEST_FUNCTION_PBAP_CLIENT_PHONEBOOKPULL},
1143         {"bt_pbap_client_get_list()"
1144                 , BT_UNIT_TEST_FUNCTION_PBAP_CLIENT_VCARDLIST},
1145         {"bt_pbap_client_pull_vcard()"
1146                 , BT_UNIT_TEST_FUNCTION_PBAP_CLIENT_VCARDPULL},
1147         {"bt_pbap_client_search_phone_book()"
1148                 , BT_UNIT_TEST_FUNCTION_PBAP_CLIENT_PHONEBOOKSEARCH},
1149         {"bt_pbap_client_get_list() Maxlist=0"
1150                 , BT_UNIT_TEST_FUNCTION_PBAP_CLIENT_VCARDLIST_MAXLIST_ZERO},
1151         {"Select this menu to set parameters and then select the function again."
1152                 , BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS},
1153         {NULL                                   , 0x0000},
1154 };
1155
1156 tc_table_t tc_tds_provider[] = {
1157         /* TDS provider functions */
1158         {"BACK"
1159                 , BT_UNIT_TEST_FUNCTION_BACK},
1160         {"TDS Provider(Register)"
1161                 , BT_UNIT_TEST_FUNCTION_TDS_PROVIDER_REGISTER},
1162         {"TDS Provider(Unregister)"
1163                 , BT_UNIT_TEST_FUNCTION_TDS_PROVIDER_UNREGISTER},
1164         {"TDS Provider set activation req callback"
1165                 , BT_UNIT_TEST_FUNCTION_TDS_PROVIDER_SET_ACT_REQ_CB},
1166         {"TDS Provider unset activation req callback"
1167                 , BT_UNIT_TEST_FUNCTION_TDS_PROVIDER_UNSET_ACT_REQ_CB},
1168         {"TDS CUSTOM Provider(Create)"
1169                 , BT_UNIT_TEST_FUNCTION_TDS_CUSTOM_PROVIDER_CREATE},
1170         {"TDS CUSTOM Provider(Destroy)"
1171                 , BT_UNIT_TEST_FUNCTION_TDS_CUSTOM_PROVIDER_DESTROY},
1172         {"TDS CUSTOM Provider(Set transport Data)"
1173                 , BT_UNIT_TEST_FUNCTION_TDS_CUSTOM_PROVIDER_SET_TRANSPORT_DATA},
1174         {"TDS CUSTOM Provider(Set manuf Data)"
1175                 , BT_UNIT_TEST_FUNCTION_TDS_CUSTOM_PROVIDER_SET_MANUF_DATA},
1176         {"TDS CUSTOM Provider(Send Activation Response)"
1177                 , BT_UNIT_TEST_FUNCTION_TDS_CUSTOM_PROVIDER_SEND_ACTIVATION_RESP},
1178         {NULL                                   , 0x0000},
1179 };
1180
1181 tc_table_t tc_tds_seeker[] = {
1182         /* TDS Seeker functions */
1183         {"BACK"
1184                 , BT_UNIT_TEST_FUNCTION_BACK},
1185         {"TDS Seeker Start Discovering Provider"
1186                 , BT_UNIT_TEST_FUNCTION_TDS_START_DISCOVERING_PROVIDER},
1187         {"TDS Seeker Stop Discovering Provider"
1188                 , BT_UNIT_TEST_FUNCTION_TDS_STOP_DISCOVERING_PROVIDER},
1189         {"TDS Seeker(Create)"
1190                 , BT_UNIT_TEST_FUNCTION_TDS_SEEKER_CREATE},
1191         {"TDS Seeker(Destroy)"
1192                 , BT_UNIT_TEST_FUNCTION_TDS_SEEKER_DESTROY},
1193         {"TDS Set Seeker Connection cb"
1194                 , BT_UNIT_TEST_FUNCTION_TDS_SEEKER_SET_CONNECTION_CALLBACK},
1195         {"TDS Seeker Connect(remote)"
1196                 , BT_UNIT_TEST_FUNCTION_TDS_SEEKER_CONNECT},
1197         {"TDS Seeker DisConnect(remote)"
1198                 , BT_UNIT_TEST_FUNCTION_TDS_SEEKER_DISCONNECT},
1199         {"TDS UnSet Seeker Connection cb"
1200                 , BT_UNIT_TEST_FUNCTION_TDS_SEEKER_UNSET_CONNECTION_CALLBACK},
1201         {"TDS Read Complete Transport Data (remote)"
1202                 , BT_UNIT_TEST_FUNCTION_TDS_SEEKER_GET_COMPLETE_DATA},
1203         {"TDS Activate Control Point (remote)"
1204                 , BT_UNIT_TEST_FUNCTION_TDS_SEEKER_ACTIVATE_CONTROL_POINT},
1205         {NULL                                   , 0x0000},
1206 };
1207
1208 tc_table_t tc_otp[] = {
1209         /* OTP functions */
1210         {"BACK"
1211                 , BT_UNIT_TEST_FUNCTION_BACK},
1212         {"bt_otp_server_init"
1213                 , BT_UNIT_TEST_FUNCTION_OTP_SERVER_INIT},
1214         {"bt_otp_server_deinit"
1215                 , BT_UNIT_TEST_FUNCTION_OTP_SERVER_DEINIT},
1216         {"bt_otp_set_server_state_changed_cb"
1217                 , BT_UNIT_TEST_FUNCTION_OTP_SET_SERVER_STATE_CHANGED_CB},
1218         {"bt_otp_unset_server_state_changed_cb"
1219                 , BT_UNIT_TEST_FUNCTION_OTP_UNSET_SERVER_STATE_CHANGED_CB},
1220         {"bt_otp_client_create"
1221                 , BT_UNIT_TEST_FUNCTION_OTP_CLIENT_CREATE},
1222         {"bt_otp_client_destroy"
1223                 , BT_UNIT_TEST_FUNCTION_OTP_CLIENT_DESTROY},
1224         {"bt_otp_client_set_connection_state_changed_cb"
1225                 , BT_UNIT_TEST_FUNCTION_OTP_CLIENT_SET_CONNECTION_CALLBACK},
1226         {"bt_otp_client_unset_connection_state_changed_cb"
1227                 , BT_UNIT_TEST_FUNCTION_OTP_CLIENT_UNSET_CONNECTION_CALLBACK},
1228         {"bt_otp_client_connect"
1229                 , BT_UNIT_TEST_FUNCTION_OTP_CLIENT_CONNECT},
1230         {"bt_otp_client_disconnect"
1231                 , BT_UNIT_TEST_FUNCTION_OTP_CLIENT_DISCONNECT},
1232         {"bt_otp_client_discover_all_objects"
1233                 , BT_UNIT_TEST_FUNCTION_OTP_CLIENT_DISCOVER_ALL_OBJECTS},
1234         {"bt_otp_client_select_object"
1235                 , BT_UNIT_TEST_FUNCTION_OTP_CLIENT_SELECT_OBJ},
1236         {"bt_otp_client_read_object_contents"
1237                 , BT_UNIT_TEST_FUNCTION_OTP_CLIENT_READ_OBJ_CONTENTS},
1238         {"bt_otp_client_create_object"
1239                 , BT_UNIT_TEST_FUNCTION_OTP_CLIENT_CREATE_OBJ},
1240         {"bt_otp_client_write_object"
1241                 , BT_UNIT_TEST_FUNCTION_OTP_CLIENT_WRITE_OBJ},
1242         {"bt_otp_client_execute_object"
1243                 , BT_UNIT_TEST_FUNCTION_OTP_CLIENT_EXECUTE_OBJ},
1244         {"bt_otp_client_delete_object"
1245                 , BT_UNIT_TEST_FUNCTION_OTP_CLIENT_DELETE_OBJ},
1246         {NULL                                   , 0x0000},
1247 };
1248
1249 tc_table_t tc_hr_sensor[] = {
1250         /* HR Sensor functions */
1251         {"BACK"
1252                 , BT_UNIT_TEST_FUNCTION_BACK},
1253         {"[sensor]Set Location Value"
1254                 , BT_UNIT_TEST_FUNCTION_HR_SENSOR_SET_LOC_VALUE},
1255         {"[sensor]Set Contact Value"
1256                 , BT_UNIT_TEST_FUNCTION_HR_SENSOR_SET_CONTACT_VALUE},
1257         {"[sensor]Set Device Name"
1258                 , BT_UNIT_TEST_FUNCTION_HR_SENSOR_SET_DEVICE_NAME},
1259         {"[sensor] Create Sensor"
1260                 , BT_UNIT_TEST_FUNCTION_HR_SENSOR_CREATE},
1261         {"[sensor] Notify Collector"
1262                 , BT_UNIT_TEST_FUNCTION_HR_SENSOR_NOTIFY},
1263         {"[sensor] Destroy Sensor"
1264                 , BT_UNIT_TEST_FUNCTION_HR_SENSOR_DESTORY},
1265         {NULL                                   , 0x0000},
1266 };
1267
1268 tc_table_t tc_hr_collector[] = {
1269         {"BACK"
1270                 , BT_UNIT_TEST_FUNCTION_BACK},
1271         {"[collector]Set Connection State callback"
1272                 , BT_UNIT_TEST_FUNCTION_HR_COLLECTOR_CONNECTION_STATE_CALLBACK},
1273         {"[collector]Set/Unset Notification"
1274                 , BT_UNIT_TEST_FUNCTION_HR_COLLECTOR_SET_NOTIFICATION},
1275         {"[collector]Start Scan"
1276                 , BT_UNIT_TEST_FUNCTION_HR_COLLECTOR_START_SCAN},
1277         {"[collector]Stop Scan"
1278                 , BT_UNIT_TEST_FUNCTION_HR_COLLECTOR_STOP_SCAN},
1279         {"[collector]Connect Sensor"
1280                 , BT_UNIT_TEST_FUNCTION_HR_COLLECTOR_CONNECT},
1281         {"[collector]Disconnect Sensor"
1282                 , BT_UNIT_TEST_FUNCTION_HR_COLLECTOR_DISCONNECT},
1283         {"[collector]Create Collector"
1284                 , BT_UNIT_TEST_FUNCTION_HR_COLLECTOR_CREATE},
1285         {"[collector]Destroy Collector"
1286                 , BT_UNIT_TEST_FUNCTION_HR_COLLECTOR_DESTROY},
1287         {"[collector]Read Body Sensor Location"
1288                 , BT_UNIT_TEST_FUNCTION_HR_COLLECTOR_GET_BSL_LOC},
1289         {NULL                                   , 0x0000},
1290 };
1291
1292
1293 tc_table_t tc_automated_test[] = {
1294         /* Automated test Functions*/
1295         {"BACK"                                                         , BT_UNIT_TEST_FUNCTION_BACK},
1296         {"On/Off repeat test()"                                         , BT_UNIT_TEST_FUNCTION_ON_OFF_REPEAT_TEST},
1297         {"On/Off repeat(1sec delay) test()"                             , BT_UNIT_TEST_FUNCTION_ON_OFF_REPEAT_TEST_1_SEC_DELAY},
1298         {"On/Off repeat(Nsec delay) test()"                             , BT_UNIT_TEST_FUNCTION_ON_OFF_REPEAT_TEST_N_SEC_DELAY},
1299         {"AppControl default"                                   , BT_UNIT_TEST_FUNCTION_APP_CONTROL_DEFAULT},
1300         {"AppControl 2.3 BT onoff"                                      , BT_UNIT_TEST_FUNCTION_APP_CONTROL_2_3_BT_ONOFF},
1301         {"AppControl 2.3 BT Visibility"                         , BT_UNIT_TEST_FUNCTION_APP_CONTROL_2_3_BT_VISIBILITY},
1302         {"AppControl 2.4 BT onoff"                                      , BT_UNIT_TEST_FUNCTION_APP_CONTROL_2_4_BT_ONOFF},
1303         {"AppControl 2.4 BT Visibility"                                 , BT_UNIT_TEST_FUNCTION_APP_CONTROL_2_4_BT_VISIBILITY},
1304         {"Check feature(ex.tizen.org/feature/network.bluetooth)"        , BT_UNIT_TEST_FUNCTION_CHECK_FEATURE},
1305
1306         {"Select this menu to set parameters and then select the function again."                       , BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS},
1307         {NULL                                   , 0x0000},
1308 };
1309
1310 static void __bt_initialize_all(void);
1311
1312 void __bt_gatt_client_value_changed_cb(bt_gatt_h chr, char *value, int len,
1313                 void *user_data);
1314
1315 void tc_usage_print(void)
1316 {
1317         int i = 0;
1318         tc_table_t *tc_table = NULL;
1319
1320         switch (current_tc_table) {
1321         case BT_UNIT_TEST_TABLE_SET_ADDRESS:
1322                 TC_PRT("Key 0 : usage BACK");
1323                 TC_PRT("Input the address of remote device."
1324                         "(e.g.,F6:FB:8F:D8:C8:7C)\n\n");
1325                 return;
1326         case BT_UNIT_TEST_TABLE_ADAPTER:
1327                 tc_table = tc_adapter;
1328                 break;
1329         case BT_UNIT_TEST_TABLE_ADAPTER_LE:
1330                 tc_table = tc_adapter_le;
1331                 break;
1332         case BT_UNIT_TEST_TABLE_DEVICE:
1333                 tc_table = tc_device;
1334                 break;
1335         case BT_UNIT_TEST_TABLE_SOCKET:
1336                 tc_table = tc_socket;
1337                 break;
1338         case BT_UNIT_TEST_TABLE_OPP:
1339                 tc_table = tc_opp;
1340                 break;
1341         case BT_UNIT_TEST_TABLE_AUDIO:
1342                 tc_table = tc_audio;
1343                 break;
1344         case BT_UNIT_TEST_TABLE_PAN:
1345                 tc_table = tc_pan;
1346                 break;
1347         case BT_UNIT_TEST_TABLE_GATT:
1348                 tc_table = tc_gatt;
1349                 break;
1350         case BT_UNIT_TEST_TABLE_HPS:
1351                 tc_table = tc_hps;
1352                 break;
1353         case BT_UNIT_TEST_TABLE_AVRCP:
1354                 tc_table = tc_avrcp;
1355                 break;
1356         case BT_UNIT_TEST_TABLE_HID:
1357                 tc_table = tc_hid;
1358                 break;
1359         case BT_UNIT_TEST_TABLE_IPSP:
1360                 tc_table = tc_ipsp;
1361                 break;
1362         case BT_UNIT_TEST_TABLE_HDP:
1363                 tc_table = tc_HDP;
1364                 break;
1365         case BT_UNIT_TEST_TABLE_DPM:
1366                 tc_table = tc_DPM;
1367                 break;
1368         case BT_UNIT_TEST_TABLE_PXP:
1369                 tc_table = tc_pxp;
1370                 break;
1371         case BT_UNIT_TEST_TABLE_HF:
1372                 if (!TIZEN_PROFILE_WEARABLE_IVI)
1373                         goto __default__;
1374                 tc_table = tc_hf;
1375                 break;
1376         case BT_UNIT_TEST_TABLE_PBAP_CLIENT:
1377                 if (!TIZEN_PROFILE_WEARABLE_IVI)
1378                         goto __default__;
1379                 tc_table = tc_pbap_client;
1380                 break;
1381         case BT_UNIT_TEST_TABLE_ETC:
1382                 if (input_automated_test_delay == true) {
1383                         TC_PRT("Input the delay for automated"
1384                                 "test.(e.g., 10)\n\n");
1385                         return;
1386                 }
1387                 tc_table = tc_automated_test;
1388                 break;
1389         case BT_UNIT_TEST_FUNCTION_INITIALIZE_ALL:
1390                 __bt_initialize_all();
1391                 TC_PRT("Key 0 : usage BACK");
1392                 return;
1393         case BT_UNIT_TEST_TABLE_TDS_PROVIDER:
1394                 tc_table = tc_tds_provider;
1395                 break;
1396         case BT_UNIT_TEST_TABLE_TDS_SEEKER:
1397                 tc_table = tc_tds_seeker;
1398                 break;
1399         case BT_UNIT_TEST_TABLE_OTP:
1400                 tc_table = tc_otp;
1401                 break;
1402         case BT_UNIT_TEST_TABLE_HRP_SENSOR:
1403                 tc_table = tc_hr_sensor;
1404                 break;
1405         case BT_UNIT_TEST_TABLE_HRP_COLLECTOR:
1406                 tc_table = tc_hr_collector;
1407                 break;
1408         case BT_UNIT_TEST_TABLE_MAIN:
1409 __default__:
1410         default:
1411                 tc_table = tc_main;
1412                 break;
1413         }
1414
1415         while (tc_table[i].tc_name) {
1416                 TC_PRT("Key %d : usage %s", tc_table[i].tc_code,
1417                                                 tc_table[i].tc_name);
1418                 i++;
1419         }
1420         printf("\n\n");
1421 }
1422
1423 static void __bt_free_test_param(tc_params_t *param)
1424 {
1425         int i = 0;
1426
1427         for (i = 0; i < param->param_count; i++)
1428                 g_free(param->params[i]);
1429         g_free(param->params);
1430         param->params = NULL;
1431         param->param_count = 0;
1432 }
1433
1434 static const char *__bt_get_error_message(bt_error_e err)
1435 {
1436         const char *err_str = NULL;
1437
1438         switch (err) {
1439         case BT_ERROR_NONE:
1440                 err_str = "BT_ERROR_NONE";
1441                 break;
1442         case BT_ERROR_CANCELLED:
1443                 err_str = "BT_ERROR_CANCELLED";
1444                 break;
1445         case BT_ERROR_INVALID_PARAMETER:
1446                 err_str = "BT_ERROR_INVALID_PARAMETER";
1447                 break;
1448         case BT_ERROR_OUT_OF_MEMORY:
1449                 err_str = "BT_ERROR_OUT_OF_MEMORY";
1450                 break;
1451         case BT_ERROR_RESOURCE_BUSY:
1452                 err_str = "BT_ERROR_RESOURCE_BUSY";
1453                 break;
1454         case BT_ERROR_TIMED_OUT:
1455                 err_str = "BT_ERROR_TIMED_OUT";
1456                 break;
1457         case BT_ERROR_NOW_IN_PROGRESS:
1458                 err_str = "BT_ERROR_NOW_IN_PROGRESS";
1459                 break;
1460         case BT_ERROR_NOT_INITIALIZED:
1461                 err_str = "BT_ERROR_NOT_INITIALIZED";
1462                 break;
1463         case BT_ERROR_NOT_ENABLED:
1464                 err_str = "BT_ERROR_NOT_ENABLED";
1465                 break;
1466         case BT_ERROR_ALREADY_DONE:
1467                 err_str = "BT_ERROR_ALREADY_DONE";
1468                 break;
1469         case BT_ERROR_OPERATION_FAILED:
1470                 err_str = "BT_ERROR_OPERATION_FAILED";
1471                 break;
1472         case BT_ERROR_NOT_IN_PROGRESS:
1473                 err_str = "BT_ERROR_NOT_IN_PROGRESS";
1474                 break;
1475         case BT_ERROR_REMOTE_DEVICE_NOT_BONDED:
1476                 err_str = "BT_ERROR_REMOTE_DEVICE_NOT_BONDED";
1477                 break;
1478         case BT_ERROR_AUTH_REJECTED:
1479                 err_str = "BT_ERROR_AUTH_REJECTED";
1480                 break;
1481         case BT_ERROR_AUTH_FAILED:
1482                 err_str = "BT_ERROR_AUTH_FAILED";
1483                 break;
1484         case BT_ERROR_REMOTE_DEVICE_NOT_FOUND:
1485                 err_str = "BT_ERROR_REMOTE_DEVICE_NOT_FOUND";
1486                 break;
1487         case BT_ERROR_SERVICE_SEARCH_FAILED:
1488                 err_str = "BT_ERROR_SERVICE_SEARCH_FAILED";
1489                 break;
1490         case BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED:
1491                 err_str = "BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED";
1492                 break;
1493         case BT_ERROR_PERMISSION_DENIED:
1494                 err_str = "BT_ERROR_PERMISSION_DENIED";
1495                 break;
1496         case BT_ERROR_SERVICE_NOT_FOUND:
1497                 err_str = "BT_ERROR_SERVICE_NOT_FOUND";
1498                 break;
1499         case BT_ERROR_NO_DATA:
1500                 err_str = "BT_ERROR_NO_DATA";
1501                 break;
1502         case BT_ERROR_NOT_SUPPORTED:
1503                 err_str = "BT_ERROR_NOT_SUPPORTED";
1504                 break;
1505         case BT_ERROR_DEVICE_POLICY_RESTRICTION:
1506                 err_str = "DEVICE_POLICY_RESTRICTION";
1507                 break;
1508         default:
1509                 err_str = "NOT Defined";
1510                 break;
1511         }
1512
1513         return err_str;
1514 }
1515
1516 void __bt_adapter_state_changed_cb(int result,
1517                 bt_adapter_state_e adapter_state, void *user_data)
1518 {
1519         TC_PRT("__bt_adapter_state_changed_cb");
1520         TC_PRT("result: %s", __bt_get_error_message(result));
1521         TC_PRT("state: %s",
1522                         (adapter_state == BT_ADAPTER_ENABLED) ?
1523                                         "ENABLED" : "DISABLED");
1524 }
1525
1526 static void __bt_adapter_disable_battery_cb(bt_battery_info_s *data)
1527 {
1528         TC_PRT("Battery data: %ld %ld %d %d", data->session_start_time,
1529                 data->session_end_time, data->session_scan_time, data->session_connected_time);
1530         if (data->atm_list == NULL) {
1531                 TC_PRT("No data transaction in this session");
1532                 return;
1533         }
1534
1535         TC_PRT("Displaying app-wise transaction details");
1536         for (GSList *l = data->atm_list; l != NULL; l = g_slist_next(l)) {
1537                 bt_battery_app_info_s *t = (bt_battery_app_info_s *)(l->data);
1538                 TC_PRT("uid: %ld, pid: %ld, received bytes: %d, sent bytes: %d, time: %u",
1539                         (long int)(t->uid), (long int)(t->pid), t->rx_bytes, t->tx_bytes, t->time);
1540         }
1541 }
1542
1543 static void __bt_adapter_device_visibility_mode_changed_cb(int result,
1544                                 bt_adapter_visibility_mode_e visibility_mode,
1545                                 void *user_data)
1546 {
1547         TC_PRT("result: %s", __bt_get_error_message(result));
1548         TC_PRT("visibility_mode: %d", visibility_mode);
1549 }
1550
1551 static void __bt_adapter_device_visibility_duration_changed_cb(int duration,
1552                                 void *user_data)
1553 {
1554         TC_PRT("visibility_duration: %d", duration);
1555 }
1556
1557 static void __bt_adapter_connectable_changed_cb(int result,
1558                                 bool connectable, void *user_data)
1559 {
1560         if (result != BT_ERROR_NONE) {
1561                 TC_PRT("connectable change is failed : [0x%04x]", result);
1562                 return;
1563         }
1564
1565         TC_PRT("%s", connectable ? "Connectable" : "Non-connectable");
1566 }
1567
1568 static void __bt_adapter_manufacturer_data_changed_cb(char *data,
1569                                                 int len, void *user_data)
1570 {
1571         int i;
1572
1573         TC_PRT("manufacturer data is changed");
1574         for (i = 0; i < len; i++)
1575                 TC_PRT("[%d] %02x", i, data[i]);
1576 }
1577
1578 static void __bt_adapter_authentication_req_cb(
1579         int result, bt_authentication_type_info_e auth_type,
1580         char *device_name, char *remote_addr,
1581         char *pass_key, void *user_data)
1582 {
1583         TC_PRT("__bt_adapter_authentication_req_cb:"
1584                 " device name = %s", device_name);
1585         TC_PRT("__bt_adapter_authentication_req_cb:"
1586                 " device address = %s", remote_addr);
1587
1588         if (auth_type == BT_AUTH_PIN_REQUEST) {
1589                 TC_PRT("Auth Type = BT_AUTH_PIN_REQUEST");
1590         } else if (auth_type == BT_AUTH_PASSKEY_CONFIRM_REQUEST) {
1591                 TC_PRT("Auth Type = BT_AUTH_PASSKEY_CONFIRM_REQUEST");
1592                 TC_PRT("Passkey: [%s]", pass_key);
1593         } else if (auth_type == BT_AUTH_KEYBOARD_PASSKEY_DISPLAY) {
1594                 TC_PRT("Auth Type = BT_AUTH_KEYBOARD_PASSKEY_DISPLAY");
1595                 TC_PRT("Passkey: [%s]", pass_key);
1596         }
1597 }
1598
1599 static void __bt_adapter_authentication_request_cb(
1600         bool incoming, bt_authentication_type_info_e auth_type,
1601         char *device_name, char *remote_addr,
1602         char *pass_key, void *user_data)
1603 {
1604         TC_PRT("__bt_adapter_authentication_request_cb:"
1605                 " device name = %s", device_name);
1606         TC_PRT("__bt_adapter_authentication_request_cb:"
1607                 " device address = %s", remote_addr);
1608
1609         if (incoming == TRUE)
1610                 TC_PRT("It is an incoming request");
1611         else
1612                 TC_PRT("It is not an incoming request");
1613
1614         if (auth_type == BT_AUTH_PIN_REQUEST) {
1615                 TC_PRT("Auth Type = BT_AUTH_PIN_REQUEST");
1616         } else if (auth_type == BT_AUTH_PASSKEY_CONFIRM_REQUEST) {
1617                 TC_PRT("Auth Type = BT_AUTH_PASSKEY_CONFIRM_REQUEST");
1618                 TC_PRT("Passkey: [%s]", pass_key);
1619         } else if (auth_type == BT_AUTH_KEYBOARD_PASSKEY_DISPLAY) {
1620                 TC_PRT("Auth Type = BT_AUTH_KEYBOARD_PASSKEY_DISPLAY");
1621                 TC_PRT("Passkey: [%s]", pass_key);
1622         }
1623 }
1624
1625 static bool __bt_adapter_bonded_device_cb(bt_device_info_s *device_info,
1626         void *user_data)
1627 {
1628         int i;
1629         char *str = NULL;
1630
1631         TC_PRT("remote_address: %s", device_info->remote_address);
1632         TC_PRT("remote_name: %s", device_info->remote_name);
1633         TC_PRT("is_connected: %d", device_info->is_connected);
1634         TC_PRT("service_count: %d", device_info->service_count);
1635         TC_PRT("service 0x%x, major 0x%x, minor 0x%x", device_info->bt_class.major_service_class_mask,
1636                         device_info->bt_class.major_device_class,
1637                         device_info->bt_class.minor_device_class);
1638
1639         if (device_info->service_uuid == NULL) {
1640                 TC_PRT("No uuids");
1641         } else {
1642                 for (i = 0; i < device_info->service_count; i++) {
1643                         bt_get_uuid_name(device_info->service_uuid[i], &str);
1644
1645                         TC_PRT("[%d / %d] %s (%s)", i, device_info->service_count,
1646                                 str ? str : "Unknown", device_info->service_uuid[i]);
1647                         g_free(str);
1648                         str = NULL;
1649                 }
1650         }
1651
1652         if (device_info->manufacturer_data_len > 0) {
1653                 TC_PRT("manufacturer specific data(len:%d)",
1654                         device_info->manufacturer_data_len);
1655                 printf("data [");
1656                 for (i = 0; i < device_info->manufacturer_data_len; i++)
1657                         printf("%02x ", device_info->manufacturer_data[i]);
1658                 printf("]\n");
1659         }
1660         printf("\n");
1661
1662         return true;
1663 }
1664
1665 static bool __bt_adapter_profile_connected_devices_cb(
1666         const char *remote_address, void *user_data)
1667 {
1668         TC_PRT("remote_address: %s", remote_address);
1669
1670         return true;
1671 }
1672
1673 static void __bt_adapter_device_discovery_state_changed_cb(
1674         int result, bt_adapter_device_discovery_state_e discovery_state,
1675         bt_adapter_device_discovery_info_s *discovery_info,
1676         void *user_data)
1677 {
1678         int i;
1679
1680         TC_PRT("discovery_state: %d", discovery_state);
1681
1682         if (discovery_info == NULL) {
1683                 TC_PRT("No discovery_info!");
1684                 return;
1685         }
1686
1687         TC_PRT("remote_address: %s", discovery_info->remote_address);
1688         TC_PRT("remote_name: %s", discovery_info->remote_name);
1689         TC_PRT("rssi: %d", discovery_info->rssi);
1690         TC_PRT("is_bonded: %d", discovery_info->is_bonded);
1691         TC_PRT("service 0x%x, major 0x%x, minor 0x%x", discovery_info->bt_class.major_service_class_mask,
1692                         discovery_info->bt_class.major_device_class,
1693                         discovery_info->bt_class.minor_device_class);
1694         TC_PRT("service_count: %d", discovery_info->service_count);
1695
1696         if (discovery_info->service_uuid == NULL) {
1697                 TC_PRT("No uuids");
1698         } else {
1699                 for (i = 0; i < discovery_info->service_count; i++)
1700                         TC_PRT("uuid: %s", discovery_info->service_uuid[i]);
1701         }
1702
1703         if (discovery_info->manufacturer_data_len > 0) {
1704                 TC_PRT("manufacturer specific data(len:%d)",
1705                         discovery_info->manufacturer_data_len);
1706                 printf("data [");
1707                 for (i = 0; i < discovery_info->manufacturer_data_len; i++)
1708                         printf("%02x ", discovery_info->manufacturer_data[i]);
1709                 printf("]\n");
1710         }
1711 }
1712
1713 static GSList *le_scan_list;
1714 gint __bt_compare_address(gpointer *a, gpointer *b)
1715 {
1716         bt_adapter_le_device_scan_result_info_s *info = (bt_adapter_le_device_scan_result_info_s *)a;
1717         char *address = (char *)b;
1718         return g_strcmp0(info->remote_address, address);
1719 }
1720
1721 static void __bt_adapter_le_scan_result_cb(
1722         int result, bt_adapter_le_device_scan_result_info_s *info,
1723         void *user_data)
1724 {
1725         int i;
1726         bt_adapter_le_packet_type_e pkt_type = BT_ADAPTER_LE_PACKET_ADVERTISING;
1727         bt_adapter_le_device_scan_result_info_s *adv_info;
1728
1729         if (info == NULL) {
1730                 TC_PRT("No discovery_info!");
1731                 return;
1732         }
1733
1734         TC_PRT(" ");
1735         TC_PRT("%s Adv %d Scan resp %d RSSI %d Addr_type %d",
1736                         info->remote_address, info->adv_data_len,
1737                         info->scan_data_len, info->rssi,
1738                         info->address_type);
1739
1740         if (info->adv_data_len > 31 || info->scan_data_len > 31) {
1741                 TC_PRT("###################");
1742                 bt_adapter_le_stop_scan();
1743                 TC_PRT("###################");
1744                 return;
1745         }
1746
1747         GSList *l = NULL;
1748         l = g_slist_find_custom(le_scan_list, info->remote_address,
1749                 (GCompareFunc)__bt_compare_address);
1750         if (l == NULL) {
1751                 adv_info = g_malloc0(sizeof(bt_adapter_le_device_scan_result_info_s));
1752                 adv_info->remote_address= g_strdup(info->remote_address);
1753                 adv_info->rssi = info->rssi;
1754                 le_scan_list = g_slist_append(le_scan_list, adv_info);
1755         } else {
1756                 adv_info = l->data;
1757                 adv_info->rssi = info->rssi;
1758         }
1759
1760         for (i = 0; i < 2; i++) {
1761                 char **uuids;
1762                 char *device_name;
1763                 int tx_power_level;
1764                 bt_adapter_le_service_data_s *data_list;
1765                 int appearance;
1766                 int manufacturer_id;
1767                 char *manufacturer_data;
1768                 int manufacturer_data_len;
1769                 int count;
1770                 bt_adapter_le_ibeacon_scan_result_info_s *ibeacon_info = NULL;
1771
1772                 pkt_type += i;
1773                 if (pkt_type == BT_ADAPTER_LE_PACKET_ADVERTISING
1774                         && info->adv_data == NULL) continue;
1775                 if (pkt_type == BT_ADAPTER_LE_PACKET_SCAN_RESPONSE
1776                         && info->scan_data == NULL) break;
1777
1778                 if (bt_adapter_le_get_scan_result_service_uuids(
1779                         info, pkt_type, &uuids, &count) == BT_ERROR_NONE) {
1780                         int i;
1781                         for (i = 0; i < count; i++) {
1782                                 TC_PRT("UUID[%d] = %s", i + 1, uuids[i]);
1783                                 g_free(uuids[i]);
1784                         }
1785                         g_free(uuids);
1786                 }
1787                 if (bt_adapter_le_get_scan_result_device_name(
1788                         info, pkt_type, &device_name) == BT_ERROR_NONE) {
1789                         TC_PRT("Device name = %s", device_name);
1790                         if (adv_info->adv_data == NULL)
1791                                 adv_info->adv_data= g_strdup(device_name);
1792                         g_free(device_name);
1793                 }
1794                 if (bt_adapter_le_get_scan_result_tx_power_level(
1795                         info, pkt_type, &tx_power_level) == BT_ERROR_NONE) {
1796                         TC_PRT("TX Power level = %d", tx_power_level);
1797                 }
1798                 if (bt_adapter_le_get_scan_result_service_solicitation_uuids(
1799                         info, pkt_type, &uuids, &count) == BT_ERROR_NONE) {
1800                         int i;
1801                         for (i = 0; i < count; i++) {
1802                                 TC_PRT("Solicitation UUID[%d] = %s",
1803                                         i + 1, uuids[i]);
1804                                 g_free(uuids[i]);
1805                         }
1806                         g_free(uuids);
1807                 }
1808                 if (bt_adapter_le_get_scan_result_service_data_list(
1809                         info, pkt_type, &data_list, &count) == BT_ERROR_NONE) {
1810                         int i;
1811                         for (i = 0; i < count; i++)
1812                                 TC_PRT("Service Data[%d] = [0x%2.2X%2.2X:0x%.2X...]",
1813                                         i + 1, data_list[i].service_uuid[0],
1814                                         data_list[i].service_uuid[1],
1815                                         data_list[i].service_data[0]);
1816                         bt_adapter_le_free_service_data_list(data_list, count);
1817                 }
1818                 if (bt_adapter_le_get_scan_result_appearance(
1819                         info, pkt_type, &appearance) == BT_ERROR_NONE) {
1820                         TC_PRT("Appearance = %d", appearance);
1821                 }
1822                 if (bt_adapter_le_get_scan_result_manufacturer_data(
1823                         info, pkt_type, &manufacturer_id, &manufacturer_data,
1824                         &manufacturer_data_len) == BT_ERROR_NONE) {
1825
1826                         if (manufacturer_data_len > 1) {
1827                                 TC_PRT("Manufacturer data[ID:%.4X, 0x%.2X%.2X...(len:%d)]",
1828                                         manufacturer_id, manufacturer_data[0],
1829                                         manufacturer_data[1], manufacturer_data_len);
1830                         } else {
1831                                 TC_PRT("Manufacturer data[ID:%.4X, len:%d]", manufacturer_id, manufacturer_data_len);
1832                         }
1833
1834                         g_free(manufacturer_data);
1835                 }
1836                 if (bt_adapter_le_get_scan_result_ibeacon_report(info, pkt_type,
1837                                                                 &ibeacon_info) == BT_ERROR_NONE) {
1838                                 TC_PRT("APPLE IBEACON");
1839                                 TC_PRT("Company_id: %d", ibeacon_info->company_id);
1840                                 TC_PRT("ibeacon_type: %d", ibeacon_info->ibeacon_type);
1841                                 TC_PRT("uuid: %s", ibeacon_info->uuid);
1842                                 TC_PRT("major_id: %d", ibeacon_info->major_id);
1843                                 TC_PRT("minor_id: %d", ibeacon_info->minor_id);
1844                                 TC_PRT("measured_power: %d", ibeacon_info->measured_power);
1845                                 bt_adapter_le_free_ibeacon_report(ibeacon_info);
1846                 }
1847         }
1848 }
1849
1850 static void __print_gatt_handler(bt_gatt_h gatt_handle)
1851 {
1852         if (!gatt_handle) {
1853                 TC_PRT("Invalid handler");
1854                 return;
1855         }
1856
1857         char *type;
1858         char *role;
1859         bt_gatt_common_s *handle = (bt_gatt_common_s *)gatt_handle;
1860
1861         if (handle->type == BT_GATT_TYPE_SERVICE)
1862                 type = g_strdup("Service");
1863         else if (handle->type == BT_GATT_TYPE_CHARACTERISTIC)
1864                 type = g_strdup("Characteristic");
1865         else if (handle->type == BT_GATT_TYPE_DESCRIPTOR)
1866                 type = g_strdup("Descriptor");
1867         else
1868                 type = g_strdup("Unknown");
1869
1870         if (handle->role == BT_GATT_ROLE_SERVER)
1871                 role = g_strdup("Server");
1872         else if (handle->role == BT_GATT_ROLE_CLIENT)
1873                 role = g_strdup("Client");
1874         else
1875                 role = g_strdup("Unknown");
1876
1877         TC_PRT("GATT %s  [%s]", type, role);
1878         TC_PRT("%s [%s]", handle->path, handle->uuid);
1879
1880         g_free(type);
1881         g_free(role);
1882 }
1883
1884 void __bt_gatt_server_read_value_requested_cb(
1885         const char *remote_address, int request_id,
1886         bt_gatt_server_h server, bt_gatt_h gatt_handle,
1887         int offset, void *user_data)
1888 {
1889         char *value = "A very long test value, can be long than MTU";
1890         int resp_status = BT_ATT_ERROR_NONE;
1891         char *new_value = NULL;
1892
1893         new_value = g_malloc0(strlen(value) + 1);
1894         strncpy(new_value, &value[offset], strlen(value) - offset);
1895         new_value[strlen(value) - offset] = '\0';
1896         TC_PRT("new_value: %s(len: %zd)\n", new_value, strlen(new_value));
1897
1898         __print_gatt_handler(gatt_handle);
1899         TC_PRT("[%s] req_id %d, offset %d", remote_address, request_id, offset);
1900         printf("\n");
1901
1902         /* Get the attribute new values here */
1903         bt_gatt_server_send_response(request_id,
1904                 BLUETOOTH_GATT_ATT_REQUEST_TYPE_READ, offset,
1905                 resp_status, new_value, strlen(new_value));
1906         g_free(new_value);
1907 }
1908
1909 void __bt_gatt_server_notification_state_change_cb(bool notify,
1910                 bt_gatt_server_h server, bt_gatt_h gatt_handle,
1911                 void *user_data)
1912 {
1913         __print_gatt_handler(gatt_handle);
1914         TC_PRT("Notification %s [%d]", notify ? "enabled" : "disabled", notify);
1915         TC_PRT("server %s", (char *)server);
1916         printf("\n\n");
1917 }
1918
1919 static void __bt_adapter_le_advertising_state_changed_cb(int result,
1920         bt_advertiser_h advertiser, bt_adapter_le_advertising_state_e adv_state,
1921         void *user_data)
1922 {
1923         TC_PRT("Result : %d", result);
1924         TC_PRT("Advertiser : %p", advertiser);
1925         TC_PRT("Advertising %s [%d]",
1926                 adv_state == BT_ADAPTER_LE_ADVERTISING_STARTED ?
1927                 "started" : "stopped", adv_state);
1928 }
1929
1930 static void __bt_adapter_le_advertising_state_changed_cb_2(int result,
1931         bt_advertiser_h advertiser, bt_adapter_le_advertising_state_e adv_state,
1932         void *user_data)
1933 {
1934         TC_PRT("Result : %d", result);
1935         TC_PRT("Advertiser : %p", advertiser);
1936         TC_PRT("Advertising %s [%d]",
1937                 adv_state == BT_ADAPTER_LE_ADVERTISING_STARTED ?
1938                 "started" : "stopped", adv_state);
1939 }
1940
1941 static void __bt_adapter_le_advertising_state_changed_cb_3(int result,
1942         bt_advertiser_h advertiser, bt_adapter_le_advertising_state_e adv_state,
1943         void *user_data)
1944 {
1945         TC_PRT("Result : %d", result);
1946         TC_PRT("Advertiser : %p", advertiser);
1947         TC_PRT("Advertising %s [%d]",
1948                 adv_state == BT_ADAPTER_LE_ADVERTISING_STARTED ?
1949                 "started" : "stopped", adv_state);
1950 }
1951
1952 static void __bt_socket_data_received_cb(bt_socket_received_data_s *data,
1953         void *user_data)
1954 {
1955         TC_PRT("+");
1956
1957         if (data == NULL) {
1958                 TC_PRT("No received data!");
1959                 return;
1960         }
1961
1962         TC_PRT("Socket fd: %d", data->socket_fd);
1963         TC_PRT("Data: %s", data->data);
1964         TC_PRT("Size: %d", data->data_size);
1965 }
1966
1967 static void __bt_hid_device_data_received_cb(const bt_hid_device_received_data_s *data,
1968         void *user_data)
1969 {
1970         TC_PRT("+");
1971         char val = 0x01;
1972         int ret = 0;
1973         static char hidmode = 0x01;
1974         if (data == NULL) {
1975                 TC_PRT("No received data");
1976                 return;
1977         }
1978         TC_PRT("Address: %s", data->address);
1979         TC_PRT("Type: %d", data->header_type);
1980         TC_PRT("Param_type: %d", data->param_type);
1981
1982         switch (data->header_type) {
1983         case BT_HID_HEADER_HANDSHAKE:
1984                 TC_PRT("HANDSHAKE data");
1985                 break;
1986         case BT_HID_HEADER_HID_CONTROL:
1987                 TC_PRT("HID Control data");
1988                 ret = bt_hid_device_disconnect(remote_addr);
1989                 TC_PRT("ret %d", ret);
1990                 break;
1991         case BT_HID_HEADER_GET_REPORT:
1992                 TC_PRT("GET_REPORT data");
1993                 TC_PRT("ReportId %d", data->data[1]);
1994
1995                 if (data->data[1] == 0x02) {
1996                         bt_hid_key_data_s send_data;
1997                         /* Will send character 'a' */
1998                         char pressedkey[8] = { 4, 0, 0, 0,  0, 0, 0, 0 };
1999                         memcpy(send_data.key, pressedkey, 8);
2000                         send_data.modifier = 0;
2001                         ret = bt_hid_device_reply_to_report(remote_addr,
2002                                         BT_HID_HEADER_GET_REPORT,
2003                                         BT_HID_PARAM_DATA_RTYPE_INPUT,
2004                                         (const char *)&send_data,
2005                                         sizeof(send_data));
2006                 } else if (data->data[1] == 0x01) {
2007                         TC_PRT("Send Mouse Event");
2008                         bt_hid_mouse_data_s send_data;
2009
2010                         send_data.buttons = 1;
2011                         send_data.padding  = BT_HID_MOUSE_BUTTON_NONE;
2012
2013                         send_data.axis_x = 10;
2014                         send_data.axis_y = 0;
2015                         ret = bt_hid_device_reply_to_report(remote_addr,
2016                                         BT_HID_HEADER_GET_REPORT,
2017                                         BT_HID_PARAM_DATA_RTYPE_INPUT,
2018                                         (const char *)&send_data,
2019                                         sizeof(send_data));
2020                 } else {
2021                         TC_PRT("Invalid ReportId");
2022                         val = BT_HID_HANDSHAKE_ERR_INVALID_REPORT_ID;
2023                         ret = bt_hid_device_reply_to_report(remote_addr,
2024                                         BT_HID_HEADER_HANDSHAKE,
2025                                         BT_HID_PARAM_DATA_RTYPE_INPUT,
2026                                         &val, sizeof(val));
2027                 }
2028                 TC_PRT("ret %d", ret);
2029                 break;
2030         case BT_HID_HEADER_SET_REPORT:
2031                 TC_PRT("SET_REPORT data");
2032                 val = BT_HID_HANDSHAKE_SUCCESSFUL;
2033                 ret = bt_hid_device_reply_to_report(remote_addr,
2034                                 BT_HID_HEADER_HANDSHAKE,
2035                                 BT_HID_PARAM_DATA_RTYPE_INPUT,
2036                                 &val, sizeof(val));
2037                 TC_PRT("ret %d", ret);
2038                 break;
2039         case BT_HID_HEADER_DATA:
2040                 TC_PRT("TRANs DATA");
2041                 break;
2042         case BT_HID_HEADER_GET_PROTOCOL:
2043                 TC_PRT("GET PROTOCOL %x", hidmode);
2044                 ret = bt_hid_device_reply_to_report(remote_addr,
2045                                 BT_HID_HEADER_GET_PROTOCOL,
2046                                 BT_HID_PARAM_DATA_RTYPE_INPUT,
2047                                 &hidmode, sizeof(hidmode));
2048                 TC_PRT("ret %d", ret);
2049                 break;
2050         case BT_HID_HEADER_SET_PROTOCOL:
2051                 TC_PRT("SET PROTOCOL");
2052                 val = BT_HID_HANDSHAKE_SUCCESSFUL;
2053
2054                 if (data->data[0] & 0x01) {
2055                         TC_PRT("HID Report mode set");
2056                         hidmode = 0x01;
2057                 } else {
2058                         TC_PRT("HID Boot mode set");
2059                         hidmode = 0x00;
2060                 }
2061                 ret = bt_hid_device_reply_to_report(remote_addr,
2062                                 BT_HID_HEADER_HANDSHAKE,
2063                                 BT_HID_PARAM_DATA_RTYPE_INPUT,
2064                                 &val, sizeof(val));
2065                 TC_PRT("ret %d", ret);
2066                 break;
2067         default:
2068                 TC_PRT("Unkonw");
2069                 break;
2070         }
2071
2072         switch (data->param_type) {
2073         case BT_HID_PARAM_DATA_RTYPE_INPUT:
2074                 TC_PRT("Input Report");
2075                 break;
2076         case BT_HID_PARAM_DATA_RTYPE_OUTPUT:
2077                 TC_PRT("Output Report");
2078                 break;
2079         }
2080 }
2081
2082 static void __bt_socket_connection_requested_cb(int socket_fd,
2083                 const char *remote_address, void *user_data)
2084 {
2085         TC_PRT("Socket fd: %d", socket_fd);
2086         TC_PRT("remote_address: %s", remote_address);
2087 }
2088
2089 static void __bt_socket_connection_state_changed_cb(int result,
2090                 bt_socket_connection_state_e connection_state,
2091                 bt_socket_connection_s *connection,
2092                 void *user_data)
2093 {
2094         TC_PRT("result: %s", __bt_get_error_message(result));
2095         TC_PRT("connection_state: %d", connection_state);
2096
2097         if (connection == NULL) {
2098                 TC_PRT("No connection data!");
2099                 return;
2100         }
2101
2102         TC_PRT("socket fd: %d", connection->socket_fd);
2103         TC_PRT("server socket fd: %d", connection->server_fd);
2104         TC_PRT("role: %d", connection->local_role);
2105         TC_PRT("remote address: %s", connection->remote_address);
2106         if (strcmp(spp_uuid, connection->service_uuid) == 0) {
2107                 TC_PRT("service_uuid: %s", spp_uuid);
2108                 client_fd = connection->socket_fd;
2109         } else {
2110                 TC_PRT("service_uuid: %s", connection->service_uuid);
2111                 custom_client_fd = connection->socket_fd;
2112         }
2113 }
2114
2115 static void __bt_adapter_le_state_changed_cb(int result,
2116                 bt_adapter_le_state_e adapter_le_state, void *user_data)
2117 {
2118         TC_PRT("__bt_adapter_le_state_changed_cb");
2119         TC_PRT("result: %s", __bt_get_error_message(result));
2120         TC_PRT("state: %s",
2121                         (adapter_le_state == BT_ADAPTER_LE_ENABLED) ?
2122                         "ENABLED" : "DISABLED");
2123 }
2124
2125 static void __bt_le_set_data_length_changed_cb(int result,
2126                 const char *remote_address, int max_tx_octets,
2127                 int max_tx_time, int max_rx_octets,
2128                 int max_rx_time, void *user_data)
2129 {
2130         TC_PRT("__bt_le_set_data_length_changed_cb \n");
2131         TC_PRT("max_tx_octets: %d  max_tx_time: %d"
2132                         "max_rx_octets: %d  max_rx_time: %d",
2133                         max_tx_octets, max_tx_time,
2134                         max_rx_octets, max_rx_time);
2135         TC_PRT("result: %s", __bt_get_error_message(result));
2136 }
2137
2138 void __bt_opp_client_push_responded_cb(int result,
2139                 const char *remote_address, void *user_data)
2140 {
2141         TC_PRT("result: %s", __bt_get_error_message(result));
2142         TC_PRT("remote_address: %s", remote_address);
2143 }
2144
2145 void __bt_opp_client_push_progress_cb(const char *file,
2146                 long long size, int percent, void *user_data)
2147 {
2148         TC_PRT("size: %ld", (long)size);
2149         TC_PRT("percent: %d", percent);
2150         TC_PRT("file: %s", file);
2151 }
2152
2153 void __bt_opp_client_push_finished_cb(int result,
2154                 const char *remote_address, void *user_data)
2155 {
2156         TC_PRT("result: %s", __bt_get_error_message(result));
2157         TC_PRT("remote_address: %s", remote_address);
2158 }
2159
2160 void __bt_audio_connection_state_changed_cb(int result,
2161                 bool connected, const char *remote_address,
2162                 bt_audio_profile_type_e type, void *user_data)
2163 {
2164         TC_PRT("result [%s]", __bt_get_error_message(result));
2165         TC_PRT("connected [%d]", connected);
2166         TC_PRT("address [%s]", remote_address);
2167         TC_PRT("type [%d]", type);
2168 }
2169
2170 void __bt_audio_absolute_volume_changed_cb(unsigned int volume, void *user_data)
2171 {
2172         TC_PRT("volume [%d]", volume);
2173 }
2174
2175 void __bt_audio_avc_status_changed_cb(bool activated, void *user_data)
2176 {
2177         TC_PRT("activated [%d]", activated);
2178 }
2179
2180 void __bt_ag_sco_state_changed_cb(int result,
2181                 bool opened, void *user_data)
2182 {
2183         TC_PRT("result [%s]", __bt_get_error_message(result));
2184         TC_PRT("opened [%s]", opened ? "YES" : "NO");
2185 }
2186
2187 void __bt_ag_speaker_gain_changed_cb(int gain, void *user_data)
2188 {
2189         TC_PRT("gain [%d]", gain);
2190 }
2191
2192 void __bt_ag_microphone_gain_changed_cb(int gain, void *user_data)
2193 {
2194         TC_PRT("gain [%d]", gain);
2195 }
2196
2197 void __bt_ag_set_call_handling_event_cb(bt_ag_call_handling_event_e event,
2198                 unsigned int call_id, void *user_data)
2199 {
2200         TC_PRT("event[%d] call_id[%d]", event, call_id);
2201 }
2202
2203 void __bt_device_authorization_changed_cb(bt_device_authorization_e authorization,
2204                 char *remote_address, void *user_data)
2205 {
2206         TC_PRT("__bt_device_authorization_changed_cb [%d]", authorization);
2207         TC_PRT("address: %s", remote_address);
2208 }
2209
2210 void __bt_device_profile_trusted_cb(int result, char *remote_address,
2211                 int trusted_profile, bool supported,
2212                 bool trusted, void *user_data)
2213 {
2214         TC_PRT("result [%s]", __bt_get_error_message(result));
2215         TC_PRT("trusted profile [%d]", trusted_profile);
2216         TC_PRT("Is supported [%d]", supported);
2217         TC_PRT("Is trusted [%d]", trusted);
2218         TC_PRT("address: %s", remote_address);
2219 }
2220
2221 void __bt_device_connection_state_changed_cb(bool connected,
2222                 bt_device_connection_info_s *conn_info, void *user_data)
2223 {
2224         TC_PRT("__bt_device_connection_state_changed_cb [%d]", connected);
2225         TC_PRT("address [%s]", conn_info->remote_address);
2226         TC_PRT("link type [%d]", conn_info->link);
2227         if (!connected) {
2228                 int rssi;
2229                 TC_PRT("disconnection reason [%d]", conn_info->disconn_reason);
2230                 if (bt_device_get_link_loss_rssi(&rssi) == BT_ERROR_NONE)
2231                         TC_PRT("RSSI = %d", rssi);
2232         }
2233 }
2234
2235 void __bt_device_att_mtu_changed_cb(int result, bt_device_att_mtu_info_s *mtu_info, void *user_data)
2236 {
2237         TC_PRT("__bt_device_att_mtu_changed_cb");
2238
2239         if (result != BT_ERROR_NONE) {
2240                 TC_PRT("Callback: Request ATT MTU failed.");
2241                 TC_PRT("result: %s", __bt_get_error_message(result));
2242         }
2243
2244         if (mtu_info) {
2245                 TC_PRT("status [%d]", mtu_info->status);
2246                 TC_PRT("address [%s]", mtu_info->remote_address);
2247                 TC_PRT("MTU [%d]", mtu_info->mtu);
2248         }
2249 }
2250
2251 bool __bt_device_connected_profile(bt_profile_e profile, void *user_data)
2252 {
2253         TC_PRT("__bt_device_connected_profile [0x%04x]", profile);
2254         return true;
2255 }
2256
2257 void __bt_device_bond_created_cb(int result,
2258                 bt_device_info_s *device_info, void *user_data)
2259 {
2260         if (result == BT_ERROR_NONE) {
2261                 TC_PRT("Callback: A bond is created.");
2262                 TC_PRT("Callback: The number of service - %d.",
2263                         device_info->service_count);
2264                 TC_PRT("Callback: class : %d %d %d", (int)device_info->bt_class.major_device_class, device_info->bt_class.minor_device_class, device_info->bt_class.major_service_class_mask);
2265
2266                 int i = 0;
2267                 for (i = 0; i < device_info->service_count; i++) {
2268                         TC_PRT("Callback: service[%d] - %s",
2269                                 i+1, device_info->service_uuid[i]);
2270                 }
2271                 TC_PRT("Callback: is_bonded - %d.",
2272                         device_info->is_bonded);
2273                 TC_PRT("Callback: is_connected - %d.",
2274                         device_info->is_connected);
2275
2276                 if (device_info->manufacturer_data_len > 0) {
2277                         TC_PRT("manufacturer specific data(len:%d)",
2278                                 device_info->manufacturer_data_len);
2279                         printf("data [");
2280                         for (i = 0; i < device_info->manufacturer_data_len; i++)
2281                                 printf("%02x ", device_info->manufacturer_data[i]);
2282                         printf("]\n");
2283                 }
2284         } else {
2285                 TC_PRT("Callback: Creating a bond is failed.");
2286                 TC_PRT("result: %s", __bt_get_error_message(result));
2287         }
2288 }
2289
2290 void __bt_device_bond_destroyed_cb(int result,
2291         char *remote_address, void *user_data)
2292 {
2293         if (result == BT_ERROR_NONE) {
2294                 TC_PRT("Callback: A bond is destroyed.");
2295                 TC_PRT("Callback: Address - %s.", remote_address);
2296         } else {
2297                 TC_PRT("Callback: Destroying a bond is failed.");
2298                 TC_PRT("result: %s", __bt_get_error_message(result));
2299         }
2300 }
2301
2302 void __bt_print_repeat_test_summary(void)
2303 {
2304         static struct timeval current_time = {0,};
2305         static struct timeval diff_time = {0,};
2306         int time_diff;
2307
2308         gettimeofday(&current_time, NULL);
2309
2310         diff_time.tv_sec = current_time.tv_sec - check_time.tv_sec;
2311         diff_time.tv_usec = current_time.tv_usec - check_time.tv_usec;
2312         if (diff_time.tv_usec < 0) {
2313                 diff_time.tv_sec = diff_time.tv_sec - 1;
2314                 diff_time.tv_usec = diff_time.tv_usec + 1000000;
2315         }
2316         time_diff = (diff_time.tv_sec * 1000);
2317         time_diff += diff_time.tv_usec / 1000;
2318
2319         TC_PRT("try: %d, success: %d, fail: %d, time(%d msec)\n",
2320                 bt_onoff_cnt/2, bt_onoff_cnt_success/2, bt_onoff_cnt_fail,
2321                 time_diff);
2322
2323         total_time += time_diff;
2324 }
2325
2326 void __bt_print_repeat_test_final_summary()
2327 {
2328         TC_PRT("try: %d, success: %d, fail: %d,"
2329                 "Total_time(%d msec), Average_time(%d msec)\n",
2330                 bt_onoff_cnt/2, bt_onoff_cnt_success/2, bt_onoff_cnt_fail,
2331                 total_time, total_time / bt_onoff_cnt);
2332 }
2333
2334 void __bt_gatt_connection_state_changed_cb(int result,
2335         bool connected, const char *remote_address, void *user_data)
2336 {
2337         if (result != BT_ERROR_NONE)
2338                 TC_PRT("result: %s", __bt_get_error_message(result));
2339
2340         if (connected) {
2341                 TC_PRT("GATT connected [%s]", remote_address);
2342                 strncpy(remote_addr, remote_address, strlen(remote_addr));
2343
2344                 bt_le_conn_update_s param;
2345
2346                 param.interval_min = 90;
2347                 param.interval_max = 90;
2348                 param.latency = 0;
2349                 param.time_out = 2000;
2350                 bt_device_le_conn_update(remote_addr, &param);
2351         } else {
2352                 TC_PRT("GATT DISconnected [%s]", remote_address);
2353         }
2354 }
2355
2356 void __bt_hps_connection_state_changed_cb(int result,
2357         bool connected, const char *remote_address, void *user_data)
2358 {
2359         int ret;
2360         if (result != BT_ERROR_NONE)
2361                 TC_PRT("result: %s", __bt_get_error_message(result));
2362
2363         if (connected) {
2364                 TC_PRT("HPS connected  [%s]", remote_address);
2365                 /* Fix : STRING_OVERFLOW */
2366                 strncpy(remote_addr, remote_address, strlen(remote_addr));
2367                 if (hps_client) {
2368                            bt_gatt_client_destroy(hps_client);
2369                            hps_client = NULL;
2370                 }
2371                 ret = bt_gatt_client_create(remote_addr, &hps_client);
2372                 TC_PRT("returns bt_gatt_client_create %s\n",
2373                         __bt_get_error_message(ret));
2374
2375         } else {
2376                 TC_PRT("HPS DISconnected [%s]", remote_address);
2377         }
2378 }
2379
2380 void __bt_gatt_client_service_changed_cb(bt_gatt_client_h c,
2381                 bt_gatt_client_service_change_type_e type,
2382                 const char *uuid, void *user_data)
2383 {
2384         char *addr = NULL;
2385         char *svc = NULL;
2386         int ret;
2387
2388         ret = bt_gatt_client_get_remote_address(client, &addr);
2389         if (ret != BT_ERROR_NONE)
2390                 TC_PRT("Cannot get remote address");
2391
2392         ret = bt_get_uuid_name(uuid, &svc);
2393         if (ret != BT_ERROR_NONE)
2394                 svc = g_strdup(uuid);
2395
2396         TC_PRT("Remote device [%s] : %s is %s", addr, svc,
2397                         type == BT_GATT_CLIENT_SERVICE_ADDED ?
2398                         "Added" : "Removed");
2399         g_free(svc);
2400         g_free(addr);
2401 }
2402
2403 void __bt_gatt_client_att_mtu_changed_cb(bt_gatt_client_h c, const bt_gatt_client_att_mtu_info_s *mtu_info, void *user_data)
2404 {
2405         char *addr = NULL;
2406         int ret;
2407
2408         TC_PRT("__bt_gatt_client_att_mtu_changed_cb");
2409
2410         ret = bt_gatt_client_get_remote_address(client, &addr);
2411         if (ret != BT_ERROR_NONE) {
2412                 TC_PRT("Cannot get remote address");
2413                 return;
2414         }
2415
2416         if (mtu_info) {
2417                 TC_PRT("status [%d]", mtu_info->status);
2418                 TC_PRT("address [%s]", mtu_info->remote_address);
2419                 TC_PRT("MTU [%d]", mtu_info->mtu);
2420         }
2421
2422         g_free(addr);
2423 }
2424
2425 int __bt_gatt_client_set_value(char *type, char *value, bt_gatt_h h)
2426 {
2427         int ret;
2428         int s_val;
2429         unsigned int u_val;
2430         char *buf;
2431         int len;
2432
2433         if (strcasecmp(type, "int8") == 0) {
2434                 s_val = atoi(value);
2435                 buf = (char *)&s_val;
2436                 len = 1;
2437         } else if (strcasecmp(type, "int16") == 0) {
2438                 s_val = atoi(value);
2439                 buf = (char *)&s_val;
2440                 len = 2;
2441         } else if (strcasecmp(type, "int32") == 0) {
2442                 s_val = atoi(value);
2443                 buf = (char *)&s_val;
2444                 len = 4;
2445         } else if (strcasecmp(type, "uint8") == 0) {
2446                 u_val = strtoul(value, NULL, 10);
2447                 buf = (char *)&u_val;
2448                 len = 1;
2449         } else if (strcasecmp(type, "uint16") == 0) {
2450                 u_val = strtoul(value, NULL, 10);
2451                 buf = (char *)&u_val;
2452                 len = 2;
2453         } else if (strcasecmp(type, "uint32") == 0) {
2454                 u_val = strtoul(value, NULL, 10);
2455                 buf = (char *)&u_val;
2456                 len = 4;
2457         } else if (strcasecmp(type, "str") == 0) {
2458                 buf = value;
2459                 len = strlen(buf);
2460         } else
2461                 return BT_ERROR_INVALID_PARAMETER;
2462
2463         ret = bt_gatt_set_value(h, buf, len);
2464         if (ret != BT_ERROR_NONE)
2465                 TC_PRT("bt_gatt_set_value is failed : %d", ret);
2466
2467         return ret;
2468 }
2469
2470 void __bt_gatt_client_print_value(bt_gatt_h h)
2471 {
2472         int ret;
2473         char *str = NULL;
2474         char *value = NULL;
2475         int len = 0;
2476         bool hex_format = false;
2477         int i;
2478
2479         ret = bt_gatt_get_value(h, &value, &len);
2480         if (ret != BT_ERROR_NONE) {
2481                 TC_PRT("bt_gatt_get_value is failed : %d", ret);
2482                 return;
2483         }
2484
2485         for (i = 0; i < len; i++)
2486                 if (isalnum(value[i]) == 0) {
2487                         hex_format = true;
2488                         break;
2489                 }
2490
2491         if (hex_format) {
2492                 str = g_malloc0(len * 5 + 1);
2493                 for (i = 0; i < len; i++) {
2494                         if (i > 0)
2495                                 str[i * 5 - 1] = ' ';
2496
2497                         snprintf(&str[i * 5], 5, "0x%02X", value[i]);
2498                 }
2499         } else {
2500                 str = g_malloc0(len + 1);
2501                 memcpy(str, value, len);
2502         }
2503
2504         TC_PRT("Value : %s", str);
2505
2506         g_free(str);
2507         g_free(value);
2508 }
2509
2510 bool __bt_gatt_print_info_cb(int total,
2511         int index, bt_gatt_h gatt_handle, void *user_data)
2512 {
2513         char *uuid = NULL;
2514         char *str = NULL;
2515
2516         bt_gatt_get_uuid(gatt_handle, &uuid);
2517         bt_get_uuid_name(uuid, &str);
2518
2519         TC_PRT("[%d / %d] %s (%s)",
2520                 index, total,
2521                 str ? str : "Unknown", uuid);
2522
2523         g_free(str);
2524         g_free(uuid);
2525
2526         return true;
2527 }
2528
2529 void __bt_gatt_client_write_complete_cb(int result,
2530         bt_gatt_h gatt_handle, void *data)
2531 {
2532         char *uuid = NULL;
2533         char *str = NULL;
2534
2535         bt_gatt_get_uuid(gatt_handle, &uuid);
2536         bt_get_uuid_name(uuid, &str);
2537
2538         TC_PRT("Write %s for %s (%s)",
2539                 result == BT_ATT_ERROR_NONE ? "Success" : "Fail",
2540                 str ? str : "Unknown", uuid);
2541
2542         g_free(str);
2543         g_free(uuid);
2544
2545         return;
2546 }
2547
2548 void __bt_gatt_client_read_complete_cb(int result,
2549         bt_gatt_h gatt_handle, void *data)
2550 {
2551         char *uuid = NULL;
2552         char *str = NULL;
2553
2554         bt_gatt_get_uuid(gatt_handle, &uuid);
2555         bt_get_uuid_name(uuid, &str);
2556
2557         TC_PRT("Read %s for %s (%s)",
2558                 result == BT_ATT_ERROR_NONE ? "Success" : "Fail",
2559                 str ? str : "Unknown", uuid);
2560
2561         g_free(str);
2562         g_free(uuid);
2563
2564         if (result != BT_ATT_ERROR_NONE)
2565                 return;
2566
2567         __bt_gatt_client_print_value(gatt_handle);
2568
2569         return;
2570 }
2571
2572 bool __bt_gatt_client_foreach_desc_cb(int total,
2573         int index, bt_gatt_h desc_handle, void *data)
2574 {
2575         char *uuid = NULL;
2576         char *str = NULL;
2577
2578         bt_gatt_get_uuid(desc_handle, &uuid);
2579         bt_get_uuid_name(uuid, &str);
2580
2581         TC_PRT("\t\t[%d / %d] %s (%s)",
2582                 index, total,
2583                 str ? str : "Unknown", uuid);
2584         __bt_gatt_client_print_value(desc_handle);
2585
2586         g_free(str);
2587         g_free(uuid);
2588
2589         return true;
2590 }
2591
2592 bool __bt_gatt_client_foreach_chr_cb(int total,
2593         int index, bt_gatt_h chr_handle, void *data)
2594 {
2595         int ret;
2596         char *uuid = NULL;
2597         char *str = NULL;
2598         int properties = 0;
2599
2600         bt_gatt_get_uuid(chr_handle, &uuid);
2601         bt_get_uuid_name(uuid, &str);
2602         bt_gatt_characteristic_get_properties(chr_handle, &properties);
2603
2604         TC_PRT("\t[%d / %d] %s (%s) (0x%X)", index, total, str ? str : "Unknown", uuid, properties);
2605         __bt_gatt_client_print_value(chr_handle);
2606
2607         g_free(str);
2608         g_free(uuid);
2609
2610         ret = bt_gatt_characteristic_foreach_descriptors(chr_handle,
2611                         __bt_gatt_client_foreach_desc_cb, NULL);
2612         if (ret != BT_ERROR_NONE)
2613                 TC_PRT("bt_gatt_characteristic_foreach_descriptors is failed : %d", ret);
2614
2615         return true;
2616 }
2617
2618 bool __bt_gatt_client_foreach_svc_cb(int total,
2619         int index, bt_gatt_h svc_handle, void *data)
2620 {
2621 #ifdef ARCH64
2622         int test_id = (int)(uintptr_t) data;
2623 #else
2624         int test_id = (int)data;
2625 #endif
2626         int ret;
2627         char *uuid = NULL;
2628         char *str = NULL;
2629
2630         bt_gatt_get_uuid(svc_handle, &uuid);
2631         bt_get_uuid_name(uuid, &str);
2632
2633         TC_PRT("[%d / %d] %s (%s)",
2634                 index, total,
2635                 str ? str : "Unknown", uuid);
2636
2637         g_free(str);
2638         g_free(uuid);
2639
2640         if (test_id == BT_UNIT_TEST_FUNCTION_GATT_CLIENT_PRINT_ALL) {
2641 #ifdef ARCH64
2642                 ret = bt_gatt_service_foreach_characteristics(svc_handle,
2643                                 __bt_gatt_client_foreach_chr_cb, (void *)(uintptr_t)test_id);
2644 #else
2645                 ret = bt_gatt_service_foreach_characteristics(svc_handle,
2646                                 __bt_gatt_client_foreach_chr_cb, (void *)test_id);
2647 #endif
2648                 if (ret != BT_ERROR_NONE)
2649                         TC_PRT("bt_gatt_service_foreach_characteristics is failed : %d", ret);
2650         }
2651
2652         return true;
2653 }
2654
2655 bool __bt_hps_client_svc_cb(int total,
2656         int index, bt_gatt_h svc_handle, void *data)
2657 {
2658 #ifdef ARCH64
2659         int test_id = (int) (uintptr_t) data;
2660 #else
2661         int test_id = (int)data;
2662 #endif
2663         int ret;
2664         char *uuid = NULL;
2665         char *str = NULL;
2666
2667         bt_gatt_get_uuid(svc_handle, &uuid);
2668         bt_get_uuid_name(uuid, &str);
2669
2670         if (!g_strcmp0(uuid, HPS_UUID)) {
2671
2672                 TC_PRT("[%d / %d] %s (%s)",
2673                         index, total,
2674                         str ? str : "Unknown", uuid);
2675
2676                 if (test_id == BT_UNIT_TEST_FUNCTION_HPS_CLIENT_PRINT_ALL) {
2677 #ifdef ARCH64
2678                         ret = bt_gatt_service_foreach_characteristics(svc_handle,
2679                                         __bt_gatt_client_foreach_chr_cb,
2680                                         (void *)(uintptr_t)test_id);
2681 #else
2682                         ret = bt_gatt_service_foreach_characteristics(svc_handle,
2683                                         __bt_gatt_client_foreach_chr_cb,
2684                                         (void *)test_id);
2685 #endif
2686                         if (ret != BT_ERROR_NONE)
2687                                 TC_PRT("bt_gatt_service_foreach_characteristics is failed : %d", ret);
2688                 }
2689         }
2690
2691         g_free(str);
2692         g_free(uuid);
2693         return true;
2694 }
2695
2696 static void __ancs_write_completed_cb(int result,
2697         bt_gatt_h request_handle, void *user_data)
2698 {
2699         if (result != BT_ERROR_NONE) {
2700                 TC_PRT("write request is failed : %d", result);
2701                 return;
2702         }
2703
2704         TC_PRT("write request is done");
2705
2706         return;
2707 }
2708
2709 static int __ancs_write_value_to_control_point(bt_gatt_client_h client,
2710         char *value, int len)
2711 {
2712         bt_gatt_h ancs_svc = NULL;
2713         bt_gatt_h control_point = NULL;
2714         char *svc_uuid = "7905F431-B5CE-4E99-A40F-4B1E122D00D0";
2715         char *chr_uuid = "69D1D8F3-45E1-49A8-9821-9BBDFDAAD9D9";
2716         int ret;
2717
2718         ret = bt_gatt_client_get_service(client,
2719                         svc_uuid, &ancs_svc);
2720         if (ret != BT_ERROR_NONE) {
2721                 TC_PRT("bt_gatt_client_get_service is failed : %d", ret);
2722                 return ret;
2723         }
2724
2725         ret = bt_gatt_service_get_characteristic(ancs_svc,
2726                         chr_uuid, &control_point);
2727         if (ret != BT_ERROR_NONE) {
2728                 TC_PRT("bt_gatt_service_get_characteristic is failed");
2729                 return ret;
2730         }
2731
2732         ret = bt_gatt_characteristic_set_write_type(control_point,
2733                         BT_GATT_WRITE_TYPE_WRITE);
2734         if (ret != BT_ERROR_NONE) {
2735                 TC_PRT("bt_gatt_characteristic_set_write_type is failed : %d", ret);
2736                 return ret;
2737         }
2738
2739         ret = bt_gatt_set_value(control_point, value, len);
2740         if (ret != BT_ERROR_NONE) {
2741                 TC_PRT("bt_gatt_set_value is failed : %d", ret);
2742                 return ret;
2743         }
2744
2745         ret = bt_gatt_client_write_value(control_point,
2746                         __ancs_write_completed_cb, NULL);
2747         if (ret != BT_ERROR_NONE) {
2748                 TC_PRT("bt_gatt_client_write_value is failed : %d", ret);
2749                 return ret;
2750         }
2751
2752         return ret;
2753 }
2754
2755 void __bt_gatt_client_value_changed_cb(bt_gatt_h chr,
2756         char *value, int len, void *user_data)
2757 {
2758         char *uuid = NULL;
2759         int i;
2760
2761         bt_gatt_get_uuid(chr, &uuid);
2762
2763         TC_PRT("Value changed for [%s]", uuid);
2764         TC_PRT("len [%d]", len);
2765         for (i = 0; i < len; i++)
2766                 TC_PRT("value %u", value[i]);
2767
2768         g_free(uuid);
2769
2770         return;
2771 }
2772 void __bt_hrp_heart_rate_value_changed_cb(bt_gatt_h chr,
2773         unsigned short hr_value, void *user_data)
2774 {
2775         char *uuid = NULL;
2776
2777         bt_gatt_get_uuid(chr, &uuid);
2778
2779         TC_PRT("Value changed for [%s]", uuid);
2780         TC_PRT("Value [%d]", hr_value);
2781
2782         g_free(uuid);
2783
2784         return;
2785 }
2786
2787 void __bt_HP_client_cp_req_status_changed_cb(bt_gatt_h chr,
2788         char *value, int len, void *user_data)
2789 {
2790         char *uuid = NULL;
2791         int i;
2792
2793         bt_gatt_get_uuid(chr, &uuid);
2794
2795         TC_PRT("Value changed for [%s]", uuid);
2796         TC_PRT("len [%d]", len);
2797                 for (i = 0; i < len; i++)
2798                                 TC_PRT("value %u", value[i]);
2799
2800         g_free(uuid);
2801
2802         return;
2803 }
2804
2805 void __bt_proximity_reporter_property_changed_cb(int result, const char *remote_address,
2806                                         int service_type, int prop_value, void *user_data)
2807 {
2808         TC_PRT("reporter_property result [%s]", __bt_get_error_message(result));
2809         TC_PRT("remote_address : %s", remote_address);
2810         TC_PRT("service_type : %d", service_type);
2811         TC_PRT("prop_value : %d", prop_value);
2812 }
2813
2814 void __bt_proximity_monitor_connection_state_changed_cb(int result, const char *remote_address,
2815                         bt_proximity_monitor_h monitor_s, bool connected, int supported_service, void *user_data)
2816 {
2817         TC_PRT("result: %s", __bt_get_error_message(result));
2818         if (result == BT_ERROR_NONE) {
2819                 if (connected) {
2820                         TC_PRT("PXP connected(address = %s)", remote_address);
2821                         TC_PRT("PXP Reporter supported Service\n");
2822                         if (supported_service & BT_PROXIMITY_LINKLOSS_ALERT)
2823                                 TC_PRT("BT_PROXIMITY_LINKLOSS_ALERT\n");
2824                         if (supported_service & BT_PROXIMITY_IMMEDIATE_ALERT)
2825                                 TC_PRT("BT_PROXIMITY_IMMEDIATE_ALERT\n");
2826                         if (supported_service & BT_PROXIMITY_TX_POWER)
2827                                 TC_PRT("BT_PROXIMITY_TX_POWER");
2828                 } else {
2829                         TC_PRT("PXP DISconnected");
2830                 }
2831         }
2832 }
2833
2834 void __bt_proximity_reporter_connection_state_changed_cb(int result, const char *remote_address,
2835                         bt_proximity_reporter_h reporter_s, bool connected, int supported_service, void *user_data)
2836 {
2837         TC_PRT("result: %s", __bt_get_error_message(result));
2838         if (result == BT_ERROR_NONE) {
2839                 if (connected) {
2840                         TC_PRT("PXP connected(address = %s)", remote_address);
2841                         TC_PRT("PXP Reporter supported Service\n");
2842                         if (supported_service & BT_PROXIMITY_LINKLOSS_ALERT)
2843                                 TC_PRT("BT_PROXIMITY_LINKLOSS_ALERT\n");
2844                         if (supported_service & BT_PROXIMITY_IMMEDIATE_ALERT)
2845                                 TC_PRT("BT_PROXIMITY_IMMEDIATE_ALERT\n");
2846                         if (supported_service & BT_PROXIMITY_TX_POWER)
2847                                 TC_PRT("BT_PROXIMITY_TX_POWER");
2848                 } else {
2849                         TC_PRT("PXP DISconnected");
2850                 }
2851         }
2852 }
2853
2854 void __tds_activation_req_cb(char *rem_bd_addr,
2855         bt_tds_transport_e transport, unsigned char *buf, int len, void *user_data)
2856 {
2857         int i;
2858
2859         TC_PRT("remote_address : %s", rem_bd_addr);
2860         TC_PRT("transport : %d", transport);
2861         for (i = 0; i < len; i++)
2862                 TC_PRT("Act req data[%d] : %.2x", i, buf[i]);
2863
2864         g_free(tds_act_address);
2865         tds_act_address = g_strdup(rem_bd_addr);
2866 }
2867
2868 void __bt_gatt_server_att_mtu_changed_cb(bt_gatt_server_h s, const bt_gatt_server_att_mtu_info_s *mtu_info, void *user_data)
2869 {
2870         TC_PRT("__bt_gatt_server_att_mtu_changed_cb");
2871
2872         if (mtu_info) {
2873                 TC_PRT("status [%d]", mtu_info->status);
2874                 TC_PRT("address [%s]", mtu_info->remote_address);
2875                 TC_PRT("MTU [%d]", mtu_info->mtu);
2876         }
2877
2878 }
2879
2880 void __bt_gatt_server_notification_sent_cb(int result,
2881         const char *remote_address, bt_gatt_server_h server,
2882         bt_gatt_h characteristic, bool completed, void *user_data)
2883 {
2884         TC_PRT("result [%s]", __bt_get_error_message(result));
2885         TC_PRT("remote_address : %s", remote_address);
2886         TC_PRT("completed : %d", completed);
2887         TC_PRT("characteristic : %p", characteristic);
2888 }
2889
2890 void __bt_gatt_server_write_value_requested_cb(const char *remote_address,
2891                                 int request_id, bt_gatt_server_h server,
2892                                 bt_gatt_h gatt_handle, bool response_needed, int offset,
2893                                 const char *value, int len, void *user_data)
2894 {
2895         int i, resp_status = BT_ATT_ERROR_NONE;
2896
2897         __print_gatt_handler(gatt_handle);
2898         TC_PRT("[%s] req_id %d, response_needed %d, offset %d, len %d",
2899                 remote_address, request_id, response_needed, offset, len);
2900
2901         for (i = 0; i < len; i++)
2902                 printf("%d ", value[i]);
2903
2904         bt_gatt_server_send_response(request_id,
2905         BLUETOOTH_GATT_ATT_REQUEST_TYPE_WRITE, offset,
2906                 resp_status, NULL, 0);
2907
2908         printf("\n");
2909 }
2910
2911 bool __bt_gatt_server_foreach_svc_cb(int total,
2912         int index, bt_gatt_h svc_handle, void *data)
2913 {
2914         char *uuid = NULL;
2915         char *str = NULL;
2916
2917         bt_gatt_get_uuid(svc_handle, &uuid);
2918         bt_get_uuid_name(uuid, &str);
2919
2920         TC_PRT("[%d / %d] %s (%s)", index, total, str ? str : "Unknown", uuid);
2921
2922         g_free(str);
2923         g_free(uuid);
2924
2925         return true;
2926 }
2927
2928 void __bt_gatt_char_write_cb(void *user_data)
2929 {
2930         TC_PRT("__bt_gatt_char_write_cb");
2931         return;
2932 }
2933
2934 void __bt_gatt_char_read_cb(unsigned char *value,
2935         int value_length, void *user_data)
2936 {
2937         int i;
2938
2939         TC_PRT("__bt_gatt_char_read_cb");
2940
2941         TC_PRT("value_length %d", value_length);
2942
2943         for (i = 0; i < value_length; i++)
2944                 TC_PRT("value %u", value[i]);
2945
2946         return;
2947 }
2948
2949 void __bt_avrcp_target_connection_state_changed_cb(bool connected,
2950         const char *remote_address, void *user_data)
2951 {
2952         TC_PRT("__bt_avrcp_target_connection_state_changed_cb");
2953         TC_PRT("connected %d", connected);
2954         TC_PRT("remote_address %s", remote_address);
2955 }
2956
2957 void __bt_avrcp_equalizer_state_changed_cb(bt_avrcp_equalizer_state_e equalizer,
2958         void *user_data)
2959 {
2960         TC_PRT("__bt_avrcp_equalizer_state_changed_cb");
2961         TC_PRT("equalizer %d (1: OFF, 2: ON)", equalizer);
2962 }
2963
2964 void __bt_avrcp_repeat_mode_changed_cb(bt_avrcp_repeat_mode_e repeat,
2965         void *user_data)
2966 {
2967         TC_PRT("__bt_avrcp_repeat_mode_changed_cb");
2968         TC_PRT("repeat %d (1: OFF, 2: SINGLE, 3: All, 4:GROUP)", repeat);
2969 }
2970
2971 void __bt_avrcp_shuffle_mode_changed_cb(bt_avrcp_shuffle_mode_e shuffle,
2972         void *user_data)
2973 {
2974         TC_PRT("__bt_avrcp_shuffle_mode_changed_cb");
2975         TC_PRT("shuffle -> %d (1: OFF, 2: All TRACK, 3:GROUP)", shuffle);
2976 }
2977
2978 void __bt_avrcp_scan_mode_changed_cb(bt_avrcp_scan_mode_e scan,
2979         void *user_data)
2980 {
2981         TC_PRT("__bt_avrcp_scan_mode_changed_cb");
2982         TC_PRT("scan -> %d", scan);
2983 }
2984
2985 void __bt_avrcp_control_connection_state_changed_cb(bool connected,
2986         const char *remote_address, void *user_data)
2987 {
2988         TC_PRT("__bt_avrcp_target_connection_state_changed_cb");
2989         TC_PRT("connected %d", connected);
2990         TC_PRT("remote_address %s", remote_address);
2991 }
2992
2993 void __bt_avrcp_song_position_changed_cb(unsigned int postion,
2994         void *user_data)
2995 {
2996         TC_PRT("__bt_avrcp_song_position_changed_cb");
2997         TC_PRT("Position %d", postion);
2998 }
2999
3000 void __bt_avrcp_player_state_changed_cb(bt_avrcp_player_state_e state,
3001         void *user_data)
3002 {
3003         TC_PRT("__bt_avrcp_player_state_changed_cb");
3004         TC_PRT("Player state -> %d (0: stopped, 1: Playing, 2:Paused, 3:FF, 4:REW)", state);
3005 }
3006
3007 void __bt_avrcp_track_info_changed_cb(bt_avrcp_metadata_attributes_info_s *metadata,
3008         void *user_data)
3009 {
3010         TC_PRT("__bt_avrcp_track_info_changed_cb");
3011         TC_PRT("title %s", metadata->title);
3012         TC_PRT("artist %s", metadata->artist);
3013         TC_PRT("album %s", metadata->album);
3014         TC_PRT("genre %s", metadata->genre);
3015         TC_PRT("total_tracks %d", metadata->total_tracks);
3016         TC_PRT("number %d", metadata->number);
3017         TC_PRT("duration %d", metadata->duration);
3018 }
3019
3020 void panu_conn_state_changed(int result, bool connected,
3021         const char *remote_address, bt_panu_service_type_e type,
3022         void *user_data)
3023 {
3024         TC_PRT("result [%s]", __bt_get_error_message(result));
3025         TC_PRT("connected [%d]", connected);
3026         TC_PRT("address [%s]", remote_address);
3027         TC_PRT("type [%d]", type);
3028
3029 }
3030
3031 void __bt_hid_host_connection_state_changed_cb(int result,
3032         bool connected, const char *remote_address,
3033         void *user_data)
3034 {
3035         TC_PRT("__bt_hid_host_connection_state_changed_cb: called");
3036         TC_PRT("result: %s", __bt_get_error_message(result));
3037 }
3038
3039 void __bt_hdp_connected_cb(int result, const char *remote_address,
3040         const char *app_id, bt_hdp_channel_type_e type,
3041         unsigned int channel, void *user_data)
3042 {
3043         TC_PRT("__bt_hdp_connected_cb: called");
3044         TC_PRT("result: %s", __bt_get_error_message(result));
3045         TC_PRT("remote_address: %s", remote_address);
3046         TC_PRT("app_id: %s", app_id);
3047         TC_PRT("type: %x", type);
3048         TC_PRT("channel: %d", channel);
3049
3050         channel_hdp = channel;
3051 }
3052
3053 void __bt_hdp_disconnected_cb(int result, const char *remote_address,
3054         unsigned int channel, void *user_data)
3055 {
3056         TC_PRT("__bt_hdp_connected_cb: called");
3057         TC_PRT("result: %s", __bt_get_error_message(result));
3058         TC_PRT("remote_address: %s", remote_address);
3059         TC_PRT("channel: %d", channel);
3060
3061         channel_hdp = channel;
3062 }
3063
3064 void __bt_hdp_data_received_cb(unsigned int channel, const char *data,
3065         unsigned int size, void *user_data)
3066 {
3067         TC_PRT("__bt_hdp_data_received_cb: called");
3068         TC_PRT("data: %s", data);
3069         TC_PRT("size: %d", size);
3070         TC_PRT("channel: %d", channel);
3071 }
3072
3073 void __bt_hid_device_connection_state_changed_cb(int result,
3074         bool connected, const char *remote_address, void *user_data)
3075 {
3076         TC_PRT("__bt_hid_device_connection_state_changed_cb:");
3077         TC_PRT("result: %s", __bt_get_error_message(result));
3078         TC_PRT("Remote Address %s", remote_address);
3079         TC_PRT("Connected %d", connected);
3080 }
3081
3082 void __bt_ipsp_init_state_changed_cb(int result,
3083         bool ipsp_initialized, void *user_data)
3084 {
3085         TC_PRT("result: %s", __bt_get_error_message(result));
3086         if (ipsp_initialized) {
3087                 TC_PRT("IPSP Init state: INITIALIZED");
3088         } else {
3089                 TC_PRT("IPSP Init state: UN-INITIALIZED");
3090                 _bt_unset_cb(BT_EVENT_IPSP_INIT_STATE_CHANGED);
3091         }
3092 }
3093
3094 void __bt_ipsp_connection_state_changed_cb(int result,
3095         bool connected, const char *remote_address, const char *iface_name, void *user_data)
3096 {
3097         TC_PRT("__bt_le_ipsp_connection_state_changed_cb: called");
3098         TC_PRT("result: %s", __bt_get_error_message(result));
3099         TC_PRT("Connected: %d", connected);
3100         TC_PRT("Remote BT address : %s", remote_address);
3101         if (connected)
3102                 TC_PRT("Local BT Interface : %s is Up", iface_name);
3103         else
3104                 TC_PRT("Local BT Interface : %s is Down", iface_name);
3105         strncpy(ipsp_iface_name, iface_name, sizeof(ipsp_iface_name));
3106         ipsp_iface_name[sizeof(ipsp_iface_name) - 1] = '\0';
3107 }
3108
3109 void __bt_hf_sco_state_changed_cb(int result,
3110         bool opened, void *user_data)
3111 {
3112         TC_PRT("opened [%s]", opened ? "YES" : "NO");
3113 }
3114
3115 void __bt_hf_set_call_handling_event_cb(bt_hf_call_handling_event_e event,
3116         char *phone_number, void *user_data)
3117 {
3118         switch (event) {
3119         case BT_HF_CALL_HANDLING_EVENT_ANSWER:
3120                 TC_PRT("[call_handling_event_cb] event [ANSWER]");
3121                 break;
3122         case BT_HF_CALL_HANDLING_EVENT_RELEASE:
3123                 TC_PRT("[call_handling_event_cb] event [RELEASE]");
3124                 break;
3125         case BT_HF_CALL_HANDLING_EVENT_REJECT:
3126                 TC_PRT("[call_handling_event_cb] event [REJECT]");
3127                 break;
3128         case BT_HF_CALL_HANDLING_EVENT_RING:
3129                 TC_PRT("[call_handling_event_cb] event [RING]");
3130                 break;
3131         case BT_HF_CALL_HANDLING_EVENT_CALL_STARTED:
3132                 TC_PRT("[call_handling_event_cb] event [CALL_STARTED]");
3133                 break;
3134         case BT_HF_CALL_HANDLING_EVENT_CALL_ENDED:
3135                 TC_PRT("[call_handling_event_cb] event [CALL_ENDED]");
3136                 break;
3137         case BT_HF_CALL_HANDLING_EVENT_VOICE_RECOGNITION_ENABLED:
3138                 TC_PRT("[call_handling_event_cb] event [VOICE_RECOGNITION_ENABLED]");
3139                 break;
3140         case BT_HF_CALL_HANDLING_EVENT_VOICE_RECOGNITION_DISABLED:
3141                 TC_PRT("[call_handling_event_cb] event [VOICE_RECOGNITION_DISABLED]");
3142                 break;
3143         case BT_HF_CALL_HANDLING_EVENT_WAITING:
3144                 TC_PRT("[call_handling_event_cb] event [WAITING]");
3145                 break;
3146         case BT_HF_CALL_HANDLING_EVENT_HELD:
3147                 TC_PRT("[call_handling_event_cb] event [HELD]");
3148                 break;
3149         case BT_HF_CALL_HANDLING_EVENT_UNHELD:
3150                 TC_PRT("[call_handling_event_cb] event [UNHELD]");
3151                 break;
3152         case BT_HF_CALL_HANDLING_EVENT_SWAPPED:
3153                 TC_PRT("[call_handling_event_cb] event [SWAPPED]");
3154                 break;
3155         default:
3156                 TC_PRT("[call_handling_event_cb] event [UNKNOWN]");
3157         }
3158
3159         TC_PRT("[call_handling_event_cb] phone_number [%s]",
3160                 phone_number);
3161 }
3162
3163 void __bt_hf_call_status_updated_event_cb(GSList *call_info_list,
3164         void *user_data)
3165 {
3166         TC_PRT("[call_status_updated_event_cb]");
3167         for (; call_info_list; call_info_list = g_slist_next(call_info_list)) {
3168                 bt_hf_call_status_info_s *call_info = call_info_list->data;
3169                 TC_PRT("    > Call info [No:%s, Dir:%d, Stat:%d, Mpt:%d, Idx:%d]",
3170                         call_info->number, call_info->direction,
3171                         call_info->status, call_info->multi_party,
3172                         call_info->index);
3173         }
3174
3175         bt_hf_free_call_status_info_list(call_info_list);
3176 }
3177
3178 void __bt_hf_speaker_gain_changed_cb(int gain,
3179         void *user_data)
3180 {
3181         TC_PRT("__bt_hf_speaker_gain_changed_cb");
3182         TC_PRT("Gain= %d", gain);
3183 }
3184
3185 void __bt_pbap_connection_state_changed_cb(int result, bool connected, const char *remote_address, void *user_data)
3186 {
3187         TC_PRT("__bt_pbap_connection_state_changed_cb");
3188         TC_PRT("Result: %d", result);
3189         TC_PRT("Remote Device: %s", remote_address);
3190         TC_PRT("Connected Status: %d", connected);
3191 }
3192
3193 void __bt_pbap_phonebook_size_cb(int result, const char *remote_address,
3194         int size, void *user_data)
3195 {
3196         TC_PRT("__bt_pbap_phonebook_size_cb");
3197         TC_PRT("Result: %d", result);
3198         TC_PRT("Remote Device: %s", remote_address);
3199         TC_PRT("Phonebook Size: %d", size);
3200 }
3201
3202 void __bt_pbap_phonebook_pull_cb(int result, const char *remote_address,
3203         const char *vcf_file, void *user_data)
3204 {
3205         TC_PRT("__bt_pbap_phonebook_pull_cb");
3206         TC_PRT("Result: %d", result);
3207         TC_PRT("Remote Device: %s", remote_address);
3208         TC_PRT("Phonebook Download File: %s", vcf_file);
3209         TC_PRT("Phonebook Download Status: %s",
3210                 (result == BT_ERROR_NONE) ? "Successful" : "Unsuccessful");
3211 }
3212
3213 void __bt_pbap_vcard_list_cb(int result, const char *remote_address,
3214         const bt_pbap_vcard_info_s *vcard_info, int count, void *user_data)
3215 {
3216         int i;
3217
3218         TC_PRT("__bt_pbap_vcard_list_cb");
3219         TC_PRT("Result: %d", result);
3220         TC_PRT("Remote Device: %s", remote_address);
3221         TC_PRT("vCard Count: %d", count);
3222
3223         for (i = 0; i < count; i++)
3224                 TC_PRT("vCard[%d]: %s", vcard_info[i].index, vcard_info[i].contact_name);
3225
3226         TC_PRT("Listing Status: %s",
3227                 (result == BT_ERROR_NONE) ? "Successful" : "Unsuccessful");
3228 }
3229
3230 void __bt_repeat_test_adapter_state_changed_cb(int result,
3231         bt_adapter_state_e adapter_state, void *user_data)
3232 {
3233         unsigned int delay = *(unsigned int *)user_data;
3234
3235         TC_PRT("__bt_repeat_test_adapter_state_changed_cb");
3236         TC_PRT("result: %s", __bt_get_error_message(result));
3237         TC_PRT("state: %s, delay(%dsec)",
3238                         (adapter_state == BT_ADAPTER_ENABLED) ?
3239                                         "ENABLED" : "DISABLED", delay);
3240
3241         __bt_print_repeat_test_summary();
3242
3243         if (result != BT_ERROR_NONE) {
3244                 char *argv[] = {NULL};
3245
3246                 TC_PRT("make dump\n");
3247                 execv("all_log_dump.sh", argv);
3248
3249                 bt_onoff_cnt_fail++;
3250         } else {
3251                 bt_onoff_cnt_success++;
3252
3253                 if (delay)
3254                         sleep(delay);
3255         }
3256
3257         gettimeofday(&check_time, NULL);
3258         if (adapter_state == BT_ADAPTER_DISABLED)
3259                 bt_adapter_enable();
3260         else
3261                 bt_adapter_disable();
3262
3263         bt_onoff_cnt++;
3264 }
3265
3266 /* TDS Seeker Callbacks */
3267 static  void __bt_tds_provider_scan_result_cb(int result, const char *remote_address,
3268                         bt_tds_transport_block_list_s *info, bt_adapter_le_device_scan_result_info_s *scan_info,
3269                         void *user_data)
3270 {
3271         int k;
3272         int l;
3273         TC_PRT("__bt_tds_provider_scan_result_cb");
3274         TC_PRT("result: %s", __bt_get_error_message(result));
3275
3276         TC_PRT("Result: %s", __bt_get_error_message(result));
3277         TC_PRT("Remote addr [%s]", remote_address);
3278         TC_PRT("Number of Transport Block [%d]", info->num_transport_block);
3279
3280         if (result == BT_ERROR_NONE) {
3281                 for (k = 0; k < info->num_transport_block; k++) {
3282                         TC_PRT("Block Num[%d] Transport Name [%d]", k+1, info->data[k]->transport);
3283                         TC_PRT("Block Num[%d] Transport state [%d]", k+1, info->data[k]->state);
3284                         TC_PRT("Block Num[%d] Is Data complete [%d]", k+1, info->data[k]->is_data_complete);
3285                         TC_PRT("Block Num[%d] Length of TDS Block data [%d]", k+1, info->data[k]->length);
3286
3287                         for (l = 0; l < info->data[k]->length; l++)
3288                                 TC_PRT("Transport Specific data [%d] = [0x%x]", l, info->data[k]->data[l]);
3289                 }
3290         }
3291 }
3292
3293 static void __bt_tds_seeker_connection_state_changed_cb(int result, const char *remote_address,
3294                         bt_tds_seeker_h seeker, bool connected, void *user_data)
3295 {
3296         TC_PRT("Result: %s", __bt_get_error_message(result));
3297         if (result == BT_ERROR_NONE) {
3298                 if (connected)
3299                         TC_PRT("TDS Seeker connected(address = %s)", remote_address);
3300                 else
3301                         TC_PRT("TDS Seeker Disconnected (address = %s)", remote_address);
3302         } else
3303                 BT_ERR("TDS Connection failed!");
3304 }
3305
3306 static void __bt_hrp_collector_connection_state_changed_cb(int result, const char *remote_address,
3307                         bt_hrp_collector_h seeker, bool connected, void *user_data)
3308 {
3309         TC_PRT("Result: %s", __bt_get_error_message(result));
3310         if (result == BT_ERROR_NONE) {
3311                 if (connected)
3312                         TC_PRT("HRP Collector connected(address = %s)", remote_address);
3313                 else
3314                         TC_PRT("HRP Collector Disconnected (address = %s)", remote_address);
3315         } else
3316                 BT_ERR("HRP Collection Connection failed!");
3317 }
3318
3319
3320 static void __bt_tds_seeker_complete_transport_data_cb(int result, const char *remote_address,
3321                         bt_tds_transport_block_list_s *info, void *user_data)
3322 {
3323         int k;
3324         int l;
3325         TC_PRT("__bt_tds_seeker_complete_transport_data_cb");
3326         TC_PRT("Result: %s", __bt_get_error_message(result));
3327         TC_PRT("Remote addr [%s]", remote_address);
3328
3329         if (result == BT_ERROR_NONE) {
3330                 TC_PRT("Number of Transport Block [%d]", info->num_transport_block);
3331                 for (k = 0; k < info->num_transport_block; k++) {
3332                         TC_PRT("Block Num[%d] Transport Name [%d]", k+1, info->data[k]->transport);
3333                         TC_PRT("Block Num[%d] Transport state [%d]", k+1, info->data[k]->state);
3334                         TC_PRT("Block Num[%d] Is Data complete [%d]", k+1, info->data[k]->is_data_complete);
3335                         TC_PRT("Block Num[%d] Length of TDS Block data [%d]", k+1, info->data[k]->length);
3336
3337                         for (l = 0; l < info->data[k]->length; l++)
3338                                 TC_PRT("Transport Specific data [%d] = [0x%x]", l, info->data[k]->data[l]);
3339                 }
3340         } else
3341                 BT_ERR("TDS Data receive request failed!");
3342 }
3343
3344 static void __bt_tds_control_point_activation_result_cb(int result, const char *remote_address,
3345                                 unsigned char *data, int length, void *user_data)
3346 {
3347         int k;
3348         TC_PRT("__bt_tds_control_point_activation_result_cb");
3349         TC_PRT("Result [%d]", result);
3350         TC_PRT("Address[%s]", remote_address);
3351
3352         if (result == BT_ERROR_NONE) {
3353                 TC_PRT("Data length [%d]", length);
3354                 for (k = 0; k < length; k++)
3355                         TC_PRT("Data[%d] [0x%x]", k, data[k]);
3356         }
3357 }
3358
3359 void __bt_otp_server_state_changed_cb(int result, bool status)
3360 {
3361         TC_PRT("__bt_otp_server_state_changed_cb");
3362         TC_PRT("Result: %d", result);
3363         TC_PRT("Server Status: %s", status ? "enabled" : "disabled");
3364 }
3365
3366 static void __bt_otp_client_connection_state_changed_cb(int result, const char *remote_address,
3367                         bt_otp_client_h otp_client, bool connected, void *user_data)
3368 {
3369         TC_PRT("Result: %s", __bt_get_error_message(result));
3370         if (result == BT_ERROR_NONE) {
3371                 if (connected)
3372                         TC_PRT("OTP Client connected(address = %s)", remote_address);
3373                 else
3374                         TC_PRT("OTP Client Disconnected (address = %s)", remote_address);
3375         } else
3376                 BT_ERR("OTP Connection failed!");
3377 }
3378
3379 static void __bt_otp_client_object_discovery_cb(int result, const char *remote_address,
3380                         bt_otp_object_list_s *obj_list, void *user_data)
3381 {
3382         int k;
3383         TC_PRT("__bt_otp_client_object_discovery_cb");
3384         TC_PRT("Result: %s", __bt_get_error_message(result));
3385         TC_PRT("Remote addr [%s]", remote_address);
3386
3387         if (result == BT_ERROR_NONE) {
3388                 TC_PRT("Number of Objects [%d]", obj_list->num_objects);
3389
3390                 for (k = 0; k < obj_list->num_objects; k++)
3391                         TC_PRT("Object[%d] Id: [%llu] Name: [%s]", k+1, obj_list->data[k]->id, obj_list->data[k]->name);
3392
3393         } else {
3394                 BT_ERR("Object discovery failed!");
3395         }
3396 }
3397
3398 static void __bt_otp_client_object_select_cb(int result, const char *remote_address,
3399                         unsigned long long obj_id, void *user_data)
3400 {
3401         TC_PRT("__bt_otp_client_object_select_cb");
3402         TC_PRT("Result: %s", __bt_get_error_message(result));
3403         TC_PRT("Remote addr [%s]", remote_address);
3404
3405         if (result == BT_ERROR_NONE)
3406                 TC_PRT("Object selected successfully! Current object[%llu]", obj_id);
3407         else
3408                 BT_ERR("Object selection failed! Current object[%llu]", obj_id);
3409 }
3410
3411 static void __bt_otp_client_read_object_complete_cb(int result, const char *remote_address,
3412                         char *file_path, void *user_data)
3413 {
3414         if (result == BT_ERROR_NONE)
3415                 TC_PRT("Read object success!, File location [%s]", file_path);
3416         else
3417                 BT_ERR("Read object failed!");
3418 }
3419
3420 static void __bt_otp_client_object_create_cb(int result, const char *remote_address,
3421                         unsigned long long obj_id, void *user_data)
3422 {
3423         if (result == BT_ERROR_NONE)
3424                 TC_PRT("Object[%llu] created successfully in remote server!", obj_id);
3425         else
3426                 BT_ERR("Object creation failed!");
3427 }
3428
3429 static void __bt_otp_client_object_write_cb(int result, const char *remote_address,
3430                         unsigned int length, void *user_data)
3431 {
3432         if (result == BT_ERROR_NONE)
3433                 TC_PRT("Object write success!, [%u] bytes written", length);
3434         else
3435                 BT_ERR("Object write failed!, [%u] bytes written", length);
3436 }
3437
3438 static void __bt_otp_client_object_execute_cb(int result, const char *remote_address,
3439                         unsigned long long obj_id, void *user_data)
3440 {
3441         TC_PRT("__bt_otp_client_object_execute_cb");
3442         TC_PRT("Result: %s", __bt_get_error_message(result));
3443         TC_PRT("Remote addr [%s]", remote_address);
3444
3445         if (result == BT_ERROR_NONE)
3446                 TC_PRT("Object[%llu] launched successfully!", obj_id);
3447         else
3448                 BT_ERR("Object[%llu] launch failed!", obj_id);
3449 }
3450
3451 static void __bt_otp_client_object_delete_cb(int result, const char *remote_address,
3452                         unsigned long long obj_id, void *user_data)
3453 {
3454         TC_PRT("__bt_otp_client_object_delete_cb");
3455         TC_PRT("Result: %s", __bt_get_error_message(result));
3456         TC_PRT("Remote addr [%s]", remote_address);
3457
3458         if (result == BT_ERROR_NONE)
3459                 TC_PRT("Object[%llu] deleted successfully!", obj_id);
3460         else
3461                 BT_ERR("Object[%llu] delete failed!", obj_id);
3462 }
3463
3464 void __bt_gatt_client_read_request_completed_cb(int result,
3465                 bt_gatt_h request_handle, void *user_data)
3466 {
3467         TC_PRT("[HR]Result : %d", result);
3468 }
3469
3470 void __bt_gatt_client_write_request_completed_cb(int result,
3471                 bt_gatt_h request_handle, void *user_data)
3472 {
3473         TC_PRT("[HR]Result : %d", result);
3474 }
3475
3476 void _bt_hrp_collector_bsl_read_completed_cb(int result,
3477                 bt_hrp_collector_h request_handle, bt_body_sensor_location_e location, void *user_data)
3478 {
3479         TC_PRT("[HR]Result : %d", result);
3480         TC_PRT("[HR]request_handle : %p", request_handle);
3481         TC_PRT("[HR]location [%d]", location);
3482
3483 }
3484
3485 static void __bt_initialize_all(void)
3486 {
3487         int ret;
3488         TC_PRT("Initialize and set callback functions");
3489
3490         ret = bt_initialize();
3491         if (ret != BT_ERROR_NONE)
3492                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
3493         ret = bt_adapter_set_state_changed_cb(
3494                         __bt_adapter_state_changed_cb, NULL);
3495         if (ret != BT_ERROR_NONE)
3496                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
3497         ret = bt_adapter_set_connectable_changed_cb(
3498                         __bt_adapter_connectable_changed_cb, NULL);
3499         if (ret != BT_ERROR_NONE)
3500                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
3501         ret = bt_device_set_bond_created_cb(
3502                         __bt_device_bond_created_cb, NULL);
3503         if (ret != BT_ERROR_NONE)
3504                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
3505         ret = bt_device_set_bond_destroyed_cb(
3506                         __bt_device_bond_destroyed_cb, NULL);
3507         if (ret != BT_ERROR_NONE)
3508                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
3509         ret = bt_device_set_connection_state_changed_cb(
3510                         __bt_device_connection_state_changed_cb, NULL);
3511         if (ret != BT_ERROR_NONE)
3512                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
3513         ret = bt_device_set_att_mtu_changed_cb(
3514                         __bt_device_att_mtu_changed_cb, NULL);
3515         if (ret != BT_ERROR_NONE)
3516                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
3517         ret = bt_gatt_set_connection_state_changed_cb(
3518                         __bt_gatt_connection_state_changed_cb, NULL);
3519         if (ret != BT_ERROR_NONE)
3520                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
3521         ret = bt_adapter_set_device_discovery_state_changed_cb(
3522                         __bt_adapter_device_discovery_state_changed_cb, NULL);
3523         if (ret != BT_ERROR_NONE)
3524                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
3525         if (TIZEN_PROFILE_WEARABLE_IVI) {
3526                 ret = bt_pbap_client_set_connection_state_changed_cb(__bt_pbap_connection_state_changed_cb,
3527                                 NULL);
3528                 if (ret != BT_ERROR_NONE)
3529                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
3530         }
3531         ret = bt_socket_set_connection_state_changed_cb(
3532                 __bt_socket_connection_state_changed_cb, NULL);
3533         if (ret != BT_ERROR_NONE)
3534                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
3535
3536         ret = bt_adapter_le_set_state_changed_cb(
3537                         __bt_adapter_le_state_changed_cb, NULL);
3538         if (ret != BT_ERROR_NONE)
3539                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
3540
3541         return;
3542 }
3543
3544 int test_set_params(int test_id, char *param)
3545 {
3546         static int param_index = 0;
3547         const char *param_type = NULL;
3548         int param_count = 0;
3549
3550         if (param_index > 0 && param_index  == g_test_param.param_count)
3551                 goto done;
3552
3553         switch (current_tc_table) {
3554         case BT_UNIT_TEST_TABLE_ADAPTER: {
3555                 switch (test_id) {
3556                 case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_VISIBILITY:
3557                         param_count = 1;
3558                         TC_PRT("Input param(%d) (non-discoverable: -1, always: 0, limited-discoverable(time): N)", param_index + 1);
3559                         break;
3560                 case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_CONNECTABLE:
3561                         param_count = 1;
3562                         param_type = BT_UNIT_TEST_PARAM_TYPE_BOOL;
3563                         TC_PRT("Input param(%d) type:%s", param_index + 1, param_type);
3564                         break;
3565                 case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_MANUFACTURER_DATA:
3566                         param_count = 1;
3567                         param_type = BT_UNIT_TEST_PARAM_TYPE_BYTE_ARRAY;
3568                         TC_PRT("Input param(%d) type:%s", param_index + 1, param_type);
3569                         break;
3570                 case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_REMOTE_OOB_EXT_DATA:
3571                         param_count = 5;
3572                         param_type = BT_UNIT_TEST_PARAM_TYPE_STRING;
3573                         TC_PRT("Input param(%d) type:%s", param_index + 1, param_type);
3574                         break;
3575                 default:
3576                         TC_PRT("There is no param to set\n");
3577                         need_to_set_params = false;
3578                         break;
3579                 }
3580
3581                 break;
3582         }
3583
3584         case BT_UNIT_TEST_TABLE_ADAPTER_LE: {
3585                 switch (test_id) {
3586                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_SET_SCAN_MODE:
3587                         param_count = 1;
3588                         TC_PRT("Scan mode\n (0 : Balanced (5000/2000 ms), 1: Low Latency (5000/5000 ms), 2 : Low Energy (5000/500 ms)");
3589                         break;
3590                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_SET_SCAN_TYPE:
3591                         param_count = 1;
3592                         TC_PRT("Scan type\n (0 : Passive, 1: Active)");
3593                         break;
3594                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_SET_SCAN_CUSTOMIZED:
3595                         param_count = 2;
3596                         switch (param_index) {
3597                         case 0:
3598                                 TC_PRT("Input Scan Interval (Unit : ms)");
3599                                 break;
3600                         case 1:
3601                                 TC_PRT("Input Scan Window (Unit : ms)");
3602                                 break;
3603                         }
3604                         break;
3605                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_REGISTER_SCAN_FILTER_DEVICE_ADDRESS:
3606                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_REGISTER_SCAN_FILTER_DEVICE_NAME:
3607                         param_count = 1;
3608                         TC_PRT("Input data for LE scan filter");
3609                         break;
3610                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_ADD_ADVERTISING_DATA:
3611                         param_count = 1;
3612                         TC_PRT("Select advertising data \n (0 : Service uuid, 1: Service solicitation 2 : Appearance & Tx power, 3 : All, 4 : ANCS");
3613                         TC_PRT("\t (Default scan response : Service Data &Local name & Manufacturer data)");
3614                         break;
3615                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_SET_ADVERTISING_MODE:
3616                         param_count = 1;
3617                         TC_PRT("Input mode \n (0 : Balanced(500 ms), 1 : Low Latency(150 ms), 2 : Low Energy (1000 ms))");
3618                         break;
3619                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_SET_ADVERTISING_FILTER_POLICY:
3620                         param_count = 1;
3621                         TC_PRT("Input filter_policy \n (0 : No use White List, 1 : Allow scan, 2 : Allow conneciton, 3 : Allow scan & conneciton)");
3622                         break;
3623                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_SET_ADVERTISING_CONNECTABLE:
3624                         param_count = 1;
3625                         TC_PRT("Input adv type \n (0 : Non-connectable (ADV_SCAN_IND), 1 : Connectable (ADV_IND) ");
3626                         break;
3627                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_SET_ADVERTISING_CUSTOM_TX_POWER:
3628                         param_count = 1;
3629                         TC_PRT("Input adv Tx power level \n ( 1 ~ -127 dBm) ");
3630                         break;
3631                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_STOP_ADVERTISING:
3632                         param_count = 1;
3633                         TC_PRT("Input adv slot id \n (Default is 0, Maximum is 2) ");
3634                         break;
3635                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_ENABLE_PRIVACY:
3636                         param_count = 1;
3637                         param_type = BT_UNIT_TEST_PARAM_TYPE_BOOL;
3638                         TC_PRT("Input param(%d) type:%s", param_index + 1, param_type);
3639                         break;
3640                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_SET_REMOTE_OOB_EXT_DATA:
3641                         param_count = 4;
3642                         param_type = BT_UNIT_TEST_PARAM_TYPE_STRING;
3643                         switch (param_index) {
3644                         case 0:
3645                                 TC_PRT("Remote address");
3646                                 break;
3647                         case 1:
3648                                 TC_PRT("Address type (0 : Public, 1 : Random");
3649                                 break;
3650                         case 2:
3651                                 TC_PRT("confirmation");
3652                                 break;
3653                         case 3:
3654                                 TC_PRT("random");
3655                                 break;
3656                         }
3657                         break;
3658                 default:
3659                         TC_PRT("There is no param to set\n");
3660                         need_to_set_params = false;
3661                         break;
3662                 }
3663
3664                 break;
3665         }
3666
3667         case BT_UNIT_TEST_TABLE_DEVICE: {
3668                 switch (test_id) {
3669                 case BT_UNIT_TEST_FUNCTION_DEVICE_IS_PROFILE_CONNECTED:
3670                 case BT_UNIT_TEST_FUNCTION_DEVICE_CREATE_BOND_BY_TYPE:
3671                         param_count = 1;
3672                         param_type = BT_UNIT_TEST_PARAM_TYPE_INT;
3673                         TC_PRT("Input param(%d) type:%s", param_index + 1, param_type);
3674                         break;
3675                 case BT_UNIT_TEST_FUNCTION_DEVICE_UPDATE_LE_CONNECTION_MODE:
3676                         param_count = 1;
3677                         TC_PRT("Input param(%d) mode (0 : balanced, 1 : low latency, 2 : low power) ", param_index + 1);
3678                         break;
3679                 case BT_UNIT_TEST_FUNCTION_DEVICE_UPDATE_LE_CONNECTION:
3680                         param_count = 4;
3681                         switch (param_index) {
3682                         case 0:
3683                                 TC_PRT("Input interval min (8 ~ 4000)");
3684                                 break;
3685                         case 1:
3686                                 TC_PRT("Input interval max (8 ~ 4000)");
3687                                 break;
3688                         case 2:
3689                                 TC_PRT("Input slave latency ( 0 ~ 499)");
3690                                 break;
3691                         case 3:
3692                                 TC_PRT("Input supervision timeout ( 100 ~ 32000)");
3693                                 break;
3694                         }
3695                         break;
3696                 case BT_UNIT_TEST_FUNCTION_DEVICE_REQUEST_ATT_MTU:
3697                         param_count = 1;
3698                         param_type = "int(1, 2, 10, ...., 512)";
3699                         TC_PRT("Input param(%d) : %s", param_index + 1, param_type);
3700                         break;
3701                 case BT_UNIT_TEST_FUNCTION_LE_DEVICE_SET_DATA_LENGTH:
3702                         param_count = 2;
3703                         switch (param_index) {
3704                         case 0:
3705                                 TC_PRT("Input max octets (27 ~ 251)");
3706                                 break;
3707                         case 1:
3708                                 TC_PRT("Input max time (328 ~ 2120)");
3709                                 break;
3710                         }
3711                         break;
3712                 default:
3713                         TC_PRT("There is no param to set\n");
3714                         need_to_set_params = false;
3715                         break;
3716                 }
3717
3718                 break;
3719         }
3720
3721         case BT_UNIT_TEST_TABLE_SOCKET: {
3722                 switch (test_id) {
3723                 case BT_UNIT_TEST_FUNCTION_SOCKET_CREATE_RFCOMM_CUSTOM_UUID:
3724                 case BT_UNIT_TEST_FUNCTION_SOCKET_CONNECT_RFCOMM_CUSTOM_UUID:
3725                 case BT_UNIT_TEST_FUNCTION_SOCKET_SEND_DATA:
3726                         param_count = 1;
3727                         param_type = BT_UNIT_TEST_PARAM_TYPE_STRING;
3728                         TC_PRT("Input param(%d) type:%s", param_index + 1, param_type);
3729                         break;
3730                 default:
3731                         TC_PRT("There is no param to set\n");
3732                         need_to_set_params = false;
3733                         break;
3734                 }
3735
3736                 break;
3737         }
3738
3739         case BT_UNIT_TEST_TABLE_OPP: {
3740                 switch (test_id) {
3741                 default:
3742                         TC_PRT("There is no param to set\n");
3743                         need_to_set_params = false;
3744                         break;
3745                 }
3746
3747                 break;
3748         }
3749
3750         case BT_UNIT_TEST_TABLE_AUDIO: {
3751                 switch (test_id) {
3752                 case BT_UNIT_TEST_FUNCTION_AUDIO_CONNECT:
3753                 case BT_UNIT_TEST_FUNCTION_AUDIO_DISCONNECT:
3754                         param_count = 1;
3755                         param_type = BT_UNIT_TEST_PARAM_TYPE_INT;
3756                         TC_PRT("Input param(%d) type:%s", param_index + 1, param_type);
3757                         break;
3758                 case BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_DIALING:
3759                 case BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_INCOMING:
3760                 case BT_UNIT_TEST_FUNCTION_CALL_LIST_ADD:
3761                 case BT_UNIT_TEST_FUNCTION_AG_SWITCH_HEADSET:
3762                         param_count = 1;
3763                         param_type = BT_UNIT_TEST_PARAM_TYPE_STRING;
3764                         TC_PRT("Input param(%d) type:%s", param_index + 1, param_type);
3765                         break;
3766                 default:
3767                         TC_PRT("There is no param to set\n");
3768                         need_to_set_params = false;
3769                         break;
3770                 }
3771
3772                 break;
3773         }
3774
3775         case BT_UNIT_TEST_TABLE_PAN: {
3776                 switch (test_id) {
3777                 default:
3778                         TC_PRT("There is no param to set\n");
3779                         need_to_set_params = false;
3780                         break;
3781                 }
3782
3783                 break;
3784         }
3785
3786         case BT_UNIT_TEST_TABLE_GATT: {
3787                 switch (test_id) {
3788                 case BT_UNIT_TEST_FUNCTION_GATT_CONNECT:
3789                         param_count = 1;
3790                         param_type = BT_UNIT_TEST_PARAM_TYPE_BOOL;
3791                         TC_PRT("Input param(%d) type:%s", param_index + 1, param_type);
3792                         break;
3793                 case BT_UNIT_TEST_FUNCTION_GATT_SET_WRITE_TYPE: {
3794                         param_count = 3;
3795                         param_type = BT_UNIT_TEST_PARAM_TYPE_STRING;
3796
3797                         switch (param_index) {
3798                         case 0:
3799                                 TC_PRT("Input Service UUID");
3800                                 break;
3801                         case 1:
3802                                 TC_PRT("Input Characteristic UUID");
3803                                 break;
3804                         case 2:
3805                                 TC_PRT("Input write_type (0 : no response, 1 : with reponse, 2 : signed)");
3806                                 break;
3807                         }
3808                         break;
3809                 }
3810                 case BT_UNIT_TEST_FUNCTION_GATT_CLIENT_READ_VALUE: {
3811                         param_count = 3;
3812
3813                         switch (param_index) {
3814                         case 0:
3815                                 TC_PRT("Input Service UUID");
3816                                 break;
3817                         case 1:
3818                                 TC_PRT("Input Characteristic UUID");
3819                                 break;
3820                         case 2:
3821                                 TC_PRT("Input Descriptor UUID or nothing");
3822                                 break;
3823                         }
3824                         break;
3825                 }
3826                 case BT_UNIT_TEST_FUNCTION_GATT_CLIENT_WRITE_VALUE: {
3827                         param_count = 5;
3828
3829                         switch (param_index) {
3830                         case 0:
3831                                 TC_PRT("Input Service UUID");
3832                                 break;
3833                         case 1:
3834                                 TC_PRT("Input Characteristic UUID");
3835                                 break;
3836                         case 2:
3837                                 TC_PRT("Input Descriptor UUID or nothing");
3838                                 break;
3839                         case 3:
3840                                 TC_PRT("Input Value Type (avail. : uint8, uint16, uint32, int8, int16, int32, str)");
3841                                 break;
3842                         case 4:
3843                                 TC_PRT("Input Value");
3844                                 break;
3845                         }
3846                         break;
3847                 }
3848                 case BT_UNIT_TEST_FUNCTION_GATT_CLIENT_SET_CHAR_VALUE_CHANGED_CB: {
3849                         param_count = 2;
3850
3851                         switch (param_index) {
3852                         case 0:
3853                                 TC_PRT("Input Service UUID");
3854                                 break;
3855                         case 1:
3856                                 TC_PRT("Input Characteristic UUID");
3857                                 break;
3858                         }
3859                         break;
3860                 }
3861                 case BT_UNIT_TEST_FUNCTION_GATT_CLIENT_UNSET_CHAR_VALUE_CHANGED_CB: {
3862                         param_count = 2;
3863
3864                         switch (param_index) {
3865                         case 0:
3866                                 TC_PRT("Input Service UUID");
3867                                 break;
3868                         case 1:
3869                                 TC_PRT("Input Characteristic UUID");
3870                                 break;
3871                         }
3872                         break;
3873                 }
3874                 case BT_UNIT_TEST_FUNCTION_GATT_CLIENT_REQUEST_ATT_MTU:
3875                         param_count = 1;
3876                         param_type = BT_UNIT_TEST_PARAM_TYPE_INT;
3877                         TC_PRT("Input param(%d) type:%s", param_index + 1, param_type);
3878                         break;
3879                 case BT_UNIT_TEST_FUNCTION_ANCS_POSITIVE_ACTION:
3880                 case BT_UNIT_TEST_FUNCTION_ANCS_NEGATIVE_ACTION:
3881                 case BT_UNIT_TEST_FUNCTION_ANCS_GET_NOTI_ATTR:
3882                         param_count = 1;
3883                         param_type = BT_UNIT_TEST_PARAM_TYPE_STRING;
3884                         TC_PRT("Input param(%d) type:%s", param_index + 1, param_type);
3885                         break;
3886                 case BT_UNIT_TEST_FUNCTION_GATT_ENABLE_DATA_BATCHING: {
3887                         param_count = 2;
3888                         switch (param_index) {
3889                         case 0:
3890                                 TC_PRT("Input buffer_threshold (1 ~ 32767)");
3891                                 break;
3892                         case 1:
3893                                 TC_PRT("Input timeout (1 ~ 32767)");
3894                                 break;
3895                         }
3896                         break;
3897                 }
3898                 default:
3899                         TC_PRT("There is no param to set\n");
3900                         need_to_set_params = false;
3901                         break;
3902                 }
3903
3904                 break;
3905         }
3906
3907         case BT_UNIT_TEST_TABLE_HPS: {
3908                 switch (test_id) {
3909                 case BT_UNIT_TEST_FUNCTION_HPS_CLIENT_CREATE:
3910                         param_count = 1;
3911                         param_type = BT_UNIT_TEST_PARAM_TYPE_BOOL;
3912                         TC_PRT("Input param(%d) type:%s", param_index + 1, param_type);
3913                         break;
3914                 case BT_UNIT_TEST_FUNCTION_HPS_CLIENT_SET_HDR:
3915                 case BT_UNIT_TEST_FUNCTION_HPS_CLIENT_SET_ENTITY:
3916                 case BT_UNIT_TEST_FUNCTION_HPS_CLIENT_SET_URI:
3917                         param_count = 1;
3918                         param_type = BT_UNIT_TEST_PARAM_TYPE_STRING;
3919                         TC_PRT("Input param(%d) type:%s", param_index + 1, param_type);
3920                         break;
3921                 case BT_UNIT_TEST_FUNCTION_HPS_CLIENT_SET_CP: {
3922                         param_count = 1;
3923                         TC_PRT("Input Value Type (avail. : \n1.HTTP_GET, \n2.HTTP_HEAD, \
3924                                                         \n3.HTTP_POST, \n4.HTTP_PUT, \n5.HTTP_DELETE, \
3925                                                         \n6.HTTPS_GET, \n7.HTTPS_HEAD, \n8.HTTPS_POST, \
3926                                                         \n9.HTTPS_PUT, \n10.HTTPS_DELETE, \n11.HTTP_CANCEL");
3927                         break;
3928                 }
3929                 default:
3930                         TC_PRT("There is no param to set\n");
3931                         need_to_set_params = false;
3932                         break;
3933                 }
3934                 break;
3935         }
3936
3937         case BT_UNIT_TEST_TABLE_DPM: {
3938                 switch (test_id) {
3939                 case BT_UNIT_TEST_FUNCTION_DPM_SET_ALLOW_BLUETOOTH_MODE:
3940                         param_count = 1;
3941                         TC_PRT("Input Value Type (avail. : \n0.BT_DPM_BT_ALLOWED, \n1.BT_DPM_HANDSFREE_ONLY, \n2.BT_DPM_BT_RESTRICTED");
3942                         break;
3943
3944                 case BT_UNIT_TEST_FUNCTION_DPM_ACTIVATE_DEVICE_RESTRICTION:
3945                 case BT_UNIT_TEST_FUNCTION_DPM_ACTIVATE_UUID_RESTRICTION:
3946                 case BT_UNIT_TEST_FUNCTION_DPM_SET_ALLOW_OUTGOING_CALL:
3947                 case BT_UNIT_TEST_FUNCTION_DPM_SET_PAIRING_STATE:
3948                 case BT_UNIT_TEST_FUNCTION_DPM_SET_DESKTOP_CONNECTIVITY_STATE:
3949                 case BT_UNIT_TEST_FUNCTION_DPM_SET_DISCOVERABLE_STATE:
3950                 case BT_UNIT_TEST_FUNCTION_DPM_SET_LIMITED_DISCOVERABLE_STATE:
3951                 case BT_UNIT_TEST_FUNCTION_DPM_SET_DATA_TRANSFER_STATE:
3952                         param_count = 1;
3953                         TC_PRT("Input Value Type (avail. : \n0.BT_DPM_BT_ALLOWED, \n1.BT_DPM_RESTRICTED");
3954                         break;
3955                 case BT_UNIT_TEST_FUNCTION_DPM_ADD_DEVICES_TO_BLACKLIST:
3956                 case BT_UNIT_TEST_FUNCTION_DPM_ADD_DEVICES_TO_WHITELIST:
3957                 case BT_UNIT_TEST_FUNCTION_DPM_REMOVE_DEVICE_FROM_BLACKLIST:
3958                 case BT_UNIT_TEST_FUNCTION_DPM_REMOVE_DEVICE_FROM_WHITELIST:
3959                         param_count = 1;
3960                         TC_PRT("Input device Address");
3961                         break;
3962                 case BT_UNIT_TEST_FUNCTION_DPM_ADD_UUIDS_TO_BLACKLIST:
3963                 case BT_UNIT_TEST_FUNCTION_DPM_ADD_UUIDS_TO_WHITELIST:
3964                 case BT_UNIT_TEST_FUNCTION_DPM_REMOVE_UUIDS_FROM_BLACKLIST:
3965                 case BT_UNIT_TEST_FUNCTION_DPM_REMOVE_UUIDS_FROM_WHITELIST:
3966                         param_count = 1;
3967                         TC_PRT("Input UUID");
3968                         break;
3969                 case BT_UNIT_TEST_FUNCTION_DPM_SET_PROFILE_STATE:
3970                         param_count = 2;
3971                         switch (param_index) {
3972                         case 0:
3973                                 TC_PRT("Input Profile Type (avail. : \n0.BT_DPM_POLICY_A2DP_PROFILE_STATE, \
3974                                                                                                 \n1.BT_DPM_POLICY_AVRCP_PROFILE_STATE, \
3975                                                                                                 \n2.BT_DPM_POLICY_BPP_PROFILE_STATE, \
3976                                                                                                 \n3.BT_DPM_POLICY_DUN_PROFILE_STATE, \
3977                                                                                                 \n4.BT_DPM_POLICY_FTP_PROFILE_STATE, \
3978                                                                                                 \n5.BT_DPM_POLICY_HFP_PROFILE_STATE, \
3979                                                                                                 \n6.BT_DPM_POLICY_HSP_PROFILE_STATE, \
3980                                                                                                 \n7.BT_DPM_POLICY_PBAP_PROFILE_STATE, \
3981                                                                                                 \n8.BT_DPM_POLICY_SAP_PROFILE_STATE, \
3982                                                                                                 \n9.BT_DPM_POLICY_SPP_PROFILE_STATE");
3983                                 break;
3984                         case 1:
3985                                 TC_PRT("Input Value Type (avail. : \n0.BT_DPM_BT_ALLOWED, \n1.BT_DPM_RESTRICTED");
3986                                 break;
3987                         }
3988                         break;
3989                 case BT_UNIT_TEST_FUNCTION_DPM_GET_PROFILE_STATE:
3990                         param_count = 1;
3991                         TC_PRT("Input Profile Type (avail. : \n0.BT_DPM_POLICY_A2DP_PROFILE_STATE, \
3992                                                                                                 \n1.BT_DPM_POLICY_AVRCP_PROFILE_STATE, \
3993                                                                                                 \n2.BT_DPM_POLICY_BPP_PROFILE_STATE, \
3994                                                                                                 \n3.BT_DPM_POLICY_DUN_PROFILE_STATE, \
3995                                                                                                 \n4.BT_DPM_POLICY_FTP_PROFILE_STATE, \
3996                                                                                                 \n5.BT_DPM_POLICY_HFP_PROFILE_STATE, \
3997                                                                                                 \n6.BT_DPM_POLICY_HSP_PROFILE_STATE, \
3998                                                                                                 \n7.BT_DPM_POLICY_PBAP_PROFILE_STATE, \
3999                                                                                                 \n8.BT_DPM_POLICY_SAP_PROFILE_STATE, \
4000                                                                                                 \n9.BT_DPM_POLICY_SPP_PROFILE_STATE");
4001
4002                         break;
4003                 default:
4004                         TC_PRT("There is no param to set\n");
4005                         need_to_set_params = false;
4006                         break;
4007                 break;
4008                 }
4009                 break;
4010         }
4011
4012         case BT_UNIT_TEST_TABLE_PXP: {
4013                 switch (test_id) {
4014                 case BT_UNIT_TEST_FUNCTION_PXP_MONITOR_WRITE_LINKLOSS_ALERT:
4015                 case BT_UNIT_TEST_FUNCTION_PXP_MONITOR_WRITE_IMMEDIATE_ALERT:
4016                         param_count = 1;
4017                         TC_PRT("Input Value Type (avail. : \n0.NONE, \n1.MILD, \n2.HIGH");
4018                         break;
4019                 default:
4020                         TC_PRT("There is no param to set\n");
4021                         need_to_set_params = false;
4022                         break;
4023                 }
4024                 break;
4025         }
4026
4027         case BT_UNIT_TEST_TABLE_AVRCP: {
4028                 switch (test_id) {
4029                 default:
4030                         TC_PRT("There is no param to set\n");
4031                         need_to_set_params = false;
4032                         break;
4033                 }
4034
4035                 break;
4036         }
4037         case BT_UNIT_TEST_TABLE_HID: {
4038                 switch (test_id) {
4039                 case BT_UNIT_TEST_FUNCTION_HID_DEVICE_SEND_RC_KEY_EVENT:
4040                         param_count = 1;
4041                         TC_PRT("Select TV control mode (1 : Vol Up, 2 : Vol Down, 3 : CH Up, 4 : CH Down) : ");
4042                         break;
4043                 default:
4044                         TC_PRT("There is no param to set\n");
4045                         need_to_set_params = false;
4046                         break;
4047                 }
4048
4049                 break;
4050         }
4051
4052         case BT_UNIT_TEST_TABLE_IPSP: {
4053                 switch (test_id) {
4054                 case BT_UNIT_TEST_FUNCTION_IPSP_CONNECT_WITH_APP_SERVER_SOCKET:
4055                         param_count = 1;
4056                         TC_PRT("IPSP Client : Input IPSP App server's IPv6 address to connect :");
4057                         break;
4058                 case BT_UNIT_TEST_FUNCTION_IPSP_SEND_IPV6_APP_DATA: {
4059                         param_count = 2;
4060                         param_type = BT_UNIT_TEST_PARAM_TYPE_STRING;
4061
4062                         switch (param_index) {
4063                         case 0:
4064                                 TC_PRT("IPSP : Input current role of Application[Server[0] / Client[1] :");
4065                                 break;
4066                         case 1:
4067                         TC_PRT("IPSP : input data to send :");
4068                                 break;
4069                         }
4070                         break;
4071                 }
4072                 case BT_UNIT_TEST_FUNCTION_IPSP_RECV_IPV6_APP_DATA:
4073                         param_count = 1;
4074                         TC_PRT("IPSP : Input current role of Application[Server[0]/Client[1] :");
4075                         break;
4076                 default:
4077                         TC_PRT("There is no param to set\n");
4078                         need_to_set_params = false;
4079                         break;
4080                 }
4081
4082                 break;
4083         }
4084
4085         case BT_UNIT_TEST_TABLE_HDP: {
4086                 switch (test_id) {
4087                 default:
4088                         TC_PRT("There is no param to set\n");
4089                         need_to_set_params = false;
4090                         break;
4091                 }
4092
4093                 break;
4094         }
4095
4096         case BT_UNIT_TEST_TABLE_HF:
4097         {
4098                 switch (test_id) {
4099                 case BT_UNIT_TEST_FUNCTION_HF_NOTIFY_CALL_WITH_PARAM:
4100                         param_count = 1;
4101                         param_type = BT_UNIT_TEST_PARAM_TYPE_INT;
4102                         TC_PRT("Input param(%d) type:%s", param_index + 1, param_type);
4103                         break;
4104                 default:
4105                         TC_PRT("There is no param to set\n");
4106                         need_to_set_params = false;
4107                         break;
4108                 }
4109
4110                 break;
4111         }
4112
4113         case BT_UNIT_TEST_TABLE_PBAP_CLIENT:
4114                 if (!TIZEN_PROFILE_WEARABLE_IVI)
4115                         goto __default__;
4116         {
4117                 switch (test_id) {
4118                 default:
4119                         TC_PRT("There is no param to set\n");
4120                         need_to_set_params = false;
4121                         break;
4122                 }
4123
4124                 break;
4125         }
4126
4127         case BT_UNIT_TEST_TABLE_ETC: {
4128                 switch (test_id) {
4129                 case BT_UNIT_TEST_FUNCTION_APP_CONTROL_DEFAULT:
4130                         param_count = 1;
4131                         param_type = BT_UNIT_TEST_PARAM_TYPE_STRING;
4132                         TC_PRT("Input launch-type string(ex. setting, headset, hid)");
4133                         break;
4134                 case BT_UNIT_TEST_FUNCTION_CHECK_FEATURE:
4135                         param_count = 1;
4136                         TC_PRT("Input feature string(ex. tizen.org/feature/network.bluetooth)");
4137                         break;
4138                 default:
4139                         TC_PRT("There is no param to set\n");
4140                         need_to_set_params = false;
4141                         break;
4142                 }
4143
4144                 break;
4145         }
4146
4147         case BT_UNIT_TEST_TABLE_OTP: {
4148                 switch (test_id) {
4149                 case BT_UNIT_TEST_FUNCTION_OTP_SERVER_INIT:
4150                 case BT_UNIT_TEST_FUNCTION_OTP_CLIENT_CREATE_OBJ:
4151                         param_count = 1;
4152                         TC_PRT("Input Value in string");
4153                         break;
4154                 case BT_UNIT_TEST_FUNCTION_OTP_CLIENT_SELECT_OBJ:
4155                         param_count = 1;
4156                         TC_PRT("Input Value in uint64_t");
4157                         break;
4158                 case BT_UNIT_TEST_FUNCTION_OTP_CLIENT_WRITE_OBJ:
4159                         param_count = 4;
4160
4161                         switch (param_index) {
4162                         case 0:
4163                                 TC_PRT("Input file path");
4164                                 break;
4165                         case 1:
4166                                 TC_PRT("Input offset");
4167                                 break;
4168                         case 2:
4169                                 TC_PRT("Input Length");
4170                                 break;
4171                         case 3:
4172                                 TC_PRT("Input mode");
4173                                 break;
4174                         }
4175                         break;
4176                 default:
4177                         TC_PRT("There is no param to set\n");
4178                         need_to_set_params = false;
4179                         break;
4180                 }
4181
4182                 break;
4183         }
4184 __default__:
4185         default:
4186                 TC_PRT("There is no param to set\n");
4187                 need_to_set_params = false;
4188                 break;
4189         }
4190
4191 done:
4192         if (need_to_set_params) {
4193                 if (param_index == 0) {
4194                         g_test_param.param_count = param_count;
4195                         g_test_param.params = g_malloc0(sizeof(char*) * g_test_param.param_count);
4196                 }
4197
4198                 if (param_index > 0) {
4199                         int len = strlen(param);
4200                         /* Remove new line character */
4201                         param[len - 1] = '\0';
4202                         g_test_param.params[param_index - 1] = g_strdup(param);
4203                 }
4204
4205                 if (param_index  == g_test_param.param_count) {
4206                         need_to_set_params = false;
4207 #ifdef ARCH64
4208                         test_input_callback((void *)(uintptr_t)test_id);
4209 #else
4210                         test_input_callback((void *)test_id);
4211 #endif
4212                         param_index = 0;
4213                         return 0;
4214                 }
4215
4216                 param_index++;
4217         }
4218
4219         return 0;
4220 }
4221
4222 int test_input_callback(void *data)
4223 {
4224         int ret = 0;
4225 #ifdef ARCH64
4226         int test_id = (uintptr_t)data;
4227 #else
4228         int test_id = (int)data;
4229 #endif
4230
4231         switch (current_tc_table) {
4232         case BT_UNIT_TEST_TABLE_MAIN: {
4233                 switch (test_id) {
4234                 case 0x00ff:
4235                         TC_PRT("Finished");
4236                         g_main_loop_quit(main_loop);
4237                         break;
4238
4239                 case BT_UNIT_TEST_FUNCTION_INITIALIZE:
4240                         ret = bt_initialize();
4241                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4242                         break;
4243                 case BT_UNIT_TEST_FUNCTION_DEINITIALIZE:
4244                         ret = bt_deinitialize();
4245                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4246                         break;
4247                 default:
4248                         break;
4249                 }
4250
4251                 break;
4252         }
4253         case BT_UNIT_TEST_TABLE_ADAPTER: {
4254                 switch (test_id) {
4255                 case BT_UNIT_TEST_FUNCTION_ADAPTER_GET_STATE: {
4256                         bt_adapter_state_e state = BT_ADAPTER_DISABLED;
4257
4258                         ret = bt_adapter_get_state(&state);
4259                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4260                         TC_PRT("state: %d", state);
4261                         break;
4262                 }
4263                 case BT_UNIT_TEST_FUNCTION_ADAPTER_ENABLE:
4264                         ret = bt_adapter_enable();
4265                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4266                         break;
4267                 case BT_UNIT_TEST_FUNCTION_ADAPTER_DISABLE:
4268                         ret = bt_adapter_disable();
4269                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4270                         break;
4271                 case BT_UNIT_TEST_FUNCTION_ADAPTER_RECOVER:
4272                         ret = bt_adapter_recover();
4273                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4274                         break;
4275                 case BT_UNIT_TEST_FUNCTION_ADAPTER_START_DEVICE_DISCOVERY:
4276                         ret = bt_adapter_start_device_discovery();
4277                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4278                         break;
4279                 case BT_UNIT_TEST_FUNCTION_ADAPTER_STOP_DEVICE_DISCOVERY:
4280                         ret = bt_adapter_stop_device_discovery();
4281                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4282                         break;
4283                 case BT_UNIT_TEST_FUNCTION_ADAPTER_IS_DISCOVERING: {
4284                         bool is_discovering = FALSE;
4285                         ret = bt_adapter_is_discovering(&is_discovering);
4286                         if (ret < BT_ERROR_NONE)
4287                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
4288                         else
4289                                 TC_PRT("is_discovering: %d", is_discovering);
4290
4291                         break;
4292                 }
4293                 case BT_UNIT_TEST_FUNCTION_ADAPTER_FOREACH_BONDED_DEVICE: {
4294                         ret = bt_adapter_foreach_bonded_device(
4295                                 __bt_adapter_bonded_device_cb, NULL);
4296                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4297                         break;
4298                 }
4299                 case BT_UNIT_TEST_FUNCTION_ADAPTER_FOREACH_PROFILE_CONNECTED_DEVICES: {
4300                         ret = bt_adapter_foreach_profile_connected_devices(BT_PROFILE_SERVICE_UUID_SPP,
4301                                 __bt_adapter_profile_connected_devices_cb, NULL);
4302                         TC_PRT("SPP connected devices returns %s\n", __bt_get_error_message(ret));
4303                         ret = bt_adapter_foreach_profile_connected_devices(BT_PROFILE_SERVICE_UUID_HFP_HF,
4304                                 __bt_adapter_profile_connected_devices_cb, NULL);
4305                         TC_PRT("HFP HF connected devices returns %s\n", __bt_get_error_message(ret));
4306                         ret = bt_adapter_foreach_profile_connected_devices(BT_PROFILE_SERVICE_UUID_A2DP_SOURCE,
4307                                 __bt_adapter_profile_connected_devices_cb, NULL);
4308                         TC_PRT("A2DP Source connected devices returns %s\n", __bt_get_error_message(ret));
4309                         ret = bt_adapter_foreach_profile_connected_devices(BT_PROFILE_SERVICE_UUID_A2DP_SINK,
4310                                 __bt_adapter_profile_connected_devices_cb, NULL);
4311                         TC_PRT("A2DP Sink connected devices returns %s\n", __bt_get_error_message(ret));
4312                         ret = bt_adapter_foreach_profile_connected_devices(BT_PROFILE_SERVICE_UUID_AVRCP_CONTROL,
4313                                 __bt_adapter_profile_connected_devices_cb, NULL);
4314                         TC_PRT("AVRCP Control connected devices returns %s\n", __bt_get_error_message(ret));
4315                         ret = bt_adapter_foreach_profile_connected_devices(BT_PROFILE_SERVICE_UUID_AVRCP_TARGET,
4316                                 __bt_adapter_profile_connected_devices_cb, NULL);
4317                         TC_PRT("AVRCP Target connected devices returns %s\n", __bt_get_error_message(ret));
4318                         break;
4319                 }
4320                 case BT_UNIT_TEST_FUNCTION_ADAPTER_GET_BONDED_DEVICE_INFO: {
4321                         bt_device_info_s *device_info = NULL;
4322                         int i;
4323                         char *str = NULL;
4324
4325                         ret = bt_adapter_get_bonded_device_info(remote_addr,
4326                                                                 &device_info);
4327                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4328
4329                         if (device_info) {
4330                                 TC_PRT("address: %s", device_info->remote_address);
4331                                 TC_PRT("name: %s", device_info->remote_name);
4332                                 TC_PRT("is_connected: %d", device_info->is_connected);
4333                                 TC_PRT("is_authorized: %d", device_info->is_authorized);
4334                                 TC_PRT("service 0x%x, major 0x%x, minor 0x%x", device_info->bt_class.major_service_class_mask,
4335                                                 device_info->bt_class.major_device_class,
4336                                                 device_info->bt_class.minor_device_class);
4337
4338                                 TC_PRT("service_count: %d", device_info->service_count);
4339                                 if (device_info->service_uuid == NULL) {
4340                                         TC_PRT("No uuids");
4341                                 } else {
4342                                         for (i = 0; i < device_info->service_count; i++) {
4343                                                 bt_get_uuid_name(device_info->service_uuid[i], &str);
4344
4345                                                 TC_PRT("[%d / %d] %s (%s)", i, device_info->service_count,
4346                                                         str ? str : "Unknown", device_info->service_uuid[i]);
4347                                                 g_free(str);
4348                                         }
4349                                 }
4350
4351                                 if (device_info->manufacturer_data_len > 0) {
4352                                         TC_PRT("manufacturer specific data(len:%d)",
4353                                                 device_info->manufacturer_data_len);
4354                                         printf("data [");
4355                                         for (i = 0; i < device_info->manufacturer_data_len; i++)
4356                                                 printf("%02x ", device_info->manufacturer_data[i]);
4357                                         printf("]\n");
4358                                 }
4359                                 printf("\n");
4360                         }
4361
4362                         bt_adapter_free_device_info(device_info);
4363                         break;
4364                 }
4365                 case BT_UNIT_TEST_FUNCTION_ADAPTER_IS_SERVICE_USED: {
4366                         bool used = FALSE;
4367
4368                         ret = bt_adapter_is_service_used(opp_uuid, &used);
4369                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4370                         TC_PRT("used: %d", used);
4371                         break;
4372                 }
4373                 case BT_UNIT_TEST_FUNCTION_ADAPTER_GET_VISIBILITY: {
4374                         bt_adapter_visibility_mode_e visibility_mode = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE;
4375                         int time = 0;
4376
4377                         ret = bt_adapter_get_visibility(&visibility_mode, &time);
4378                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4379                         TC_PRT("mode: %d", visibility_mode);
4380                         TC_PRT("time: %d", time);
4381                         break;
4382                 }
4383                 case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_VISIBILITY: {
4384                         int mode = BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE;
4385                         int timeout_sec = 0;
4386
4387                         if (g_test_param.param_count > 0) {
4388                                 if (g_test_param.params[0][0] == '-')
4389                                         mode = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE;
4390                                 else if (g_test_param.params[0][0] == '0')
4391                                         mode = BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE;
4392                                 else {
4393                                         mode = BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE;
4394                                         timeout_sec = atoi(g_test_param.params[0]);
4395                                 }
4396                                 __bt_free_test_param(&g_test_param);
4397                         }
4398
4399                         ret = bt_adapter_set_visibility(mode, timeout_sec);
4400                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4401                         break;
4402                 }
4403                 case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_DEVICE_DISCOVERY_STATE_CHANGED_CB:
4404                         ret = bt_adapter_set_device_discovery_state_changed_cb(
4405                                 __bt_adapter_device_discovery_state_changed_cb, NULL);
4406                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4407                         break;
4408                 case BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_DEVICE_DISCOVERY_STATE_CHANGED_CB:
4409                         ret = bt_adapter_unset_device_discovery_state_changed_cb();
4410                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4411                         break;
4412
4413                 case BT_UNIT_TEST_FUNCTION_ADAPTER_GET_LOCAL_OOB_DATA: {
4414                         ret = bt_adapter_get_local_oob_data(&hash, &randomizer,
4415                                 &hash_len, &rand_len);
4416                         if (ret < BT_ERROR_NONE) {
4417                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
4418                         } else {
4419                                 TC_PRT("hash = [%s]", hash);
4420                                 TC_PRT("randomizer = [%s]", randomizer);
4421                         }
4422                         break;
4423                 }
4424
4425                 case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_REMOTE_OOB_DATA: {
4426                         ret = bt_adapter_set_remote_oob_data(remote_addr, hash,
4427                                 randomizer, hash_len, rand_len);
4428                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4429                         break;
4430                 }
4431                 case BT_UNIT_TEST_FUNCTION_ADAPTER_GET_LOCAL_OOB_EXT_DATA: {
4432                         unsigned char *data[4];
4433                         int len[4];
4434                         int i;
4435
4436                         ret = bt_adapter_get_local_oob_ext_data(
4437                                         &data[0], &data[1], &len[0], &len[1],
4438                                         &data[2], &data[3], &len[2], &len[3]);
4439                         if (ret < BT_ERROR_NONE) {
4440                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
4441                         } else {
4442                                 for (i = 0; i < 4; i++) {
4443                                         int j;
4444
4445                                         printf("Data[%d] : ", i);
4446
4447                                         for (j = 0; j < len[i]; j++)
4448                                                 printf("%02x", data[i][j]);
4449
4450                                         printf("\n");
4451
4452                                         g_free(data[i]);
4453                                 }
4454                         }
4455                         break;
4456                 }
4457                 case BT_UNIT_TEST_FUNCTION_ADAPTER_READ_BATTERY_INFO: {
4458                         bt_battery_info_s battery_data;
4459                         memset(&battery_data, 0, sizeof(bt_battery_info_s));
4460                         ret = bt_adapter_read_battery_info(&battery_data);
4461                         if (ret < 0) {
4462                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
4463                         } else {
4464                                 TC_PRT("Battery data: %ld %ld %d %d", battery_data.session_start_time,
4465                                         battery_data.session_end_time, battery_data.session_scan_time, battery_data.session_connected_time);
4466
4467                                 TC_PRT("Tx time [%d], Rx time [%d], Idle time [%d]", battery_data.tx_time,
4468                                         battery_data.rx_time, battery_data.idle_time);
4469
4470                                 if(battery_data.atm_list == NULL) {
4471                                         TC_PRT("No data transaction in this session");
4472                                         break;
4473                                 }
4474
4475                                 TC_PRT("Displaying app-wise transaction details");
4476                                 for (GSList *l = battery_data.atm_list; l != NULL; l = g_slist_next(l)) {
4477                                         bt_battery_app_info_s *t = (bt_battery_app_info_s *)(l->data);
4478                                         TC_PRT("uid: %ld, pid: %ld, received bytes: %d, sent bytes: %d, time: %u",
4479                                                 (long int)(t->uid), (long int)(t->pid), t->rx_bytes, t->tx_bytes, t->time);
4480                                 }
4481                         }
4482                         break;
4483                 }
4484                 case BT_UNIT_TEST_FUNCTION_ADAPTER_INIT_BATTERY_MONITOR: {
4485                         int ret = bt_adapter_init_battery_monitor(__bt_adapter_disable_battery_cb, NULL);
4486                         if (ret == BLUETOOTH_ERROR_NONE)
4487                                 TC_PRT("Battery monitor initialized and activated");
4488                         else
4489                                 TC_PRT("Battery monitor could not be initialized and activated");
4490                         break;
4491                 }
4492                 case BT_UNIT_TEST_FUNCTION_ADAPTER_DEINIT_BATTERY_MONITOR: {
4493                         int ret = bt_adapter_deinit_battery_monitor();
4494                         if (ret == BLUETOOTH_ERROR_NONE)
4495                                 TC_PRT("Battery monitor deinitialized successfully");
4496                         else
4497                                 TC_PRT("Battery monitor could not be deinitialized");
4498                         break;
4499                 }
4500                 case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_REMOTE_OOB_EXT_DATA: {
4501                         char remote_addr[18];
4502                         unsigned char *param_data[4];
4503                         int len[4];
4504                         int i;
4505                         char tmp[3];
4506                         long val;
4507
4508                         if (g_test_param.param_count != 5) {
4509                                 TC_PRT("Input parameter first!");
4510                                 break;
4511                         }
4512
4513                         g_strlcpy(remote_addr, g_test_param.params[0],
4514                                         sizeof(remote_addr));
4515
4516                         for (i = 0; i < 4; i++) {
4517                                 len[i] = strlen(g_test_param.params[i + 1]) / 2;
4518                                 param_data[i] = g_malloc0(len[i]);
4519                         }
4520
4521                         for (i = 0; i < 4; i++) {
4522                                 int j;
4523
4524                                 printf("param_data[%d] : ", i);
4525                                 for (j = 0; j < len[i]; j++) {
4526                                         g_strlcpy(tmp, g_test_param.params[i + 1] + 2 * j, sizeof(tmp));
4527                                         val = strtol(tmp, NULL, 16);
4528                                         param_data[i][j] = val;
4529                                         printf("%02x", param_data[i][j]);
4530                                 }
4531                                 printf("\n");
4532                         }
4533
4534                         ret = bt_adapter_set_remote_oob_ext_data(remote_addr,
4535                                         param_data[0], param_data[1], len[0], len[1],
4536                                         param_data[2], param_data[3], len[2], len[3]);
4537
4538                         __bt_free_test_param(&g_test_param);
4539
4540                         for (i = 0; i < 4; i++)
4541                                 g_free(param_data[i]);
4542
4543                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4544                         break;
4545                 }
4546
4547                 case BT_UNIT_TEST_FUNCTION_ADAPTER_REMOVE_REMOTE_OOB_DATA: {
4548                         ret = bt_adapter_remove_remote_oob_data(remote_addr);
4549                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4550                         break;
4551                 }
4552
4553                 case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_VISIBILITY_MODE_CHANGED_CB:
4554                         ret = bt_adapter_set_visibility_mode_changed_cb(
4555                                 __bt_adapter_device_visibility_mode_changed_cb, NULL);
4556                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4557                         break;
4558                 case BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_VISIBILITY_MODE_CHANGED_CB:
4559                         ret = bt_adapter_unset_visibility_mode_changed_cb();
4560                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4561                         break;
4562
4563                 case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_VISIBILITY_DURATION_CHANGED_CB:
4564                         ret = bt_adapter_set_visibility_duration_changed_cb(
4565                                         __bt_adapter_device_visibility_duration_changed_cb, NULL);
4566                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4567                         break;
4568                 case BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_VISIBILITY_DURATION_CHANGED_CB:
4569                         ret = bt_adapter_unset_visibility_duration_changed_cb();
4570                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4571                         break;
4572
4573                 case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_CONNECTABLE_CHANGED_CB: {
4574                         ret = bt_adapter_set_connectable_changed_cb(
4575                                 __bt_adapter_connectable_changed_cb, NULL);
4576                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4577                         break;
4578                 }
4579
4580                 case BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_CONNECTABLE_CHANGED_CB: {
4581                         ret = bt_adapter_unset_connectable_changed_cb();
4582                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4583                         break;
4584                 }
4585
4586                 case BT_UNIT_TEST_FUNCTION_ADAPTER_GET_CONNECTABLE: {
4587                         bool connectable = false;
4588
4589                         ret = bt_adapter_get_connectable(&connectable);
4590                         if (ret < BT_ERROR_NONE) {
4591                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
4592                                 break;
4593                         }
4594
4595                         TC_PRT("%s", connectable ? "Connectable" : "Non-connectable");
4596                         break;
4597                 }
4598
4599                 case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_CONNECTABLE: {
4600                         bool connectable = false;
4601
4602                         bt_adapter_get_connectable(&connectable);
4603
4604                         if (g_test_param.param_count > 0) {
4605                                 if (g_strrstr(g_test_param.params[0], "true"))
4606                                         connectable = true;
4607                                 else
4608                                         connectable = false;
4609
4610                                 __bt_free_test_param(&g_test_param);
4611                         }
4612
4613                         ret = bt_adapter_set_connectable(!connectable);
4614                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4615                         break;
4616                 }
4617
4618                 case BT_UNIT_TEST_FUNCTION_ADAPTER_GET_VERSION: {
4619                         char *version = NULL;
4620
4621                         ret = bt_adapter_get_version(&version);
4622                         if (ret < BT_ERROR_NONE)
4623                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
4624                         else {
4625                                 TC_PRT("Version: [%s]", version);
4626                                 g_free(version);
4627                         }
4628                         break;
4629                 }
4630
4631                 case BT_UNIT_TEST_FUNCTION_ADAPTER_GET_LOCAL_INFO: {
4632                         char *chipset = NULL;
4633                         char *firmware = NULL;
4634                         char *stack_version = NULL;
4635                         char *profiles = NULL;
4636
4637                         ret = bt_adapter_get_local_info(&chipset, &firmware,
4638                                 &stack_version, &profiles);
4639                         if (ret < BT_ERROR_NONE)
4640                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
4641                         else {
4642                                 TC_PRT("Local info: [%s, %s, %s]", chipset, firmware, stack_version);
4643                                 TC_PRT("Local info(Profiles):\n%s", profiles);
4644                                 g_free(chipset);
4645                                 g_free(firmware);
4646                                 g_free(stack_version);
4647                                 g_free(profiles);
4648                         }
4649                         break;
4650                 }
4651
4652                 case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_MANUFACTURER_DATA_CHANGED_CB:
4653                 {
4654                         ret = bt_adapter_set_manufacturer_data_changed_cb(
4655                                 __bt_adapter_manufacturer_data_changed_cb, NULL);
4656                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4657                         break;
4658                 }
4659
4660                 case BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_MANUFACTURER_DATA_CHANGED_CB:
4661                         ret = bt_adapter_unset_manufacturer_data_changed_cb();
4662                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4663                         break;
4664
4665                 case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_MANUFACTURER_DATA:
4666                 {
4667                         char param_data[20] = {0x03, 0xFF, 0x01, 0x02};
4668                         int len = 4;
4669                         int i = 0;
4670
4671                         if (g_test_param.param_count > 0) {
4672                                 len = 0;
4673                                 for (i = 0; i < (strlen(g_test_param.params[0]) - 1); i += 2) {
4674                                         if (g_test_param.params[0][i] >= 'A' && g_test_param.params[0][i] <= 'F')
4675                                                 param_data[i/2] = (g_test_param.params[0][i] - 'A' + 0X0A) << 4;
4676                                         else
4677                                                 param_data[i/2] = (g_test_param.params[0][i] - '0') << 4;
4678
4679                                         if (g_test_param.params[0][i+1] >= 'A' && g_test_param.params[0][i+1] <= 'F')
4680                                                 param_data[i/2] += (g_test_param.params[0][i+1] - 'A' + 0X0A);
4681                                         else
4682                                                 param_data[i/2] += (g_test_param.params[0][i+1] - '0');
4683                                         len++;
4684                                 }
4685
4686                                 __bt_free_test_param(&g_test_param);
4687                         }
4688
4689                         ret = bt_adapter_set_manufacturer_data(param_data, len);
4690
4691                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4692                         break;
4693                 }
4694                 case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_AUTHENTICATION_REQUSET_CB:
4695                 {
4696                         ret = bt_adapter_set_authentication_req_cb(
4697                                 __bt_adapter_authentication_req_cb, NULL);
4698                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4699                         break;
4700                 }
4701                 case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_AUTHENTICATION_REQUEST_CB_NEW:
4702                 {
4703                         ret = bt_adapter_set_authentication_request_cb(
4704                                 __bt_adapter_authentication_request_cb, NULL);
4705                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4706                         break;
4707                 }
4708                 case BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_AUTHENTICATION_REQUSET_CB:
4709                 {
4710                         ret = bt_adapter_unset_authentication_req_cb();
4711                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4712                         break;
4713                 }
4714                 case BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_AUTHENTICATION_REQUEST_CB_NEW:
4715                 {
4716                         ret = bt_adapter_unset_authentication_request_cb();
4717                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4718                         break;
4719                 }
4720                 case BT_UNIT_TEST_FUNCTION_ADAPTER_PASSKEY_REPLY_ACCEPT:
4721                 {
4722                         char *passkey = NULL;
4723                         TC_PRT("bt_adapter_passkey_reply: Authenticate Logitech Mouse: reply = Accept");
4724                         passkey = g_strdup("0000"); /* Passkey - "0000" for mouse */
4725                         ret = bt_adapter_passkey_reply(passkey, TRUE);
4726                         if (ret < BT_ERROR_NONE)
4727                                 TC_PRT("failed with [0x%04x]", ret);
4728                         else
4729                                 TC_PRT("bt_adapter_passkey_reply: accept authentication result = %d", ret);
4730                         g_free(passkey);
4731                         break;
4732                 }
4733                 case BT_UNIT_TEST_FUNCTION_ADAPTER_PASSKEY_REPLY_CANCEL:
4734                 {
4735                         char *passkey = NULL;
4736                         TC_PRT("bt_adapter_passkey_reply: cancel authentication reply");
4737                         passkey = g_strdup("0000"); /* Passkey - "0000" */
4738                         ret = bt_adapter_passkey_reply(passkey, FALSE);
4739                         if (ret < BT_ERROR_NONE)
4740                                 TC_PRT("failed with [0x%04x]", ret);
4741                         else
4742                                 TC_PRT("bt_adapter_passkey_reply: Logitech Mouse cancel authentication result = %d", ret);
4743                         g_free(passkey);
4744                         break;
4745                 }
4746                 case BT_UNIT_TEST_FUNCTION_ADAPTER_PASSKEY_CONFIRMATION_REPLY_ACCEPT:
4747                 {
4748                         ret = bt_adapter_passkey_confirmation_reply(TRUE);
4749                         if (ret < BT_ERROR_NONE)
4750                                 TC_PRT("failed with [0x%04x]", ret);
4751                         else
4752                                 TC_PRT("bt_adapter_passkey_confirmation_reply accept, result = %d", ret);
4753                         break;
4754                 }
4755                 case BT_UNIT_TEST_FUNCTION_ADAPTER_PASSKEY_CONFIRMATION_REPLY_REJECT:
4756                 {
4757                         ret = bt_adapter_passkey_confirmation_reply(FALSE);
4758                         if (ret < BT_ERROR_NONE)
4759                                 TC_PRT("failed with [0x%04x]", ret);
4760                         else
4761                                 TC_PRT("bt_adapter_passkey_confirmation_reply reject, result = %d", ret);
4762                         break;
4763                 }
4764                 case BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS:
4765                         need_to_set_params = true;
4766                         TC_PRT("Select the function again");
4767                         break;
4768
4769                 default:
4770                         break;
4771                 }
4772
4773                 break;
4774         }
4775
4776         case BT_UNIT_TEST_TABLE_ADAPTER_LE: {
4777                 switch (test_id) {
4778                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_GET_STATE: {
4779                         bt_adapter_le_state_e le_state = BT_ADAPTER_LE_DISABLED;
4780
4781                         ret = bt_adapter_le_get_state(&le_state);
4782                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4783                         TC_PRT("le_state: %d", le_state);
4784                         break;
4785                 }
4786
4787                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_ENABLE: {
4788                         ret = bt_adapter_le_enable();
4789                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4790                         break;
4791                 }
4792
4793                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_DISABLE: {
4794                         ret = bt_adapter_le_disable();
4795                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4796                         break;
4797                 }
4798
4799                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_SET_SCAN_MODE: {
4800                         int mode = BT_ADAPTER_LE_SCAN_MODE_BALANCED;
4801
4802                         if (g_test_param.param_count > 0) {
4803                                 mode = atoi(g_test_param.params[0]);
4804                                 __bt_free_test_param(&g_test_param);
4805                         }
4806
4807                         ret = bt_adapter_le_set_scan_mode(mode);
4808                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4809                         break;
4810                 }
4811                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_SET_SCAN_TYPE: {
4812                         int type = BT_ADAPTER_LE_PASSIVE_SCAN;
4813
4814                         if (g_test_param.param_count > 0) {
4815                                 type = atoi(g_test_param.params[0]);
4816                                 __bt_free_test_param(&g_test_param);
4817                         }
4818
4819                         ret = bt_adapter_le_set_scan_type(type);
4820                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4821                         break;
4822                 }
4823
4824                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_START_SCAN: {
4825                         ret = bt_adapter_le_start_scan(
4826                                 __bt_adapter_le_scan_result_cb, NULL);
4827                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4828                         break;
4829                 }
4830
4831                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_STOP_SCAN: {
4832                         ret = bt_adapter_le_stop_scan();
4833                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
4834
4835                         GSList *l = NULL;
4836                         int cnt = 0;
4837                         bt_adapter_le_device_scan_result_info_s *info;
4838                         printf("LE scan result :\n");
4839                         for (l = le_scan_list; l != NULL; l = g_slist_next(l)) {
4840                                 info = l->data;
4841                                 if (info) {
4842                                         printf("[%d] %s, %d dBm", ++cnt, info->remote_address, info->rssi);
4843                                         if (info->adv_data)
4844                                                 printf(", %s", info->adv_data);
4845                                         printf("\n");
4846                                         g_free(info->remote_address);
4847                                         g_free(info->adv_data);
4848                                         g_free(info);
4849                                 }
4850                         }
4851                         g_slist_free(le_scan_list);
4852                         le_scan_list = NULL;
4853
4854                         break;
4855                 }
4856
4857                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_ADD_ADVERTISING_DATA: {
4858                         int adv_data_type = 3; /* default all */
4859                         int manufacturer_id = 117;
4860                         char *manufacture = NULL;
4861                         char manufacture_0[] = {0x0, 0x0, 0x0, 0x0};
4862                         char manufacture_1[] = {0x01, 0x01, 0x01, 0x01};
4863                         char manufacture_2[] = {0x02, 0x02, 0x02, 0x02};
4864                         char manufacture_3[] = {0x03, 0x03, 0x03, 0x03};
4865                         char service_data[] = {0x01, 0x02, 0x03};
4866                         const char *time_svc_uuid_16 = "1805";
4867                         const char *battery_svc_uuid_16 = "180f";
4868                         const char *heart_rate_svc_uuid_16 = "180d";
4869                         const char *lmmediate_alert_svc_uuid_16 = "1802";
4870                         const char *ancs_uuid_128 = "7905F431-B5CE-4E99-A40F-4B1E122D00D0";
4871                         const char *ams_uuid_128 = "89D3502B-0F36-433A-8EF4-C502AD55F8DC";
4872                         int appearance = 192;  /* 192 is generic watch */
4873
4874                         advertiser = advertiser_list[advertiser_index];
4875
4876                         if (advertiser == NULL) {
4877                                 ret = bt_adapter_le_create_advertiser(&advertiser);
4878                                 TC_PRT("created le advertiser(%d)", ret);
4879                                 advertiser_list[advertiser_index] = advertiser;
4880                         } else {
4881                                 ret = bt_adapter_le_clear_advertising_data(advertiser,
4882                                         BT_ADAPTER_LE_PACKET_ADVERTISING);
4883                                 if (ret != BT_ERROR_NONE)
4884                                         TC_PRT("clear advertising data [0x%04x]", ret);
4885                                 ret = bt_adapter_le_clear_advertising_data(advertiser,
4886                                         BT_ADAPTER_LE_PACKET_SCAN_RESPONSE);
4887                                 if (ret != BT_ERROR_NONE)
4888                                         TC_PRT("clear scan response data [0x%04x]", ret);
4889                         }
4890
4891                         if (g_test_param.param_count > 0) {
4892                                 adv_data_type = atoi(g_test_param.params[0]);
4893                                 __bt_free_test_param(&g_test_param);
4894                         }
4895
4896                         switch (adv_data_type) {
4897                         case 0: /* service uuid */
4898                                 ret = bt_adapter_le_add_advertising_service_uuid(advertiser,
4899                                                 BT_ADAPTER_LE_PACKET_ADVERTISING, time_svc_uuid_16);
4900                                 if (ret != BT_ERROR_NONE)
4901                                         TC_PRT("add service_uuid [0x%04x]", ret);
4902
4903                                 ret = bt_adapter_le_add_advertising_service_uuid(advertiser,
4904                                                 BT_ADAPTER_LE_PACKET_ADVERTISING, battery_svc_uuid_16);
4905                                 if (ret != BT_ERROR_NONE)
4906                                         TC_PRT("add service_uuid [0x%04x]", ret);
4907
4908                                 manufacture = manufacture_0;
4909                                 break;
4910
4911                         case 1: /* service solicitation */
4912                                 ret = bt_adapter_le_add_advertising_service_solicitation_uuid(advertiser,
4913                                                 BT_ADAPTER_LE_PACKET_ADVERTISING, heart_rate_svc_uuid_16);
4914                                 if (ret != BT_ERROR_NONE)
4915                                         TC_PRT("add service_solicitation_uuid [0x%04x]", ret);
4916
4917                                 ret = bt_adapter_le_add_advertising_service_solicitation_uuid(advertiser,
4918                                                 BT_ADAPTER_LE_PACKET_ADVERTISING, lmmediate_alert_svc_uuid_16);
4919                                 if (ret != BT_ERROR_NONE)
4920                                         TC_PRT("add service_solicitation_uuid [0x%04x]", ret);
4921
4922                                 manufacture = manufacture_1;
4923                                 break;
4924
4925                         case 2: /* appearance & tx power level */
4926                                 ret = bt_adapter_le_set_advertising_appearance(advertiser,
4927                                         BT_ADAPTER_LE_PACKET_ADVERTISING, appearance);
4928                                 if (ret != BT_ERROR_NONE)
4929                                         TC_PRT("add appearance data [0x%04x]", ret);
4930
4931                                 ret = bt_adapter_le_set_advertising_tx_power_level(advertiser,
4932                                         BT_ADAPTER_LE_PACKET_ADVERTISING, true);
4933                                 if (ret != BT_ERROR_NONE)
4934                                         TC_PRT("add appearance data [0x%04x]", ret);
4935                                 manufacture = manufacture_2;
4936                                 break;
4937
4938                         case 3: /* All */
4939                                 ret = bt_adapter_le_add_advertising_service_uuid(advertiser,
4940                                                 BT_ADAPTER_LE_PACKET_ADVERTISING, time_svc_uuid_16);
4941                                 if (ret != BT_ERROR_NONE)
4942                                         TC_PRT("add service_uuid [0x%04x]", ret);
4943
4944                                 ret = bt_adapter_le_add_advertising_service_uuid(advertiser,
4945                                                 BT_ADAPTER_LE_PACKET_ADVERTISING, battery_svc_uuid_16);
4946                                 if (ret != BT_ERROR_NONE)
4947                                         TC_PRT("add service_uuid [0x%04x]", ret);
4948
4949                                 ret = bt_adapter_le_add_advertising_service_solicitation_uuid(advertiser,
4950                                                 BT_ADAPTER_LE_PACKET_ADVERTISING, heart_rate_svc_uuid_16);
4951                                 if (ret != BT_ERROR_NONE)
4952                                         TC_PRT("add service_solicitation_uuid [0x%04x]", ret);
4953
4954                                 ret = bt_adapter_le_add_advertising_service_solicitation_uuid(advertiser,
4955                                                 BT_ADAPTER_LE_PACKET_ADVERTISING, lmmediate_alert_svc_uuid_16);
4956                                 if (ret != BT_ERROR_NONE)
4957                                         TC_PRT("add service_solicitation_uuid [0x%04x]", ret);
4958
4959                                 ret = bt_adapter_le_set_advertising_appearance(advertiser,
4960                                         BT_ADAPTER_LE_PACKET_ADVERTISING, appearance);
4961                                 if (ret != BT_ERROR_NONE)
4962                                         TC_PRT("add appearance data [0x%04x]", ret);
4963
4964                                 ret = bt_adapter_le_set_advertising_tx_power_level(advertiser,
4965                                         BT_ADAPTER_LE_PACKET_ADVERTISING, true);
4966                                 if (ret != BT_ERROR_NONE)
4967                                         TC_PRT("add tx_power_level [0x%04x]", ret);
4968
4969                                 manufacture = manufacture_3;
4970                                 break;
4971
4972                         case 4: /* ANCS */
4973                                 ret = bt_adapter_le_add_advertising_service_solicitation_uuid(advertiser,
4974                                                 BT_ADAPTER_LE_PACKET_ADVERTISING, time_svc_uuid_16);
4975                                 if (ret != BT_ERROR_NONE)
4976                                         TC_PRT("add service_solicitation_uuid [0x%04x]", ret);
4977
4978                                 ret = bt_adapter_le_add_advertising_service_solicitation_uuid(advertiser,
4979                                                 BT_ADAPTER_LE_PACKET_ADVERTISING, ancs_uuid_128);
4980                                 if (ret != BT_ERROR_NONE)
4981                                         TC_PRT("add service_solicitation_uuid [0x%04x]", ret);
4982
4983                                 ret = bt_adapter_le_set_advertising_device_name(advertiser,
4984                                         BT_ADAPTER_LE_PACKET_SCAN_RESPONSE, true);
4985                                 if (ret != BT_ERROR_NONE)
4986                                         TC_PRT("set device name [0x%04x]", ret);
4987
4988                                 return 0;
4989
4990                         case 5: /* AMS */
4991                                 ret = bt_adapter_le_add_advertising_service_solicitation_uuid(advertiser,
4992                                                 BT_ADAPTER_LE_PACKET_ADVERTISING, time_svc_uuid_16);
4993                                 if (ret != BT_ERROR_NONE)
4994                                         TC_PRT("add service_solicitation_uuid [0x%04x]", ret);
4995
4996                                 ret = bt_adapter_le_add_advertising_service_solicitation_uuid(advertiser,
4997                                                 BT_ADAPTER_LE_PACKET_ADVERTISING, ams_uuid_128);
4998                                 if (ret != BT_ERROR_NONE)
4999                                         TC_PRT("add service_solicitation_uuid [0x%04x]", ret);
5000
5001                                 ret = bt_adapter_le_set_advertising_device_name(advertiser,
5002                                         BT_ADAPTER_LE_PACKET_SCAN_RESPONSE, true);
5003                                 if (ret != BT_ERROR_NONE)
5004                                         TC_PRT("set device name [0x%04x]", ret);
5005
5006                                 return 0;
5007
5008                         default:
5009                                 TC_PRT("No adv data");
5010                                 break;
5011                         }
5012
5013                         /* Default scsn response data */
5014                         ret = bt_adapter_le_add_advertising_service_data(advertiser,
5015                                 BT_ADAPTER_LE_PACKET_SCAN_RESPONSE, time_svc_uuid_16,
5016                                 service_data, sizeof(service_data));
5017                         if (ret != BT_ERROR_NONE)
5018                                 TC_PRT("add service_data [0x%04x]", ret);
5019
5020                         ret = bt_adapter_le_set_advertising_device_name(advertiser,
5021                                 BT_ADAPTER_LE_PACKET_SCAN_RESPONSE, true);
5022                         if (ret != BT_ERROR_NONE)
5023                                 TC_PRT("set device name [0x%04x]", ret);
5024
5025                         ret = bt_adapter_le_add_advertising_manufacturer_data(advertiser,
5026                                 BT_ADAPTER_LE_PACKET_SCAN_RESPONSE,
5027                                 manufacturer_id,
5028                                 manufacture, sizeof(manufacture_0));
5029                         if (ret != BT_ERROR_NONE)
5030                                 TC_PRT("add manufacturer data [0x%04x]", ret);
5031
5032                         break;
5033                 }
5034                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_ADD_HOGP_ADVERTISING_DATA: {
5035                         const char *battery_svc_uuid_16 = "180f";
5036                         const char *hid_svc_uuid_16 = "1812";
5037                         const char *gatt_svc_uuid_16 = "1801";
5038                         int appearance = 192;  /* 192 is generic watch */
5039
5040                         advertiser = advertiser_list[advertiser_index];
5041
5042                         if (advertiser == NULL) {
5043                                 ret = bt_adapter_le_create_advertiser(&advertiser);
5044                                 TC_PRT("created le advertiser(%d)", ret);
5045                                 advertiser_list[advertiser_index] = advertiser;
5046                         } else {
5047                                 ret = bt_adapter_le_clear_advertising_data(advertiser,
5048                                         BT_ADAPTER_LE_PACKET_ADVERTISING);
5049                                 if (ret != BT_ERROR_NONE)
5050                                         TC_PRT("clear advertising data [0x%04x]", ret);
5051                                 ret = bt_adapter_le_clear_advertising_data(advertiser,
5052                                         BT_ADAPTER_LE_PACKET_SCAN_RESPONSE);
5053                                 if (ret != BT_ERROR_NONE)
5054                                         TC_PRT("clear scan response data [0x%04x]", ret);
5055                         }
5056
5057                         ret = bt_adapter_le_add_advertising_service_uuid(advertiser,
5058                                         BT_ADAPTER_LE_PACKET_ADVERTISING, battery_svc_uuid_16);
5059                         if (ret != BT_ERROR_NONE)
5060                                 TC_PRT("add service_uuid [0x%04x]", ret);
5061
5062                         ret = bt_adapter_le_add_advertising_service_uuid(advertiser,
5063                                         BT_ADAPTER_LE_PACKET_ADVERTISING, hid_svc_uuid_16);
5064                         if (ret != BT_ERROR_NONE)
5065                                 TC_PRT("add service_uuid [0x%04x]", ret);
5066
5067                         ret = bt_adapter_le_add_advertising_service_uuid(advertiser,
5068                                         BT_ADAPTER_LE_PACKET_ADVERTISING, gatt_svc_uuid_16);
5069                         if (ret != BT_ERROR_NONE)
5070                                 TC_PRT("add service_uuid [0x%04x]", ret);
5071
5072                         ret = bt_adapter_le_set_advertising_appearance(advertiser,
5073                                 BT_ADAPTER_LE_PACKET_ADVERTISING, appearance);
5074                         if (ret != BT_ERROR_NONE)
5075                                 TC_PRT("add appearance data [0x%04x]", ret);
5076
5077                         ret = bt_adapter_le_set_advertising_tx_power_level(advertiser,
5078                                 BT_ADAPTER_LE_PACKET_ADVERTISING, true);
5079                         if (ret != BT_ERROR_NONE)
5080                                 TC_PRT("add tx_power_level [0x%04x]", ret);
5081
5082                         /* Default scsn response data */
5083                         ret = bt_adapter_le_set_advertising_device_name(advertiser,
5084                                 BT_ADAPTER_LE_PACKET_SCAN_RESPONSE, true);
5085                         if (ret != BT_ERROR_NONE)
5086                                 TC_PRT("set device name [0x%04x]", ret);
5087
5088                         break;
5089                 }
5090                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_SET_ADVERTISING_MODE: {
5091                         int mode = BT_ADAPTER_LE_ADVERTISING_MODE_BALANCED;
5092
5093                         advertiser = advertiser_list[advertiser_index];
5094
5095                         if (advertiser == NULL) {
5096                                 ret = bt_adapter_le_create_advertiser(&advertiser);
5097                                 TC_PRT("created le advertiser(%d)", ret);
5098                                 advertiser_list[advertiser_index] = advertiser;
5099                         }
5100
5101                         if (g_test_param.param_count > 0) {
5102                                 mode = atoi(g_test_param.params[0]);
5103                                 __bt_free_test_param(&g_test_param);
5104                         }
5105
5106                         ret = bt_adapter_le_set_advertising_mode(advertiser, mode);
5107                         if (ret != BT_ERROR_NONE)
5108                                 TC_PRT("add scan response data [0x%04x]", ret);
5109                         break;
5110                 }
5111                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_SET_ADVERTISING_FILTER_POLICY: {
5112                         int filter_policy = BT_ADAPTER_LE_ADVERTISING_FILTER_ALLOW_CONN_WL;
5113
5114                         advertiser = advertiser_list[advertiser_index];
5115
5116                         if (advertiser == NULL) {
5117                                 ret = bt_adapter_le_create_advertiser(&advertiser);
5118                                 TC_PRT("created le advertiser(%d)", ret);
5119                                 advertiser_list[advertiser_index] = advertiser;
5120                         }
5121
5122                         if (g_test_param.param_count > 0) {
5123                                 filter_policy = atoi(g_test_param.params[0]);
5124                                 __bt_free_test_param(&g_test_param);
5125                         }
5126
5127                         ret = bt_adapter_le_set_advertising_filter_policy(advertiser, filter_policy);
5128                         if (ret != BT_ERROR_NONE)
5129                                 TC_PRT("add scan response data [0x%04x]", ret);
5130                         break;
5131                 }
5132                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_SET_ADVERTISING_CONNECTABLE: {
5133                         int type = BT_ADAPTER_LE_ADVERTISING_CONNECTABLE;
5134
5135                         advertiser = advertiser_list[advertiser_index];
5136
5137                         if (advertiser == NULL) {
5138                                 ret = bt_adapter_le_create_advertiser(&advertiser);
5139                                 TC_PRT("created le advertiser(%d)", ret);
5140                                 advertiser_list[advertiser_index] = advertiser;
5141                         }
5142
5143                         if (g_test_param.param_count > 0) {
5144                                 type = atoi(g_test_param.params[0]);
5145                                 __bt_free_test_param(&g_test_param);
5146                         }
5147
5148                         ret = bt_adapter_le_set_advertising_connectable(advertiser, type);
5149                         if (ret != BT_ERROR_NONE)
5150                                 TC_PRT("add scan response data [0x%04x]", ret);
5151                         break;
5152                 }
5153                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_SET_ADVERTISING_CUSTOM_TX_POWER: {
5154                         int tx_power_level = 0;
5155
5156                         advertiser = advertiser_list[advertiser_index];
5157
5158                         if (advertiser == NULL) {
5159                                 ret = bt_adapter_le_create_advertiser(&advertiser);
5160                                 TC_PRT("created le advertiser(%d)", ret);
5161                                 advertiser_list[advertiser_index] = advertiser;
5162                         }
5163
5164                         if (g_test_param.param_count > 0) {
5165                                 tx_power_level = atoi(g_test_param.params[0]);
5166                                 __bt_free_test_param(&g_test_param);
5167                         }
5168
5169                         ret = bt_adapter_le_set_advertising_custom_tx_power_level(advertiser, tx_power_level);
5170                         if (ret != BT_ERROR_NONE)
5171                                 TC_PRT("set Tx power level [0x%04x]", ret);
5172                         break;
5173                 }
5174                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_START_ADVERTISING_NEW: {
5175                         bt_adapter_le_advertising_state_changed_cb cb;
5176
5177                         if (advertiser_index == 0) cb = __bt_adapter_le_advertising_state_changed_cb;
5178                         else if (advertiser_index == 1) cb = __bt_adapter_le_advertising_state_changed_cb_2;
5179                         else cb = __bt_adapter_le_advertising_state_changed_cb_3;
5180
5181                         advertiser = advertiser_list[advertiser_index];
5182                         advertiser_index++;
5183                         advertiser_index %= 3;
5184
5185                         if (advertiser == NULL) {
5186                                 ret = bt_adapter_le_create_advertiser(&advertiser);
5187                                 TC_PRT("created le advertiser(%d)", ret);
5188                                 advertiser_list[advertiser_index] = advertiser;
5189                         }
5190
5191                         TC_PRT("advertiser: %p", advertiser);
5192
5193                         ret = bt_adapter_le_start_advertising_new(advertiser, cb, NULL);
5194                         if (ret < BT_ERROR_NONE)
5195                                 TC_PRT("failed with [0x%04x]", ret);
5196                         break;
5197                 }
5198                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_STOP_ADVERTISING: {
5199                         int slot_id = 0;
5200
5201                         if (g_test_param.param_count > 0) {
5202                                 slot_id = atoi(g_test_param.params[0]);
5203                                 __bt_free_test_param(&g_test_param);
5204                         }
5205
5206                         if (slot_id < 0 ||
5207                                 slot_id >= (sizeof(advertiser_list) / sizeof(advertiser_list[0]))) {
5208                                 TC_PRT("wrong slot_id: %d", slot_id);
5209                                 break;
5210                         }
5211
5212                         advertiser = advertiser_list[slot_id];
5213
5214                         ret = bt_adapter_le_stop_advertising(advertiser);
5215                         if (ret < BT_ERROR_NONE)
5216                                         TC_PRT("failed with [0x%04x]", ret);
5217                         break;
5218                 }
5219                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_ADD_WHITE_LIST: {
5220                         ret = bt_adapter_le_add_white_list(remote_addr,
5221                                 BT_DEVICE_PUBLIC_ADDRESS);
5222                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5223                         break;
5224                 }
5225
5226                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_REMOVE_WHITE_LIST: {
5227                         ret = bt_adapter_le_remove_white_list(remote_addr,
5228                                 BT_DEVICE_PUBLIC_ADDRESS);
5229                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5230                         break;
5231                 }
5232
5233                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_ENABLE_PRIVACY: {
5234                         static bool enable_privacy = false;
5235
5236                         if (enable_privacy == false)
5237                                 enable_privacy = true;
5238                         else
5239                                 enable_privacy = false;
5240
5241                         if (g_test_param.param_count > 0) {
5242                                 if (g_strrstr(g_test_param.params[0], "true"))
5243                                         enable_privacy = true;
5244                                 else
5245                                         enable_privacy = false;
5246
5247                                 __bt_free_test_param(&g_test_param);
5248                         }
5249
5250                         ret = bt_adapter_le_enable_privacy(enable_privacy);
5251                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5252                         break;
5253                 }
5254
5255                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_GET_LOCAL_OOB_EXT_DATA: {
5256                         char *local_address;
5257                         bt_device_address_type_e address_type = 0;
5258                         unsigned char *confirm;
5259                         unsigned char *random;
5260                         int confirm_len;
5261                         int random_len;
5262                         int i;
5263
5264                         bt_adapter_le_get_local_oob_ext_data(&local_address, &address_type,
5265                                 &confirm, &random,
5266                                 &confirm_len, &random_len);
5267
5268                         printf("local address : %s\n", local_address);
5269                         printf("address type : %d\n", address_type);
5270                         printf("confirm : ");
5271                         for (i=0; i<confirm_len; i++)
5272                                 printf("%02x", confirm[i]);
5273                         printf("\nrandom : ");
5274                         for (i=0; i<random_len; i++)
5275                                 printf("%02x", random[i]);
5276                         printf("\n");
5277
5278                         g_free(local_address);
5279                         g_free(confirm);
5280                         g_free(random);
5281                         break;
5282                 }
5283
5284                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_SET_REMOTE_OOB_EXT_DATA: {
5285                         char remote_addr[18];
5286                         unsigned char *param_data[2];
5287                         int len[2];
5288                         int i;
5289                         char tmp[3];
5290                         long val;
5291                         bt_device_address_type_e addr_type = BT_DEVICE_PUBLIC_ADDRESS;
5292
5293                         if (g_test_param.param_count != 3) {
5294                                 TC_PRT("Input parameter first!");
5295                                 break;
5296                         }
5297
5298                         g_strlcpy(remote_addr, g_test_param.params[0],
5299                                         sizeof(remote_addr));
5300
5301                         for (i = 0; i < 2; i++) {
5302                                 len[i] = strlen(g_test_param.params[i + 1]) / 2;
5303                                 param_data[i] = g_malloc0(len[i]);
5304                         }
5305
5306                         for (i = 0; i < 2; i++) {
5307                                 int j;
5308
5309                                 printf("param_data[%d] : ", i);
5310                                 for (j = 0; j < len[i]; j++) {
5311                                         g_strlcpy(tmp, g_test_param.params[i + 1] + 2 * j, sizeof(tmp));
5312                                         val = strtol(tmp, NULL, 16);
5313                                         param_data[i][j] = val;
5314                                         printf("%02x", param_data[i][j]);
5315                                 }
5316                                 printf("\n");
5317                         }
5318
5319                         ret = bt_adapter_le_set_remote_oob_ext_data(remote_addr,
5320                                         addr_type,
5321                                         param_data[0], param_data[1], len[0], len[1]);
5322
5323                         __bt_free_test_param(&g_test_param);
5324
5325                         for (i = 0; i < 2; i++)
5326                                 g_free(param_data[i]);
5327
5328                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5329                         break;
5330                 }
5331
5332                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_REGISTER_SCAN_FILTER_DEVICE_ADDRESS: {
5333                         bt_scan_filter_h scan_filter;
5334
5335                         ret = bt_adapter_le_scan_filter_create(&scan_filter);
5336                         if (ret != BT_ERROR_NONE)
5337                                 TC_PRT("failed with [0x%04x]", ret);
5338
5339                         if (g_test_param.param_count > 0) {
5340                                 ret = bt_adapter_le_scan_filter_set_device_address(scan_filter, g_test_param.params[0]);
5341                                 __bt_free_test_param(&g_test_param);
5342                         } else {
5343                                 ret = bt_adapter_le_scan_filter_set_device_address(scan_filter, remote_addr);
5344                         }
5345                         if (ret != BT_ERROR_NONE)
5346                                 TC_PRT("failed with [0x%04x]", ret);
5347
5348                         ret = bt_adapter_le_scan_filter_register(scan_filter);
5349                         if (ret != BT_ERROR_NONE)
5350                                 TC_PRT("failed with [0x%04x]", ret);
5351
5352                         ret = bt_adapter_le_scan_filter_destroy(scan_filter);
5353                         if (ret != BT_ERROR_NONE)
5354                                 TC_PRT("failed with [0x%04x]", ret);
5355
5356                         break;
5357                 }
5358
5359                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_REGISTER_SCAN_FILTER_DEVICE_NAME: {
5360                         bt_scan_filter_h scan_filter;
5361
5362                         ret = bt_adapter_le_scan_filter_create(&scan_filter);
5363                         if (ret != BT_ERROR_NONE)
5364                                 TC_PRT("failed with [0x%04x]", ret);
5365
5366                         if (g_test_param.param_count > 0) {
5367                                 ret = bt_adapter_le_scan_filter_set_device_name(scan_filter, g_test_param.params[0]);
5368                                 __bt_free_test_param(&g_test_param);
5369                         } else {
5370                                 ret = bt_adapter_le_scan_filter_set_device_name(scan_filter, "Galaxy");
5371                         }
5372                         if (ret != BT_ERROR_NONE)
5373                                 TC_PRT("failed with [0x%04x]", ret);
5374
5375                         ret = bt_adapter_le_scan_filter_register(scan_filter);
5376                         if (ret != BT_ERROR_NONE)
5377                                 TC_PRT("failed with [0x%04x]", ret);
5378
5379                         ret = bt_adapter_le_scan_filter_destroy(scan_filter);
5380                         if (ret != BT_ERROR_NONE)
5381                                 TC_PRT("failed with [0x%04x]", ret);
5382
5383                         break;
5384                 }
5385
5386
5387                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_REGISTER_SCAN_FILTER_SERVICE_UUID: {
5388                         bt_scan_filter_h scan_filter;
5389
5390                         ret = bt_adapter_le_scan_filter_create(&scan_filter);
5391                         if (ret != BT_ERROR_NONE)
5392                                 TC_PRT("failed with [0x%04x]", ret);
5393
5394                         ret = bt_adapter_le_scan_filter_set_service_uuid(scan_filter, "1805");
5395                         if (ret != BT_ERROR_NONE)
5396                                 TC_PRT("failed with [0x%04x]", ret);
5397
5398                         ret = bt_adapter_le_scan_filter_register(scan_filter);
5399                         if (ret != BT_ERROR_NONE)
5400                                 TC_PRT("failed with [0x%04x]", ret);
5401
5402                         ret = bt_adapter_le_scan_filter_destroy(scan_filter);
5403                         if (ret != BT_ERROR_NONE)
5404                                 TC_PRT("failed with [0x%04x]", ret);
5405
5406                         break;
5407                 }
5408
5409                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_REGISTER_SCAN_FILTER_SERVICE_SOLICITATION_UUID: {
5410                         bt_scan_filter_h scan_filter;
5411
5412                         ret = bt_adapter_le_scan_filter_create(&scan_filter);
5413                         if (ret != BT_ERROR_NONE)
5414                                 TC_PRT("failed with [0x%04x]", ret);
5415
5416                         ret = bt_adapter_le_scan_filter_set_service_solicitation_uuid(scan_filter, "1805");
5417                         if (ret != BT_ERROR_NONE)
5418                                 TC_PRT("failed with [0x%04x]", ret);
5419
5420                         ret = bt_adapter_le_scan_filter_register(scan_filter);
5421                         if (ret != BT_ERROR_NONE)
5422                                 TC_PRT("failed with [0x%04x]", ret);
5423
5424                         ret = bt_adapter_le_scan_filter_destroy(scan_filter);
5425                         if (ret != BT_ERROR_NONE)
5426                                 TC_PRT("failed with [0x%04x]", ret);
5427
5428                         break;
5429                 }
5430
5431                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_REGISTER_SCAN_FILTER_MANUFACTURER_DATA: {
5432                         bt_scan_filter_h scan_filter = NULL;
5433                         int manufacturer_id = 117; /* samsung */
5434                         char param_data[] = {0x42, 0x04};
5435                         /* Use "appearance & tx power level" of bt_adapter_le_add_XXX_advertising_data */
5436
5437                         ret = bt_adapter_le_scan_filter_create(&scan_filter);
5438                         if (ret != BT_ERROR_NONE)
5439                                 TC_PRT("failed with [0x%04x]", ret);
5440
5441                         ret = bt_adapter_le_scan_filter_set_manufacturer_data(scan_filter,
5442                                                 manufacturer_id, param_data, sizeof(param_data));
5443                         if (ret != BT_ERROR_NONE)
5444                                 TC_PRT("failed with [0x%04x]", ret);
5445
5446                         ret = bt_adapter_le_scan_filter_register(scan_filter);
5447                         if (ret != BT_ERROR_NONE)
5448                                 TC_PRT("failed with [0x%04x]", ret);
5449
5450                         ret = bt_adapter_le_scan_filter_destroy(scan_filter);
5451                         if (ret != BT_ERROR_NONE)
5452                                 TC_PRT("failed with [0x%04x]", ret);
5453
5454                         break;
5455                 }
5456
5457                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_REGISTER_SCAN_FILTER_IBEACON_DATA: {
5458                         bt_scan_filter_h scan_filter;
5459
5460                         ret = bt_adapter_le_scan_filter_create(&scan_filter);
5461                         if (ret != BT_ERROR_NONE)
5462                            TC_PRT("failed with [0x%04x]", ret);
5463
5464                         ret = bt_adapter_le_scan_filter_set_type(scan_filter, BT_ADAPTER_LE_SCAN_FILTER_TYPE_IBEACON);
5465                         if (ret != BT_ERROR_NONE)
5466                                 TC_PRT("failed with [0x%04x]", ret);
5467
5468                         ret = bt_adapter_le_scan_filter_register(scan_filter);
5469                         if (ret != BT_ERROR_NONE)
5470                                 TC_PRT("failed with [0x%04x]", ret);
5471
5472                         break;
5473                 }
5474
5475                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_UNREGISTER_ALL_SCAN_FILTERS: {
5476                         ret = bt_adapter_le_scan_filter_unregister_all();
5477                         if (ret != BT_ERROR_NONE)
5478                                 TC_PRT("failed with [0x%04x]", ret);
5479
5480                         break;
5481                 }
5482
5483                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_WRITE_HOST_SUGGESTED_DEFAULT_DATA_LENGTH: {
5484
5485                         TC_PRT("Testing: Write Host suggested default LE Data length");
5486
5487                         unsigned int def_tx_octects = 30;
5488                         unsigned int def_tx_time = 330;
5489                         ret = bt_adapter_le_write_host_suggested_default_data_length(
5490                                 def_tx_octects, def_tx_time);
5491                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5492
5493                         break;
5494                 }
5495                 case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_READ_HOST_SUGGESTED_DEFAULT_DATA_LENGTH: {
5496
5497                         TC_PRT("Read host suggested default LE Data length");
5498
5499                         unsigned int def_tx_octets = 0;
5500                         unsigned int def_tx_time = 0;
5501                         ret = bt_adapter_le_read_suggested_default_data_length(
5502                                 &def_tx_octets, &def_tx_time);
5503                         TC_PRT("host suggested default le data length values are  %d %d",
5504                                         def_tx_octets, def_tx_time);
5505                         break;
5506                 }
5507                 case BT_UNIT_TEST_FUNCTION_LE_2M_PHY_SUPPORT: {
5508
5509                         TC_PRT("Check LE 2M PHY Feature support");
5510                         bool is_2m_phy_supported = FALSE;
5511
5512                         ret = bt_adapter_le_is_2m_phy_supported(&is_2m_phy_supported);
5513                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5514                         TC_PRT("LE 2M PHY Support [%s]", is_2m_phy_supported ? "YES" : "NO");
5515                         break;
5516                 }
5517                 case BT_UNIT_TEST_FUNCTION_LE_CODED_PHY_SUPPORT: {
5518
5519                         TC_PRT("Check LE CODED PHY Feature support");
5520                         bool is_coded_phy_supported = FALSE;
5521
5522                         ret = bt_adapter_le_is_coded_phy_supported(&is_coded_phy_supported);
5523                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5524                         TC_PRT("LE CODED PHY Support [%s]", is_coded_phy_supported ? "YES" : "NO");
5525                         break;
5526                 }
5527                 case BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS:
5528                         need_to_set_params = true;
5529                         TC_PRT("Select the function again");
5530                         break;
5531
5532                 default:
5533                         break;
5534                 }
5535
5536                 break;
5537         }
5538
5539         case BT_UNIT_TEST_TABLE_DEVICE: {
5540                 switch (test_id) {
5541                 case BT_UNIT_TEST_FUNCTION_DEVICE_SET_PROFILE_TRUSTED_A2DP_TRUE: {
5542                         ret = bt_device_set_profile_trusted(remote_addr, BT_TRUSTED_PROFILE_A2DP, TRUE);
5543                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5544                         break;
5545                 }
5546                 case BT_UNIT_TEST_FUNCTION_DEVICE_SET_PROFILE_TRUSTED_A2DP_FALSE: {
5547                         ret = bt_device_set_profile_trusted(remote_addr, BT_TRUSTED_PROFILE_A2DP, FALSE);
5548                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5549                         break;
5550                 }
5551                 case BT_UNIT_TEST_FUNCTION_DEVICE_SET_PROFILE_TRUSTED_HFP_TRUE: {
5552                         ret = bt_device_set_profile_trusted(remote_addr, BT_TRUSTED_PROFILE_HFP_HF, TRUE);
5553                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5554                         break;
5555                 }
5556                 case BT_UNIT_TEST_FUNCTION_DEVICE_SET_PROFILE_TRUSTED_HFP_FALSE: {
5557                         ret = bt_device_set_profile_trusted(remote_addr, BT_TRUSTED_PROFILE_HFP_HF, FALSE);
5558                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5559                         break;
5560                 }
5561                 case BT_UNIT_TEST_FUNCTION_DEVICE_SET_PROFILE_TRUSTED_CB:
5562                         ret = bt_device_set_trusted_profile_cb(
5563                                 __bt_device_profile_trusted_cb, NULL);
5564                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5565                         break;
5566                 case BT_UNIT_TEST_FUNCTION_DEVICE_UNSET_PROFILE_TRUSTED_CB:
5567                         ret = bt_device_unset_trusted_profile_cb();
5568                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5569                         break;
5570                 case BT_UNIT_TEST_FUNCTION_DEVICE_SET_AUTHORIZATION_TRUE: {
5571                         ret = bt_device_set_authorization(remote_addr, BT_DEVICE_AUTHORIZED);
5572                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5573                         break;
5574                 }
5575                 case BT_UNIT_TEST_FUNCTION_DEVICE_SET_AUTHORIZATION_FALSE: {
5576                         ret = bt_device_set_authorization(remote_addr, BT_DEVICE_UNAUTHORIZED);
5577                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5578                         break;
5579                 }
5580                 case BT_UNIT_TEST_FUNCTION_DEVICE_SET_AUTHORIZATION_CHANGED_CB:
5581                         ret = bt_device_set_authorization_changed_cb(
5582                                 __bt_device_authorization_changed_cb, NULL);
5583                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5584                         break;
5585
5586                 case BT_UNIT_TEST_FUNCTION_DEVICE_UNSET_AUTHORIZATION_CHANGED_CB:
5587                         ret = bt_device_unset_authorization_changed_cb();
5588                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5589                         break;
5590
5591                 case BT_UNIT_TEST_FUNCTION_DEVICE_SET_CONNECTION_STAET_CHANGED_CB:
5592                         ret = bt_device_set_connection_state_changed_cb(
5593                                 __bt_device_connection_state_changed_cb, NULL);
5594                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5595                         break;
5596
5597                 case BT_UNIT_TEST_FUNCTION_DEVICE_UNSET_CONNECTION_STAET_CHANGED_CB:
5598                         ret = bt_device_unset_connection_state_changed_cb();
5599                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5600                         break;
5601
5602                 case BT_UNIT_TEST_FUNCTION_DEVICE_FOREACH_CONNECTED_PROFILES: {
5603                         ret = bt_device_foreach_connected_profiles(remote_addr,
5604                                 __bt_device_connected_profile, NULL);
5605                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5606                         break;
5607                 }
5608
5609                 case BT_UNIT_TEST_FUNCTION_DEVICE_IS_PROFILE_CONNECTED: {
5610                         bool connected_status = false;
5611                         bt_profile_e profile = BT_PROFILE_HSP;
5612
5613                         if (g_test_param.param_count > 0) {
5614                                 profile = atoi(g_test_param.params[0]);
5615
5616                                 __bt_free_test_param(&g_test_param);
5617                         }
5618
5619                         ret = bt_device_is_profile_connected(remote_addr,
5620                                 profile, &connected_status);
5621                         if (ret < BT_ERROR_NONE)
5622                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
5623
5624                         TC_PRT("Profile [%s]",
5625                                 connected_status ? "Connected" : "Disconnected");
5626                         break;
5627                 }
5628
5629                 case BT_UNIT_TEST_FUNCTION_DEVICE_SET_BOND_CREATED_CB: {
5630                         ret = bt_device_set_bond_created_cb(
5631                                 __bt_device_bond_created_cb, NULL);
5632                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5633                         break;
5634                 }
5635
5636                 case BT_UNIT_TEST_FUNCTION_DEVICE_SET_BOND_DESTROYED_CB: {
5637                         ret = bt_device_set_bond_destroyed_cb(
5638                                 __bt_device_bond_destroyed_cb, NULL);
5639                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5640                         break;
5641                 }
5642
5643                 case BT_UNIT_TEST_FUNCTION_DEVICE_DISCONNECT: {
5644                         ret = bt_device_disconnect(remote_addr);
5645                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5646                         break;
5647                 }
5648
5649                 case BT_UNIT_TEST_FUNCTION_DEVICE_CREATE_BOND: {
5650                         ret = bt_device_create_bond(remote_addr);
5651                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5652                         break;
5653                 }
5654
5655                 case BT_UNIT_TEST_FUNCTION_DEVICE_CREATE_BOND_BY_TYPE: {
5656                         bt_device_connection_link_type_e link_type = BT_DEVICE_CONNECTION_LINK_LE;
5657
5658                         if (g_test_param.param_count > 0) {
5659                                 link_type = atoi(g_test_param.params[0]);
5660
5661                                 __bt_free_test_param(&g_test_param);
5662                         }
5663
5664                         ret = bt_device_create_bond_by_type(remote_addr,
5665                                         link_type);
5666                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5667                         break;
5668                 }
5669
5670                 case BT_UNIT_TEST_FUNCTION_DEVICE_DESTROY_BOND: {
5671                         ret = bt_device_destroy_bond(remote_addr);
5672                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5673                         break;
5674                 }
5675
5676                 case BT_UNIT_TEST_FUNCTION_DEVICE_GET_CONNECTION_STATE: {
5677                         bool bredr_connected = false;
5678                         bool le_connected = false;
5679
5680                         ret = bt_device_get_connection_state(remote_addr,
5681                                         BT_DEVICE_CONNECTION_LINK_BREDR,
5682                                         &bredr_connected);
5683                         if (ret < BT_ERROR_NONE)
5684                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
5685
5686                         ret = bt_device_get_connection_state(remote_addr,
5687                                         BT_DEVICE_CONNECTION_LINK_LE,
5688                                         &le_connected);
5689                         if (ret < BT_ERROR_NONE)
5690                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
5691
5692                         TC_PRT("BR/EDR [%s], LE [%s]",
5693                                 bredr_connected ? "Connected" : "Disconnected",
5694                                 le_connected ? "Connected" : "Disconnected");
5695
5696                         break;
5697                 }
5698                 case BT_UNIT_TEST_FUNCTION_DEVICE_REQUEST_ATT_MTU: {
5699                         unsigned int mtu = 512; /* MAX MTU Value */
5700
5701                         if (g_test_param.param_count > 0) {
5702                                 mtu = atoi(g_test_param.params[0]);
5703
5704                                 __bt_free_test_param(&g_test_param);
5705                         }
5706
5707                         ret = bt_device_request_att_mtu(remote_addr, mtu);
5708                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5709                         break;
5710                 }
5711                 case BT_UNIT_TEST_FUNCTION_DEVICE_GET_ATT_MTU: {
5712                         unsigned int mtu = 0;
5713                         ret = bt_device_get_att_mtu(remote_addr, &mtu);
5714                         TC_PRT("returns %s, MTU %d\n", __bt_get_error_message(ret), mtu);
5715                         break;
5716                 }
5717                 case BT_UNIT_TEST_FUNCTION_DEVICE_SET_REQUEST_ATT_MTU_CHANGED_CB: {
5718                         ret = bt_device_set_att_mtu_changed_cb(__bt_device_att_mtu_changed_cb, NULL);
5719                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5720                         break;
5721                 }
5722                 case BT_UNIT_TEST_FUNCTION_DEVICE_UNSET_REQUEST_ATT_MTU_CHANGED_CB: {
5723                         ret = bt_device_unset_att_mtu_changed_cb();
5724                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5725                         break;
5726                 }
5727
5728                 case BT_UNIT_TEST_FUNCTION_DEVICE_UPDATE_LE_CONNECTION: {
5729                         bt_le_conn_update_s param;
5730
5731                         if (g_test_param.param_count == 0)
5732                                 break;
5733
5734                         param.interval_min = atof(g_test_param.params[0]);
5735                         param.interval_max = atof(g_test_param.params[1]);
5736                         param.latency = atoi(g_test_param.params[2]);
5737                         param.time_out = atoi(g_test_param.params[3]);
5738
5739                         __bt_free_test_param(&g_test_param);
5740
5741                         ret = bt_device_le_conn_update(remote_addr, &param);
5742                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5743                         break;
5744                 }
5745                 case BT_UNIT_TEST_FUNCTION_LE_DEVICE_SET_DATA_LENGTH: {
5746
5747                         TC_PRT("Set LE Data length paramters cmd");
5748
5749                         unsigned int tx_octets = 50;
5750                         unsigned int tx_time = 500;
5751
5752                         if (g_test_param.param_count > 0) {
5753                                 tx_octets = atoi(g_test_param.params[0]);
5754                                 tx_time = atoi(g_test_param.params[1]);
5755
5756                                 __bt_free_test_param(&g_test_param);
5757                         }
5758
5759                         TC_PRT("settting le data length values  tx octects: %d  tx time: %d",
5760                                 tx_octets, tx_time);
5761                         ret = bt_device_le_set_data_length(remote_addr,
5762                                 tx_octets, tx_time);
5763                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5764
5765                         break;
5766                 }
5767                 case BT_UNIT_TEST_FUNCTION_LE_DEVICE_DATA_LENGTH_CHANGED_CB: {
5768
5769                         TC_PRT("Setting LE Data length change callback");
5770
5771                         ret = bt_device_le_set_data_length_change_cb(
5772                                 __bt_le_set_data_length_changed_cb,
5773                                 NULL);
5774                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5775
5776                         break;
5777                 }
5778                 case BT_UNIT_TEST_FUNCTION_DEVICE_UPDATE_LE_CONNECTION_MODE: {
5779                         int mode = BT_DEVICE_LE_CONNECTION_MODE_BALANCED;
5780
5781                         if (g_test_param.param_count > 0) {
5782                                 mode = atoi(g_test_param.params[0]);
5783                                 __bt_free_test_param(&g_test_param);
5784                         }
5785                         ret = bt_device_update_le_connection_mode(remote_addr, mode);
5786                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5787                         break;
5788                 }
5789                 case BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS:
5790                         need_to_set_params = true;
5791                         TC_PRT("Select the function again");
5792                         break;
5793
5794                 default:
5795                         break;
5796                 }
5797
5798                 break;
5799         }
5800         case BT_UNIT_TEST_TABLE_SOCKET: {
5801                 switch (test_id) {
5802                 case BT_UNIT_TEST_FUNCTION_SOCKET_CREATE_RFCOMM: {
5803                         int socket_fd = 0;
5804
5805                         ret = bt_socket_create_rfcomm(spp_uuid, &socket_fd);
5806                         if (ret < BT_ERROR_NONE) {
5807                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
5808                         } else {
5809                                 TC_PRT("socket_fd: %d", socket_fd);
5810                                 server_fd = socket_fd;
5811                         }
5812                         break;
5813                 }
5814                 case BT_UNIT_TEST_FUNCTION_SOCKET_DESTROY_RFCOMM:
5815                         ret = bt_socket_destroy_rfcomm(server_fd);
5816                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5817                         break;
5818                 case BT_UNIT_TEST_FUNCTION_SOCKET_LISTEN_AND_ACCEPT_RFCOMM:
5819                         ret = bt_socket_listen_and_accept_rfcomm(server_fd, 1);
5820                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5821                         break;
5822                 case BT_UNIT_TEST_FUNCTION_SOCKET_LISTEN:
5823                         ret = bt_socket_listen(server_fd, 1);
5824                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5825                         break;
5826                 case BT_UNIT_TEST_FUNCTION_SOCKET_ACCEPT: {
5827                         int socket_fd = 0;
5828
5829                         ret = bt_socket_accept(server_fd);
5830                         if (ret < BT_ERROR_NONE) {
5831                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
5832                         } else {
5833                                 TC_PRT("socket_fd: %d", socket_fd);
5834                                 client_fd = socket_fd;
5835                         }
5836                         break;
5837                 }
5838                 case BT_UNIT_TEST_FUNCTION_SOCKET_REJECT:
5839                         ret = bt_socket_reject(server_fd);
5840                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5841                         break;
5842                 case BT_UNIT_TEST_FUNCTION_SOCKET_CONNECT_RFCOMM: {
5843                         ret = bt_socket_connect_rfcomm(remote_addr, spp_uuid);
5844                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5845                         break;
5846                 }
5847                 case BT_UNIT_TEST_FUNCTION_SOCKET_DISCONNECT_RFCOMM:
5848                         ret = bt_socket_disconnect_rfcomm(client_fd);
5849                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5850                         break;
5851                 case BT_UNIT_TEST_FUNCTION_SOCKET_SEND_DATA: {
5852                         char data[] = "Sending test";
5853
5854                         if (g_test_param.param_count > 0) {
5855                                 ret = bt_socket_send_data(client_fd,
5856                                         g_test_param.params[0],
5857                                         strlen(g_test_param.params[0]) + 1);
5858
5859                                 __bt_free_test_param(&g_test_param);
5860                         } else {
5861                                 ret = bt_socket_send_data(client_fd,
5862                                         data, sizeof(data));
5863                         }
5864
5865                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5866                         break;
5867                 }
5868                 case BT_UNIT_TEST_FUNCTION_SOCKET_CREATE_RFCOMM_CUSTOM_UUID: {
5869                         int socket_fd = 0;
5870
5871                         if (g_test_param.param_count > 0) {
5872                                 ret = bt_socket_create_rfcomm(g_test_param.params[0], &socket_fd);
5873
5874                                 __bt_free_test_param(&g_test_param);
5875                         } else {
5876                                 ret = bt_socket_create_rfcomm(custom_uuid, &socket_fd);
5877                         }
5878
5879                         if (ret < BT_ERROR_NONE) {
5880                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
5881                         } else {
5882                                 TC_PRT("socket_fd: %d", socket_fd);
5883                                 custom_server_fd = socket_fd;
5884                         }
5885                         break;
5886                 }
5887                 case BT_UNIT_TEST_FUNCTION_SOCKET_DESTROY_RFCOMM_CUSTOM_UUID:
5888                         ret = bt_socket_destroy_rfcomm(custom_server_fd);
5889                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5890                         break;
5891                 case BT_UNIT_TEST_FUNCTION_SOCKET_LISTEN_AND_ACCEPT_RFCOMM_CUSTOM_UUID:
5892                         ret = bt_socket_listen_and_accept_rfcomm(custom_server_fd, 1);
5893                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5894                         break;
5895                 case BT_UNIT_TEST_FUNCTION_SOCKET_CONNECT_RFCOMM_CUSTOM_UUID: {
5896                         if (g_test_param.param_count > 0) {
5897                                 ret = bt_socket_connect_rfcomm(remote_addr, g_test_param.params[0]);
5898
5899                                 __bt_free_test_param(&g_test_param);
5900                         } else {
5901                                 ret = bt_socket_connect_rfcomm(remote_addr, custom_uuid);
5902                         }
5903
5904                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5905                         break;
5906                 }
5907                 case BT_UNIT_TEST_FUNCTION_SOCKET_DISCONNECT_RFCOMM_CUSTOM_UUID:
5908                         ret = bt_socket_disconnect_rfcomm(custom_client_fd);
5909                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5910                         break;
5911                 case BT_UNIT_TEST_FUNCTION_SOCKET_SEND_DATA_CUSTOM_UUID: {
5912                         char param_data[] = "Sending test";
5913
5914                         if (g_test_param.param_count > 0) {
5915                                 ret = bt_socket_send_data(custom_client_fd,
5916                                                 g_test_param.params[0],
5917                                                 strlen(g_test_param.params[0]) + 1);
5918
5919                                 __bt_free_test_param(&g_test_param);
5920                         } else {
5921                                 ret = bt_socket_send_data(custom_client_fd,
5922                                         param_data, sizeof(param_data));
5923                         }
5924
5925                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5926                         break;
5927                 }
5928                 case BT_UNIT_TEST_FUNCTION_SOCKET_SET_DATA_RECEIVED_CB:
5929                         ret = bt_socket_set_data_received_cb(
5930                                 __bt_socket_data_received_cb, NULL);
5931                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5932                         break;
5933                 case BT_UNIT_TEST_FUNCTION_SOCKET_UNSET_DATA_RECEIVED_CB:
5934                         ret = bt_socket_unset_data_received_cb();
5935                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5936                         break;
5937                 case BT_UNIT_TEST_FUNCTION_SOCKET_SET_CONNECTION_REQUESTED_CB:
5938                         ret = bt_socket_set_connection_requested_cb(
5939                                 __bt_socket_connection_requested_cb, NULL);
5940                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5941                         break;
5942                 case BT_UNIT_TEST_FUNCTION_SOCKET_UNSET_CONNECTION_REQUESTED_CB:
5943                         ret = bt_socket_unset_connection_requested_cb();
5944                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5945                         break;
5946                 case BT_UNIT_TEST_FUNCTION_SOCKET_SET_CONNECTION_STATE_CHANGED_CB:
5947                         ret = bt_socket_set_connection_state_changed_cb(
5948                                 __bt_socket_connection_state_changed_cb, NULL);
5949                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5950                         break;
5951                 case BT_UNIT_TEST_FUNCTION_SOCKET_UNSET_CONNECTION_STATE_CHANGED_CB:
5952                         ret = bt_socket_unset_connection_state_changed_cb();
5953                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5954                         break;
5955
5956                 case BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS:
5957                         need_to_set_params = true;
5958                         TC_PRT("Select the function again");
5959                         break;
5960
5961                 default:
5962                         break;
5963                 }
5964
5965                 break;
5966         }
5967         case BT_UNIT_TEST_TABLE_OPP: {
5968                 switch (test_id) {
5969                 case BT_UNIT_TEST_FUNCTION_OPP_CLIENT_INITIALIZE:
5970                         ret = bt_opp_client_initialize();
5971                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5972                         break;
5973                 case BT_UNIT_TEST_FUNCTION_OPP_CLIENT_DEINITIALIZE:
5974                         ret = bt_opp_client_deinitialize();
5975                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5976                         break;
5977                 case BT_UNIT_TEST_FUNCTION_OPP_CLIENT_ADD_FILE:
5978                         ret = bt_opp_client_add_file("/opt/media/Images/image1.jpg");
5979                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5980                         break;
5981                 case BT_UNIT_TEST_FUNCTION_OPP_CLIENT_CLEAR_FILES:
5982                         ret = bt_opp_client_clear_files();
5983                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5984                         break;
5985                 case BT_UNIT_TEST_FUNCTION_OPP_CLIENT_PUSH_FILES: {
5986                         ret = bt_opp_client_push_files(remote_addr,
5987                                         __bt_opp_client_push_responded_cb,
5988                                         __bt_opp_client_push_progress_cb,
5989                                         __bt_opp_client_push_finished_cb,
5990                                         NULL);
5991                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5992                         break;
5993                 }
5994                 case BT_UNIT_TEST_FUNCTION_OPP_CLIENT_CANCEL_PUSH:
5995                         ret = bt_opp_client_cancel_push();
5996                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
5997                         break;
5998
5999                 case BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS:
6000                         need_to_set_params = true;
6001                         TC_PRT("Select the function again");
6002                         break;
6003
6004                 default:
6005                         break;
6006                 }
6007
6008                 break;
6009         }
6010         case BT_UNIT_TEST_TABLE_AUDIO: {
6011                 switch (test_id) {
6012                 case BT_UNIT_TEST_FUNCTION_AUDIO_INITIALIZE:
6013                         ret = bt_audio_initialize();
6014                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6015                         break;
6016                 case BT_UNIT_TEST_FUNCTION_AUDIO_DEINITIALIZE:
6017                         ret = bt_audio_deinitialize();
6018                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6019                         break;
6020                 case BT_UNIT_TEST_FUNCTION_AUDIO_CONNECT: {
6021                         bt_audio_profile_type_e audio_profile = BT_AUDIO_PROFILE_TYPE_ALL;
6022
6023                         if (g_test_param.param_count > 0) {
6024                                 audio_profile = atoi(g_test_param.params[0]);
6025
6026                                 __bt_free_test_param(&g_test_param);
6027                         }
6028
6029                         ret = bt_audio_connect(remote_addr,  audio_profile);
6030                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6031                         break;
6032                 }
6033                 case BT_UNIT_TEST_FUNCTION_AUDIO_DISCONNECT: {
6034                         bt_audio_profile_type_e audio_profile = BT_AUDIO_PROFILE_TYPE_ALL;
6035
6036                         if (g_test_param.param_count > 0) {
6037                                 audio_profile = atoi(g_test_param.params[0]);
6038
6039                                 __bt_free_test_param(&g_test_param);
6040                         }
6041
6042                         ret = bt_audio_disconnect(remote_addr,  audio_profile);
6043                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6044                         break;
6045                 }
6046                 case BT_UNIT_TEST_FUNCTION_AUDIO_SINK_CONNECT: {
6047                         bt_audio_profile_type_e audio_profile = BT_AUDIO_PROFILE_TYPE_A2DP_SINK;
6048
6049                         if (g_test_param.param_count > 0) {
6050                                 audio_profile = atoi(g_test_param.params[0]);
6051
6052                                 __bt_free_test_param(&g_test_param);
6053                         }
6054
6055                         ret = bt_audio_connect(remote_addr,  audio_profile);
6056                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6057                         break;
6058                 }
6059                 case BT_UNIT_TEST_FUNCTION_AUDIO_SINK_DISCONNECT: {
6060                         bt_audio_profile_type_e audio_profile = BT_AUDIO_PROFILE_TYPE_A2DP_SINK;
6061
6062                         if (g_test_param.param_count > 0) {
6063                                 audio_profile = atoi(g_test_param.params[0]);
6064
6065                                 __bt_free_test_param(&g_test_param);
6066                         }
6067
6068                         ret = bt_audio_disconnect(remote_addr,  audio_profile);
6069                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6070                         break;
6071                 }
6072                 case BT_UNIT_TEST_FUNCTION_AUDIO_SET_CONNECTION_STATE_CHANGED_CB:
6073                         ret = bt_audio_set_connection_state_changed_cb(
6074                                                 __bt_audio_connection_state_changed_cb, NULL);
6075                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6076                         break;
6077                 case BT_UNIT_TEST_FUNCTION_AUDIO_UNSET_CONNECTION_STATE_CHANGED_CB:
6078                         ret = bt_audio_unset_connection_state_changed_cb();
6079                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6080                         break;
6081                 case BT_UNIT_TEST_FUNCTION_AG_OPEN_SCO:
6082                         ret = bt_ag_open_sco();
6083                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6084                         break;
6085                 case BT_UNIT_TEST_FUNCTION_AG_CLOSE_SCO:
6086                         ret = bt_ag_close_sco();
6087                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6088                         break;
6089                 case BT_UNIT_TEST_FUNCTION_AG_IS_SCO_OPENED: {
6090                         bool opened = false;
6091                         ret = bt_ag_is_sco_opened(&opened);
6092                         TC_PRT("opend[%s]", opened ? "YES" : "NO");
6093                         if (ret < BT_ERROR_NONE)
6094                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
6095                         break;
6096                 }
6097                 case BT_UNIT_TEST_FUNCTION_AG_SET_SCO_STATE_CHANGED_CB:
6098                         ret = bt_ag_set_sco_state_changed_cb(
6099                                 __bt_ag_sco_state_changed_cb, NULL);
6100                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6101                         break;
6102                 case BT_UNIT_TEST_FUNCTION_AG_UNSET_SCO_STATE_CHANGED_CB:
6103                         ret = bt_ag_unset_sco_state_changed_cb();
6104                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6105                         break;
6106                 case BT_UNIT_TEST_FUNCTION_AG_SET_SPEAKER_GAIN_CHANGED_CB:
6107                         ret = bt_ag_set_speaker_gain_changed_cb(
6108                                 __bt_ag_speaker_gain_changed_cb, NULL);
6109                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6110                         break;
6111                 case BT_UNIT_TEST_FUNCTION_AG_UNSET_SPEAKER_GAIN_CHANGED_CB:
6112                         ret = bt_ag_unset_speaker_gain_changed_cb();
6113                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6114                         break;
6115                 case BT_UNIT_TEST_FUNCTION_AG_SET_MICRO_GAIN_CHANGED_CB:
6116                         ret = bt_ag_set_microphone_gain_changed_cb(
6117                                 __bt_ag_microphone_gain_changed_cb, NULL);
6118                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6119                         break;
6120                 case BT_UNIT_TEST_FUNCTION_AG_UNSET_MICRO_GAIN_CHANGED_CB:
6121                         ret = bt_ag_unset_microphone_gain_changed_cb();
6122                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6123                         break;
6124                 case BT_UNIT_TEST_FUNCTION_AG_IS_CONNECTED: {
6125                         bool connected = false;
6126                         ret = bt_ag_is_connected(&connected);
6127                         TC_PRT("returns %s\n",
6128                                 connected ? "Connected" : "Disconnected");
6129                         break;
6130                 }
6131                 case BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_IDLE: {
6132                         unsigned int call_id = 1;
6133
6134                         ret = bt_ag_notify_call_event(
6135                                 BT_AG_CALL_EVENT_IDLE,
6136                                 call_id, NULL);
6137                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6138                         break;
6139                 }
6140                 case BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_ANSWERED: {
6141                         unsigned int call_id = 1;
6142                         bool sco_required = true;
6143
6144                         ret = bt_ag_notify_call_event(
6145                                 BT_AG_CALL_EVENT_ANSWERED,
6146                                 call_id, NULL);
6147                         if (sco_required)
6148                                 bt_ag_open_sco();
6149                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6150                         break;
6151                 }
6152                 case BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_DIALING: {
6153                         unsigned int call_id = 1;
6154                         bool sco_required = TRUE;
6155                         const char *phone_number;
6156
6157                         if (g_test_param.param_count > 0) {
6158                                 ret = bt_ag_notify_call_event(
6159                                                 BT_AG_CALL_EVENT_DIALING,
6160                                                 call_id, g_test_param.params[0]);
6161
6162                                 __bt_free_test_param(&g_test_param);
6163                         } else {
6164                                 phone_number = g_strdup("01012345678");
6165
6166                                 ret = bt_ag_notify_call_event(
6167                                                 BT_AG_CALL_EVENT_DIALING,
6168                                                 call_id, phone_number);
6169                         }
6170
6171                         if (sco_required)
6172                                 bt_ag_open_sco();
6173                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6174                         break;
6175                 }
6176                 case BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_ALERTING: {
6177                         unsigned int call_id = 1;
6178
6179                         ret = bt_ag_notify_call_event(
6180                                         BT_AG_CALL_EVENT_ALERTING,
6181                                         call_id, NULL);
6182                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6183                         break;
6184                 }
6185                 case BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_INCOMING: {
6186                         unsigned int call_id = 1;
6187                         const char *phone_number;
6188
6189                         if (g_test_param.param_count > 0) {
6190                                 ret = bt_ag_notify_call_event(
6191                                                 BT_AG_CALL_EVENT_INCOMING,
6192                                                 call_id, g_test_param.params[0]);
6193
6194                                 __bt_free_test_param(&g_test_param);
6195                         } else {
6196                                 phone_number = g_strdup("01012345678");
6197
6198                                 ret = bt_ag_notify_call_event(
6199                                                 BT_AG_CALL_EVENT_INCOMING,
6200                                                 call_id, phone_number);
6201                         }
6202
6203                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6204                         break;
6205                 }
6206                 case BT_UNIT_TEST_FUNCTION_CALL_LIST_CREATE:
6207                         ret = bt_call_list_create(&call_list);
6208                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6209                         break;
6210                 case BT_UNIT_TEST_FUNCTION_CALL_LIST_DESTROY:
6211                         ret = bt_call_list_destroy(call_list);
6212                         call_list = NULL;
6213                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6214                         break;
6215                 case BT_UNIT_TEST_FUNCTION_CALL_LIST_RESET:
6216                         ret = bt_call_list_reset(call_list);
6217                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6218                         break;
6219                 case BT_UNIT_TEST_FUNCTION_CALL_LIST_ADD: {
6220                         const char *phone_number;
6221
6222                         if (g_test_param.param_count > 0) {
6223                                 ret = bt_call_list_add(call_list, 1,
6224                                         BT_AG_CALL_STATE_ACTIVE,
6225                                         g_test_param.params[0]);
6226
6227                                 __bt_free_test_param(&g_test_param);
6228                         } else {
6229                                 phone_number = g_strdup("01012345678");
6230
6231                                 ret = bt_call_list_add(call_list, 1,
6232                                         BT_AG_CALL_STATE_ACTIVE,
6233                                         phone_number);
6234                         }
6235
6236                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6237                         break;
6238                 }
6239                 case BT_UNIT_TEST_FUNCTION_AG_NOTIFY_CALL_LIST:
6240                         ret = bt_ag_notify_call_list(call_list);
6241                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6242                         break;
6243                 case BT_UNIT_TEST_FUNCTION_AG_SET_CALL_HANDLING_EVENT_CB:
6244                         ret = bt_ag_set_call_handling_event_cb(
6245                                         __bt_ag_set_call_handling_event_cb, NULL);
6246                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6247                         break;
6248                 case BT_UNIT_TEST_FUNCTION_AG_IS_NREC_ENABLED: {
6249                         bool enabled = false;
6250                         ret = bt_ag_is_nrec_enabled(&enabled);
6251                         TC_PRT("opend[%s]", enabled ? "YES" : "NO");
6252                         if (ret < BT_ERROR_NONE)
6253                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
6254                         break;
6255                 }
6256                 case BT_UNIT_TEST_FUNCTION_AG_SWITCH_HEADSET: {
6257                         if (g_test_param.param_count < 0) {
6258                                 TC_PRT("Input parameters first");
6259                                 break;
6260                         }
6261
6262                         ret = bt_ag_switch_headset(g_test_param.params[0]);
6263                         __bt_free_test_param(&g_test_param);
6264
6265                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6266                         break;
6267                 }
6268
6269                 case BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS:
6270                         need_to_set_params = true;
6271                         TC_PRT("Select the function again");
6272                         break;
6273                 case BT_UNIT_TEST_FUNCTION_A2DP_SOURCE_ROLE: {
6274                         bt_audio_role_e role = BT_A2DP_SOURCE;
6275                         ret = bt_audio_select_role(role);
6276                         TC_PRT("Asdp Source set change ret = %d", ret);
6277                         break;
6278                 }
6279                 case BT_UNIT_TEST_FUNCTION_A2DP_SINK_ROLE: {
6280                         bt_audio_role_e role = BT_A2DP_SINK;
6281                         ret = bt_audio_select_role(role);
6282                         TC_PRT("Asdp Sink set change ret = %d", ret);
6283                         break;
6284                 }
6285                 case BT_UNIT_TEST_FUNCTION_AUDIO_SET_ABSOLUTE_VOLUME: {
6286                         if (absolute_volume > 150)
6287                                 absolute_volume = 0;
6288
6289                         ret = bt_audio_set_absolute_volume(absolute_volume);
6290                         TC_PRT("ret = %d", ret);
6291
6292                         if (ret == BT_ERROR_NONE)
6293                                 absolute_volume = absolute_volume + 50;
6294
6295                         break;
6296                 }
6297                 case BT_UNIT_TEST_FUNCTION_AUDIO_GET_ABSOLUTE_VOLUME: {
6298                         unsigned int volume = 0;
6299                         ret = bt_audio_get_absolute_volume(&volume);
6300                         TC_PRT("ret = %d, volume: %d", ret, volume);
6301
6302                         if (ret == BT_ERROR_NONE)
6303                                 absolute_volume = volume;
6304
6305                         break;
6306                 }
6307                 case BT_UNIT_TEST_FUNCTION_AUDIO_IS_AVC_ACTIVATED: {
6308                         bool activated = false;
6309                         ret = bt_audio_is_avc_activated(&activated);
6310                         TC_PRT("ret = %d, activated = %d", ret, activated);
6311                         break;
6312                 }
6313                 case BT_UNIT_TEST_FUNCTION_AUDIO_SET_ABSOLUTE_VOLUME_CHANGED_CB: {
6314                         ret = bt_audio_set_absolute_volume_changed_cb(__bt_audio_absolute_volume_changed_cb, NULL);
6315                         TC_PRT("ret = %d", ret);
6316                         break;
6317                 }
6318                 case BT_UNIT_TEST_FUNCTION_AUDIO_UNSET_ABSOLUTE_VOLUME_CHANGED_CB: {
6319                         ret = bt_audio_unset_absolute_volume_changed_cb();
6320                         TC_PRT("ret = %d", ret);
6321                         break;
6322                 }
6323                 case BT_UNIT_TEST_FUNCTION_AUDIO_SET_AVC_STATUE_CHANGED_CB: {
6324                         ret = bt_audio_set_avc_status_changed_cb(__bt_audio_avc_status_changed_cb, NULL);
6325                         TC_PRT("ret = %d", ret);
6326                         break;
6327                 }
6328                 case BT_UNIT_TEST_FUNCTION_AUDIO_UNSET_AVC_STATUE_CHANGED_CB: {
6329                         ret = bt_audio_unset_avc_status_changed_cb();
6330                         TC_PRT("ret = %d", ret);
6331                         break;
6332                 }
6333                 default:
6334                         break;
6335                 }
6336
6337                 break;
6338         }
6339         case BT_UNIT_TEST_TABLE_PAN: {
6340                 switch (test_id) {
6341                 case BT_UNIT_TEST_FUNCTION_NAP_ACTIVATE:
6342                         ret = bt_nap_activate();
6343                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6344                         break;
6345
6346                 case BT_UNIT_TEST_FUNCTION_NAP_DEACTIVATE:
6347                         ret = bt_nap_deactivate();
6348                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6349                         break;
6350
6351                 case BT_UNIT_TEST_FUNCTION_NAP_DISCONNECT_ALL:
6352                         ret = bt_nap_disconnect_all();
6353                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6354                         break;
6355
6356                 case BT_UNIT_TEST_FUNCTION_NAP_DISCONNECT: {
6357                         ret = bt_nap_disconnect(remote_addr);
6358                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6359                         break;
6360                 }
6361
6362                 case BT_UNIT_TEST_FUNCTION_PANU_SET_CONNECTION_STATE_CHANGED_CB: {
6363                         ret = bt_panu_set_connection_state_changed_cb(
6364                                         panu_conn_state_changed, NULL);
6365                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6366                         break;
6367                 }
6368                 case BT_UNIT_TEST_FUNCTION_PANU_CONNECT: {
6369                         ret = bt_panu_connect(remote_addr,
6370                                 BT_PANU_SERVICE_TYPE_NAP);
6371                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6372                         break;
6373                 }
6374
6375                 case BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS:
6376                         need_to_set_params = true;
6377                         TC_PRT("Select the function again");
6378                         break;
6379
6380                 default:
6381                         break;
6382                 }
6383
6384                 break;
6385         }
6386         case BT_UNIT_TEST_TABLE_GATT: {
6387                 switch (test_id) {
6388                 case BT_UNIT_TEST_FUNCTION_GATT_CONNECT: {
6389                         bool auto_connect = false;
6390
6391                         if (g_test_param.param_count > 0) {
6392                                 if (g_strrstr(g_test_param.params[0], "true"))
6393                                         auto_connect = true;
6394                                 else
6395                                         auto_connect = false;
6396
6397                                 __bt_free_test_param(&g_test_param);
6398                         }
6399
6400                         ret = bt_gatt_connect(remote_addr, auto_connect);
6401                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6402                         break;
6403                 }
6404                 case BT_UNIT_TEST_FUNCTION_GATT_DISCONNECT: {
6405                         ret = bt_gatt_disconnect(remote_addr);
6406                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6407                         break;
6408                 }
6409                 case BT_UNIT_TEST_FUNCTION_SET_GATT_CONNECTION_STATE_CHANGED_CB: {
6410                         ret = bt_gatt_set_connection_state_changed_cb(
6411                                 __bt_gatt_connection_state_changed_cb, NULL);
6412                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6413                         break;
6414                 }
6415                 case BT_UNIT_TEST_FUNCTION_UNSET_GATT_CONNECTION_STATE_CHANGED_CB: {
6416                         ret = bt_gatt_unset_connection_state_changed_cb();
6417                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6418                         break;
6419                 }
6420                 case BT_UNIT_TEST_FUNCTION_GATT_SET_WRITE_TYPE: {
6421                         char *svc_uuid = NULL;
6422                         char *chr_uuid = NULL;
6423                         bt_gatt_h svc = NULL;
6424                         bt_gatt_h chr = NULL;
6425                         bt_gatt_write_type_e write_type;
6426
6427                         if (g_test_param.param_count < 3) {
6428                                 TC_PRT("Input parameters first");
6429                                 break;
6430                         }
6431
6432                         svc_uuid = g_test_param.params[0];
6433                         chr_uuid = g_test_param.params[1];
6434
6435                         ret = bt_gatt_client_get_service(client, svc_uuid, &svc);
6436                         if (ret != BT_ERROR_NONE) {
6437                                 TC_PRT("bt_gatt_client_get_service is failed : %d", ret);
6438                                 __bt_free_test_param(&g_test_param);
6439                                 break;
6440                         }
6441
6442                         ret = bt_gatt_service_get_characteristic(svc, chr_uuid, &chr);
6443                         if (ret != BT_ERROR_NONE) {
6444                                 TC_PRT("bt_gatt_service_get_characteristic is failed : %d", ret);
6445                                 __bt_free_test_param(&g_test_param);
6446                                 break;
6447                         }
6448
6449                         write_type = atoi(g_test_param.params[2]);
6450                         ret = bt_gatt_characteristic_set_write_type(chr, write_type);
6451                         if (ret != BT_ERROR_NONE)
6452                                 TC_PRT("bt_gatt_characteristic_set_write_type is failed : %d", ret);
6453
6454                         __bt_free_test_param(&g_test_param);
6455                         break;
6456                 }
6457                 case BT_UNIT_TEST_FUNCTION_GATT_CLIENT_CREATE: {
6458                         if (client) {
6459                                bt_gatt_client_destroy(client);
6460                                client = NULL;
6461                         }
6462                         ret = bt_gatt_client_create(remote_addr, &client);
6463                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6464                         break;
6465                 }
6466                 case BT_UNIT_TEST_FUNCTION_GATT_CLIENT_DESTROY: {
6467                         if (!client)
6468                                 break;
6469
6470                         ret = bt_gatt_client_destroy(client);
6471                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6472                         client = NULL;
6473                         break;
6474                 }
6475                 case BT_UNIT_TEST_FUNCTION_GATT_CLIENT_GET_REMOTE_ADDRESS: {
6476                         char *addr = NULL;
6477
6478                         ret = bt_gatt_client_get_remote_address(client, &addr);
6479                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6480
6481                         if (addr) {
6482                                 TC_PRT("remote addr : %s\n", addr);
6483                                 g_free(addr);
6484                         }
6485                         break;
6486                 }
6487                 case BT_UNIT_TEST_FUNCTION_GATT_CLIENT_PRINT_ALL: {
6488 #ifdef ARCH64
6489                         ret = bt_gatt_client_foreach_services(client,
6490                                 __bt_gatt_client_foreach_svc_cb,
6491                                 (void *)(uintptr_t)test_id);
6492 #else
6493                         ret = bt_gatt_client_foreach_services(client,
6494                                 __bt_gatt_client_foreach_svc_cb,
6495                                 (void *)test_id);
6496 #endif
6497                         if (ret != BT_ERROR_NONE)
6498                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
6499                         break;
6500                 }
6501                 case BT_UNIT_TEST_FUNCTION_GATT_CLIENT_READ_VALUE: {
6502                         char *svc_uuid = NULL;
6503                         char *chr_uuid = NULL;
6504                         char *desc_uuid = NULL;
6505                         bt_gatt_h svc = NULL;
6506                         bt_gatt_h chr = NULL;
6507                         bt_gatt_h desc = NULL;
6508
6509                         if (g_test_param.param_count < 3) {
6510                                 TC_PRT("Input parameters first");
6511                                 break;
6512                         }
6513
6514                         svc_uuid = g_test_param.params[0];
6515                         chr_uuid = g_test_param.params[1];
6516
6517                         ret = bt_gatt_client_get_service(client,
6518                                         svc_uuid, &svc);
6519                         if (ret != BT_ERROR_NONE) {
6520                                 TC_PRT("bt_gatt_client_get_service is failed : %d", ret);
6521                                 __bt_free_test_param(&g_test_param);
6522                                 break;
6523                         }
6524
6525                         ret = bt_gatt_service_get_characteristic(svc,
6526                                         chr_uuid, &chr);
6527                         if (ret != BT_ERROR_NONE) {
6528                                 TC_PRT("bt_gatt_service_get_characteristic is failed : %d", ret);
6529                                 __bt_free_test_param(&g_test_param);
6530                                 break;
6531                         }
6532
6533                         if (strlen(g_test_param.params[2]) > 0) {
6534                                 desc_uuid = g_test_param.params[2];
6535                                 ret = bt_gatt_characteristic_get_descriptor(chr,
6536                                         desc_uuid, &desc);
6537                                 if (ret != BT_ERROR_NONE) {
6538                                         TC_PRT("bt_gatt_characteristic_get_descriptor is failed : %d", ret);
6539                                         __bt_free_test_param(&g_test_param);
6540                                         break;
6541                                 }
6542                                 ret = bt_gatt_client_read_value(desc,
6543                                                 __bt_gatt_client_read_complete_cb, NULL);
6544                         } else {
6545                                 ret = bt_gatt_client_read_value(chr,
6546                                                 __bt_gatt_client_read_complete_cb, NULL);
6547                         }
6548
6549                         if (ret != BT_ERROR_NONE)
6550                                 TC_PRT("bt_gatt_client_read_value is failed : %d", ret);
6551
6552                         __bt_free_test_param(&g_test_param);
6553                         break;
6554                 }
6555                 case BT_UNIT_TEST_FUNCTION_GATT_CLIENT_WRITE_VALUE: {
6556                         char *svc_uuid = NULL;
6557                         char *chr_uuid = NULL;
6558                         char *desc_uuid = NULL;
6559                         bt_gatt_h svc = NULL;
6560                         bt_gatt_h chr = NULL;
6561                         bt_gatt_h desc = NULL;
6562
6563                         if (g_test_param.param_count < 5) {
6564                                 TC_PRT("Input parameters first");
6565                                 break;
6566                         }
6567
6568                         svc_uuid = g_test_param.params[0];
6569                         chr_uuid = g_test_param.params[1];
6570
6571                         ret = bt_gatt_client_get_service(client,
6572                                         svc_uuid, &svc);
6573                         if (ret != BT_ERROR_NONE) {
6574                                 TC_PRT("bt_gatt_client_get_service is failed : %d", ret);
6575                                 __bt_free_test_param(&g_test_param);
6576                                 break;
6577                         }
6578
6579                         ret = bt_gatt_service_get_characteristic(svc,
6580                                         chr_uuid, &chr);
6581                         if (ret != BT_ERROR_NONE) {
6582                                 TC_PRT("bt_gatt_service_get_characteristic is failed : %d", ret);
6583                                 __bt_free_test_param(&g_test_param);
6584                                 break;
6585                         }
6586
6587                         if (strlen(g_test_param.params[2]) > 0) {
6588                                 desc_uuid = g_test_param.params[2];
6589                                 ret = bt_gatt_characteristic_get_descriptor(chr,
6590                                                 desc_uuid, &desc);
6591                                 if (ret != BT_ERROR_NONE) {
6592                                         TC_PRT("bt_gatt_characteristic_get_descriptor is failed : %d", ret);
6593                                         __bt_free_test_param(&g_test_param);
6594                                         break;
6595                                 }
6596
6597                                 ret = __bt_gatt_client_set_value(g_test_param.params[3],
6598                                                 g_test_param.params[4], desc);
6599                                 if (ret != BT_ERROR_NONE) {
6600                                         TC_PRT("bt_gatt_set_value is failed : %d", ret);
6601                                         __bt_free_test_param(&g_test_param);
6602                                         break;
6603                                 }
6604
6605                                 ret = bt_gatt_client_write_value(desc,
6606                                                 __bt_gatt_client_write_complete_cb, NULL);
6607                         } else {
6608                                 ret = __bt_gatt_client_set_value(g_test_param.params[3],
6609                                                 g_test_param.params[4], chr);
6610                                 if (ret != BT_ERROR_NONE) {
6611                                         TC_PRT("bt_gatt_set_value is failed : %d", ret);
6612                                         __bt_free_test_param(&g_test_param);
6613                                         break;
6614                                 }
6615
6616                                 ret = bt_gatt_client_write_value(chr,
6617                                                 __bt_gatt_client_write_complete_cb, NULL);
6618                         }
6619
6620                         if (ret != BT_ERROR_NONE)
6621                                 TC_PRT("bt_gatt_client_write_value is failed : %d", ret);
6622
6623                         __bt_free_test_param(&g_test_param);
6624                         break;
6625                 }
6626                 case BT_UNIT_TEST_FUNCTION_GATT_CLIENT_SET_CHAR_VALUE_CHANGED_CB: {
6627                         char *svc_uuid = NULL;
6628                         char *chr_uuid = NULL;
6629                         bt_gatt_h svc = NULL;
6630                         bt_gatt_h chr = NULL;
6631
6632                         if (g_test_param.param_count < 2) {
6633                                 TC_PRT("Input parameters first");
6634                                 break;
6635                         }
6636
6637                         svc_uuid = g_test_param.params[0];
6638                         chr_uuid = g_test_param.params[1];
6639
6640                         ret = bt_gatt_client_get_service(client,
6641                                         svc_uuid, &svc);
6642                         if (ret != BT_ERROR_NONE) {
6643                                 TC_PRT("bt_gatt_client_get_service is failed : %d", ret);
6644                                 __bt_free_test_param(&g_test_param);
6645                                 break;
6646                         }
6647
6648                         ret = bt_gatt_service_get_characteristic(svc,
6649                                         chr_uuid, &chr);
6650                         if (ret != BT_ERROR_NONE) {
6651                                 TC_PRT("bt_gatt_service_get_characteristic is failed : %d", ret);
6652                                 __bt_free_test_param(&g_test_param);
6653                                 break;
6654                         }
6655
6656                         ret = bt_gatt_client_set_characteristic_value_changed_cb(chr,
6657                                         __bt_gatt_client_value_changed_cb, NULL);
6658                         if (ret != BT_ERROR_NONE)
6659                                 TC_PRT("bt_gatt_client_set_characteristic_value_changed_cb is failed : %d", ret);
6660
6661                         __bt_free_test_param(&g_test_param);
6662                         break;
6663                 }
6664                 case BT_UNIT_TEST_FUNCTION_GATT_CLIENT_UNSET_CHAR_VALUE_CHANGED_CB: {
6665                         char *svc_uuid = NULL;
6666                         char *chr_uuid = NULL;
6667                         bt_gatt_h svc = NULL;
6668                         bt_gatt_h chr = NULL;
6669
6670                         if (g_test_param.param_count < 2) {
6671                                 TC_PRT("Input parameters first");
6672                                 break;
6673                         }
6674
6675                         svc_uuid = g_test_param.params[0];
6676                         chr_uuid = g_test_param.params[1];
6677
6678                         ret = bt_gatt_client_get_service(client,
6679                                         svc_uuid, &svc);
6680                         if (ret != BT_ERROR_NONE) {
6681                                 TC_PRT("bt_gatt_client_get_service is failed : %d", ret);
6682                                 __bt_free_test_param(&g_test_param);
6683                                 break;
6684                         }
6685
6686                         ret = bt_gatt_service_get_characteristic(svc,
6687                                         chr_uuid, &chr);
6688                         if (ret != BT_ERROR_NONE) {
6689                                 TC_PRT("bt_gatt_service_get_characteristic is failed : %d", ret);
6690                                 __bt_free_test_param(&g_test_param);
6691                                 break;
6692                         }
6693
6694                         ret = bt_gatt_client_unset_characteristic_value_changed_cb(chr);
6695                         if (ret != BT_ERROR_NONE)
6696                                 TC_PRT("bt_gatt_client_unset_characteristic_value_changed_cb is failed : %d", ret);
6697
6698                         __bt_free_test_param(&g_test_param);
6699                         break;
6700                 }
6701                 case BT_UNIT_TEST_FUNCTION_GATT_CLIENT_FOREACH_SERVICES: {
6702 #ifdef ARCH64
6703                         ret = bt_gatt_client_foreach_services(client,
6704                                 __bt_gatt_client_foreach_svc_cb, (void *)(uintptr_t)test_id);
6705 #else
6706                         ret = bt_gatt_client_foreach_services(client,
6707                                 __bt_gatt_client_foreach_svc_cb, (void *)(uintptr_t)test_id);
6708 #endif
6709                         if (ret != BT_ERROR_NONE)
6710                                 TC_PRT("bt_gatt_client_foreach_services_by_uuid is failed");
6711                         break;
6712                 }
6713                 case BT_UNIT_TEST_FUNCTION_GATT_CLIENT_REQUEST_ATT_MTU: {
6714                         unsigned int mtu = 512; /* MAX MTU Value */
6715
6716                         if (g_test_param.param_count > 0) {
6717                                 mtu = atoi(g_test_param.params[0]);
6718
6719                                 __bt_free_test_param(&g_test_param);
6720                         }
6721
6722                         ret = bt_gatt_client_request_att_mtu_change(client, mtu);
6723                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6724                         break;
6725                 }
6726                 case BT_UNIT_TEST_FUNCTION_GATT_CLIENT_GET_ATT_MTU: {
6727                         unsigned int mtu = 0;
6728                         ret = bt_gatt_client_get_att_mtu(client, &mtu);
6729                         TC_PRT("returns %s, MTU %d\n", __bt_get_error_message(ret), mtu);
6730                         break;
6731                 }
6732                 case BT_UNIT_TEST_FUNCTION_GATT_CLIENT_SET_SERVICE_CHANGED_CB: {
6733                         ret = bt_gatt_client_set_service_changed_cb(client,
6734                                         __bt_gatt_client_service_changed_cb, NULL);
6735                         if (ret != BT_ERROR_NONE)
6736                                 TC_PRT("bt_gatt_client_set_service_changed_cb is failed");
6737                         break;
6738                 }
6739                 case BT_UNIT_TEST_FUNCTION_GATT_CLIENT_UNSET_SERVICE_CHANGED_CB: {
6740                         ret = bt_gatt_client_unset_service_changed_cb(client);
6741                         if (ret != BT_ERROR_NONE)
6742                                 TC_PRT("bt_gatt_client_unset_service_changed_cb is failed");
6743                         break;
6744                 }
6745                 case BT_UNIT_TEST_FUNCTION_GATT_CLIENT_SET_ATT_MTU_CHANGED_CB: {
6746                         ret = bt_gatt_client_set_att_mtu_changed_cb(client, __bt_gatt_client_att_mtu_changed_cb, NULL);
6747                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6748                         break;
6749                 }
6750                 case BT_UNIT_TEST_FUNCTION_GATT_CLIENT_UNSET_ATT_MTU_CHANGED_CB: {
6751                         ret = bt_gatt_client_unset_att_mtu_changed_cb(client);
6752                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6753                         break;
6754                 }
6755                 case BT_UNIT_TEST_FUNCTION_GATT_SERVER_INITIALIZE: {
6756
6757                         ret = bt_gatt_server_initialize();
6758
6759                         TC_PRT("returns %s \n", __bt_get_error_message(ret));
6760                         break;
6761                 }
6762                 case BT_UNIT_TEST_FUNCTION_GATT_SERVER_DEINITIALIZE: {
6763
6764                         ret = bt_gatt_server_deinitialize();
6765
6766                         server = NULL;
6767
6768                         TC_PRT("returns %s \n", __bt_get_error_message(ret));
6769                         break;
6770                 }
6771                 case BT_UNIT_TEST_FUNCTION_GATT_SERVER_UNREGISTER_ALL_SERVICES: {
6772                         ret = bt_gatt_server_unregister_all_services(server);
6773                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6774
6775                         break;
6776                 }
6777                 case BT_UNIT_TEST_FUNCTION_GATT_SERVER_SET_MTU_CHANGED_CB: {
6778                         ret = bt_gatt_server_set_att_mtu_changed_cb(server, __bt_gatt_server_att_mtu_changed_cb, NULL);
6779                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
6780                         break;
6781                 }
6782                 case BT_UNIT_TEST_FUNCTION_GATT_SERVER_REGISTER_BATTERY_SVC: {
6783                         bt_gatt_h service = NULL;
6784                         bt_gatt_h characteristic = NULL;
6785                         bt_gatt_h descriptor = NULL;
6786                         char *service_uuid = "180f"; /* Battery Service */
6787                         char *char_uuid = "2a19"; /* Battery Level */
6788                         char *desc_uuid = "2902";  /* CCCD */
6789                         char char_value[1] = {80}; /* 80% */
6790                         char desc_value[2] = {0, 0}; /* Notification & Indication */
6791                         int permissions = BT_GATT_PERMISSION_READ;
6792                         int properties = BT_GATT_PROPERTY_READ | BT_GATT_PROPERTY_NOTIFY;
6793
6794                         ret = bt_gatt_server_initialize();
6795                         TC_PRT("bt_gatt_server_initialize : %s \n", __bt_get_error_message(ret));
6796
6797                         if (server == NULL) {
6798                                 ret = bt_gatt_server_create(&server);
6799                                 TC_PRT("bt_gatt_server_create : %s \n", __bt_get_error_message(ret));
6800                         }
6801
6802                         ret = bt_gatt_service_create(service_uuid, BT_GATT_SERVICE_TYPE_PRIMARY, &service);
6803                         TC_PRT("bt_gatt_service_create : %s \n", __bt_get_error_message(ret));
6804
6805                         ret = bt_gatt_characteristic_create(char_uuid, permissions, properties,
6806                                                                                                 char_value, sizeof(char_value), &characteristic);
6807                         TC_PRT("bt_gatt_characteristic_create : %s\n", __bt_get_error_message(ret));
6808
6809                         bt_gatt_server_set_read_value_requested_cb(characteristic,
6810                                 __bt_gatt_server_read_value_requested_cb, NULL);
6811                         bt_gatt_server_set_characteristic_notification_state_change_cb(characteristic,
6812                                 __bt_gatt_server_notification_state_change_cb, NULL);
6813                         ret = bt_gatt_service_add_characteristic(service, characteristic);
6814                         TC_PRT("bt_gatt_service_add_characteristic : %s\n", __bt_get_error_message(ret));
6815
6816                         permissions = BT_GATT_PERMISSION_READ | BT_GATT_PERMISSION_WRITE;
6817                         ret = bt_gatt_descriptor_create(desc_uuid, permissions,
6818                                                 desc_value, sizeof(desc_value), &descriptor);
6819                         TC_PRT("bt_gatt_descriptor_create : %s\n", __bt_get_error_message(ret));
6820
6821                         ret = bt_gatt_characteristic_add_descriptor(characteristic, descriptor);
6822                         TC_PRT("bt_gatt_characteristic_add_descriptor : %s\n", __bt_get_error_message(ret));
6823
6824                         ret = bt_gatt_server_register_service(server, service);
6825                         TC_PRT("bt_gatt_server_register_service : %s\n", __bt_get_error_message(ret));
6826
6827                         battery_h.svc = service;
6828                         battery_h.chr = characteristic;
6829                         battery_h.desc = descriptor;
6830
6831                         break;
6832                 }
6833                 case BT_UNIT_TEST_FUNCTION_GATT_SERVER_CHANGE_BATTERY_LEVEL: {
6834                         char char_value[1] = {1 + (rand()%100)};
6835                         if (!server) {
6836                                 TC_PRT("bt gatt server is not created");
6837                                 break;
6838                         }
6839                         ret = bt_gatt_set_value(battery_h.chr, char_value, 1);
6840                         TC_PRT("Value[%d], returns %s\n", char_value[0], __bt_get_error_message(ret));
6841
6842                         /* notify only client remote_addr */
6843                         ret = bt_gatt_server_notify_characteristic_changed_value(battery_h.chr,
6844                                 __bt_gatt_server_notification_sent_cb,
6845                                 remote_addr, NULL);
6846                         TC_PRT("bt_gatt_server_notify : %s\n", __bt_get_error_message(ret));
6847
6848                         break;
6849                 }
6850                 case BT_UNIT_TEST_FUNCTION_GATT_SERVER_REGISTER_HEART_RATE_SVC: {
6851                         bt_gatt_h service = NULL;
6852                         bt_gatt_h characteristic = NULL;
6853                         bt_gatt_h descriptor = NULL;
6854                         char *service_uuid = "180d"; /* Heart Rate Service */
6855                         char *char_uuid = "2a37"; /* Heart Rate Measurement */
6856                         char *desc_uuid = "2902";  /* CCCD */
6857                         char char_value_1[3] = {1, 0x38, 0}; /* Flag + Measurement value (56) */
6858                         char desc_value[2] = {1, 0}; /* Notification enabled */
6859                         int permissions = BT_GATT_PERMISSION_READ;
6860                         int properties = BT_GATT_PROPERTY_NOTIFY | BT_GATT_PROPERTY_READ; /* READ property added for testing */
6861
6862                         ret = bt_gatt_server_initialize();
6863                         TC_PRT("bt_gatt_server_initialize : %s \n", __bt_get_error_message(ret));
6864
6865                         if (server == NULL) {
6866                                 ret = bt_gatt_server_create(&server);
6867                                 TC_PRT("bt_gatt_server_create : %s \n", __bt_get_error_message(ret));
6868                         }
6869
6870                         ret = bt_gatt_service_create(service_uuid, BT_GATT_SERVICE_TYPE_PRIMARY, &service);
6871                         TC_PRT("bt_gatt_service_create : %s \n", __bt_get_error_message(ret));
6872
6873                         ret = bt_gatt_characteristic_create(char_uuid, permissions, properties,
6874                                                                                                 char_value_1, sizeof(char_value_1), &characteristic);
6875                         TC_PRT("bt_gatt_characteristic_create : %s\n", __bt_get_error_message(ret));
6876
6877                         heart_rate_h.chr = characteristic;
6878
6879                         bt_gatt_server_set_read_value_requested_cb(characteristic,
6880                                 __bt_gatt_server_read_value_requested_cb, NULL);
6881                         bt_gatt_server_set_characteristic_notification_state_change_cb(characteristic,
6882                                 __bt_gatt_server_notification_state_change_cb, NULL);
6883                         ret = bt_gatt_service_add_characteristic(service, characteristic);
6884                         TC_PRT("bt_gatt_service_add_characteristic : %s\n", __bt_get_error_message(ret));
6885
6886                         permissions = BT_GATT_PERMISSION_READ | BT_GATT_PERMISSION_WRITE;
6887                         ret = bt_gatt_descriptor_create(desc_uuid, permissions,
6888                                         desc_value, sizeof(desc_value), &descriptor);
6889                         TC_PRT("bt_gatt_descriptor_create : %s\n", __bt_get_error_message(ret));
6890
6891                         ret = bt_gatt_characteristic_add_descriptor(characteristic, descriptor);
6892                         TC_PRT("bt_gatt_characteristic_add_descriptor : %s\n", __bt_get_error_message(ret));
6893
6894                         char_uuid = "2a38"; /* Body Sensor Location */
6895                         permissions = BT_GATT_PERMISSION_READ;
6896                         properties = BT_GATT_PROPERTY_READ;
6897                         char char_value_2 = 4; /* Hand */
6898                         ret = bt_gatt_characteristic_create(char_uuid, permissions, properties,
6899                                                                                                 &char_value_2, sizeof(char_value_2), &characteristic);
6900                         TC_PRT("bt_gatt_characteristic_create : %s\n", __bt_get_error_message(ret));
6901
6902                         bt_gatt_server_set_read_value_requested_cb(characteristic,
6903                                 __bt_gatt_server_read_value_requested_cb, NULL);
6904                         ret = bt_gatt_service_add_characteristic(service, characteristic);
6905                         TC_PRT("bt_gatt_service_add_characteristic : %s\n", __bt_get_error_message(ret));
6906
6907                         ret = bt_gatt_server_register_service(server, service);
6908                         TC_PRT("bt_gatt_server_register_service : %s\n", __bt_get_error_message(ret));
6909
6910                         heart_rate_h.svc = service;
6911                         heart_rate_h.desc = descriptor;
6912
6913                         break;
6914                 }
6915                 case BT_UNIT_TEST_FUNCTION_GATT_SERVER_NOTIFY_HEART_RATE_MEASUREMENT: {
6916                         int char_value = 60 + (rand()%60);
6917                         if (!server) {
6918                                 TC_PRT("bt gatt server is not created");
6919                                 break;
6920                         }
6921                         ret = bt_gatt_set_int_value(heart_rate_h.chr,
6922                                         BT_DATA_TYPE_UINT16, char_value, 1);
6923                         TC_PRT("bt_gatt_set_value(value : %d) : %s\n",
6924                                 char_value, __bt_get_error_message(ret));
6925
6926                         /* Notify all client devices */
6927                         ret = bt_gatt_server_notify_characteristic_changed_value(heart_rate_h.chr,
6928                                 __bt_gatt_server_notification_sent_cb,
6929                                 NULL, NULL);
6930                         TC_PRT("bt_gatt_server_notify : %s\n", __bt_get_error_message(ret));
6931
6932                         break;
6933                 }
6934                 case BT_UNIT_TEST_FUNCTION_GATT_SERVER_REGISTER_THERMOMETER_SVC: {
6935                         bt_gatt_h service = NULL;
6936                         bt_gatt_h characteristic = NULL;
6937                         bt_gatt_h descriptor = NULL;
6938                         char *service_uuid = "1809"; /* Health Thermometer Service */
6939                         char *char_uuid = "2a1c"; /* Temperature Measurement */
6940                         char *desc_uuid = "2902";  /* CCCD */
6941                         char char_value[5] = {0, 0x85, 0xff, 0xff, 0xfe}; /* Flag + Temperature Measurement Value (Celsius, -1.23) */
6942                         char desc_value[2] = {2, 0}; /* Indication enabled */
6943                         int permissions = BT_GATT_PERMISSION_READ;
6944                         int properties = BT_GATT_PROPERTY_INDICATE | BT_GATT_PROPERTY_READ; /* READ property added for testing */
6945
6946                         ret = bt_gatt_server_initialize();
6947                         TC_PRT("bt_gatt_server_initialize : %s \n", __bt_get_error_message(ret));
6948
6949                         if (server == NULL) {
6950                                 ret = bt_gatt_server_create(&server);
6951                                 TC_PRT("bt_gatt_server_create : %s \n", __bt_get_error_message(ret));
6952                         }
6953
6954                         ret = bt_gatt_service_create(service_uuid,
6955                                         BT_GATT_SERVICE_TYPE_PRIMARY, &service);
6956                         TC_PRT("bt_gatt_service_create : %s \n", __bt_get_error_message(ret));
6957
6958                         ret = bt_gatt_characteristic_create(char_uuid, permissions, properties,
6959                                                                                                 char_value, sizeof(char_value), &characteristic);
6960                         TC_PRT("bt_gatt_characteristic_create : %s\n", __bt_get_error_message(ret));
6961
6962                         bt_gatt_server_set_read_value_requested_cb(characteristic,
6963                                 __bt_gatt_server_read_value_requested_cb, NULL);
6964                         bt_gatt_server_set_characteristic_notification_state_change_cb(characteristic,
6965                                 __bt_gatt_server_notification_state_change_cb, NULL);
6966                         ret = bt_gatt_service_add_characteristic(service, characteristic);
6967                         TC_PRT("bt_gatt_service_add_characteristic : %s\n", __bt_get_error_message(ret));
6968
6969                         permissions = BT_GATT_PERMISSION_READ | BT_GATT_PERMISSION_WRITE;
6970                         ret = bt_gatt_descriptor_create(desc_uuid, permissions,
6971                                 desc_value, sizeof(desc_value), &descriptor);
6972                         TC_PRT("bt_gatt_descriptor_create : %s\n", __bt_get_error_message(ret));
6973
6974                         ret = bt_gatt_characteristic_add_descriptor(characteristic, descriptor);
6975                         TC_PRT("bt_gatt_characteristic_add_descriptor : %s\n", __bt_get_error_message(ret));
6976
6977                         ret = bt_gatt_server_register_service(server, service);
6978                         TC_PRT("bt_gatt_server_register_service : %s\n", __bt_get_error_message(ret));
6979
6980                         thermometer_h.chr = characteristic;
6981                         thermometer_h.svc = service;
6982                         thermometer_h.desc = descriptor;
6983
6984                         break;
6985                 }
6986                 case BT_UNIT_TEST_FUNCTION_GATT_SERVER_CHANGE_THERMOMETER_MEASUREMENT: {
6987                         if (!server) {
6988                                 TC_PRT("bt gatt server is not created");
6989                                 break;
6990                         }
6991                         ret = bt_gatt_set_float_value(thermometer_h.chr, BT_DATA_TYPE_FLOAT, 123, -2, 1);
6992                         TC_PRT("bt_gatt_set_value(value : 1.23) : %s\n", __bt_get_error_message(ret));
6993
6994                         /* notify only client remote_addr */
6995                         ret = bt_gatt_server_notify_characteristic_changed_value(thermometer_h.chr,
6996                                 __bt_gatt_server_notification_sent_cb, remote_addr, NULL);
6997                         TC_PRT("bt_gatt_server_notify : %s\n", __bt_get_error_message(ret));
6998
6999                         break;
7000                 }
7001                 case BT_UNIT_TEST_FUNCTION_GATT_SERVER_REGISTER_DEVICE_INFORMATION_SVC: {
7002                         bt_gatt_h service = NULL;
7003                         bt_gatt_h characteristic = NULL;
7004                         char *service_uuid = "180a"; /* Device Infromation Service */
7005                         char *char_uuid = NULL;
7006                         char *char_value;
7007                         int permissions = BT_GATT_PERMISSION_READ;
7008                         int properties = BT_GATT_PROPERTY_READ;
7009
7010                         ret = bt_gatt_server_initialize();
7011                         TC_PRT("bt_gatt_server_initialize : %s \n", __bt_get_error_message(ret));
7012
7013                         if (server == NULL) {
7014                                 ret = bt_gatt_server_create(&server);
7015                                 TC_PRT("bt_gatt_server_create : %s \n", __bt_get_error_message(ret));
7016                         }
7017
7018                         ret = bt_gatt_service_create(service_uuid,
7019                                 BT_GATT_SERVICE_TYPE_PRIMARY, &service);
7020                         TC_PRT("bt_gatt_service_create : %s \n", __bt_get_error_message(ret));
7021
7022                         char_uuid = "2a29"; /* Manufacturer Name String */
7023                         char_value = g_strdup("Samsung");
7024                         ret = bt_gatt_characteristic_create(char_uuid, permissions,
7025                                         properties, char_value,
7026                                         strlen(char_value), &characteristic);
7027                         TC_PRT("bt_gatt_characteristic_create : %s\n", __bt_get_error_message(ret));
7028                         g_free(char_value);
7029
7030                         bt_gatt_server_set_read_value_requested_cb(characteristic,
7031                                 __bt_gatt_server_read_value_requested_cb,
7032                                 NULL);
7033                         ret = bt_gatt_service_add_characteristic(service, characteristic);
7034                         TC_PRT("bt_gatt_service_add_characteristic : %s\n", __bt_get_error_message(ret));
7035
7036                         char_uuid = "2a24"; /* Model Number String */
7037                         char_value = g_strdup("TIZEN_HR 0408");
7038                         ret = bt_gatt_characteristic_create(char_uuid, permissions,
7039                                         properties, char_value,
7040                                         strlen(char_value), &characteristic);
7041                         TC_PRT("bt_gatt_characteristic_create : %s\n", __bt_get_error_message(ret));
7042                         g_free(char_value);
7043
7044                         bt_gatt_server_set_read_value_requested_cb(characteristic,
7045                                 __bt_gatt_server_read_value_requested_cb,
7046                                 NULL);
7047                         ret = bt_gatt_service_add_characteristic(service, characteristic);
7048                         TC_PRT("bt_gatt_service_add_characteristic : %s\n", __bt_get_error_message(ret));
7049
7050                         char_uuid = "2a28"; /* S/W Revision String */
7051                         char_value = g_strdup("NC2");
7052                         ret = bt_gatt_characteristic_create(char_uuid, permissions, properties,
7053                                         char_value, strlen(char_value), &characteristic);
7054                         TC_PRT("bt_gatt_characteristic_create : %s\n", __bt_get_error_message(ret));
7055                         g_free(char_value);
7056
7057                         bt_gatt_server_set_read_value_requested_cb(characteristic,
7058                                 __bt_gatt_server_read_value_requested_cb,
7059                                 NULL);
7060                         ret = bt_gatt_service_add_characteristic(service, characteristic);
7061                         TC_PRT("bt_gatt_service_add_characteristic : %s\n", __bt_get_error_message(ret));
7062
7063                         char_uuid = "2a26"; /* Firmware Revision Name String */
7064                         char_value = g_strdup("Firmware Ver 04");
7065                         ret = bt_gatt_characteristic_create(char_uuid, permissions,
7066                                         properties, char_value,
7067                                         strlen(char_value), &characteristic);
7068                         TC_PRT("bt_gatt_characteristic_create : %s\n", __bt_get_error_message(ret));
7069                         g_free(char_value);
7070
7071                         bt_gatt_server_set_read_value_requested_cb(characteristic,
7072                                 __bt_gatt_server_read_value_requested_cb,
7073                                 NULL);
7074                         ret = bt_gatt_service_add_characteristic(service, characteristic);
7075                         TC_PRT("bt_gatt_service_add_characteristic : %s\n", __bt_get_error_message(ret));
7076
7077                         ret = bt_gatt_server_register_service(server, service);
7078                         TC_PRT("bt_gatt_server_register_service : %s\n", __bt_get_error_message(ret));
7079                         break;
7080                 }
7081                 case BT_UNIT_TEST_FUNCTION_GATT_SERVER_REGISTER_LINK_LOSS_SVC: {
7082                         bt_gatt_h service = NULL;
7083                         bt_gatt_h characteristic = NULL;
7084                         char *service_uuid = "1803"; /* Link Loss Service */
7085                         char *char_uuid = "2a06"; /* Alert Level */
7086                         char char_value[1] = {2}; /* high alert */
7087                         int value_length = 1;
7088                         int permissions = BT_GATT_PERMISSION_READ | BT_GATT_PERMISSION_WRITE;
7089                         int properties = BT_GATT_PROPERTY_READ | BT_GATT_PROPERTY_WRITE;
7090
7091                         ret = bt_gatt_server_initialize();
7092                         TC_PRT("bt_gatt_server_initialize : %s \n", __bt_get_error_message(ret));
7093
7094                         if (server == NULL) {
7095                                 ret = bt_gatt_server_create(&server);
7096                                 TC_PRT("bt_gatt_server_create : %s \n", __bt_get_error_message(ret));
7097                         }
7098
7099                         ret = bt_gatt_service_create(service_uuid,
7100                                         BT_GATT_SERVICE_TYPE_PRIMARY,
7101                                         &service);
7102                         TC_PRT("bt_gatt_service_create : %s \n", __bt_get_error_message(ret));
7103
7104                         ret = bt_gatt_characteristic_create(char_uuid, permissions,
7105                                         properties, char_value,
7106                                         value_length, &characteristic);
7107                         TC_PRT("bt_gatt_characteristic_create : %s\n", __bt_get_error_message(ret));
7108
7109                         ret = bt_gatt_server_set_write_value_requested_cb(characteristic,
7110                                 __bt_gatt_server_write_value_requested_cb,
7111                                 NULL);
7112                         TC_PRT("bt_gatt_server_set_write_value_requested_cb : %s\n", __bt_get_error_message(ret));
7113
7114                         bt_gatt_server_set_read_value_requested_cb(characteristic,
7115                                 __bt_gatt_server_read_value_requested_cb, NULL);
7116                         ret = bt_gatt_service_add_characteristic(service, characteristic);
7117                         TC_PRT("bt_gatt_service_add_characteristic : %s\n", __bt_get_error_message(ret));
7118
7119                         ret = bt_gatt_server_register_service(server, service);
7120                         TC_PRT("bt_gatt_server_register_service : %s\n", __bt_get_error_message(ret));
7121
7122                         break;
7123                 }
7124                 case BT_UNIT_TEST_FUNCTION_GATT_SERVER_REGISTER_HOGP_SVC: {
7125                         bt_gatt_h service1 = NULL;
7126                         bt_gatt_h service2 = NULL;
7127                         bt_gatt_h service3 = NULL;
7128                         bt_gatt_h characteristic1_1 = NULL;
7129                         bt_gatt_h characteristic2_1 = NULL;
7130                         bt_gatt_h characteristic2_2 = NULL;
7131                         bt_gatt_h characteristic2_3 = NULL;
7132                         bt_gatt_h characteristic2_4 = NULL;
7133                         bt_gatt_h characteristic2_5 = NULL;
7134                         bt_gatt_h characteristic2_6 = NULL;
7135                         bt_gatt_h characteristic2_7 = NULL;
7136                         bt_gatt_h descriptor1_1 = NULL;
7137                         bt_gatt_h descriptor2_3 = NULL;
7138                         bt_gatt_h descriptor2_4_1 = NULL;
7139                         bt_gatt_h descriptor2_4_2 = NULL;
7140                         bt_gatt_h descriptor2_5_1 = NULL;
7141                         bt_gatt_h descriptor2_5_2 = NULL;
7142                         char *service_uuid1 = "180f"; /* Battery Service */
7143                         char *service_uuid2 = "1812"; /* HID Service */
7144                         char *service_uuid3 = "1801"; /* Generic Attribute Service */
7145                         char *char_uuid1 = "2a19"; /* Battery Level */
7146                         char *char_uuid2_1 = "2a4a"; /* HID information */
7147                         char *char_uuid2_2 = "2a4b";
7148                         char *char_uuid2_3 = "2a33";
7149                         char *char_uuid2_4 = "2a4d";
7150                         char *char_uuid2_5 = "2a4d";
7151                         char *char_uuid2_6 = "2a4c";
7152                         char *char_uuid2_7 = "2a4e";
7153                         char *desc_uuid1_1 = "2902"; /* Client Characteristic Configuration */
7154                         char *desc_uuid2_3 = "2902"; /* Client Characteristic Configuration */
7155                         char *desc_uuid2_4_1 = "2902"; /* Client Characteristic Configuration */
7156                         char *desc_uuid2_4_2 = "2908"; /* Report Reference */
7157                         char *desc_uuid2_5_1 = "2908"; /* Report Reference */
7158                         char *desc_uuid2_5_2 = "2901"; /* Characteristic User Description */
7159                         int permissions = BT_GATT_PERMISSION_READ | BT_GATT_PERMISSION_WRITE;
7160                         int properties = BT_GATT_PROPERTY_READ | BT_GATT_PROPERTY_WRITE;
7161
7162                         char char_value[1] = {80}; /* 80% */
7163                         char char_value_unknown[4] = {10, 20, 30, 40};
7164                         char desc_value_configration[2] = {0, 0}; /* Notification & Indication */
7165
7166                         ret = bt_gatt_server_initialize();
7167                         TC_PRT("bt_gatt_server_initialize : %s \n", __bt_get_error_message(ret));
7168
7169                         if (server == NULL) {
7170                                 ret = bt_gatt_server_create(&server);
7171                                 TC_PRT("bt_gatt_server_create : %s \n", __bt_get_error_message(ret));
7172                         }
7173
7174                         /* Battery Service */
7175                         ret = bt_gatt_service_create(service_uuid1,
7176                                         BT_GATT_SERVICE_TYPE_PRIMARY,
7177                                         &service1);
7178                         TC_PRT("bt_gatt_service_create : %s \n", __bt_get_error_message(ret));
7179
7180                         ret = bt_gatt_characteristic_create(char_uuid1, permissions,
7181                                         properties, char_value,
7182                                         1, &characteristic1_1);
7183                         TC_PRT("bt_gatt_characteristic_create : %s\n", __bt_get_error_message(ret));
7184
7185                         ret = bt_gatt_service_add_characteristic(service1, characteristic1_1);
7186                         TC_PRT("bt_gatt_service_add_characteristic : %s\n", __bt_get_error_message(ret));
7187
7188                         ret = bt_gatt_descriptor_create(desc_uuid1_1, permissions,
7189                                         desc_value_configration, 2, &descriptor1_1);
7190                         TC_PRT("bt_gatt_descriptor_create : %s\n", __bt_get_error_message(ret));
7191
7192                         ret = bt_gatt_characteristic_add_descriptor(characteristic1_1, descriptor1_1);
7193                         TC_PRT("bt_gatt_characteristic_add_descriptor : %s\n", __bt_get_error_message(ret));
7194
7195                         ret = bt_gatt_server_register_service(server, service1);
7196                         TC_PRT("bt_gatt_server_register_service : %s\n", __bt_get_error_message(ret));
7197
7198                         /* HID Service */
7199                         ret = bt_gatt_service_create(service_uuid2,
7200                                         BT_GATT_SERVICE_TYPE_PRIMARY,
7201                                         &service2);
7202                         TC_PRT("bt_gatt_service_create : %s \n", __bt_get_error_message(ret));
7203
7204                         ret = bt_gatt_characteristic_create(char_uuid2_1, permissions,
7205                                         properties, char_value_unknown,
7206                                         4, &characteristic2_1);
7207                         TC_PRT("bt_gatt_characteristic_create : %s\n", __bt_get_error_message(ret));
7208
7209                         ret = bt_gatt_service_add_characteristic(service2, characteristic2_1);
7210                         TC_PRT("bt_gatt_service_add_characteristic : %s\n", __bt_get_error_message(ret));
7211
7212                         ret = bt_gatt_characteristic_create(char_uuid2_2, permissions,
7213                                         properties, char_value_unknown,
7214                                         4, &characteristic2_2);
7215                         TC_PRT("bt_gatt_characteristic_create : %s\n", __bt_get_error_message(ret));
7216
7217                         ret = bt_gatt_service_add_characteristic(service2, characteristic2_2);
7218                         TC_PRT("bt_gatt_service_add_characteristic : %s\n", __bt_get_error_message(ret));
7219
7220                         ret = bt_gatt_characteristic_create(char_uuid2_3, permissions,
7221                                         properties, char_value_unknown,
7222                                         4, &characteristic2_3);
7223                         TC_PRT("bt_gatt_characteristic_create : %s\n", __bt_get_error_message(ret));
7224
7225                         ret = bt_gatt_service_add_characteristic(service2, characteristic2_3);
7226                         TC_PRT("bt_gatt_service_add_characteristic : %s\n", __bt_get_error_message(ret));
7227
7228                         ret = bt_gatt_descriptor_create(desc_uuid2_3, permissions,
7229                                         desc_value_configration, 2, &descriptor2_3);
7230                         TC_PRT("bt_gatt_descriptor_create : %s\n", __bt_get_error_message(ret));
7231
7232                         ret = bt_gatt_characteristic_add_descriptor(characteristic2_3, descriptor2_3);
7233                         TC_PRT("bt_gatt_characteristic_add_descriptor : %s\n", __bt_get_error_message(ret));
7234
7235                         ret = bt_gatt_characteristic_create(char_uuid2_4, permissions,
7236                                         properties, char_value_unknown,
7237                                         4, &characteristic2_4);
7238                         TC_PRT("bt_gatt_characteristic_create : %s\n", __bt_get_error_message(ret));
7239
7240                         ret = bt_gatt_service_add_characteristic(service2, characteristic2_4);
7241                         TC_PRT("bt_gatt_service_add_characteristic : %s\n", __bt_get_error_message(ret));
7242
7243                         ret = bt_gatt_descriptor_create(desc_uuid2_4_1, permissions,
7244                                         desc_value_configration, 2, &descriptor2_4_1);
7245                         TC_PRT("bt_gatt_descriptor_create : %s\n", __bt_get_error_message(ret));
7246
7247                         ret = bt_gatt_characteristic_add_descriptor(characteristic2_4, descriptor2_4_1);
7248                         TC_PRT("bt_gatt_characteristic_add_descriptor : %s\n", __bt_get_error_message(ret));
7249
7250                         ret = bt_gatt_descriptor_create(desc_uuid2_4_2, permissions,
7251                                         desc_value_configration, 2, &descriptor2_4_2);
7252                         TC_PRT("bt_gatt_descriptor_create : %s\n", __bt_get_error_message(ret));
7253
7254                         ret = bt_gatt_characteristic_add_descriptor(characteristic2_4, descriptor2_4_2);
7255                         TC_PRT("bt_gatt_characteristic_add_descriptor : %s\n", __bt_get_error_message(ret));
7256
7257                         ret = bt_gatt_characteristic_create(char_uuid2_5, permissions,
7258                                         properties, char_value_unknown,
7259                                         4, &characteristic2_5);
7260                         TC_PRT("bt_gatt_characteristic_create : %s\n", __bt_get_error_message(ret));
7261
7262                         ret = bt_gatt_service_add_characteristic(service2, characteristic2_5);
7263                         TC_PRT("bt_gatt_service_add_characteristic : %s\n", __bt_get_error_message(ret));
7264
7265                         ret = bt_gatt_descriptor_create(desc_uuid2_5_1, permissions,
7266                                         desc_value_configration, 2, &descriptor2_5_1);
7267                         TC_PRT("bt_gatt_descriptor_create : %s\n", __bt_get_error_message(ret));
7268
7269                         ret = bt_gatt_characteristic_add_descriptor(characteristic2_5, descriptor2_5_1);
7270                         TC_PRT("bt_gatt_characteristic_add_descriptor : %s\n", __bt_get_error_message(ret));
7271
7272                         ret = bt_gatt_descriptor_create(desc_uuid2_5_2, permissions,
7273                                         desc_value_configration, 2, &descriptor2_5_2);
7274                         TC_PRT("bt_gatt_descriptor_create : %s\n", __bt_get_error_message(ret));
7275
7276                         ret = bt_gatt_characteristic_add_descriptor(characteristic2_5, descriptor2_5_2);
7277                         TC_PRT("bt_gatt_characteristic_add_descriptor : %s\n", __bt_get_error_message(ret));
7278
7279                         ret = bt_gatt_characteristic_create(char_uuid2_6, permissions,
7280                                         properties, char_value_unknown,
7281                                         4, &characteristic2_6);
7282                         TC_PRT("bt_gatt_characteristic_create : %s\n", __bt_get_error_message(ret));
7283
7284                         ret = bt_gatt_service_add_characteristic(service2, characteristic2_6);
7285                         TC_PRT("bt_gatt_service_add_characteristic : %s\n", __bt_get_error_message(ret));
7286
7287                         ret = bt_gatt_characteristic_create(char_uuid2_7, permissions,
7288                                         properties, char_value_unknown,
7289                                         4, &characteristic2_7);
7290                         TC_PRT("bt_gatt_characteristic_create : %s\n", __bt_get_error_message(ret));
7291
7292                         ret = bt_gatt_service_add_characteristic(service2, characteristic2_7);
7293                         TC_PRT("bt_gatt_service_add_characteristic : %s\n", __bt_get_error_message(ret));
7294
7295                         ret = bt_gatt_server_register_service(server, service2);
7296                         TC_PRT("bt_gatt_server_register_service : %s\n", __bt_get_error_message(ret));
7297
7298                         /* Generic Attribute Service */
7299                         ret = bt_gatt_service_create(service_uuid3,
7300                                         BT_GATT_SERVICE_TYPE_PRIMARY,
7301                                         &service3);
7302                         TC_PRT("bt_gatt_service_create : %s \n", __bt_get_error_message(ret));
7303
7304                         ret = bt_gatt_server_register_service(server, service3);
7305                         TC_PRT("bt_gatt_server_register_service : %s\n", __bt_get_error_message(ret));
7306                         break;
7307                 }
7308                 case BT_UNIT_TEST_FUNCTION_GATT_SERVER_REGISTER_CUSTOM_SVC: {
7309                         bt_gatt_h service = NULL;
7310                         bt_gatt_h characteristic = NULL;
7311                         bt_gatt_h descriptor = NULL;
7312                         char *service_uuid = "000018f2-0000-1000-8000-00805f9b34fb";
7313                         char *char_uuid = "00002af6-0000-1000-8000-00805f9b34fb";
7314                         char *desc_uuid = "2902";  // CCCD
7315                         char char_value[4] = {10, 20, 30, 40};
7316                         char desc_value[2] = {0, 0}; // Notification disabled
7317                         int value_length = 4;
7318                         int permissions = BT_GATT_PERMISSION_READ | BT_GATT_PERMISSION_WRITE;
7319                         int properties = BT_GATT_PROPERTY_BROADCAST | BT_GATT_PROPERTY_READ |
7320                                                         BT_GATT_PROPERTY_WRITE | BT_GATT_PROPERTY_NOTIFY;
7321
7322                         ret = bt_gatt_server_initialize();
7323                         TC_PRT("bt_gatt_server_initialize : %s \n", __bt_get_error_message(ret));
7324
7325                         if (server == NULL) {
7326                                 ret = bt_gatt_server_create(&server);
7327                                 TC_PRT("bt_gatt_server_create : %s \n", __bt_get_error_message(ret));
7328                         }
7329
7330                         ret = bt_gatt_service_create(service_uuid,
7331                                         BT_GATT_SERVICE_TYPE_PRIMARY,
7332                                         &service);
7333                         TC_PRT("bt_gatt_service_create : %s \n", __bt_get_error_message(ret));
7334
7335                         /* Read & Write & Notify characteristics UUID */
7336                         ret = bt_gatt_characteristic_create(char_uuid, permissions,
7337                                         properties, char_value,
7338                                         value_length, &characteristic);
7339                         TC_PRT("bt_gatt_characteristic_create : %s\n", __bt_get_error_message(ret));
7340
7341                         bt_gatt_server_set_read_value_requested_cb(characteristic,
7342                                 __bt_gatt_server_read_value_requested_cb, NULL);
7343
7344                         ret = bt_gatt_server_set_write_value_requested_cb(characteristic,
7345                                 __bt_gatt_server_write_value_requested_cb, NULL);
7346
7347                         ret = bt_gatt_server_set_characteristic_notification_state_change_cb(characteristic,
7348                                                 __bt_gatt_server_notification_state_change_cb, NULL);
7349
7350                         ret = bt_gatt_service_add_characteristic(service, characteristic);
7351                         TC_PRT("bt_gatt_service_add_characteristic : %s\n", __bt_get_error_message(ret));
7352
7353                         /* CCCD for Notify characteristics */
7354                         ret = bt_gatt_descriptor_create(desc_uuid, permissions,
7355                                         desc_value, value_length, &descriptor);
7356                         TC_PRT("bt_gatt_descriptor_create : %s\n", __bt_get_error_message(ret));
7357
7358                         ret = bt_gatt_characteristic_add_descriptor(characteristic, descriptor);
7359                         TC_PRT("bt_gatt_characteristic_add_descriptor : %s\n", __bt_get_error_message(ret));
7360
7361                         ret = bt_gatt_server_register_service(server, service);
7362                         TC_PRT("bt_gatt_server_register_service : %s\n", __bt_get_error_message(ret));
7363
7364                         custom_h.svc = service;
7365                         custom_h.chr = characteristic;
7366                         custom_h.desc = descriptor;
7367                         break;
7368                 }
7369                 case BT_UNIT_TEST_FUNCTION_GATT_SERVER_CHANGE_CUSTOM_VAL: {
7370                         char char_value[4] = {50, 60, 70, 80};
7371                         if (!server) {
7372                                 TC_PRT("bt gatt server is not created");
7373                                 break;
7374                         }
7375                         ret = bt_gatt_set_value(custom_h.chr, char_value, 4);
7376                         TC_PRT("returns  %s\n", __bt_get_error_message(ret));
7377
7378                         /* notify only client remote_addr */
7379                         ret = bt_gatt_server_notify_characteristic_changed_value(custom_h.chr,
7380                                         __bt_gatt_server_notification_sent_cb, remote_addr, NULL);
7381                         TC_PRT("bt_gatt_server_notify_characteristic_changed_value : %s\n",
7382                                         __bt_get_error_message(ret));
7383
7384                         break;
7385                 }
7386                 case BT_UNIT_TEST_FUNCTION_GATT_START_SERVER: {
7387                         ret = bt_gatt_server_start();
7388                         TC_PRT("bt_gatt_server_register_service : %s\n", __bt_get_error_message(ret));
7389                         break;
7390                 }
7391                 case BT_UNIT_TEST_FUNCTION_GATT_GET_SPEC_NAME_FROM_UUID: {
7392                         char *name = NULL;
7393                         char *uuid = "0000180F-0000-1000-8000-00805F9B34FB";
7394                         ret = bt_gatt_get_uuid_specification_name(uuid, &name);
7395                         TC_PRT("bt_gatt_get_uuid_specification_name : %s\n", __bt_get_error_message(ret));
7396                         if (BT_ERROR_NONE == ret) {
7397                                 TC_PRT("UUID [%s] Specification Name [%s]", uuid, name);
7398                                 free(name);
7399                         }
7400                         break;
7401                 }
7402                 case BT_UNIT_TEST_FUNCTION_GATT_SERVER_FOREACH_SERVICES: {
7403 #ifdef ARCH64
7404                         ret = bt_gatt_server_foreach_services(server,
7405                         __bt_gatt_server_foreach_svc_cb, (void *)(uintptr_t)test_id);
7406 #else
7407                         ret = bt_gatt_server_foreach_services(server,
7408                         __bt_gatt_server_foreach_svc_cb, (void *)test_id);
7409 #endif
7410                         TC_PRT("bt_gatt_server_foreach_services: %s\n", __bt_get_error_message(ret));
7411                         break;
7412                 }
7413                 case BT_UNIT_TEST_FUNCTION_GATT_SERVER_GET_DEVICE_MTU: {
7414                         unsigned int mtu = 0;
7415                         ret = bt_gatt_server_get_device_mtu(remote_addr, &mtu);
7416                         TC_PRT("returns %s, MTU %d\n", __bt_get_error_message(ret), mtu);
7417                         break;
7418                 }
7419                 case BT_UNIT_TEST_FUNCTION_ANCS_PAIR: {
7420                         bt_device_connection_link_type_e link_type = BT_DEVICE_CONNECTION_LINK_LE;
7421
7422                         if (g_test_param.param_count > 0) {
7423                                 link_type = atoi(g_test_param.params[0]);
7424
7425                                 __bt_free_test_param(&g_test_param);
7426                         }
7427
7428                         ret = bt_device_create_bond_by_type(remote_addr, link_type);
7429                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
7430                         break;
7431                 }
7432                 case BT_UNIT_TEST_FUNCTION_ANCS_WATCH: {
7433                         bt_gatt_h ancs_svc = NULL;
7434                         bt_gatt_h noti_source = NULL;;
7435                         char *svc_uuid = "7905F431-B5CE-4E99-A40F-4B1E122D00D0";
7436                         char *chr_uuid = "9FBF120D-6301-42D9-8C58-25E699A21DBD";
7437
7438                         ret = bt_gatt_client_get_service(client, svc_uuid, &ancs_svc);
7439                         if (ret != BT_ERROR_NONE) {
7440                                 TC_PRT("bt_gatt_client_get_service is failed : %d", ret);
7441                                 break;
7442                         }
7443
7444                         ret = bt_gatt_service_get_characteristic(ancs_svc,
7445                                         chr_uuid, &noti_source);
7446                         if (ret != BT_ERROR_NONE) {
7447                                 TC_PRT("bt_gatt_service_get_characteristic is failed : %d", ret);
7448                                 break;
7449                         }
7450
7451                         ret = bt_gatt_client_set_characteristic_value_changed_cb(noti_source,
7452                                         __bt_gatt_client_value_changed_cb, NULL);
7453                         if (ret != BT_ERROR_NONE)
7454                                 TC_PRT("bt_gatt_client_set_characteristic_value_changed_cb is failed : %d", ret);
7455                         break;
7456                 }
7457                 case BT_UNIT_TEST_FUNCTION_ANCS_POSITIVE_ACTION: {
7458                         char value[6];
7459                         char *noti_id = NULL;
7460                         int id;
7461
7462                         if (g_test_param.param_count == 0) {
7463                                 TC_PRT("Input parameters first");
7464                                 break;
7465                         }
7466
7467                         noti_id = g_test_param.params[0];
7468                         id = atoi(noti_id);
7469
7470                         value[0] = 0x02;
7471                         memcpy(&value[1], &id, sizeof(int));
7472                         value[5] = 0x00;
7473
7474                         __ancs_write_value_to_control_point(client,
7475                                         value, sizeof(value));
7476
7477                         break;
7478                 }
7479                 case BT_UNIT_TEST_FUNCTION_ANCS_NEGATIVE_ACTION: {
7480                         char value[6];
7481                         char *noti_id = NULL;
7482                         int id;
7483
7484                         if (g_test_param.param_count == 0) {
7485                                 TC_PRT("Input parameters first");
7486                                 break;
7487                         }
7488
7489                         noti_id = g_test_param.params[0];
7490                         id = atoi(noti_id);
7491
7492                         value[0] = 0x02;
7493                         memcpy(&value[1], &id, sizeof(int));
7494                         value[5] = 0x01;
7495
7496                         __ancs_write_value_to_control_point(client,
7497                                         value, sizeof(value));
7498
7499                         break;
7500                 }
7501                 case BT_UNIT_TEST_FUNCTION_ANCS_GET_NOTI_ATTR: {
7502                         bt_gatt_h ancs_svc = NULL;
7503                         bt_gatt_h data_source = NULL;;
7504                         char *svc_uuid = "7905F431-B5CE-4E99-A40F-4B1E122D00D0";
7505                         char *chr_uuid = "22EAC6E9-24D6-4BB5-BE44-B36ACE7C7BFB";
7506
7507                         char value[19];
7508                         char *noti_id = NULL;
7509                         int id;
7510
7511                         if (g_test_param.param_count == 0) {
7512                                 TC_PRT("Input parameters first");
7513                                 break;
7514                         }
7515
7516                         ret = bt_gatt_client_get_service(client,
7517                                         svc_uuid, &ancs_svc);
7518                         if (ret != BT_ERROR_NONE) {
7519                                 TC_PRT("bt_gatt_client_get_service is failed : %d", ret);
7520                                 break;
7521                         }
7522
7523                         ret = bt_gatt_service_get_characteristic(ancs_svc,
7524                                         chr_uuid, &data_source);
7525                         if (ret != BT_ERROR_NONE) {
7526                                 TC_PRT("bt_gatt_service_get_characteristic is failed : %d", ret);
7527                                 break;
7528                         }
7529
7530                         ret = bt_gatt_client_set_characteristic_value_changed_cb(data_source,
7531                                         __bt_gatt_client_value_changed_cb, NULL);
7532                         if (ret != BT_ERROR_NONE)
7533                                 TC_PRT("bt_gatt_client_set_characteristic_value_changed_cb is failed : %d", ret);
7534
7535                         noti_id = g_test_param.params[0];
7536                         id = atoi(noti_id);
7537
7538                         value[0] = 0x00;
7539                         memcpy(&value[1], &id, sizeof(int));
7540                         value[5] = 0x00;
7541                         value[6] = 0x01;
7542                         value[7] = 0xff;
7543                         value[8] = 0x00;
7544                         value[9] = 0x02;
7545                         value[10] = 0xff;
7546                         value[11] = 0x00;
7547                         value[12] = 0x03;
7548                         value[13] = 0xff;
7549                         value[14] = 0x00;
7550                         value[15] = 0x04;
7551                         value[16] = 0x05;
7552                         value[17] = 0x06;
7553                         value[18] = 0x07;
7554
7555                         __ancs_write_value_to_control_point(client,
7556                                         value, sizeof(value));
7557
7558                         break;
7559                 }
7560                 case BT_UNIT_TEST_FUNCTION_GATT_GET_DATA_BATCHING_AVAILABLE_PACKETS: {
7561                         int available = 0;
7562                         ret = bt_gatt_get_data_batching_available_packets(&available);
7563                         TC_PRT("returns %s, (available:%d)\n", __bt_get_error_message(ret), available);
7564                         break;
7565                 }
7566                 case BT_UNIT_TEST_FUNCTION_GATT_ENABLE_DATA_BATCHING: {
7567                         int packet_threshold = 30;
7568                         int timeout = 20;
7569
7570                         if (g_test_param.param_count > 0) {
7571                                 packet_threshold = atoi(g_test_param.params[0]);
7572                                 timeout = atoi(g_test_param.params[1]);
7573
7574                                 __bt_free_test_param(&g_test_param);
7575                         }
7576
7577                         ret = bt_gatt_enable_data_batching(remote_addr, packet_threshold, timeout);
7578                         TC_PRT("returns %s, (packet_threshold:%d, timeout:%d)\n", __bt_get_error_message(ret), packet_threshold, timeout);
7579                         break;
7580                 }
7581                 case BT_UNIT_TEST_FUNCTION_GATT_DISABLE_DATA_BATCHING: {
7582                         ret = bt_gatt_disable_data_batching(remote_addr);
7583                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
7584                         break;
7585                 }
7586                 case BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS:
7587                         need_to_set_params = true;
7588                         TC_PRT("Select the function again");
7589                         break;
7590
7591                 default:
7592                         break;
7593                 }
7594
7595                 break;
7596         }
7597         case BT_UNIT_TEST_TABLE_HPS: {
7598                 switch (test_id) {
7599                 case BT_UNIT_TEST_FUNCTION_HPS_CLIENT_CREATE: {
7600                         bool auto_connect = false;
7601
7602                         if (g_test_param.param_count > 0) {
7603                                 if (g_strrstr(g_test_param.params[0], "true"))
7604                                         auto_connect = true;
7605                                 else
7606                                         auto_connect = false;
7607
7608                                 __bt_free_test_param(&g_test_param);
7609                         }
7610
7611                         ret = bt_gatt_connect(remote_addr, auto_connect);
7612                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
7613                         ret = bt_gatt_set_connection_state_changed_cb(
7614                                         __bt_hps_connection_state_changed_cb,
7615                                         NULL);
7616                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
7617                         break;
7618                 }
7619                 case BT_UNIT_TEST_FUNCTION_HPS_CLIENT_DESTROY: {
7620                         if (!hps_client)
7621                                 break;
7622
7623                         ret = bt_gatt_client_destroy(hps_client);
7624                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
7625                         hps_client = NULL;
7626                         ret = bt_gatt_disconnect(remote_addr);
7627                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
7628                         break;
7629                 }
7630                 case BT_UNIT_TEST_FUNCTION_HPS_CLIENT_PRINT_ALL: {
7631 #ifdef ARCH64
7632                         ret = bt_gatt_client_foreach_services(hps_client,
7633                                         __bt_hps_client_svc_cb, (void *)(uintptr_t)test_id);
7634 #else
7635                         ret = bt_gatt_client_foreach_services(hps_client,
7636                                         __bt_hps_client_svc_cb, (void *)test_id);
7637 #endif
7638                         if (ret != BT_ERROR_NONE)
7639                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
7640                         break;
7641                 }
7642                 case BT_UNIT_TEST_FUNCTION_HPS_CLIENT_SET_URI: {
7643                         bt_gatt_h svc = NULL;
7644                         bt_gatt_h chr = NULL;
7645                         char *uri = NULL;
7646
7647                         if (g_test_param.param_count < 1) {
7648                                                         TC_PRT("Input parameters first");
7649                                                         break;
7650                         }
7651
7652                         uri = g_test_param.params[0];
7653                         ret = bt_gatt_client_get_service(hps_client,
7654                                         HPS_UUID, &svc);
7655                         if (ret != BT_ERROR_NONE) {
7656                                 TC_PRT("bt_gatt_client_get_service is failed : %d", ret);
7657                                 __bt_free_test_param(&g_test_param);
7658                                 break;
7659                         }
7660
7661                         ret = bt_gatt_service_get_characteristic(svc,
7662                                         HTTP_URI_UUID, &chr);
7663                         if (ret != BT_ERROR_NONE) {
7664                                 TC_PRT("bt_gatt_service_get_characteristic is failed : %d", ret);
7665                                 __bt_free_test_param(&g_test_param);
7666                                 break;
7667                         }
7668
7669                         ret = __bt_gatt_client_set_value("str", uri, chr);
7670                         if (ret != BT_ERROR_NONE) {
7671                                 TC_PRT("bt_gatt_set_value is failed : %d", ret);
7672                                 __bt_free_test_param(&g_test_param);
7673                                 break;
7674                         }
7675
7676                         ret = bt_gatt_client_write_value(chr,
7677                                         __bt_gatt_client_write_complete_cb, NULL);
7678
7679                         if (ret != BT_ERROR_NONE)
7680                                 TC_PRT("bt_gatt_client_write_value is failed : %d", ret);
7681
7682                         __bt_free_test_param(&g_test_param);
7683                         break;
7684                 }
7685                 case BT_UNIT_TEST_FUNCTION_HPS_CLIENT_SET_HDR: {
7686                         bt_gatt_h svc = NULL;
7687                         bt_gatt_h chr = NULL;
7688                         char *hdr = NULL;
7689
7690                         if (g_test_param.param_count < 1) {
7691                                                         TC_PRT("Input parameters first");
7692                                                         break;
7693                         }
7694
7695                         hdr = g_test_param.params[0];
7696
7697                         ret = bt_gatt_client_get_service(hps_client,
7698                                         HPS_UUID, &svc);
7699                         if (ret != BT_ERROR_NONE) {
7700                                 TC_PRT("bt_gatt_client_get_service is failed : %d", ret);
7701                                 __bt_free_test_param(&g_test_param);
7702                                 break;
7703                         }
7704
7705                         ret = bt_gatt_service_get_characteristic(svc,
7706                                         HTTP_HDR_UUID, &chr);
7707                         if (ret != BT_ERROR_NONE) {
7708                                 TC_PRT("bt_gatt_service_get_characteristic is failed : %d", ret);
7709                                 __bt_free_test_param(&g_test_param);
7710                                 break;
7711                         }
7712
7713                         ret = __bt_gatt_client_set_value("str", hdr, chr);
7714                         if (ret != BT_ERROR_NONE) {
7715                                 TC_PRT("bt_gatt_set_value is failed : %d", ret);
7716                                 __bt_free_test_param(&g_test_param);
7717                                 break;
7718                         }
7719
7720                         ret = bt_gatt_client_write_value(chr,
7721                                         __bt_gatt_client_write_complete_cb, NULL);
7722
7723                         if (ret != BT_ERROR_NONE)
7724                                 TC_PRT("bt_gatt_client_write_value is failed : %d", ret);
7725
7726                         __bt_free_test_param(&g_test_param);
7727                         break;
7728                 }
7729                 case BT_UNIT_TEST_FUNCTION_HPS_CLIENT_SET_ENTITY: {
7730                         bt_gatt_h svc = NULL;
7731                         bt_gatt_h chr = NULL;
7732                         char *entity = NULL;
7733
7734                         if (g_test_param.param_count < 1) {
7735                                                         TC_PRT("Input parameters first");
7736                                                         break;
7737                         }
7738
7739                         entity = g_test_param.params[0];
7740
7741                         ret = bt_gatt_client_get_service(hps_client,
7742                                         HPS_UUID, &svc);
7743                         if (ret != BT_ERROR_NONE) {
7744                                 TC_PRT("bt_gatt_client_get_service is failed : %d", ret);
7745                                 __bt_free_test_param(&g_test_param);
7746                                 break;
7747                         }
7748
7749                         ret = bt_gatt_service_get_characteristic(svc,
7750                                         HTTP_ENTITY_UUID, &chr);
7751                         if (ret != BT_ERROR_NONE) {
7752                                 TC_PRT("bt_gatt_service_get_characteristic is failed : %d", ret);
7753                                 __bt_free_test_param(&g_test_param);
7754                                 break;
7755                         }
7756
7757                         ret = __bt_gatt_client_set_value("str",
7758                                         entity, chr);
7759                         if (ret != BT_ERROR_NONE) {
7760                                 TC_PRT("bt_gatt_set_value is failed : %d", ret);
7761                                 __bt_free_test_param(&g_test_param);
7762                                 break;
7763                         }
7764
7765                         ret = bt_gatt_client_set_characteristic_value_changed_cb(chr,
7766                                         __bt_HP_client_cp_req_status_changed_cb, NULL);
7767
7768                         if (ret != BT_ERROR_NONE)
7769                                 TC_PRT("bt_gatt_client_write_value is failed : %d", ret);
7770
7771                         ret = bt_gatt_client_write_value(chr,
7772                                         __bt_gatt_client_write_complete_cb, NULL);
7773
7774                         if (ret != BT_ERROR_NONE)
7775                                 TC_PRT("bt_gatt_client_write_value is failed : %d", ret);
7776
7777                         __bt_free_test_param(&g_test_param);
7778                         break;
7779                 }
7780                 case BT_UNIT_TEST_FUNCTION_HPS_CLIENT_SET_CP: {
7781                         bt_gatt_h svc = NULL;
7782                         bt_gatt_h chr = NULL;
7783
7784                         if (g_test_param.param_count < 1) {
7785                                         TC_PRT("Input parameters first");
7786                                         break;
7787                         }
7788
7789                         ret = bt_gatt_client_get_service(hps_client,
7790                                         HPS_UUID, &svc);
7791                         if (ret != BT_ERROR_NONE) {
7792                                 TC_PRT("bt_gatt_client_get_service is failed : %d", ret);
7793                                 __bt_free_test_param(&g_test_param);
7794                                 break;
7795                         }
7796
7797                         ret = bt_gatt_service_get_characteristic(svc,
7798                                         HTTP_CP_UUID, &chr);
7799                         if (ret != BT_ERROR_NONE) {
7800                                 TC_PRT("bt_gatt_service_get_characteristic is failed : %d", ret);
7801                                 __bt_free_test_param(&g_test_param);
7802                                 break;
7803                         }
7804
7805                         ret = __bt_gatt_client_set_value("uint8",
7806                                         g_test_param.params[0], chr);
7807                         if (ret != BT_ERROR_NONE) {
7808                                 TC_PRT("bt_gatt_set_value is failed : %d", ret);
7809                                 __bt_free_test_param(&g_test_param);
7810                                 break;
7811                         }
7812
7813                         ret = bt_gatt_client_write_value(chr,
7814                                         __bt_gatt_client_write_complete_cb, NULL);
7815
7816                         if (ret != BT_ERROR_NONE)
7817                                 TC_PRT("bt_gatt_client_write_value is failed : %d", ret);
7818
7819                         __bt_free_test_param(&g_test_param);
7820                         break;
7821                 }
7822
7823                 case BT_UNIT_TEST_FUNCTION_HPS_CLIENT_GET_URI: {
7824                         bt_gatt_h svc = NULL;
7825                         bt_gatt_h chr = NULL;
7826
7827                         ret = bt_gatt_client_get_service(hps_client,
7828                                         HPS_UUID, &svc);
7829                         if (ret != BT_ERROR_NONE) {
7830                                 TC_PRT("bt_gatt_client_get_service is failed : %d", ret);
7831                                 break;
7832                         }
7833
7834                         ret = bt_gatt_service_get_characteristic(svc,
7835                                         HTTP_URI_UUID, &chr);
7836                         if (ret != BT_ERROR_NONE) {
7837                                 TC_PRT("bt_gatt_service_get_characteristic is failed : %d", ret);
7838                                         break;
7839                         }
7840
7841                         ret = bt_gatt_client_read_value(chr,
7842                                         __bt_gatt_client_read_complete_cb, NULL);
7843
7844                         if (ret != BT_ERROR_NONE)
7845                                 TC_PRT("bt_gatt_client_read_value is failed : %d", ret);
7846                         break;
7847                 }
7848
7849                 case BT_UNIT_TEST_FUNCTION_HPS_CLIENT_GET_HDR: {
7850                         bt_gatt_h svc = NULL;
7851                         bt_gatt_h chr = NULL;
7852
7853                         ret = bt_gatt_client_get_service(hps_client,
7854                                         HPS_UUID, &svc);
7855                         if (ret != BT_ERROR_NONE) {
7856                                 TC_PRT("bt_gatt_client_get_service is failed : %d", ret);
7857                                 break;
7858                         }
7859
7860                         ret = bt_gatt_service_get_characteristic(svc,
7861                                         HTTP_HDR_UUID, &chr);
7862                         if (ret != BT_ERROR_NONE) {
7863                                 TC_PRT("bt_gatt_service_get_characteristic is failed : %d", ret);
7864                                         break;
7865                         }
7866
7867                         ret = bt_gatt_client_read_value(chr,
7868                                         __bt_gatt_client_read_complete_cb, NULL);
7869
7870                         if (ret != BT_ERROR_NONE)
7871                                 TC_PRT("bt_gatt_client_read_value is failed : %d", ret);
7872                         break;
7873                 }
7874                 case BT_UNIT_TEST_FUNCTION_HPS_CLIENT_GET_ENTITY: {
7875                         bt_gatt_h svc = NULL;
7876                         bt_gatt_h chr = NULL;
7877
7878                         ret = bt_gatt_client_get_service(hps_client,
7879                                         HPS_UUID, &svc);
7880                         if (ret != BT_ERROR_NONE) {
7881                                 TC_PRT("bt_gatt_client_get_service is failed : %d", ret);
7882                                 break;
7883                         }
7884
7885                         ret = bt_gatt_service_get_characteristic(svc,
7886                                         HTTP_ENTITY_UUID, &chr);
7887                         if (ret != BT_ERROR_NONE) {
7888                                 TC_PRT("bt_gatt_service_get_characteristic is failed : %d", ret);
7889                                         break;
7890                         }
7891
7892                         ret = bt_gatt_client_read_value(chr,
7893                                         __bt_gatt_client_read_complete_cb, NULL);
7894
7895                         if (ret != BT_ERROR_NONE)
7896                                 TC_PRT("bt_gatt_client_read_value is failed : %d", ret);
7897
7898                         break;
7899                 }
7900                 case BT_UNIT_TEST_FUNCTION_HPS_CLIENT_GET_SECURITY: {
7901                         bt_gatt_h svc = NULL;
7902                         bt_gatt_h chr = NULL;
7903
7904                         ret = bt_gatt_client_get_service(hps_client,
7905                                         HPS_UUID, &svc);
7906                         if (ret != BT_ERROR_NONE) {
7907                                 TC_PRT("bt_gatt_client_get_service is failed : %d", ret);
7908                                 break;
7909                         }
7910
7911                         ret = bt_gatt_service_get_characteristic(svc,
7912                                         HTTP_SECURITY_UUID, &chr);
7913                         if (ret != BT_ERROR_NONE) {
7914                                 TC_PRT("bt_gatt_service_get_characteristic is failed : %d", ret);
7915                                         break;
7916                         }
7917
7918                         ret = bt_gatt_client_read_value(chr,
7919                                         __bt_gatt_client_read_complete_cb, NULL);
7920
7921                         if (ret != BT_ERROR_NONE)
7922                                 TC_PRT("bt_gatt_client_read_value is failed : %d", ret);
7923
7924                         break;
7925                 }
7926                 case BT_UNIT_TEST_FUNCTION_HPS_CLIENT_SET_STATUS_NOTIFICATION: {
7927                         bt_gatt_h svc = NULL;
7928                         bt_gatt_h chr = NULL;
7929
7930                         ret = bt_gatt_client_get_service(hps_client,
7931                                         HPS_UUID, &svc);
7932                         if (ret != BT_ERROR_NONE) {
7933                                 TC_PRT("bt_gatt_client_get_service is failed : %d", ret);
7934                                 break;
7935                         }
7936
7937                         ret = bt_gatt_service_get_characteristic(svc,
7938                                         HTTP_STATUS_UUID, &chr);
7939                         if (ret != BT_ERROR_NONE) {
7940                                 TC_PRT("bt_gatt_service_get_characteristic is failed : %d", ret);
7941                                 break;
7942                         }
7943
7944                         ret = bt_gatt_client_set_characteristic_value_changed_cb(chr,
7945                                         __bt_gatt_client_value_changed_cb, NULL);
7946                         if (ret != BT_ERROR_NONE)
7947                                 TC_PRT("bt_gatt_client_set_characteristic_value_changed_cb is failed : %d", ret);
7948                         break;
7949                 }
7950                 case BT_UNIT_TEST_FUNCTION_HPS_CLIENT_UNSET_STATUS_NOTIFICATION: {
7951                         bt_gatt_h svc = NULL;
7952                         bt_gatt_h chr = NULL;
7953
7954                         ret = bt_gatt_client_get_service(hps_client,
7955                                         HPS_UUID, &svc);
7956                         if (ret != BT_ERROR_NONE) {
7957                                 TC_PRT("bt_gatt_client_get_service is failed : %d", ret);
7958                                 break;
7959                         }
7960
7961                         ret = bt_gatt_service_get_characteristic(svc,
7962                                         HTTP_STATUS_UUID, &chr);
7963                         if (ret != BT_ERROR_NONE) {
7964                                 TC_PRT("bt_gatt_service_get_characteristic is failed : %d", ret);
7965                                 break;
7966                         }
7967
7968                         ret = bt_gatt_client_unset_characteristic_value_changed_cb(chr);
7969                         if (ret != BT_ERROR_NONE)
7970                                 TC_PRT("bt_gatt_client_unset_characteristic_value_changed_cb is failed : %d", ret);
7971                         break;
7972                 }
7973                 case BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS:
7974                         need_to_set_params = true;
7975                         TC_PRT("Select the function again");
7976                         break;
7977
7978                 default:
7979                         break;
7980                 }
7981
7982                 break;
7983         }
7984
7985
7986         case BT_UNIT_TEST_TABLE_AVRCP: {
7987                 switch (test_id) {
7988                 case BT_UNIT_TEST_FUNCTION_AVRCP_TARGET_INITIALIZE:
7989                         ret = bt_avrcp_target_initialize(
7990                                         __bt_avrcp_target_connection_state_changed_cb,
7991                                         NULL);
7992                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
7993                         break;
7994
7995                 case BT_UNIT_TEST_FUNCTION_AVRCP_TARGET_DEINITIALIZE:
7996                         ret = bt_avrcp_target_deinitialize();
7997                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
7998                         break;
7999
8000                 case BT_UNIT_TEST_FUNCTION_AVRCP_SET_EQUALIZER_STATE_CHANGED_CB:
8001                         ret = bt_avrcp_set_equalizer_state_changed_cb(
8002                                         __bt_avrcp_equalizer_state_changed_cb,
8003                                         NULL);
8004                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8005                         break;
8006
8007                 case BT_UNIT_TEST_FUNCTION_AVRCP_SET_REPEAT_MODE_CHANGED_CB:
8008                         ret = bt_avrcp_set_repeat_mode_changed_cb(
8009                                         __bt_avrcp_repeat_mode_changed_cb,
8010                                         NULL);
8011                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8012                         break;
8013
8014                 case BT_UNIT_TEST_FUNCTION_AVRCP_SET_SHUFFLE_MODE_CHANGED_CB:
8015                         ret = bt_avrcp_set_shuffle_mode_changed_cb(
8016                                         __bt_avrcp_shuffle_mode_changed_cb,
8017                                         NULL);
8018                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8019                         break;
8020
8021                 case BT_UNIT_TEST_FUNCTION_AVRCP_SET_SCAN_MODE_CHANGED_CB:
8022                         ret = bt_avrcp_set_scan_mode_changed_cb(
8023                                         __bt_avrcp_scan_mode_changed_cb,
8024                                         NULL);
8025                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8026                         break;
8027
8028                 case BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_EQUALIZER_STATE_CHANGED_CB:
8029                         ret = bt_avrcp_unset_equalizer_state_changed_cb();
8030                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8031                         break;
8032
8033                 case BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_REPEAT_MODE_CHANGED_CB:
8034                         ret = bt_avrcp_unset_repeat_mode_changed_cb();
8035                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8036                         break;
8037
8038                 case BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_SHUFFLE_MODE_CHANGED_CB:
8039                         ret = bt_avrcp_unset_shuffle_mode_changed_cb();
8040                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8041                         break;
8042
8043                 case BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_SCAN_MODE_CHANGED_CB:
8044                         ret = bt_avrcp_unset_scan_mode_changed_cb();
8045                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8046                         break;
8047
8048                 case BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_INITIALIZE:
8049                         ret = bt_avrcp_control_initialize(
8050                                         __bt_avrcp_control_connection_state_changed_cb,
8051                                         NULL);
8052                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8053                         break;
8054
8055                 case BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_DEINITIALIZE:
8056                         ret = bt_avrcp_control_deinitialize();
8057                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8058                         break;
8059
8060                 case BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_CONNECT:
8061                         ret = bt_avrcp_control_connect(remote_addr);
8062                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8063                         break;
8064
8065                 case BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_DISCONNECT:
8066                         ret = bt_avrcp_control_disconnect(remote_addr);
8067                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8068                         break;
8069
8070                 case BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_PLAY:
8071                         ret = bt_avrcp_control_send_player_command(BT_AVRCP_CONTROL_PLAY);
8072                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8073                         break;
8074
8075                 case BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_STOP:
8076                         ret = bt_avrcp_control_send_player_command(BT_AVRCP_CONTROL_STOP);
8077                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8078                         break;
8079
8080                 case BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_PAUSE:
8081                         ret = bt_avrcp_control_send_player_command(BT_AVRCP_CONTROL_PAUSE);
8082                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8083                         break;
8084
8085                 case BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_FF:
8086                         ret = bt_avrcp_control_send_player_command(BT_AVRCP_CONTROL_FAST_FORWARD);
8087                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8088                         break;
8089
8090                 case BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_RW:
8091                         ret = bt_avrcp_control_send_player_command(BT_AVRCP_CONTROL_REWIND);
8092                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8093                         break;
8094
8095                 case BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_NEXT:
8096                         ret = bt_avrcp_control_send_player_command(BT_AVRCP_CONTROL_NEXT);
8097                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8098                         break;
8099
8100                 case BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_PREV: {
8101                         ret = bt_avrcp_control_send_player_command(BT_AVRCP_CONTROL_PREVIOUS);
8102                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8103                         break;
8104                         }
8105                 case BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_SET_ABSOLUTE_VOLUME: {
8106                         static unsigned int volume_level = 1;
8107                         ret = bt_avrcp_control_set_absolute_volume(volume_level++);
8108                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8109                         break;
8110                         }
8111                 case BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_VOLUME_UP: {
8112                         ret = bt_avrcp_control_increase_volume();
8113                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8114                         break;
8115                         }
8116                 case BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_VOLUME_DOWN: {
8117                         ret = bt_avrcp_control_decrease_volume();
8118                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8119                         break;
8120                         }
8121                 case BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_SEND_DELAY_REPORT: {
8122                         static unsigned int delay_level = 1;
8123                         ret = bt_avrcp_control_send_delay_report(delay_level++);
8124                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8125                         break;
8126                         }
8127                 case BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_GET_REPEAT: {
8128                         bt_avrcp_repeat_mode_e mode = BT_AVRCP_REPEAT_MODE_GROUP;
8129                         ret = bt_avrcp_control_get_repeat_mode(&mode);
8130                         TC_PRT("Repet mode : %d returns %s\n", mode,
8131                                         __bt_get_error_message(ret));
8132                         break;
8133                         }
8134
8135                 case BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_SET_REPEAT: {
8136                         ret = bt_avrcp_control_set_repeat_mode(2);
8137                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8138                         break;
8139                         }
8140
8141                 case BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_GET_SHUFFLE: {
8142                         bt_avrcp_shuffle_mode_e mode = BT_AVRCP_SHUFFLE_MODE_ALL_TRACK;
8143                         ret = bt_avrcp_control_get_shuffle_mode(&mode);
8144                         TC_PRT("Shuffle mode %d returns %s\n", mode, __bt_get_error_message(ret));
8145                         break;
8146                         }
8147
8148                 case BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_SET_SHUFFLE: {
8149                         ret = bt_avrcp_control_set_shuffle_mode(1);
8150                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8151                         break;
8152                         }
8153
8154                 case BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_GET_POSITION: {
8155                         unsigned int position = 0;
8156                         ret = bt_avrcp_control_get_position(&position);
8157                         TC_PRT("position %d returns %s\n", position, __bt_get_error_message(ret));
8158                         break;
8159                         }
8160
8161                 case BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_GET_PLAY_STATUS: {
8162                         unsigned int status = 0;
8163                         ret = bt_avrcp_control_get_play_status(&status);
8164                         TC_PRT("status %d returns %s\n", status, __bt_get_error_message(ret));
8165                         break;
8166                         }
8167
8168                 case BT_UNIT_TEST_FUNCTION_AVRCP_CONTROL_GET_TRACK_INFO: {
8169                         bt_avrcp_metadata_attributes_info_s *track;
8170                         ret = bt_avrcp_control_get_track_info(&track);
8171                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8172                         if (ret == BT_ERROR_NONE) {
8173                                 TC_PRT("Title. %s\n", track->title);
8174                                 TC_PRT("Artist %s\n", track->artist);
8175                                 TC_PRT("Album %s\n", track->album);
8176                                 TC_PRT("Genre %s\n", track->genre);
8177                                 TC_PRT("Total tracks %d\n", track->total_tracks);
8178                                 TC_PRT("Number %d\n", track->number);
8179                                 TC_PRT("Duration %d\n", track->duration);
8180                                 bt_avrcp_control_free_track_info(track);
8181                         }
8182                         break;
8183                         }
8184
8185                 case BT_UNIT_TEST_FUNCTION_AVRCP_SET_SONG_POSITION_CHANGED_CB:
8186                         ret = bt_avrcp_set_position_changed_cb(
8187                                         __bt_avrcp_song_position_changed_cb,
8188                                         NULL);
8189                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8190                         break;
8191
8192                 case BT_UNIT_TEST_FUNCTION_AVRCP_SET_PLAY_STATE_CHANGED_CB:
8193                         ret = bt_avrcp_set_play_status_changed_cb(
8194                                         __bt_avrcp_player_state_changed_cb,
8195                                         NULL);
8196                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8197                         break;
8198
8199                 case BT_UNIT_TEST_FUNCTION_AVRCP_SET_TRACK_INFO_CHANGED_CB:
8200                         ret = bt_avrcp_set_track_info_changed_cb(
8201                                         __bt_avrcp_track_info_changed_cb,
8202                                         NULL);
8203                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8204                         break;
8205
8206                 case BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_SONG_POSITION_CHANGED_CB:
8207                         ret = bt_avrcp_unset_position_changed_cb();
8208                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8209                         break;
8210
8211                 case BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_PLAY_STATE_CHANGED_CB:
8212                         ret = bt_avrcp_unset_play_status_changed_cb();
8213                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8214                         break;
8215
8216                 case BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_TRACK_INFO_CHANGED_CB:
8217                         ret = bt_avrcp_unset_track_info_changed_cb();
8218                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8219                         break;
8220
8221                 case BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS:
8222                         need_to_set_params = true;
8223                         TC_PRT("Select the function again");
8224                         break;
8225
8226                 default:
8227                         break;
8228                 }
8229
8230                 break;
8231         }
8232         case BT_UNIT_TEST_TABLE_HID: {
8233                 switch (test_id) {
8234                 case BT_UNIT_TEST_FUNCTION_HID_HOST_INITIALIZE:
8235                         ret = bt_hid_host_initialize(
8236                                         __bt_hid_host_connection_state_changed_cb,
8237                                         NULL);
8238                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8239                         break;
8240                 case BT_UNIT_TEST_FUNCTION_HID_HOST_DEINITIALIZE:
8241                         ret = bt_hid_host_deinitialize();
8242                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8243                         break;
8244                 case BT_UNIT_TEST_FUNCTION_HID_HOST_CONNECT: {
8245                         ret = bt_hid_host_connect(remote_addr);
8246                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8247                         break;
8248                 }
8249                 case BT_UNIT_TEST_FUNCTION_HID_HOST_DISCONNECT: {
8250                         ret = bt_hid_host_disconnect(remote_addr);
8251                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8252                         break;
8253                 }
8254                 case BT_UNIT_TEST_FUNCTION_HID_DEVICE_ACTIVATE: {
8255                         ret = bt_hid_device_activate(
8256                                         __bt_hid_device_connection_state_changed_cb,
8257                                         NULL);
8258                         TC_PRT("returns %s", __bt_get_error_message(ret));
8259                         break;
8260                 }
8261                 case BT_UNIT_TEST_FUNCTION_HID_DEVICE_CONNECT: {
8262                         ret = bt_hid_device_connect(remote_addr);
8263                         TC_PRT("returns %s", __bt_get_error_message(ret));
8264                         break;
8265                 }
8266                 case BT_UNIT_TEST_FUCNTION_HID_DEVICE_DEACTIVATE: {
8267                         ret = bt_hid_device_deactivate();
8268                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8269                         break;
8270                 }
8271                 case BT_UNIT_TEST_FUNCTION_HID_DEVICE_DISCONNECT: {
8272                         ret = bt_hid_device_disconnect(remote_addr);
8273                         TC_PRT("return %s", __bt_get_error_message(ret));
8274                         break;
8275                 }
8276                 case BT_UNIT_TEST_FUNCTION_HID_DEVICE_SEND_MOUSE_EVENT: {
8277                         bt_hid_mouse_data_s send_data;
8278                         int i;
8279
8280                         send_data.buttons = 1;
8281                         send_data.padding  = BT_HID_MOUSE_BUTTON_LEFT;
8282
8283                         send_data.axis_x = 10;
8284                         send_data.axis_y = 0;
8285                         for (i = 0; i < 30; i++) {
8286                                 usleep(30000);
8287                                 ret = bt_hid_device_send_mouse_event(
8288                                                 remote_addr, &send_data);
8289                                 if (ret < 0)
8290                                         TC_PRT("returns %d\n", ret);
8291                         }
8292                         send_data.axis_x = 0;
8293                         send_data.axis_y = 10;
8294                         for (i = 0; i < 30; i++) {
8295                                 usleep(30000);
8296                                 ret = bt_hid_device_send_mouse_event(
8297                                                 remote_addr, &send_data);
8298                                 if (ret < 0)
8299                                         TC_PRT("returns %d\n", ret);
8300                         }
8301                         send_data.axis_x = -10;
8302                         send_data.axis_y = 0;
8303                         for (i = 0; i < 60; i++) {
8304                                 usleep(30000);
8305                                 ret = bt_hid_device_send_mouse_event(
8306                                                 remote_addr, &send_data);
8307                                 if (ret < 0)
8308                                         TC_PRT("returns %d\n", ret);
8309                         }
8310                         send_data.axis_x = 0;
8311                         send_data.axis_y = -10;
8312                         for (i = 0; i < 60; i++) {
8313                                 usleep(30000);
8314                                 ret = bt_hid_device_send_mouse_event(
8315                                                 remote_addr, &send_data);
8316                                 if (ret < 0)
8317                                         TC_PRT("returns %d\n", ret);
8318                         }
8319                         send_data.axis_x = 10;
8320                         send_data.axis_y = 0;
8321                         for (i = 0; i < 60; i++) {
8322                                 usleep(30000);
8323                                 ret = bt_hid_device_send_mouse_event(
8324                                                 remote_addr, &send_data);
8325                                 if (ret < 0)
8326                                         TC_PRT("returns %d\n", ret);
8327                         }
8328                         send_data.axis_x = 0;
8329                         send_data.axis_y = 10;
8330                         for (i = 0; i < 30; i++) {
8331                                 usleep(30000);
8332                                 ret = bt_hid_device_send_mouse_event(
8333                                                 remote_addr, &send_data);
8334                                 if (ret < 0)
8335                                         TC_PRT("returns %d\n", ret);
8336                         }
8337                         send_data.axis_x = -10;
8338                         send_data.axis_y = 0;
8339                         for (i = 0; i < 30; i++) {
8340                                 usleep(30000);
8341                                 ret = bt_hid_device_send_mouse_event(
8342                                                 remote_addr, &send_data);
8343                                 if (ret < 0)
8344                                         TC_PRT("returns %d\n", ret);
8345                         }
8346                         TC_PRT("Completed");
8347
8348                         break;
8349                 }
8350                 case BT_UNIT_TEST_FUNCTION_HID_DEVICE_SEND_MOUSE_EVENT_SCROLL: {
8351                         bt_hid_mouse_data_s send_data;
8352
8353                         send_data.buttons = BT_HID_MOUSE_BUTTON_NONE;
8354                         send_data.padding  = 0x01;
8355
8356                         send_data.axis_x = 0;
8357                         send_data.axis_y = 0;
8358                         TC_PRT("Scroll UP");
8359                         ret = bt_hid_device_send_mouse_event(remote_addr, &send_data);
8360                         if (ret < 0)
8361                                 TC_PRT("returns %d\n", ret);
8362                         break;
8363                 }
8364                 case BT_UNIT_TEST_FUNCTION_HID_DEVICE_SEND_MOUSE_EVENT_SCROLL_DOWN: {
8365                         bt_hid_mouse_data_s send_data;
8366                         send_data.buttons = BT_HID_MOUSE_BUTTON_NONE;
8367                         send_data.padding = 0xff;
8368                         send_data.axis_x = 0;
8369                         send_data.axis_y = 0;
8370                         TC_PRT("Scroll Down");
8371                         ret = bt_hid_device_send_mouse_event(remote_addr, &send_data);
8372                                 if (ret < 0)
8373                                         TC_PRT("returns %d\n", ret);
8374                         break;
8375                 }
8376                 case BT_UNIT_TEST_FUNCTION_HID_DEVICE_SEND_KEY_EVENT: {
8377                         bt_hid_key_data_s send_data;
8378                         /* Will send character 'a' */
8379                         char    pressedkey[8]    = { 4, 0, 0, 0,  0, 0, 0, 0 };
8380                         char    pressedkey1[8]   = { 0, 0, 0, 0,  0, 0, 0, 0 };
8381                         memcpy(send_data.key, pressedkey, 8);
8382                         send_data.modifier = 0;
8383                         ret = bt_hid_device_send_key_event(
8384                                         remote_addr, &send_data);
8385                         TC_PRT("returns %d\n", ret);
8386                         memcpy(send_data.key, pressedkey1, 8);
8387                         ret = bt_hid_device_send_key_event(
8388                                         remote_addr, &send_data);
8389                         TC_PRT("returns %d\n", ret);
8390                         break;
8391                 }
8392                 case BT_UNIT_TEST_FUNCTION_HID_DEVICE_SEND_RC_KEY_EVENT: {
8393                         unsigned char report_id = 0xF7;
8394                         char pressed_data[6]    = {0x07, 0x00, 0x00, 0x00, 0x00, 0x00};
8395                         char released_data[6]   = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
8396                         static int mode = 1;
8397
8398                         if (g_test_param.param_count > 0) {
8399                                 mode = atoi(g_test_param.params[0]);
8400                                 __bt_free_test_param(&g_test_param);
8401                         }
8402
8403                         if (mode == 1)
8404                                 pressed_data[0] = 0x07;  /* Vol up */
8405                         else if (mode == 2)
8406                                 pressed_data[0] = 0x0B; /* Vol down */
8407                         else if (mode == 3)
8408                                 pressed_data[0] = 0x12; /* CH up */
8409                         else if (mode == 4)
8410                                 pressed_data[0] = 0x10; /* CH down */
8411
8412                         ret = bt_hid_device_send_custom_event(remote_addr,
8413                                         report_id, pressed_data, 6);
8414                         TC_PRT("returns %d\n", ret);
8415
8416                         ret = bt_hid_device_send_custom_event(remote_addr,
8417                                         report_id, released_data, 6);
8418                         TC_PRT("returns %d\n", ret);
8419
8420                         break;
8421                 }
8422                 case BT_UNIT_TEST_FUNCTION_HID_DEVICE_SET_DATA_RECEIVED_CB: {
8423                         ret = bt_hid_device_set_data_received_cb(
8424                                         __bt_hid_device_data_received_cb,
8425                                         NULL);
8426                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8427                         break;
8428                 }
8429                 case BT_UNIT_TEST_FUNCTION_HID_DEVICE_UNSET_DATA_RECEIVED_CB: {
8430                         ret = bt_hid_device_unset_data_received_cb();
8431                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8432                         break;
8433                 }
8434
8435                 case BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS:
8436                         need_to_set_params = true;
8437                         TC_PRT("Select the function again");
8438                         break;
8439
8440                 default:
8441                         break;
8442                 }
8443
8444                 break;
8445         }
8446
8447         case BT_UNIT_TEST_TABLE_IPSP: {
8448                 switch (test_id) {
8449                 case BT_UNIT_TEST_FUNCTION_IPSP_REGISTER: {
8450                         bt_gatt_h service = NULL;
8451                         char *service_uuid = "1820"; /* IPSP Service */
8452
8453                         ret = bt_gatt_server_initialize();
8454                         TC_PRT("bt_gatt_server_initialize : %s \n", __bt_get_error_message(ret));
8455
8456                         if (server == NULL) {
8457                                 ret = bt_gatt_server_create(&server);
8458                                 TC_PRT("bt_gatt_server_create : %s \n", __bt_get_error_message(ret));
8459                         }
8460
8461                         ret = bt_gatt_service_create(service_uuid, BT_GATT_SERVICE_TYPE_PRIMARY, &service);
8462                         TC_PRT("bt_gatt_service_create : %s \n", __bt_get_error_message(ret));
8463
8464                         ret = bt_gatt_server_register_service(server, service);
8465                         TC_PRT("bt_gatt_server_register_service : %s\n", __bt_get_error_message(ret));
8466                         ipsp_h.svc = service;
8467
8468                         break;
8469                 }
8470                 case BT_UNIT_TEST_FUNCTION_IPSP_UNREGISTER:
8471                         if (server != NULL && ipsp_h.svc != NULL) {
8472                                 ret = bt_gatt_server_unregister_service(server,
8473                                                 ipsp_h.svc);
8474                                 TC_PRT("bt_gatt_server_unregister_service : returns %s\n",
8475                                                 __bt_get_error_message(ret));
8476                                 if (ret == BT_ERROR_NONE)
8477                                         ipsp_h.svc = NULL;
8478                         } else {
8479                                 TC_PRT("Gatt Server or IPSP not registered !");
8480                         }
8481                         break;
8482                 case BT_UNIT_TEST_FUNCTION_IPSP_INITIALIZE:
8483                         /* Initialize IPSP server */
8484                         if (server != NULL && ipsp_h.svc != NULL) {
8485                                 ret = bt_ipsp_initialize(
8486                                                 &__bt_ipsp_init_state_changed_cb,
8487                                                 NULL);
8488                                 TC_PRT("bt_le_ipsp_initialize : returns %s\n", __bt_get_error_message(ret));
8489                         } else {
8490                                 TC_PRT("Gatt Server or IPSP not registered !");
8491                         }
8492                         break;
8493                 case BT_UNIT_TEST_FUNCTION_IPSP_DEINITIALIZE:
8494                         /* De-Initialize IPSP server */
8495                         ret = bt_ipsp_deinitialize();
8496                         TC_PRT("bt_le_ipsp_deinitialize : returns %s\n", __bt_get_error_message(ret));
8497                         break;
8498                 case BT_UNIT_TEST_FUNCTION_IPSP_CONNECT:
8499                         ret = bt_ipsp_connect(remote_addr);
8500                         TC_PRT("returns %s", __bt_get_error_message(ret));
8501                         break;
8502                 case BT_UNIT_TEST_FUNCTION_IPSP_DISCONNECT:
8503                         ret = bt_ipsp_disconnect(remote_addr);
8504                         TC_PRT("returns %s", __bt_get_error_message(ret));
8505                         break;
8506                 case BT_UNIT_TEST_FUNCTION_IPSP_START_ADVERTISING: {
8507                         const char *ipsp_svc_uuid_16 = "1820";
8508
8509                         /* Add IPSP service in advertising data */
8510                         advertiser = advertiser_list[advertiser_index];
8511                         if (advertiser == NULL) {
8512                                 ret = bt_adapter_le_create_advertiser(&advertiser);
8513                                 if (ret != BT_ERROR_NONE) {
8514                                         TC_PRT("created le advertiser(%d)", ret);
8515                                         break;
8516                                 }
8517
8518                                 advertiser_list[advertiser_index] = advertiser;
8519                                 ret = bt_adapter_le_set_advertising_device_name(advertiser,
8520                                                 BT_ADAPTER_LE_PACKET_SCAN_RESPONSE, true);
8521                                 if (ret != BT_ERROR_NONE) {
8522                                         TC_PRT("set device name [0x%04x]", ret);
8523                                         break;
8524                                 }
8525                         }
8526
8527                         ret = bt_adapter_le_add_advertising_service_solicitation_uuid(advertiser,
8528                                         BT_ADAPTER_LE_PACKET_ADVERTISING, ipsp_svc_uuid_16);
8529                         if (ret != BT_ERROR_NONE) {
8530                                 TC_PRT("add service_solicitation_uuid [0x%04x]", ret);
8531                                 break;
8532                         }
8533
8534                         /* Start advertising IPSP service */
8535                         bt_adapter_le_advertising_state_changed_cb cb;
8536
8537                         if (advertiser_index == 0) cb = __bt_adapter_le_advertising_state_changed_cb;
8538                         else if (advertiser_index == 1) cb = __bt_adapter_le_advertising_state_changed_cb_2;
8539                         else cb = __bt_adapter_le_advertising_state_changed_cb_3;
8540
8541                         advertiser = advertiser_list[advertiser_index];
8542
8543                         advertiser_index++;
8544                         advertiser_index %= 3;
8545
8546                         TC_PRT("advertiser: %p", advertiser);
8547
8548                         ret = bt_adapter_le_start_advertising_new(advertiser, cb, NULL);
8549                         if (ret < BT_ERROR_NONE)
8550                                 TC_PRT("failed with [0x%04x]", ret);
8551
8552                         break;
8553                 }
8554                 case BT_UNIT_TEST_FUNCTION_IPSP_SET_CONNECTION_STATE_CHANGED_CB:
8555                         ret = bt_ipsp_set_connection_state_changed_cb(
8556                                         __bt_ipsp_connection_state_changed_cb, NULL);
8557                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8558                         break;
8559
8560                 case BT_UNIT_TEST_FUNCTION_IPSP_UNSET_CONNECTION_STATE_CHANGED_CB:
8561                         ret = bt_ipsp_unset_connection_state_changed_cb();
8562                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
8563                         break;
8564
8565                 case BT_UNIT_TEST_FUNCTION_IPSP_CREATE_APP_SERVER_SOCKET: {
8566                         int serverSocket = 0;
8567                         struct ifaddrs *ifap, *ifa;
8568                         struct sockaddr_in6 serverAddr, clientAddr;
8569                         socklen_t clilen;
8570                         char host[NI_MAXHOST];
8571                         char client_ipv6[100] = {0, };
8572                         char *addr = NULL;
8573
8574                         TC_PRT("\n****** IPSP Application Server Started ******\n");
8575
8576                         getifaddrs(&ifap);
8577
8578                         for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
8579                                 if (ifa->ifa_addr->sa_family == AF_INET6) {
8580                                         if (!memcmp(ifa->ifa_name, ipsp_iface_name, IFNAMSIZ)) {
8581                                                 getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in6), host, NI_MAXHOST,
8582                                                                         NULL, 0, NI_NUMERICHOST);
8583                                                 TC_PRT("[IPV6]Host : %s \n", host);
8584                                                 addr = strchr(host, '%');
8585                                                 if (addr != NULL) {
8586                                                         addr = g_strndup(host, (addr - host));
8587                                                         TC_PRT("Found match Interface: %s and addr : %s\n", ifa->ifa_name, addr);
8588                                                 }
8589                                         }
8590                                 }
8591                         }
8592
8593                         freeifaddrs(ifap);
8594
8595                         if (addr != NULL) {
8596                         bzero((char *) &serverAddr, sizeof(serverAddr));
8597
8598                         serverAddr.sin6_flowinfo = 0;
8599                         serverAddr.sin6_family = AF_INET6;
8600                         serverAddr.sin6_addr = in6addr_any;
8601                                 serverAddr.sin6_port = htons(IPSP_PORT);
8602                         serverAddr.sin6_scope_id = if_nametoindex(ipsp_iface_name);
8603                         inet_pton(AF_INET6, addr, &(serverAddr.sin6_addr.s6_addr));
8604
8605                         g_free(addr);
8606
8607                         /* Create the IPSP APP server socket */
8608                         serverSocket = socket(AF_INET6, SOCK_STREAM, 0);
8609                                 if (serverSocket < 0) {
8610                                 TC_PRT("\nIPSP server Error : In socket creation !");
8611                                         break;
8612                                 }
8613                         else
8614                                 TC_PRT("\nIPSP Server : Socket created..");
8615
8616
8617                         /* Bind the address struct to the socket */
8618                                 if (bind(serverSocket, (struct sockaddr *) &serverAddr, sizeof(serverAddr)) < 0) {
8619                                 TC_PRT("\nIPSP server Error : In socket binding !");
8620                                         close(serverSocket);
8621                                         break;
8622                                 }
8623                         else
8624                                 TC_PRT("\nIPSP Server : Socket binding done..");
8625
8626
8627                         /* Listen on the socket, with 1 max connection requests queued */
8628                                 if (listen(serverSocket, 1) < 0) {
8629                                 TC_PRT("\nIPSP server Error : In socket listening !");
8630                                         close(serverSocket);
8631                                         break;
8632                                 }
8633                         else
8634                                 TC_PRT("\nIPSP server : Socket listening, waiting for connection...\n");
8635
8636                         /* Accept call creates a new socket for the incoming connection */
8637                         clilen = sizeof(clientAddr);
8638                         ipsp_server_sock = accept(serverSocket, (struct sockaddr *) &clientAddr, &clilen);
8639                                 if (ipsp_server_sock  < 0) {
8640                                 TC_PRT("\nIPSP server Error : While accepting incoming connection !");
8641                                         close(serverSocket);
8642                                         break;
8643                                 }
8644
8645                         inet_ntop(AF_INET6, &(clientAddr.sin6_addr), client_ipv6, 100);
8646                         TC_PRT("\n****** IPSP server : Incoming connection from client... %s successful, ready to send/receive IPV6 data ******", client_ipv6);
8647
8648                         close(serverSocket);
8649                         } else {
8650                                 TC_PRT("Matching Address is Not Found , Wait till the Connected Event is recieved from STACK");
8651                         }
8652                         break;
8653                 }
8654                 case BT_UNIT_TEST_FUNCTION_IPSP_CONNECT_WITH_APP_SERVER_SOCKET: {
8655                         char *saddr = NULL;
8656                         struct sockaddr_in6 serverAddr;
8657                         struct hostent *server;
8658
8659                         if (g_test_param.param_count < 1) {
8660                                 TC_PRT("Input IPSP Application's server IPv6 address first !");
8661                                 break;
8662                         }
8663                         saddr = g_test_param.params[0];
8664
8665                         TC_PRT("\n****** IPSP Application Client Started ******\n");
8666
8667                         /* Create the IPSP APP Client socket */
8668                         ipsp_client_sock = socket(AF_INET6, SOCK_STREAM, 0);
8669                         if (ipsp_client_sock < 0)
8670                                 TC_PRT("\nIPSP Client Error : In socket creation !");
8671                         else
8672                                 TC_PRT("\nIPSP Client : Socket created..");
8673
8674                         /* Sockets Layer Call: gethostbyname2() */
8675                         server = gethostbyname2(saddr, AF_INET6);
8676
8677                         if (server == NULL)
8678                                 TC_PRT("\nIPSP Client Error : No such host !");
8679                         else {
8680
8681                                 TC_PRT("\nIPSP Client GetHostbyName Success!");
8682                                 memset((char *) &serverAddr, 0, sizeof(serverAddr));
8683                                 serverAddr.sin6_flowinfo = 0;
8684                                 serverAddr.sin6_family = AF_INET6;
8685                                 serverAddr.sin6_addr = in6addr_any;
8686                                 serverAddr.sin6_port = htons(IPSP_PORT);
8687                                 serverAddr.sin6_scope_id = if_nametoindex(ipsp_iface_name);
8688
8689                                 memmove((char *) &serverAddr.sin6_addr.s6_addr, (char *) server->h_addr, server->h_length);
8690
8691                                 TC_PRT("\nIPSP Client Attempt To Connect to server %s!", serverAddr.sin6_addr.s6_addr);
8692                                 /* Connect with IPSP APP Server socket */
8693                                 if (connect(ipsp_client_sock, (struct sockaddr *) &serverAddr, sizeof(serverAddr)) < 0)
8694                                         TC_PRT("\nIPSP Client Error : %d while connecting with server !", errno);
8695                                 else
8696                                         TC_PRT("\n****** IPSP Client : Connection with : %s successful, ready to send/receive IPV6 data ******\n", saddr);
8697
8698                                 __bt_free_test_param(&g_test_param);
8699                         }
8700                         break;
8701                 }
8702                 case BT_UNIT_TEST_FUNCTION_IPSP_SEND_IPV6_APP_DATA: {
8703                         int role = -1, n = 0;
8704                         char *param_data = NULL;
8705
8706                         if (g_test_param.param_count < 2) {
8707                                 TC_PRT("IPSP Error : Input IPSP Application's role and data to send first !");
8708                                 break;
8709                         }
8710
8711                         role = atoi(g_test_param.params[0]);
8712                         param_data = g_test_param.params[1];
8713
8714                         if (role == 0) {
8715                                 if (ipsp_server_sock) {
8716                                         TC_PRT("IPSP : Current role is IPSP Sever !");
8717
8718                                         /* Sockets Layer Call: send() */
8719                                         n = send(ipsp_server_sock, param_data, strlen(param_data) + 1, 0);
8720                                         if (n < 0)
8721                                                 TC_PRT("\nIPSP Error : While sending data !");
8722                                 } else {
8723                                         TC_PRT("IPSP Error: There is no connected server socket !");
8724                                 }
8725                         } else if (role == 1) {
8726                                 if (ipsp_client_sock) {
8727                                         /* Sockets Layer Call: send() */
8728                                         n = send(ipsp_client_sock, param_data, strlen(param_data) + 1, 0);
8729                                         if (n < 0)
8730                                                 TC_PRT("\nIPSP Error : While sending data !");
8731                                 } else {
8732                                         TC_PRT("IPSP Error: There is no connected client socket !");
8733                                 }
8734                         } else {
8735                                 TC_PRT("IPSP Error: Please input the proper role !");
8736                         }
8737                         __bt_free_test_param(&g_test_param);
8738
8739                         break;
8740                 }
8741                 case BT_UNIT_TEST_FUNCTION_IPSP_RECV_IPV6_APP_DATA: {
8742                         int role = -1, n;
8743                         char buffer[256] = {0};
8744
8745                         if (g_test_param.param_count < 1) {
8746                                 TC_PRT("IPSP Error : Input IPSP Application's role first !");
8747                                 break;
8748                         }
8749
8750                         role = atoi(g_test_param.params[0]);
8751
8752                         if (role == 0) {
8753                                 if (ipsp_server_sock) {
8754                                         TC_PRT("IPSP : Current role is IPSP Sever,  ready to receive data !");
8755
8756                                         /* Sockets Layer Call: recv() */
8757                                         n = recv(ipsp_server_sock, buffer, 255, 0);
8758                                         if (n < 0)
8759                                                 TC_PRT("\nIPSP Server Error : While receiving data from client !");
8760
8761                                         TC_PRT("\nIPSP Server : Message received from client: %s\n", buffer);
8762                                 } else {
8763                                         TC_PRT("IPSP Error: There is no connected or active server socket !");
8764                                 }
8765                         } else if (role == 1) {
8766                                 if (ipsp_client_sock) {
8767                                         TC_PRT("IPSP : Current role is IPSP Client, ready to receive data !");
8768
8769                                         /* Sockets Layer Call: recv() */
8770                                         n = recv(ipsp_client_sock, buffer, 255, 0);
8771                                         if (n < 0)
8772                                                 TC_PRT("\nIPSP Client Error : %d while receiving data from server!", errno);
8773
8774                                         TC_PRT("\nIPSP Client : Message received from server: %s\n", buffer);
8775                                 } else {
8776                                         TC_PRT("IPSP Error: There is no connected or active client socket !");
8777                                 }
8778                         } else {
8779                                 TC_PRT("IPSP Error: Please input the proper role !");
8780                         }
8781
8782                         __bt_free_test_param(&g_test_param);
8783
8784                         break;
8785                 }
8786                 case BT_UNIT_TEST_FUNCTION_IPSP_CLOSE_SOCKET: {
8787                         if (ipsp_server_sock) {
8788                                 TC_PRT("IPSP server : Closing server socket..");
8789                                 close(ipsp_server_sock);
8790                                 ipsp_server_sock = 0;
8791                         }
8792
8793                         if (ipsp_client_sock) {
8794                                 TC_PRT("IPSP Client : Closing client socket..");
8795                                 close(ipsp_client_sock);
8796                                 ipsp_client_sock = 0;
8797                         }
8798
8799                         break;
8800                 }
8801
8802                 case BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS:
8803                         need_to_set_params = true;
8804                         TC_PRT("Select the function again");
8805                         break;
8806
8807                 default:
8808                         break;
8809                 }
8810
8811                 break;
8812         }
8813
8814         case BT_UNIT_TEST_TABLE_HDP: {
8815                 switch (test_id) {
8816                 case BT_UNIT_TEST_FUNCTION_HDP_REGISTER_SINK_APP:
8817                         ret = bt_hdp_register_sink_app(0x1007, &appid);
8818                         TC_PRT("bt_hdp_register_sink_app : returns %s\n", __bt_get_error_message(ret));
8819                         break;
8820                 case BT_UNIT_TEST_FUNCTION_HDP_UNREGISTER_SINK_APP:
8821                         ret = bt_hdp_unregister_sink_app(appid);
8822                         TC_PRT("bt_hdp_unregister_sink_app : returns %s\n", __bt_get_error_message(ret));
8823                         break;
8824                 case BT_UNIT_TEST_FUNCTION_HDP_CONNECT_TO_SOURCE:
8825                         ret = bt_hdp_connect_to_source(remote_addr,
8826                                         appid);
8827                         TC_PRT("bt_hdp_connect_to_source : returns %s\n", __bt_get_error_message(ret));
8828                         break;
8829                 case BT_UNIT_TEST_FUNCTION_HDP_DISCONNECT:
8830                         ret = bt_hdp_disconnect(remote_addr,
8831                                         channel_hdp);
8832                         TC_PRT("bt_hdp_disconnect : returns %s\n", __bt_get_error_message(ret));
8833                         break;
8834                 case BT_UNIT_TEST_FUNCTION_HDP_SEND_DATA:
8835                         ret = bt_hdp_send_data(channel_hdp,
8836                                         data_hdp, strlen(data_hdp));
8837                         TC_PRT("bt_hdp_send_data : returns %s\n", __bt_get_error_message(ret));
8838                         break;
8839                 case BT_UNIT_TEST_FUNCTION_HDP_SET_CONNECTION_CB:
8840                         ret = bt_hdp_set_connection_state_changed_cb(
8841                                         __bt_hdp_connected_cb,
8842                                         __bt_hdp_disconnected_cb, NULL);
8843                         TC_PRT("bt_hdp_set_connection_state_changed_cb : returns %s\n", __bt_get_error_message(ret));
8844                         break;
8845                 case BT_UNIT_TEST_FUNCTION_HDP_UNSET_CONNECTION_CB:
8846                         ret = bt_hdp_unset_connection_state_changed_cb();
8847                         TC_PRT("bt_hdp_unset_connection_state_changed_cb : returns %s\n", __bt_get_error_message(ret));
8848                         break;
8849                 case BT_UNIT_TEST_FUNCTION_HDP_SET_DATA_RECEIVED_CB:
8850                         ret = bt_hdp_set_data_received_cb(
8851                                         __bt_hdp_data_received_cb,
8852                                         NULL);
8853                         TC_PRT("bt_hdp_set_data_received_cb : returns %s\n", __bt_get_error_message(ret));
8854                         break;
8855                 case BT_UNIT_TEST_FUNCTION_HDP_UNSET_DATA_RECEIVED_CB:
8856                         ret = bt_hdp_unset_data_received_cb();
8857                         TC_PRT("bt_hdp_unset_data_received_cb : returns %s\n", __bt_get_error_message(ret));
8858                         break;
8859                 default:
8860                         break;
8861                 }
8862                         break;
8863         }
8864         case BT_UNIT_TEST_TABLE_DPM: {
8865                 switch (test_id) {
8866                 case BT_UNIT_TEST_FUNCTION_DPM_SET_DEFAULT_POLICIES: {
8867                         const char *hfp_uuid = "0000111f-0000-1000-8000-00805f9b34fb";
8868                         const char *hsp_uuid = "00001112-0000-1000-8000-00805f9b34fb";
8869                         const char *a2dp_uuid = "0000110D-0000-1000-8000-00805F9B34FB";
8870                         const char *avrcp_target_uuid =  "0000110c-0000-1000-8000-00805f9b34fb";
8871
8872                         ret = bt_dpm_set_allow_bluetooth_mode(BT_DPM_BT_ALLOWED);
8873
8874                         TC_PRT("bt_dpm_set_allow_bluetooth_mode : returns %s\n",
8875                                                 __bt_get_error_message(ret));
8876
8877                         ret = bt_dpm_activate_device_restriction(BT_DPM_BT_ALLOWED);
8878
8879                         TC_PRT("bt_dpm_activate_device_restriction : returns %s\n",
8880                                                 __bt_get_error_message(ret));
8881
8882                         ret = bt_dpm_activate_uuid_restriction(BT_DPM_BT_ALLOWED);
8883
8884                         TC_PRT("bt_dpm_activate_uuid_restriction : returns %s\n",
8885                                                 __bt_get_error_message(ret));
8886
8887                         ret = bt_dpm_set_allow_outgoing_call(BT_DPM_BT_ALLOWED);
8888
8889                         TC_PRT("bt_dpm_set_allow_outgoing_call : returns %s\n",
8890                                                 __bt_get_error_message(ret));
8891
8892                         ret = bt_dpm_set_pairing_state(BT_DPM_BT_ALLOWED);
8893
8894                         TC_PRT("bt_dpm_set_pairing_state : returns %s\n",
8895                                                 __bt_get_error_message(ret));
8896
8897                         ret = bt_dpm_set_profile_state(BT_DPM_POLICY_HFP_PROFILE_STATE,
8898                                                                 BT_DPM_BT_ALLOWED);
8899
8900                         TC_PRT("bt_dpm_set_profile_state : returns %s\n",
8901                                                 __bt_get_error_message(ret));
8902
8903                         ret = bt_dpm_set_desktop_connectivity_state(BT_DPM_BT_ALLOWED);
8904
8905                         TC_PRT("bt_dpm_set_desktop_connectivity_state : returns %s\n",
8906                                                 __bt_get_error_message(ret));
8907
8908                         ret = bt_dpm_set_discoverable_state(BT_DPM_BT_ALLOWED);
8909
8910                         TC_PRT("bt_dpm_set_discoverable_state : returns %s\n",
8911                                                 __bt_get_error_message(ret));
8912
8913                         ret = bt_dpm_set_limited_discoverable_state(BT_DPM_BT_ALLOWED);
8914
8915                         TC_PRT("bt_dpm_set_limited_discoverable_state : returns %s\n",
8916                                                 __bt_get_error_message(ret));
8917
8918                         ret = bt_dpm_set_data_transfer_state(BT_DPM_BT_ALLOWED);
8919
8920                         TC_PRT("bt_dpm_set_data_transfer_state : returns %s\n",
8921                                                 __bt_get_error_message(ret));
8922
8923                         ret = bt_dpm_add_uuids_to_whitelist(spp_uuid);
8924
8925                         TC_PRT("bt_dpm_add_uuids_to_whitelist : returns %s\n",
8926                                                 __bt_get_error_message(ret));
8927
8928                         ret = bt_dpm_add_uuids_to_whitelist(opp_uuid);
8929
8930                         TC_PRT("bt_dpm_add_uuids_to_whitelist : returns %s\n",
8931                                                 __bt_get_error_message(ret));
8932
8933                         ret = bt_dpm_add_uuids_to_whitelist(hid_uuid);
8934
8935                         TC_PRT("bt_dpm_add_uuids_to_whitelist : returns %s\n",
8936                                                 __bt_get_error_message(ret));
8937
8938                         ret = bt_dpm_add_uuids_to_whitelist(hfp_uuid);
8939
8940                         TC_PRT("bt_dpm_add_uuids_to_whitelist : returns %s\n",
8941                                                 __bt_get_error_message(ret));
8942
8943                         ret = bt_dpm_add_uuids_to_whitelist(hsp_uuid);
8944
8945                         TC_PRT("bt_dpm_add_uuids_to_whitelist : returns %s\n",
8946                                                 __bt_get_error_message(ret));
8947
8948                         ret = bt_dpm_add_uuids_to_whitelist(a2dp_uuid);
8949
8950                         TC_PRT("bt_dpm_add_uuids_to_whitelist : returns %s\n",
8951                                                 __bt_get_error_message(ret));
8952
8953                         ret = bt_dpm_add_uuids_to_whitelist(avrcp_target_uuid);
8954
8955                         TC_PRT("bt_dpm_add_uuids_to_whitelist : returns %s\n",
8956                                                 __bt_get_error_message(ret));
8957                         break;
8958                 }
8959                 case BT_UNIT_TEST_FUNCTION_DPM_SET_ALLOW_BLUETOOTH_MODE: {
8960                         int value;
8961                         if (g_test_param.param_count < 1) {
8962                                         TC_PRT("Input parameters first");
8963                                         break;
8964                         }
8965                         value = atoi(g_test_param.params[0]);
8966                         ret = bt_dpm_set_allow_bluetooth_mode(value);
8967
8968                         TC_PRT("bt_dpm_set_allow_bluetooth_mode : returns %s\n",
8969                                                 __bt_get_error_message(ret));
8970                         __bt_free_test_param(&g_test_param);
8971                         break;
8972                 }
8973                 case BT_UNIT_TEST_FUNCTION_DPM_GET_ALLOW_BLUETOOTH_MODE: {
8974                         bt_dpm_allow_e value = BT_DPM_ERROR;
8975                         ret = bt_dpm_get_allow_bluetooth_mode(&value);
8976                         TC_PRT("bt_dpm_get_allow_bluetooth_mode : allow: %d, returns %s\n",
8977                                                 value , __bt_get_error_message(ret));
8978                         break;
8979                 }
8980                 case BT_UNIT_TEST_FUNCTION_DPM_ACTIVATE_DEVICE_RESTRICTION: {
8981                         int value;
8982                         if (g_test_param.param_count < 1) {
8983                                         TC_PRT("Input parameters first");
8984                                         break;
8985                         }
8986                         value = atoi(g_test_param.params[0]);
8987
8988                         ret = bt_dpm_activate_device_restriction(value);
8989                         TC_PRT("bt_dpm_activate_device_restriction : returns %s\n",
8990                                                 __bt_get_error_message(ret));
8991                         __bt_free_test_param(&g_test_param);
8992                         break;
8993                 }
8994                 case BT_UNIT_TEST_FUNCTION_DPM_IS_DEVICE_RESTRICTIO_ACTIVATE: {
8995                         bt_dpm_status_e value = BT_DPM_STATUS_ERROR;
8996                         ret = bt_dpm_is_device_restriction_active(&value);
8997                         TC_PRT("bt_dpm_is_device_restriction_active : allow: %d, returns %s\n",
8998                                                 value, __bt_get_error_message(ret));
8999                         break;
9000                 }
9001                 case BT_UNIT_TEST_FUNCTION_DPM_ACTIVATE_UUID_RESTRICTION: {
9002                         int value;
9003                         if (g_test_param.param_count < 1) {
9004                                         TC_PRT("Input parameters first");
9005                                         break;
9006                         }
9007                         value = atoi(g_test_param.params[0]);
9008
9009                         ret = bt_dpm_activate_uuid_restriction(value);
9010                         TC_PRT("bt_dpm_activate_uuid_restriction : returns %s\n",
9011                                                 __bt_get_error_message(ret));
9012                         __bt_free_test_param(&g_test_param);
9013                         break;
9014                 }
9015                 case BT_UNIT_TEST_FUNCTION_DPM_IS_UUID_RESTRICTIO_ACTIVATE: {
9016                         bt_dpm_status_e value = BT_DPM_STATUS_ERROR;
9017                         ret = bt_dpm_is_uuid_restriction_active(&value);
9018                         TC_PRT("bt_dpm_is_uuid_restriction_active : allow: %d, returns %s\n",
9019                                                 value, __bt_get_error_message(ret));
9020                         break;
9021                 }
9022                 case BT_UNIT_TEST_FUNCTION_DPM_ADD_DEVICES_TO_BLACKLIST:
9023                         if (g_test_param.param_count < 1) {
9024                                         TC_PRT("Input parameters first");
9025                                         break;
9026                         }
9027
9028                         ret = bt_dpm_add_devices_to_blacklist(g_test_param.params[0]);
9029                         TC_PRT("bt_dpm_add_devices_to_blacklist : returns %s\n",
9030                                                 __bt_get_error_message(ret));
9031                         __bt_free_test_param(&g_test_param);
9032                         break;
9033                 case BT_UNIT_TEST_FUNCTION_DPM_ADD_DEVICES_TO_WHITELIST:
9034                         if (g_test_param.param_count < 1) {
9035                                         TC_PRT("Input parameters first");
9036                                         break;
9037                         }
9038
9039                         ret = bt_dpm_add_devices_to_whitelist(g_test_param.params[0]);
9040                         TC_PRT("bt_dpm_add_devices_to_whitelist : returns %s\n",
9041                                                 __bt_get_error_message(ret));
9042                         __bt_free_test_param(&g_test_param);
9043                         break;
9044                 case BT_UNIT_TEST_FUNCTION_DPM_ADD_UUIDS_TO_BLACKLIST:
9045                         if (g_test_param.param_count < 1) {
9046                                         TC_PRT("Input parameters first");
9047                                         break;
9048                         }
9049
9050                         ret = bt_dpm_add_uuids_to_blacklist(g_test_param.params[0]);
9051                         TC_PRT("bt_dpm_add_uuids_to_blacklist : returns %s\n",
9052                                                 __bt_get_error_message(ret));
9053                         __bt_free_test_param(&g_test_param);
9054                         break;
9055                 case BT_UNIT_TEST_FUNCTION_DPM_ADD_UUIDS_TO_WHITELIST:
9056                         if (g_test_param.param_count < 1) {
9057                                         TC_PRT("Input parameters first");
9058                                         break;
9059                         }
9060
9061                         ret = bt_dpm_add_uuids_to_whitelist(g_test_param.params[0]);
9062                         TC_PRT("bt_dpm_add_uuids_to_whitelist : returns %s\n",
9063                                                 __bt_get_error_message(ret));
9064                         __bt_free_test_param(&g_test_param);
9065                         break;
9066                 case BT_UNIT_TEST_FUNCTION_DPM_GET_DEVICES_FROM_BLACKLIST: {
9067                         bt_dpm_device_list_s *device_list = NULL;
9068                         int i = 0;
9069                         char *str = NULL;
9070                         ret = bt_dpm_get_devices_from_blacklist(&device_list);
9071                         TC_PRT("bt_dpm_get_devices_from_blacklist : returns %s\n",
9072                                                 __bt_get_error_message(ret));
9073                         if (device_list) {
9074                                 TC_PRT("list len %d", device_list->count);
9075                                 for (i = 0; i < device_list->count; i++) {
9076                                         str = g_strdup((const gchar*)device_list->devices[i]);
9077                                         TC_PRT("%d: %s\n", i, str);
9078                                         g_free(str);
9079                                         free(device_list->devices[i]);
9080                                 }
9081                                 free(device_list);
9082                         }
9083                         break;
9084                 }
9085                 case BT_UNIT_TEST_FUNCTION_DPM_GET_DEVICES_FROM_WHITELIST: {
9086                         bt_dpm_device_list_s *device_list = NULL;
9087                         int i = 0;
9088                         char *str = NULL;
9089                         ret = bt_dpm_get_devices_from_whitelist(&device_list);
9090                         TC_PRT("bt_dpm_get_devices_from_whitelist : returns %s\n",
9091                                                 __bt_get_error_message(ret));
9092
9093                         if (device_list) {
9094                                 TC_PRT("list len %d", device_list->count);
9095                                 for (i = 0; i < device_list->count; i++) {
9096                                         str = g_strdup((const gchar*)device_list->devices[i]);
9097                                         TC_PRT("%d: %s\n", i, str);
9098                                         g_free(str);
9099                                         free(device_list->devices[i]);
9100                                 }
9101                                 free(device_list);
9102                         }
9103                         break;
9104                 }
9105                 case BT_UNIT_TEST_FUNCTION_DPM_GET_UUIDS_FROM_BLACKLIST: {
9106                         bt_dpm_uuids_list_s *uuids_list = NULL;
9107                         int i = 0;
9108                         char *str = NULL;
9109                         ret = bt_dpm_get_uuids_from_blacklist(&uuids_list);
9110                         TC_PRT("bt_dpm_get_uuids_from_blacklist : returns %s\n",
9111                                                 __bt_get_error_message(ret));
9112
9113                         if (uuids_list) {
9114                                 TC_PRT("list len %d", uuids_list->count);
9115                                 for (i = 0; i < uuids_list->count; i++) {
9116                                         str = g_strdup(uuids_list->uuids[i]);
9117                                         TC_PRT("%d: %s\n", i, str);
9118                                         g_free(str);
9119                                         free(uuids_list->uuids[i]);
9120                                 }
9121                                 free(uuids_list);
9122                         }
9123                         break;
9124                 }
9125                 case BT_UNIT_TEST_FUNCTION_DPM_GET_UUIDS_FROM_WHITELIST: {
9126                         bt_dpm_uuids_list_s *uuids_list = NULL;
9127                         int i = 0;
9128                         char *str = NULL;
9129                         ret = bt_dpm_get_uuids_from_whitelist(&uuids_list);
9130                         TC_PRT("bt_dpm_get_uuids_from_whitelist : returns %s\n",
9131                                                 __bt_get_error_message(ret));
9132
9133                         if (uuids_list) {
9134                                 TC_PRT("list len %d", uuids_list->count);
9135                                 for (i = 0; i < uuids_list->count; i++) {
9136                                         str = g_strdup(uuids_list->uuids[i]);
9137                                         TC_PRT("%d: %s\n", i, str);
9138                                         g_free(str);
9139                                         free(uuids_list->uuids[i]);
9140                                 }
9141                                 free(uuids_list);
9142                         }
9143                         break;
9144                 }
9145                 case BT_UNIT_TEST_FUNCTION_DPM_CLEAR_DEVICES_FROM_BLACKLIST:
9146                         ret = bt_dpm_clear_devices_from_blacklist();
9147                         TC_PRT("bt_dpm_clear_devices_from_blacklist : returns %s\n",
9148                                                 __bt_get_error_message(ret));
9149                         break;
9150                 case BT_UNIT_TEST_FUNCTION_DPM_CLEAR_DEVICES_FROM_WHITELIST:
9151                         ret = bt_dpm_clear_devices_from_whitelist();
9152                         TC_PRT("bt_dpm_clear_devices_from_whitelist : returns %s\n",
9153                                                 __bt_get_error_message(ret));
9154                         break;
9155                 case BT_UNIT_TEST_FUNCTION_DPM_CLEAR_UUIDS_FROM_BLACKLIST:
9156                         ret = bt_dpm_clear_uuids_from_blacklist();
9157                         TC_PRT("bt_dpm_clear_uuids_from_blacklist : returns %s\n",
9158                                                 __bt_get_error_message(ret));
9159                         break;
9160                 case BT_UNIT_TEST_FUNCTION_DPM_CLEAR_UUIDS_FROM_WHITELIST:
9161                         ret = bt_dpm_clear_uuids_from_whitelist();
9162                         TC_PRT("bt_dpm_clear_uuids_from_whitelist : returns %s\n",
9163                                                 __bt_get_error_message(ret));
9164                         break;
9165                 case BT_UNIT_TEST_FUNCTION_DPM_REMOVE_DEVICE_FROM_BLACKLIST:
9166                         if (g_test_param.param_count < 1) {
9167                                         TC_PRT("Input parameters first");
9168                                         break;
9169                         }
9170
9171                         ret = bt_dpm_remove_device_from_blacklist(g_test_param.params[0]);
9172                         TC_PRT("bt_dpm_add_devices_to_blacklist : returns %s\n",
9173                                                 __bt_get_error_message(ret));
9174                         __bt_free_test_param(&g_test_param);
9175                         break;
9176                 case BT_UNIT_TEST_FUNCTION_DPM_REMOVE_DEVICE_FROM_WHITELIST:
9177                         if (g_test_param.param_count < 1) {
9178                                         TC_PRT("Input parameters first");
9179                                         break;
9180                         }
9181
9182                         ret = bt_dpm_remove_device_from_whitelist(g_test_param.params[0]);
9183                         TC_PRT("bt_dpm_remove_device_from_whitelist : returns %s\n",
9184                                                 __bt_get_error_message(ret));
9185                         __bt_free_test_param(&g_test_param);
9186                         break;
9187                 case BT_UNIT_TEST_FUNCTION_DPM_REMOVE_UUIDS_FROM_BLACKLIST:
9188                         if (g_test_param.param_count < 1) {
9189                                         TC_PRT("Input parameters first");
9190                                         break;
9191                         }
9192
9193                         ret = bt_dpm_remove_uuid_from_blacklist(g_test_param.params[0]);
9194                         TC_PRT("bt_dpm_remove_device_from_blacklist : returns %s\n",
9195                                                 __bt_get_error_message(ret));
9196                         __bt_free_test_param(&g_test_param);
9197                         break;
9198                 case BT_UNIT_TEST_FUNCTION_DPM_REMOVE_UUIDS_FROM_WHITELIST:
9199                         if (g_test_param.param_count < 1) {
9200                                         TC_PRT("Input parameters first");
9201                                         break;
9202                         }
9203
9204                         ret = bt_dpm_remove_uuid_from_whitelist(g_test_param.params[0]);
9205                         TC_PRT("bt_dpm_remove_uuid_from_whitelist : returns %s\n",
9206                                                 __bt_get_error_message(ret));
9207                         __bt_free_test_param(&g_test_param);
9208                         break;
9209                 case BT_UNIT_TEST_FUNCTION_DPM_SET_ALLOW_OUTGOING_CALL: {
9210                         int value;
9211                         if (g_test_param.param_count < 1) {
9212                                         TC_PRT("Input parameters first");
9213                                         break;
9214                         }
9215                         value = atoi(g_test_param.params[0]);
9216
9217                         ret = bt_dpm_set_allow_outgoing_call(value);
9218                         TC_PRT("bt_dpm_set_allow_outgoing_call : returns %s\n",
9219                                                 __bt_get_error_message(ret));
9220                         __bt_free_test_param(&g_test_param);
9221                         break;
9222                 }
9223                 case BT_UNIT_TEST_FUNCTION_DPM_GET_ALLOW_OUTGOING_CALL: {
9224                         bt_dpm_status_e value = BT_DPM_STATUS_ERROR;
9225                         ret = bt_dpm_get_allow_outgoing_call(&value);
9226                         TC_PRT("bt_dpm_get_allow_outgoing_call : allow: %d, returns %s\n",
9227                                                 value, __bt_get_error_message(ret));
9228                         break;
9229                 }
9230                 case BT_UNIT_TEST_FUNCTION_DPM_SET_PAIRING_STATE: {
9231                         int value;
9232                         if (g_test_param.param_count < 1) {
9233                                         TC_PRT("Input parameters first");
9234                                         break;
9235                         }
9236                         value = atoi(g_test_param.params[0]);
9237
9238                         ret = bt_dpm_set_pairing_state(value);
9239                         TC_PRT("bt_dpm_set_pairing_state : returns %s\n",
9240                                                 __bt_get_error_message(ret));
9241                         __bt_free_test_param(&g_test_param);
9242                         break;
9243                 }
9244                 case BT_UNIT_TEST_FUNCTION_DPM_GET_PAIRING_STATE: {
9245                         bt_dpm_status_e value = BT_DPM_STATUS_ERROR;
9246                         ret = bt_dpm_get_pairing_state(&value);
9247                         TC_PRT("bt_dpm_get_pairing_state : allow: %d, returns %s\n",
9248                                                 value, __bt_get_error_message(ret));
9249                         break;
9250                 }
9251                 case BT_UNIT_TEST_FUNCTION_DPM_SET_PROFILE_STATE: {
9252                         int profile, value;
9253                         if (g_test_param.param_count < 2) {
9254                                         TC_PRT("Input parameters first");
9255                                         break;
9256                         }
9257                         profile = atoi(g_test_param.params[0]);
9258                         value = atoi(g_test_param.params[1]);
9259
9260                         ret = bt_dpm_set_profile_state(profile, value);
9261                         TC_PRT("bt_dpm_set_profile_state : returns %s\n",
9262                                                 __bt_get_error_message(ret));
9263                         __bt_free_test_param(&g_test_param);
9264                         break;
9265                 }
9266                 case BT_UNIT_TEST_FUNCTION_DPM_GET_PROFILE_STATE: {
9267                         bt_dpm_status_e value = BT_DPM_STATUS_ERROR;
9268                         int profile;
9269                         if (g_test_param.param_count < 1) {
9270                                         TC_PRT("Input parameters first");
9271                                         break;
9272                         }
9273                         profile = atoi(g_test_param.params[0]);
9274
9275                         ret = bt_dpm_get_profile_state(profile, &value);
9276                         TC_PRT("bt_dpm_get_profile_state : allow: %d, returns %s\n",
9277                                                 value, __bt_get_error_message(ret));
9278                         __bt_free_test_param(&g_test_param);
9279                         break;
9280                 }
9281                 case BT_UNIT_TEST_FUNCTION_DPM_SET_DESKTOP_CONNECTIVITY_STATE: {
9282                         int value;
9283                         if (g_test_param.param_count < 1) {
9284                                         TC_PRT("Input parameters first");
9285                                         break;
9286                         }
9287                         value = atoi(g_test_param.params[0]);
9288
9289                         ret = bt_dpm_set_desktop_connectivity_state(value);
9290                         TC_PRT("bt_dpm_set_desktop_connectivity_state : returns %s\n",
9291                                                 __bt_get_error_message(ret));
9292                         __bt_free_test_param(&g_test_param);
9293                         break;
9294                 }
9295                 case BT_UNIT_TEST_FUNCTION_DPM_GET_DESKTOP_CONNECTIVITY_STATE: {
9296                         bt_dpm_status_e value = BT_DPM_STATUS_ERROR;
9297                         ret = bt_dpm_get_desktop_connectivity_state(&value);
9298                         TC_PRT("bt_dpm_get_desktop_connectivity_state : allow: %d, returns %s\n",
9299                                                 value, __bt_get_error_message(ret));
9300                         break;
9301                 }
9302                 case BT_UNIT_TEST_FUNCTION_DPM_SET_DISCOVERABLE_STATE: {
9303                         int value;
9304                         if (g_test_param.param_count < 1) {
9305                                         TC_PRT("Input parameters first");
9306                                         break;
9307                         }
9308                         value = atoi(g_test_param.params[0]);
9309                         ret = bt_dpm_set_discoverable_state(value);
9310                         TC_PRT("bt_dpm_set_discoverable_state : returns %s\n",
9311                                                 __bt_get_error_message(ret));
9312                         __bt_free_test_param(&g_test_param);
9313                         break;
9314                 }
9315                 case BT_UNIT_TEST_FUNCTION_DPM_GET_DISCOVERABLE_STATE: {
9316                         bt_dpm_status_e value = BT_DPM_STATUS_ERROR;
9317                         ret = bt_dpm_get_discoverable_state(&value);
9318                         TC_PRT("bt_dpm_get_discoverable_state : allow: %d, returns %s\n",
9319                                                 value, __bt_get_error_message(ret));
9320                         break;
9321                 }
9322                 case BT_UNIT_TEST_FUNCTION_DPM_SET_LIMITED_DISCOVERABLE_STATE: {
9323                         int value;
9324                         if (g_test_param.param_count < 1) {
9325                                         TC_PRT("Input parameters first");
9326                                         break;
9327                         }
9328                         value = atoi(g_test_param.params[0]);
9329
9330                         ret = bt_dpm_set_limited_discoverable_state(value);
9331                         TC_PRT("bt_dpm_set_limited_discoverable_state : returns %s\n",
9332                                                 __bt_get_error_message(ret));
9333                         __bt_free_test_param(&g_test_param);
9334                         break;
9335                 }
9336                 case BT_UNIT_TEST_FUNCTION_DPM_GET_LIMITED_DISCOVERABLE_STATE: {
9337                         bt_dpm_status_e value = BT_DPM_STATUS_ERROR;
9338                         ret = bt_dpm_get_limited_discoverable_state(&value);
9339                         TC_PRT("bt_dpm_get_limited_discoverable_state : allow: %d, returns %s\n",
9340                                                 value, __bt_get_error_message(ret));
9341                         break;
9342                 }
9343                 case BT_UNIT_TEST_FUNCTION_DPM_SET_DATA_TRANSFER_STATE: {
9344                         int value;
9345                         if (g_test_param.param_count < 1) {
9346                                         TC_PRT("Input parameters first");
9347                                         break;
9348                         }
9349                         value = atoi(g_test_param.params[0]);
9350
9351                         ret = bt_dpm_set_data_transfer_state(value);
9352                         TC_PRT("bt_dpm_set_data_transfer_state : returns %s\n",
9353                                                 __bt_get_error_message(ret));
9354                         __bt_free_test_param(&g_test_param);
9355                         break;
9356                 }
9357                 case BT_UNIT_TEST_FUNCTION_DPM_GET_DATA_TRANSFER_STATE: {
9358                         bt_dpm_status_e value = BT_DPM_STATUS_ERROR;
9359                         ret = bt_dpm_get_data_transfer_state(&value);
9360                         TC_PRT("bt_dpm_get_data_transfer_state : allow: %d, returns %s\n",
9361                                                 value, __bt_get_error_message(ret));
9362                         break;
9363                 }
9364                 case BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS:
9365                         need_to_set_params = true;
9366                         TC_PRT("Select the function again");
9367                         break;
9368
9369                 default:
9370                         break;
9371                 }
9372                 break;
9373         }
9374
9375         case BT_UNIT_TEST_TABLE_PXP: {
9376                 switch (test_id) {
9377                 case BT_UNIT_TEST_FUNCTION_PXP_REPORTER_REGISTER: {
9378                         if (reporter) {
9379                                 ret = bt_proximity_reporter_destroy(reporter);
9380                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
9381
9382                                 ret = bt_proximity_reporter_unset_property_changed_cb(reporter);
9383                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
9384
9385                                 ret = bt_proximity_reporter_unset_connection_state_changed_cb(reporter);
9386                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
9387                                 reporter = NULL;
9388                         }
9389                         ret = bt_proximity_reporter_create(&reporter);
9390                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9391                         break;
9392                 }
9393                 case BT_UNIT_TEST_FUNCTION_PXP_REPORTER_UNREGISTER: {
9394                         ret = bt_proximity_reporter_unset_connection_state_changed_cb(reporter);
9395                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9396
9397                         ret = bt_proximity_reporter_unset_property_changed_cb(reporter);
9398                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9399
9400
9401                         ret = bt_proximity_reporter_destroy(reporter);
9402                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9403                         reporter = NULL;
9404                         break;
9405                 }
9406                 case BT_UNIT_TEST_FUNCTION_PXP_MONITOR_CREATE: {
9407                         if (monitor) {
9408                                 ret = bt_proximity_monitor_disconnect(monitor);
9409                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
9410
9411                                 ret = bt_proximity_monitor_unset_connection_state_changed_cb(monitor);
9412                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
9413
9414                                 ret = bt_proximity_monitor_destroy(monitor);
9415                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
9416                                 monitor = NULL;
9417                         }
9418                         ret = bt_proximity_monitor_create(remote_addr, &monitor);
9419                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9420                         break;
9421
9422                 }
9423                 case BT_UNIT_TEST_FUNCTION_PXP_MONITOR_DESTROY: {
9424                         ret = bt_proximity_monitor_unset_connection_state_changed_cb(monitor);
9425                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9426
9427                         ret = bt_proximity_monitor_destroy(monitor);
9428                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9429                         monitor = NULL;
9430                         break;
9431                 }
9432                 case BT_UNIT_TEST_FUNCTION_PXP_MONITOR_CONNECT: {
9433                         ret = bt_proximity_monitor_connect(monitor);
9434                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9435                         break;
9436                 }
9437                 case BT_UNIT_TEST_FUNCTION_PXP_MONITOR_DISCONNECT: {
9438                         ret = bt_proximity_monitor_disconnect(monitor);
9439                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9440                         break;
9441                 }
9442                 case BT_UNIT_TEST_FUNCTION_PXP_MONITOR_SET_CONNECTION_STATE_CHANGED_CB: {
9443                         ret = bt_proximity_monitor_set_connection_state_changed_cb(monitor,
9444                                         __bt_proximity_monitor_connection_state_changed_cb,
9445                                         NULL);
9446                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9447                         break;
9448                 }
9449                 case BT_UNIT_TEST_FUNCTION_PXP_MONITOR_UNSET_CONNECTION_STATE_CHANGED_CB: {
9450                         ret = bt_proximity_monitor_unset_connection_state_changed_cb(monitor);
9451                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9452                         break;
9453                 }
9454                 case BT_UNIT_TEST_FUNCTION_PXP_REPORTER_SET_CONNECTION_STATE_CHANGED_CB: {
9455                         ret = bt_proximity_reporter_set_connection_state_changed_cb(reporter,
9456                                         __bt_proximity_reporter_connection_state_changed_cb,
9457                                         NULL);
9458                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9459                         break;
9460                 }
9461                 case BT_UNIT_TEST_FUNCTION_PXP_REPORTER_UNSET_CONNECTION_STATE_CHANGED_CB: {
9462                         ret = bt_proximity_reporter_unset_connection_state_changed_cb(reporter);
9463                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9464                         break;
9465                 }
9466                 case BT_UNIT_TEST_FUNCTION_PXP_REPORTER_SET_PROPERTIES_CHANGED_CB: {
9467                         ret = bt_proximity_reporter_set_property_changed_cb(reporter,
9468                                         __bt_proximity_reporter_property_changed_cb,
9469                                         NULL);
9470                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9471                         break;
9472                 }
9473                 case BT_UNIT_TEST_FUNCTION_PXP_REPORTER_UNSET_PROPERTIES_CHANGED_CB: {
9474                         ret = bt_proximity_reporter_unset_property_changed_cb(reporter);
9475                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9476                         break;
9477                 }
9478                 case BT_UNIT_TEST_FUNCTION_PXP_MONITOR_SET_SCAN_FILTER_SERVICE_UUID: {
9479                         if (pxp_scan_filter) {
9480                                 ret = bt_adapter_le_scan_filter_unset_proximity_uuid(pxp_scan_filter);
9481                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
9482
9483                                 ret = bt_adapter_le_scan_filter_destroy(pxp_scan_filter);
9484                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
9485                                 pxp_scan_filter = NULL;
9486                         }
9487                         ret = bt_adapter_le_scan_filter_create(&pxp_scan_filter);
9488                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9489
9490                         ret = bt_adapter_le_scan_filter_set_type(pxp_scan_filter,
9491                                         BT_ADAPTER_LE_SCAN_FILTER_TYPE_PROXIMITY_UUID);
9492                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9493
9494                         ret = bt_adapter_le_scan_filter_register(pxp_scan_filter);
9495                         if (ret != BT_ERROR_NONE)
9496                                 TC_PRT("failed with [0x%04x]", ret);
9497
9498                         break;
9499                 }
9500                 case BT_UNIT_TEST_FUNCTION_PXP_MONITOR_UNSET_SCAN_FILTER_SERVICE_UUID: {
9501                         ret = bt_adapter_le_scan_filter_unset_proximity_uuid(pxp_scan_filter);
9502                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9503
9504                         ret = bt_adapter_le_scan_filter_destroy(pxp_scan_filter);
9505                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9506                         pxp_scan_filter = NULL;
9507
9508                         break;
9509                 }
9510                 case BT_UNIT_TEST_FUNCTION_PXP_REPORTER_START_ADVERTISING: {
9511                         /* Add Reporter service in advertising data */
9512                         advertiser = advertiser_list[advertiser_index];
9513                         if (advertiser == NULL) {
9514                                 ret = bt_adapter_le_create_advertiser(&advertiser);
9515                                 if (ret != BT_ERROR_NONE) {
9516                                         TC_PRT("created le advertiser(%d)", ret);
9517                                         break;
9518                                 }
9519
9520                                 advertiser_list[advertiser_index] = advertiser;
9521                                 ret = bt_adapter_le_set_advertising_device_name(advertiser,
9522                                                 BT_ADAPTER_LE_PACKET_SCAN_RESPONSE, true);
9523                                 if (ret != BT_ERROR_NONE) {
9524                                         TC_PRT("set device name [0x%04x]", ret);
9525                                         break;
9526                                 }
9527                         }
9528
9529                         ret = bt_adapter_le_add_advertising_service_solicitation_uuid(advertiser,
9530                                         BT_ADAPTER_LE_PACKET_ADVERTISING, PXP_IMMEDIATE_ALERT_SVC_UUID);
9531                         if (ret != BT_ERROR_NONE) {
9532                                 TC_PRT("add service_solicitation_uuid [0x%04x]", ret);
9533                                 break;
9534                         }
9535
9536                         ret = bt_adapter_le_add_advertising_service_solicitation_uuid(advertiser,
9537                                         BT_ADAPTER_LE_PACKET_ADVERTISING, PXP_LINK_LOSS_SVC_UUID);
9538                         if (ret != BT_ERROR_NONE) {
9539                                 TC_PRT("add service_solicitation_uuid [0x%04x]", ret);
9540                                 break;
9541                         }
9542
9543                         /* Start advertising PXP Reporter service */
9544                         bt_adapter_le_advertising_state_changed_cb cb;
9545
9546                         if (advertiser_index == 0) cb = __bt_adapter_le_advertising_state_changed_cb;
9547                         else if (advertiser_index == 1) cb = __bt_adapter_le_advertising_state_changed_cb_2;
9548                         else cb = __bt_adapter_le_advertising_state_changed_cb_3;
9549
9550                         advertiser = advertiser_list[advertiser_index];
9551
9552                         advertiser_index++;
9553                         advertiser_index %= 3;
9554
9555                         TC_PRT("advertiser: %p", advertiser);
9556
9557                         ret = bt_adapter_le_start_advertising_new(advertiser, cb, NULL);
9558                         if (ret < BT_ERROR_NONE)
9559                                 TC_PRT("failed with [0x%04x]", ret);
9560
9561                         break;
9562                 }
9563                 case BT_UNIT_TEST_FUNCTION_PXP_MONITOR_WRITE_LINKLOSS_ALERT: {
9564                         int alert_value;
9565                         if (g_test_param.param_count < 1) {
9566                                         TC_PRT("Input parameters first");
9567                                         break;
9568                         }
9569
9570                         alert_value = atoi(g_test_param.params[0]);
9571                         ret = bt_proximity_monitor_set_linkloss_alert(monitor, alert_value);
9572                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9573                         break;
9574                 }
9575                 case BT_UNIT_TEST_FUNCTION_PXP_MONITOR_WRITE_IMMEDIATE_ALERT: {
9576                         int alert_value;
9577                         if (g_test_param.param_count < 1) {
9578                                         TC_PRT("Input parameters first");
9579                                         break;
9580                         }
9581
9582                         alert_value = atoi(g_test_param.params[0]);
9583                         ret = bt_proximity_monitor_set_immediate_alert(monitor, alert_value);
9584                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9585                         break;
9586                 }
9587
9588                 case BT_UNIT_TEST_FUNCTION_PXP_MONITOR_READ_LINKLOSS_ALERT: {
9589                         int alert_level = 0;
9590                         ret = bt_proximity_monitor_get_linkloss_alert(monitor, &alert_level);
9591                         TC_PRT("returns %s, alert_level: %d\n", __bt_get_error_message(ret), alert_level);
9592                         break;
9593                 }
9594                 case BT_UNIT_TEST_FUNCTION_PXP_MONITOR_READ_IMMEDIATE_ALERT: {
9595                         int alert_level = 0;
9596                         ret = bt_proximity_monitor_get_immediate_alert(monitor, &alert_level);
9597                         TC_PRT("returns %s, alert_level: %d\n", __bt_get_error_message(ret), alert_level);
9598                         break;
9599                 }
9600                 case BT_UNIT_TEST_FUNCTION_PXP_MONITOR_READ_SIGNAL_LEVEL: {
9601                         int alert_level = 0;
9602                         ret = bt_proximity_monitor_get_signal_level(monitor, &alert_level);
9603                         TC_PRT("returns %s, signal_level: %d\n", __bt_get_error_message(ret), alert_level);
9604                         break;
9605                 }
9606                 case BT_UNIT_TEST_FUNCTION_PXP_REPORTER_READ_LINKLOSS_ALERT: {
9607                         int alert_level = 0;
9608                         ret = bt_proximity_reporter_get_linkloss_alert(remote_addr, &alert_level);
9609                         TC_PRT("returns %s, alert_level: %d\n", __bt_get_error_message(ret), alert_level);
9610                         break;
9611                 }
9612                 case BT_UNIT_TEST_FUNCTION_PXP_REPORTER_READ_IMMEDIATE_ALERT: {
9613                         int alert_level = 0;
9614                         ret = bt_proximity_reporter_get_immediate_alert(remote_addr, &alert_level);
9615                         TC_PRT("returns %s, alert_level: %d\n", __bt_get_error_message(ret), alert_level);
9616                         break;
9617                 }
9618                 case BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS:
9619                         need_to_set_params = true;
9620                         TC_PRT("Select the function again");
9621                         break;
9622
9623                 default:
9624                         break;
9625                 }
9626                 break;
9627         }
9628
9629         case BT_UNIT_TEST_TABLE_HF: {
9630                 if (!TIZEN_PROFILE_WEARABLE_IVI)
9631                         break;
9632                 switch (test_id) {
9633                 case BT_UNIT_TEST_FUNCTION_HF_INITIALIZE:
9634                         ret = bt_hf_initialize();
9635                         if (ret < BT_ERROR_NONE)
9636                                 TC_PRT("failed with [0x%04x]", ret);
9637                         else if (ret == BT_ERROR_NONE)
9638                                 TC_PRT("Success");
9639                         break;
9640                 case BT_UNIT_TEST_FUNCTION_HF_DEINITIALIZE:
9641                         ret = bt_hf_deinitialize();
9642                         if (ret < BT_ERROR_NONE)
9643                                 TC_PRT("failed with [0x%04x]", ret);
9644                         else if (ret == BT_ERROR_NONE)
9645                                 TC_PRT("Success");
9646                         break;
9647                 case BT_UNIT_TEST_FUNCTION_HF_NOTIFY_CALL_ANSWER:
9648                         ret = bt_hf_notify_call_event(
9649                                         BT_HF_CALL_EVENT_ANSWER,
9650                                         "9663868998");
9651                         if (ret < BT_ERROR_NONE)
9652                                 TC_PRT("failed with [0x%04x]", ret);
9653                         else if (ret == BT_ERROR_NONE)
9654                                 TC_PRT("Success");
9655                         break;
9656                 case BT_UNIT_TEST_FUNCTION_HF_NOTIFY_SPEAKER_GAIN:
9657                         ret = bt_hf_notify_speaker_gain(10);
9658                         if (ret < BT_ERROR_NONE)
9659                                 TC_PRT("failed with [0x%04x]", ret);
9660                         else if (ret == BT_ERROR_NONE)
9661                                 TC_PRT("Success");
9662                         break;
9663                 case BT_UNIT_TEST_FUNCTION_HF_SET_SPEAKER_GAIN_CB:
9664                         ret = bt_hf_set_speaker_gain_changed_cb(
9665                                         __bt_hf_speaker_gain_changed_cb,
9666                                         NULL);
9667                         if (ret < BT_ERROR_NONE)
9668                                 TC_PRT("failed with [0x%04x]", ret);
9669                         else if (ret == BT_ERROR_NONE)
9670                                 TC_PRT("Success");
9671                         break;
9672                 case BT_UNIT_TEST_FUNCTION_HF_UNSET_SPEAKER_GAIN_CB:
9673                         ret = bt_hf_unset_speaker_gain_changed_cb();
9674                         if (ret < BT_ERROR_NONE)
9675                                 TC_PRT("failed with [0x%04x]", ret);
9676                         else if (ret == BT_ERROR_NONE)
9677                                 TC_PRT("Success");
9678                         break;
9679                 case BT_UNIT_TEST_FUNCTION_HF_NOTIFY_VOICE_REC_TRUE:
9680                         ret = bt_hf_notify_voice_recognition_state(true);
9681                         if (ret < BT_ERROR_NONE)
9682                                 TC_PRT("failed with [0x%04x]", ret);
9683                         else if (ret == BT_ERROR_NONE)
9684                                 TC_PRT("Success");
9685                         break;
9686                 case BT_UNIT_TEST_FUNCTION_HF_NOTIFY_CALL_TERM:
9687                         ret = bt_hf_notify_call_event(
9688                                         BT_HF_CALL_EVENT_IDLE,
9689                                         "9663868998");
9690                         if (ret < BT_ERROR_NONE)
9691                                 TC_PRT("failed with [0x%04x]", ret);
9692                         else if (ret == BT_ERROR_NONE)
9693                                 TC_PRT("Success");
9694                         break;
9695                 case BT_UNIT_TEST_FUNCTION_HF_NOTIFY_CALL_INIT:
9696                         ret = bt_hf_notify_call_event(
9697                                         BT_HF_CALL_EVENT_DIAL,
9698                                         "9663868998");
9699                         if (ret < BT_ERROR_NONE)
9700                                 TC_PRT("failed with [0x%04x]", ret);
9701                         else if (ret == BT_ERROR_NONE)
9702                                 TC_PRT("Success");
9703                         break;
9704                 case BT_UNIT_TEST_FUNCTION_HF_NOTIFY_VOICE_REC_FALSE:
9705                         ret = bt_hf_notify_voice_recognition_state(false);
9706                         if (ret < BT_ERROR_NONE)
9707                                 TC_PRT("failed with [0x%04x]", ret);
9708                         else if (ret == BT_ERROR_NONE)
9709                                 TC_PRT("Success");
9710                         break;
9711                 case BT_UNIT_TEST_FUNCTION_HF_IS_SCO_OPENED: {
9712                         bool is_opened = false;
9713                         ret = bt_hf_is_sco_opened(&is_opened);
9714                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9715                         TC_PRT("Sco is opened [%s]", is_opened ? "YES" : "NO");
9716                         break;
9717                 }
9718                 case BT_UNIT_TEST_FUNCTION_HF_GET_CODEC_ID: {
9719                         unsigned int codec_id = 0;
9720                         ret = bt_hf_get_codec_id(&codec_id);
9721                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9722                         TC_PRT("Codec ID [%d]", codec_id);
9723                         break;
9724                 }
9725                 case BT_UNIT_TEST_FUNCTION_HF_GET_CALL_STATUS_INFO_LIST: {
9726                         GSList *list;
9727                         ret = bt_hf_get_call_status_info_list(&list);
9728
9729                         if (ret < BT_ERROR_NONE)
9730                                 TC_PRT("failed with [0x%04x]", ret);
9731                         else {
9732                                 for (; list; list = g_slist_next(list)) {
9733                                         bt_hf_call_status_info_s *call_info = list->data;
9734                                         TC_PRT("Call info [No:%s, Dir:%d, Stat:%d, Mpt:%d, Idx:%d]",
9735                                                 call_info->number, call_info->direction,
9736                                                 call_info->status, call_info->multi_party,
9737                                                 call_info->index);
9738                                 }
9739                                 bt_hf_free_call_status_info_list(list);
9740                         }
9741                         break;
9742                 }
9743                 case BT_UNIT_TEST_FUNCTION_HF_REQUEST_CALL_STATUS_INFO_LIST: {
9744                         ret = bt_hf_request_call_status_info_list();
9745                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9746                         break;
9747                 }
9748                 case BT_UNIT_TEST_FUNCTION_HF_SET_SCO_CHANGED_CB:
9749                         ret = bt_hf_set_sco_state_changed_cb(
9750                                         __bt_hf_sco_state_changed_cb, NULL);
9751                         if (ret < BT_ERROR_NONE)
9752                                 TC_PRT("failed with [0x%04x]", ret);
9753                         else if (ret == BT_ERROR_NONE)
9754                                 TC_PRT("Success");
9755                         break;
9756                 case BT_UNIT_TEST_FUNCTION_HF_UNSET_SCO_CHANGED_CB:
9757                         ret = bt_hf_unset_sco_state_changed_cb();
9758                         if (ret < BT_ERROR_NONE)
9759                                 TC_PRT("failed with [0x%04x]", ret);
9760                         else if (ret == BT_ERROR_NONE)
9761                                 TC_PRT("Success");
9762                         break;
9763                 case BT_UNIT_TEST_FUNCTION_HF_SET_CALL_EVENT_CB:
9764                         ret = bt_hf_set_call_handling_event_cb(
9765                                         __bt_hf_set_call_handling_event_cb,
9766                                         NULL);
9767                         if (ret < BT_ERROR_NONE)
9768                                 TC_PRT("failed with [0x%04x]", ret);
9769                         else if (ret == BT_ERROR_NONE)
9770                                 TC_PRT("Success");
9771                         break;
9772                 case BT_UNIT_TEST_FUNCTION_HF_UNSET_CALL_EVENT_CB:
9773                         ret = bt_hf_unset_call_handling_event_cb();
9774                         if (ret < BT_ERROR_NONE)
9775                                 TC_PRT("failed with [0x%04x]", ret);
9776                         else if (ret == BT_ERROR_NONE)
9777                                 TC_PRT("Success");
9778                         break;
9779                 case BT_UNIT_TEST_FUNCTION_HF_SET_CALL_STATUS_UPDATED_EVENT_CB:
9780                         ret = bt_hf_set_call_status_updated_event_cb(
9781                                         __bt_hf_call_status_updated_event_cb,
9782                                         NULL);
9783                         if (ret < BT_ERROR_NONE)
9784                                 TC_PRT("failed with [0x%04x]", ret);
9785                         else if (ret == BT_ERROR_NONE)
9786                                 TC_PRT("Success");
9787                         break;
9788                 case BT_UNIT_TEST_FUNCTION_HF_UNSET_CALL_STATUS_UPDATED_EVENT_CB:
9789                         ret = bt_hf_unset_call_status_updated_event_cb();
9790                         if (ret < BT_ERROR_NONE)
9791                                 TC_PRT("failed with [0x%04x]", ret);
9792                         else if (ret == BT_ERROR_NONE)
9793                                 TC_PRT("Success");
9794                         break;
9795                 case BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS:
9796                         need_to_set_params = true;
9797                         TC_PRT("Select the function again");
9798                         break;
9799
9800                 default:
9801                         break;
9802                 }
9803
9804                 break;
9805         }
9806         case BT_UNIT_TEST_TABLE_PBAP_CLIENT: {
9807                 if (!TIZEN_PROFILE_WEARABLE_IVI)
9808                         break;
9809                 switch (test_id) {
9810
9811                 /*PBAP Test Cases */
9812                 case BT_UNIT_TEST_FUNCTION_PBAP_CLIENT_INITIALIZE:
9813                         ret = bt_pbap_client_initialize();
9814                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9815                         break;
9816                 case BT_UNIT_TEST_FUNCTION_PBAP_CLIENT_DEINITIALIZE:
9817                         ret = bt_pbap_client_deinitialize();
9818                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9819                         break;
9820                 case BT_UNIT_TEST_FUNCTION_PBAP_CLIENT_SET_CONNECTION_STATE_CHANGED_CB: {
9821                         ret = bt_pbap_client_set_connection_state_changed_cb(__bt_pbap_connection_state_changed_cb,
9822                                         NULL);
9823                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9824                         break;
9825                 }
9826                 case BT_UNIT_TEST_FUNCTION_PBAP_CLIENT_UNSET_CONNECTION_STATE_CHANGED_CB: {
9827                         ret = bt_pbap_client_unset_connection_state_changed_cb();
9828                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9829                         break;
9830                 }
9831                 case BT_UNIT_TEST_FUNCTION_PBAP_CLIENT_CONNECT: {
9832                         ret = bt_pbap_client_connect(remote_addr);
9833                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9834                         break;
9835                 }
9836                 case BT_UNIT_TEST_FUNCTION_PBAP_CLIENT_DISCONNECT: {
9837                         ret = bt_pbap_client_disconnect(remote_addr);
9838                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9839                         break;
9840                 }
9841                 case BT_UNIT_TEST_FUNCTION_PBAP_CLIENT_IS_CONNECTED: {
9842                         bool connected_status = false;
9843
9844                         ret = bt_pbap_client_is_connected(remote_addr, &connected_status);
9845                         if (ret < BT_ERROR_NONE)
9846                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
9847
9848                         TC_PRT("PBAP Profile [%s]",
9849                                 connected_status ? "Connected" : "Disconnected");
9850                         break;
9851                 }
9852                 case BT_UNIT_TEST_FUNCTION_PBAP_CLIENT_GETSIZE: {
9853                         ret = bt_pbap_client_get_phone_book_size(remote_addr,
9854                                         0, 0,
9855                                         __bt_pbap_phonebook_size_cb,
9856                                         NULL);
9857                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9858                         break;
9859                 }
9860                 case BT_UNIT_TEST_FUNCTION_PBAP_CLIENT_PHONEBOOKPULL: {
9861                         unsigned int fields = BT_PBAP_FIELD_PHOTO | BT_PBAP_FIELD_EMAIL | BT_PBAP_FIELD_ORG | BT_PBAP_FIELD_X_IRMC_CALL_DATETIME;
9862
9863                         ret = bt_pbap_client_get_phone_book(remote_addr,
9864                                         0, 0, 0, 0, 0, 100,
9865                                         fields, __bt_pbap_phonebook_pull_cb,
9866                                         NULL);
9867                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9868                         break;
9869                 }
9870                 case BT_UNIT_TEST_FUNCTION_PBAP_CLIENT_VCARDLIST: {
9871                         ret = bt_pbap_client_get_list(remote_addr,
9872                                         0, 0, 0, 0, 100,
9873                                         __bt_pbap_vcard_list_cb,
9874                                         NULL);
9875                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9876                         break;
9877                 }
9878                 case BT_UNIT_TEST_FUNCTION_PBAP_CLIENT_VCARDPULL: {
9879                         long long unsigned fields = BT_PBAP_FIELD_PHOTO | BT_PBAP_FIELD_EMAIL | BT_PBAP_FIELD_ORG;
9880                         ret = bt_pbap_client_pull_vcard(remote_addr,
9881                                         0, 0, 0, 0, fields,
9882                                         __bt_pbap_phonebook_pull_cb,
9883                                         NULL);
9884                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9885                         break;
9886                 }
9887                 case BT_UNIT_TEST_FUNCTION_PBAP_CLIENT_PHONEBOOKSEARCH: {
9888                         ret = bt_pbap_client_search_phone_book(remote_addr,
9889                                         0, 0,
9890                                         0, "ff",
9891                                         0, 0, 100,
9892                                         __bt_pbap_vcard_list_cb,
9893                                         NULL);
9894                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9895                         break;
9896                 }
9897                 case BT_UNIT_TEST_FUNCTION_PBAP_CLIENT_VCARDLIST_MAXLIST_ZERO: {
9898                         ret = bt_pbap_client_get_list(remote_addr,
9899                                         0, 0, 0, 0, 0,
9900                                         __bt_pbap_vcard_list_cb,
9901                                         NULL);
9902                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9903                         break;
9904                 }
9905
9906                 case BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS:
9907                         need_to_set_params = true;
9908                         TC_PRT("Select the function again");
9909                         break;
9910
9911                 default:
9912                         break;
9913                 }
9914
9915                 break;
9916         }
9917         case BT_UNIT_TEST_TABLE_TDS_PROVIDER: {
9918                 switch (test_id) {
9919                 case BT_UNIT_TEST_FUNCTION_TDS_PROVIDER_REGISTER: {
9920                         ret = bt_tds_provider_register();
9921                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9922                         break;
9923                 }
9924                 case BT_UNIT_TEST_FUNCTION_TDS_PROVIDER_UNREGISTER: {
9925                         ret = bt_tds_provider_unregister();
9926                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9927                         provider = NULL;
9928                         break;
9929                 }
9930                 case BT_UNIT_TEST_FUNCTION_TDS_PROVIDER_SET_ACT_REQ_CB: {
9931                         ret = bt_tds_set_transport_activation_requested_cb(__tds_activation_req_cb, NULL);
9932                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9933                         break;
9934                 }
9935                 case BT_UNIT_TEST_FUNCTION_TDS_PROVIDER_UNSET_ACT_REQ_CB: {
9936                         ret = bt_tds_unset_transport_activation_requested_cb();
9937                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9938                         break;
9939                 }
9940                 case BT_UNIT_TEST_FUNCTION_TDS_CUSTOM_PROVIDER_CREATE: {
9941                         if (provider) {
9942                                 ret = bt_tds_provider_destroy(provider);
9943                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
9944
9945                                 provider = NULL;
9946                         }
9947                         ret = bt_tds_provider_create(&provider, BT_TDS_TRANSPORT_CUSTOM);
9948                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9949                         break;
9950                 }
9951                 case BT_UNIT_TEST_FUNCTION_TDS_CUSTOM_PROVIDER_DESTROY: {
9952                         ret = bt_tds_provider_destroy(provider);
9953                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9954                         provider = NULL;
9955                         break;
9956                 }
9957                 case BT_UNIT_TEST_FUNCTION_TDS_CUSTOM_PROVIDER_SET_TRANSPORT_DATA: {
9958                         unsigned char buf[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, /* Mac */
9959                                                 0x20, 0xFA, /* Operating Channel */
9960                                                 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF}; /* Hash */
9961
9962                         ret = bt_tds_provider_set_transport_data(provider,
9963                                         BT_TDS_TRANSPORT_STATE_OFF, buf, sizeof(buf));
9964                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9965                         break;
9966                 }
9967                 case BT_UNIT_TEST_FUNCTION_TDS_CUSTOM_PROVIDER_SET_MANUF_DATA: {
9968                         unsigned char buf[] = {0x00, 0x75, 0x4E, 0x24, 0x36, 0x28, 0x01, 0x13};
9969
9970                         ret = bt_tds_provider_set_manufacturer_data(buf, sizeof(buf));
9971                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9972                         break;
9973                 }
9974                 case BT_UNIT_TEST_FUNCTION_TDS_CUSTOM_PROVIDER_SEND_ACTIVATION_RESP: {
9975                         ret = bt_tds_provider_send_activation_resp(
9976                                         tds_act_address, BLUETOOTH_ERROR_NONE, provider);
9977                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9978                         break;
9979                 }
9980                 default:
9981                         break;
9982                 }
9983                 break;
9984         }
9985         case BT_UNIT_TEST_TABLE_TDS_SEEKER: {
9986                 switch (test_id) {
9987                 case BT_UNIT_TEST_FUNCTION_TDS_START_DISCOVERING_PROVIDER: {
9988                         ret = bt_tds_start_seeking_providers(__bt_tds_provider_scan_result_cb, NULL);
9989                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9990                         break;
9991                 }
9992                 case BT_UNIT_TEST_FUNCTION_TDS_STOP_DISCOVERING_PROVIDER: {
9993                         ret = bt_tds_stop_seeking_providers();
9994                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
9995                         break;
9996                 }
9997                 case BT_UNIT_TEST_FUNCTION_TDS_SEEKER_CREATE: {
9998                         if (seeker)
9999                                 seeker = NULL;
10000                         ret = bt_tds_seeker_create(remote_addr, &seeker);
10001                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
10002                         break;
10003                 }
10004                 case BT_UNIT_TEST_FUNCTION_TDS_SEEKER_DESTROY: {
10005                         if (seeker) {
10006                                 ret = bt_tds_seeker_destroy(seeker);
10007                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
10008                         }
10009                         break;
10010                 }
10011                 case BT_UNIT_TEST_FUNCTION_TDS_SEEKER_SET_CONNECTION_CALLBACK: {
10012                         if (seeker) {
10013                                 ret = bt_tds_seeker_set_connection_state_changed_cb(seeker,
10014                                                 __bt_tds_seeker_connection_state_changed_cb, NULL);
10015                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
10016                         }
10017                         break;
10018                 }
10019                 case BT_UNIT_TEST_FUNCTION_TDS_SEEKER_CONNECT: {
10020                         if (seeker) {
10021                                 ret = bt_tds_seeker_connect(seeker);
10022                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
10023                         }
10024                         break;
10025                 }
10026                 case BT_UNIT_TEST_FUNCTION_TDS_SEEKER_DISCONNECT: {
10027                         if (seeker) {
10028                                 ret = bt_tds_seeker_disconnect(seeker);
10029                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
10030                         }
10031                         break;
10032                 }
10033                 case BT_UNIT_TEST_FUNCTION_TDS_SEEKER_UNSET_CONNECTION_CALLBACK: {
10034                         if (seeker) {
10035                                 ret = bt_tds_seeker_unset_connection_state_changed_cb(seeker);
10036                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
10037                         }
10038                         break;
10039                 }
10040                 case BT_UNIT_TEST_FUNCTION_TDS_SEEKER_GET_COMPLETE_DATA: {
10041                         if (seeker) {
10042                                 ret = bt_tds_seeker_get_complete_transport_blocks(seeker,
10043                                                 __bt_tds_seeker_complete_transport_data_cb, NULL);
10044                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
10045                         }
10046                         break;
10047                 }
10048                 case BT_UNIT_TEST_FUNCTION_TDS_SEEKER_ACTIVATE_CONTROL_POINT: {
10049                         if (seeker) {
10050                                 unsigned char buf[] = {0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, /* Mac */
10051                                         0x0A, 0x0B};    /* Channel Info */
10052                                 bt_tds_transport_e transport = BT_TDS_TRANSPORT_CUSTOM;
10053                                 ret = bt_tds_seeker_activate_control_point(seeker, transport, buf, sizeof(buf),
10054                                                 __bt_tds_control_point_activation_result_cb, NULL);
10055                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
10056                         }
10057                         break;
10058                 }
10059                 default:
10060                         break;
10061                 }
10062                 break;
10063         }
10064         case BT_UNIT_TEST_TABLE_OTP: {
10065                 switch (test_id) {
10066                 case BT_UNIT_TEST_FUNCTION_OTP_SERVER_INIT: {
10067                         char *directory = NULL;
10068
10069                         if (g_test_param.param_count < 1)
10070                                         TC_PRT("No relative path set");
10071                         else
10072                                 directory = g_test_param.params[0];
10073
10074                         TC_PRT("%s", directory);
10075
10076                         ret = bt_otp_server_initialize(directory);
10077                         if (ret < BT_ERROR_NONE)
10078                                 TC_PRT("failed with [0x%04x]", ret);
10079                         else if (ret == BT_ERROR_NONE)
10080                                 TC_PRT("Success");
10081                         /* __bt_free_test_param(&g_test_param); */
10082                         break;
10083                 }
10084                 case BT_UNIT_TEST_FUNCTION_OTP_SERVER_DEINIT: {
10085                         ret = bt_otp_server_deinitialize();
10086                         if (ret < BT_ERROR_NONE)
10087                                 TC_PRT("failed with [0x%04x]", ret);
10088                         else if (ret == BT_ERROR_NONE)
10089                                 TC_PRT("Success");
10090                         break;
10091                 }
10092                 case BT_UNIT_TEST_FUNCTION_OTP_SET_SERVER_STATE_CHANGED_CB: {
10093                         ret = bt_otp_set_server_state_changed_cb(
10094                                                 __bt_otp_server_state_changed_cb, NULL);
10095                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
10096                         break;
10097                 }
10098                 case BT_UNIT_TEST_FUNCTION_OTP_UNSET_SERVER_STATE_CHANGED_CB: {
10099                         ret = bt_otp_unset_server_state_changed_cb();
10100                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
10101                         break;
10102                 }
10103                 case BT_UNIT_TEST_FUNCTION_OTP_CLIENT_CREATE: {
10104                         if (otp_client)
10105                                 otp_client = NULL;
10106                         ret = bt_otp_client_create(remote_addr, &otp_client);
10107                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
10108                         break;
10109                 }
10110                 case BT_UNIT_TEST_FUNCTION_OTP_CLIENT_DESTROY: {
10111                         if (otp_client) {
10112                                 ret = bt_otp_client_destroy(otp_client);
10113                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
10114                         }
10115                         break;
10116                 }
10117                 case BT_UNIT_TEST_FUNCTION_OTP_CLIENT_SET_CONNECTION_CALLBACK: {
10118                         if (otp_client) {
10119                                 ret = bt_otp_client_set_connection_state_changed_cb(otp_client,
10120                                                 __bt_otp_client_connection_state_changed_cb, NULL);
10121                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
10122                         }
10123                         break;
10124                 }
10125                 case BT_UNIT_TEST_FUNCTION_OTP_CLIENT_CONNECT: {
10126                         if (otp_client) {
10127                                 ret = bt_otp_client_connect(otp_client);
10128                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
10129                         }
10130                         break;
10131                 }
10132                 case BT_UNIT_TEST_FUNCTION_OTP_CLIENT_DISCONNECT: {
10133                         if (otp_client) {
10134                                 ret = bt_otp_client_disconnect(otp_client);
10135                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
10136                         }
10137                         break;
10138                 }
10139                 case BT_UNIT_TEST_FUNCTION_OTP_CLIENT_UNSET_CONNECTION_CALLBACK: {
10140                         if (otp_client) {
10141                                 ret = bt_otp_client_unset_connection_state_changed_cb(otp_client);
10142                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
10143                         }
10144                         break;
10145                 }
10146                 case BT_UNIT_TEST_FUNCTION_OTP_CLIENT_DISCOVER_ALL_OBJECTS:     {
10147                         if (otp_client) {
10148                                 ret = bt_otp_client_discover_all_objects(otp_client,
10149                                                                 __bt_otp_client_object_discovery_cb, NULL);
10150                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
10151                         }
10152                         break;
10153                 }
10154                 case BT_UNIT_TEST_FUNCTION_OTP_CLIENT_SELECT_OBJ:       {
10155                         if (otp_client) {
10156                                 unsigned long long id;
10157                                 if (g_test_param.param_count < 1) {
10158                                                 TC_PRT("Input parameters first");
10159                                                 break;
10160                                 }
10161
10162                                 id = (unsigned long long)atoi(g_test_param.params[0]);
10163                                 TC_PRT("Object ID[%llu]", id);
10164                                 ret = bt_otp_client_select_object(otp_client, id,
10165                                                         __bt_otp_client_object_select_cb, NULL);
10166                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
10167                         }
10168                         break;
10169                 }
10170                 case BT_UNIT_TEST_FUNCTION_OTP_CLIENT_READ_OBJ_CONTENTS:        {
10171                         if (otp_client) {
10172                                 ret = bt_otp_client_read_object_contents(otp_client,
10173                                                         __bt_otp_client_read_object_complete_cb, NULL);
10174                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
10175                         }
10176                         break;
10177                 }
10178                 case BT_UNIT_TEST_FUNCTION_OTP_CLIENT_CREATE_OBJ: {
10179                         char *file_path = NULL;
10180                         if (g_test_param.param_count < 1) {
10181                                         TC_PRT("Input parameters first");
10182                                         break;
10183                         }
10184
10185                         file_path = g_test_param.params[0];
10186                         TC_PRT("%s", file_path);
10187
10188                         if (otp_client) {
10189                                 ret = bt_otp_client_create_object(otp_client,
10190                                                 file_path, __bt_otp_client_object_create_cb, NULL);
10191                                 if (ret < BT_ERROR_NONE)
10192                                         TC_PRT("failed with [0x%04x]", ret);
10193                                 else if (ret == BT_ERROR_NONE)
10194                                         TC_PRT("Success");
10195                         }
10196                         __bt_free_test_param(&g_test_param);
10197                         break;
10198                 }
10199                 case BT_UNIT_TEST_FUNCTION_OTP_CLIENT_WRITE_OBJ: {
10200                         char *file_path = NULL;
10201                         int offset, length, mode;
10202
10203                         if (g_test_param.param_count < 4) {
10204                                         TC_PRT("Input parameters first");
10205                                         break;
10206                         }
10207
10208                         file_path = g_test_param.params[0];
10209                         TC_PRT("%s", file_path);
10210
10211                         offset = strtoul(g_test_param.params[1], NULL, 10);
10212                         length = strtoul(g_test_param.params[2], NULL, 10);
10213                         mode = strtoul(g_test_param.params[3], NULL, 10);
10214
10215                         if (otp_client) {
10216                                 ret = bt_otp_client_write_object(otp_client,
10217                                                 file_path, offset, length, mode,
10218                                                 __bt_otp_client_object_write_cb, NULL);
10219                                 if (ret < BT_ERROR_NONE)
10220                                         TC_PRT("failed with [0x%04x]", ret);
10221                                 else if (ret == BT_ERROR_NONE)
10222                                         TC_PRT("Success");
10223                         }
10224                         __bt_free_test_param(&g_test_param);
10225                         break;
10226                 }
10227                 case BT_UNIT_TEST_FUNCTION_OTP_CLIENT_EXECUTE_OBJ:      {
10228                         if (otp_client) {
10229                                 ret = bt_otp_client_execute_object(otp_client,
10230                                                         __bt_otp_client_object_execute_cb, NULL);
10231                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
10232                         }
10233                         break;
10234                 }
10235                 case BT_UNIT_TEST_FUNCTION_OTP_CLIENT_DELETE_OBJ:       {
10236                         if (otp_client) {
10237                                 ret = bt_otp_client_delete_object(otp_client,
10238                                                         __bt_otp_client_object_delete_cb, NULL);
10239                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
10240                         }
10241                         break;
10242                 }
10243                 case BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS:
10244                         need_to_set_params = true;
10245                         TC_PRT("Select the function again");
10246                         break;
10247                 default:
10248                         break;
10249                 }
10250                 break;
10251         }
10252                 case BT_UNIT_TEST_TABLE_HRP_SENSOR: {
10253                 switch (test_id) {
10254                 case BT_UNIT_TEST_FUNCTION_HR_SENSOR_SET_LOC_VALUE: {
10255                         TC_PRT("HR SENSOR SET LOC VALUE\n");
10256                         bt_body_sensor_location_e location = BT_BSL_WRIST;
10257                         bt_hrp_sensor_set_location_value(location);
10258
10259                         break;
10260                 }
10261                 case BT_UNIT_TEST_FUNCTION_HR_SENSOR_SET_CONTACT_VALUE: {
10262                         TC_PRT("HR SENSOR SET CONTACT VALUE\n");
10263                         bool iscontact = true;
10264                         bt_hrp_sensor_set_contact_value(iscontact);
10265                         break;
10266                 }
10267                 case BT_UNIT_TEST_FUNCTION_HR_SENSOR_SET_DEVICE_NAME: {
10268                         TC_PRT("HR SENSOR SET DEVICE NAME\n");
10269                         char *name = g_strdup("SAMSUNG HR");
10270                         bt_hrp_sensor_set_device_manufacturer_name(name);
10271                         break;
10272                 }
10273                 case BT_UNIT_TEST_FUNCTION_HR_SENSOR_CREATE: {
10274                         TC_PRT("HR SENSOR CREATE\n");
10275                         ret  = bt_hrp_sensor_create();
10276                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
10277                         break;
10278                 }
10279                 case BT_UNIT_TEST_FUNCTION_HR_SENSOR_NOTIFY: {
10280                         TC_PRT("HR SENSOR UPDATE HR value\n");
10281                         bt_hrp_sensor_set_heartrate_value(60 + (rand()%60));
10282                         break;
10283                 }
10284                 case BT_UNIT_TEST_FUNCTION_HR_SENSOR_DESTORY: {
10285                         TC_PRT("HR SENSOR DESTROY\n");
10286                         ret = bt_hrp_sensor_destroy();
10287                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
10288                         break;
10289                 }
10290                 default:
10291                         break;
10292                 }
10293                 break;
10294         }
10295                 case BT_UNIT_TEST_TABLE_HRP_COLLECTOR: {
10296                 switch (test_id) {
10297                 case BT_UNIT_TEST_FUNCTION_HR_COLLECTOR_CONNECTION_STATE_CALLBACK: {
10298                                 TC_PRT("HR COLLECTOR CONNECTION STATE CALLBACK\n");
10299                         if (collector) {
10300                                 ret = bt_hrp_collector_set_connection_state_changed_cb(collector,
10301                                                 __bt_hrp_collector_connection_state_changed_cb, NULL);
10302                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
10303                         }
10304                                 break;
10305                 }
10306                 case BT_UNIT_TEST_FUNCTION_HR_COLLECTOR_SET_NOTIFICATION: {
10307                                 TC_PRT("HR COLLECTOR SET NOTIFICATION\n");
10308                                 if (set_notif == true) {
10309                                         set_notif = false;
10310                                         ret = bt_hrp_collector_set_notification(collector,
10311                                                                         __bt_hrp_heart_rate_value_changed_cb, true);
10312                                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
10313                                 } else {
10314                                         set_notif = true;
10315                                         ret = bt_hrp_collector_set_notification(collector,
10316                                                                         __bt_hrp_heart_rate_value_changed_cb, false);
10317                                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
10318                                 }
10319                                 break;
10320                 }
10321                 case BT_UNIT_TEST_FUNCTION_HR_COLLECTOR_CREATE: {
10322                                 TC_PRT("HR COLLECTOR CREATE\n");
10323                                 ret = bt_hrp_collector_create(remote_addr, &collector);
10324                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
10325                                 break;
10326                 }
10327                 case BT_UNIT_TEST_FUNCTION_HR_COLLECTOR_START_SCAN: {
10328                                 TC_PRT("HR COLLECTOR START SCAN\n");
10329                                 ret = bt_hrp_collector_start_scan(__bt_adapter_le_scan_result_cb, NULL);
10330                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
10331                                 break;
10332                 }
10333                 case BT_UNIT_TEST_FUNCTION_HR_COLLECTOR_STOP_SCAN: {
10334                                 TC_PRT("HR COLLECTOR STOP SCAN\n");
10335                                 ret = bt_hrp_collector_stop_scan();
10336                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
10337                                 break;
10338                 }
10339                 case BT_UNIT_TEST_FUNCTION_HR_COLLECTOR_CONNECT: {
10340                                 TC_PRT("HR COLLECTOR CONNECT\n");
10341                                 ret = bt_hrp_collector_connect(collector);
10342                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
10343                                 break;
10344                 }
10345                 case BT_UNIT_TEST_FUNCTION_HR_COLLECTOR_DISCONNECT: {
10346                                 TC_PRT("HR COLLECTOR DISCONNECT\n");
10347                                 ret = bt_hrp_collector_disconnect(collector);
10348                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
10349                                 break;
10350                 }
10351                 case BT_UNIT_TEST_FUNCTION_HR_COLLECTOR_GET_BSL_LOC: {
10352                                 TC_PRT("HR COLLECTOR GET BSL LOCATION\n");
10353                                 if (collector) {
10354                                         ret = bt_hrp_collector_get_body_sensor_location(collector, _bt_hrp_collector_bsl_read_completed_cb);
10355                                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
10356                                 }
10357                                 break;
10358                 }
10359                 case BT_UNIT_TEST_FUNCTION_HR_COLLECTOR_DESTROY: {
10360                                 TC_PRT("HR COLLECTOR DESTROY\n");
10361                                 ret = bt_hrp_collector_destory(collector);
10362                                 TC_PRT("returns %s\n", __bt_get_error_message(ret));
10363                                 collector  = NULL;
10364                                 break;
10365                 }
10366                 default:
10367                         break;
10368                 }
10369                 break;
10370         }
10371
10372         case BT_UNIT_TEST_TABLE_ETC: {
10373                 static unsigned int delay = 0;
10374                 bt_onoff_cnt = 0;
10375                 bt_onoff_cnt_success = 0;
10376                 bt_onoff_cnt_fail = 0;
10377
10378                 total_time = 0;
10379                 gettimeofday(&check_time, NULL);
10380
10381                 if (input_automated_test_delay == true) {
10382                         delay = test_id;
10383                         test_id = BT_UNIT_TEST_FUNCTION_ON_OFF_REPEAT_TEST_N_SEC_DELAY;
10384                 }
10385
10386                 switch (test_id) {
10387                 /*Automated Test Cases */
10388                 case BT_UNIT_TEST_FUNCTION_ON_OFF_REPEAT_TEST: {
10389                         bt_adapter_state_e state = BT_ADAPTER_DISABLED;
10390                         delay = 0;
10391
10392                         ret = bt_adapter_set_state_changed_cb(
10393                                         __bt_repeat_test_adapter_state_changed_cb,
10394                                         &delay);
10395                         TC_PRT("set_cb returns %s\n", __bt_get_error_message(ret));
10396
10397                         ret = bt_adapter_get_state(&state);
10398                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
10399                         TC_PRT("Current state: %d", state);
10400
10401                         if (state == BT_ADAPTER_DISABLED)
10402                                 bt_adapter_enable();
10403                         else
10404                                 bt_adapter_disable();
10405                         break;
10406                 }
10407                 case BT_UNIT_TEST_FUNCTION_ON_OFF_REPEAT_TEST_1_SEC_DELAY: {
10408                         bt_adapter_state_e state = BT_ADAPTER_DISABLED;
10409                         delay = 1;
10410
10411                         ret = bt_adapter_set_state_changed_cb(
10412                                         __bt_repeat_test_adapter_state_changed_cb,
10413                                         &delay);
10414                         TC_PRT("set_cb returns %s\n", __bt_get_error_message(ret));
10415
10416                         ret = bt_adapter_get_state(&state);
10417                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
10418                         TC_PRT("Current state: %d", state);
10419
10420                         if (state == BT_ADAPTER_DISABLED)
10421                                 bt_adapter_enable();
10422                         else
10423                                 bt_adapter_disable();
10424                         break;
10425                 }
10426                 case BT_UNIT_TEST_FUNCTION_ON_OFF_REPEAT_TEST_N_SEC_DELAY: {
10427                         bt_adapter_state_e state = BT_ADAPTER_DISABLED;
10428
10429                         input_automated_test_delay = false;
10430
10431                         ret = bt_adapter_set_state_changed_cb(
10432                                         __bt_repeat_test_adapter_state_changed_cb,
10433                                         &delay);
10434                         TC_PRT("set_cb returns %s\n", __bt_get_error_message(ret));
10435
10436                         ret = bt_adapter_get_state(&state);
10437                         TC_PRT("returns %s\n", __bt_get_error_message(ret));
10438                         TC_PRT("Current state: %d", state);
10439
10440                         if (state == BT_ADAPTER_DISABLED)
10441                                 bt_adapter_enable();
10442                         else
10443                                 bt_adapter_disable();
10444                         break;
10445                 }
10446                 case BT_UNIT_TEST_FUNCTION_APP_CONTROL_DEFAULT: {
10447                         char *mode = "setting";
10448
10449                         if (g_test_param.param_count > 0)
10450                                 mode = g_test_param.params[0];
10451
10452                         app_control_h service = NULL;
10453
10454                         app_control_create(&service);
10455                         app_control_set_app_id(service, "com.samsung.bluetooth-single");
10456                         app_control_set_operation(service, APP_CONTROL_OPERATION_DEFAULT);
10457                         app_control_add_extra_data(service, "launch-type", mode);
10458                         ret = app_control_send_launch_request(service, NULL, NULL);
10459                         TC_PRT("returns %d", ret);
10460
10461                         app_control_destroy(service);
10462                         break;
10463                 }
10464                 case BT_UNIT_TEST_FUNCTION_APP_CONTROL_2_3_BT_ONOFF: {
10465                         app_control_h service = NULL;
10466
10467                         app_control_create(&service);
10468                         app_control_set_operation(service, APP_CONTROL_OPERATION_EDIT);
10469                         app_control_set_mime(service, "application/x-bluetooth-on-off");
10470
10471                         ret = app_control_send_launch_request(service, NULL, NULL);
10472                         TC_PRT("returns %d", ret);
10473
10474                         app_control_destroy(service);
10475
10476                         break;
10477                 }
10478                 case BT_UNIT_TEST_FUNCTION_APP_CONTROL_2_3_BT_VISIBILITY: {
10479                         app_control_h service = NULL;
10480
10481                         app_control_create(&service);
10482                         app_control_set_operation(service, APP_CONTROL_OPERATION_EDIT);
10483                         app_control_set_mime(service, "application/x-bluetooth-visibility");
10484
10485                         ret = app_control_send_launch_request(service, NULL, NULL);
10486                         TC_PRT("returns %d", ret);
10487
10488                         app_control_destroy(service);
10489
10490                         break;
10491                 }
10492                 case BT_UNIT_TEST_FUNCTION_APP_CONTROL_2_4_BT_ONOFF: {
10493                         app_control_h service = NULL;
10494
10495                         app_control_create(&service);
10496                         app_control_set_operation(service, APP_CONTROL_OPERATION_SETTING_BT_ENABLE);
10497
10498                         ret = app_control_send_launch_request(service, NULL, NULL);
10499                         TC_PRT("returns %d", ret);
10500
10501                         app_control_destroy(service);
10502
10503                         break;
10504                 }
10505                 case BT_UNIT_TEST_FUNCTION_APP_CONTROL_2_4_BT_VISIBILITY: {
10506                         app_control_h service = NULL;
10507
10508                         app_control_create(&service);
10509                         app_control_set_operation(service, APP_CONTROL_OPERATION_SETTING_BT_VISIBILITY);
10510
10511                         ret = app_control_send_launch_request(service, NULL, NULL);
10512                         TC_PRT("returns %d", ret);
10513
10514                         app_control_destroy(service);
10515
10516                         break;
10517                 }
10518                 case BT_UNIT_TEST_FUNCTION_CHECK_FEATURE: {
10519                         int ret;
10520                         bool is_supported = false;
10521
10522                         if (g_test_param.param_count > 0) {
10523                                 ret = system_info_get_custom_bool(
10524                                         g_test_param.params[0], &is_supported);
10525                                 if (ret != 0)
10526                                         TC_PRT("returns %d", ret);
10527                                 TC_PRT("%s is %s", g_test_param.params[0],
10528                                         is_supported ? "true" : "false");
10529                                 __bt_free_test_param(&g_test_param);
10530                         } else {
10531                                 ret = system_info_get_custom_bool(
10532                                         "tizen.org/feature/network.bluetooth", &is_supported);
10533                                 if (ret != 0)
10534                                         TC_PRT("returns %d", ret);
10535                                 TC_PRT("tizen.org/feature/network.bluetooth is %s",
10536                                         is_supported ? "true" : "false");
10537                         }
10538
10539                         break;
10540                 }
10541                 case BT_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS:
10542                         need_to_set_params = true;
10543                         TC_PRT("Select the function again");
10544                         break;
10545                 default:
10546                         break;
10547                 }
10548
10549                 break;
10550         }
10551         default:
10552                 break;
10553         }
10554
10555         return 0;
10556 }
10557
10558 static gboolean key_event_cb(GIOChannel *chan,
10559                                 GIOCondition cond,
10560                                 gpointer data)
10561 {
10562         char buf[BUFFER_LEN] = { 0 };
10563
10564 #ifdef ARCH64
10565                 unsigned long len = 0;
10566 #else
10567                 unsigned int len = 0;
10568 #endif
10569         int test_id;
10570         bool is_call_api = false;
10571
10572         memset(buf, 0, sizeof(buf));
10573
10574         if (g_io_channel_read_chars(chan, buf, sizeof(buf),
10575                                 &len, NULL) == G_IO_STATUS_ERROR) {
10576                 TC_PRT("IO Channel read error");
10577                 return FALSE;
10578         }
10579
10580         if (need_to_set_params == true) {
10581                 if (g_test_id == -1) {
10582                         test_id = atoi(buf);
10583                         g_test_id = test_id;
10584                 }
10585                 test_set_params(g_test_id, buf);
10586                 return TRUE;
10587         } else {
10588                 TC_PRT("%s", buf);
10589                 test_id = atoi(buf);
10590
10591                 g_test_id = -1;
10592                 need_to_set_params = false;
10593         }
10594
10595         if (current_tc_table == BT_UNIT_TEST_TABLE_MAIN) {
10596                 if (buf[0] == '0' && buf[2] == 0)
10597                         current_tc_table = BT_UNIT_TEST_TABLE_SET_ADDRESS;
10598                 else if (test_id >= BT_UNIT_TEST_TABLE_ADAPTER
10599                         && test_id < BT_UNIT_TEST_TABLE_FINISH)
10600                         current_tc_table = test_id;
10601                 else
10602                         is_call_api = true;
10603         }  else {
10604                 if (buf[0] == '0' && buf[2] == 0) {
10605                         current_tc_table = BT_UNIT_TEST_TABLE_MAIN;
10606                 } else if (current_tc_table == BT_UNIT_TEST_TABLE_ETC
10607                                         && test_id == BT_UNIT_TEST_FUNCTION_ON_OFF_REPEAT_TEST_N_SEC_DELAY
10608                                         && input_automated_test_delay == false) {
10609                                 input_automated_test_delay = true;
10610                 } else {
10611                         is_call_api = true;
10612                 }
10613         }
10614
10615         tc_usage_print();
10616
10617         if (current_tc_table == BT_UNIT_TEST_TABLE_SET_ADDRESS
10618                         && is_call_api == true) {
10619                 memcpy(remote_addr, buf, 17);
10620                 remote_addr[17] = 0;
10621         } else if (test_id && is_call_api)
10622 #ifdef ARCH64
10623                 g_idle_add(test_input_callback, (void *)(uintptr_t)test_id);
10624 #else
10625                 g_idle_add(test_input_callback, (void *)test_id);
10626 #endif
10627         return TRUE;
10628 }
10629
10630 void sig_handler(int signo)
10631 {
10632         if (signo == SIGINT) {
10633                 if (bt_onoff_cnt > 0)
10634                         __bt_print_repeat_test_final_summary();
10635
10636                 bt_deinitialize();
10637                 exit(0);
10638         }
10639 }
10640
10641 int main()
10642 {
10643         GIOChannel *key_io;
10644
10645         current_tc_table = BT_UNIT_TEST_TABLE_MAIN;
10646
10647         key_io = g_io_channel_unix_new(fileno(stdin));
10648
10649         g_io_channel_set_encoding(key_io, NULL, NULL);
10650         g_io_channel_set_flags(key_io, G_IO_FLAG_NONBLOCK, NULL);
10651
10652         g_io_add_watch(key_io, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
10653                         key_event_cb, NULL);
10654
10655         g_io_channel_unref(key_io);
10656
10657         main_loop = g_main_loop_new(NULL, FALSE);
10658
10659         if (signal(SIGINT, sig_handler) == SIG_ERR)
10660                 TC_PRT("\n can't catch SIGINT\n");
10661
10662         g_main_loop_run(main_loop);
10663
10664         bt_deinitialize();
10665
10666         return 0;
10667 }