diff options
50 files changed, 7854 insertions, 40 deletions
diff --git a/TC/READAME.txt b/TC/READAME.txt new file mode 100644 index 0000000..f0edad5 --- /dev/null +++ b/TC/READAME.txt @@ -0,0 +1,5 @@ +Before run DTS of bluetooth, BT should be disabled. +This DTS needs another target and it must be set as the following: + 1) BT is activated. + 2) BT is discoverable. + 3) BT name is set as "dts_test". diff --git a/TC/_export_env.sh b/TC/_export_env.sh new file mode 100755 index 0000000..ac8f4a1 --- /dev/null +++ b/TC/_export_env.sh @@ -0,0 +1,9 @@ +#!/bin/sh + +. ./config +export TET_INSTALL_PATH=$TET_INSTALL_HOST_PATH # tetware root path +export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-target # tetware target path +#export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-simulator # tetware simulator path +export PATH=$TET_TARGET_PATH/bin:$PATH +export LD_LIBRARY_PATH=$TET_TARGET_PATH/lib/tet3:$LD_LIBRARY_PATH +export TET_ROOT=$TET_TARGET_PATH diff --git a/TC/_export_target_env.sh b/TC/_export_target_env.sh new file mode 100755 index 0000000..c693f83 --- /dev/null +++ b/TC/_export_target_env.sh @@ -0,0 +1,8 @@ +#!/bin/sh +. ./config +export TET_INSTALL_PATH=$TET_INSTALL_TARGET_PATH # path to path +export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-target +#export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-simulator # tetware simulator path +export PATH=$TET_TARGET_PATH/bin:$PATH +export LD_LIBRARY_PATH=$TET_TARGET_PATH/lib/tet3:$LD_LIBRARY_PATH +export TET_ROOT=$TET_TARGET_PATH diff --git a/TC/build.sh b/TC/build.sh new file mode 100755 index 0000000..72aad6c --- /dev/null +++ b/TC/build.sh @@ -0,0 +1,16 @@ +#!/bin/sh + +. ./_export_env.sh # setting environment variables + +export TET_SUITE_ROOT=`pwd` +FILE_NAME_EXTENSION=`date +%s` + +RESULT_DIR=results +HTML_RESULT=$RESULT_DIR/build-tar-result-$FILE_NAME_EXTENSION.html +JOURNAL_RESULT=$RESULT_DIR/build-tar-result-$FILE_NAME_EXTENSION.journal + +mkdir -p $RESULT_DIR + +tcc -c -p ./ +tcc -b -j $JOURNAL_RESULT -p ./ +grw -c 7 -f chtml -o $HTML_RESULT $JOURNAL_RESULT diff --git a/TC/clean.sh b/TC/clean.sh new file mode 100755 index 0000000..29743e0 --- /dev/null +++ b/TC/clean.sh @@ -0,0 +1,11 @@ +#!/bin/sh + +. ./_export_env.sh # setting environment variables + +export TET_SUITE_ROOT=`pwd` +RESULT_DIR=results + +tcc -c -p ./ # executing tcc, with clean option (-c) +rm -r $RESULT_DIR +rm -r tet_tmp_dir +rm testcase/tet_captured diff --git a/TC/config b/TC/config new file mode 100644 index 0000000..f919537 --- /dev/null +++ b/TC/config @@ -0,0 +1,2 @@ +TET_INSTALL_HOST_PATH=/home/bwlee/tools/TETware +TET_INSTALL_TARGET_PATH=/home/bwlee/tools/TETware diff --git a/TC/execute.sh b/TC/execute.sh new file mode 100755 index 0000000..0fe02e2 --- /dev/null +++ b/TC/execute.sh @@ -0,0 +1,15 @@ +#!/bin/sh + +. ./_export_target_env.sh # setting environment variables + +export TET_SUITE_ROOT=`pwd` +FILE_NAME_EXTENSION=`date +%s` + +RESULT_DIR=results +HTML_RESULT=$RESULT_DIR/exec-tar-result-$FILE_NAME_EXTENSION.html +JOURNAL_RESULT=$RESULT_DIR/exec-tar-result-$FILE_NAME_EXTENSION.journal + +mkdir -p $RESULT_DIR + +tcc -e -j $JOURNAL_RESULT -p ./ +grw -c 7 -f chtml -o $HTML_RESULT $JOURNAL_RESULT diff --git a/TC/testcase/Makefile b/TC/testcase/Makefile new file mode 100644 index 0000000..7d86802 --- /dev/null +++ b/TC/testcase/Makefile @@ -0,0 +1,24 @@ +CC ?= gcc + +C_FILES = $(shell ls *.c) + +PKGS = capi-network-bluetooth glib-2.0 + +LDFLAGS = `pkg-config --libs $(PKGS)` +LDFLAGS += $(TET_ROOT)/lib/tet3/tcm_s.o +LDFLAGS += -L$(TET_ROOT)/lib/tet3 -ltcm_s +LDFLAGS += -L$(TET_ROOT)/lib/tet3 -lapi_s + +CFLAGS = -I. `pkg-config --cflags $(PKGS)` +CFLAGS += -I$(TET_ROOT)/inc/tet3 +CFLAGS += -Wall + +TCS := $(shell ls -1 *.c | cut -d. -f1) + +all: $(TCS) + +%: %.c + $(CC) -o $@ $< $(CFLAGS) $(LDFLAGS) + +clean: + rm -f $(TCS) diff --git a/TC/testcase/tslist b/TC/testcase/tslist new file mode 100644 index 0000000..39a8464 --- /dev/null +++ b/TC/testcase/tslist @@ -0,0 +1,28 @@ +/testcase/utc_network_bluetooth_adapter_positive +/testcase/utc_network_bluetooth_adapter_negative +/testcase/utc_network_bluetooth_device_discovery_positive +/testcase/utc_network_bluetooth_device_discovery_negative +/testcase/utc_network_bluetooth_device_positive +/testcase/utc_network_bluetooth_device_negative +/testcase/utc_network_bluetooth_service_search_positive +/testcase/utc_network_bluetooth_service_search_negative +/testcase/utc_network_bluetooth_socket_positive +/testcase/utc_network_bluetooth_socket_negative +/testcase/utc_network_bluetooth_gatt_negative +/testcase/utc_network_bluetooth_gatt_positive +/testcase/utc_network_bluetooth_hid_negative +/testcase/utc_network_bluetooth_hid_positive +/testcase/utc_network_bluetooth_hdp_negative +/testcase/utc_network_bluetooth_hdp_positive +/testcase/utc_network_bluetooth_opp-server_negative +/testcase/utc_network_bluetooth_opp-server_positive +/testcase/utc_network_bluetooth_opp-client_negative +/testcase/utc_network_bluetooth_opp-client_positive +/testcase/utc_network_bluetooth_pan_negative +/testcase/utc_network_bluetooth_pan_positive +/testcase/utc_network_bluetooth_audio_negative +/testcase/utc_network_bluetooth_audio_positive +/testcase/utc_network_bluetooth_avrcp_negative +/testcase/utc_network_bluetooth_avrcp_positive +/testcase/utc_network_bluetooth_common_negative +/testcase/utc_network_bluetooth_common_positive diff --git a/TC/testcase/utc_network_bluetooth_adapter_negative.c b/TC/testcase/utc_network_bluetooth_adapter_negative.c new file mode 100644 index 0000000..06fdea7 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_adapter_negative.c @@ -0,0 +1,288 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <tet_api.h> +#include <bluetooth.h> +#include <stdlib.h> +#include <stdbool.h> +#include <glib.h> +#include <time.h> + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); +bt_adapter_visibility_mode_e adapter_visibility_mode = BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE; +char adapter_name[128] = "dts_test"; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_deinitialize_n(void); +static void utc_network_bluetooth_adapter_set_state_changed_cb_n(void); +static void utc_network_bluetooth_adapter_set_name_changed_cb_n(void); +static void utc_network_bluetooth_adapter_set_visibility_mode_changed_cb_n(void); +static void utc_network_bluetooth_adapter_enable_n(void); +static void utc_network_bluetooth_adapter_get_state_n(void); +static void utc_network_bluetooth_adapter_get_address_n(void); +static void utc_network_bluetooth_adapter_set_name_n(void); +static void utc_network_bluetooth_adapter_get_name_n(void); +static void utc_network_bluetooth_adapter_set_visibility_n(void); +static void utc_network_bluetooth_adapter_get_visibility_n(void); +static void utc_network_bluetooth_adapter_disable_n(void); +static void utc_network_bluetooth_adapter_unset_state_changed_cb_n(void); +static void utc_network_bluetooth_adapter_unset_name_changed_cb_n(void); +static void utc_network_bluetooth_adapter_unset_visibility_mode_changed_cb_n(void); + +void adapter_state_changed_cb_for_adapter_n(int result, + bt_adapter_state_e adapter_state, + void *user_data); +void adapter_state_changed_cb_for_adapter_n(int result, + bt_adapter_state_e adapter_state, + void *user_data); +void adapter_name_changed_cb_for_adapter_n(char *device_name, void *user_data); +void adapter_visibility_mode_changed_cb_for_adpater_n(int result, + bt_adapter_visibility_mode_e visibility_mode, + void *user_data); +void device_discovery_state_changed_cb_for_adapter_n(int result, + bt_adapter_device_discovery_state_e discovery_state, + bt_device_info_s *device_info, + void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_adapter_disable_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_set_state_changed_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_set_name_changed_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_set_visibility_mode_changed_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_get_state_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_get_address_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_set_name_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_get_name_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_get_visibility_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_set_visibility_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_deinitialize_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_enable_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_unset_state_changed_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_unset_name_changed_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_unset_visibility_mode_changed_cb_n, NEGATIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + /* start of TC */ + tet_printf("TC start."); + bt_initialize(); +} + +static void cleanup(void) +{ + /* end of TC */ + tet_printf("TC end"); +} + +/** + * @brief Negative test case of bt_deinitialize() + */ +static void utc_network_bluetooth_deinitialize_n(void) +{ + int ret = bt_deinitialize(); + + if (ret == BT_ERROR_NONE) { + ret = bt_deinitialize(); + dts_check_eq("bt_deinitialize", ret, BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned."); + } else { + dts_fail("bt_deinitialize", "bt_deinitialize() failed."); + } +} + +/** + * @brief Negative test case of bt_adapter_disable() + */ +static void utc_network_bluetooth_adapter_disable_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_disable(); + dts_check_eq("bt_adapter_disable", ret, BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is disabled"); +} + +/** + * @brief Negative test case of bt_adapter_set_state_changed_cb() + */ +static void utc_network_bluetooth_adapter_set_state_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_set_state_changed_cb(NULL, NULL); + dts_check_eq("bt_adapter_set_state_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL."); +} + +/** + * @brief Negative test case of bt_adapter_set_name_changed_cb() + */ +static void utc_network_bluetooth_adapter_set_name_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_set_name_changed_cb(NULL, NULL); + dts_check_eq("bt_adapter_set_name_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL."); +} + +/** + * @brief Negative test case of bt_adapter_set_visibility_mode_changed_cb() + */ +static void utc_network_bluetooth_adapter_set_visibility_mode_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_set_visibility_mode_changed_cb(NULL, NULL); + dts_check_eq("bt_adapter_set_visibility_mode_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL."); +} + +/** + * @brief Negative test case of bt_adapter_get_state() + */ +static void utc_network_bluetooth_adapter_get_state_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_get_state(NULL); + dts_check_eq("bt_adapter_get_state", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL."); +} + +/** + * @brief Negative test case of bt_adapter_get_address(). + */ +static void utc_network_bluetooth_adapter_get_address_n(void) +{ + char *address = NULL; + int ret = bt_adapter_get_address(&address); + + dts_check_eq("bt_adapter_get_address", ret, BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled."); +} + +/** + * @brief Negative test case of bt_adapter_get_name(). + */ +static void utc_network_bluetooth_adapter_get_name_n(void) +{ + char *name = NULL; + int ret = bt_adapter_get_name(&name); + + dts_check_eq("bt_adapter_get_name", ret, BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled."); +} + +/** + * @brief Negative test case of bt_adapter_get_visibility(). + */ +static void utc_network_bluetooth_adapter_get_visibility_n(void) +{ + bt_adapter_visibility_mode_e mode = + BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE; + int dur = 10; + int ret = bt_adapter_get_visibility(&mode, &dur); + + dts_check_eq("bt_adapter_get_visibility", ret, BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled."); +} + +/** + * @brief Negative test case of bt_adapter_set_name(). + */ +static void utc_network_bluetooth_adapter_set_name_n(void) +{ + int ret = bt_adapter_set_name(adapter_name); + + dts_check_eq("bt_adapter_set_name", ret, BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled."); +} + +/** + * @brief Negative test case of bt_adapter_set_visibility(). + */ +static void utc_network_bluetooth_adapter_set_visibility_n(void) +{ + int ret = bt_adapter_set_visibility(adapter_visibility_mode, 180); + + dts_check_eq("bt_adapter_set_visibility", ret, BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled."); +} + +/** + * @brief Negative test case of bt_adapter_unset_state_changed_cb() + */ +static void utc_network_bluetooth_adapter_unset_state_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_unset_state_changed_cb(); + dts_check_eq("bt_adapter_unset_state_changed_cb", ret, + BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized."); +} + +/** + * @brief Negative test case of bt_adapter_unset_name_changed_cb() + */ +static void utc_network_bluetooth_adapter_unset_name_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_unset_name_changed_cb(); + dts_check_eq("bt_adapter_unset_name_changed_cb", ret, + BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized."); +} + +/** + * @brief Negative test case of bt_adapter_unset_visibility_mode_changed_cb() + */ +static void +utc_network_bluetooth_adapter_unset_visibility_mode_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_unset_visibility_mode_changed_cb(); + dts_check_eq("bt_adapter_unset_visibility_mode_changed_cb", ret, + BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized."); +} + +/** + * @brief Negative test case of bt_adapter_enable() + */ +static void utc_network_bluetooth_adapter_enable_n(void) +{ + bt_error_e ret = bt_adapter_enable(); + dts_check_eq("bt_adapter_enable", ret, BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned."); +} diff --git a/TC/testcase/utc_network_bluetooth_adapter_positive.c b/TC/testcase/utc_network_bluetooth_adapter_positive.c new file mode 100644 index 0000000..28168a3 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_adapter_positive.c @@ -0,0 +1,499 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <tet_api.h> +#include <bluetooth.h> +#include <stdlib.h> +#include <stdbool.h> +#include <glib.h> +#include <time.h> + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); +static GMainLoop *mainloop; +static bool callback_result = false; +bt_adapter_visibility_mode_e adapter_visibility_mode = BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE; +char adapter_name[128] = "dts_test"; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_initialize_p(void); +static void utc_network_bluetooth_deinitialize_p(void); +static void utc_network_bluetooth_adapter_set_state_changed_cb_p(void); +static void utc_network_bluetooth_adapter_set_name_changed_cb_p(void); +static void utc_network_bluetooth_adapter_set_visibility_mode_changed_cb_p(void); +static void utc_network_bluetooth_adapter_enable_p(void); +static void utc_network_bluetooth_adapter_get_state_p(void); +static void utc_network_bluetooth_adapter_get_address_p(void); +static void utc_network_bluetooth_adapter_set_name_p(void); +static void utc_network_bluetooth_adapter_get_name_p(void); +static void utc_network_bluetooth_adapter_set_visibility_p(void); +static void utc_network_bluetooth_adapter_get_visibility_p(void); +static void utc_network_bluetooth_adapter_disable_p(void); +static void utc_network_bluetooth_adapter_unset_state_changed_cb_p(void); +static void utc_network_bluetooth_adapter_unset_name_changed_cb_p(void); +static void utc_network_bluetooth_adapter_unset_visibility_mode_changed_cb_p(void); + +void adapter_state_changed_cb_for_adapter_p(int result, + bt_adapter_state_e adapter_state, + void *user_data); +void adapter_state_changed_cb_for_adapter_p(int result, + bt_adapter_state_e adapter_state, + void *user_data); +void adapter_name_changed_cb_for_adapter_p(char *device_name, void *user_data); +void adapter_visibility_mode_changed_cb_for_adpater_p(int result, + bt_adapter_visibility_mode_e visibility_mode, + void *user_data); +void device_discovery_state_changed_cb_for_adapter_p(int result, + bt_adapter_device_discovery_state_e discovery_state, + bt_device_info_s *device_info, + void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_initialize_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_enable_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_set_state_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_unset_state_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_get_state_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_get_address_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_get_name_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_set_name_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_unset_name_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_set_name_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_set_visibility_mode_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_unset_visibility_mode_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_get_visibility_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_set_visibility_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_disable_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_deinitialize_p, POSITIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + /* start of TC */ + tet_printf("TC start."); + mainloop = g_main_loop_new(NULL, FALSE); +} + +static void cleanup(void) +{ + /* end of TC */ + tet_printf("TC end"); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +/** + * @brief Callback funtions + */ +void adapter_state_changed_cb_for_adapter_p(int result, + bt_adapter_state_e adapter_state, + void *user_data) +{ + if (user_data != NULL && !strcmp((char *)user_data, "enable")) { + if (adapter_state == BT_ADAPTER_ENABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was enabled."); + callback_result = true; + } else { + tet_printf("Callback: BT was not enabled."); + } + + if (mainloop) + g_main_loop_quit(mainloop); + } else if (user_data != NULL && !strcmp((char *)user_data, "disable")) { + if (adapter_state == BT_ADAPTER_DISABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was disabled."); + callback_result = true; + } else { + tet_printf("Callback: BT was not disabled."); + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } + } +} + +void device_discovery_state_changed_cb_for_adapter_p(int result, + bt_adapter_device_discovery_state_e discovery_state, + bt_device_info_s *device_info, + void *user_data) +{ + tet_printf("bt_adapter_device_discovery_state_changed_cb was called"); + + if (user_data != NULL && !strcmp((char *)user_data, "enable")) { + if (discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FINISHED) { + tet_printf("Callback: bt_adapter_device_discovery_state_changed_cb_for_adapter_p was called \ + and device discovery ends."); + if (mainloop) { + g_main_loop_quit(mainloop); + } + } + } +} + +void adapter_name_changed_cb_for_adapter_p(char *device_name, void *user_data) +{ + tet_printf("bt_adapter_name_changed_cb_for_adapter_p was called: %s", + (char *)device_name); + + if (user_data != NULL && !strcmp((char *)user_data, "set_name")) { + if (!strcmp(device_name, adapter_name)) + callback_result = true; + } + + if (mainloop) + g_main_loop_quit(mainloop); + +} + +void adapter_visibility_mode_changed_cb_for_adpater_p(int result, + bt_adapter_visibility_mode_e visibility_mode, + void *user_data) +{ + tet_printf("bt_adapter_visibility_mode_changed_cb was called: %d", visibility_mode); + + if (user_data != NULL && !strcmp((char *)user_data, "set_visibility")) { + if (result == BT_ERROR_NONE) { + if (visibility_mode == adapter_visibility_mode) { + callback_result = true; + } else { + tet_printf("Callback: adapter_visibility_mode_changed_cb_for_adpater_p() was called but visibility mode is not same."); + tet_printf("Callback: actual visibility mode : %d", visibility_mode); + callback_result = false; + } + } else { + tet_printf("\n Callback: adapter_visibility_mode_changed_cb_for_adpater_p() was called but failed."); + callback_result = false; + } + } + + if (mainloop) + g_main_loop_quit(mainloop); +} + +/** + * @brief Positive test case of bt_initialize() + */ +static void utc_network_bluetooth_initialize_p(void) +{ + int ret = bt_initialize(); + dts_check_eq("bt_initialize", ret, BT_ERROR_NONE, + "bt_initialize() failed."); +} + +/** + * @brief Positive test case of bt_deinitialize() + */ +static void utc_network_bluetooth_deinitialize_p(void) +{ + int ret = bt_deinitialize(); + dts_check_eq("bt_deinitialize", ret, + BT_ERROR_NONE, "bt_deinitialize() failed."); +} + +/** + * @brief Positive test case of bt_adapter_set_state_changed_cb() + */ +static void utc_network_bluetooth_adapter_set_state_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_adapter_p, NULL); + dts_check_eq("bt_adapter_set_state_changed_cb", ret, BT_ERROR_NONE, + "bt_adapter_set_state_changed_cb failed."); +} + +/** + * @brief Positive test case of bt_adapter_set_name_changed_cb() + */ +static void utc_network_bluetooth_adapter_set_name_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + ret = bt_adapter_set_name_changed_cb(adapter_name_changed_cb_for_adapter_p, NULL); + if (ret == BT_ERROR_NONE) { + timeout_id = g_timeout_add(10000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } + dts_check_eq("bt_adapter_set_name_changed_cb", ret, BT_ERROR_NONE, + "bt_adapter_set_name_changed_cb failed."); +} + +/** + * @brief Positive test case of bt_adapter_set_visibility_mode_changed_cb() + */ +static void utc_network_bluetooth_adapter_set_visibility_mode_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + ret = bt_adapter_set_visibility_mode_changed_cb(adapter_visibility_mode_changed_cb_for_adpater_p, NULL); + if (ret == BT_ERROR_NONE) { + timeout_id = g_timeout_add(10000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } + dts_check_eq("bt_adapter_set_visibility_mode_changed_cb", ret, + BT_ERROR_NONE, + "bt_adapter_set_visibility_mode_changed_cb failed."); +} + +/** + * @brief Positive test case of bt_adapter_enable() + */ +static void utc_network_bluetooth_adapter_enable_p(void) +{ + int timeout_id = 0; + callback_result = false; + bt_error_e ret = BT_ERROR_NONE; + + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_adapter_p, "enable") != BT_ERROR_NONE) { + dts_fail("bt_adapter_enable", + "bt_adapter_set_state_changed_cb() failed."); + } + + ret = bt_adapter_enable(); + if (ret == BT_ERROR_NONE) { + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_ALREADY_DONE) { + callback_result = true; + } else { + dts_fail("bt_adapter_enable", "bt_adapter_enable() failed."); + bt_adapter_unset_state_changed_cb(); + return; + } + + tet_printf("callback_result: %d", callback_result); + bt_adapter_unset_state_changed_cb(); + dts_check_eq("bt_adapter_enable", callback_result, true, + "BT was not enabled."); +} + +/** + * @brief Positive test case of bt_adapter_get_state() + */ +static void utc_network_bluetooth_adapter_get_state_p(void) +{ + bt_adapter_state_e adapter_state = BT_ADAPTER_DISABLED; + int ret = BT_ERROR_NONE; + + ret = bt_adapter_get_state(&adapter_state); + if (ret == BT_ERROR_NONE && adapter_state == BT_ADAPTER_ENABLED) { + dts_pass("bt_adapter_get_state", + "bt_adapter_get_state() succeeded."); + } else { + dts_fail("bt_adapter_get_state", + "bt_adapter_get_state() failed."); + } +} + +/** + * @brief Positive test case of bt_adapter_get_address(). + */ +static void utc_network_bluetooth_adapter_get_address_p(void) +{ + char *address = NULL; + int ret = bt_adapter_get_address(&address); + + if (address != NULL) + tet_printf("device address: %s", address); + + dts_check_eq("bt_adapter_get_address", ret, BT_ERROR_NONE, + "bt_adapter_get_address() failed."); +} + +/** + * @brief Positive test case of bt_adapter_get_name(). + */ +static void utc_network_bluetooth_adapter_get_name_p(void) +{ + char *name = NULL; + int ret = bt_adapter_get_name(&name); + + if (name != NULL) + tet_printf("device name : %s", name); + + memset(adapter_name, 0x00, sizeof(adapter_name)); + g_strlcpy(adapter_name, name, sizeof(adapter_name)); + + dts_check_eq("bt_adapter_get_name", ret, BT_ERROR_NONE, + "bt_adapter_get_name() failed."); +} + +/** + * @brief Positive test case of bt_adapter_get_visibility(). + */ +static void utc_network_bluetooth_adapter_get_visibility_p(void) +{ + bt_adapter_visibility_mode_e mode = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE; + int dur = 1; + int ret = bt_adapter_get_visibility(&mode, &dur); + + tet_printf("visibility mode : %d", mode); + if (mode == BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE) { + adapter_visibility_mode = BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE; + } else if (mode == BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE) { + adapter_visibility_mode = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE; + } else + adapter_visibility_mode = BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE; + + dts_check_eq("bt_adapter_get_visibility", ret, BT_ERROR_NONE, + "bt_adapter_get_visibility() failed."); +} + +/** + * @brief Positive test case of bt_adapter_set_name(). + */ +static void utc_network_bluetooth_adapter_set_name_p(void) +{ + int timeout_id = 0; + char name[128] = ""; + + snprintf(name, 128, "%s_1", adapter_name); + strncpy(adapter_name, name, 128); + + if (bt_adapter_set_name_changed_cb(adapter_name_changed_cb_for_adapter_p, "set_name") != BT_ERROR_NONE) { + dts_fail("bt_adapter_set_name", + "bt_adapter_set_name_changed_cb() failed."); + } + + if (bt_adapter_set_name(adapter_name) == BT_ERROR_NONE) { + tet_printf("adapter_name_changed_cb_for_adapter_p() will be called"); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + bt_adapter_unset_name_changed_cb(); + dts_check_eq("bt_adapter_set_name", callback_result, true, + "The local adapter name was not set."); + } else { + dts_fail("bt_adapter_set_name", "bt_adapter_set_name() failed"); + } +} + +/** + * @brief Positive test case of bt_adapter_set_visibility(). + */ +static void utc_network_bluetooth_adapter_set_visibility_p(void) +{ + callback_result = false; + int timeout = 0; + int timeout_id = 0; + + if (bt_adapter_set_visibility_mode_changed_cb(adapter_visibility_mode_changed_cb_for_adpater_p, "set_visibility") != BT_ERROR_NONE) { + dts_fail("bt_adapter_set_visibility", + "bt_adapter_set_visibility_mode_changed_cb() failed."); + } + + tet_printf("set visibility mode: %d", adapter_visibility_mode); + if (adapter_visibility_mode == BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE) { + timeout = 90; + tet_printf("set timeout: %d", timeout); + } + + if (bt_adapter_set_visibility(adapter_visibility_mode, timeout) == BT_ERROR_NONE) { + tet_printf("bt_adapter_visibility_changed_cb() will be called"); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + bt_adapter_unset_visibility_mode_changed_cb(); + dts_check_eq("bt_adapter_set_visibility", callback_result, true, + "The visibility of BT was not set."); + } else { + dts_fail("bt_adapter_set_visibility", + "bt_adapter_set_visibility() failed"); + } +} + +/** + * @brief Positive test case of bt_adapter_disable() + */ +static void utc_network_bluetooth_adapter_disable_p(void) +{ + callback_result = false; + int timeout_id = 0; + + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_adapter_p, "disable") != BT_ERROR_NONE) { + dts_fail("bt_adapter_disable", + "bt_adapter_set_state_changed_cb() failed."); + } + + if (bt_adapter_disable() == BT_ERROR_NONE) { + tet_printf("bt_adapter_state_changed_cb() will be called"); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + bt_adapter_unset_state_changed_cb(); + dts_check_eq("bt_adapter_disable", callback_result, true, + "BT was not disabled"); + } else { + dts_fail("bt_adapter_disable", "bt_adapter_disable() failed"); + } +} + +/** + * @brief Positive test case of bt_adapter_unset_state_changed_cb() + */ +static void utc_network_bluetooth_adapter_unset_state_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_unset_state_changed_cb(); + dts_check_eq("bt_adapter_unset_state_changed_cb", ret, BT_ERROR_NONE, + "bt_adapter_unset_state_changed_cb() failed."); +} + +/** + * @brief Positive test case of bt_adapter_unset_name_changed_cb() + */ +static void utc_network_bluetooth_adapter_unset_name_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_unset_name_changed_cb(); + dts_check_eq("bt_adapter_unset_name_changed_cb", ret, BT_ERROR_NONE, + "bt_adapter_unset_name_changed_cb() failed."); +} + +/** + * @brief Positive test case of bt_adapter_unset_visibility_mode_changed_cb() + */ +static void utc_network_bluetooth_adapter_unset_visibility_mode_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_unset_visibility_mode_changed_cb(); + dts_check_eq("bt_adapter_unset_visibility_mode_changed_cb", ret, + BT_ERROR_NONE, + "bt_adapter_unset_visibility_mode_changed_cb() failed."); +} diff --git a/TC/testcase/utc_network_bluetooth_audio_negative.c b/TC/testcase/utc_network_bluetooth_audio_negative.c new file mode 100644 index 0000000..63c29d9 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_audio_negative.c @@ -0,0 +1,362 @@ +/* + * utc_network_bluetooth_audio_negative.c + * + * Created on: 19-Sep-2013 + * Author: mrinal.m + */ + +#include <tet_api.h> +#include <bluetooth.h> +#include <glib.h> + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_audio_connect_n(void); +static void utc_network_bluetooth_audio_disconnect_n(void); +static void utc_network_bluetooth_audio_set_connection_n(void); +static void utc_network_bluetooth_ag_get_speaker_gain_n(void); +static void utc_network_bluetooth_ag_is_nrec_enabled_n(void); +static void utc_network_bluetooth_ag_set_microphone_gain_changed_n(void); +static void utc_network_bluetooth_ag_set_speaker_gain_changed_n(void); +static void utc_network_bluetooth_ag_is_sco_opened_n(void); +static void utc_network_bluetooth_ag_set_sco_state_changed_n(void); +static void utc_network_bluetooth_ag_notify_call_event_n(void); +static void utc_network_bluetooth_ag_notify_call_list_n(void); +static void utc_network_bluetooth_ag_set_call_handling_event_cb_n(void); +static void utc_network_bluetooth_ag_set_multi_call_handling_event_cb_n(void); +static void utc_network_bluetooth_ag_unset_multi_call_handling_event_cb_n(void); +static void utc_network_bluetooth_ag_unset_dtmf_transmitted_cb_n(void); +static void utc_network_bluetooth_ag_call_list_destroy_n(void); +static void utc_network_bluetooth_ag_call_list_reset_n(void); +static void utc_network_bluetooth_ag_call_list_add_n(void); + +void adapter_state_changed_cb_for_audio_negative(int result, + bt_adapter_state_e adapter_state, + void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_audio_connect_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_audio_disconnect_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_audio_set_connection_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_get_speaker_gain_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_is_nrec_enabled_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_set_microphone_gain_changed_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_set_speaker_gain_changed_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_is_sco_opened_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_set_sco_state_changed_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_notify_call_event_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_notify_call_list_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_set_call_handling_event_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_set_multi_call_handling_event_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_unset_multi_call_handling_event_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_unset_dtmf_transmitted_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_call_list_destroy_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_call_list_reset_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_call_list_add_n, NEGATIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + + if (bt_audio_initialize() != BT_ERROR_NONE) + tet_printf("bt_audio_initialize failed"); + + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_audio_negative, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +/** + * @brief Callback funtions + */ +void adapter_state_changed_cb_for_audio_negative(int result, + bt_adapter_state_e adapter_state, + void *user_data) +{ + tet_printf("Callback: bt_adapter_state_changed_cb was called."); + if (user_data != NULL && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_DISABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was disabled. DTS will be started."); + } else { + tet_printf("Callback: BT was not disabled. DTS will be started but DTS may fail."); + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } + } +} + +/** + * @brief Negative test case of bt_audio_connect() + */ +static void utc_network_bluetooth_audio_connect_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_audio_connect(NULL, BT_AUDIO_PROFILE_TYPE_HSP_HFP); + dts_check_eq("bt_audio_connect", ret, + BT_ERROR_INVALID_PARAMETER, "bt_audio_connect() failed."); +} + +/** + * @brief Negative test case of bt_audio_disconnect() + */ +static void utc_network_bluetooth_audio_disconnect_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_audio_disconnect(NULL, BT_AUDIO_PROFILE_TYPE_A2DP); + dts_check_eq("bt_audio_disconnect", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_audio_disconnect() failed."); +} + +/** + * @brief Negative test case of bt_audio_set_connection_state_changed_cb() + */ +static void utc_network_bluetooth_audio_set_connection_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_audio_set_connection_state_changed_cb(NULL, NULL); + dts_check_eq("bt_audio_set_connection_state_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_audio_set_connection_state_changed_cb() failed."); +} + +/** + * @brief Negative test case of bt_ag_get_speaker_gain() + */ +static void utc_network_bluetooth_ag_get_speaker_gain_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_get_speaker_gain(NULL); + dts_check_eq("bt_ag_get_speaker_gain", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_ag_get_speaker_gain() failed."); +} + +/** + * @brief Negative test case of bt_ag_is_nrec_enabled() + */ +static void utc_network_bluetooth_ag_is_nrec_enabled_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_is_nrec_enabled(NULL); + dts_check_eq("bt_ag_is_nrec_enabled", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_ag_is_nrec_enabled() failed."); +} + +/** + * @brief Negative test case of bt_ag_set_microphone_gain_changed_cb() + */ +static void utc_network_bluetooth_ag_set_microphone_gain_changed_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_set_microphone_gain_changed_cb(NULL, NULL); + dts_check_eq("bt_ag_set_microphone_gain_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_ag_set_microphone_gain_changed_cb() failed."); +} + +/** + * @brief Negative test case of bt_ag_set_speaker_gain_changed_cb() + */ +static void utc_network_bluetooth_ag_set_speaker_gain_changed_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_set_speaker_gain_changed_cb(NULL, NULL); + dts_check_eq("bt_ag_set_speaker_gain_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_ag_set_speaker_gain_changed_cb() failed."); +} + +/** + * @brief Negative test case of bt_ag_is_sco_opened() + */ +static void utc_network_bluetooth_ag_is_sco_opened_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_is_sco_opened(NULL); + dts_check_eq("bt_ag_is_sco_opened", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_ag_is_sco_opened() failed."); +} + +/** + * @brief Negative test case of bt_ag_set_sco_state_changed_cb() + */ +static void utc_network_bluetooth_ag_set_sco_state_changed_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_set_sco_state_changed_cb(NULL, NULL); + dts_check_eq("bt_ag_set_sco_state_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_ag_set_sco_state_changed_cb() failed."); +} + +/** + * @brief Negative test case of bt_ag_notify_call_event() + */ +static void utc_network_bluetooth_ag_notify_call_event_n(void) +{ + int ret = BT_ERROR_NONE; + unsigned int call_id = 0; + ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_INCOMING, call_id, NULL); + dts_check_eq("bt_ag_notify_call_event", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_ag_notify_call_event() failed."); +} + +/** + * @brief Negative test case of bt_ag_notify_call_list() + */ +static void utc_network_bluetooth_ag_notify_call_list_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_notify_call_list(NULL); + dts_check_eq("bt_ag_notify_call_list", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_ag_notify_call_list() failed."); +} + +/** + * @brief Negative test case of bt_ag_set_call_handling_event_cb() + */ +static void utc_network_bluetooth_ag_set_call_handling_event_cb_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_set_call_handling_event_cb(NULL, NULL); + dts_check_eq("bt_ag_set_call_handling_event_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_ag_set_call_handling_event_cb() failed."); +} + +/** + * @brief Negative test case of bt_ag_set_multi_call_handling_event_cb() + */ +static void utc_network_bluetooth_ag_set_multi_call_handling_event_cb_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_set_multi_call_handling_event_cb(NULL, NULL); + dts_check_eq("bt_ag_set_multi_call_handling_event_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_ag_set_multi_call_handling_event_cb() failed."); +} + +/** + * @brief Negative test case of bt_ag_set_dtmf_transmitted_cb() + */ +static void utc_network_bluetooth_ag_unset_multi_call_handling_event_cb_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_set_dtmf_transmitted_cb(NULL, NULL); + dts_check_eq("bt_ag_set_dtmf_transmitted_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_ag_set_dtmf_transmitted_cb() failed."); +} + +/** + * @brief Negative test case of bt_call_list_create() + */ +static void utc_network_bluetooth_ag_unset_dtmf_transmitted_cb_n(void) +{ + int ret = BT_ERROR_NONE; + bt_call_list_h handle; + handle = g_malloc0(sizeof(bt_call_list_h)); + ret = bt_call_list_create(handle); + dts_check_eq("bt_call_list_create", ret, BT_ERROR_NONE, + "bt_call_list_create() failed."); +} + +/** + * @brief Negative test case of bt_call_list_destroy() + */ +static void utc_network_bluetooth_ag_call_list_destroy_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_call_list_destroy(NULL); + dts_check_eq("bt_call_list_destroy", ret, BT_ERROR_INVALID_PARAMETER, + "bt_call_list_destroy() failed."); +} + +/** + * @brief Negative test case of bt_call_list_reset() + */ +static void utc_network_bluetooth_ag_call_list_reset_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_call_list_reset(NULL); + dts_check_eq("bt_call_list_reset", ret, BT_ERROR_INVALID_PARAMETER, + "bt_call_list_reset() failed."); +} + +/** + * @brief Negative test case of bt_call_list_add() + */ +static void utc_network_bluetooth_ag_call_list_add_n(void) +{ + int ret = BT_ERROR_NONE; + unsigned int call_id = 0; + + ret = bt_call_list_add(NULL, call_id, BT_AG_CALL_STATE_INCOMING); + dts_check_eq("bt_call_list_add", ret, BT_ERROR_INVALID_PARAMETER, + "bt_call_list_add() failed."); + +} diff --git a/TC/testcase/utc_network_bluetooth_audio_positive.c b/TC/testcase/utc_network_bluetooth_audio_positive.c new file mode 100644 index 0000000..1f7c6a5 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_audio_positive.c @@ -0,0 +1,618 @@ +/* + * utc_network_bluetooth_audio_positive.c + * + * Created on: 19-Sep-2013 + * Author: mrinal.m + */ + +#include <tet_api.h> +#include <bluetooth.h> +#include <glib.h> + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +char target_address[18] = ""; +static GMainLoop *mainloop; + +static void utc_network_bluetooth_audio_initialize_p(void); +static void utc_network_bluetooth_audio_deinitialize_p(void); +static void utc_network_bluetooth_audio_connect_p(void); +static void utc_network_bluetooth_audio_disconnect_p(void); +static void utc_network_bluetooth_audio_set_connection_p(void); +static void utc_network_bluetooth_audio_unset_connection_p(void); +static void utc_network_bluetooth_ag_notify_speaker_gain_p(void); +static void utc_network_bluetooth_ag_get_speaker_gain_p(void); +static void utc_network_bluetooth_ag_is_nrec_enabled_p(void); +static void utc_network_bluetooth_ag_set_microphone_gain_changed_p(void); +static void utc_network_bluetooth_ag_unset_microphone_gain_changed_p(void); +static void utc_network_bluetooth_ag_set_speaker_gain_changed_p(void); +static void utc_network_bluetooth_ag_unset_speaker_gain_changed_p(void); +static void utc_network_bluetooth_ag_open_sco_p(void); +static void utc_network_bluetooth_ag_close_sco_p(void); +static void utc_network_bluetooth_ag_is_sco_opened_p(void); +static void utc_network_bluetooth_ag_set_sco_state_changed_p(void); +static void utc_network_bluetooth_ag_unset_sco_state_changed_p(void); +static void utc_network_bluetooth_ag_notify_call_event_p(void); +static void utc_network_bluetooth_ag_notify_call_list_p(void); +static void utc_network_bluetooth_ag_notify_voice_recognition_state_p(void); +static void utc_network_bluetooth_ag_set_call_handling_event_cb_p(void); +static void utc_network_bluetooth_ag_unset_call_handling_event_cb_p(void); +static void utc_network_bluetooth_ag_set_multi_call_handling_event_cb_p(void); +static void utc_network_bluetooth_ag_unset_multi_call_handling_event_cb_p(void); +static void utc_network_bluetooth_ag_set_dtmf_transmitted_cb_p(void); +static void utc_network_bluetooth_ag_unset_dtmf_transmitted_cb_p(void); +static void utc_network_bluetooth_ag_call_list_create_p(void); +static void utc_network_bluetooth_ag_call_list_destroy_p(void); +static void utc_network_bluetooth_ag_call_list_reset_p(void); +static void utc_network_bluetooth_ag_call_list_add_p(void); +static void utc_network_bluetooth_ag_ca2dp_set_content_protection_p(void); + +void connection_state_changed_cb_for_audio_p(int result, bool connected, + const char *remote_address, + bt_audio_profile_type_e type, + void *user_data); +void dtmf_transmitted_cb_for_ag_p(const char *dtmf, void *user_data); +void multi_call_handling_event_cb_for_ag_p(bt_ag_multi_call_handling_event_e event, void *user_data); +void call_handling_event_cb_for_ag_p(bt_ag_call_handling_event_e event, + unsigned int call_id, void *user_data); +void sco_state_changed_cb_for_ag_p(int result, bool opened, void *user_data); +void speaker_gain_changed_cb_for_ag_p(int gain, void *user_data); +void microphone_gain_changed_cb_for_ag_p(int gain, void *user_data); +void adapter_state_changed_cb_for_audio_p(int result, + bt_adapter_state_e adapter_state, + void *user_data); + +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_audio_initialize_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_audio_set_connection_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_audio_connect_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_open_sco_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_set_microphone_gain_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_set_speaker_gain_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_notify_speaker_gain_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_get_speaker_gain_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_is_nrec_enabled_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_unset_microphone_gain_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_unset_speaker_gain_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_set_sco_state_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_is_sco_opened_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_notify_call_event_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_notify_call_list_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_notify_voice_recognition_state_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_set_call_handling_event_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_unset_call_handling_event_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_set_multi_call_handling_event_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_unset_multi_call_handling_event_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_set_dtmf_transmitted_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_unset_dtmf_transmitted_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_close_sco_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_unset_sco_state_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_call_list_create_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_call_list_destroy_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_call_list_reset_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_call_list_add_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_ca2dp_set_content_protection_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_audio_disconnect_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_audio_unset_connection_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_audio_deinitialize_p, POSITIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + bt_error_e ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + tet_printf("TC start."); + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_audio_p, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_enable() was called."); + ret = bt_adapter_enable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_enable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret != BT_ERROR_ALREADY_DONE) { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("[%s] Callback: Timeout.", __FUNCTION__); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +/** + * @brief Callback funtions + */ + +void adapter_state_changed_cb_for_audio_p(int result, + bt_adapter_state_e adapter_state, + void *user_data) +{ + +} + +void connection_state_changed_cb_for_audio_p(int result, bool connected, + const char *remote_address, + bt_audio_profile_type_e type, + void *user_data) +{ + +} + +void microphone_gain_changed_cb_for_ag_p(int gain, void *user_data) +{ + +} + +void speaker_gain_changed_cb_for_ag_p(int gain, void *user_data) +{ + +} + +void sco_state_changed_cb_for_ag_p(int result, bool opened, void *user_data) +{ + +} + +void call_handling_event_cb_for_ag_p(bt_ag_call_handling_event_e event, + unsigned int call_id, void *user_data) +{ + +} + +void multi_call_handling_event_cb_for_ag_p(bt_ag_multi_call_handling_event_e event, void *user_data) +{ + +} + +void dtmf_transmitted_cb_for_ag_p(const char *dtmf, void *user_data) +{ + +} + +/** + * @brief Positive test case of bt_audio_initialize() + */ +static void utc_network_bluetooth_audio_initialize_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_audio_initialize(); + dts_check_eq("bt_audio_initialize", ret, BT_ERROR_NONE, + "bt_audio_initialize() failed. %x", ret); + +} + +/** + * @brief Positive test case of bt_audio_connect() + */ +static void utc_network_bluetooth_audio_connect_p(void) +{ + int ret = BT_ERROR_NONE; + const char *remote_address = "00:23:78:AB:C4:20"; + ret = bt_audio_connect(remote_address, BT_AUDIO_PROFILE_TYPE_HSP_HFP); + dts_check_eq("bt_audio_connect", ret, BT_ERROR_NONE, + "bt_audio_connect() failed. %x", ret); +} + +/** + * @brief Positive test case of bt_audio_disconnect() + */ +static void utc_network_bluetooth_audio_disconnect_p(void) +{ + int ret = BT_ERROR_NONE; + const char *remote_address = "00:23:78:AB:C4:20"; + ret = bt_audio_disconnect(remote_address, BT_AUDIO_PROFILE_TYPE_A2DP); + dts_check_eq("bt_audio_disconnect", ret, BT_ERROR_NONE, + "bt_audio_disconnect() failed. %x", ret); +} + +/** + * @brief Positive test case of bt_audio_set_connection_state_changed_cb() + */ +static void utc_network_bluetooth_audio_set_connection_p(void) +{ + int ret = BT_ERROR_NONE; + ret = + bt_audio_set_connection_state_changed_cb + (connection_state_changed_cb_for_audio_p, NULL); + dts_check_eq("bt_audio_set_connection_state_changed_cb", ret, + BT_ERROR_NONE, + "bt_audio_set_connection_state_changed_cb() failed."); +} + +/** + * @brief Positive test case of bt_audio_unset_connection_state_changed_cb() + */ +static void utc_network_bluetooth_audio_unset_connection_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_audio_unset_connection_state_changed_cb(); + dts_check_eq("bt_audio_set_connection_state_changed_cb", ret, + BT_ERROR_NONE, + "bt_audio_set_connection_state_changed_cb() failed."); +} + +/** + * @brief Positive test case of bt_ag_notify_speaker_gain() + */ +static void utc_network_bluetooth_ag_notify_speaker_gain_p(void) +{ + int ret = BT_ERROR_NONE; + int gain = 10; + ret = bt_ag_notify_speaker_gain(gain); + dts_check_eq("bt_ag_notify_speaker_gain", ret, BT_ERROR_NONE, + "bt_ag_notify_speaker_gain() failed.%x", ret); +} + +/** + * @brief Positive test case of bt_ag_get_speaker_gain() + */ +static void utc_network_bluetooth_ag_get_speaker_gain_p(void) +{ + int ret = BT_ERROR_NONE; + int gain = 0; + ret = bt_ag_get_speaker_gain(&gain); + dts_check_eq("bt_ag_get_speaker_gain", ret, BT_ERROR_NONE, + "bt_ag_get_speaker_gain() failed."); + +} + +/** + * @brief Positive test case of bt_ag_is_nrec_enabled() + */ +static void utc_network_bluetooth_ag_is_nrec_enabled_p(void) +{ + int ret = BT_ERROR_NONE; + bool enabled = 1; + ret = bt_ag_is_nrec_enabled(&enabled); + dts_check_eq("bt_ag_is_nrec_enabled", ret, BT_ERROR_NONE, + "bt_ag_is_nrec_enabled() failed."); + +} + +/** + * @brief Positive test case of bt_ag_set_microphone_gain_changed_cb() + */ +static void utc_network_bluetooth_ag_set_microphone_gain_changed_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_set_microphone_gain_changed_cb(microphone_gain_changed_cb_for_ag_p, NULL); + dts_check_eq("bt_ag_set_microphone_gain_changed_cb", ret, BT_ERROR_NONE, + "bt_ag_set_microphone_gain_changed_cb() failed."); + +} + +/** + * @brief Positive test case of bt_ag_unset_microphone_gain_changed_cb() + */ +static void utc_network_bluetooth_ag_unset_microphone_gain_changed_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_unset_microphone_gain_changed_cb(); + dts_check_eq("bt_ag_unset_microphone_gain_changed_cb", ret, + BT_ERROR_NONE, + "bt_ag_unset_microphone_gain_changed_cb() failed."); + +} + +/** + * @brief Positive test case of bt_ag_set_speaker_gain_changed_cb() + */ +static void utc_network_bluetooth_ag_set_speaker_gain_changed_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_set_speaker_gain_changed_cb(speaker_gain_changed_cb_for_ag_p, NULL); + dts_check_eq("bt_ag_set_speaker_gain_changed_cb", ret, BT_ERROR_NONE, + "bt_ag_set_speaker_gain_changed_cb() failed."); + +} + +/** + * @brief Positive test case of bt_ag_unset_speaker_gain_changed_cb() + */ +static void utc_network_bluetooth_ag_unset_speaker_gain_changed_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_unset_speaker_gain_changed_cb(); + dts_check_eq("bt_ag_unset_speaker_gain_changed_cb", ret, BT_ERROR_NONE, + "bt_ag_unset_speaker_gain_changed_cb() failed."); + +} + +/** + * @brief Positive test case of bt_ag_open_sco() + */ +static void utc_network_bluetooth_ag_open_sco_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_open_sco(); + dts_check_eq("bt_ag_open_sco", ret, BT_ERROR_NONE, + "bt_ag_open_sco() failed."); + +} + +/** + * @brief Positive test case of bt_ag_close_sco() + */ +static void utc_network_bluetooth_ag_close_sco_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_close_sco(); + dts_check_eq("bt_ag_close_sco", ret, BT_ERROR_NONE, + "bt_ag_close_sco() failed."); + +} + +/** + * @brief Positive test case of bt_ag_is_sco_opened() + */ +static void utc_network_bluetooth_ag_is_sco_opened_p(void) +{ + int ret = BT_ERROR_NONE; + bool opened = 1; + ret = bt_ag_is_sco_opened(&opened); + dts_check_eq("bt_ag_is_sco_opened", ret, BT_ERROR_NONE, + "bt_ag_is_sco_opened() failed."); + +} + +/** + * @brief Positive test case of bt_ag_set_sco_state_changed_cb() + */ +static void utc_network_bluetooth_ag_set_sco_state_changed_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_set_sco_state_changed_cb(sco_state_changed_cb_for_ag_p, NULL); + dts_check_eq("bt_ag_set_sco_state_changed_cb", ret, BT_ERROR_NONE, + "bt_ag_set_sco_state_changed_cb() failed."); + +} + +/** + * @brief Positive test case of bt_ag_unset_sco_state_changed_cb() + */ +static void utc_network_bluetooth_ag_unset_sco_state_changed_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_unset_sco_state_changed_cb(); + dts_check_eq("bt_ag_unset_sco_state_changed_cb", ret, BT_ERROR_NONE, + "bt_ag_unset_sco_state_changed_cb() failed."); + +} + +/** + * @brief Positive test case of bt_ag_notify_call_event() + */ +static void utc_network_bluetooth_ag_notify_call_event_p(void) +{ + int ret = BT_ERROR_NONE; + const char *phone_number = "9663868998"; + unsigned int call_id = 0; + ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_INCOMING, + call_id, phone_number); + dts_check_eq("bt_ag_notify_call_event", ret, BT_ERROR_NONE, + "bt_ag_notify_call_event() failed."); + +} + +/** + * @brief Positive test case of bt_ag_notify_call_list() + */ +static void utc_network_bluetooth_ag_notify_call_list_p(void) +{ + int ret = BT_ERROR_NONE; + bt_call_list_h handle; + handle = g_malloc0(sizeof(bt_call_list_h)); + bt_call_list_add(handle, 1, BT_AG_CALL_STATE_ACTIVE); + ret = bt_ag_notify_call_list(handle); + dts_check_eq("bt_ag_notify_call_list", ret, BT_ERROR_NONE, + "bt_ag_notify_call_list() failed."); + +} + +/** + * @brief Positive test case of bt_ag_notify_voice_recognition_state() + */ +static void utc_network_bluetooth_ag_notify_voice_recognition_state_p(void) +{ + int ret = BT_ERROR_NONE; + bool state = true; + + ret = bt_ag_notify_voice_recognition_state(state); + dts_check_eq("bt_ag_notify_voice_recognition_state", ret, BT_ERROR_NONE, + "bt_ag_notify_voice_recognition_state() failed."); + +} + +/** + * @brief Positive test case of bt_ag_set_call_handling_event_cb() + */ +static void utc_network_bluetooth_ag_set_call_handling_event_cb_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_set_call_handling_event_cb(call_handling_event_cb_for_ag_p, + NULL); + dts_check_eq("bt_ag_set_call_handling_event_cb", ret, BT_ERROR_NONE, + "bt_ag_set_call_handling_event_cb() failed."); + +} + +/** + * @brief Positive test case of bt_ag_unset_call_handling_event_cb() + */ +static void utc_network_bluetooth_ag_unset_call_handling_event_cb_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_unset_call_handling_event_cb(); + dts_check_eq("bt_ag_unset_call_handling_event_cb", ret, BT_ERROR_NONE, + "bt_ag_unset_call_handling_event_cb() failed."); + +} + +/** + * @brief Positive test case of bt_ag_set_multi_call_handling_event_cb() + */ +static void utc_network_bluetooth_ag_set_multi_call_handling_event_cb_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_set_multi_call_handling_event_cb(multi_call_handling_event_cb_for_ag_p, NULL); + dts_check_eq("bt_ag_set_multi_call_handling_event_cb", ret, + BT_ERROR_NONE, + "bt_ag_set_multi_call_handling_event_cb() failed."); + +} + +/** + * @brief Positive test case of bt_ag_unset_multi_call_handling_event_cb() + */ +static void utc_network_bluetooth_ag_unset_multi_call_handling_event_cb_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_unset_multi_call_handling_event_cb(); + dts_check_eq("bt_ag_unset_multi_call_handling_event_cb", ret, + BT_ERROR_NONE, + "bt_ag_unset_multi_call_handling_event_cb() failed."); + +} + +/** + * @brief Positive test case of bt_ag_set_dtmf_transmitted_cb() + */ +static void utc_network_bluetooth_ag_set_dtmf_transmitted_cb_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_set_dtmf_transmitted_cb(dtmf_transmitted_cb_for_ag_p, NULL); + dts_check_eq("bt_ag_set_dtmf_transmitted_cb", ret, BT_ERROR_NONE, + "bt_ag_set_dtmf_transmitted_cb() failed."); + +} + +/** + * @brief Positive test case of bt_ag_unset_dtmf_transmitted_cb() + */ +static void utc_network_bluetooth_ag_unset_dtmf_transmitted_cb_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_unset_dtmf_transmitted_cb(); + dts_check_eq("bt_ag_unset_dtmf_transmitted_cb", ret, BT_ERROR_NONE, + "bt_ag_unset_dtmf_transmitted_cb() failed."); + +} + +/** + * @brief Positive test case of bt_call_list_create() + */ +static void utc_network_bluetooth_ag_call_list_create_p(void) +{ + int ret = BT_ERROR_NONE; + bt_call_list_h handle; + handle = g_malloc0(sizeof(bt_call_list_h)); + bt_call_list_add(handle, 1, BT_AG_CALL_STATE_ACTIVE); + ret = bt_call_list_create(&handle); + dts_check_eq("bt_call_list_create", ret, BT_ERROR_NONE, + "bt_call_list_create() failed."); +} + +/** + * @brief Positive test case of bt_call_list_destroy() + */ +static void utc_network_bluetooth_ag_call_list_destroy_p(void) +{ + int ret = BT_ERROR_NONE; + bt_call_list_h handle; + handle = g_malloc0(sizeof(bt_call_list_h)); + bt_call_list_add(handle, 1, BT_AG_CALL_STATE_ACTIVE); + ret = bt_call_list_destroy(handle); + dts_check_eq("bt_call_list_destroy", ret, BT_ERROR_NONE, + "bt_call_list_destroy() failed."); +} + +/** + * @brief Positive test case of bt_call_list_reset() + */ +static void utc_network_bluetooth_ag_call_list_reset_p(void) +{ + int ret = BT_ERROR_NONE; + bt_call_list_h handle; + handle = g_malloc0(sizeof(bt_call_list_h)); + bt_call_list_add(handle, 1, BT_AG_CALL_STATE_ACTIVE); + ret = bt_call_list_reset(handle); + dts_check_eq("bt_call_list_reset", ret, BT_ERROR_NONE, + "bt_call_list_reset() failed."); +} + +/** + * @brief Positive test case of bt_call_list_add() + */ +static void utc_network_bluetooth_ag_call_list_add_p(void) +{ + int ret = BT_ERROR_NONE; + unsigned int call_id = 0; + bt_call_list_h handle; + handle = g_malloc0(sizeof(bt_call_list_h)); + bt_call_list_add(handle, 1, BT_AG_CALL_STATE_ACTIVE); + ret = bt_call_list_add(handle, call_id, BT_AG_CALL_STATE_INCOMING); + dts_check_eq("bt_call_list_add", ret, BT_ERROR_NONE, + "bt_call_list_add() failed."); +} + +/** + * @brief Positive test case of bt_a2dp_set_content_protection() + */ +static void utc_network_bluetooth_ag_ca2dp_set_content_protection_p(void) +{ + int ret = BT_ERROR_NONE; + bool status = true; + ret = bt_a2dp_set_content_protection(status); + dts_check_eq("bt_a2dp_set_content_protection", ret, BT_ERROR_NONE, + "bt_a2dp_set_content_protection() failed."); +} + +/** + * @brief Positive test case of bt_audio_deinitialize() + */ +static void utc_network_bluetooth_audio_deinitialize_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_audio_deinitialize(); + dts_check_eq("bt_audio_deinitialize", ret, BT_ERROR_NONE, + "bt_audio_deinitialize() failed."); +} diff --git a/TC/testcase/utc_network_bluetooth_avrcp_negative.c b/TC/testcase/utc_network_bluetooth_avrcp_negative.c new file mode 100644 index 0000000..d418475 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_avrcp_negative.c @@ -0,0 +1,171 @@ +/* + * utc_network_bluetooth_avrcp_negative.c + * + * Created on: 20-Sep-2013 + * Author: mrinal.m + */ + +#include "bluetooth.h" +#include <tet_api.h> +#include <glib.h> + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +const char target_name[128] = "dts_test"; +char target_address[18] = ""; + +static GMainLoop *mainloop; + +static void utc_network_bluetooth_audio_initialize_n(void); +static void utc_network_bluetooth_avrcp_set_equalizer_state_changed_n(void); +static void utc_network_bluetooth_avrcp_set_repeat_mode_changed_n(void); +static void utc_network_bluetooth_avrcp_set_shuffle_mode_changed_n(void); +static void utc_network_bluetooth_avrcp_set_scan_mode_changed_n(void); + +void adapter_state_changed_cb_for_avrcp_n(int result, + bt_adapter_state_e adapter_state, + void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_audio_initialize_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_set_equalizer_state_changed_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_set_repeat_mode_changed_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_set_shuffle_mode_changed_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_set_scan_mode_changed_n, NEGATIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_avrcp_n, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +/** + * @brief Negative test case of bt_avrcp_target_initialize() + */ + +void adapter_state_changed_cb_for_avrcp_n(int result, + bt_adapter_state_e adapter_state, + void *user_data) +{ + +} + +static void utc_network_bluetooth_audio_initialize_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_target_initialize(NULL, NULL); + dts_check_eq("bt_avrcp_target_initialize", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_avrcp_target_initialize() failed."); + +} + +/** + * @brief Negative test case of bt_avrcp_set_equalizer_state_changed_cb() + */ +static void utc_network_bluetooth_avrcp_set_equalizer_state_changed_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_set_equalizer_state_changed_cb(NULL, NULL); + dts_check_eq("bt_avrcp_set_equalizer_state_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_avrcp_set_equalizer_state_changed_cb() failed."); + +} + +/** + * @brief Negative test case of bt_avrcp_set_repeat_mode_changed_cb() + */ +static void utc_network_bluetooth_avrcp_set_repeat_mode_changed_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_set_repeat_mode_changed_cb(NULL, NULL); + dts_check_eq("bt_avrcp_set_repeat_mode_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_avrcp_set_repeat_mode_changed_cb() failed."); + +} + +/** + * @brief Negative test case of bt_avrcp_set_shuffle_mode_changed_cb() + */ +static void utc_network_bluetooth_avrcp_set_shuffle_mode_changed_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_set_shuffle_mode_changed_cb(NULL, NULL); + dts_check_eq("bt_avrcp_set_shuffle_mode_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_avrcp_set_shuffle_mode_changed_cb() failed."); + +} + +/** + * @brief Negative test case of bt_avrcp_set_scan_mode_changed_cb() + */ +static void utc_network_bluetooth_avrcp_set_scan_mode_changed_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_set_scan_mode_changed_cb(NULL, NULL); + dts_check_eq("bt_avrcp_set_scan_mode_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_avrcp_set_scan_mode_changed_cb() failed."); + +} diff --git a/TC/testcase/utc_network_bluetooth_avrcp_positive.c b/TC/testcase/utc_network_bluetooth_avrcp_positive.c new file mode 100644 index 0000000..dab7f7e --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_avrcp_positive.c @@ -0,0 +1,387 @@ +/* + * utc_network_bluetooth_avrcp_positive.c + * + * Created on: 20-Sep-2013 + * Author: mrinal.m + */ + +#include "bluetooth.h" +#include <tet_api.h> +#include <glib.h> + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +void target_connection_state_changed_cb_for_avrcp_p(bool connected, + const char *remote_address, + void *user_data); +void equalizer_state_changed_cb_for_avrcp_p(bt_avrcp_equalizer_state_e equalizer, void *user_data); +void repeat_mode_changed_cb_for_avrcp_p(bt_avrcp_repeat_mode_e repeat, + void *user_data); +void shuffle_mode_changed_cb_for_avrcp_p(bt_avrcp_shuffle_mode_e shuffle, + void *user_data); +void scan_mode_changed_cb_for_avrcp_p(bt_avrcp_scan_mode_e scan, + void *user_data); + +static void utc_network_bluetooth_avrcp_targe_initialize_p(void); +static void utc_network_bluetooth_avrcp_target_deinitialize_p(void); +static void utc_network_bluetooth_avrcp_target_notify_equalizer_state_p(void); +static void utc_network_bluetooth_avrcp_target_notify_repeat_mode_p(void); +static void utc_network_bluetooth_avrcp_target_notify_shuffle_mode_p(void); +static void utc_network_bluetooth_avrcp_target_notify_scan_mode_p(void); +static void utc_network_bluetooth_avrcp_target_notify_player_state_p(void); +static void utc_network_bluetooth_avrcp_target_notify_position_p(void); +static void utc_network_bluetooth_avrcp_target_notify_track_p(void); +static void utc_network_bluetooth_avrcp_set_equalizer_state_changed_p(void); +static void utc_network_bluetooth_avrcp_unset_equalizer_state_changed_p(void); +static void utc_network_bluetooth_avrcp_set_repeat_mode_changed_p(void); +static void utc_network_bluetooth_avrcp_unset_repeat_mode_changed_p(void); +static void utc_network_bluetooth_avrcp_set_shuffle_mode_changed_p(void); +static void utc_network_bluetooth_avrcp_unset_shuffle_mode_changed_p(void); +static void utc_network_bluetooth_avrcp_set_scan_mode_changed_p(void); +static void utc_network_bluetooth_avrcp_unset_scan_mode_changed_p(void); + +void adapter_state_changed_cb_for_avrcp_p(int result, + bt_adapter_state_e adapter_state, + void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_avrcp_targe_initialize_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_target_notify_equalizer_state_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_target_notify_repeat_mode_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_target_notify_shuffle_mode_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_target_notify_scan_mode_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_target_notify_player_state_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_target_notify_position_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_target_notify_track_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_set_equalizer_state_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_unset_equalizer_state_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_set_repeat_mode_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_unset_repeat_mode_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_set_shuffle_mode_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_unset_shuffle_mode_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_set_scan_mode_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_unset_scan_mode_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_target_deinitialize_p, POSITIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_avrcp_p, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_enable() was called."); + ret = bt_adapter_enable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_enable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret != BT_ERROR_ALREADY_DONE) { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +/** + * @brief Callback funtions + */ + +void adapter_state_changed_cb_for_avrcp_p(int result, + bt_adapter_state_e adapter_state, + void *user_data) +{ + +} + +void target_connection_state_changed_cb_for_avrcp_p(bool connected, + const char *remote_address, + void *user_data) +{ + +} + +void equalizer_state_changed_cb_for_avrcp_p(bt_avrcp_equalizer_state_e equalizer, void *user_data) +{ + +} + +void repeat_mode_changed_cb_for_avrcp_p(bt_avrcp_repeat_mode_e repeat, + void *user_data) +{ + +} + +void shuffle_mode_changed_cb_for_avrcp_p(bt_avrcp_shuffle_mode_e shuffle, + void *user_data) +{ + +} + +void scan_mode_changed_cb_for_avrcp_p(bt_avrcp_scan_mode_e scan, + void *user_data) +{ + +} + +/** + * @brief Positive test case of bt_avrcp_target_initialize() + */ +static void utc_network_bluetooth_avrcp_targe_initialize_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_target_initialize(target_connection_state_changed_cb_for_avrcp_p, NULL); + dts_check_eq("bt_avrcp_target_initialize", ret, BT_ERROR_NONE, + "bt_avrcp_target_initialize() failed."); + +} + +/** + * @brief Positive test case of bt_avrcp_target_deinitialize() + */ +static void utc_network_bluetooth_avrcp_target_deinitialize_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_target_deinitialize(); + dts_check_eq("bt_avrcp_target_deinitialize", ret, BT_ERROR_NONE, + "bt_avrcp_target_deinitialize() failed."); + +} + +/** + * @brief Positive test case of bt_avrcp_target_notify_equalizer_state() + */ +static void utc_network_bluetooth_avrcp_target_notify_equalizer_state_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_target_notify_equalizer_state(BT_AVRCP_EQUALIZER_STATE_ON); + dts_check_eq("bt_avrcp_target_notify_equalizer_state", ret, + BT_ERROR_NONE, + "bt_avrcp_target_notify_equalizer_state() failed."); + +} + +/** + * @brief Positive test case of bt_avrcp_target_notify_repeat_mode() + */ +static void utc_network_bluetooth_avrcp_target_notify_repeat_mode_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_target_notify_repeat_mode(BT_AVRCP_REPEAT_MODE_ALL_TRACK); + dts_check_eq("bt_avrcp_target_notify_repeat_mode", ret, BT_ERROR_NONE, + "bt_avrcp_target_notify_repeat_mode() failed."); + +} + +/** + * @brief Positive test case of bt_avrcp_target_notify_shuffle_mode() + */ +static void utc_network_bluetooth_avrcp_target_notify_shuffle_mode_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_target_notify_shuffle_mode(BT_AVRCP_SHUFFLE_MODE_ALL_TRACK); + dts_check_eq("bt_avrcp_target_notify_shuffle_mode", ret, BT_ERROR_NONE, + "bt_avrcp_target_notify_shuffle_mode() failed."); + +} + +/** + * @brief Positive test case of bt_avrcp_target_notify_scan_mode() + */ +static void utc_network_bluetooth_avrcp_target_notify_scan_mode_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_target_notify_scan_mode(BT_AVRCP_SCAN_MODE_ALL_TRACK); + dts_check_eq("bt_avrcp_target_notify_scan_mode", ret, BT_ERROR_NONE, + "bt_avrcp_target_notify_scan_mode() failed."); +} + +/** + * @brief Positive test case of bt_avrcp_target_notify_player_state() + */ +static void utc_network_bluetooth_avrcp_target_notify_player_state_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_target_notify_player_state(BT_AVRCP_PLAYER_STATE_PLAYING); + dts_check_eq("bt_avrcp_target_notify_player_state", ret, BT_ERROR_NONE, + "bt_avrcp_target_notify_player_state() failed."); +} + +/** + * @brief Positive test case of bt_avrcp_target_notify_position() + */ +static void utc_network_bluetooth_avrcp_target_notify_position_p(void) +{ + int ret = BT_ERROR_NONE; + unsigned int position = 0; + ret = bt_avrcp_target_notify_position(position); + dts_check_eq("bt_avrcp_target_notify_position", ret, BT_ERROR_NONE, + "bt_avrcp_target_notify_position() failed."); +} + +/** + * @brief Positive test case of bt_avrcp_target_notify_track() + */ +static void utc_network_bluetooth_avrcp_target_notify_track_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_target_notify_track("title", "artist", "album", "genre", 5, 20, 2); + dts_check_eq("bt_avrcp_target_notify_track", ret, BT_ERROR_NONE, + "bt_avrcp_target_notify_track() failed."); +} + +/** + * @brief Positive test case of bt_avrcp_set_equalizer_state_changed_cb() + */ +static void utc_network_bluetooth_avrcp_set_equalizer_state_changed_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_set_equalizer_state_changed_cb(equalizer_state_changed_cb_for_avrcp_p, NULL); + dts_check_eq("bt_avrcp_set_equalizer_state_changed_cb", ret, + BT_ERROR_NONE, + "bt_avrcp_set_equalizer_state_changed_cb() failed."); + +} + +/** + * @brief Positive test case of bt_avrcp_unset_equalizer_state_changed_cb() + */ +static void utc_network_bluetooth_avrcp_unset_equalizer_state_changed_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_unset_equalizer_state_changed_cb(); + dts_check_eq("bt_avrcp_unset_equalizer_state_changed_cb", ret, + BT_ERROR_NONE, + "bt_avrcp_unset_equalizer_state_changed_cb() failed."); + +} + +/** + * @brief Positive test case of bt_avrcp_set_repeat_mode_changed_cb() + */ +static void utc_network_bluetooth_avrcp_set_repeat_mode_changed_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_set_repeat_mode_changed_cb(repeat_mode_changed_cb_for_avrcp_p, NULL); + dts_check_eq("bt_avrcp_set_repeat_mode_changed_cb", ret, BT_ERROR_NONE, + "bt_avrcp_set_repeat_mode_changed_cb() failed."); + +} + +/** + * @brief Positive test case of bt_avrcp_unset_repeat_mode_changed_cb() + */ +static void utc_network_bluetooth_avrcp_unset_repeat_mode_changed_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_unset_repeat_mode_changed_cb(); + dts_check_eq("bt_avrcp_unset_repeat_mode_changed_cb", ret, + BT_ERROR_NONE, + "bt_avrcp_unset_repeat_mode_changed_cb() failed."); + +} + +/** + * @brief Positive test case of bt_avrcp_set_shuffle_mode_changed_cb() + */ +static void utc_network_bluetooth_avrcp_set_shuffle_mode_changed_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_set_shuffle_mode_changed_cb(shuffle_mode_changed_cb_for_avrcp_p, NULL); + dts_check_eq("bt_avrcp_set_shuffle_mode_changed_cb", ret, BT_ERROR_NONE, + "bt_avrcp_set_shuffle_mode_changed_cb() failed."); +} + +/** + * @brief Positive test case of bt_avrcp_unset_shuffle_mode_changed_cb() + */ +static void utc_network_bluetooth_avrcp_unset_shuffle_mode_changed_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_unset_shuffle_mode_changed_cb(); + dts_check_eq("bt_avrcp_unset_shuffle_mode_changed_cb", ret, + BT_ERROR_NONE, + "bt_avrcp_unset_shuffle_mode_changed_cb() failed."); +} + +/** + * @brief Positive test case of bt_avrcp_set_scan_mode_changed_cb() + */ +static void utc_network_bluetooth_avrcp_set_scan_mode_changed_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_set_scan_mode_changed_cb(scan_mode_changed_cb_for_avrcp_p, NULL); + dts_check_eq("bt_avrcp_set_scan_mode_changed_cb", ret, BT_ERROR_NONE, + "bt_avrcp_set_scan_mode_changed_cb() failed."); +} + +/** + * @brief Positive test case of bt_avrcp_unset_scan_mode_changed_cb() + */ +static void utc_network_bluetooth_avrcp_unset_scan_mode_changed_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_unset_scan_mode_changed_cb(); + dts_check_eq("bt_avrcp_unset_scan_mode_changed_cb", ret, BT_ERROR_NONE, + "bt_avrcp_unset_scan_mode_changed_cb() failed."); + +} diff --git a/TC/testcase/utc_network_bluetooth_common_negative.c b/TC/testcase/utc_network_bluetooth_common_negative.c new file mode 100644 index 0000000..507d7f5 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_common_negative.c @@ -0,0 +1,84 @@ +/* + * utc_network_bluetooth_common_negative.c + * + * Created on: 20-Sep-2013 + * Author: mrinal.m + */ + +#include "bluetooth.h" +#include <tet_api.h> +#include <glib.h> + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; +void adapter_state_changed_cb_for_common_n(int result, + bt_adapter_state_e adapter_state, + void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {NULL, 0}, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_common_n, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +void adapter_state_changed_cb_for_common_n(int result, + bt_adapter_state_e adapter_state, + void *user_data) +{ + +} diff --git a/TC/testcase/utc_network_bluetooth_common_positive.c b/TC/testcase/utc_network_bluetooth_common_positive.c new file mode 100644 index 0000000..c694655 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_common_positive.c @@ -0,0 +1,119 @@ +/* + * utc_network_bluetooth_common_positive.c + * + * Created on: 20-Sep-2013 + * Author: mrinal.m + */ + +#include "bluetooth.h" +#include <tet_api.h> +#include <glib.h> + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +void adapter_state_changed_cb_for_common_p(int result, + bt_adapter_state_e adapter_state, + void *user_data); +gboolean timeout_func(gpointer data); + +static void utc_network_bluetooth_bt_initialize_p(void); +static void utc_network_bluetooth_bt_deinitialize_p(void); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_bt_initialize_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_bt_deinitialize_p, POSITIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_common_p, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_enable() was called."); + ret = bt_adapter_enable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_enable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret != BT_ERROR_ALREADY_DONE) { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +void adapter_state_changed_cb_for_common_p(int result, + bt_adapter_state_e adapter_state, + void *user_data) +{ + +} + +/** + * @brief Positive test case of bt_initialize() + */ +static void utc_network_bluetooth_bt_initialize_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_initialize(); + dts_check_eq("bt_initialize", ret, BT_ERROR_NONE, + "bt_initialize() failed."); + +} + +/** + * @brief Positive test case of bt_deinitialize() + */ +static void utc_network_bluetooth_bt_deinitialize_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_deinitialize(); + dts_check_eq("bt_deinitialize", ret, BT_ERROR_NONE, + "bt_deinitialize() failed."); + +} diff --git a/TC/testcase/utc_network_bluetooth_device_discovery_negative.c b/TC/testcase/utc_network_bluetooth_device_discovery_negative.c new file mode 100644 index 0000000..b5b422f --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_device_discovery_negative.c @@ -0,0 +1,191 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <tet_api.h> +#include <bluetooth.h> +#include <stdlib.h> +#include <stdbool.h> +#include <glib.h> + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static GMainLoop *mainloop; +gboolean timeout_func(gpointer data); + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_device_discovery_cancel_n(void); +static void utc_network_bluetooth_device_discovery_unset_state_changed_cb_n(void); +static void utc_network_bluetooth_device_discovery_set_state_changed_cb_n(void); +static void utc_network_bluetooth_device_discovery_start_n(void); +static void utc_network_bluetooth_device_discovery_get_status_n(void); + +void adapter_state_changed_cb_for_discovery_n(int result, + bt_adapter_state_e adapter_state, + void *user_data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_device_discovery_cancel_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_device_discovery_set_state_changed_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_device_discovery_get_status_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_device_discovery_start_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_device_discovery_unset_state_changed_cb_n, NEGATIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_discovery_n, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end"); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +/** + * @brief Callback funtions + */ +void adapter_state_changed_cb_for_discovery_n(int result, + state_e adapter_state, + void *user_data) +{ + tet_printf("Callback: bt_adapter_state_changed_cb was called."); + if (user_data != NULL && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_DISABLED && + result == BT_ERROR_NONE) { + tet_printf("Callback: BT was disabled. DTS will be started."); + } else { + tet_printf("Callback: BT was not disabled. DTS will be started but DTS may fail."); + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } + } +} + +/** + *@brief Negative test case of bt_adapter_stop_device_discovery() + */ +static void utc_network_bluetooth_device_discovery_cancel_n(void) +{ + int ret = bt_adapter_stop_device_discovery(); + + dts_check_eq("bt_adapter_stop_device_discovery", ret, + BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled"); +} + +/** + *@brief Negative test case of bt_adapter_unset_device_discovery_state_changed_cb() + */ +static void utc_network_bluetooth_device_discovery_unset_state_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + if (bt_deinitialize() != BT_ERROR_NONE) { + dts_fail("bt_adapter_unset_device_discovery_state_changed_cb", + "bt_deinitialize() failed."); + } + ret = bt_adapter_unset_device_discovery_state_changed_cb(); + dts_check_eq("bt_adapter_unset_device_discovery_state_changed_cb", ret, + BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized."); +} + +/** + *@brief Negative test case of bt_adapter_set_device_discovery_state_changed_cb() + */ +static void utc_network_bluetooth_device_discovery_set_state_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_set_device_discovery_state_changed_cb(NULL, NULL); + dts_check_eq("bt_adapter_set_device_discovery_state_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL"); +} + +/** + *@brief Negative test case of bt_adapter_start_device_discovery() + */ +static void utc_network_bluetooth_device_discovery_start_n(void) +{ + bt_error_e ret = BT_ERROR_NONE; + + ret = bt_adapter_start_device_discovery();; + dts_check_eq("bt_adapter_start_device_discovery", ret, + BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled"); +} + +/** + *@brief Negative test case of bt_adapter_is_discovering() + */ +static void utc_network_bluetooth_device_discovery_get_status_n(void) +{ + bt_error_e ret = BT_ERROR_NONE; + bool status = false; + + ret = bt_adapter_is_discovering(&status); + dts_check_eq("bt_adapter_is_discovering", ret, BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled"); +} diff --git a/TC/testcase/utc_network_bluetooth_device_discovery_positive.c b/TC/testcase/utc_network_bluetooth_device_discovery_positive.c new file mode 100644 index 0000000..0cd0fe4 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_device_discovery_positive.c @@ -0,0 +1,261 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <tet_api.h> +#include <bluetooth.h> +#include <stdlib.h> +#include <stdbool.h> +#include <glib.h> + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static GMainLoop *mainloop; +static bool callback_result = false; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_device_discovery_get_status_p(void); +static void utc_network_bluetooth_device_discovery_set_state_changed_cb_p(void); +static void utc_network_bluetooth_device_discovery_start_p(void); +static void utc_network_bluetooth_device_discovery_unset_state_changed_cb_p(void); +static void utc_network_bluetooth_device_discovery_cancel_p(void); + +gboolean timeout_func(gpointer data); +void adapter_state_changed_cb_for_discovery_p(int result, + bt_adapter_state_e adapter_state, + void *user_data); +void device_discovery_state_changed_cb_for_discovery_p(int result, + bt_adapter_device_discovery_state_e discovery_state, + bt_adapter_device_discovery_info_s *discovery_info, + void *user_data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_device_discovery_get_status_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_device_discovery_set_state_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_device_discovery_start_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_device_discovery_unset_state_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_device_discovery_cancel_p, POSITIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + bt_error_e ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_discovery_p, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed."); + } + + ret = bt_adapter_enable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_enable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_ALREADY_DONE) { + tet_printf("BT was already enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_enable() failed."); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf + ("bt_adapter_unset_device_discovery_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + tet_printf("TC end"); + bt_deinitialize(); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +/** + * @brief Callback funtions + */ +void adapter_state_changed_cb_for_discovery_p(int result, + bt_adapter_state_e adapter_state, + void *user_data) +{ + if (user_data != NULL && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_ENABLED && + result == BT_ERROR_NONE) { + tet_printf("Callback: BT was enabled."); + } else { + tet_printf("Callback: bt_adapter_state_changed_cb() was \ + called but bt_adapter_enable() failed."); + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } + } +} + +void device_discovery_state_changed_cb_for_discovery_p(int result, + bt_adapter_device_discovery_state_e discovery_state, + bt_adapter_device_discovery_info_s *discovery_info, + void *user_data) +{ + tet_printf("Callback: device_discovery_state_changed_cb_for_discovery_p is called"); + + if (discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FOUND) { + tet_printf("Callback: Devices were found"); + tet_printf("Callback: Device name is %s", discovery_info->remote_name); + tet_printf("Callback: Service class: %x", discovery_info->bt_class.major_service_class_mask); + if (user_data != NULL && !strcmp((char *)user_data, "start")) { + callback_result = true; + if (mainloop) { + g_main_loop_quit(mainloop); + } + } + } else if (discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FINISHED) { + tet_printf("Callback: Device discovery finished"); + if (user_data != NULL) { + if (!strcmp((char *)user_data, "start") && callback_result == false) { + tet_printf("You need a discoverable device"); + tet_printf("utc_network_bluetooth_device_discovery_start_p and \ + utc_network_bluetooth_device_discovery_cancel_p will fail"); + } else if (!strcmp((char *)user_data, "cancel")) { + if (result == BT_ERROR_CANCELLED) { + callback_result = true; + } + } + } + if (mainloop) { + g_main_loop_quit(mainloop); + } + } +} + +/** + * @brief Positive test case of bt_adapter_is_discovering() + */ +static void utc_network_bluetooth_device_discovery_get_status_p(void) +{ + bt_error_e ret = BT_ERROR_NONE; + bool status = false; + + ret = bt_adapter_is_discovering(&status); + dts_check_eq("bt_adapter_is_discovering", ret, BT_ERROR_NONE, + "bt_adapter_is_discovering() failed."); +} + +/** + * @brief Positive test case of bt_adapter_set_device_discovery_state_changed_cb() + */ +static void utc_network_bluetooth_device_discovery_set_state_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_set_device_discovery_state_changed_cb(device_discovery_state_changed_cb_for_discovery_p, "start"); + dts_check_eq("bt_adapter_set_device_discovery_state_changed_cb", ret, + BT_ERROR_NONE, + "bt_adapter_set_device_discovery_state_changed_cb() failed."); +} + +/** + * @brief Positive test case of bt_adapter_start_device_discovery() + */ +static void utc_network_bluetooth_device_discovery_start_p(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + callback_result = false; + + ret = bt_adapter_start_device_discovery(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_device_discovery_state_changed_cb_for_discovery_p() will be called."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + dts_check_eq("bt_adapter_start_device_discovery", + callback_result, true, + "Callback was called but failed."); + } else { + dts_fail("bt_adapter_start_device_discovery", + "bt_adapter_start_device_discovery() failed."); + } +} + +/** + * @brief Positive test case of bt_adapter_unset_device_discovery_state_changed_cb() + */ +static void utc_network_bluetooth_device_discovery_unset_state_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_unset_device_discovery_state_changed_cb(); + dts_check_eq("bt_adapter_unset_device_discovery_state_changed_cb", ret, + BT_ERROR_NONE, + "bt_device_discovery_uset_state_changed_cb() failed"); +} + +/** + * @brief Positive test case of bt_adapter_stop_device_discovery() + */ +static void utc_network_bluetooth_device_discovery_cancel_p(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + callback_result = false; + + if (bt_adapter_set_device_discovery_state_changed_cb(device_discovery_state_changed_cb_for_discovery_p, "cancel") != BT_ERROR_NONE) { + dts_fail("bt_adapter_stop_device_discovery", + "bt_adapter_set_device_discovery_state_changed_cb() failed"); + } + + ret = bt_adapter_stop_device_discovery(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_device_discovery_state_changed_cb_for_discovery_p() will be called"); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + bt_adapter_unset_device_discovery_state_changed_cb(); + dts_check_eq("bt_adapter_stop_device_discovery", + callback_result, true, + "Callback was called but failed"); + } else { + dts_fail("bt_adapter_stop_device_discovery", + "bt_adapter_stop_device_discovery() failed"); + } + +} diff --git a/TC/testcase/utc_network_bluetooth_device_negative.c b/TC/testcase/utc_network_bluetooth_device_negative.c new file mode 100644 index 0000000..f1e7d42 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_device_negative.c @@ -0,0 +1,296 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <tet_api.h> +#include <bluetooth.h> +#include <stdlib.h> +#include <stdbool.h> +#include <glib.h> + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; +gboolean timeout_func(gpointer data); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_device_set_bonded_cb_n(void); +static void utc_network_bluetooth_device_set_unbonded_cb_n(void); +static void utc_network_bluetooth_device_set_authorization_state_changed_cb_n(void); +static void utc_network_bluetooth_device_cancel_bonding_n(void); +static void utc_network_bluetooth_device_bond_n(void); +static void utc_network_bluetooth_device_foreach_bonded_device_n(void); +static void utc_network_bluetooth_device_set_alias_n(void); +static void utc_network_bluetooth_device_set_authorization_n(void); +static void utc_network_bluetooth_device_unbond_n(void); +static void utc_network_bluetooth_device_unset_bonded_cb_n(void); +static void utc_network_bluetooth_device_unset_unbonded_cb_n(void); +static void utc_network_bluetooth_device_unset_authorization_state_changed_cb_n(void); + +void adapter_state_changed_cb_for_device_negative(int result, + bt_adapter_state_e adapter_state, + void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_device_set_bonded_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_device_set_unbonded_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_device_set_authorization_state_changed_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_device_bond_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_device_cancel_bonding_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_device_unbond_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_device_foreach_bonded_device_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_device_set_alias_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_device_set_authorization_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_device_unset_bonded_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_device_unset_unbonded_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_device_unset_authorization_state_changed_cb_n, NEGATIVE_TC_IDX}, + {NULL, 0}, +}; + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_device_negative, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +/** + * @brief Callback funtions + */ +void adapter_state_changed_cb_for_device_negative(int result, + bt_adapter_state_e adapter_state, + void *user_data) +{ + tet_printf("Callback: bt_adapter_state_changed_cb was called."); + if ((user_data != NULL) && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_DISABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was disabled. DTS will be started."); + } else { + tet_printf("Callback: BT was not disabled. DTS will be started but DTS may fail."); + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } + } +} + +/** + * @brief Negative test case of bt_device_set_bond_created_cb() + */ +static void utc_network_bluetooth_device_set_bonded_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_device_set_bond_created_cb(NULL, NULL); + dts_check_eq("bt_device_set_bond_created_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL"); +} + +/** + * @brief Negative test case of bt_device_set_bond_destroyed_cb() + */ +static void utc_network_bluetooth_device_set_unbonded_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_device_set_bond_destroyed_cb(NULL, NULL); + dts_check_eq("bt_device_set_bond_destroyed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL"); +} + +/** + * @brief Negative test case of bt_device_set_authorization_changed_cb() + */ +static void +utc_network_bluetooth_device_set_authorization_state_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_device_set_authorization_changed_cb(NULL, NULL); + dts_check_eq("bt_device_set_authorization_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL"); +} + +/** + * @brief Negative test case of bt_device_unset_bond_created_cb() + */ +static void utc_network_bluetooth_device_unset_bonded_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + if (bt_deinitialize() != BT_ERROR_NONE) { + dts_fail("bt_device_unset_bond_created_cb", + "bt_deinitialize() failed."); + } + + ret = bt_device_unset_bond_created_cb(); + dts_check_eq("bt_device_unset_bond_created_cb", ret, + BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized."); +} + + /** + * @brief Negative test case of bt_device_unset_bond_destroyed_cb() + */ +static void utc_network_bluetooth_device_unset_unbonded_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_device_unset_bond_destroyed_cb(); + dts_check_eq("bt_device_unset_bond_destroyed_cb", ret, + BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized."); +} + +/** + * @brief Negative test case of bt_device_unset_authorization_changed_cb() + */ +static void +utc_network_bluetooth_device_unset_authorization_state_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_device_unset_authorization_changed_cb(); + dts_check_eq("bt_device_unset_authorization_changed_cb", ret, + BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized."); +} + + /** + * @brief Negative test case of bt_device_create_bond() + */ +static void utc_network_bluetooth_device_bond_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_device_create_bond(NULL); + dts_check_eq("bt_device_create_bond", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized."); +} + + /** + * @brief Negative test case of bt_device_cancel_bonding() + */ +static void utc_network_bluetooth_device_cancel_bonding_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_device_cancel_bonding(); + dts_check_eq("bt_device_cancel_bonding", ret, BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled"); +} + +/** + * @brief Negative test case of bt_device_destroy_bond() + */ +static void utc_network_bluetooth_device_unbond_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_device_destroy_bond(NULL); + dts_check_eq("bt_device_destroy_bond", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL"); +} + +/** + * @brief Negative test case of bt_adapter_foreach_bonded_device() + */ +static void utc_network_bluetooth_device_foreach_bonded_device_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_foreach_bonded_device(NULL, NULL); + dts_check_eq("bt_adapter_foreach_bonded_device", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL"); +} + +/** + * @brief Negative test case of bt_device_set_alias() + */ +static void utc_network_bluetooth_device_set_alias_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_device_set_alias(NULL, "dts_alias"); + dts_check_eq("bt_device_set_alias", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when address parameter is NULL"); +} + +/** + * @brief Negative test case of bt_device_set_authorization() + */ +static void utc_network_bluetooth_device_set_authorization_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_device_set_authorization(NULL, BT_DEVICE_AUTHORIZED); + dts_check_eq("bt_device_set_authorization", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when address parameter is NULL"); +} diff --git a/TC/testcase/utc_network_bluetooth_device_positive.c b/TC/testcase/utc_network_bluetooth_device_positive.c new file mode 100644 index 0000000..0a43e2d --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_device_positive.c @@ -0,0 +1,610 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <tet_api.h> +#include <bluetooth.h> +#include <stdlib.h> +#include <stdbool.h> +#include <glib.h> + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; +static bool callback_result = false; +char target_name[128] = "dts_test"; +char target_address[18] = ""; +bt_device_info_s *device_info = NULL; +bool discovery_result = false; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_device_set_bonded_cb_p(void); +static void utc_network_bluetooth_device_set_unbonded_cb_p(void); +static void utc_network_bluetooth_device_set_authorization_state_changed_cb_p(void); +static void utc_network_bluetooth_device_cancel_bonding_p(void); +static void utc_network_bluetooth_device_bond_p(void); +static void utc_network_bluetooth_device_foreach_bonded_device_p(void); +static void utc_network_bluetooth_device_set_alias_p(void); +static void utc_network_bluetooth_device_set_authorization_p(void); +static void utc_network_bluetooth_device_unbond_p(void); +static void utc_network_bluetooth_device_unset_bonded_cb_p(void); +static void utc_network_bluetooth_device_unset_unbonded_cb_p(void); +static void utc_network_bluetooth_device_unset_authorization_state_changed_cb_p(void); + +gboolean timeout_func(gpointer data); +void adapter_state_changed_cb_for_device_p(int result, + bt_adapter_state_e adapter_state, + void *user_data); +void device_discovery_state_changed_cb_for_device_p(int result, + bt_adapter_device_discovery_state_e discovery_state, + bt_adapter_device_discovery_info_s *discovery_info, + void *user_data); +void device_bonded_cb(int result, bt_device_info_s *device_info, + void *user_data); +void device_unbonded_cb(int result, char *remote_address, void *user_data); +void device_authorization_state_changed_cb(bt_device_authorization_e authorization_state, + char *remote_address, + void *user_data); +bool bonded_device_cb_for_device_p(bt_device_info_s *dev_info, + void *user_data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_device_set_bonded_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_device_unset_bonded_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_device_cancel_bonding_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_device_bond_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_device_foreach_bonded_device_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_device_set_alias_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_device_set_authorization_state_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_device_set_authorization_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_device_unset_authorization_state_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_device_set_unbonded_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_device_unbond_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_device_unset_unbonded_cb_p, POSITIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + bt_error_e ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + callback_result = false; + discovery_result = false; + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_device_p, "startup") != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + if (bt_adapter_set_device_discovery_state_changed_cb(device_discovery_state_changed_cb_for_device_p, "startup") != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_device_discovery_state_changed_cb() failed."); + } + + ret = bt_adapter_enable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_enable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + + tet_printf("BT was enabled. Device discovery will be started"); + if (bt_adapter_start_device_discovery() == BT_ERROR_NONE) { + tet_printf("bt_adapter_start_device_discovery() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else { + tet_printf("bt_adapter_start_device_discovery() failed."); + } + } else if (ret == BT_ERROR_ALREADY_DONE) { + tet_printf("BT was already enabled. Device discovery will be started"); + if (bt_adapter_start_device_discovery() == BT_ERROR_NONE) { + tet_printf("bt_adapter_start_device_discovery() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else { + tet_printf("bt_adapter_start_device_discovery() failed."); + } + } else { + tet_printf("DTS may fail because bt_adapter_enable() failed."); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_unset_state_changed_cb() failed."); + } + + if (bt_adapter_unset_device_discovery_state_changed_cb() != + BT_ERROR_NONE) { + tet_printf("bt_adapter_unset_device_discovery_state_changed_cb() failed."); + } + + tet_printf("TC start."); +} + +static void cleanup(void) +{ + /* end of TC */ + if (device_info != NULL) + free(device_info); + + bt_deinitialize(); + tet_printf("TC end"); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("[%s] Callback: Timeout.", __FUNCTION__); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +void adapter_state_changed_cb_for_device_p(int result, + bt_adapter_state_e adapter_state, + void *user_data) +{ + tet_printf("Callback: bt_adapter_state_changed_cb() was called"); + if (user_data != NULL && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_ENABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was enabled."); + } else { + tet_printf("Callback: BT was not enabled. DTS will be started but DTS may fail."); + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } + } +} + +void device_discovery_state_changed_cb_for_device_p(int result, + bt_adapter_device_discovery_state_e discovery_state, + bt_adapter_device_discovery_info_s *discovery_info, + void *user_data) +{ + tet_printf("Callback: bt_adapter_device_discovery_state_changed_cb() was called"); + if (user_data != NULL && !strcmp((char *)user_data, "startup")) { + if (discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FINISHED) { + tet_printf("Callback: Device discovery finished. DTS will be started."); + if (mainloop) { + g_main_loop_quit(mainloop); + } + } else if (discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FOUND) { + tet_printf("Callback: Devices were founded (%s)", discovery_info->remote_name); + if (discovery_info->remote_name != NULL && !strcmp(discovery_info->remote_name, target_name)) { + discovery_result = true; + tet_printf("Callback: dts_test device was found."); + strncpy(target_address, discovery_info->remote_address, 18); + tet_printf("Callback: device address: [%s]", discovery_info->remote_address); + if (bt_adapter_stop_device_discovery() == BT_ERROR_NONE) { + tet_printf("Callback: Device discovery will be stopped"); + } + } + } + } +} + +void device_bonded_cb(int result, bt_device_info_s * device_info, + void *user_data) +{ + int i = 0; + + tet_printf("Callback: bt_device_bond_created_cb() was called."); + if (result == BT_ERROR_TIMED_OUT) + tet_printf("result is BT_ERROR_TIMEOUT"); + else if (result == BT_ERROR_CANCELLED) + tet_printf("result is BT_ERROR_CANCELLED"); + else if (result == BT_ERROR_AUTH_FAILED) + tet_printf("result is BT_ERROR_AUTH_FAILED"); + else if (result == BT_ERROR_OPERATION_FAILED) + tet_printf("result is BT_ERROR_OPERATION_FAILED"); + else if (result == BT_ERROR_AUTH_REJECTED) + tet_printf("result is BT_ERROR_AUTH_REJECTED"); + else if (result == BT_ERROR_REMOTE_DEVICE_NOT_FOUND) + tet_printf("result is BT_ERROR_REMOTE_DEVICE_NOT_FOUND"); + else if (result == BT_ERROR_NONE) + tet_printf("result is BT_ERROR_NONE"); + else + tet_printf("result is unknown: %s", + _bt_convert_error_to_string(result)); + + /* in case of bt_device_cancel_bonding() */ + if (user_data != NULL && !strcmp((char *)user_data, "cancel")) { + if (result == BT_ERROR_CANCELLED) { + tet_printf("Callback: Cancellation of bonding succeeded"); + callback_result = true; + } else { + tet_printf("Callback: Cancellation of bonding failed"); + } + } /* in case of bt_device_create_bond() */ + else if (user_data != NULL && !strcmp((char *)user_data, "bond")) { + if (device_info == NULL) { + tet_printf("Callback data is NULL"); + + if (result == BT_ERROR_CANCELLED) + tet_printf("No user input in the peer device"); + + if (mainloop) + g_main_loop_quit(mainloop); + + return; + } + + if (device_info->remote_name != NULL && !strcmp(device_info->remote_name, target_name)) { + if (result == BT_ERROR_NONE) { + tet_printf("Callback: Bonding succeeded"); + tet_printf("Callback: serivce count : %d", device_info->service_count); + callback_result = true; + for (i = 0; i < device_info->service_count; i++) { + tet_printf("Callback: service list[%d] - %s", i + 1, device_info->service_uuid[i]); + } + } else { + tet_printf("Callback: Bonding failed"); + } + } + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } +} + +void device_unbonded_cb(int result, char *remote_address, void *user_data) +{ + tet_printf("Callback: bt_device_bond_destroyed_cb() was called."); + tet_printf("Callback: target address"); + if (target_address != NULL) { + tet_printf("device address: %s", target_address); + } else + tet_printf("Callback: target address is NULL!"); + + tet_printf("Callback: address of unbonded device"); + if (remote_address != NULL) { + tet_printf("device address: %s", remote_address); + if (!strcmp(remote_address, target_address)) { + if (result == BT_ERROR_NONE) { + tet_printf("Callback: Unbonding succeeded"); + callback_result = true; + } else { + tet_printf("Callback: Unbonding failed"); + } + } + } else + tet_printf("Callback: address of unbonded device is NULL!"); + + + if (mainloop) { + g_main_loop_quit(mainloop); + } + +} + +void device_authorization_state_changed_cb(bt_device_authorization_e + authorization_state, char *address, + void *user_data) +{ + if (authorization_state == BT_DEVICE_AUTHORIZED) { + if (address != NULL && !strcmp(address, target_address)) { + callback_result = true; + if (mainloop) { + g_main_loop_quit(mainloop); + } + } + } else { + if (address != NULL && !strcmp(address, target_address)) { + callback_result = true; + if (mainloop) { + g_main_loop_quit(mainloop); + } + } + } +} + +/** + * @brief Positive test case of bt_device_set_bond_created_cb() + */ +static void utc_network_bluetooth_device_set_bonded_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + /* Normal operation test */ + ret = bt_device_set_bond_created_cb(device_bonded_cb, "cancel"); + dts_check_eq("bt_device_set_bond_created_cb", ret, BT_ERROR_NONE, + "bt_device_set_bond_created_cb() failed"); +} + +/** + * @brief Positive test case of bt_device_set_bond_destroyed_cb() + */ +static void utc_network_bluetooth_device_set_unbonded_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + /* Normal operation test */ + ret = bt_device_set_bond_destroyed_cb(device_unbonded_cb, NULL); + dts_check_eq("bt_device_set_bond_destroyed_cb", ret, BT_ERROR_NONE, + "bt_device_set_bond_destroyed_cb() failed"); +} + +/** + * @brief Positive test case of bt_device_set_authorization_changed_cb() + */ +static void +utc_network_bluetooth_device_set_authorization_state_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + /* Normal operation test */ + ret = bt_device_set_authorization_changed_cb(device_authorization_state_changed_cb, NULL); + dts_check_eq("bt_device_set_authorization_changed_cb", ret, + BT_ERROR_NONE, + "bt_device_set_authorization_changed_cb() failed"); +} + +/** + * @brief Positive test case of bt_device_cancel_bonding() + */ +static void utc_network_bluetooth_device_cancel_bonding_p(void) +{ + int ret = BT_ERROR_NONE; + callback_result = false; + int timeout_id = 0; + + if (bt_device_set_bond_created_cb(device_bonded_cb, "cancel") != + BT_ERROR_NONE) { + dts_fail("bt_device_cancel_bonding", + "bt_device_set_bond_created_cb() failed"); + } + + /* bond device */ + ret = bt_device_create_bond(target_address); + if (ret != BT_ERROR_NONE) { + dts_fail("bt_device_cancel_bonding", + "bt_device_create_bond failed"); + } + tet_printf("bt_device_create_bond() was called"); + + /* cancel bonding */ + ret = bt_device_cancel_bonding(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_device_cancel_bonding() will be called"); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + bt_device_unset_bond_created_cb(); + dts_check_eq("bt_device_cancel_bonding", callback_result, true, + "Failed"); + } else { + bt_device_unset_bond_created_cb(); + dts_fail("bt_device_cancel_bonding", + "bt_device_cancel_bonding() failed"); + } +} + +/** + * @brief Positive test case of bt_device_unset_bond_created_cb() + */ +static void utc_network_bluetooth_device_unset_bonded_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + /* Normal operation test */ + ret = bt_device_unset_bond_created_cb(); + dts_check_eq("bt_device_unset_bond_created_cb", ret, BT_ERROR_NONE, + "bt_device_unset_bond_created_cb() failed"); +} + +/** + * @brief Positive test case of bt_device_create_bond() + */ +static void utc_network_bluetooth_device_bond_p(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + callback_result = false; + + /* bond device */ + ret = bt_device_set_bond_created_cb(device_bonded_cb, "bond"); + if (ret != BT_ERROR_NONE) { + dts_fail("bt_device_create_bond", + "bt_device_set_bond_created_cb() failed"); + } + + ret = bt_device_create_bond(target_address); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_device_bond_created_cb() will be called"); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + bt_device_unset_bond_created_cb(); + dts_check_eq("bt_device_create_bond", callback_result, true, + "Failed"); + } else { + bt_device_unset_bond_created_cb(); + dts_fail("bt_device_create_bond", + "bt_device_create_bond() failed"); + } +} + +bool bonded_device_cb_for_device_p(bt_device_info_s * dev_info, void *user_data) +{ + int i = 0; + device_info = (bt_device_info_s *) malloc(sizeof(bt_device_info_s)); + if (device_info == NULL) { + tet_printf("Callback: Memory allocation failed");; + } else if (dev_info != NULL) { + device_info->remote_address = strdup(dev_info->remote_address); + tet_printf("device address : %s", device_info->remote_address); + device_info->remote_name = strdup(dev_info->remote_name); + tet_printf("device name : %s", device_info->remote_name); + device_info->bt_class.major_device_class = dev_info->bt_class.major_device_class; + tet_printf("major clasee : %2.2X", device_info->bt_class.major_device_class); + device_info->bt_class.minor_device_class = dev_info->bt_class.minor_device_class; + tet_printf("minor clasee : %2.2X", device_info->bt_class.minor_device_class); + device_info->bt_class.major_service_class_mask = dev_info->bt_class.major_service_class_mask; + tet_printf("service clasee : %2.2X", device_info->bt_class.major_service_class_mask); + device_info->service_count = dev_info->service_count; + tet_printf("service count : %d", device_info->service_count); + if (device_info->service_count > 0) { + device_info->service_uuid = (char **)malloc(sizeof(char *) * device_info->service_count); + if (device_info->service_uuid == NULL) { + tet_printf("Failed to allocate memory"); + } else { + if (dev_info->service_uuid == NULL) { + tet_printf("service_list is NULL"); + } else { + tet_printf("Copy service list"); + for (i = 0; i < device_info->service_count; i++) { + device_info->service_uuid[i] = strdup(dev_info->service_uuid[i]); + tet_printf("Callback: service list[%d] - %s", i + 1, device_info->service_uuid[i]); + } + } + } + } else + device_info->service_uuid = NULL; + + device_info->is_bonded = dev_info->is_bonded; + tet_printf("is_bonded : %d", device_info->is_bonded); + device_info->is_connected = dev_info->is_connected; + tet_printf("is_connected : %d", device_info->is_connected); + tet_printf("Callback: device_info was selected."); + } + + return false; +} + +/** + * @brief Positive test case of bt_adapter_foreach_bonded_device() + */ +static void utc_network_bluetooth_device_foreach_bonded_device_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_foreach_bonded_device(bonded_device_cb_for_device_p, NULL); + if (ret == BT_ERROR_NONE) { + dts_pass("bt_adapter_foreach_bonded_device", + "bt_adapter_foreach_bonded_device pass"); + } else { + dts_fail("bt_adapter_foreach_bonded_device", + "bt_adapter_foreach_bonded_device() failed"); + } +} + +/** + * @brief Positive test case of bt_device_set_alias() + */ +static void utc_network_bluetooth_device_set_alias_p(void) +{ + int ret = BT_ERROR_NONE; + + if (device_info == NULL) { + tet_printf("No device to alias"); + dts_fail("bt_device_set_alias", "bt_device_set_alias() failed"); + return; + } + + ret = bt_device_set_alias(device_info->remote_address, "dts_alias"); + dts_check_eq("bt_device_set_alias", ret, BT_ERROR_NONE, + "bt_device_set_alias() failed"); +} + +/** + * @brief Positive test case of bt_device_set_authorization() + */ +static void utc_network_bluetooth_device_set_authorization_p(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + callback_result = false; + + ret = bt_device_set_authorization(target_address, BT_DEVICE_AUTHORIZED); + if (ret == BT_ERROR_NONE) { + tet_printf("device_authorization_state_changed_cb will be called"); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + dts_check_eq("bt_device_set_authorization", callback_result, + true, "Callback was called but failed"); + callback_result = false; + } else { + dts_fail("bt_device_set_authorization", + "bt_device_set_authorization() failed"); + } +} + +/** + * @brief Positive test case of bt_device_destroy_bond() + */ +static void utc_network_bluetooth_device_unbond_p(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + callback_result = false; + + tet_printf("bt_device_destroy_bond() will start"); + ret = bt_device_destroy_bond(target_address); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_device_unbond_cb() will be called"); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + dts_check_eq("bt_device_destroy_bond", callback_result, true, + "Failed"); + } else { + dts_fail("bt_device_destroy_bond", + "bt_device_destroy_bond() failed"); + } +} + +/** + * @brief Positive test case of bt_device_unset_bond_destroyed_cb() + */ +static void utc_network_bluetooth_device_unset_unbonded_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + /* Normal operation test */ + ret = bt_device_unset_bond_destroyed_cb(); + dts_check_eq("bt_device_unset_bond_destroyed_cb", ret, BT_ERROR_NONE, + "bt_device_unset_bond_destroyed_cb() failed"); +} + +/** + * @brief Positive test case of bt_device_unset_authorization_changed_cb() + */ +static void utc_network_bluetooth_device_unset_authorization_state_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + /* Normal operation test */ + ret = bt_device_unset_authorization_changed_cb(); + dts_check_eq("bt_device_unset_authorization_changed_cb", ret, + BT_ERROR_NONE, + "bt_device_unset_authorization_changed_cb() failed"); +} diff --git a/TC/testcase/utc_network_bluetooth_gatt_negative.c b/TC/testcase/utc_network_bluetooth_gatt_negative.c new file mode 100644 index 0000000..c58bdcf --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_gatt_negative.c @@ -0,0 +1,238 @@ +/* + * utc_network_bluetooth_gatt_negative.c + * + * Created on: 23-Sep-2013 + * Author: shagun.garg + */ + +#include <tet_api.h> +#include <bluetooth.h> +#include <stdlib.h> +#include <stdbool.h> +#include <glib.h> + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_gatt_foreach_primary_services_n(void); +static void utc_network_bluetooth_gatt_discover_characteristics_n(void); +static void utc_network_bluetooth_gatt_get_service_uuid_n(void); +static void utc_network_bluetooth_gatt_foreach_included_services_n(void); +static void utc_network_bluetooth_gatt_set_characteristic_changed_cb_n(void); +static void utc_network_bluetooth_gatt_unset_characteristic_changed_cb_n(void); +static void utc_network_bluetooth_gatt_get_characteristic_declaration_n(void); +static void utc_network_bluetooth_gatt_set_characteristic_value_n(void); +static void utc_network_bluetooth_gatt_clone_attribute_handle_n(void); +static void utc_network_bluetooth_gatt_destroy_attribute_handle_n(void); + +void adapter_state_changed_cb_for_gatt_n(int result, bt_adapter_state_e adapter_state, void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_gatt_foreach_primary_services_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_gatt_discover_characteristics_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_gatt_get_service_uuid_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_gatt_foreach_included_services_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_gatt_set_characteristic_changed_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_gatt_unset_characteristic_changed_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_gatt_get_characteristic_declaration_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_gatt_set_characteristic_value_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_gatt_clone_attribute_handle_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_gatt_destroy_attribute_handle_n, NEGATIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_gatt_n, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +/** + * @brief Callback funtions + */ +void adapter_state_changed_cb_for_gatt_n(int result, bt_adapter_state_e adapter_state, void *user_data) +{ + tet_printf("Callback: bt_adapter_state_changed_cb was called."); + if ((user_data != NULL) && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_DISABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was disabled. DTS will be started."); + } else { + tet_printf("Callback: BT was not disabled. DTS will be started but DTS may fail."); + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } + } +} + +/** + * @brief Negative test case of bt_gatt_foreach_primary_services() + */ +static void utc_network_bluetooth_gatt_foreach_primary_services_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_gatt_foreach_primary_services(NULL, NULL, NULL); + dts_check_eq("bt_gatt_foreach_primary_services", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when remote address and callback parameters are NULL."); +} + +/** + * @brief Negative test case of bt_gatt_discover_characteristics() + */ +static void utc_network_bluetooth_gatt_discover_characteristics_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_gatt_discover_characteristics(NULL, NULL, NULL); + dts_check_eq("bt_gatt_discover_characteristics", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when service and callback parameters are NULL."); +} + +/** + * @brief Negative test case of bt_gatt_get_service_uuid() + */ +static void utc_network_bluetooth_gatt_get_service_uuid_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_gatt_get_service_uuid(NULL, NULL); + dts_check_eq("bt_gatt_get_service_uuid", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when service parameter is NULL."); +} + +/** + * @brief Negative test case of bt_gatt_foreach_included_services() + */ +static void utc_network_bluetooth_gatt_foreach_included_services_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_gatt_foreach_included_services(NULL, NULL, NULL); + dts_check_eq("bt_socket_unset_connection_state_changed_cb", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when service and callback parameters are NULL."); +} + +/** + * @brief Negative test case of bt_gatt_set_characteristic_changed_cb() + */ +static void utc_network_bluetooth_gatt_set_characteristic_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_gatt_set_characteristic_changed_cb(NULL, NULL, NULL); + dts_check_eq("bt_gatt_set_characteristic_changed_cb", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when service and callback parameters are NULL."); +} + +/** + * @brief Negative test case of bt_gatt_unset_characteristic_changed_cb() + */ +static void utc_network_bluetooth_gatt_unset_characteristic_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_gatt_unset_characteristic_changed_cb(NULL); + dts_check_eq("bt_gatt_unset_characteristic_changed_cb", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when service parameter is NULL."); +} + +/** + * @brief Negative test case of bt_gatt_get_characteristic_declaration() + */ +static void utc_network_bluetooth_gatt_get_characteristic_declaration_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_gatt_get_characteristic_declaration(NULL, NULL, NULL, 0); + dts_check_eq("bt_gatt_get_characteristic_declaration", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when characteristic parameter is NULL."); +} + +/** + * @brief Negative test case of bt_gatt_set_characteristic_value() + */ +static void utc_network_bluetooth_gatt_set_characteristic_value_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_gatt_set_characteristic_value(NULL, NULL, -1); + dts_check_eq("bt_socket_connect_rfcomm", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when characteristic and value parameters are NULL."); +} + +/** + * @brief Negative test case of bt_gatt_clone_attribute_handle() + */ +static void utc_network_bluetooth_gatt_clone_attribute_handle_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_gatt_clone_attribute_handle(NULL, NULL); + dts_check_eq("bt_gatt_clone_attribute_handle", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when origin parameter is NULL."); +} + +/** + * @brief Negative test case of bt_gatt_destroy_attribute_handle() + */ +static void utc_network_bluetooth_gatt_destroy_attribute_handle_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_gatt_destroy_attribute_handle(NULL); + dts_check_eq("bt_gatt_destroy_attribute_handle", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when handle parameter is NULL."); +} diff --git a/TC/testcase/utc_network_bluetooth_gatt_positive.c b/TC/testcase/utc_network_bluetooth_gatt_positive.c new file mode 100644 index 0000000..5df118c --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_gatt_positive.c @@ -0,0 +1,282 @@ +/* + * utc_network_bluetooth_gatt_positive.c + * + * Created on: 23-Sep-2013 + * Author: shagun.garg + */ + +#include <tet_api.h> +#include <bluetooth.h> +#include <stdlib.h> +#include <stdbool.h> +#include <glib.h> +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +const char target_name[128] = "dts_test"; +char target_address[18] = ""; + +static GMainLoop *mainloop; + +static void utc_network_bluetooth_gatt_foreach_primary_services_p(void); +static void utc_network_bluetooth_gatt_discover_characteristics_p(void); + +static void utc_network_bluetooth_gatt_get_service_uuid_p(void); +static void utc_network_bluetooth_gatt_foreach_included_services_p(void); +static void utc_network_bluetooth_gatt_set_characteristic_changed_cb_p(void); +static void utc_network_bluetooth_gatt_unset_characteristic_changed_cb_p(void); +static void utc_network_bluetooth_gatt_get_characteristic_declaration_p(void); +static void utc_network_bluetooth_gatt_set_characteristic_value_p(void); +static void utc_network_bluetooth_gatt_clone_attribute_handle_p(void); +static void utc_network_bluetooth_gatt_destroy_attribute_handle_p(void); + +gboolean timeout_func(gpointer data); +void adapter_state_changed_cb_for_gatt_p(int result, bt_adapter_state_e adapter_state, void *user_data); + +bool primary_service_cb_for_gatt_p(bt_gatt_attribute_h service, void *user_data); +bool included_service_cb_for_gatt_p(bt_gatt_attribute_h service, void *user_data); +bool characteristics_discovered_cb_for_gatt_p(int result, int index, int total, bt_gatt_attribute_h characteristic, + void *user_data); +void characteristics_changed_cb_for_gatt_p(bt_gatt_attribute_h characteristic, unsigned char *value, int value_length, + void *user_data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_gatt_foreach_primary_services_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_gatt_discover_characteristics_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_gatt_get_service_uuid_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_gatt_foreach_included_services_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_gatt_set_characteristic_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_gatt_unset_characteristic_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_gatt_get_characteristic_declaration_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_gatt_set_characteristic_value_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_gatt_clone_attribute_handle_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_gatt_destroy_attribute_handle_p, POSITIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + bt_error_e ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + tet_printf("TC start."); + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_gatt_p, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("[%s] Callback: Timeout.", __FUNCTION__); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +void adapter_state_changed_cb_for_gatt_p(int result, bt_adapter_state_e adapter_state, void *user_data) +{ + if (user_data != NULL && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_ENABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was enabled."); + bt_adapter_start_device_discovery(); + } else { + tet_printf("Callback: BT was not enabled. DTS will be started but DTS may fail."); + if (mainloop) { + g_main_loop_quit(mainloop); + } + } + } +} + +bool primary_service_cb_for_gatt_p(bt_gatt_attribute_h service, void *user_data) +{ + return false; +} + +bool characteristics_discovered_cb_for_gatt_p(int result, int index, int total, bt_gatt_attribute_h characteristic, + void *user_data) +{ + return false; +} + +bool included_service_cb_for_gatt_p(bt_gatt_attribute_h service, void *user_data) +{ + return false; +} + +void characteristics_changed_cb_for_gatt_p(bt_gatt_attribute_h characteristic, unsigned char *value, int value_length, + void *user_data) +{ + +} + +/** + * @brief Positive test case of bt_gatt_foreach_primary_services() + */ +static void utc_network_bluetooth_gatt_foreach_primary_services_p(void) +{ + int ret = BT_ERROR_NONE; + char *remote_addr = "dts_addr"; + + ret = bt_gatt_foreach_primary_services(remote_addr, primary_service_cb_for_gatt_p, NULL); + dts_check_eq("bt_gatt_foreach_primary_services", ret, BT_ERROR_NONE, "bt_gatt_foreach_primary_services() failed."); +} + +/** + * @brief Positive test case of bt_gatt_discover_characteristics() + */ +static void utc_network_bluetooth_gatt_discover_characteristics_p(void) +{ + int ret = BT_ERROR_NONE; + bt_call_list_h gatt_serv; + gatt_serv = g_malloc0(sizeof(bt_call_list_h)); + + ret = bt_gatt_discover_characteristics(gatt_serv, characteristics_discovered_cb_for_gatt_p, NULL); + dts_check_eq("bt_gatt_discover_characteristics", ret, BT_ERROR_NONE, "bt_gatt_discover_characteristics() failed."); +} + +/** + * @brief Positive test case of bt_gatt_get_service_uuid() + */ +static void utc_network_bluetooth_gatt_get_service_uuid_p(void) +{ + int ret = BT_ERROR_NONE; + char *uid = "dts_uid"; + bt_call_list_h gatt_serv; + gatt_serv = g_malloc0(sizeof(bt_call_list_h)); + + ret = bt_gatt_get_service_uuid(gatt_serv, &uid); + dts_check_eq("bt_gatt_get_service_uuid", ret, BT_ERROR_NONE, "bt_gatt_get_service_uuid() failed."); +} + +/** + * @brief Positive test case of bt_gatt_foreach_included_services() + */ +static void utc_network_bluetooth_gatt_foreach_included_services_p(void) +{ + int ret = BT_ERROR_NONE; + bt_call_list_h gatt_serv; + gatt_serv = g_malloc0(sizeof(bt_call_list_h)); + ret = bt_gatt_foreach_included_services(gatt_serv, included_service_cb_for_gatt_p, NULL); + dts_check_eq("bt_gatt_foreach_included_services", ret, BT_ERROR_NONE, "bt_gatt_foreach_included_services() failed."); +} + +/** + * @brief Positive test case of bt_gatt_set_characteristic_changed_cb() + */ +static void utc_network_bluetooth_gatt_set_characteristic_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + bt_call_list_h gatt_serv; + gatt_serv = g_malloc0(sizeof(bt_call_list_h)); + ret = bt_gatt_set_characteristic_changed_cb(gatt_serv, characteristics_changed_cb_for_gatt_p, NULL); + dts_check_eq("bt_gatt_set_characteristic_changed_cb", ret, BT_ERROR_NONE, + "bt_gatt_set_characteristic_changed_cb() failed."); +} + +/** + * @brief Positive test case of bt_gatt_unset_characteristic_changed_cb() + */ +static void utc_network_bluetooth_gatt_unset_characteristic_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + bt_call_list_h gatt_serv; + gatt_serv = g_malloc0(sizeof(bt_call_list_h)); + ret = bt_gatt_unset_characteristic_changed_cb(gatt_serv); + dts_check_eq("bt_gatt_unset_characteristic_changed_cb", ret, BT_ERROR_NONE, + "bt_gatt_unset_characteristic_changed_cb() failed."); + +} + +/** + * @brief Positive test case of bt_gatt_get_characteristic_declaration() + */ +static void utc_network_bluetooth_gatt_get_characteristic_declaration_p(void) +{ + int ret = BT_ERROR_NONE; + char **uid = "dts_uid"; + unsigned char **val = "dts_value"; + int l = 1; + bt_call_list_h gatt_charac; + gatt_charac = g_malloc0(sizeof(bt_call_list_h)); + ret = bt_gatt_get_characteristic_declaration(gatt_charac, uid, val, &l); + dts_check_eq("bt_gatt_get_characteristic_declaration", ret, BT_ERROR_NONE, + "gatt_get_characteristic_declaration() failed."); +} + +/** + * @brief Positive test case of bt_gatt_set_characteristic_value() + */ +static void utc_network_bluetooth_gatt_set_characteristic_value_p(void) +{ + int ret = BT_ERROR_NONE; + bt_call_list_h gatt_charac; + gatt_charac = g_malloc0(sizeof(bt_call_list_h)); + const unsigned char *gatt_value = "dts_value"; + ret = bt_gatt_set_characteristic_value(gatt_charac, gatt_value, strlen("dts_value")); + dts_check_eq("bt_gatt_set_characteristic_value", ret, BT_ERROR_NONE, "bt_gatt_set_characteristic_value() failed."); +} + +/** + * @brief Positive test case of bt_gatt_clone_attribute_handle() + */ +static void utc_network_bluetooth_gatt_clone_attribute_handle_p(void) +{ + int ret = BT_ERROR_NONE; + bt_call_list_h gatt_origin; + gatt_origin = g_malloc0(sizeof(bt_call_list_h)); + + ret = bt_gatt_clone_attribute_handle(NULL, gatt_origin); + dts_check_eq("bt_gatt_clone_attribute_handle", ret, BT_ERROR_NONE, "bt_gatt_clone_attribute_handle() failed."); +} + +/** + * @brief Positive test case of bt_gatt_destroy_attribute_handle() + */ +static void utc_network_bluetooth_gatt_destroy_attribute_handle_p(void) +{ + int ret = BT_ERROR_NONE; + bt_call_list_h gatt_handle; + gatt_handle = g_malloc0(sizeof(bt_call_list_h)); + + ret = bt_gatt_destroy_attribute_handle(gatt_handle); + dts_check_eq("bt_gatt_destroy_attribute_handle", ret, BT_ERROR_NONE, "bt_gatt_destroy_attribute_handle() failed."); +} diff --git a/TC/testcase/utc_network_bluetooth_hdp_negative.c b/TC/testcase/utc_network_bluetooth_hdp_negative.c new file mode 100644 index 0000000..4313d0b --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_hdp_negative.c @@ -0,0 +1,235 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <tet_api.h> +#include <bluetooth.h> +#include <stdlib.h> +#include <stdbool.h> +#include <glib.h> + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_hdp_register_sink_app_n(void); +static void utc_network_bluetooth_hdp_unregister_sink_app_n(void); +static void utc_network_bluetooth_hdp_connect_to_source_n(void); +static void utc_network_bluetooth_hdp_disconnect_n(void); +static void utc_network_bluetooth_hdp_send_data_n(void); +static void utc_network_bluetooth_hdp_set_connection_state_changed_cb_n(void); +static void utc_network_bluetooth_hdp_unset_connection_state_changed_cb_n(void); +static void utc_network_bluetooth_hdp_set_data_received_cb_n(void); +static void utc_network_bluetooth_hdp_unset_data_received_cb_n(void); + +void adapter_state_changed_cb_for_hdp_n(int result, bt_adapter_state_e adapter_state, void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_hdp_register_sink_app_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_hdp_unregister_sink_app_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_hdp_connect_to_source_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_hdp_disconnect_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_hdp_send_data_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_hdp_set_connection_state_changed_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_hdp_unset_connection_state_changed_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_hdp_set_data_received_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_hdp_unset_data_received_cb_n, NEGATIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_hdp_n, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +/** + * @brief Callback funtions + */ +void adapter_state_changed_cb_for_hdp_n(int result, bt_adapter_state_e adapter_state, void *user_data) +{ + tet_printf("Callback: bt_adapter_state_changed_cb was called."); + if ((user_data != NULL) && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_DISABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was disabled. DTS will be started."); + } else { + tet_printf("Callback: BT was not disabled. DTS will be started but DTS may fail."); + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } + } +} + +/** + * @brief Negative test case of bt_hdp_set_data_received_cb() + */ +static void utc_network_bluetooth_hdp_set_data_received_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hdp_set_data_received_cb(NULL, NULL); + dts_check_eq("bt_hdp_set_data_received_cb", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL"); +} + +/** + * @brief Negative test case of bt_hdp_set_connection_state_changed_cb() + */ +static void utc_network_bluetooth_hdp_set_connection_state_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hdp_set_connection_state_changed_cb(NULL, NULL, NULL); + dts_check_eq("bt_hdp_set_connection_state_changed_cb", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when callback parameters are NULL"); +} + +/** + * @brief Negative test case of bt_hdp_unset_data_received_cb() + */ +static void utc_network_bluetooth_hdp_unset_data_received_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hdp_unset_data_received_cb(); + dts_check_eq("bt_hdp_unset_data_received_cb", ret, BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized."); +} + +/** + * @brief Negative test case of bt_hdp_unset_connection_state_changed_cb() + */ +static void utc_network_bluetooth_hdp_unset_connection_state_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hdp_unset_connection_state_changed_cb(); + dts_check_eq("bt_hdp_unset_connection_state_changed_cb", ret, BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized."); +} + +/** + * @brief Negative test case of bt_hdp_disconnect() + */ +static void utc_network_bluetooth_hdp_disconnect_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hdp_disconnect(NULL, 1); + dts_check_eq("bt_hdp_disconnect", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when remote address parameter is NULL"); +} + +/** + * @brief Negative test case of bt_hdp_connect_to_source() + */ +static void utc_network_bluetooth_hdp_connect_to_source_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hdp_connect_to_source(NULL, NULL); + dts_check_eq("bt_hdp_connect_to_source", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when remote address and app_id parameter are NULL"); +} + +/** + * @brief Negative test case of bt_hdp_register_sink_app() + */ +static void utc_network_bluetooth_hdp_register_sink_app_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hdp_register_sink_app(1, NULL); + dts_check_eq("bt_hdp_register_sink_app", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when app_id parameter is NULL"); +} + +/** + * @brief Negative test case of bt_hdp_unregister_sink_appe() + */ +static void utc_network_bluetooth_hdp_unregister_sink_app_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hdp_unregister_sink_app(NULL); + dts_check_eq("bt_shdp_unregister_sink", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when app_id parameter is NULL"); +} + +/** + * @brief Negative test case of bt_hdp_send_data() + */ +static void utc_network_bluetooth_hdp_send_data_n(void) +{ + int ret = BT_ERROR_NONE; + char *data = "dts_test"; + + ret = bt_hdp_send_data(1, data, sizeof(data)); + dts_check_eq("bt_hdp_send_data", ret, BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled"); +} diff --git a/TC/testcase/utc_network_bluetooth_hdp_positive.c b/TC/testcase/utc_network_bluetooth_hdp_positive.c new file mode 100644 index 0000000..aa0eaa9 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_hdp_positive.c @@ -0,0 +1,226 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <tet_api.h> +#include <bluetooth.h> +#include <stdlib.h> +#include <stdbool.h> +#include <glib.h> + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_hdp_register_sink_app_p(void); +static void utc_network_bluetooth_hdp_unregister_sink_app_p(void); +static void utc_network_bluetooth_hdp_connect_to_source_p(void); +static void utc_network_bluetooth_hdp_disconnect_p(void); +static void utc_network_bluetooth_hdp_send_data_p(void); +static void utc_network_bluetooth_hdp_set_connection_state_changed_cb_p(void); +static void utc_network_bluetooth_hdp_unset_connection_state_changed_cb_p(void); +static void utc_network_bluetooth_hdp_set_data_received_cb_p(void); +static void utc_network_bluetooth_hdp_unset_data_received_cb_p(void); + +void data_received_cb_for_hdp_p(unsigned int channel, const char *data, unsigned int size, void *user_data); +void connected_cb_for_hdp_p(int result, const char *remote_address, const char *app_id, + bt_hdp_channel_type_e type, unsigned int channel, void *user_data); +void disconnected_cb_for_hdp_p(int result, const char *remote_address, unsigned int channel, void *user_data); + +void adapter_state_changed_cb_for_hdp_p(int result, bt_adapter_state_e adapter_state, void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_hdp_register_sink_app_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_hdp_unregister_sink_app_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_hdp_connect_to_source_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_hdp_disconnect_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_hdp_send_data_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_hdp_set_connection_state_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_hdp_unset_connection_state_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_hdp_set_data_received_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_hdp_unset_data_received_cb_p, POSITIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_hdp_p, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +void adapter_state_changed_cb_for_hdp_p(int result, bt_adapter_state_e adapter_state, void *user_data) +{ + if ((user_data != NULL) && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_ENABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was enabled."); + bt_adapter_start_device_discovery(); + } else { + tet_printf("Callback: BT was not enabled. DTS will be started but DTS may fail."); + if (mainloop) { + g_main_loop_quit(mainloop); + } + } + } +} + +void data_received_cb_for_hdp_p(unsigned int channel, const char *data, unsigned int size, void *user_data) +{ + +} + +void connected_cb_for_hdp_p(int result, const char *remote_address, const char *app_id, + bt_hdp_channel_type_e type, unsigned int channel, void *user_data) +{ + +} + +void disconnected_cb_for_hdp_p(int result, const char *remote_address, unsigned int channel, void *user_data) +{ + +} + +static void utc_network_bluetooth_hdp_set_data_received_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hdp_set_data_received_cb(data_received_cb_for_hdp_p, NULL); + dts_check_eq("bt_hdp_set_data_received_cb", ret, BT_ERROR_NONE, "bt_hdp_set_data_received_cb() failed."); +} + +static void utc_network_bluetooth_hdp_unset_data_received_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hdp_unset_data_received_cb(); + dts_check_eq("bt_hdp_unset_data_received_cb", ret, BT_ERROR_NONE, "bt_hdp_unset_data_received_cb() failed."); +} + +static void utc_network_bluetooth_hdp_set_connection_state_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hdp_set_connection_state_changed_cb(connected_cb_for_hdp_p, disconnected_cb_for_hdp_p, NULL); + dts_check_eq("bt_hdp_set_connection_state_changed_cb", ret, BT_ERROR_NONE, + "bt_hdp_set_connection_state_changed_cb() failed."); +} + +static void utc_network_bluetooth_hdp_unset_connection_state_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hdp_unset_connection_state_changed_cb(); + dts_check_eq("bt_hdp_unset_connection_state_changed_cb", ret, BT_ERROR_NONE, + "bt_hdp_unset_connection_state_changed_cb() failed."); +} + +static void utc_network_bluetooth_hdp_send_data_p(void) +{ + int ret = BT_ERROR_NONE; + char *dts_test = "dts_test"; + + ret = bt_hdp_send_data(1, "dts_test", sizeof(dts_test)); + dts_check_eq("bt_hdp_send_data", ret, BT_ERROR_NONE, "bt_hdp_send_data() failed."); +} + +static void utc_network_bluetooth_hdp_disconnect_p(void) +{ + int ret = BT_ERROR_NONE; + char *remote_adr = ""; + + ret = bt_hdp_disconnect(remote_adr, 1); + dts_check_eq("bt_hdp_disconnect", ret, BT_ERROR_NONE, "bt_hdp_disconnect() failed."); +} + +static void utc_network_bluetooth_hdp_connect_to_source_p(void) +{ + int ret = BT_ERROR_NONE; + char *remote_adr = "dts_remote"; + char *appid = "dts_id"; + + ret = bt_hdp_connect_to_source(remote_adr, appid); + dts_check_eq("bt_hdp_connect_to_source", ret, BT_ERROR_NONE, "bt_hdp_connect_to_source() failed."); + +} + +static void utc_network_bluetooth_hdp_unregister_sink_app_p(void) +{ + int ret = BT_ERROR_NONE; + char *appid = "dts_id"; + + ret = bt_hdp_unregister_sink_app(appid); + dts_check_eq("bt_hdp_unregister_sink_app", ret, BT_ERROR_NONE, "bt_hdp_unregister_sink_app() failed."); + +} + +static void utc_network_bluetooth_hdp_register_sink_app_p(void) +{ + int ret = BT_ERROR_NONE; + char *appid = "dts_id"; + + ret = bt_hdp_register_sink_app(1, &appid); + dts_check_eq("bt_hdp_register_sink_app", ret, BT_ERROR_NONE, "bt_hdp_register_sink_app() failed."); + +} diff --git a/TC/testcase/utc_network_bluetooth_hid_negative.c b/TC/testcase/utc_network_bluetooth_hid_negative.c new file mode 100644 index 0000000..6b99d66 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_hid_negative.c @@ -0,0 +1,149 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <tet_api.h> +#include <bluetooth.h> +#include <stdlib.h> +#include <stdbool.h> +#include <glib.h> + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_hid_host_initialize_n(void); +static void utc_network_bluetooth_hid_host_deinitialize_n(void); +static void utc_network_bluetooth_hid_host_connect_n(void); +static void utc_network_bluetooth_hid_host_disconnect_n(void); + +void adapter_state_changed_cb_for_hid_n(int result, bt_adapter_state_e adapter_state, void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_hid_host_initialize_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_hid_host_deinitialize_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_hid_host_connect_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_hid_host_disconnect_n, NEGATIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_hid_n, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +void adapter_state_changed_cb_for_hid_n(int result, bt_adapter_state_e adapter_state, void *user_data) +{ + if ((user_data != NULL) && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_ENABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was enabled."); + bt_adapter_start_device_discovery(); + } else { + tet_printf("Callback: BT was not enabled. DTS will be started but DTS may fail."); + if (mainloop) { + g_main_loop_quit(mainloop); + } + } + } +} + +static void utc_network_bluetooth_hid_host_initialize_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hid_host_initialize(NULL, NULL); + dts_check_eq("bt_socket_set_data_received_cb", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL."); +} + +static void utc_network_bluetooth_hid_host_deinitialize_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hid_host_deinitialize(); + dts_check_eq("bt_hid_host_deinitialize", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned."); +} + +static void utc_network_bluetooth_hid_host_connect_n(void) +{ + int ret = BT_ERROR_NONE; + //char* remote_addr="dts_addr"; + + ret = bt_hid_host_connect(NULL); + dts_check_eq("bt_hid_host_connect", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when remote address parameter is NULL."); +} + +static void utc_network_bluetooth_hid_host_disconnect_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hid_host_disconnect(NULL); + dts_check_eq("bt_hid_host_disconnect", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when remote address parameter is NULL."); +} diff --git a/TC/testcase/utc_network_bluetooth_hid_positive.c b/TC/testcase/utc_network_bluetooth_hid_positive.c new file mode 100644 index 0000000..a06a164 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_hid_positive.c @@ -0,0 +1,152 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <tet_api.h> +#include <bluetooth.h> +#include <stdlib.h> +#include <stdbool.h> +#include <glib.h> + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_hid_host_initialize_p(void); +static void utc_network_bluetooth_hid_host_deinitialize_p(void); +static void utc_network_bluetooth_hid_host_connect_p(void); +static void utc_network_bluetooth_hid_host_disconnect_p(void); + +void adapter_state_changed_cb_for_hid_p(int result, bt_adapter_state_e adapter_state, void *user_data); +void host_connection_state_changed_cb_for_hid_p(int result, bool connected, const char *remote_address, void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_hid_host_initialize_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_hid_host_deinitialize_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_hid_host_connect_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_hid_host_disconnect_p, POSITIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_hid_p, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +void adapter_state_changed_cb_for_hid_p(int result, bt_adapter_state_e adapter_state, void *user_data) +{ + if (user_data != NULL && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_ENABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was enabled."); + bt_adapter_start_device_discovery(); + } else { + tet_printf("Callback: BT was not enabled. DTS will be started but DTS may fail."); + if (mainloop) { + g_main_loop_quit(mainloop); + } + } + } +} + +void host_connection_state_changed_cb_for_hid_p(int result, bool connected, const char *remote_address, void *user_data) +{ + +} + +static void utc_network_bluetooth_hid_host_initialize_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hid_host_initialize(host_connection_state_changed_cb_for_hid_p, NULL); + dts_check_eq("bt_hid_host_initialize", ret, BT_ERROR_NONE, "bt_hid_host_initialize() failed."); +} + +static void utc_network_bluetooth_hid_host_deinitialize_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hid_host_deinitialize(); + dts_check_eq("bt_hid_host_deinitialize", ret, BT_ERROR_NONE, "bt_hid_host_deinitialize() failed."); +} + +static void utc_network_bluetooth_hid_host_connect_p(void) +{ + int ret = BT_ERROR_NONE; + char *remote_addr = "dts_addr"; + + ret = bt_hid_host_connect(remote_addr); + dts_check_eq("bt_hid_host_connect", ret, BT_ERROR_NONE, "bt_hid_host_connect() failed."); +} + +static void utc_network_bluetooth_hid_host_disconnect_p(void) +{ + int ret = BT_ERROR_NONE; + char *remote_addr = "dts_addr"; + + ret = bt_hid_host_disconnect(remote_addr); + dts_check_eq("bt_hid_host_disconnect", ret, BT_ERROR_NONE, "bt_hid_host_disconnect() failed."); +} diff --git a/TC/testcase/utc_network_bluetooth_opp-client_negative.c b/TC/testcase/utc_network_bluetooth_opp-client_negative.c new file mode 100644 index 0000000..67299e9 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_opp-client_negative.c @@ -0,0 +1,172 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <tet_api.h> +#include <bluetooth.h> +#include <stdlib.h> +#include <stdbool.h> +#include <glib.h> + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_opp_client_initialize_n(void); +static void utc_network_bluetooth_opp_client_deinitialize_n(void); +static void utc_network_bluetooth_opp_client_add_file_n(void); +static void utc_network_bluetooth_opp_client_clear_files_n(void); +static void utc_network_bluetooth_opp_client_push_files_n(void); +static void utc_network_bluetooth_opp_client_cancel_push_n(void); + +void adapter_state_changed_cb_for_opp_client_n(int result, bt_adapter_state_e adapter_state, void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_opp_client_initialize_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_opp_client_deinitialize_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_opp_client_add_file_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_opp_client_clear_files_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_opp_client_push_files_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_opp_client_cancel_push_n, NEGATIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_opp_client_n, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +void adapter_state_changed_cb_for_opp_client_n(int result, bt_adapter_state_e adapter_state, void *user_data) +{ + if (user_data != NULL && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_ENABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was enabled."); + bt_adapter_start_device_discovery(); + } else { + tet_printf("Callback: BT was not enabled. DTS will be started but DTS may fail."); + if (mainloop) { + g_main_loop_quit(mainloop); + } + } + } +} + +static void utc_network_bluetooth_opp_client_initialize_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_client_initialize(); + dts_check_eq("bt_opp_client_initialize", ret, BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned."); +} + +static void utc_network_bluetooth_opp_client_deinitialize_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_client_deinitialize(); + dts_check_eq("bt_opp_client_deinitialize", ret, BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned."); + +} + +static void utc_network_bluetooth_opp_client_add_file_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_client_add_file(NULL); + dts_check_eq("bt_opp_client_add_file", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when file parameter is NULL"); +} + +static void utc_network_bluetooth_opp_client_clear_files_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_client_clear_files(); + dts_check_eq("bt_opp_client_clear_files", ret, BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned."); + +} + +static void utc_network_bluetooth_opp_client_push_files_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_client_push_files(NULL, NULL, NULL, NULL, NULL); + dts_check_eq("bt_opp_client_push_files", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when parameters are NULL"); +} + +static void utc_network_bluetooth_opp_client_cancel_push_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_client_cancel_push(); + dts_check_eq("bt_opp_client_cancel_push", ret, BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned."); +} diff --git a/TC/testcase/utc_network_bluetooth_opp-client_positive.c b/TC/testcase/utc_network_bluetooth_opp-client_positive.c new file mode 100644 index 0000000..341243d --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_opp-client_positive.c @@ -0,0 +1,190 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <tet_api.h> +#include <bluetooth.h> +#include <stdlib.h> +#include <stdbool.h> +#include <glib.h> + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_opp_client_initialize_p(void); +static void utc_network_bluetooth_opp_client_deinitialize_p(void); +static void utc_network_bluetooth_opp_client_add_file_p(void); +static void utc_network_bluetooth_opp_client_clear_files_p(void); +static void utc_network_bluetooth_opp_client_push_files_p(void); +static void utc_network_bluetooth_opp_client_cancel_push_p(void); + +void push_responded_cb_for_opp_client_p(int result, const char *remote_address, void *user_data); +void push_progress_cb_for_opp_client_p(const char *file, long long size, int percent, void *user_data); +void push_finished_cb_for_opp_client_p(int result, const char *remote_address, void *user_data); +void adapter_state_changed_cb_for_opp_client_p(int result, bt_adapter_state_e adapter_state, void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_opp_client_initialize_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_opp_client_deinitialize_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_opp_client_add_file_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_opp_client_clear_files_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_opp_client_push_files_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_opp_client_cancel_push_p, POSITIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_opp_client_p, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +void adapter_state_changed_cb_for_opp_client_p(int result, bt_adapter_state_e adapter_state, void *user_data) +{ + if ((user_data != NULL) && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_ENABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was enabled."); + bt_adapter_start_device_discovery(); + } else { + tet_printf("Callback: BT was not enabled. DTS will be started but DTS may fail."); + if (mainloop) { + g_main_loop_quit(mainloop); + } + } + } +} + +void push_responded_cb_for_opp_client_p(int result, const char *remote_address, void *user_data) +{ + +} + +void push_progress_cb_for_opp_client_p(const char *file, long long size, int percent, void *user_data) +{ + +} + +void push_finished_cb_for_opp_client_p(int result, const char *remote_address, void *user_data) +{ + +} + +static void utc_network_bluetooth_opp_client_initialize_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_client_initialize(); + dts_check_eq("bt_opp_client_initialize", ret, BT_ERROR_NONE, "bt_opp_client_initialize() failed."); +} + +static void utc_network_bluetooth_opp_client_deinitialize_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_client_deinitialize(); + dts_check_eq("bt_opp_client_deinitialize", ret, BT_ERROR_NONE, "bt_opp_client_deinitialize() failed."); + +} + +static void utc_network_bluetooth_opp_client_add_file_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_client_add_file("dts_file"); + dts_check_eq("bt_opp_client_add_file", ret, BT_ERROR_NONE, "bt_opp_client_add_file() failed"); +} + +static void utc_network_bluetooth_opp_client_clear_files_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_client_clear_files(); + dts_check_eq("bt_opp_client_clear_files", ret, BT_ERROR_NONE, "bt_opp_client_clear_files() failed."); + +} + +static void utc_network_bluetooth_opp_client_push_files_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = + bt_opp_client_push_files(NULL, push_responded_cb_for_opp_client_p, push_progress_cb_for_opp_client_p, + push_finished_cb_for_opp_client_p, NULL); + if (ret == BT_ERROR_NONE) { + dts_pass("bt_opp_client_push_files", "bt_opp_client_push_files pass"); + } else { + dts_fail("bt_opp_client_push_files", "bt_opp_client_push_files() failed"); + } +} + +static void utc_network_bluetooth_opp_client_cancel_push_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_client_cancel_push(); + dts_check_eq("bt_opp_client_cancel_push", ret, BT_ERROR_NONE, "bt_opp_client_cancel_push() failed."); +} diff --git a/TC/testcase/utc_network_bluetooth_opp-server_negative.c b/TC/testcase/utc_network_bluetooth_opp-server_negative.c new file mode 100644 index 0000000..d44db06 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_opp-server_negative.c @@ -0,0 +1,174 @@ +/* + * + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <tet_api.h> +#include <bluetooth.h> +#include <stdlib.h> +#include <stdbool.h> +#include <glib.h> + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_opp_server_initialize_n(void); +static void utc_network_bluetooth_opp_server_initialize_by_connection_request_n(void); +static void utc_network_bluetooth_opp_server_deinitialize_n(void); +static void utc_network_bluetooth_opp_server_accept_n(void); +static void utc_network_bluetooth_opp_server_reject_n(void); +static void utc_network_bluetooth_opp_server_set_destination_n(void); + +void adapter_state_changed_cb_for_opp_server_n(int result, bt_adapter_state_e adapter_state, void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_opp_server_initialize_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_opp_server_initialize_by_connection_request_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_opp_server_deinitialize_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_opp_server_accept_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_opp_server_reject_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_opp_server_set_destination_n, NEGATIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_opp_server_n, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +/** + * @brief Callback funtions + */ +void adapter_state_changed_cb_for_opp_server_n(int result, bt_adapter_state_e adapter_state, void *user_data) +{ + tet_printf("Callback: bt_adapter_state_changed_cb was called."); + if ((user_data != NULL) && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_DISABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was disabled. DTS will be started."); + } else { + tet_printf("Callback: BT was not disabled. DTS will be started but DTS may fail."); + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } + } +} + +static void utc_network_bluetooth_opp_server_initialize_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_server_initialize(NULL, NULL, NULL); + dts_check_eq("bt_opp_server_initializa", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when destination parameter is NULL"); +} + +static void utc_network_bluetooth_opp_server_deinitialize_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_server_deinitialize(); + dts_check_eq("bt_opp_server_deinitialize", ret, BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned."); +} + +static void utc_network_bluetooth_opp_server_accept_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_opp_server_accept(NULL, NULL, NULL, NULL, NULL); + dts_check_eq("bt_opp_server_accept", ret, BT_ERROR_NOT_INITIALIZED, "BT_ERROR_NOT_INITIALIZED must be returned."); + +} + +static void utc_network_bluetooth_opp_server_reject_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_server_reject(); + dts_check_eq("bt_opp_server_reject", ret, BT_ERROR_NOT_INITIALIZED, "BT_ERROR_NOT_INITIALIZED must be returned."); +} + +static void utc_network_bluetooth_opp_server_set_destination_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_server_set_destination(NULL); + dts_check_eq("bt_opp_server_set_destination", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned destination parameter is NULL"); +} + +static void utc_network_bluetooth_opp_server_initialize_by_connection_request_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_server_initialize_by_connection_request(NULL, NULL, NULL); + dts_check_eq("bt_opp_server_initialize_by_connection_request", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned destination parameter is NULL"); + +} diff --git a/TC/testcase/utc_network_bluetooth_opp-server_positive.c b/TC/testcase/utc_network_bluetooth_opp-server_positive.c new file mode 100644 index 0000000..fa93272 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_opp-server_positive.c @@ -0,0 +1,182 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <tet_api.h> +#include <bluetooth.h> +#include <stdlib.h> +#include <stdbool.h> +#include <glib.h> + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; +char dest[18] = ""; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_opp_server_initialize_p(void); +static void utc_network_bluetooth_opp_server_initialize_by_connection_request_p(void); +static void utc_network_bluetooth_opp_server_deinitialize_p(void); +static void utc_network_bluetooth_opp_server_accept_p(void); +static void utc_network_bluetooth_opp_server_reject_p(void); +static void utc_network_bluetooth_opp_server_set_destination_p(void); + +void push_requested_cb_for_opp_server_p(const char *file, int size, void *user_data); +void connection_requested_cb_for_opp_server_p(const char *remote_address, void *user_data); +void adapter_state_changed_cb_for_opp_server_p(int result, bt_adapter_state_e adapter_state, void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_opp_server_initialize_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_opp_server_initialize_by_connection_request_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_opp_server_deinitialize_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_opp_server_accept_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_opp_server_reject_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_opp_server_set_destination_p, POSITIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_opp_server_p, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +void adapter_state_changed_cb_for_opp_server_p(int result, bt_adapter_state_e adapter_state, void *user_data) +{ + tet_printf("Callback: bt_adapter_state_changed_cb was called."); + if (user_data != NULL && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_DISABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was disabled. DTS will be started."); + } else { + tet_printf("Callback: BT was not disabled. DTS will be started but DTS may fail."); + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } + } +} + +void push_requested_cb_for_opp_server_p(const char *file, int size, void *user_data) +{ + +} + +void connection_requested_cb_for_opp_server_p(const char *remote_address, void *user_data) +{ + +} + +static void utc_network_bluetooth_opp_server_initialize_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_server_initialize(dest, push_requested_cb_for_opp_server_p, NULL); + dts_check_eq("bt_opp_server_initialize", ret, BT_ERROR_NONE, "bt_opp_server_initialize() failed"); + +} + +static void utc_network_bluetooth_opp_server_deinitialize_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_server_deinitialize(); + dts_check_eq("bt_opp_server_deinitialize", ret, BT_ERROR_NONE, "bt_opp_server_deinitialize() failed."); +} + +static void utc_network_bluetooth_opp_server_accept_p(void) +{ + int ret = BT_ERROR_NONE; + int tid = 1; + ret = bt_opp_server_accept(NULL, NULL, "dts_name", NULL, &tid); + dts_check_eq("bt_opp_server_accept", ret, BT_ERROR_NONE, "bt_opp_server_accept() failed."); + +} + +static void utc_network_bluetooth_opp_server_reject_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_server_reject(); + dts_check_eq("bt_opp_server_reject", ret, BT_ERROR_NONE, "bt_opp_server_reject() failed."); +} + +static void utc_network_bluetooth_opp_server_set_destination_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_server_set_destination(dest); + dts_check_eq("bt_opp_server_set_destination", ret, BT_ERROR_NONE, "bt_opp_server_destination() failed"); +} + +static void utc_network_bluetooth_opp_server_initialize_by_connection_request_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_server_initialize_by_connection_request(dest, connection_requested_cb_for_opp_server_p, NULL); + dts_check_eq("bt_opp_server_initialize_by_connection_request", ret, BT_ERROR_NONE, + "bt_opp_server_initialize_by_connection_request() failed"); + +} diff --git a/TC/testcase/utc_network_bluetooth_pan_negative.c b/TC/testcase/utc_network_bluetooth_pan_negative.c new file mode 100644 index 0000000..a5a0712 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_pan_negative.c @@ -0,0 +1,148 @@ +/* + * utc_network_bluetooth_pan_negative.c + * + * Created on: 20-Sep-2013 + * Author: mrinal.m + */ + +#include "bluetooth.h" +#include <tet_api.h> +#include <glib.h> + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_nap_set_connection_state_changed_n(void); +static void utc_network_bluetooth_panu_set_connection_state_changed_n(void); +static void utc_network_bluetooth_panu_connect_n(void); +static void utc_network_bluetooth_panu_disconnect_n(void); + +void adapter_state_changed_cb_for_pan_n(int result, + bt_adapter_state_e adapter_state, + void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_nap_set_connection_state_changed_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_panu_set_connection_state_changed_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_panu_connect_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_panu_disconnect_n, NEGATIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_pan_n, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +/** + * @brief Negative test case of bt_nap_set_connection_state_changed_cb() + */ + +void adapter_state_changed_cb_for_pan_n(int result, + bt_adapter_state_e adapter_state, + void *user_data) +{ + +} + +static void utc_network_bluetooth_nap_set_connection_state_changed_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_nap_set_connection_state_changed_cb(NULL, NULL); + dts_check_eq("bt_nap_set_connection_state_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_nap_set_connection_state_changed_cb() failed."); + +} + +/** + * @brief Negative test case of bt_panu_set_connection_state_changed_cb() + */ +static void utc_network_bluetooth_panu_set_connection_state_changed_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_panu_set_connection_state_changed_cb(NULL, NULL); + dts_check_eq("bt_panu_set_connection_state_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_panu_set_connection_state_changed_cb() failed."); + +} + +/** + * @brief Negative test case of bt_panu_connect() + */ +static void utc_network_bluetooth_panu_connect_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_panu_connect(NULL, BT_PANU_SERVICE_TYPE_NAP); + dts_check_eq("bt_panu_connect", ret, BT_ERROR_INVALID_PARAMETER, + "bt_panu_connect() failed."); + +} + +/** + * @brief Negative test case of bt_panu_disconnect() + */ +static void utc_network_bluetooth_panu_disconnect_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_panu_disconnect(NULL); + dts_check_eq("bt_panu_disconnect", ret, BT_ERROR_INVALID_PARAMETER, + "bt_panu_disconnect() failed."); + +} diff --git a/TC/testcase/utc_network_bluetooth_pan_positive.c b/TC/testcase/utc_network_bluetooth_pan_positive.c new file mode 100644 index 0000000..28d5632 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_pan_positive.c @@ -0,0 +1,237 @@ +/* + * utc_network_bluetooth_pan_positive.c + * + * Created on: 20-Sep-2013 + * Author: mrinal.m + */ + +#include "bluetooth.h" +#include <tet_api.h> +#include <glib.h> + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_nap_activate_p(void); +static void utc_network_bluetooth_nap_deactivate_p(void); +static void utc_network_bluetooth_nap_disconnect_all_p(void); +static void utc_network_bluetooth_nap_set_connection_state_changed_p(void); +static void utc_network_bluetooth_nap_unset_connection_state_changed_p(void); +static void utc_network_bluetooth_panu_set_connection_state_changed_p(void); +static void utc_network_bluetooth_panu_unset_connection_state_changed_p(void); +static void utc_network_bluetooth_panu_connect_p(void); +static void utc_network_bluetooth_panu_disconnect_p(void); + +void connection_state_changed_cb_for_nap_p(bool connected, + const char *remote_address, + const char *interface_name, + void *user_data); +void connection_state_changed_cb_for_panu_p(int result, + bool connected, + const char *remote_address, + bt_panu_service_type_e type, + void *user_data); + +void adapter_state_changed_cb_for_pan_p(int result, + bt_adapter_state_e adapter_state, + void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_nap_activate_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_nap_set_connection_state_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_nap_unset_connection_state_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_nap_deactivate_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_nap_disconnect_all_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_panu_connect_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_panu_set_connection_state_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_panu_unset_connection_state_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_panu_disconnect_p, POSITIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_pan_p, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_enable() was called."); + + ret = bt_adapter_enable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_enable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret != BT_ERROR_ALREADY_DONE) { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +/** + * @brief Callback funtions +*/ + +void adapter_state_changed_cb_for_pan_p(int result, + bt_adapter_state_e adapter_state, + void *user_data) +{ + +} + +void connection_state_changed_cb_for_nap_p(bool connected, + const char *remote_address, + const char *interface_name, + void *user_data) +{ + +} + +void connection_state_changed_cb_for_panu_p(int result, + bool connected, + const char *remote_address, + bt_panu_service_type_e type, + void *user_data) +{ + +} + +/** + * @brief Positive test case of bt_nap_activate() +*/ +static void utc_network_bluetooth_nap_activate_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_nap_activate(); + if (ret != BT_ERROR_ALREADY_DONE) { + dts_check_eq("bt_nap_activate", ret, BT_ERROR_NONE, "bt_nap_activate() failed."); + } else { + dts_check_eq("bt_nap_activate", ret, BT_ERROR_ALREADY_DONE, + "bt_nap_activate() failed."); + } +} + +/** + * @brief Positive test case of bt_nap_deactivate() +*/ +static void utc_network_bluetooth_nap_deactivate_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_nap_deactivate(); + dts_check_eq("bt_nap_deactivate", ret, BT_ERROR_NONE, "bt_nap_deactivate() failed."); +} + +/** + * @brief Positive test case of bt_nap_disconnect_all() + */ +static void utc_network_bluetooth_nap_disconnect_all_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_nap_disconnect_all(); + dts_check_eq("bt_nap_disconnect_all", ret, BT_ERROR_NONE, + "bt_nap_disconnect_all() failed."); +} + +/** + * @brief Positive test case of bt_nap_set_connection_state_changed_cb() + */ +static void utc_network_bluetooth_nap_set_connection_state_changed_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_nap_set_connection_state_changed_cb(connection_state_changed_cb_for_nap_p, NULL); + dts_check_eq("bt_nap_set_connection_state_changed_cb", ret, BT_ERROR_NONE, + "bt_nap_set_connection_state_changed_cb() failed."); +} + +/** + * @brief Positive test case of bt_nap_unset_connection_state_changed_cb() +*/ +static void utc_network_bluetooth_nap_unset_connection_state_changed_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_nap_unset_connection_state_changed_cb(); + dts_check_eq("bt_nap_unset_connection_state_changed_cb", ret, BT_ERROR_NONE, + "bt_nap_unset_connection_state_changed_cb() failed."); +} + +/** + * @brief Positive test case of bt_panu_set_connection_state_changed_cb() +*/ +static void utc_network_bluetooth_panu_set_connection_state_changed_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_panu_set_connection_state_changed_cb(connection_state_changed_cb_for_panu_p, NULL); + dts_check_eq("bt_panu_set_connection_state_changed_cb", ret, BT_ERROR_NONE, + "bt_panu_set_connection_state_changed_cb() failed."); +} + +/** + * @brief Positive test case of bt_panu_unset_connection_state_changed_cb() +*/ +static void utc_network_bluetooth_panu_unset_connection_state_changed_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_panu_unset_connection_state_changed_cb(); + dts_check_eq("bt_panu_unset_connection_state_changed_cb", ret, BT_ERROR_NONE, + "bt_panu_unset_connection_state_changed_cb() failed."); +} + +/** + * @brief Positive test case of bt_panu_connect() +*/ +static void utc_network_bluetooth_panu_connect_p(void) +{ + int ret = BT_ERROR_NONE; + const char *remote_address = "00:00:00:00:00:00"; + ret = bt_panu_connect(remote_address, BT_PANU_SERVICE_TYPE_NAP); + dts_check_eq("bt_panu_connect", ret, BT_ERROR_NONE, "bt_panu_connect() failed."); +} + +/** + * @brief Positive test case of bt_panu_disconnect() +*/ +static void utc_network_bluetooth_panu_disconnect_p(void) +{ + int ret = BT_ERROR_NONE; + const char *remote_address = "00:00:00:00:00:00"; + ret = bt_panu_disconnect(remote_address); + dts_check_eq("bt_panu_disconnect", ret, BT_ERROR_NONE, "bt_panu_disconnect() failed."); +} diff --git a/TC/testcase/utc_network_bluetooth_service_search_negative.c b/TC/testcase/utc_network_bluetooth_service_search_negative.c new file mode 100644 index 0000000..1e83157 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_service_search_negative.c @@ -0,0 +1,178 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <tet_api.h> +#include <bluetooth.h> +#include <stdlib.h> +#include <stdbool.h> +#include <glib.h> + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_service_search_set_cb_n(void); +static void utc_network_bluetooth_service_search_unset_cb_n(void); +static void utc_network_bluetooth_service_search_n(void); +static void utc_network_bluetooth_service_search_cancel_n(void); + +void adapter_state_changed_cb_for_service_search_n(int result, + bt_adapter_state_e adapter_state, + void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_service_search_set_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_service_search_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_service_search_cancel_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_service_search_unset_cb_n, NEGATIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_service_search_n, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +/** + * @brief Callback funtions + */ +void adapter_state_changed_cb_for_service_search_n(int result, + bt_adapter_state_e + adapter_state, + void *user_data) +{ + tet_printf("Callback: bt_adapter_state_changed_cb was called."); + if (user_data != NULL && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_DISABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was disabled. DTS will be started."); + } else { + tet_printf("Callback: BT was not disabled. DTS will be started but DTS may fail."); + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } + } +} + +/** + * @brief Negative test case of bt_device_set_service_searched_cb() + */ +static void utc_network_bluetooth_service_search_set_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_device_set_service_searched_cb(NULL, NULL); + dts_check_eq("bt_device_set_service_searched_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL"); +} + +/** + * @brief Negative test case of bt_device_unset_service_searched_cb() + */ +static void utc_network_bluetooth_service_search_unset_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + if (bt_deinitialize() != BT_ERROR_NONE) { + dts_fail("bt_device_unset_service_searched_cb", + "bt_deinitialize() failed."); + } + + ret = bt_device_unset_service_searched_cb(); + dts_check_eq("bt_device_unset_service_searched_cb", ret, + BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized."); +} + +/** + * @brief Negative test case of bt_device_start_service_search() + */ +static void utc_network_bluetooth_service_search_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_device_start_service_search(NULL); + dts_check_eq("bt_device_start_service_search", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL"); +} + +/** + * @brief Negative test case of bt_device_cancel_service_search() + */ +static void utc_network_bluetooth_service_search_cancel_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_device_cancel_service_search(); + dts_check_eq("bt_device_cancel_service_search", ret, + BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled"); +} diff --git a/TC/testcase/utc_network_bluetooth_service_search_positive.c b/TC/testcase/utc_network_bluetooth_service_search_positive.c new file mode 100644 index 0000000..eab85ed --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_service_search_positive.c @@ -0,0 +1,366 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <tet_api.h> +#include <bluetooth.h> +#include <stdlib.h> +#include <stdbool.h> +#include <glib.h> +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +char target_name[128] = "dts_test"; +char target_address[18] = ""; +bool callback_result = false; +bool discovery_result = false; +bool bonding_result = false; +static GMainLoop *mainloop; + +static void utc_network_bluetooth_service_search_set_cb_p(void); +static void utc_network_bluetooth_service_search_p(void); +static void utc_network_bluetooth_service_search_cancel_p(void); +static void utc_network_bluetooth_service_search_unset_cb_p(void); + +gboolean timeout_func(gpointer data); +void adapter_state_changed_cb_for_service_search_p(int result, + bt_adapter_state_e adapter_state, + void *user_data); +void device_discovery_state_changed_cb_for_service_search_p(int result, + bt_adapter_device_discovery_state_e discovery_state, + bt_adapter_device_discovery_info_s *discovery_info, + void *user_data); +void service_searched_cb_for_service_search_p(int result, + bt_device_sdp_info_s *sdp_info, + void *user_data); +void device_bonded_cb_for_service_search_p(int result, + bt_device_info_s *device_info, + void *user_data); +void device_unbonded_cb(int result, char *remote_address, void *user_data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_service_search_set_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_service_search_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_service_search_cancel_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_service_search_unset_cb_p, POSITIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + bt_error_e ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + callback_result = false; + discovery_result = false; + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_service_search_p, "startup") != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + if (bt_adapter_set_device_discovery_state_changed_cb(device_discovery_state_changed_cb_for_service_search_p, "startup") != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_device_discovery_state_changed_cb() failed."); + } + + ret = bt_adapter_enable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_enable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + + tet_printf("BT was enabled. Device discovery will be started"); + if (bt_adapter_start_device_discovery() == BT_ERROR_NONE) { + tet_printf("bt_adapter_start_device_discovery() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else { + tet_printf("bt_adapter_start_device_discovery() failed."); + } + } else if (ret == BT_ERROR_ALREADY_DONE) { + tet_printf("BT was already enabled. Device discovery will be started"); + if (bt_adapter_start_device_discovery() == BT_ERROR_NONE) { + tet_printf("bt_adapter_start_device_discovery() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else { + tet_printf("bt_adapter_start_device_discovery() failed."); + } + } else { + tet_printf("DTS may fail because bt_adapter_enable() failed."); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_unset_state_changed_cb() failed."); + } + + if (bt_adapter_unset_device_discovery_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_unset_device_discovery_state_changed_cb() failed."); + } + + tet_printf("TC start."); +} + +static void cleanup(void) +{ + /* end of TC */ + int timeout_id = 0; + + /* Destroy a bond */ + bt_device_set_bond_destroyed_cb(device_unbonded_cb, NULL); + if (bt_device_destroy_bond(target_address) == BT_ERROR_NONE) { + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } + + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("[%s] Callback: Timeout.", __FUNCTION__); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +/** + * @brief Callback funtions + */ +void device_unbonded_cb(int result, char *remote_address, void *user_data) +{ + tet_printf("Callback: bt_device_bond_destroyed_cb() was called."); + + if (mainloop) { + g_main_loop_quit(mainloop); + } + +} + +void adapter_state_changed_cb_for_service_search_p(int result, + bt_adapter_state_e adapter_state, + void *user_data) +{ + tet_printf("Callback: bt_adapter_state_changed_cb() was called"); + if (user_data != NULL && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_ENABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was enabled."); + } else { + tet_printf("Callback: BT was not enabled. DTS will be started but DTS may fail."); + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } + } +} + +void device_discovery_state_changed_cb_for_service_search_p(int result, + bt_adapter_device_discovery_state_e + discovery_state, + bt_adapter_device_discovery_info_s + * discovery_info, + void *user_data) +{ + tet_printf("Callback: bt_adapter_device_discovery_state_changed_cb() was called"); + if (user_data != NULL && !strcmp((char *)user_data, "startup")) { + if (discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FINISHED) { + tet_printf("Callback: Device discovery finished. DTS will be started."); + if (mainloop) { + g_main_loop_quit(mainloop); + } + } else if (discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FOUND) { + tet_printf("Callback: Devices were founded (%s)", + discovery_info->remote_name); + if (discovery_info->remote_name != NULL && !strcmp(discovery_info->remote_name, target_name)) { + discovery_result = true; + tet_printf("Callback: dts_test device was found."); + strncpy(target_address, discovery_info->remote_address, 18); + tet_printf("Callback: device address: %s", discovery_info->remote_address); + if (bt_adapter_stop_device_discovery() == BT_ERROR_NONE) { + tet_printf("Callback: Device discovery will be stopped"); + } + } + } + } +} + +void service_searched_cb_for_service_search_p(int result, + bt_device_sdp_info_s *sdp_info, + void *user_data) +{ + int i = 0; + + tet_printf("Callback: bt_device_service_searched_cb() was called."); + if (result == BT_ERROR_NONE) { + if (sdp_info != NULL && !strcmp(sdp_info->remote_address, target_address)) { + tet_printf("Callback: Service search succeeded."); + tet_printf("Callback: Service count : %d", sdp_info->service_count); + for (i = 0; i < sdp_info->service_count; i++) { + tet_printf("Callback: uuid[%d] - %s", i + 1, sdp_info->service_uuid[i]); + } + + callback_result = true; + } + } else if (result == BT_ERROR_CANCELLED) { + if (sdp_info != NULL && !strcmp(sdp_info->remote_address, target_address)) { + tet_printf("Callback: Calcellation of service search succeeded."); + callback_result = true; + } + } else { + tet_printf("Callback: Failed."); + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } +} + +void device_bonded_cb_for_service_search_p(int result, + bt_device_info_s *device_info, + void *user_data) +{ + if (user_data != NULL && !strcmp((char *)user_data, "startup")) { + if (device_info->remote_address != NULL && !strcmp(device_info->remote_address, target_address)) { + if (result == BT_ERROR_NONE) { + tet_printf("Callback: Bonding succeeded"); + bonding_result = true; + } else { + tet_printf("Callback: Bonding failed"); + } + } + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } +} + +/** + * @brief Positive test case of bt_device_set_service_searched_cb() + */ +static void utc_network_bluetooth_service_search_set_cb_p(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + ret = bt_device_set_service_searched_cb(service_searched_cb_for_service_search_p, NULL); + if (ret == BT_ERROR_NONE) { + if (bt_device_set_bond_created_cb(device_bonded_cb_for_service_search_p, "startup") != BT_ERROR_NONE) { + tet_printf("bt_device_set_bond_created_cb() failed."); + } + + if (discovery_result == true && bt_device_create_bond(target_address) == BT_ERROR_NONE) { + tet_printf("bt_device_create_bond() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else { + tet_printf("bt_device_create_bond() failed."); + } + } + + dts_check_eq("bt_device_set_service_searched_cb", ret, BT_ERROR_NONE, + "bt_device_set_service_searched_cb() failed."); +} + +/** + * @brief Positive test case of bt_device_start_service_search() + */ +static void utc_network_bluetooth_service_search_p(void) +{ + int timeout_id = 0; + + if (discovery_result != true) { + dts_fail("bt_device_start_service_search", + "device discovery failed."); + } + + callback_result = false; + if (bt_device_start_service_search(target_address) == BT_ERROR_NONE) { + tet_printf("bt_device_start_service_search() succeeded."); + tet_printf("service_searched_cb_for_service_search_p() will be called."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + dts_check_eq("bt_device_start_service_search", callback_result, + true, "Service search failed."); + } else { + dts_fail("bt_device_start_service_search", + "bt_device_start_service_search() failed."); + } +} + +/** + * @brief Positive test case of bt_device_cancel_service_search() + */ +static void utc_network_bluetooth_service_search_cancel_p(void) +{ + int timeout_id = 0; + + if (discovery_result != true) { + dts_fail("bt_device_cancel_service_search", + "device discovery failed."); + } + + callback_result = false; + if (bt_device_start_service_search(target_address) != BT_ERROR_NONE) { + dts_fail("bt_device_cancel_service_search", + "bt_device_start_service_search() failed."); + } else { + tet_printf("bt_device_cancel_service_search", + "bt_device_start_service_search() succeeded."); + } + + if (bt_device_cancel_service_search() == BT_ERROR_NONE) { + tet_printf("bt_device_cancel_service_search() succeeded."); + tet_printf("service_searched_cb_for_service_search_p() will be called."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + dts_check_eq("bt_device_cancel_service_search", callback_result, + true, "Cancellation of service search failed."); + } else { + dts_fail("bt_device_cancel_service_search", + "bt_device_cancel_service_search() failed."); + } +} + +/** + * @brief Positive test case of bt_device_unset_service_searched_cb() + */ +static void utc_network_bluetooth_service_search_unset_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_device_unset_service_searched_cb(); + dts_check_eq("bt_device_unset_service_searched_cb", ret, BT_ERROR_NONE, + "bt_device_set_service_searched_cb() failed."); +} diff --git a/TC/testcase/utc_network_bluetooth_socket_negative.c b/TC/testcase/utc_network_bluetooth_socket_negative.c new file mode 100644 index 0000000..9e3f490 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_socket_negative.c @@ -0,0 +1,266 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <tet_api.h> +#include <bluetooth.h> +#include <stdlib.h> +#include <stdbool.h> +#include <glib.h> + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_socket_set_data_received_cb_n(void); +static void utc_network_bluetooth_socket_set_connection_state_changed_cb_n(void); +static void utc_network_bluetooth_socket_unset_data_received_cb_n(void); +static void utc_network_bluetooth_socket_unset_connection_state_changed_cb_n(void); +static void utc_network_bluetooth_socket_create_rfcomm_n(void); +static void utc_network_bluetooth_socket_destroy_rfcomm_n(void); +static void utc_network_bluetooth_socket_listen_and_accept_rfcomm_n(void); +static void utc_network_bluetooth_socket_connect_rfcomm_n(void); +static void utc_network_bluetooth_socket_disconnect_rfcomm_n(void); +static void utc_network_bluetooth_socket_send_data_n(void); + +void adapter_state_changed_cb_for_device_negative(int result, + bt_adapter_state_e adapter_state, + void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_socket_set_data_received_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_socket_set_connection_state_changed_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_socket_create_rfcomm_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_socket_destroy_rfcomm_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_socket_listen_and_accept_rfcomm_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_socket_connect_rfcomm_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_socket_disconnect_rfcomm_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_socket_send_data_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_socket_unset_data_received_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_socket_unset_connection_state_changed_cb_n, NEGATIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_device_negative, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +/** + * @brief Callback funtions + */ +void adapter_state_changed_cb_for_device_negative(int result, + bt_adapter_state_e adapter_state, + void *user_data) +{ + tet_printf("Callback: bt_adapter_state_changed_cb was called."); + if (user_data != NULL && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_DISABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was disabled. DTS will be started."); + } else { + tet_printf("Callback: BT was not disabled. DTS will be started but DTS may fail."); + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } + } +} + +/** + * @brief Negative test case of bt_socket_set_data_received_cb() + */ +static void utc_network_bluetooth_socket_set_data_received_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_socket_set_data_received_cb(NULL, NULL); + dts_check_eq("bt_socket_set_data_received_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL"); +} + +/** + * @brief Negative test case of bt_socket_set_connection_state_changed_cb() + */ +static void utc_network_bluetooth_socket_set_connection_state_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_socket_set_connection_state_changed_cb(NULL, NULL); + dts_check_eq("bt_socket_set_connection_state_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL"); +} + +/** + * @brief Negative test case of bt_socket_unset_data_received_cb() + */ +static void utc_network_bluetooth_socket_unset_data_received_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + if (bt_deinitialize() != BT_ERROR_NONE) { + dts_fail("bt_socket_unset_data_received_cb", + "bt_deinitialize() failed."); + } + + ret = bt_socket_unset_data_received_cb(); + dts_check_eq("bt_socket_unset_data_received_cb", ret, + BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized."); +} + +/** + * @brief Negative test case of bt_socket_unset_connection_state_changed_cb() + */ +static void utc_network_bluetooth_socket_unset_connection_state_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_socket_unset_connection_state_changed_cb(); + dts_check_eq("bt_socket_unset_connection_state_changed_cb", ret, + BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized."); +} + +/** + * @brief Negative test case of bt_socket_create_rfcomm() + */ +static void utc_network_bluetooth_socket_create_rfcomm_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_socket_create_rfcomm(NULL, NULL); + dts_check_eq("bt_socket_create_rfcomm", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when port_uuid parameter is NULL"); +} + +/** + * @brief Negative test case of bt_socket_destroy_rfcomm() + */ +static void utc_network_bluetooth_socket_destroy_rfcomm_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_socket_destroy_rfcomm(-1); + dts_check_eq("bt_socket_listen_and_accept_rfcomm", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when socket_fd is below 0"); +} + +/** + * @brief Negative test case of bt_socket_listen_and_accept_rfcomm() + */ +static void utc_network_bluetooth_socket_listen_and_accept_rfcomm_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_socket_listen_and_accept_rfcomm(1, 1); + dts_check_eq("bt_socket_listen_and_accept_rfcomm", ret, + BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled"); +} + +/** + * @brief Negative test case of bt_socket_connect_rfcomm() + */ +static void utc_network_bluetooth_socket_connect_rfcomm_n(void) +{ + int ret = BT_ERROR_NONE; + char *address = ""; + char *uuid = ""; + + ret = bt_socket_connect_rfcomm(address, uuid); + dts_check_eq("bt_socket_connect_rfcomm", ret, BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled"); +} + +/** + * @brief Negative test case of bt_socket_disconnect_rfcomm() + */ +static void utc_network_bluetooth_socket_disconnect_rfcomm_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_socket_disconnect_rfcomm(-1); + dts_check_eq("bt_socket_disconnect_rfcomm", ret, BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled"); +} + +/** + * @brief Negative test case of bt_socket_send_data() + */ +static void utc_network_bluetooth_socket_send_data_n(void) +{ + int ret = BT_ERROR_NONE; + char *data = "dts_test"; + + ret = bt_socket_send_data(1, data, sizeof(data)); + dts_check_eq("bt_socket_send_data", ret, BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled"); +} diff --git a/TC/testcase/utc_network_bluetooth_socket_positive.c b/TC/testcase/utc_network_bluetooth_socket_positive.c new file mode 100644 index 0000000..5754b4f --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_socket_positive.c @@ -0,0 +1,440 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <tet_api.h> +#include <bluetooth.h> +#include <stdlib.h> +#include <stdbool.h> +#include <glib.h> +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +const char target_name[128] = "dts_test"; +const char *rfcomm_test_uuid_spp = "00001101-0000-1000-8000-00805F9B34FB"; +char target_address[18] = ""; +int socket_fd = 0; +bool callback_result = false; +bool discovery_result = false; +bool bonding_result = false; +bool is_connecting = false; +static GMainLoop *mainloop; + +static void utc_network_bluetooth_socket_set_data_received_cb_p(void); +static void utc_network_bluetooth_socket_set_connection_state_changed_cb_p(void); + +static void utc_network_bluetooth_socket_create_rfcomm_p(void); +static void utc_network_bluetooth_socket_destroy_rfcomm_p(void); +static void utc_network_bluetooth_socket_listen_and_accept_rfcomm_p(void); +static void utc_network_bluetooth_socket_connect_rfcomm_p(void); +static void utc_network_bluetooth_socket_disconnect_rfcomm_p(void); +static void utc_network_bluetooth_socket_send_data_p(void); +static void utc_network_bluetooth_socket_unset_data_received_cb_p(void); +static void utc_network_bluetooth_socket_unset_connection_state_changed_cb_p(void); + +gboolean timeout_func(gpointer data); +void adapter_state_changed_cb_for_socket_p(int result, + bt_adapter_state_e adapter_state, + void *user_data); +void device_discovery_state_changed_cb_for_socket_p(int result, + bt_adapter_device_discovery_state_e discovery_state, + bt_adapter_device_discovery_info_s *discovery_info, + void *user_data); +void device_bonded_cb_for_socket_p(int result, bt_device_info_s *device_info, + void *user_data); +void socket_data_received_cb_for_socket_p(bt_socket_received_data_s *data, + void *user_data); +void socket_connection_state_changed_cb_for_socket_p(int result, + bt_socket_connection_state_e connection_state, + bt_socket_connection_s *connection, + void *user_data); +void device_unbonded_cb(int result, char *remote_address, void *user_data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_socket_set_connection_state_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_socket_set_data_received_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_socket_create_rfcomm_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_socket_listen_and_accept_rfcomm_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_socket_destroy_rfcomm_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_socket_connect_rfcomm_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_socket_send_data_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_socket_disconnect_rfcomm_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_socket_unset_data_received_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_socket_unset_connection_state_changed_cb_p, POSITIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + bt_error_e ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + tet_printf("TC start."); + callback_result = false; + discovery_result = false; + bonding_result = false; + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_socket_p, "startup") != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + if (bt_adapter_set_device_discovery_state_changed_cb(device_discovery_state_changed_cb_for_socket_p, "startup") != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_device_discovery_state_changed_cb() failed."); + } + + if (bt_device_set_bond_created_cb(device_bonded_cb_for_socket_p, "startup") != BT_ERROR_NONE) { + tet_printf("bt_device_set_bond_created_cb() failed."); + } + + ret = bt_adapter_enable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_enable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + + tet_printf("BT was enabled. Device discovery will be started"); + if (bt_adapter_start_device_discovery() == BT_ERROR_NONE) { + tet_printf("bt_adapter_start_device_discovery() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else { + tet_printf("bt_adapter_start_device_discovery() failed."); + } + } else if (ret == BT_ERROR_ALREADY_DONE) { + tet_printf("BT was already enabled. Device discovery will be started"); + if (bt_adapter_start_device_discovery() == BT_ERROR_NONE) { + tet_printf("bt_adapter_start_device_discovery() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else { + tet_printf("bt_adapter_start_device_discovery() failed."); + } + } else { + tet_printf("DTS may fail because bt_adapter_enable() failed."); + } + + if (discovery_result == true && bt_device_create_bond(target_address) == BT_ERROR_NONE) { + tet_printf("bt_device_create_bond() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else { + tet_printf("bt_device_create_bond() failed."); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_unset_state_changed_cb() failed."); + } + + if (bt_adapter_unset_device_discovery_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_unset_device_discovery_state_changed_cb() failed."); + } + + if (bt_device_unset_bond_created_cb() != BT_ERROR_NONE) { + tet_printf("bt_device_unset_bond_created_cb() failed."); + } + +} + +static void cleanup(void) +{ + /* end of TC */ + int timeout_id = 0; + + /* Destroy a bond */ + bt_device_set_bond_destroyed_cb(device_unbonded_cb, NULL); + if (bt_device_destroy_bond(target_address) == BT_ERROR_NONE) { + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } + + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("[%s] Callback: Timeout.", __FUNCTION__); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +/** + * @brief Callback funtions + */ +void device_unbonded_cb(int result, char *remote_address, void *user_data) +{ + tet_printf("Callback: bt_device_bond_destroyed_cb() was called."); + + if (mainloop) { + g_main_loop_quit(mainloop); + } + +} + +void adapter_state_changed_cb_for_socket_p(int result, + bt_adapter_state_e adapter_state, + void *user_data) +{ + if (user_data != NULL && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_ENABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was enabled."); + bt_adapter_start_device_discovery(); + } else { + tet_printf("Callback: BT was not enabled. DTS will be started but DTS may fail."); + if (mainloop) { + g_main_loop_quit(mainloop); + } + } + } +} + +void device_discovery_state_changed_cb_for_socket_p(int result, + bt_adapter_device_discovery_state_e discovery_state, + bt_adapter_device_discovery_info_s *discovery_info, + void *user_data) +{ + tet_printf("Callback: bt_adapter_device_discovery_state_changed_cb() was called"); + if (user_data != NULL && !strcmp((char *)user_data, "startup")) { + if (discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FINISHED) { + tet_printf("Callback: Device discovery finished. DTS will be started."); + if (mainloop) { + g_main_loop_quit(mainloop); + } + } else if (discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FOUND) { + tet_printf("Callback: Devices were founded (%s)", discovery_info->remote_name); + if (discovery_info->remote_name != NULL && !strcmp(discovery_info->remote_name, target_name)) { + discovery_result = true; + tet_printf("Callback: dts_test device was found."); + strncpy(target_address, discovery_info->remote_address, 18); + tet_printf("Callback: device address: %s", discovery_info->remote_address); + if (bt_adapter_stop_device_discovery() == BT_ERROR_NONE) { + tet_printf("Callback: Device discovery will be stopped"); + } + } + } + } +} + +void device_bonded_cb_for_socket_p(int result, bt_device_info_s *device_info, + void *user_data) +{ + if (user_data != NULL && !strcmp((char *)user_data, "startup")) { + if (device_info->remote_address != NULL && !strcmp(device_info->remote_address, target_address)) { + if (result == BT_ERROR_NONE) { + tet_printf("Callback: Bonding succeeded"); + bonding_result = true; + } else { + tet_printf("Callback: Bonding failed"); + } + } + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } +} + +void socket_data_received_cb_for_socket_p(bt_socket_received_data_s *data, + void *user_data) +{ +} + +void socket_connection_state_changed_cb_for_socket_p(int result, + bt_socket_connection_state_e connection_state, + bt_socket_connection_s *connection, + void *user_data) +{ + tet_printf("Callback: bt_socket_connection_state_changed_cb() was called"); + if (connection_state == BT_SOCKET_CONNECTED) + tet_printf("Callback: Connected"); + else + tet_printf("Callback: Disconnected"); + + if (connection_state == BT_SOCKET_CONNECTED) { + tet_printf("Callback: [BT_SOCKET_CONNECTED] result = %d", result); + if (result == BT_ERROR_NONE && is_connecting == true) { + callback_result = true; + socket_fd = connection->socket_fd; + tet_printf("Callback: socket_fd = %d", socket_fd); + + if (mainloop) { + g_main_loop_quit(mainloop); + } + } + } else if (connection_state == BT_SOCKET_DISCONNECTED) { + tet_printf("Callback: [BT_SOCKET_DISCONNECTED] result = %d", result); + if (result == BT_ERROR_NONE && is_connecting == false) { + callback_result = true; + socket_fd = connection->socket_fd; + tet_printf("Callback: socket_fd = %d", socket_fd); + + if (mainloop) { + g_main_loop_quit(mainloop); + } + } + } +} + +/** + * @brief Positive test case of bt_socket_set_data_received_cb() + */ +static void utc_network_bluetooth_socket_set_data_received_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_socket_set_data_received_cb(socket_data_received_cb_for_socket_p, NULL); + dts_check_eq("bt_socket_set_data_received_cb", ret, BT_ERROR_NONE, + "bt_socket_set_data_received_cb() failed."); +} + +/** + * @brief Positive test case of bt_socket_set_connection_state_changed_cb() + */ +static void utc_network_bluetooth_socket_set_connection_state_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_socket_set_connection_state_changed_cb(socket_connection_state_changed_cb_for_socket_p, NULL); + dts_check_eq("bt_socket_set_connection_state_changed_cb", ret, + BT_ERROR_NONE, + "bt_socket_set_connection_state_changed_cb() failed."); +} + +/** + * @brief Positive test case of bt_socket_create_rfcomm() + */ +static void utc_network_bluetooth_socket_create_rfcomm_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_socket_create_rfcomm(rfcomm_test_uuid_spp, &socket_fd); + dts_check_eq("bt_socket_create_rfcomm", ret, BT_ERROR_NONE, + "bt_socket_create_rfcomm() failed."); +} + +/** + * @brief Positive test case of bt_socket_listen_and_accept_rfcomm() + */ +static void utc_network_bluetooth_socket_listen_and_accept_rfcomm_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_socket_listen_and_accept_rfcomm(socket_fd, 1); + dts_check_eq("bt_socket_listen_and_accept_rfcomm", ret, BT_ERROR_NONE, + "bt_socket_listen_and_accept_rfcomm() failed."); +} + +/** + * @brief Positive test case of bt_socket_destroy_rfcomm() + */ +static void utc_network_bluetooth_socket_destroy_rfcomm_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_socket_destroy_rfcomm(socket_fd); + dts_check_eq("bt_socket_destroy_rfcomm", ret, BT_ERROR_NONE, + "bt_socket_destroy_rfcomm() failed."); +} + +/** + * @brief Positive test case of bt_socket_connect_rfcomm() + */ +static void utc_network_bluetooth_socket_connect_rfcomm_p(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + is_connecting = true; + callback_result = false; + ret = bt_socket_connect_rfcomm(target_address, rfcomm_test_uuid_spp); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_socket_connect_rfcomm() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else { + dts_fail("bt_socket_connect_rfcomm", + "bt_socket_connect_rfcomm() failed"); + } + dts_check_eq("bt_socket_connect_rfcomm", callback_result, true, + "connecting failed."); +} + +/** + * @brief Positive test case of bt_socket_disconnect_rfcomm() + */ +static void utc_network_bluetooth_socket_disconnect_rfcomm_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_socket_disconnect_rfcomm(socket_fd); + dts_check_eq("bt_socket_disconnect_rfcomm", ret, BT_ERROR_NONE, + "bt_socket_disconnect_rfcomm() failed."); +} + +/** + * @brief Positive test case of bt_socket_send_data() + */ +static void utc_network_bluetooth_socket_send_data_p(void) +{ + int ret = BT_ERROR_NONE; + char *dts_test = "dts_test"; + + ret = bt_socket_send_data(socket_fd, "dts_test", sizeof(dts_test)); + dts_check_eq("bt_socket_send_data", ret, BT_ERROR_NONE, + "bt_socket_send_data() failed."); +} + +/** + * @brief Positive test case of bt_socket_unset_data_received_cb() + */ +static void utc_network_bluetooth_socket_unset_data_received_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_socket_unset_data_received_cb(); + dts_check_eq("bt_socket_unset_data_received_cb", ret, BT_ERROR_NONE, + "bt_socket_unset_data_received_cb() failed."); +} + +/** + * @brief Positive test case of bt_socket_unset_connection_state_changed_cb() + */ +static void utc_network_bluetooth_socket_unset_connection_state_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_socket_unset_connection_state_changed_cb(); + dts_check_eq("bt_socket_unset_connection_state_changed_cb", ret, + BT_ERROR_NONE, + "bt_socket_unset_connection_state_changed_cb() failed."); +} diff --git a/TC/tet_scen b/TC/tet_scen new file mode 100755 index 0000000..03f029a --- /dev/null +++ b/TC/tet_scen @@ -0,0 +1,7 @@ +all + ^TEST +##### Scenarios for TEST ##### + +# Test scenario +TEST + :include:/testcase/tslist diff --git a/TC/tetbuild.cfg b/TC/tetbuild.cfg new file mode 100644 index 0000000..f7eda55 --- /dev/null +++ b/TC/tetbuild.cfg @@ -0,0 +1,5 @@ +TET_OUTPUT_CAPTURE=True # capture option for build operation checking +TET_BUILD_TOOL=make # build with using make command +TET_BUILD_FILE=-f Makefile # execution file (Makefile) for build +TET_API_COMPLIANT=True # use TET API in Test Case ? +TET_PASS_TC_NAME=True # report passed TC name in Journal file? diff --git a/TC/tetclean.cfg b/TC/tetclean.cfg new file mode 100644 index 0000000..02d7030 --- /dev/null +++ b/TC/tetclean.cfg @@ -0,0 +1,5 @@ +TET_OUTPUT_CAPTURE=True # capture option +TET_CLEAN_TOOL= make clean # clean tool +TET_CLEAN_FILE= Makefile # file for clean +TET_API_COMPLIANT=True # TET API useage +TET_PASS_TC_NAME=True # showing name , passed TC diff --git a/TC/tetexec.cfg b/TC/tetexec.cfg new file mode 100644 index 0000000..ef3e452 --- /dev/null +++ b/TC/tetexec.cfg @@ -0,0 +1,5 @@ +TET_OUTPUT_CAPTURE=True # capturing execution or not +TET_EXEC_TOOL= # ex) exec : execution tool set up/ Optional +TET_EXEC_FILE= # ex) exectool : execution file/ Optional +TET_API_COMPLIANT=True # Test case or Tool usesTET API? +TET_PASS_TC_NAME=True # showing Passed TC name ? diff --git a/debian/changelog b/debian/changelog index 10dff27..62c177c 100644 --- a/debian/changelog +++ b/debian/changelog @@ -1,35 +1,3 @@ -capi-network-bluetooth (0.1.40-1) unstable; urgency=low - - * Implement bt_reset_adapter API - * Git: magnolia/framework/api/bluetooth - * Tag: capi-network-bluetooth_0.1.40-1 - - -- DoHyun Pyun <dh79.pyun@samsung.com> Mon, 04 Feb 2013 14:20:28 +0900 - -capi-network-bluetooth (0.1.39-1) unstable; urgency=low - - * Implement bt_reset_adapter API - * Git: magnolia/framework/api/bluetooth - * Tag: capi-network-bluetooth_0.1.39-1 - - -- DoHyun Pyun <dh79.pyun@samsung.com> Sat, 02 Feb 2013 13:42:02 +0900 - -capi-network-bluetooth (0.1.38-1) unstable; urgency=low - - * Implement bluetooth_nap_disconnect_all API - * Git: magnolia/framework/api/bluetooth - * Tag: capi-network-bluetooth_0.1.38-1 - - -- DoHyun Pyun <dh79.pyun@samsung.com> Mon, 21 Jan 2013 18:33:37 +0900 - -capi-network-bluetooth (0.1.37-1) unstable; urgency=low - - * Implement GATT API's and Prevent defect fix - * Git: magnolia/framework/api/bluetooth - * Tag: capi-network-bluetooth_0.1.37-1 - - -- Chethan T N <chethan.tn@samsung.com> Tue, 15 Jan 2013 18:16:50 +0530 - capi-network-bluetooth (0.1.36-1) unstable; urgency=low * Implement AVRCP callback functions diff --git a/include/bluetooth.h b/include/bluetooth.h index c286178..cf86c88 100644 --- a/include/bluetooth.h +++ b/include/bluetooth.h @@ -75,6 +75,7 @@ typedef enum BT_ERROR_REMOTE_DEVICE_NOT_FOUND = TIZEN_ERROR_NETWORK_CLASS|0x0109, /**< Remote device not found */ BT_ERROR_SERVICE_SEARCH_FAILED = TIZEN_ERROR_NETWORK_CLASS|0x010A, /**< Service search failed */ BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED = TIZEN_ERROR_NETWORK_CLASS|0x010B, /**< Remote device is not connected */ + BT_ERROR_PERMISSION_DENIED = TIZEN_ERROR_NETWORK_CLASS|0x010C, /**< Permission denied */ } bt_error_e; /** @@ -111,6 +112,13 @@ typedef enum BT_ADAPTER_DEVICE_DISCOVERY_FOUND, /**< The remote Bluetooth device is found */ } bt_adapter_device_discovery_state_e; +typedef enum +{ + BT_ADAPTER_DEVICE_DISCOVERY_BREDR = 0x01, /**< Device discovery for BREDR devices only */ + BT_ADAPTER_DEVICE_DISCOVERY_LE, /**< Device discovery for LE devices only */ + BT_ADAPTER_DEVICE_DISCOVERY_LE_BREDR, /**< Device discovery for both LE and BREDR devices */ +} bt_adapter_discover_devices_type_e; + /** * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE * @brief Enumerations of device authorization state. @@ -993,6 +1001,40 @@ int bt_adapter_set_visibility(bt_adapter_visibility_mode_e discoverable_mode, in /** * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE + * @brief Starts the device discovery for a particular type, asynchronously. The various + * supporting discovery types are BT_ADAPTER_DEVICE_DISCOVERY_BREDR, BT_ADAPTER_DEVICE_DISCOVERY_LE + * and BT_ADAPTER_DEVICE_DISCOVERY_LE_BREDR. + * + * @details If a device is discovered for a particular type, bt_adapter_device_discovery_state_changed_cb() +* will be invoked with #BT_ADAPTER_DEVICE_DISCOVERY_FOUND, and then bt_adapter_device_discovery_state_changed_cb() + * will be called with #BT_ADAPTER_DEVICE_DISCOVERY_FINISHED in case of the completion or cancellation of the discovery. + * + * @remarks To connect to peer Bluetooth device, you need to know its Bluetooth address. \n + * The device discovery can be stopped by bt_adapter_stop_device_discovery(). This API is similar to + * bt_adapter_start_device_discovery() but here we can specify the device type to be discovered which + * could makes the discovery procedure faster. + * + * @return 0 on success, otherwise a negative error value. + * @retval #BT_ERROR_NONE Successful + * @retval #BT_ERROR_NOT_INITIALIZED Not initialized + * @retval #BT_ERROR_NOT_ENABLED Not enabled + * @retval #BT_ERROR_NOW_IN_PROGRESS Operation is now in progress + * @retval #BT_ERROR_OPERATION_FAILED Operation failed + * + * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable(). + * @post This function invokes bt_adapter_device_discovery_state_changed_cb(). + * + * @see bt_adapter_enable() + * @see bt_adapter_is_discovering() + * @see bt_adapter_stop_device_discovery() + * @see bt_adapter_device_discovery_state_changed_cb() + * @see bt_adapter_set_device_discovery_state_changed_cb() + * @see bt_adapter_unset_device_discovery_state_changed_cb() + */ +int bt_adapter_start_discover_devices(bt_adapter_discover_devices_type_e type); + +/** + * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE * @brief Starts the device discovery, asynchronously. * * @details If a device is discovered, bt_adapter_device_discovery_state_changed_cb() will be invoked diff --git a/include/bluetooth_private.h b/include/bluetooth_private.h index c55a8fe..11731cf 100644 --- a/include/bluetooth_private.h +++ b/include/bluetooth_private.h @@ -84,8 +84,12 @@ typedef enum BT_EVENT_AVRCP_SCAN_MODE_CHANGED, /**< AVRCP scan mode change callback */ BT_EVENT_HID_CONNECTION_STATUS, /**< HID connection status callback */ BT_EVENT_DEVICE_CONNECTION_STATUS, /**< Device connection status callback */ + BT_EVENT_GATT_CONNECTION_STATUS, /** < GATT connection status callback */ + BT_EVENT_GATT_RSSI_VALUE, /** < RSSI value for remote device */ BT_EVENT_GATT_CHARACTERISTIC_DISCOVERED, /**< GATT characteristic discovered callback */ BT_EVENT_GATT_VALUE_CHANGED, /**< GATT characteristic value changed callback */ + BT_EVENT_GATT_READ_CHARACTERISTIC, /**< GATT characteristic value read callback */ + BT_EVENT_GATT_WRITE_CHARACTERISTIC, /**< GATT characteristic value read callback */ } bt_event_e; /** diff --git a/src/bluetooth-adapter.c b/src/bluetooth-adapter.c index 46c2947..ba125ce 100644 --- a/src/bluetooth-adapter.c +++ b/src/bluetooth-adapter.c @@ -243,6 +243,7 @@ int bt_adapter_foreach_bonded_device(bt_adapter_bonded_device_cb foreach_cb, voi } if (dev_list != NULL) { + g_ptr_array_foreach(dev_list, (GFunc)g_free, NULL); g_ptr_array_free(dev_list, TRUE); } @@ -428,6 +429,19 @@ int bt_adapter_start_device_discovery(void) return error_code; } +int bt_adapter_start_discover_devices(bt_adapter_discover_devices_type_e type) +{ + int error_code = BT_ERROR_NONE; + + BT_CHECK_INIT_STATUS(); + error_code = _bt_get_error_code(bluetooth_start_custom_discovery(type, + 0, 0, BLUETOOTH_DEVICE_MAJOR_MASK_MISC)); + if (error_code != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); + } + return error_code; +} + int bt_adapter_stop_device_discovery(void) { int error_code = BT_ERROR_NONE; diff --git a/src/bluetooth-common.c b/src/bluetooth-common.c index 67a6cc1..7d01ba3 100644 --- a/src/bluetooth-common.c +++ b/src/bluetooth-common.c @@ -68,7 +68,9 @@ static bt_event_sig_event_slot_s bt_event_slot_container[] = { {BT_EVENT_HID_CONNECTION_STATUS, NULL, NULL}, {BT_EVENT_DEVICE_CONNECTION_STATUS, NULL, NULL}, {BT_EVENT_GATT_CHARACTERISTIC_DISCOVERED, NULL, NULL}, - {BT_EVENT_GATT_VALUE_CHANGED, NULL, NULL} + {BT_EVENT_GATT_VALUE_CHANGED, NULL, NULL}, + {BT_EVENT_GATT_READ_CHARACTERISTIC, NULL, NULL}, + {BT_EVENT_GATT_WRITE_CHARACTERISTIC, NULL, NULL} }; /* @@ -184,6 +186,8 @@ int _bt_get_error_code(int origin_error) return BT_ERROR_REMOTE_DEVICE_NOT_FOUND; case BLUETOOTH_ERROR_SERVICE_SEARCH_ERROR: return BT_ERROR_SERVICE_SEARCH_FAILED; + case BLUETOOTH_ERROR_PERMISSION_DEINED : + return BT_ERROR_PERMISSION_DENIED; case BLUETOOTH_ERROR_SERVICE_NOT_FOUND: case BLUETOOTH_ERROR_PARING_FAILED: case BLUETOOTH_ERROR_MAX_CONNECTION: @@ -526,6 +530,7 @@ static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *us (_bt_get_error_code(param->result), BT_ADAPTER_DEVICE_DISCOVERY_FINISHED, NULL, bt_event_slot_container[event_index].user_data); break; case BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED: + case BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND: BT_INFO("bt_adapter_device_discovery_state_changed_cb() will be called with BT_ADAPTER_DEVICE_DISCOVERY_FOUND"); if (__bt_get_bt_adapter_device_discovery_info_s(&discovery_info, (bluetooth_device_info_t *)(param->param_data)) == BT_ERROR_NONE) { ((bt_adapter_device_discovery_state_changed_cb)bt_event_slot_container[event_index].callback) @@ -1062,7 +1067,11 @@ static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *us bt_event_slot_container[event_index].user_data); break; + case BLUETOOTH_EVENT_GATT_READ_CHAR: + BT_INFO("BLUETOOTH_EVENT_GATT_READ_CHAR"); + break; default: + BT_INFO("__bt_event_proxy default case %d",event); break; } } @@ -1161,6 +1170,11 @@ static int __bt_get_cb_index(int event) case BLUETOOTH_EVENT_DEVICE_CONNECTED: case BLUETOOTH_EVENT_DEVICE_DISCONNECTED: return BT_EVENT_DEVICE_CONNECTION_STATUS; + case BLUETOOTH_EVENT_GATT_CONNECTED: + case BLUETOOTH_EVENT_GATT_DISCONNECTED: + return BT_EVENT_GATT_CONNECTION_STATUS; + case BLUETOOTH_EVENT_GATT_RSSI: + return BT_EVENT_GATT_RSSI_VALUE; case BLUETOOTH_EVENT_SERVICE_SEARCHED: return BT_EVENT_SERVICE_SEARCHED; case BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED: @@ -1252,6 +1266,10 @@ static int __bt_get_cb_index(int event) return BT_EVENT_GATT_CHARACTERISTIC_DISCOVERED; case BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED: return BT_EVENT_GATT_VALUE_CHANGED; + case BLUETOOTH_EVENT_GATT_READ_CHAR: + return BT_EVENT_GATT_READ_CHARACTERISTIC; + case BLUETOOTH_EVENT_GATT_WRITE_CHAR: + return BT_EVENT_GATT_WRITE_CHARACTERISTIC; default: return -1; } diff --git a/src/bluetooth-device.c b/src/bluetooth-device.c index 442f0b9..85c6a9a 100644 --- a/src/bluetooth-device.c +++ b/src/bluetooth-device.c @@ -255,3 +255,20 @@ int bt_device_unset_connection_state_changed_cb(void) return BT_ERROR_NONE; } +int bt_device_read_rssi_value(const char *address) +{ + int ret; + bluetooth_device_address_t bd_addr = { {0,} }; + + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(address); + + _bt_convert_address_to_hex(&bd_addr, address); + + ret = _bt_get_error_code(bluetooth_read_rssi(&bd_addr)); + + if (ret != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + } + return ret; +} diff --git a/src/bluetooth-gatt.c b/src/bluetooth-gatt.c index b159fb0..19315c4 100644 --- a/src/bluetooth-gatt.c +++ b/src/bluetooth-gatt.c @@ -211,7 +211,7 @@ int bt_gatt_get_characteristic_declaration(bt_gatt_attribute_h characteristic, BT_CHECK_INIT_STATUS(); BT_CHECK_INPUT_PARAMETER(characteristic); - memset(&property, 0x00, sizeof(bt_gatt_service_property_t)); + memset(&property, 0x00, sizeof(bt_gatt_char_property_t)); ret = _bt_get_error_code(bluetooth_gatt_get_characteristics_property((const char *)characteristic, &property)); @@ -250,7 +250,7 @@ int bt_gatt_set_characteristic_value(bt_gatt_attribute_h characteristic, return BT_ERROR_INVALID_PARAMETER; ret = _bt_get_error_code(bluetooth_gatt_set_characteristics_value((const char *)characteristic, - (const guint8 *)value, value_length)); + (const guint8 *)value, value_length, 0)); if (ret != BT_ERROR_NONE) { BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); diff --git a/src/bluetooth-pan.c b/src/bluetooth-pan.c index eb27268..740b429 100644 --- a/src/bluetooth-pan.c +++ b/src/bluetooth-pan.c @@ -70,6 +70,23 @@ int bt_nap_disconnect_all(void) return error; } +int bt_nap_disconnect(const char *remote_address) +{ + int error = BT_ERROR_INVALID_PARAMETER; + bluetooth_device_address_t addr_hex = { {0,} }; + + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(remote_address); + _bt_convert_address_to_hex(&addr_hex, remote_address); + error = bluetooth_network_server_disconnect(&addr_hex); + error = _bt_get_error_code(error); + if (error != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), + error); + } + return error; +} + int bt_nap_set_connection_state_changed_cb( bt_nap_connection_state_changed_cb callback, void *user_data) diff --git a/test/bt_unit_test.c b/test/bt_unit_test.c index ff02085..8b3ce00 100644 --- a/test/bt_unit_test.c +++ b/test/bt_unit_test.c @@ -32,6 +32,7 @@ #define PRT(format, args...) printf("%s:%d() "format, __FUNCTION__, __LINE__, ##args) #define TC_PRT(format, args...) PRT(format"\n", ##args) +#define DEVICE_ADDRESS "F6:FB:8F:D8:C8:7C" const char *spp_uuid = "00001101-0000-1000-8000-00805F9B34FB"; const char *opp_uuid = "00001105-0000-1000-8000-00805f9b34fb"; @@ -76,6 +77,10 @@ tc_table_t tc_table[] = { {"bt_adapter_get_local_oob_data" , 14}, {"bt_adapter_set_remote_oob_data" , 15}, {"bt_adapter_remove_remote_oob_data" , 16}, + {"bt_adapter_start_discover_devices" , 17}, + {"bt_adapter_set_visibility_mode_changed_cb" , 18}, + {"bt_adapter_unset_visibility_mode_changed_cb" , 19}, + /* Socket functions */ {"bt_socket_create_rfcomm" , 50}, @@ -85,7 +90,7 @@ tc_table_t tc_table[] = { {"bt_socket_accept" , 54}, {"bt_socket_reject" , 55}, {"bt_socket_connect_rfcomm" , 56}, - {"bt_socket_disconnect_rfcomm" , 57}, + {"bt_socket_disconnect_rfcomm" , 57}, {"bt_socket_send_data" , 58}, {"bt_socket_set_data_received_cb" , 59}, {"bt_socket_unset_data_received_cb" , 60}, @@ -140,6 +145,8 @@ tc_table_t tc_table[] = { {"bt_device_set_connection_state_changed_cb" , 124}, {"bt_device_unset_connection_state_changed_cb" , 125}, {"bt_device_foreach_connected_profiles" , 126}, + {"bt_device_set_bond_created_cb" , 127}, + {"bt_device_create_bond" , 128}, /* Gatt functions */ {"bt_gatt_foreach_primary_services" , 140}, @@ -221,6 +228,13 @@ static void __bt_free_gatt_characteristics_services(void) char_service_index = 0; } +static void __bt_adapter_device_visibility_mode_changed_cb(int result, + bt_adapter_visibility_mode_e visibility_mode, + void *user_data) +{ + TC_PRT("visibility_mode: %d", visibility_mode); +} + static void __bt_adapter_device_discovery_state_changed_cb(int result, bt_adapter_device_discovery_state_e discovery_state, @@ -358,6 +372,26 @@ bool __bt_device_connected_profile(bt_profile_e profile, void *user_data) return true; } +void __bt_device_bond_created_cb(int result, bt_device_info_s *device_info, void *user_data) +{ + if(result == BT_ERROR_NONE) + { + TC_PRT("Callback: A bond with chat_server is created."); + TC_PRT("Callback: The number of service - %d.", device_info->service_count); + + int i = 0; + for(i=0; i<device_info->service_count; i++) + { + TC_PRT("Callback: service[%d] - %s", i+1, device_info->service_uuid[i]); + } + TC_PRT("Callback: is_bonded - %d.", device_info->is_bonded); + TC_PRT("Callback: is_connected - %d.", device_info->is_connected); + } + else + { + TC_PRT("Callback: Creating a bond is failed."); + } +} bool __bt_gatt_primary_service_cb(bt_gatt_attribute_h service, void *user_data) { TC_PRT("__bt_gatt_primary_service_cb"); @@ -453,7 +487,7 @@ void __bt_avrcp_scan_mode_changed_cb(bt_avrcp_scan_mode_e scan, void *user_data) int test_input_callback(void *data) { int ret = 0; - int test_id = (int)data; + long test_id = (long)data; switch (test_id) { case 0x00ff: @@ -604,6 +638,25 @@ int test_input_callback(void *data) break; } + case 17: { + ret = bt_adapter_start_discover_devices(BT_ADAPTER_DEVICE_DISCOVERY_BREDR); + if (ret < BT_ERROR_NONE) + TC_PRT("failed with [0x%04x]", ret); + break; + } + + case 18: + ret = bt_adapter_set_visibility_mode_changed_cb(__bt_adapter_device_visibility_mode_changed_cb, NULL); + if (ret < BT_ERROR_NONE) + TC_PRT("failed with [0x%04x]", ret); + break; + case 19: + ret = bt_adapter_unset_visibility_mode_changed_cb(); + if (ret < BT_ERROR_NONE) + TC_PRT("failed with [0x%04x]", ret); + break; + + /* Socket functions */ case 50: { int socket_fd = 0; @@ -1022,6 +1075,27 @@ int test_input_callback(void *data) break; } + case 127 : { + ret = bt_device_set_bond_created_cb(__bt_device_bond_created_cb, + NULL); + if (ret < BT_ERROR_NONE) { + TC_PRT("failed with [0x%04x]", ret); + } + break; + } + + case 128 : { + char *address; + + address = g_strdup(DEVICE_ADDRESS); + + ret = bt_device_create_bond(address); + if (ret < BT_ERROR_NONE) { + TC_PRT("failed with [0x%04x]", ret); + } + break; + } + case 140: { char *address; @@ -1185,7 +1259,6 @@ int test_input_callback(void *data) TC_PRT("failed with [0x%04x]", ret); } break; - default: break; } @@ -1199,8 +1272,8 @@ static gboolean key_event_cb(GIOChannel *chan, { char buf[BUFFER_LEN] = { 0 }; - unsigned int len = 0; - int test_id; + gsize len = 0; + long test_id; memset(buf, 0, sizeof(buf)); |