| // SPDX-License-Identifier: GPL-2.0-or-later |
| /* |
| * |
| * BlueZ - Bluetooth protocol stack for Linux |
| * |
| * Copyright (C) 2014 Intel Corporation. All rights reserved. |
| * |
| * |
| */ |
| |
| #include <sys/socket.h> |
| #include <unistd.h> |
| #include <stdint.h> |
| #include <stdio.h> |
| #include <string.h> |
| |
| #include <glib.h> |
| #include "src/shared/hfp.h" |
| #include "src/shared/tester.h" |
| #include "src/shared/util.h" |
| |
| struct context { |
| guint watch_id; |
| int fd_server; |
| int fd_client; |
| struct hfp_gw *hfp; |
| struct hfp_hf *hfp_hf; |
| const struct test_data *data; |
| unsigned int pdu_offset; |
| }; |
| |
| struct test_pdu { |
| bool valid; |
| uint8_t *data; |
| size_t size; |
| enum hfp_gw_cmd_type type; |
| bool fragmented; |
| }; |
| |
| struct test_data { |
| char *test_name; |
| struct test_pdu *pdu_list; |
| hfp_result_func_t result_func; |
| hfp_response_func_t response_func; |
| hfp_hf_result_func_t hf_result_func; |
| GIOFunc test_handler; |
| }; |
| |
| #define data(args...) ((const unsigned char[]) { args }) |
| |
| #define raw_pdu(args...) \ |
| { \ |
| .valid = true, \ |
| .data = util_memdup(data(args), sizeof(data(args))), \ |
| .size = sizeof(data(args)), \ |
| } |
| |
| #define data_end() \ |
| { \ |
| .valid = false, \ |
| } |
| |
| #define type_pdu(cmd_type, args...) \ |
| { \ |
| .valid = true, \ |
| .data = util_memdup(data(args), sizeof(data(args))), \ |
| .size = sizeof(data(args)), \ |
| .type = cmd_type, \ |
| } |
| |
| #define frg_pdu(args...) \ |
| { \ |
| .valid = true, \ |
| .data = util_memdup(data(args), sizeof(data(args))), \ |
| .size = sizeof(data(args)), \ |
| .fragmented = true, \ |
| } |
| |
| #define define_test(name, function, result_function, args...) \ |
| do { \ |
| const struct test_pdu pdus[] = { \ |
| args, { } \ |
| }; \ |
| static struct test_data data; \ |
| data.test_name = g_strdup(name); \ |
| data.pdu_list = util_memdup(pdus, sizeof(pdus)); \ |
| data.result_func = result_function; \ |
| tester_add(name, &data, NULL, function, NULL); \ |
| data.test_handler = test_handler; \ |
| } while (0) |
| |
| #define define_hf_test(name, function, result_func, response_function, \ |
| args...)\ |
| do { \ |
| const struct test_pdu pdus[] = { \ |
| args, { } \ |
| }; \ |
| static struct test_data data; \ |
| data.test_name = g_strdup(name); \ |
| data.pdu_list = util_memdup(pdus, sizeof(pdus)); \ |
| data.hf_result_func = result_func; \ |
| data.response_func = response_function; \ |
| tester_add(name, &data, NULL, function, NULL); \ |
| data.test_handler = test_hf_handler; \ |
| } while (0) |
| |
| static void test_free(gconstpointer user_data) |
| { |
| const struct test_data *data = user_data; |
| struct test_pdu *pdu; |
| int i; |
| |
| for (i = 0; (pdu = &data->pdu_list[i]) && pdu->valid; i++) |
| g_free(pdu->data); |
| |
| g_free(data->test_name); |
| g_free(data->pdu_list); |
| } |
| |
| static void destroy_context(struct context *context) |
| { |
| if (context->watch_id) |
| g_source_remove(context->watch_id); |
| |
| test_free(context->data); |
| |
| if (context->hfp) |
| hfp_gw_unref(context->hfp); |
| |
| if (context->hfp_hf) |
| hfp_hf_unref(context->hfp_hf); |
| |
| g_free(context); |
| } |
| |
| static gboolean context_quit(gpointer user_data) |
| { |
| struct context *context = user_data; |
| |
| if (context == NULL) |
| return FALSE; |
| |
| destroy_context(context); |
| tester_test_passed(); |
| return FALSE; |
| } |
| |
| static gboolean test_handler(GIOChannel *channel, GIOCondition cond, |
| gpointer user_data) |
| { |
| struct context *context = user_data; |
| const struct test_pdu *pdu; |
| |
| pdu = &context->data->pdu_list[context->pdu_offset++]; |
| |
| g_assert(!pdu->valid); |
| context->watch_id = 0; |
| |
| context_quit(context); |
| |
| return FALSE; |
| } |
| |
| static gboolean send_pdu(gpointer user_data) |
| { |
| struct context *context = user_data; |
| const struct test_pdu *pdu; |
| ssize_t len; |
| |
| pdu = &context->data->pdu_list[context->pdu_offset++]; |
| if (!pdu || !pdu->valid) |
| return FALSE; |
| |
| len = write(context->fd_server, pdu->data, pdu->size); |
| g_assert_cmpint(len, ==, pdu->size); |
| |
| pdu = &context->data->pdu_list[context->pdu_offset]; |
| if (pdu->fragmented) |
| g_idle_add(send_pdu, context); |
| |
| return FALSE; |
| } |
| |
| static gboolean test_hf_handler(GIOChannel *channel, GIOCondition cond, |
| gpointer user_data) |
| { |
| struct context *context = user_data; |
| gchar buf[60]; |
| gsize bytes_read; |
| GError *error = NULL; |
| |
| if (cond & (G_IO_HUP | G_IO_ERR | G_IO_NVAL)) |
| goto done; |
| |
| /* dummy read */ |
| g_io_channel_read_chars(channel, buf, 60, &bytes_read, &error); |
| |
| send_pdu(context); |
| |
| return TRUE; |
| |
| done: |
| context->watch_id = 0; |
| |
| context_quit(context); |
| |
| return FALSE; |
| } |
| |
| static void cmd_handler(const char *command, void *user_data) |
| { |
| struct context *context = user_data; |
| const struct test_pdu *pdu; |
| unsigned int cmd_len = strlen(command); |
| |
| pdu = &context->data->pdu_list[context->pdu_offset++]; |
| |
| g_assert(cmd_len == pdu->size); |
| g_assert(!memcmp(command, pdu->data, cmd_len)); |
| |
| hfp_gw_send_result(context->hfp, HFP_RESULT_ERROR); |
| } |
| |
| static void prefix_handler(struct hfp_context *result, |
| enum hfp_gw_cmd_type type, void *user_data) |
| { |
| struct context *context = user_data; |
| const struct test_pdu *pdu; |
| |
| pdu = &context->data->pdu_list[context->pdu_offset++]; |
| |
| g_assert(type == pdu->type); |
| |
| hfp_gw_send_result(context->hfp, HFP_RESULT_ERROR); |
| } |
| |
| static struct context *create_context(gconstpointer data) |
| { |
| struct context *context = g_new0(struct context, 1); |
| GIOChannel *channel; |
| int err, sv[2]; |
| const struct test_data *d = data; |
| |
| err = socketpair(AF_UNIX, SOCK_SEQPACKET | SOCK_CLOEXEC, 0, sv); |
| g_assert(err == 0); |
| |
| channel = g_io_channel_unix_new(sv[1]); |
| |
| g_io_channel_set_close_on_unref(channel, TRUE); |
| g_io_channel_set_encoding(channel, NULL, NULL); |
| g_io_channel_set_buffered(channel, FALSE); |
| |
| context->watch_id = g_io_add_watch(channel, |
| G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL, |
| d->test_handler, context); |
| |
| g_assert(context->watch_id > 0); |
| |
| g_io_channel_unref(channel); |
| |
| context->fd_server = sv[1]; |
| context->fd_client = sv[0]; |
| context->data = data; |
| |
| return context; |
| } |
| |
| static void test_init(gconstpointer data) |
| { |
| struct context *context = create_context(data); |
| |
| context->hfp = hfp_gw_new(context->fd_client); |
| |
| g_assert(context->hfp); |
| g_assert(hfp_gw_set_close_on_unref(context->hfp, true)); |
| |
| hfp_gw_unref(context->hfp); |
| context->hfp = NULL; |
| |
| context_quit(context); |
| } |
| |
| static void test_command_handler(gconstpointer data) |
| { |
| struct context *context = create_context(data); |
| const struct test_pdu *pdu; |
| ssize_t len; |
| bool ret; |
| |
| context->hfp = hfp_gw_new(context->fd_client); |
| g_assert(context->hfp); |
| |
| pdu = &context->data->pdu_list[context->pdu_offset++]; |
| |
| ret = hfp_gw_set_close_on_unref(context->hfp, true); |
| g_assert(ret); |
| |
| ret = hfp_gw_set_command_handler(context->hfp, cmd_handler, |
| context, NULL); |
| g_assert(ret); |
| |
| len = write(context->fd_server, pdu->data, pdu->size); |
| g_assert_cmpint(len, ==, pdu->size); |
| |
| context_quit(context); |
| } |
| |
| static void test_register(gconstpointer data) |
| { |
| struct context *context = create_context(data); |
| const struct test_pdu *pdu; |
| ssize_t len; |
| bool ret; |
| |
| context->hfp = hfp_gw_new(context->fd_client); |
| g_assert(context->hfp); |
| |
| pdu = &context->data->pdu_list[context->pdu_offset++]; |
| |
| ret = hfp_gw_set_close_on_unref(context->hfp, true); |
| g_assert(ret); |
| |
| if (context->data->result_func) { |
| ret = hfp_gw_register(context->hfp, context->data->result_func, |
| (char *)pdu->data, context, NULL); |
| g_assert(ret); |
| } |
| |
| pdu = &context->data->pdu_list[context->pdu_offset++]; |
| |
| len = write(context->fd_server, pdu->data, pdu->size); |
| g_assert_cmpint(len, ==, pdu->size); |
| |
| context_quit(context); |
| } |
| |
| static void test_fragmented(gconstpointer data) |
| { |
| struct context *context = create_context(data); |
| bool ret; |
| |
| context->hfp = hfp_gw_new(context->fd_client); |
| g_assert(context->hfp); |
| |
| ret = hfp_gw_set_close_on_unref(context->hfp, true); |
| g_assert(ret); |
| |
| g_idle_add(send_pdu, context); |
| } |
| |
| static void test_send_and_close(gconstpointer data) |
| { |
| struct context *context = create_context(data); |
| bool ret; |
| |
| context->hfp = hfp_gw_new(context->fd_client); |
| g_assert(context->hfp); |
| |
| ret = hfp_gw_set_close_on_unref(context->hfp, true); |
| g_assert(ret); |
| |
| send_pdu(context); |
| |
| hfp_gw_unref(context->hfp); |
| context->hfp = NULL; |
| |
| context_quit(context); |
| } |
| |
| static void check_ustring_1(struct hfp_context *result, |
| enum hfp_gw_cmd_type type, void *user_data) |
| { |
| struct context *context = user_data; |
| const struct test_pdu *pdu; |
| unsigned int i = 3, j = 0; |
| char str[10]; |
| |
| pdu = &context->data->pdu_list[context->pdu_offset++]; |
| |
| g_assert(type == pdu->type); |
| |
| g_assert(hfp_context_get_unquoted_string(result, str, sizeof(str))); |
| |
| while (context->data->pdu_list[1].data[i] != '\r') { |
| g_assert(j < sizeof(str)); |
| g_assert(str[j] == context->data->pdu_list[1].data[i]); |
| |
| i++; |
| j++; |
| } |
| |
| g_assert(str[j] == '\0'); |
| |
| hfp_gw_send_result(context->hfp, HFP_RESULT_ERROR); |
| } |
| |
| static void check_ustring_2(struct hfp_context *result, |
| enum hfp_gw_cmd_type type, void *user_data) |
| { |
| struct context *context = user_data; |
| const struct test_pdu *pdu; |
| char str[10]; |
| |
| memset(str, 'X', sizeof(str)); |
| |
| pdu = &context->data->pdu_list[context->pdu_offset++]; |
| |
| g_assert(type == pdu->type); |
| |
| g_assert(!hfp_context_get_unquoted_string(result, str, 3)); |
| |
| g_assert(str[3] == 'X'); |
| |
| hfp_gw_send_result(context->hfp, HFP_RESULT_ERROR); |
| } |
| |
| static void check_string_1(struct hfp_context *result, |
| enum hfp_gw_cmd_type type, void *user_data) |
| { |
| struct context *context = user_data; |
| const struct test_pdu *pdu; |
| unsigned int i = 4, j = 0; |
| char str[10]; |
| |
| pdu = &context->data->pdu_list[context->pdu_offset++]; |
| |
| g_assert(type == pdu->type); |
| |
| g_assert(hfp_context_get_string(result, str, sizeof(str))); |
| |
| while (context->data->pdu_list[1].data[i] != '\"') { |
| g_assert(j < sizeof(str)); |
| g_assert(str[j] == context->data->pdu_list[1].data[i]); |
| |
| i++; |
| j++; |
| } |
| |
| g_assert(context->data->pdu_list[1].data[i] == '\"'); |
| g_assert(str[j] == '\0'); |
| |
| hfp_gw_send_result(context->hfp, HFP_RESULT_ERROR); |
| } |
| |
| static void check_string_2(struct hfp_context *result, |
| enum hfp_gw_cmd_type type, void *user_data) |
| { |
| struct context *context = user_data; |
| const struct test_pdu *pdu; |
| char str[10]; |
| |
| memset(str, 'X', sizeof(str)); |
| |
| pdu = &context->data->pdu_list[context->pdu_offset++]; |
| |
| g_assert(type == pdu->type); |
| |
| g_assert(!hfp_context_get_string(result, str, 3)); |
| |
| g_assert(str[3] == 'X'); |
| |
| hfp_gw_send_result(context->hfp, HFP_RESULT_ERROR); |
| } |
| |
| static void check_string_3(struct hfp_context *result, |
| enum hfp_gw_cmd_type type, void *user_data) |
| { |
| struct context *context = user_data; |
| const struct test_pdu *pdu; |
| |
| pdu = &context->data->pdu_list[context->pdu_offset++]; |
| |
| g_assert(type == pdu->type); |
| |
| hfp_gw_send_result(context->hfp, HFP_RESULT_ERROR); |
| } |
| |
| static void test_hf_init(gconstpointer data) |
| { |
| struct context *context = create_context(data); |
| |
| context->hfp_hf = hfp_hf_new(context->fd_client); |
| g_assert(context->hfp_hf); |
| g_assert(hfp_hf_set_close_on_unref(context->hfp_hf, true)); |
| |
| hfp_hf_unref(context->hfp_hf); |
| context->hfp_hf = NULL; |
| |
| context_quit(context); |
| } |
| |
| static bool unsolicited_resp = false; |
| |
| static void hf_unsolicited_resp_cb(struct hfp_context *context, |
| void *user_data) { |
| unsolicited_resp = true; |
| } |
| |
| static void hf_response_with_data(enum hfp_result res, |
| enum hfp_error cme_err, |
| void *user_data) |
| { |
| struct context *context = user_data; |
| |
| g_assert(unsolicited_resp); |
| unsolicited_resp = false; |
| |
| hfp_hf_disconnect(context->hfp_hf); |
| } |
| |
| static void hf_cme_error_response_cb(enum hfp_result res, |
| enum hfp_error cme_err, |
| void *user_data) |
| { |
| struct context *context = user_data; |
| |
| g_assert_cmpint(res, ==, HFP_RESULT_CME_ERROR); |
| g_assert_cmpint(cme_err, ==, 30); |
| |
| hfp_hf_disconnect(context->hfp_hf); |
| } |
| |
| static void hf_response_cb(enum hfp_result res, enum hfp_error cme_err, |
| void *user_data) |
| { |
| struct context *context = user_data; |
| |
| hfp_hf_disconnect(context->hfp_hf); |
| } |
| |
| static void test_hf_send_command(gconstpointer data) |
| { |
| struct context *context = create_context(data); |
| const struct test_pdu *pdu; |
| bool ret; |
| |
| context->hfp_hf = hfp_hf_new(context->fd_client); |
| g_assert(context->hfp_hf); |
| |
| ret = hfp_hf_set_close_on_unref(context->hfp_hf, true); |
| g_assert(ret); |
| |
| if (context->data->response_func) { |
| if (context->data->hf_result_func) { |
| pdu = &context->data->pdu_list[context->pdu_offset++]; |
| |
| ret = hfp_hf_register(context->hfp_hf, |
| context->data->hf_result_func, |
| (char *)pdu->data, |
| NULL, NULL); |
| g_assert(ret); |
| } |
| |
| pdu = &context->data->pdu_list[context->pdu_offset++]; |
| |
| ret = hfp_hf_send_command(context->hfp_hf, |
| context->data->response_func, |
| context, (char *)pdu->data); |
| g_assert(ret); |
| } |
| |
| context_quit(context); |
| } |
| static void hf_chld_result_handler(struct hfp_context *hf_context, |
| void *user_data) |
| { |
| struct context *context = user_data; |
| char str[3]; |
| |
| g_assert(hf_context); |
| g_assert(hfp_context_get_unquoted_string(hf_context, str, |
| sizeof(str))); |
| g_assert_cmpstr(str, ==, "1"); |
| g_assert(hfp_context_get_unquoted_string(hf_context, str, |
| sizeof(str))); |
| g_assert_cmpstr(str, ==, "2x"); |
| |
| hfp_hf_disconnect(context->hfp_hf); |
| } |
| |
| static void hf_chld_skip_field(struct hfp_context *hf_context, |
| void *user_data) |
| { |
| struct context *context = user_data; |
| char str[3]; |
| |
| g_assert(hf_context); |
| |
| hfp_context_skip_field(hf_context); |
| |
| g_assert(hfp_context_get_unquoted_string(hf_context, str, |
| sizeof(str))); |
| g_assert_cmpstr(str, ==, "2x"); |
| |
| hfp_hf_disconnect(context->hfp_hf); |
| } |
| |
| static void hf_clcc_result_handler(struct hfp_context *hf_context, |
| void *user_data) |
| { |
| struct context *context = user_data; |
| char name[10]; |
| uint32_t val1, val2; |
| |
| g_assert(hf_context); |
| g_assert(hfp_context_open_container(hf_context)); |
| g_assert(hfp_context_get_string(hf_context, name, sizeof(name))); |
| g_assert_cmpstr(name, ==, "call"); |
| g_assert(hfp_context_open_container(hf_context)); |
| g_assert(hfp_context_get_number(hf_context, &val1)); |
| g_assert_cmpint(val1, ==, 0); |
| g_assert(hfp_context_get_number(hf_context, &val1)); |
| g_assert_cmpint(val1, ==, 1); |
| g_assert(hfp_context_close_container(hf_context)); |
| g_assert(hfp_context_close_container(hf_context)); |
| |
| g_assert(hfp_context_open_container(hf_context)); |
| g_assert(hfp_context_get_string(hf_context, name, sizeof(name))); |
| g_assert_cmpstr(name, ==, "callsetup"); |
| g_assert(hfp_context_open_container(hf_context)); |
| g_assert(hfp_context_get_range(hf_context, &val1, &val2)); |
| g_assert_cmpint(val1, ==, 0); |
| g_assert_cmpint(val2, ==, 3); |
| g_assert(hfp_context_close_container(hf_context)); |
| g_assert(hfp_context_close_container(hf_context)); |
| |
| hfp_hf_disconnect(context->hfp_hf); |
| } |
| |
| static void hf_result_handler(struct hfp_context *result, |
| void *user_data) |
| { |
| struct context *context = user_data; |
| |
| hfp_hf_disconnect(context->hfp_hf); |
| } |
| |
| static void test_hf_unsolicited(gconstpointer data) |
| { |
| struct context *context = create_context(data); |
| bool ret; |
| |
| context->hfp_hf = hfp_hf_new(context->fd_client); |
| g_assert(context->hfp_hf); |
| |
| ret = hfp_hf_set_close_on_unref(context->hfp_hf, true); |
| g_assert(ret); |
| |
| if (context->data->hf_result_func) { |
| const struct test_pdu *pdu; |
| |
| pdu = &context->data->pdu_list[context->pdu_offset++]; |
| |
| ret = hfp_hf_register(context->hfp_hf, |
| context->data->hf_result_func, |
| (char *)pdu->data, context, |
| NULL); |
| g_assert(ret); |
| } |
| |
| send_pdu(context); |
| } |
| |
| static void test_hf_robustness(gconstpointer data) |
| { |
| struct context *context = create_context(data); |
| bool ret; |
| |
| context->hfp_hf = hfp_hf_new(context->fd_client); |
| g_assert(context->hfp_hf); |
| |
| ret = hfp_hf_set_close_on_unref(context->hfp_hf, true); |
| g_assert(ret); |
| |
| send_pdu(context); |
| |
| hfp_hf_unref(context->hfp_hf); |
| context->hfp_hf = NULL; |
| |
| context_quit(context); |
| } |
| |
| int main(int argc, char *argv[]) |
| { |
| tester_init(&argc, &argv); |
| |
| define_test("/hfp/test_init", test_init, NULL, data_end()); |
| define_test("/hfp/test_cmd_handler_1", test_command_handler, NULL, |
| raw_pdu('A', 'T', '+', 'B', 'R', 'S', 'F', '\r'), |
| raw_pdu('A', 'T', '+', 'B', 'R', 'S', 'F'), |
| data_end()); |
| define_test("/hfp/test_cmd_handler_2", test_command_handler, NULL, |
| raw_pdu('A', 'T', 'D', '1', '2', '3', '4', '\r'), |
| raw_pdu('A', 'T', 'D', '1', '2', '3', '4'), |
| data_end()); |
| define_test("/hfp/test_register_1", test_register, prefix_handler, |
| raw_pdu('+', 'B', 'R', 'S', 'F', '\0'), |
| raw_pdu('A', 'T', '+', 'B', 'R', 'S', 'F', '\r'), |
| type_pdu(HFP_GW_CMD_TYPE_COMMAND, 0), |
| data_end()); |
| define_test("/hfp/test_register_2", test_register, prefix_handler, |
| raw_pdu('+', 'B', 'R', 'S', 'F', '\0'), |
| raw_pdu('A', 'T', '+', 'B', 'R', 'S', 'F', '=', '\r'), |
| type_pdu(HFP_GW_CMD_TYPE_SET, 0), |
| data_end()); |
| define_test("/hfp/test_register_3", test_register, prefix_handler, |
| raw_pdu('+', 'B', 'R', 'S', 'F', '\0'), |
| raw_pdu('A', 'T', '+', 'B', 'R', 'S', 'F', '?', '\r'), |
| type_pdu(HFP_GW_CMD_TYPE_READ, 0), |
| data_end()); |
| define_test("/hfp/test_register_4", test_register, prefix_handler, |
| raw_pdu('+', 'B', 'R', 'S', 'F', '\0'), |
| raw_pdu('A', 'T', '+', 'B', 'R', 'S', 'F', '=', '?', |
| '\r'), |
| type_pdu(HFP_GW_CMD_TYPE_TEST, 0), |
| data_end()); |
| define_test("/hfp/test_register_5", test_register, prefix_handler, |
| raw_pdu('D', '\0'), |
| raw_pdu('A', 'T', 'D', '1', '2', '3', '4', '5', '\r'), |
| type_pdu(HFP_GW_CMD_TYPE_SET, 0), |
| data_end()); |
| define_test("/hfp/test_fragmented_1", test_fragmented, NULL, |
| frg_pdu('A'), frg_pdu('T'), frg_pdu('+'), frg_pdu('B'), |
| frg_pdu('R'), frg_pdu('S'), frg_pdu('F'), frg_pdu('\r'), |
| data_end()); |
| define_test("/hfp/test_ustring_1", test_register, check_ustring_1, |
| raw_pdu('D', '\0'), |
| raw_pdu('A', 'T', 'D', '0', '1', '2', '3', '\r'), |
| type_pdu(HFP_GW_CMD_TYPE_SET, 0), |
| data_end()); |
| define_test("/hfp/test_ustring_2", test_register, check_ustring_2, |
| raw_pdu('D', '\0'), |
| raw_pdu('A', 'T', 'D', '0', '1', '2', '3', '\r'), |
| type_pdu(HFP_GW_CMD_TYPE_SET, 0), |
| data_end()); |
| define_test("/hfp/test_string_1", test_register, check_string_1, |
| raw_pdu('D', '\0'), |
| raw_pdu('A', 'T', 'D', '\"', '0', '1', '2', '3', '\"', |
| '\r'), |
| type_pdu(HFP_GW_CMD_TYPE_SET, 0), |
| data_end()); |
| define_test("/hfp/test_string_2", test_register, check_string_2, |
| raw_pdu('D', '\0'), |
| raw_pdu('A', 'T', 'D', '\"', '0', '1', '2', '3', '\"', |
| '\r'), |
| type_pdu(HFP_GW_CMD_TYPE_SET, 0), |
| data_end()); |
| define_test("/hfp/test_corrupted_1", test_register, check_string_3, |
| raw_pdu('D', '\0'), |
| raw_pdu('\r', 'A', 'T', 'D', '\"', '0', '1', '2', '3', |
| '\"', '\r'), |
| type_pdu(HFP_GW_CMD_TYPE_SET, 0), |
| data_end()); |
| define_test("/hfp/test_empty", test_send_and_close, NULL, |
| raw_pdu('\r'), |
| data_end()); |
| define_hf_test("/hfp_hf/test_init", test_hf_init, NULL, NULL, |
| data_end()); |
| define_hf_test("/hfp_hf/test_send_command_1", test_hf_send_command, |
| NULL, hf_response_cb, |
| raw_pdu('A', 'T', '+', 'B', 'R', 'S', 'F', '\0'), |
| raw_pdu('\r', '\n', 'O', 'k', '\r', '\n'), |
| data_end()); |
| |
| define_hf_test("/hfp_hf/test_send_command_2", test_hf_send_command, |
| hf_unsolicited_resp_cb, |
| hf_response_with_data, |
| raw_pdu('+', 'B', 'R', 'S', 'F', '\0'), |
| raw_pdu('A', 'T', '+', 'B', 'R', 'S', 'F', '\0'), |
| frg_pdu('\r', '\n', '+', 'B', 'R', 'S', 'F', '\r', |
| '\n'), |
| frg_pdu('\r', '\n', 'O', 'k', '\r', '\n'), |
| data_end()); |
| |
| define_hf_test("/hfp_hf/test_send_command_3", test_hf_send_command, |
| NULL, hf_cme_error_response_cb, |
| raw_pdu('A', 'T', '+', 'C', 'H', 'L', 'D', '=', |
| '1', '\0'), |
| frg_pdu('\r', '\n', '+', 'C', 'M', 'E', ' ', 'E'), |
| frg_pdu('R', 'R', 'O', 'R', ':', '3', '0', '\r', '\n'), |
| data_end()); |
| |
| define_hf_test("/hfp_hf/test_unsolicited_1", test_hf_unsolicited, |
| hf_result_handler, NULL, |
| raw_pdu('+', 'C', 'L', 'C', 'C', '\0'), |
| frg_pdu('\r', '\n', '+', 'C', 'L', 'C'), |
| frg_pdu('C', '\r', '\n'), |
| data_end()); |
| |
| define_hf_test("/hfp_hf/test_unsolicited_2", test_hf_unsolicited, |
| hf_result_handler, NULL, |
| raw_pdu('+', 'C', 'L', 'C', 'C', '\0'), |
| frg_pdu('\r', '\n', '+', 'C', 'L', 'C', 'C', ':', '1'), |
| frg_pdu(',', '3', ',', '0', '\r', '\n'), |
| data_end()); |
| |
| define_hf_test("/hfp_hf/test_unsolicited_3", test_hf_unsolicited, |
| hf_result_handler, NULL, |
| raw_pdu('+', 'C', 'L', 'C', 'C', '\0'), |
| frg_pdu('\r'), frg_pdu('\n'), frg_pdu('+'), |
| frg_pdu('C'), frg_pdu('L'), frg_pdu('C'), frg_pdu('C'), |
| frg_pdu(':'), frg_pdu('1'), frg_pdu(','), frg_pdu('3'), |
| frg_pdu(','), frg_pdu('0'), frg_pdu('\r'), |
| frg_pdu('\n'), |
| data_end()); |
| |
| define_hf_test("/hfp_hf/test_corrupted_1", test_hf_unsolicited, |
| hf_result_handler, NULL, |
| raw_pdu('+', 'C', 'L', 'C', 'C', '\0'), |
| frg_pdu('\r', 'X', '\r', '\n'), |
| frg_pdu('+', 'C', 'L', 'C', 'C', ':', '1', ',', '3'), |
| frg_pdu(',', '0', '\r', '\n'), |
| data_end()); |
| |
| define_hf_test("/hfp_hf/test_corrupted_2", test_hf_unsolicited, |
| hf_result_handler, NULL, |
| raw_pdu('+', 'C', 'L', 'C', 'C', '\0'), |
| raw_pdu('+', 'C', 'L', 'C', 'C', '\r', '\n'), |
| data_end()); |
| |
| define_hf_test("/hfp_hf/test_empty", test_hf_robustness, NULL, NULL, |
| raw_pdu('\r'), data_end()); |
| |
| define_hf_test("/hfp_hf/test_unknown", test_hf_robustness, NULL, NULL, |
| raw_pdu('\r', '\n', 'B', 'R', '\r', '\n'), |
| data_end()); |
| |
| define_hf_test("/hfp_hf/test_context_parser_1", test_hf_unsolicited, |
| hf_clcc_result_handler, NULL, |
| raw_pdu('+', 'C', 'L', 'C', 'C', '\0'), |
| frg_pdu('+', 'C', 'L', 'C', 'C', ':'), |
| frg_pdu('(', '\"', 'c', 'a', 'l', 'l', '\"'), |
| frg_pdu('(', '0', ',', '1', ')', ')', ','), |
| frg_pdu('(', '\"', 'c', 'a', 'l', 'l', 's', 'e', 't'), |
| frg_pdu('u', 'p', '\"', ',', '(', '0', '-', '3', ')'), |
| frg_pdu(')', '\r', '\n'), |
| data_end()); |
| |
| define_hf_test("/hfp_hf/test_context_parser_2", test_hf_unsolicited, |
| hf_chld_result_handler, NULL, |
| raw_pdu('+', 'C', 'H', 'L', 'D', '\0'), |
| frg_pdu('+', 'C', 'H', 'L', 'D', ':'), |
| frg_pdu('1', ',', '2', 'x', '\r', '\n'), |
| data_end()); |
| |
| define_hf_test("/hfp_hf/test_context_skip_field", test_hf_unsolicited, |
| hf_chld_skip_field, NULL, |
| raw_pdu('+', 'C', 'H', 'L', 'D', '\0'), |
| frg_pdu('+', 'C', 'H', 'L', 'D', ':'), |
| frg_pdu('1', ',', '2', 'x', '\r', '\n'), |
| data_end()); |
| |
| return tester_run(); |
| } |