| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you 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 <string.h> |
| #include <errno.h> |
| #include <limits.h> |
| #include "testutil/testutil.h" |
| #include "nimble/ble.h" |
| #include "ble_hs_test.h" |
| #include "host/ble_uuid.h" |
| #include "ble_hs_test_util.h" |
| |
| struct ble_gatt_read_test_attr { |
| uint16_t conn_handle; |
| uint16_t handle; |
| uint8_t value_len; |
| uint8_t value[BLE_ATT_ATTR_MAX_LEN]; |
| }; |
| |
| #define BLE_GATT_READ_TEST_MAX_ATTRS 256 |
| |
| struct ble_gatt_read_test_attr |
| ble_gatt_read_test_attrs[BLE_GATT_READ_TEST_MAX_ATTRS]; |
| int ble_gatt_read_test_num_attrs; |
| int ble_gatt_read_test_complete; |
| |
| uint16_t ble_gatt_read_test_bad_conn_handle; |
| int ble_gatt_read_test_bad_status; |
| |
| static void |
| ble_gatt_read_test_misc_init(void) |
| { |
| ble_hs_test_util_init(); |
| ble_gatt_read_test_num_attrs = 0; |
| ble_gatt_read_test_complete = 0; |
| ble_gatt_read_test_bad_conn_handle = 0; |
| ble_gatt_read_test_bad_status = 0; |
| |
| memset(&ble_gatt_read_test_attrs[0], 0, |
| sizeof ble_gatt_read_test_attrs[0]); |
| } |
| |
| static int |
| ble_gatt_read_test_cb(uint16_t conn_handle, const struct ble_gatt_error *error, |
| struct ble_gatt_attr *attr, void *arg) |
| { |
| struct ble_gatt_read_test_attr *dst; |
| int *stop_after; |
| int rc; |
| |
| stop_after = arg; |
| |
| TEST_ASSERT_FATAL(error != NULL); |
| |
| if (error->status != 0) { |
| ble_gatt_read_test_bad_conn_handle = conn_handle; |
| ble_gatt_read_test_bad_status = error->status; |
| ble_gatt_read_test_complete = 1; |
| return 0; |
| } |
| |
| if (attr == NULL) { |
| ble_gatt_read_test_complete = 1; |
| return 0; |
| } |
| |
| TEST_ASSERT_FATAL(ble_gatt_read_test_num_attrs < |
| BLE_GATT_READ_TEST_MAX_ATTRS); |
| dst = ble_gatt_read_test_attrs + ble_gatt_read_test_num_attrs++; |
| |
| TEST_ASSERT_FATAL(OS_MBUF_PKTLEN(attr->om) <= sizeof dst->value); |
| |
| dst->conn_handle = conn_handle; |
| dst->handle = attr->handle; |
| dst->value_len = OS_MBUF_PKTLEN(attr->om); |
| rc = os_mbuf_copydata(attr->om, 0, OS_MBUF_PKTLEN(attr->om), dst->value); |
| TEST_ASSERT_FATAL(rc == 0); |
| |
| if (stop_after != NULL && *stop_after > 0) { |
| (*stop_after)--; |
| if (*stop_after == 0) { |
| ble_gatt_read_test_complete = 1; |
| return 1; |
| } |
| } else { |
| ble_gatt_read_test_complete = 1; |
| } |
| |
| return 0; |
| } |
| |
| static int |
| ble_gatt_read_test_long_cb(uint16_t conn_handle, |
| const struct ble_gatt_error *error, |
| struct ble_gatt_attr *attr, void *arg) |
| { |
| struct ble_gatt_read_test_attr *dst; |
| int *reads_left; |
| int rc; |
| |
| reads_left = arg; |
| |
| TEST_ASSERT_FATAL(error != NULL); |
| |
| if (error->status != 0) { |
| ble_gatt_read_test_bad_conn_handle = conn_handle; |
| ble_gatt_read_test_bad_status = error->status; |
| ble_gatt_read_test_complete = 1; |
| return 0; |
| } |
| |
| if (attr == NULL) { |
| ble_gatt_read_test_complete = 1; |
| return 0; |
| } |
| |
| dst = ble_gatt_read_test_attrs + 0; |
| |
| TEST_ASSERT_FATAL(OS_MBUF_PKTLEN(attr->om) <= |
| dst->value_len + sizeof dst->value); |
| TEST_ASSERT(attr->offset == dst->value_len); |
| |
| if (attr->offset == 0) { |
| dst->conn_handle = conn_handle; |
| dst->handle = attr->handle; |
| } else { |
| TEST_ASSERT(conn_handle == dst->conn_handle); |
| TEST_ASSERT(attr->handle == dst->handle); |
| } |
| rc = os_mbuf_copydata(attr->om, 0, OS_MBUF_PKTLEN(attr->om), |
| dst->value + dst->value_len); |
| TEST_ASSERT_FATAL(rc == 0); |
| dst->value_len += OS_MBUF_PKTLEN(attr->om); |
| |
| if (reads_left != NULL && *reads_left > 0) { |
| (*reads_left)--; |
| if (*reads_left == 0) { |
| ble_gatt_read_test_complete = 1; |
| return 1; |
| } |
| } |
| |
| return 0; |
| } |
| |
| static void |
| ble_gatt_read_test_misc_rx_rsp_good_raw(uint16_t conn_handle, |
| uint8_t att_op, |
| const void *data, int data_len) |
| { |
| uint8_t buf[1024]; |
| int rc; |
| |
| TEST_ASSERT_FATAL(data_len <= sizeof buf); |
| |
| /* Send the pending ATT Read Request. */ |
| |
| buf[0] = att_op; |
| memcpy(buf + 1, data, data_len); |
| |
| rc = ble_hs_test_util_l2cap_rx_payload_flat(conn_handle, BLE_L2CAP_CID_ATT, |
| buf, 1 + data_len); |
| TEST_ASSERT(rc == 0); |
| } |
| |
| static void |
| ble_gatt_read_test_misc_rx_rsp_good(uint16_t conn_handle, |
| struct ble_hs_test_util_flat_attr *attr) |
| { |
| ble_gatt_read_test_misc_rx_rsp_good_raw(conn_handle, BLE_ATT_OP_READ_RSP, |
| attr->value, |
| attr->value_len); |
| } |
| |
| static void |
| ble_gatt_read_test_misc_rx_rsp_bad(uint16_t conn_handle, |
| uint8_t att_error, uint16_t err_handle) |
| { |
| /* Send the pending ATT Read Request. */ |
| |
| ble_hs_test_util_rx_att_err_rsp(conn_handle, BLE_ATT_OP_READ_REQ, |
| att_error, err_handle); |
| } |
| |
| static int |
| ble_gatt_read_test_misc_uuid_rx_rsp_good( |
| uint16_t conn_handle, struct ble_hs_test_util_flat_attr *attrs) |
| { |
| struct ble_att_read_type_rsp rsp; |
| uint8_t buf[1024]; |
| int prev_len; |
| int off; |
| int rc; |
| int i; |
| |
| if (ble_gatt_read_test_complete || attrs[0].handle == 0) { |
| return 0; |
| } |
| |
| /* Send the pending ATT Read By Type Request. */ |
| |
| rsp.batp_length = 2 + attrs[0].value_len; |
| ble_att_read_type_rsp_write(buf, sizeof buf, &rsp); |
| |
| prev_len = 0; |
| off = BLE_ATT_READ_TYPE_RSP_BASE_SZ; |
| for (i = 0; attrs[i].handle != 0; i++) { |
| if (prev_len != 0 && prev_len != attrs[i].value_len) { |
| break; |
| } |
| prev_len = attrs[i].value_len; |
| |
| put_le16(buf + off, attrs[i].handle); |
| off += 2; |
| |
| memcpy(buf + off, attrs[i].value, attrs[i].value_len); |
| off += attrs[i].value_len; |
| } |
| |
| rc = ble_hs_test_util_l2cap_rx_payload_flat(conn_handle, BLE_L2CAP_CID_ATT, |
| buf, off); |
| TEST_ASSERT(rc == 0); |
| |
| return i; |
| } |
| |
| static void |
| ble_gatt_read_test_misc_verify_good(struct ble_hs_test_util_flat_attr *attr) |
| { |
| int rc; |
| |
| ble_gatt_read_test_misc_init(); |
| ble_hs_test_util_create_conn(2, ((uint8_t[]){2,3,4,5,6,7,8,9}), |
| NULL, NULL); |
| |
| /* Exchange MTU: We need plus 1 for the read response opcode */ |
| ble_hs_test_util_set_att_mtu(2, attr->value_len + 1); |
| |
| rc = ble_gattc_read(2, attr->handle, ble_gatt_read_test_cb, NULL); |
| TEST_ASSERT_FATAL(rc == 0); |
| |
| ble_gatt_read_test_misc_rx_rsp_good(2, attr); |
| |
| TEST_ASSERT(ble_gatt_read_test_num_attrs == 1); |
| TEST_ASSERT(ble_gatt_read_test_attrs[0].conn_handle == 2); |
| TEST_ASSERT(ble_gatt_read_test_attrs[0].handle == attr->handle); |
| TEST_ASSERT(ble_gatt_read_test_attrs[0].value_len == attr->value_len); |
| TEST_ASSERT(memcmp(ble_gatt_read_test_attrs[0].value, attr->value, |
| attr->value_len) == 0); |
| } |
| |
| static void |
| ble_gatt_read_test_misc_verify_bad(uint8_t att_status, |
| struct ble_hs_test_util_flat_attr *attr) |
| { |
| int rc; |
| |
| ble_gatt_read_test_misc_init(); |
| ble_hs_test_util_create_conn(2, ((uint8_t[]){2,3,4,5,6,7,8,9}), |
| NULL, NULL); |
| |
| rc = ble_gattc_read(2, attr->handle, ble_gatt_read_test_cb, NULL); |
| TEST_ASSERT_FATAL(rc == 0); |
| |
| ble_gatt_read_test_misc_rx_rsp_bad(2, att_status, attr->handle); |
| |
| TEST_ASSERT(ble_gatt_read_test_num_attrs == 0); |
| TEST_ASSERT(ble_gatt_read_test_bad_conn_handle == 2); |
| TEST_ASSERT(ble_gatt_read_test_bad_status == |
| BLE_HS_ERR_ATT_BASE + att_status); |
| TEST_ASSERT(!ble_gattc_any_jobs()); |
| } |
| |
| static void |
| ble_gatt_read_test_misc_uuid_verify_good( |
| uint16_t start_handle, uint16_t end_handle, const ble_uuid_t *uuid, |
| int stop_after, struct ble_hs_test_util_flat_attr *attrs) |
| { |
| int num_read; |
| int idx; |
| int rc; |
| int i; |
| |
| ble_gatt_read_test_misc_init(); |
| ble_hs_test_util_create_conn(2, ((uint8_t[]){2,3,4,5,6,7,8,9}), |
| NULL, NULL); |
| |
| rc = ble_gattc_read_by_uuid(2, start_handle, end_handle, uuid, |
| ble_gatt_read_test_cb, &stop_after); |
| TEST_ASSERT_FATAL(rc == 0); |
| |
| idx = 0; |
| while (1) { |
| num_read = ble_gatt_read_test_misc_uuid_rx_rsp_good(2, attrs + idx); |
| if (num_read == 0) { |
| ble_hs_test_util_rx_att_err_rsp(2, BLE_ATT_OP_READ_TYPE_REQ, |
| BLE_ATT_ERR_ATTR_NOT_FOUND, |
| start_handle); |
| break; |
| } |
| |
| idx += num_read; |
| } |
| |
| TEST_ASSERT(ble_gatt_read_test_complete); |
| TEST_ASSERT(idx == ble_gatt_read_test_num_attrs); |
| |
| for (i = 0; i < idx; i++) { |
| TEST_ASSERT(ble_gatt_read_test_attrs[i].conn_handle == 2); |
| TEST_ASSERT(ble_gatt_read_test_attrs[i].handle == attrs[i].handle); |
| TEST_ASSERT(ble_gatt_read_test_attrs[i].value_len == |
| attrs[i].value_len); |
| TEST_ASSERT(memcmp(ble_gatt_read_test_attrs[i].value, attrs[i].value, |
| attrs[i].value_len) == 0); |
| } |
| TEST_ASSERT(!ble_gattc_any_jobs()); |
| } |
| |
| static void |
| ble_gatt_read_test_misc_long_verify_good( |
| int max_reads, struct ble_hs_test_util_flat_attr *attr) |
| { |
| int reads_left; |
| int chunk_sz; |
| int rem_len; |
| int att_op; |
| uint16_t offset = 0; |
| int off; |
| int rc; |
| |
| ble_gatt_read_test_misc_init(); |
| ble_hs_test_util_create_conn(2, ((uint8_t[]){2,3,4,5,6,7,8,9}), |
| NULL, NULL); |
| |
| if (max_reads == 0) { |
| max_reads = INT_MAX; |
| } |
| reads_left = max_reads; |
| rc = ble_gattc_read_long(2, attr->handle, offset, |
| ble_gatt_read_test_long_cb, &reads_left); |
| TEST_ASSERT_FATAL(rc == 0); |
| |
| off = 0; |
| rem_len = attr->value_len; |
| do { |
| if (rem_len > BLE_ATT_MTU_DFLT - 1) { |
| chunk_sz = BLE_ATT_MTU_DFLT - 1; |
| } else { |
| chunk_sz = rem_len; |
| } |
| if (off == 0) { |
| att_op = BLE_ATT_OP_READ_RSP; |
| } else { |
| att_op = BLE_ATT_OP_READ_BLOB_RSP; |
| } |
| ble_gatt_read_test_misc_rx_rsp_good_raw(2, att_op, |
| attr->value + off, chunk_sz); |
| rem_len -= chunk_sz; |
| off += chunk_sz; |
| } while (rem_len > 0 && reads_left > 0); |
| |
| TEST_ASSERT(ble_gatt_read_test_complete); |
| TEST_ASSERT(!ble_gattc_any_jobs()); |
| TEST_ASSERT(ble_gatt_read_test_attrs[0].conn_handle == 2); |
| TEST_ASSERT(ble_gatt_read_test_attrs[0].handle == attr->handle); |
| if (reads_left > 0) { |
| TEST_ASSERT(ble_gatt_read_test_attrs[0].value_len == attr->value_len); |
| } |
| TEST_ASSERT(memcmp(ble_gatt_read_test_attrs[0].value, attr->value, |
| ble_gatt_read_test_attrs[0].value_len) == 0); |
| } |
| |
| static void |
| ble_gatt_read_test_misc_long_verify_bad( |
| uint8_t att_status, struct ble_hs_test_util_flat_attr *attr) |
| { |
| uint16_t offset = 0; |
| int rc; |
| |
| ble_gatt_read_test_misc_init(); |
| ble_hs_test_util_create_conn(2, ((uint8_t[]){2,3,4,5,6,7,8,9}), |
| NULL, NULL); |
| |
| rc = ble_gattc_read_long(2, attr->handle, offset, |
| ble_gatt_read_test_long_cb, NULL); |
| TEST_ASSERT_FATAL(rc == 0); |
| |
| ble_gatt_read_test_misc_rx_rsp_bad(2, att_status, attr->handle); |
| |
| TEST_ASSERT(ble_gatt_read_test_num_attrs == 0); |
| TEST_ASSERT(ble_gatt_read_test_bad_conn_handle == 2); |
| TEST_ASSERT(ble_gatt_read_test_bad_status == |
| BLE_HS_ERR_ATT_BASE + att_status); |
| TEST_ASSERT(!ble_gattc_any_jobs()); |
| } |
| |
| static int |
| ble_gatt_read_test_misc_extract_handles( |
| struct ble_hs_test_util_flat_attr *attrs, uint16_t *handles) |
| { |
| int i; |
| |
| for (i = 0; attrs[i].handle != 0; i++) { |
| handles[i] = attrs[i].handle; |
| } |
| return i; |
| } |
| |
| static void |
| ble_gatt_read_test_misc_mult_verify_good( |
| struct ble_hs_test_util_flat_attr *attrs) |
| { |
| uint8_t expected_value[512]; |
| uint16_t handles[256]; |
| int num_attrs; |
| int chunk_sz; |
| int off; |
| int rc; |
| int i; |
| |
| ble_gatt_read_test_misc_init(); |
| ble_hs_test_util_create_conn(2, ((uint8_t[]){2,3,4,5,6,7,8,9}), |
| NULL, NULL); |
| |
| num_attrs = ble_gatt_read_test_misc_extract_handles(attrs, handles); |
| |
| off = 0; |
| for (i = 0; i < num_attrs; i++) { |
| if (attrs[i].value_len > BLE_ATT_MTU_DFLT - 1 - off) { |
| chunk_sz = BLE_ATT_MTU_DFLT - 1 - off; |
| } else { |
| chunk_sz = attrs[i].value_len; |
| } |
| |
| if (chunk_sz > 0) { |
| memcpy(expected_value + off, attrs[i].value, chunk_sz); |
| off += chunk_sz; |
| } |
| } |
| |
| rc = ble_gattc_read_mult(2, handles, num_attrs, |
| ble_gatt_read_test_cb, NULL); |
| TEST_ASSERT_FATAL(rc == 0); |
| |
| ble_gatt_read_test_misc_rx_rsp_good_raw(2, BLE_ATT_OP_READ_MULT_RSP, |
| expected_value, off); |
| |
| TEST_ASSERT(ble_gatt_read_test_complete); |
| TEST_ASSERT(!ble_gattc_any_jobs()); |
| TEST_ASSERT(ble_gatt_read_test_attrs[0].conn_handle == 2); |
| TEST_ASSERT(ble_gatt_read_test_attrs[0].value_len == off); |
| TEST_ASSERT(memcmp(ble_gatt_read_test_attrs[0].value, expected_value, |
| off) == 0); |
| } |
| |
| static void |
| ble_gatt_read_test_misc_mult_verify_bad( |
| uint8_t att_status, uint16_t err_handle, |
| struct ble_hs_test_util_flat_attr *attrs) |
| { |
| uint16_t handles[256]; |
| int num_attrs; |
| int rc; |
| |
| ble_gatt_read_test_misc_init(); |
| ble_hs_test_util_create_conn(2, ((uint8_t[]){2,3,4,5,6,7,8,9}), |
| NULL, NULL); |
| |
| num_attrs = ble_gatt_read_test_misc_extract_handles(attrs, handles); |
| |
| rc = ble_gattc_read_mult(2, handles, num_attrs, |
| ble_gatt_read_test_cb, NULL); |
| TEST_ASSERT_FATAL(rc == 0); |
| |
| ble_gatt_read_test_misc_rx_rsp_bad(2, att_status, err_handle); |
| |
| TEST_ASSERT(ble_gatt_read_test_num_attrs == 0); |
| TEST_ASSERT(ble_gatt_read_test_bad_conn_handle == 2); |
| TEST_ASSERT(ble_gatt_read_test_bad_status == |
| BLE_HS_ERR_ATT_BASE + att_status); |
| TEST_ASSERT(!ble_gattc_any_jobs()); |
| } |
| |
| TEST_CASE_SELF(ble_gatt_read_test_by_handle) |
| { |
| /* Read a seven-byte attribute. */ |
| ble_gatt_read_test_misc_verify_good( |
| (struct ble_hs_test_util_flat_attr[]) { { |
| .handle = 43, |
| .value = { 1,2,3,4,5,6,7 }, |
| .value_len = 7 |
| } }); |
| |
| /* Read a one-byte attribute. */ |
| ble_gatt_read_test_misc_verify_good( |
| (struct ble_hs_test_util_flat_attr[]) { { |
| .handle = 0x5432, |
| .value = { 0xff }, |
| .value_len = 1 |
| } }); |
| |
| /* Read a 200-byte attribute. */ |
| ble_gatt_read_test_misc_verify_good( |
| (struct ble_hs_test_util_flat_attr[]) { { |
| .handle = 815, |
| .value = { 0 }, |
| .value_len = 200, |
| } }); |
| |
| /* Fail due to attribute not found. */ |
| ble_gatt_read_test_misc_verify_bad(BLE_ATT_ERR_ATTR_NOT_FOUND, |
| (struct ble_hs_test_util_flat_attr[]) { { |
| .handle = 719, |
| .value = { 1,2,3,4,5,6,7 }, |
| .value_len = 7 |
| } }); |
| |
| /* Fail due to invalid PDU. */ |
| ble_gatt_read_test_misc_verify_bad(BLE_ATT_ERR_INVALID_PDU, |
| (struct ble_hs_test_util_flat_attr[]) { { |
| .handle = 65, |
| .value = { 0xfa, 0x4c }, |
| .value_len = 2 |
| } }); |
| |
| ble_hs_test_util_assert_mbufs_freed(NULL); |
| } |
| |
| TEST_CASE_SELF(ble_gatt_read_test_by_uuid) |
| { |
| /* Read a single seven-byte attribute. */ |
| ble_gatt_read_test_misc_uuid_verify_good(1, 100, BLE_UUID16_DECLARE(0x1234), 0, |
| (struct ble_hs_test_util_flat_attr[]) { { |
| .handle = 43, |
| .value = { 1,2,3,4,5,6,7 }, |
| .value_len = 7 |
| }, { |
| 0, |
| } }); |
| |
| /* Read two seven-byte attributes; one response. */ |
| ble_gatt_read_test_misc_uuid_verify_good(1, 100, BLE_UUID16_DECLARE(0x1234), 0, |
| (struct ble_hs_test_util_flat_attr[]) { { |
| .handle = 43, |
| .value = { 1,2,3,4,5,6,7 }, |
| .value_len = 7 |
| }, { |
| .handle = 44, |
| .value = { 2,3,4,5,6,7,8 }, |
| .value_len = 7 |
| }, { |
| 0, |
| } }); |
| |
| /* Read two attributes; two responses. */ |
| ble_gatt_read_test_misc_uuid_verify_good(1, 100, BLE_UUID16_DECLARE(0x1234), 0, |
| (struct ble_hs_test_util_flat_attr[]) { { |
| .handle = 43, |
| .value = { 1,2,3,4,5,6,7 }, |
| .value_len = 7 |
| }, { |
| .handle = 44, |
| .value = { 2,3,4 }, |
| .value_len = 3 |
| }, { |
| 0, |
| } }); |
| |
| /* Stop after three reads. */ |
| ble_gatt_read_test_misc_uuid_verify_good(1, 100, BLE_UUID16_DECLARE(0x1234), 3, |
| (struct ble_hs_test_util_flat_attr[]) { { |
| .handle = 43, |
| .value = { 1,2,3,4,5,6,7 }, |
| .value_len = 7 |
| }, { |
| .handle = 44, |
| .value = { 2,3,4 }, |
| .value_len = 3 |
| }, { |
| .handle = 45, |
| .value = { 2,3,4 }, |
| .value_len = 3 |
| }, { |
| .handle = 46, |
| .value = { 3,4,5,6 }, |
| .value_len = 4 |
| }, { |
| .handle = 47, |
| .value = { 2,3,4 }, |
| .value_len = 3 |
| }, { |
| 0, |
| } }); |
| |
| ble_hs_test_util_assert_mbufs_freed(NULL); |
| } |
| |
| TEST_CASE_SELF(ble_gatt_read_test_long) |
| { |
| uint8_t data512[512]; |
| int i; |
| |
| for (i = 0; i < sizeof data512; i++) { |
| data512[i] = i; |
| } |
| |
| /* Read a seven-byte attribute. */ |
| ble_gatt_read_test_misc_long_verify_good(0, |
| (struct ble_hs_test_util_flat_attr[]) { { |
| .handle = 43, |
| .value = { 1,2,3,4,5,6,7 }, |
| .value_len = 7 |
| } }); |
| |
| /* Read a zero-byte attribute. */ |
| ble_gatt_read_test_misc_long_verify_good(0, |
| (struct ble_hs_test_util_flat_attr[]) { { |
| .handle = 43, |
| .value = { 0 }, |
| .value_len = 0 |
| } }); |
| |
| /* Read a 60-byte attribute; three requests. */ |
| ble_gatt_read_test_misc_long_verify_good(0, |
| (struct ble_hs_test_util_flat_attr[]) { { |
| .handle = 34, |
| .value = { |
| 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, |
| 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, |
| 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, |
| 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60 |
| }, |
| .value_len = 60 |
| } }); |
| |
| /* Stop after two reads. */ |
| ble_gatt_read_test_misc_long_verify_good(2, |
| (struct ble_hs_test_util_flat_attr[]) { { |
| .handle = 34, |
| .value = { |
| 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, |
| 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, |
| 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, |
| 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60 |
| }, |
| .value_len = 60 |
| } }); |
| |
| /* Fail due to attribute not found. */ |
| ble_gatt_read_test_misc_long_verify_bad(BLE_ATT_ERR_ATTR_NOT_FOUND, |
| (struct ble_hs_test_util_flat_attr[]) { { |
| .handle = 719, |
| .value = { 1, 2, 3, 4, 5, 6, 7 }, |
| .value_len = 7 |
| } }); |
| |
| ble_hs_test_util_assert_mbufs_freed(NULL); |
| } |
| |
| TEST_CASE_SELF(ble_gatt_read_test_mult) |
| { |
| uint8_t data512[512]; |
| int i; |
| |
| for (i = 0; i < sizeof data512; i++) { |
| data512[i] = i; |
| } |
| |
| /* Read one attribute. */ |
| ble_gatt_read_test_misc_mult_verify_good( |
| (struct ble_hs_test_util_flat_attr[]) { { |
| .handle = 43, |
| .value = { 0, 1, 2, 3, 4, 5, 6, 7 }, |
| .value_len = 7 |
| }, { |
| 0 |
| } }); |
| |
| /* Read two attributes. */ |
| ble_gatt_read_test_misc_mult_verify_good( |
| (struct ble_hs_test_util_flat_attr[]) { { |
| .handle = 43, |
| .value = { 0, 1, 2, 3, 4, 5, 6, 7 }, |
| .value_len = 7, |
| }, { |
| .handle = 44, |
| .value = { 8, 9, 10, 11 }, |
| .value_len = 4, |
| }, { |
| 0 |
| } }); |
| |
| /* Read two attributes (swap order). */ |
| ble_gatt_read_test_misc_mult_verify_good( |
| (struct ble_hs_test_util_flat_attr[]) { { |
| .handle = 44, |
| .value = { 8, 9, 10, 11 }, |
| .value_len = 4, |
| }, { |
| .handle = 43, |
| .value = { 0, 1, 2, 3, 4, 5, 6, 7 }, |
| .value_len = 7, |
| }, { |
| 0 |
| } }); |
| |
| /* Read five attributes. */ |
| ble_gatt_read_test_misc_mult_verify_good( |
| (struct ble_hs_test_util_flat_attr[]) { { |
| .handle = 43, |
| .value = { 0, 1, 2, 3, 4, 5, 6, 7 }, |
| .value_len = 7, |
| }, { |
| .handle = 44, |
| .value = { 8, 9, 10, 11 }, |
| .value_len = 4, |
| }, { |
| .handle = 145, |
| .value = { 12, 13 }, |
| .value_len = 2, |
| }, { |
| .handle = 191, |
| .value = { 14, 15, 16 }, |
| .value_len = 3, |
| }, { |
| .handle = 352, |
| .value = { 17, 18, 19, 20 }, |
| .value_len = 4, |
| }, { |
| 0 |
| } }); |
| |
| /* Fail due to attribute not found. */ |
| ble_gatt_read_test_misc_mult_verify_bad(BLE_ATT_ERR_ATTR_NOT_FOUND, 719, |
| (struct ble_hs_test_util_flat_attr[]) { { |
| .handle = 719, |
| .value = { 1,2,3,4,5,6,7 }, |
| .value_len = 7 |
| }, { |
| 0 |
| } }); |
| |
| ble_hs_test_util_assert_mbufs_freed(NULL); |
| } |
| |
| TEST_CASE_SELF(ble_gatt_read_test_concurrent) |
| { |
| int rc; |
| int i; |
| |
| ble_gatt_read_test_misc_init(); |
| ble_hs_test_util_create_conn(2, ((uint8_t[]){2,3,4,5,6,7,8,9}), |
| NULL, NULL); |
| |
| /*** |
| * Perform three concurrent reads. Assert that each response is correctly |
| * matched up with its corresponding GATT procedure. |
| */ |
| |
| struct ble_hs_test_util_flat_attr attrs[3] = { |
| { |
| .handle = 1, |
| .offset = 0, |
| .value_len = 3, |
| .value = { 1, 2, 3 }, |
| }, |
| { |
| .handle = 2, |
| .offset = 0, |
| .value_len = 4, |
| .value = { 2, 3, 4, 5 }, |
| }, |
| { |
| .handle = 3, |
| .offset = 0, |
| .value_len = 5, |
| .value = { 3, 4, 5, 6, 7 }, |
| }, |
| }; |
| |
| rc = ble_gattc_read(2, attrs[0].handle, ble_gatt_read_test_cb, NULL); |
| TEST_ASSERT_FATAL(rc == 0); |
| rc = ble_gattc_read(2, attrs[1].handle, ble_gatt_read_test_cb, NULL); |
| TEST_ASSERT_FATAL(rc == 0); |
| rc = ble_gattc_read(2, attrs[2].handle, ble_gatt_read_test_cb, NULL); |
| TEST_ASSERT_FATAL(rc == 0); |
| |
| ble_gatt_read_test_misc_rx_rsp_good(2, attrs + 0); |
| ble_gatt_read_test_misc_rx_rsp_good(2, attrs + 1); |
| ble_gatt_read_test_misc_rx_rsp_good(2, attrs + 2); |
| |
| TEST_ASSERT(ble_gatt_read_test_num_attrs == 3); |
| |
| for (i = 0; i < 3; i++) { |
| TEST_ASSERT(ble_gatt_read_test_attrs[i].handle == attrs[i].handle); |
| TEST_ASSERT(ble_gatt_read_test_attrs[i].value_len == |
| attrs[i].value_len); |
| TEST_ASSERT(memcmp(ble_gatt_read_test_attrs[i].value, attrs[i].value, |
| attrs[i].value_len) == 0); |
| } |
| |
| ble_hs_test_util_assert_mbufs_freed(NULL); |
| } |
| |
| TEST_CASE_SELF(ble_gatt_read_test_long_oom) |
| { |
| static const struct ble_hs_test_util_flat_attr attr = { |
| .handle = 34, |
| .value = { |
| 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, |
| 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, |
| 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, |
| 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60 |
| }, |
| .value_len = 60, |
| }; |
| |
| struct os_mbuf *oms; |
| int32_t ticks_until; |
| int reads_left; |
| int chunk_sz; |
| uint16_t offset = 0; |
| int off; |
| int rc; |
| |
| ble_gatt_read_test_misc_init(); |
| ble_hs_test_util_create_conn(2, ((uint8_t[]){2,3,4,5,6,7,8,9}), |
| NULL, NULL); |
| |
| /* Initiate a read long procedure. */ |
| off = 0; |
| reads_left = 0; |
| rc = ble_gattc_read_long(2, attr.handle, offset, ble_gatt_read_test_long_cb, |
| &reads_left); |
| TEST_ASSERT_FATAL(rc == 0); |
| |
| /* Exhaust the msys pool. Leave one mbuf for the forthcoming response. */ |
| oms = ble_hs_test_util_mbuf_alloc_all_but(1); |
| chunk_sz = ble_att_mtu(2) - BLE_ATT_READ_RSP_BASE_SZ; |
| ble_gatt_read_test_misc_rx_rsp_good_raw(2, BLE_ATT_OP_READ_RSP, |
| attr.value + off, chunk_sz); |
| off += chunk_sz; |
| |
| /* Ensure no follow-up request got sent. It should not have gotten sent |
| * due to mbuf exhaustion. |
| */ |
| ble_hs_test_util_prev_tx_queue_clear(); |
| TEST_ASSERT(ble_hs_test_util_prev_tx_dequeue_pullup() == NULL); |
| |
| /* Verify that we will resume the stalled GATT procedure in one second. */ |
| ticks_until = ble_gattc_timer(); |
| TEST_ASSERT(ticks_until == os_time_ms_to_ticks32(MYNEWT_VAL(BLE_GATT_RESUME_RATE))); |
| |
| /* Verify the procedure proceeds after mbufs become available. */ |
| rc = os_mbuf_free_chain(oms); |
| TEST_ASSERT_FATAL(rc == 0); |
| os_time_advance(ticks_until); |
| ble_gattc_timer(); |
| |
| /* Exhaust the msys pool. Leave one mbuf for the forthcoming response. */ |
| oms = ble_hs_test_util_mbuf_alloc_all_but(1); |
| chunk_sz = ble_att_mtu(2) - BLE_ATT_READ_RSP_BASE_SZ; |
| ble_gatt_read_test_misc_rx_rsp_good_raw(2, BLE_ATT_OP_READ_RSP, |
| attr.value + off, chunk_sz); |
| off += chunk_sz; |
| |
| /* Ensure no follow-up request got sent. It should not have gotten sent |
| * due to mbuf exhaustion. |
| */ |
| ble_hs_test_util_prev_tx_queue_clear(); |
| TEST_ASSERT(ble_hs_test_util_prev_tx_dequeue_pullup() == NULL); |
| |
| /* Verify that we will resume the stalled GATT procedure in one second. */ |
| ticks_until = ble_gattc_timer(); |
| TEST_ASSERT(ticks_until == os_time_ms_to_ticks32(MYNEWT_VAL(BLE_GATT_RESUME_RATE))); |
| |
| /* Verify that procedure completes when mbufs are available. */ |
| rc = os_mbuf_free_chain(oms); |
| TEST_ASSERT_FATAL(rc == 0); |
| os_time_advance(ticks_until); |
| ble_gattc_timer(); |
| |
| chunk_sz = attr.value_len - off; |
| ble_gatt_read_test_misc_rx_rsp_good_raw(2, BLE_ATT_OP_READ_RSP, |
| attr.value + off, chunk_sz); |
| off += chunk_sz; |
| |
| TEST_ASSERT(ble_gatt_read_test_complete); |
| TEST_ASSERT(!ble_gattc_any_jobs()); |
| TEST_ASSERT(ble_gatt_read_test_attrs[0].conn_handle == 2); |
| TEST_ASSERT(ble_gatt_read_test_attrs[0].handle == attr.handle); |
| TEST_ASSERT(ble_gatt_read_test_attrs[0].value_len == attr.value_len); |
| TEST_ASSERT(memcmp(ble_gatt_read_test_attrs[0].value, attr.value, |
| ble_gatt_read_test_attrs[0].value_len) == 0); |
| |
| ble_hs_test_util_assert_mbufs_freed(NULL); |
| } |
| |
| TEST_SUITE(ble_gatt_read_test_suite) |
| { |
| ble_gatt_read_test_by_handle(); |
| ble_gatt_read_test_by_uuid(); |
| ble_gatt_read_test_long(); |
| ble_gatt_read_test_mult(); |
| ble_gatt_read_test_concurrent(); |
| ble_gatt_read_test_long_oom(); |
| } |
