BLE Host unit tests - queue of previous data txes.

9 files changed, 231 insertions, 173 deletions

diff --git a/net/nimble/host/src/test/ble_att_clt_test.c b/net/nimble/host/src/test/ble_att_clt_test.c
index 54ddb273..cd194318 100644
--- a/net/nimble/host/src/test/ble_att_clt_test.c
+++ b/net/nimble/host/src/test/ble_att_clt_test.c
@@ -43,10 +43,7 @@ ble_att_clt_test_misc_verify_tx_write(uint16_t handle_id, void *value,
     struct ble_att_write_req req;
     struct os_mbuf *om;
 
-    TEST_ASSERT_FATAL(ble_hs_test_util_prev_tx != NULL);
-
-    om = os_mbuf_pullup(ble_hs_test_util_prev_tx,
-                        OS_MBUF_PKTLEN(ble_hs_test_util_prev_tx));
+    om = ble_hs_test_util_prev_tx_dequeue_pullup();
     TEST_ASSERT_FATAL(om != NULL);
 
     if (is_req) {
@@ -221,10 +218,7 @@ ble_att_clt_test_misc_prep_good(uint16_t handle, uint16_t offset,
     TEST_ASSERT(rc == 0);
 
     ble_hs_test_util_tx_all();
-    TEST_ASSERT_FATAL(ble_hs_test_util_prev_tx != NULL);
-
-    om = os_mbuf_pullup(ble_hs_test_util_prev_tx,
-                        OS_MBUF_PKTLEN(ble_hs_test_util_prev_tx));
+    om = ble_hs_test_util_prev_tx_dequeue_pullup();
     TEST_ASSERT_FATAL(om != NULL);
     TEST_ASSERT(om->om_len == BLE_ATT_PREP_WRITE_CMD_BASE_SZ + attr_data_len);
 
@@ -253,10 +247,7 @@ ble_att_clt_test_misc_exec_good(uint8_t flags)
     TEST_ASSERT(rc == 0);
 
     ble_hs_test_util_tx_all();
-    TEST_ASSERT_FATAL(ble_hs_test_util_prev_tx != NULL);
-
-    om = os_mbuf_pullup(ble_hs_test_util_prev_tx,
-                        OS_MBUF_PKTLEN(ble_hs_test_util_prev_tx));
+    om = ble_hs_test_util_prev_tx_dequeue_pullup();
     TEST_ASSERT_FATAL(om != NULL);
     TEST_ASSERT(om->om_len == BLE_ATT_EXEC_WRITE_REQ_SZ);
 
@@ -393,10 +384,7 @@ TEST_CASE(ble_att_clt_test_tx_read_mult)
     TEST_ASSERT(rc == 0);
 
     ble_hs_test_util_tx_all();
-    TEST_ASSERT_FATAL(ble_hs_test_util_prev_tx != NULL);
-
-    om = os_mbuf_pullup(ble_hs_test_util_prev_tx,
-                        OS_MBUF_PKTLEN(ble_hs_test_util_prev_tx));
+    om = ble_hs_test_util_prev_tx_dequeue_pullup();
     TEST_ASSERT_FATAL(om != NULL);
     TEST_ASSERT(om->om_len == BLE_ATT_READ_MULT_REQ_BASE_SZ + 4);
 
diff --git a/net/nimble/host/src/test/ble_att_svr_test.c b/net/nimble/host/src/test/ble_att_svr_test.c
index 8ce414da..770dcb9e 100644
--- a/net/nimble/host/src/test/ble_att_svr_test.c
+++ b/net/nimble/host/src/test/ble_att_svr_test.c
@@ -302,12 +302,15 @@ ble_att_svr_test_misc_verify_tx_err_rsp(struct ble_l2cap_chan *chan,
                                         uint8_t error_code)
 {
     struct ble_att_error_rsp rsp;
+    struct os_mbuf *om;
     uint8_t buf[BLE_ATT_ERROR_RSP_SZ];
     int rc;
 
     ble_hs_test_util_tx_all();
 
-    rc = os_mbuf_copydata(ble_hs_test_util_prev_tx, 0, sizeof buf, buf);
+    om = ble_hs_test_util_prev_tx_dequeue();
+
+    rc = os_mbuf_copydata(om, 0, sizeof buf, buf);
     TEST_ASSERT(rc == 0);
 
     ble_att_error_rsp_parse(buf, sizeof buf, &rsp);
@@ -315,63 +318,60 @@ ble_att_svr_test_misc_verify_tx_err_rsp(struct ble_l2cap_chan *chan,
     TEST_ASSERT(rsp.baep_req_op == req_op);
     TEST_ASSERT(rsp.baep_handle == handle);
     TEST_ASSERT(rsp.baep_error_code == error_code);
-
-    /* Remove the error response from the buffer. */
-    os_mbuf_adj(ble_hs_test_util_prev_tx, BLE_ATT_ERROR_RSP_SZ);
 }
 
 static void
 ble_att_svr_test_misc_verify_tx_read_rsp(struct ble_l2cap_chan *chan,
                                          uint8_t *attr_data, int attr_len)
 {
+    struct os_mbuf *om;
     uint8_t u8;
     int rc;
     int i;
 
     ble_hs_test_util_tx_all();
 
-    rc = os_mbuf_copydata(ble_hs_test_util_prev_tx, 0, 1, &u8);
+    om = ble_hs_test_util_prev_tx_dequeue();
+
+    rc = os_mbuf_copydata(om, 0, 1, &u8);
     TEST_ASSERT(rc == 0);
     TEST_ASSERT(u8 == BLE_ATT_OP_READ_RSP);
 
     for (i = 0; i < attr_len; i++) {
-        rc = os_mbuf_copydata(ble_hs_test_util_prev_tx, i + 1, 1, &u8);
+        rc = os_mbuf_copydata(om, i + 1, 1, &u8);
         TEST_ASSERT(rc == 0);
         TEST_ASSERT(u8 == attr_data[i]);
     }
 
-    rc = os_mbuf_copydata(ble_hs_test_util_prev_tx, i + 1, 1, &u8);
+    rc = os_mbuf_copydata(om, i + 1, 1, &u8);
     TEST_ASSERT(rc != 0);
-
-    /* Remove the read response from the buffer. */
-    os_mbuf_adj(ble_hs_test_util_prev_tx, attr_len + 1);
 }
 
 static void
 ble_att_svr_test_misc_verify_tx_read_blob_rsp(struct ble_l2cap_chan *chan,
                                               uint8_t *attr_data, int attr_len)
 {
+    struct os_mbuf *om;
     uint8_t u8;
     int rc;
     int i;
 
     ble_hs_test_util_tx_all();
 
-    rc = os_mbuf_copydata(ble_hs_test_util_prev_tx, 0, 1, &u8);
+    om = ble_hs_test_util_prev_tx_dequeue();
+
+    rc = os_mbuf_copydata(om, 0, 1, &u8);
     TEST_ASSERT(rc == 0);
     TEST_ASSERT(u8 == BLE_ATT_OP_READ_BLOB_RSP);
 
     for (i = 0; i < attr_len; i++) {
-        rc = os_mbuf_copydata(ble_hs_test_util_prev_tx, i + 1, 1, &u8);
+        rc = os_mbuf_copydata(om, i + 1, 1, &u8);
         TEST_ASSERT(rc == 0);
         TEST_ASSERT(u8 == attr_data[i]);
     }
 
-    rc = os_mbuf_copydata(ble_hs_test_util_prev_tx, i + 1, 1, &u8);
+    rc = os_mbuf_copydata(om, i + 1, 1, &u8);
     TEST_ASSERT(rc != 0);
-
-    /* Remove the read response from the buffer. */
-    os_mbuf_adj(ble_hs_test_util_prev_tx, attr_len + 1);
 }
 
 static void
@@ -406,6 +406,7 @@ ble_att_svr_test_misc_verify_tx_read_mult_rsp(struct ble_l2cap_chan *chan,
                                               struct ble_gatt_attr *attrs,
                                               int num_attrs)
 {
+    struct os_mbuf *om;
     uint8_t *attr_value;
     uint8_t u8;
     int rc;
@@ -415,7 +416,9 @@ ble_att_svr_test_misc_verify_tx_read_mult_rsp(struct ble_l2cap_chan *chan,
 
     ble_hs_test_util_tx_all();
 
-    rc = os_mbuf_copydata(ble_hs_test_util_prev_tx, 0, 1, &u8);
+    om = ble_hs_test_util_prev_tx_dequeue();
+
+    rc = os_mbuf_copydata(om, 0, 1, &u8);
     TEST_ASSERT(rc == 0);
     TEST_ASSERT(u8 == BLE_ATT_OP_READ_MULT_RSP);
 
@@ -427,7 +430,7 @@ ble_att_svr_test_misc_verify_tx_read_mult_rsp(struct ble_l2cap_chan *chan,
              ii < attrs[i].value_len && off < ble_l2cap_chan_mtu(chan);
              ii++) {
 
-            rc = os_mbuf_copydata(ble_hs_test_util_prev_tx, off, 1, &u8);
+            rc = os_mbuf_copydata(om, off, 1, &u8);
             TEST_ASSERT(rc == 0);
             TEST_ASSERT(u8 == attr_value[ii]);
 
@@ -435,7 +438,7 @@ ble_att_svr_test_misc_verify_tx_read_mult_rsp(struct ble_l2cap_chan *chan,
         }
     }
 
-    rc = os_mbuf_copydata(ble_hs_test_util_prev_tx, off, 1, &u8);
+    rc = os_mbuf_copydata(om, off, 1, &u8);
     TEST_ASSERT(rc != 0);
 }
 
@@ -462,39 +465,37 @@ ble_att_svr_test_misc_verify_all_read_mult(struct ble_hs_conn *conn,
 static void
 ble_att_svr_test_misc_verify_tx_write_rsp(struct ble_l2cap_chan *chan)
 {
+    struct os_mbuf *om;
     uint8_t u8;
     int rc;
 
     ble_hs_test_util_tx_all();
 
-    rc = os_mbuf_copydata(ble_hs_test_util_prev_tx, 0, 1, &u8);
+    om = ble_hs_test_util_prev_tx_dequeue();
+
+    rc = os_mbuf_copydata(om, 0, 1, &u8);
     TEST_ASSERT(rc == 0);
     TEST_ASSERT(u8 == BLE_ATT_OP_WRITE_RSP);
-
-    /* Remove the write response from the buffer. */
-    os_mbuf_adj(ble_hs_test_util_prev_tx,
-                BLE_ATT_WRITE_RSP_SZ);
 }
 
 static void
 ble_att_svr_test_misc_verify_tx_mtu_rsp(struct ble_l2cap_chan *chan)
 {
     struct ble_att_mtu_cmd rsp;
+    struct os_mbuf *om;
     uint8_t buf[BLE_ATT_MTU_CMD_SZ];
     int rc;
 
     ble_hs_test_util_tx_all();
 
-    rc = os_mbuf_copydata(ble_hs_test_util_prev_tx, 0, sizeof buf, buf);
+    om = ble_hs_test_util_prev_tx_dequeue();
+
+    rc = os_mbuf_copydata(om, 0, sizeof buf, buf);
     TEST_ASSERT(rc == 0);
 
     ble_att_mtu_cmd_parse(buf, sizeof buf, &rsp);
 
     TEST_ASSERT(rsp.bamc_mtu == chan->blc_my_mtu);
-
-    /* Remove the write response from the buffer. */
-    os_mbuf_adj(ble_hs_test_util_prev_tx,
-                BLE_ATT_MTU_CMD_SZ);
 }
 
 struct ble_att_svr_test_info_entry {
@@ -510,6 +511,7 @@ ble_att_svr_test_misc_verify_tx_find_info_rsp(
 {
     struct ble_att_svr_test_info_entry *entry;
     struct ble_att_find_info_rsp rsp;
+    struct os_mbuf *om;
     uint16_t handle;
     uint16_t uuid16;
     uint8_t buf[BLE_ATT_FIND_INFO_RSP_BASE_SZ];
@@ -521,14 +523,16 @@ ble_att_svr_test_misc_verify_tx_find_info_rsp(
 
     off = 0;
 
-    rc = os_mbuf_copydata(ble_hs_test_util_prev_tx, off, sizeof buf, buf);
+    om = ble_hs_test_util_prev_tx_dequeue_pullup();
+
+    rc = os_mbuf_copydata(om, off, sizeof buf, buf);
     TEST_ASSERT(rc == 0);
     off += sizeof buf;
 
     ble_att_find_info_rsp_parse(buf, sizeof buf, &rsp);
 
     for (entry = entries; entry->handle != 0; entry++) {
-        rc = os_mbuf_copydata(ble_hs_test_util_prev_tx, off, 2, &handle);
+        rc = os_mbuf_copydata(om, off, 2, &handle);
         TEST_ASSERT(rc == 0);
         off += 2;
 
@@ -538,7 +542,7 @@ ble_att_svr_test_misc_verify_tx_find_info_rsp(
         if (entry->uuid16 != 0) {
             TEST_ASSERT(rsp.bafp_format ==
                         BLE_ATT_FIND_INFO_RSP_FORMAT_16BIT);
-            rc = os_mbuf_copydata(ble_hs_test_util_prev_tx, off, 2, &uuid16);
+            rc = os_mbuf_copydata(om, off, 2, &uuid16);
             TEST_ASSERT(rc == 0);
             off += 2;
 
@@ -547,7 +551,7 @@ ble_att_svr_test_misc_verify_tx_find_info_rsp(
         } else {
             TEST_ASSERT(rsp.bafp_format ==
                         BLE_ATT_FIND_INFO_RSP_FORMAT_128BIT);
-            rc = os_mbuf_copydata(ble_hs_test_util_prev_tx, off, 16, uuid128);
+            rc = os_mbuf_copydata(om, off, 16, uuid128);
             TEST_ASSERT(rc == 0);
             off += 16;
 
@@ -556,10 +560,7 @@ ble_att_svr_test_misc_verify_tx_find_info_rsp(
     }
 
     /* Ensure there is no extra data in the response. */
-    TEST_ASSERT(off == OS_MBUF_PKTHDR(ble_hs_test_util_prev_tx)->omp_len);
-
-    /* Remove the response from the buffer. */
-    os_mbuf_adj(ble_hs_test_util_prev_tx, off);
+    TEST_ASSERT(off == OS_MBUF_PKTHDR(om)->omp_len);
 }
 
 struct ble_att_svr_test_type_value_entry {
@@ -573,6 +574,7 @@ ble_att_svr_test_misc_verify_tx_find_type_value_rsp(
     struct ble_att_svr_test_type_value_entry *entries)
 {
     struct ble_att_svr_test_type_value_entry *entry;
+    struct os_mbuf *om;
     uint16_t u16;
     uint8_t op;
     int off;
@@ -582,20 +584,22 @@ ble_att_svr_test_misc_verify_tx_find_type_value_rsp(
 
     off = 0;
 
-    rc = os_mbuf_copydata(ble_hs_test_util_prev_tx, off, 1, &op);
+    om = ble_hs_test_util_prev_tx_dequeue_pullup();
+
+    rc = os_mbuf_copydata(om, off, 1, &op);
     TEST_ASSERT(rc == 0);
     off += 1;
 
     TEST_ASSERT(op == BLE_ATT_OP_FIND_TYPE_VALUE_RSP);
 
     for (entry = entries; entry->first != 0; entry++) {
-        rc = os_mbuf_copydata(ble_hs_test_util_prev_tx, off, 2, &u16);
+        rc = os_mbuf_copydata(om, off, 2, &u16);
         TEST_ASSERT(rc == 0);
         htole16(&u16, u16);
         TEST_ASSERT(u16 == entry->first);
         off += 2;
 
-        rc = os_mbuf_copydata(ble_hs_test_util_prev_tx, off, 2, &u16);
+        rc = os_mbuf_copydata(om, off, 2, &u16);
         TEST_ASSERT(rc == 0);
         htole16(&u16, u16);
         TEST_ASSERT(u16 == entry->last);
@@ -603,10 +607,7 @@ ble_att_svr_test_misc_verify_tx_find_type_value_rsp(
     }
 
     /* Ensure there is no extra data in the response. */
-    TEST_ASSERT(off == OS_MBUF_PKTHDR(ble_hs_test_util_prev_tx)->omp_len);
-
-    /* Remove the response from the buffer. */
-    os_mbuf_adj(ble_hs_test_util_prev_tx, off);
+    TEST_ASSERT(off == OS_MBUF_PKTHDR(om)->omp_len);
 }
 
 struct ble_att_svr_test_group_type_entry {
@@ -632,9 +633,7 @@ ble_att_svr_test_misc_verify_tx_read_group_type_rsp(
 
     ble_hs_test_util_tx_all();
 
-    om = os_mbuf_pullup(ble_hs_test_util_prev_tx,
-                        BLE_ATT_READ_GROUP_TYPE_RSP_BASE_SZ);
-    TEST_ASSERT_FATAL(om != NULL);
+    om = ble_hs_test_util_prev_tx_dequeue_pullup();
 
     ble_att_read_group_type_rsp_parse(om->om_data, om->om_len, &rsp);
 
@@ -704,9 +703,7 @@ ble_att_svr_test_misc_verify_tx_read_type_rsp(
 
     ble_hs_test_util_tx_all();
 
-    om = os_mbuf_pullup(ble_hs_test_util_prev_tx,
-                        BLE_ATT_READ_TYPE_RSP_BASE_SZ);
-    TEST_ASSERT_FATAL(om != NULL);
+    om = ble_hs_test_util_prev_tx_dequeue_pullup();
 
     ble_att_read_type_rsp_parse(om->om_data, om->om_len, &rsp);
 
@@ -738,13 +735,15 @@ ble_att_svr_test_misc_verify_tx_prep_write_rsp(struct ble_l2cap_chan *chan,
                                                void *data, int data_len)
 {
     struct ble_att_prep_write_cmd rsp;
+    struct os_mbuf *om;
     uint8_t buf[1024];
     int rc;
 
     ble_hs_test_util_tx_all();
 
-    rc = os_mbuf_copydata(ble_hs_test_util_prev_tx, 0,
-                          OS_MBUF_PKTLEN(ble_hs_test_util_prev_tx), buf);
+    om = ble_hs_test_util_prev_tx_dequeue();
+
+    rc = os_mbuf_copydata(om, 0, OS_MBUF_PKTLEN(om), buf);
     TEST_ASSERT_FATAL(rc == 0);
 
     ble_att_prep_write_rsp_parse(buf, sizeof buf, &rsp);
@@ -754,7 +753,7 @@ ble_att_svr_test_misc_verify_tx_prep_write_rsp(struct ble_l2cap_chan *chan,
     TEST_ASSERT(memcmp(buf + BLE_ATT_PREP_WRITE_CMD_BASE_SZ, data,
                        data_len) == 0);
 
-    TEST_ASSERT(OS_MBUF_PKTLEN(ble_hs_test_util_prev_tx) ==
+    TEST_ASSERT(OS_MBUF_PKTLEN(om) ==
                 BLE_ATT_PREP_WRITE_CMD_BASE_SZ + data_len);
 }
 
@@ -765,9 +764,7 @@ ble_att_svr_test_misc_verify_tx_exec_write_rsp(struct ble_l2cap_chan *chan)
 
     ble_hs_test_util_tx_all();
 
-    om = os_mbuf_pullup(ble_hs_test_util_prev_tx, BLE_ATT_EXEC_WRITE_RSP_SZ);
-    TEST_ASSERT_FATAL(om != NULL);
-
+    om = ble_hs_test_util_prev_tx_dequeue_pullup();
     ble_att_exec_write_rsp_parse(om->om_data, om->om_len);
 }
 
@@ -934,8 +931,7 @@ ble_att_svr_test_misc_verify_tx_indicate_rsp(struct ble_l2cap_chan *chan)
 
     ble_hs_test_util_tx_all();
 
-    om = os_mbuf_pullup(ble_hs_test_util_prev_tx, BLE_ATT_INDICATE_RSP_SZ);
-    TEST_ASSERT_FATAL(om != NULL);
+    om = ble_hs_test_util_prev_tx_dequeue_pullup();
 
     ble_att_indicate_rsp_parse(om->om_data, om->om_len);
 }
@@ -988,13 +984,14 @@ ble_att_svr_test_misc_verify_indicate(struct ble_hs_conn *conn,
         TEST_ASSERT(ble_att_svr_test_n_attr_handle == attr_handle);
         TEST_ASSERT(ble_att_svr_test_attr_n_len == attr_len);
         TEST_ASSERT(memcmp(ble_att_svr_test_attr_n, attr_val, attr_len) == 0);
+        ble_att_svr_test_misc_verify_tx_indicate_rsp(chan);
     } else {
         TEST_ASSERT(ble_att_svr_test_n_conn_handle == 0xffff);
         TEST_ASSERT(ble_att_svr_test_n_attr_handle == 0);
         TEST_ASSERT(ble_att_svr_test_attr_n_len == 0);
+        ble_hs_test_util_tx_all();
+        TEST_ASSERT(ble_hs_test_util_prev_tx_queue_sz() == 0);
     }
-
-    ble_att_svr_test_misc_verify_tx_indicate_rsp(chan);
 }
 
 TEST_CASE(ble_att_svr_test_mtu)
diff --git a/net/nimble/host/src/test/ble_gatt_find_s_test.c b/net/nimble/host/src/test/ble_gatt_find_s_test.c
index 24b2dccd..6b360c6b 100644
--- a/net/nimble/host/src/test/ble_gatt_find_s_test.c
+++ b/net/nimble/host/src/test/ble_gatt_find_s_test.c
@@ -152,10 +152,7 @@ ble_gatt_find_s_test_misc_verify_tx_read_type(uint16_t start_handle,
 
     ble_hs_test_util_tx_all();
 
-    TEST_ASSERT_FATAL(ble_hs_test_util_prev_tx != NULL);
-
-    om = os_mbuf_pullup(ble_hs_test_util_prev_tx,
-                        OS_MBUF_PKTLEN(ble_hs_test_util_prev_tx));
+    om = ble_hs_test_util_prev_tx_dequeue_pullup();
     TEST_ASSERT_FATAL(om != NULL);
 
     ble_att_read_type_req_parse(om->om_data, om->om_len, &req);
@@ -175,10 +172,7 @@ ble_gatt_find_s_test_misc_verify_tx_read(uint16_t handle)
 
     ble_hs_test_util_tx_all();
 
-    TEST_ASSERT_FATAL(ble_hs_test_util_prev_tx != NULL);
-
-    om = os_mbuf_pullup(ble_hs_test_util_prev_tx,
-                        OS_MBUF_PKTLEN(ble_hs_test_util_prev_tx));
+    om = ble_hs_test_util_prev_tx_dequeue_pullup();
     TEST_ASSERT_FATAL(om != NULL);
 
     ble_att_read_req_parse(om->om_data, om->om_len, &req);
diff --git a/net/nimble/host/src/test/ble_gatts_notify_test.c b/net/nimble/host/src/test/ble_gatts_notify_test.c
index a1b9e572..b0e079b5 100644
--- a/net/nimble/host/src/test/ble_gatts_notify_test.c
+++ b/net/nimble/host/src/test/ble_gatts_notify_test.c
@@ -178,22 +178,20 @@ static void
 ble_gatts_notify_test_misc_verify_tx_n(struct ble_l2cap_chan *chan,
                                        uint8_t *attr_data, int attr_len)
 {
-    uint8_t buf[1024];
     struct ble_att_notify_req req;
-    int req_len;
-    int rc;
+    struct os_mbuf *om;
     int i;
 
     ble_hs_test_util_tx_all();
 
-    req_len = OS_MBUF_PKTLEN(ble_hs_test_util_prev_tx);
-    rc = os_mbuf_copydata(ble_hs_test_util_prev_tx, 0, req_len, buf);
-    TEST_ASSERT_FATAL(rc == 0);
+    om = ble_hs_test_util_prev_tx_dequeue_pullup();
+    TEST_ASSERT_FATAL(om != NULL);
 
-    ble_att_notify_req_parse(buf, req_len, &req);
+    ble_att_notify_req_parse(om->om_data, om->om_len, &req);
 
     for (i = 0; i < attr_len; i++) {
-        TEST_ASSERT(buf[BLE_ATT_NOTIFY_REQ_BASE_SZ + i] == attr_data[i]);
+        TEST_ASSERT(om->om_data[BLE_ATT_NOTIFY_REQ_BASE_SZ + i] ==
+                    attr_data[i]);
     }
 }
 
@@ -201,22 +199,20 @@ static void
 ble_gatts_notify_test_misc_verify_tx_i(struct ble_l2cap_chan *chan,
                                        uint8_t *attr_data, int attr_len)
 {
-    uint8_t buf[1024];
     struct ble_att_indicate_req req;
-    int req_len;
-    int rc;
+    struct os_mbuf *om;
     int i;
 
     ble_hs_test_util_tx_all();
 
-    req_len = OS_MBUF_PKTLEN(ble_hs_test_util_prev_tx);
-    rc = os_mbuf_copydata(ble_hs_test_util_prev_tx, 0, req_len, buf);
-    TEST_ASSERT_FATAL(rc == 0);
+    om = ble_hs_test_util_prev_tx_dequeue_pullup();
+    TEST_ASSERT_FATAL(om != NULL);
 
-    ble_att_indicate_req_parse(buf, req_len, &req);
+    ble_att_indicate_req_parse(om->om_data, om->om_len, &req);
 
     for (i = 0; i < attr_len; i++) {
-        TEST_ASSERT(buf[BLE_ATT_INDICATE_REQ_BASE_SZ + i] == attr_data[i]);
+        TEST_ASSERT(om->om_data[BLE_ATT_INDICATE_REQ_BASE_SZ + i] ==
+                    attr_data[i]);
     }
 }
 
@@ -272,6 +268,11 @@ TEST_CASE(ble_gatts_notify_test_i)
         conn, chan, ble_gatts_notify_test_chr_2_def_handle,
         BLE_GATTS_CLT_CFG_F_INDICATE);
 
+    /* Toss both write responses. */
+    ble_hs_test_util_tx_all();
+    ble_hs_test_util_prev_tx_dequeue();
+    ble_hs_test_util_prev_tx_dequeue();
+
     /* Update characteristic 1's value. */
     ble_gatts_notify_test_chr_1_len = 1;
     ble_gatts_notify_test_chr_1_val[0] = 0xab;
@@ -283,9 +284,6 @@ TEST_CASE(ble_gatts_notify_test_i)
         ble_gatts_notify_test_chr_1_val,
         ble_gatts_notify_test_chr_1_len);
 
-    os_mbuf_free_chain(ble_hs_test_util_prev_tx);
-    ble_hs_test_util_prev_tx = NULL;
-
     /* Update characteristic 2's value. */
     ble_gatts_notify_test_chr_2_len = 16;
     memcpy(ble_gatts_notify_test_chr_2_val,
@@ -295,12 +293,14 @@ TEST_CASE(ble_gatts_notify_test_i)
     /* Verify the second indication doesn't get sent until the first is
      * confirmed.
      */
-    TEST_ASSERT(ble_hs_test_util_prev_tx == NULL);
+    ble_hs_test_util_tx_all();
+    TEST_ASSERT(ble_hs_test_util_prev_tx_queue_sz() == 0);
 
     /* Receive the confirmation for the first indication. */
     ble_gatts_notify_test_misc_rx_indicate_rsp(conn, chan);
 
     /* Verify indication sent properly. */
+    ble_hs_test_util_tx_all();
     ble_gatts_notify_test_misc_verify_tx_i(
         chan,
         ble_gatts_notify_test_chr_2_val,
diff --git a/net/nimble/host/src/test/ble_hs_test.c b/net/nimble/host/src/test/ble_hs_test.c
index 183774eb..aaaf19f9 100644
--- a/net/nimble/host/src/test/ble_hs_test.c
+++ b/net/nimble/host/src/test/ble_hs_test.c
@@ -29,11 +29,9 @@ uint8_t g_dev_addr[BLE_DEV_ADDR_LEN];
 void
 ble_hs_test_pkt_txed(struct os_mbuf *om)
 {
-    os_mbuf_free_chain(ble_hs_test_util_prev_tx);
-    ble_hs_test_util_prev_tx = om;
-
     /* XXX: For now, just strip the HCI ACL data and L2CAP headers. */
     os_mbuf_adj(om, BLE_HCI_DATA_HDR_SZ + BLE_L2CAP_HDR_SZ);
+    ble_hs_test_util_prev_tx_enqueue(om);
 }
 
 void
diff --git a/net/nimble/host/src/test/ble_hs_test_util.c b/net/nimble/host/src/test/ble_hs_test_util.c
index d8c9dab7..87774cb0 100644
--- a/net/nimble/host/src/test/ble_hs_test_util.c
+++ b/net/nimble/host/src/test/ble_hs_test_util.c
@@ -43,15 +43,79 @@ os_membuf_t ble_hs_test_util_mbuf_mpool_data[BLE_HS_TEST_UTIL_MEMPOOL_SIZE];
 struct os_mbuf_pool ble_hs_test_util_mbuf_pool;
 struct os_mempool ble_hs_test_util_mbuf_mpool;
 
-struct os_mbuf *ble_hs_test_util_prev_tx;
+static STAILQ_HEAD(, os_mbuf_pkthdr) ble_hs_test_util_prev_tx_queue;
+struct os_mbuf *ble_hs_test_util_prev_tx_cur;
 
-#define BLE_HS_TEST_UTIL_MAX_PREV_HCI_TXES      64
+#define BLE_HS_TEST_UTIL_PREV_HCI_TX_CNT      64
 static uint8_t
-ble_hs_test_util_prev_hci_tx[BLE_HS_TEST_UTIL_MAX_PREV_HCI_TXES][260];
+ble_hs_test_util_prev_hci_tx[BLE_HS_TEST_UTIL_PREV_HCI_TX_CNT][260];
 int ble_hs_test_util_num_prev_hci_txes;
 
 uint8_t ble_hs_test_util_cur_hci_tx[260];
 
+void
+ble_hs_test_util_prev_tx_enqueue(struct os_mbuf *om)
+{
+    struct os_mbuf_pkthdr *omp;
+
+    assert(OS_MBUF_IS_PKTHDR(om));
+
+    omp = OS_MBUF_PKTHDR(om);
+    if (STAILQ_EMPTY(&ble_hs_test_util_prev_tx_queue)) {
+        STAILQ_INSERT_HEAD(&ble_hs_test_util_prev_tx_queue, omp, omp_next);
+    } else {
+        STAILQ_INSERT_TAIL(&ble_hs_test_util_prev_tx_queue, omp, omp_next);
+    }
+}
+
+struct os_mbuf *
+ble_hs_test_util_prev_tx_dequeue(void)
+{
+    struct os_mbuf_pkthdr *omp;
+
+    os_mbuf_free_chain(ble_hs_test_util_prev_tx_cur);
+
+    omp = STAILQ_LAST(&ble_hs_test_util_prev_tx_queue, os_mbuf_pkthdr,
+                      omp_next);
+    if (omp != NULL) {
+        STAILQ_REMOVE(&ble_hs_test_util_prev_tx_queue, omp, os_mbuf_pkthdr,
+                      omp_next);
+        ble_hs_test_util_prev_tx_cur = OS_MBUF_PKTHDR_TO_MBUF(omp);
+    } else {
+        ble_hs_test_util_prev_tx_cur = NULL;
+    }
+    return ble_hs_test_util_prev_tx_cur;
+}
+
+struct os_mbuf *
+ble_hs_test_util_prev_tx_dequeue_pullup(void)
+{
+    struct os_mbuf *om;
+
+    om = ble_hs_test_util_prev_tx_dequeue();
+    if (om != NULL) {
+        om = os_mbuf_pullup(om, OS_MBUF_PKTLEN(om));
+        TEST_ASSERT_FATAL(om != NULL);
+        ble_hs_test_util_prev_tx_cur = om;
+    }
+
+    return om;
+}
+
+int
+ble_hs_test_util_prev_tx_queue_sz(void)
+{
+    struct os_mbuf_pkthdr *omp;
+    int cnt;
+
+    cnt = 0;
+    STAILQ_FOREACH(omp, &ble_hs_test_util_prev_tx_queue, omp_next) {
+        cnt++;
+    }
+
+    return cnt;
+}
+
 void *
 ble_hs_test_util_get_first_hci_tx(void)
 {
@@ -92,7 +156,7 @@ void
 ble_hs_test_util_enqueue_hci_tx(void *cmd)
 {
     TEST_ASSERT_FATAL(ble_hs_test_util_num_prev_hci_txes <
-                      BLE_HS_TEST_UTIL_MAX_PREV_HCI_TXES);
+                      BLE_HS_TEST_UTIL_PREV_HCI_TX_CNT);
     memcpy(ble_hs_test_util_prev_hci_tx + ble_hs_test_util_num_prev_hci_txes,
            cmd, 260);
 
@@ -644,6 +708,8 @@ ble_hs_test_util_init(void)
     tu_init();
 
     os_eventq_init(&ble_hs_test_util_evq);
+    STAILQ_INIT(&ble_hs_test_util_prev_tx_queue);
+    ble_hs_test_util_prev_tx_cur = NULL;
 
     os_msys_reset();
     stats_module_reset();
@@ -674,6 +740,5 @@ ble_hs_test_util_init(void)
     /* Don't limit a connection's ability to transmit; simplify tests. */
     ble_hs_cfg.max_outstanding_pkts_per_conn = 0;
 
-    ble_hs_test_util_prev_tx = NULL;
     ble_hs_test_util_prev_hci_tx_clear();
 }
diff --git a/net/nimble/host/src/test/ble_hs_test_util.h b/net/nimble/host/src/test/ble_hs_test_util.h
index aea5f08b..0dc5caff 100644
--- a/net/nimble/host/src/test/ble_hs_test_util.h
+++ b/net/nimble/host/src/test/ble_hs_test_util.h
@@ -27,13 +27,17 @@ struct ble_hs_conn;
 struct ble_l2cap_chan;
 
 struct os_eventq ble_hs_test_util_evq;
-extern struct os_mbuf *ble_hs_test_util_prev_tx;
 
 struct ble_hs_test_util_num_completed_pkts_entry {
     uint16_t handle_id; /* 0 for terminating entry in array. */
     uint16_t num_pkts;
 };
 
+void ble_hs_test_util_prev_tx_enqueue(struct os_mbuf *om);
+struct os_mbuf *ble_hs_test_util_prev_tx_dequeue(void);
+struct os_mbuf *ble_hs_test_util_prev_tx_dequeue_pullup(void);
+int ble_hs_test_util_prev_tx_queue_sz(void);
+
 void ble_hs_test_util_set_ack_params(uint16_t opcode, uint8_t status,
                                      void *params, uint8_t params_len);
 void ble_hs_test_util_set_ack(uint16_t opcode, uint8_t status);
diff --git a/net/nimble/host/src/test/ble_l2cap_sm_test.c b/net/nimble/host/src/test/ble_l2cap_sm_test.c
index ad39ab02..a0a2f193 100644
--- a/net/nimble/host/src/test/ble_l2cap_sm_test.c
+++ b/net/nimble/host/src/test/ble_l2cap_sm_test.c
@@ -211,17 +211,21 @@ ble_l2cap_sm_test_util_rx_random(struct ble_hs_conn *conn,
     TEST_ASSERT_FATAL(rc == exp_status);
 }
 
-static void
+static struct os_mbuf *
 ble_l2cap_sm_test_util_verify_tx_hdr(uint8_t sm_op, uint16_t payload_len)
 {
-    TEST_ASSERT_FATAL(ble_hs_test_util_prev_tx != NULL);
-    TEST_ASSERT(OS_MBUF_PKTLEN(ble_hs_test_util_prev_tx) ==
-                BLE_L2CAP_SM_HDR_SZ + payload_len);
+    struct os_mbuf *om;
+
+    om = ble_hs_test_util_prev_tx_dequeue();
+    TEST_ASSERT_FATAL(om != NULL);
 
-    TEST_ASSERT_FATAL(ble_hs_test_util_prev_tx->om_data[0] == sm_op);
+    TEST_ASSERT(OS_MBUF_PKTLEN(om) == BLE_L2CAP_SM_HDR_SZ + payload_len);
+    TEST_ASSERT_FATAL(om->om_data[0] == sm_op);
 
-    ble_hs_test_util_prev_tx->om_data += BLE_L2CAP_SM_HDR_SZ;
-    ble_hs_test_util_prev_tx->om_len -= BLE_L2CAP_SM_HDR_SZ;
+    om->om_data += BLE_L2CAP_SM_HDR_SZ;
+    om->om_len -= BLE_L2CAP_SM_HDR_SZ;
+
+    return om;
 }
 
 static void
@@ -230,12 +234,10 @@ ble_l2cap_sm_test_util_verify_tx_pair_cmd(
     struct ble_l2cap_sm_pair_cmd *exp_cmd)
 {
     struct ble_l2cap_sm_pair_cmd cmd;
+    struct os_mbuf *om;
 
-    ble_l2cap_sm_test_util_verify_tx_hdr(op, BLE_L2CAP_SM_PAIR_CMD_SZ);
-
-    ble_l2cap_sm_pair_cmd_parse(ble_hs_test_util_prev_tx->om_data,
-                                ble_hs_test_util_prev_tx->om_len,
-                                &cmd);
+    om = ble_l2cap_sm_test_util_verify_tx_hdr(op, BLE_L2CAP_SM_PAIR_CMD_SZ);
+    ble_l2cap_sm_pair_cmd_parse(om->om_data, om->om_len, &cmd);
 
     TEST_ASSERT(cmd.io_cap == exp_cmd->io_cap);
     TEST_ASSERT(cmd.oob_data_flag == exp_cmd->oob_data_flag);
@@ -266,13 +268,11 @@ ble_l2cap_sm_test_util_verify_tx_pair_confirm(
     struct ble_l2cap_sm_pair_confirm *exp_cmd)
 {
     struct ble_l2cap_sm_pair_confirm cmd;
+    struct os_mbuf *om;
 
-    ble_l2cap_sm_test_util_verify_tx_hdr(BLE_L2CAP_SM_OP_PAIR_CONFIRM,
-                                         BLE_L2CAP_SM_PAIR_CONFIRM_SZ);
-
-    ble_l2cap_sm_pair_confirm_parse(ble_hs_test_util_prev_tx->om_data,
-                                    ble_hs_test_util_prev_tx->om_len,
-                                    &cmd);
+    om = ble_l2cap_sm_test_util_verify_tx_hdr(BLE_L2CAP_SM_OP_PAIR_CONFIRM,
+                                              BLE_L2CAP_SM_PAIR_CONFIRM_SZ);
+    ble_l2cap_sm_pair_confirm_parse(om->om_data, om->om_len, &cmd);
 
     TEST_ASSERT(memcmp(cmd.value, exp_cmd->value, 16) == 0);
 }
@@ -282,13 +282,11 @@ ble_l2cap_sm_test_util_verify_tx_pair_random(
     struct ble_l2cap_sm_pair_random *exp_cmd)
 {
     struct ble_l2cap_sm_pair_random cmd;
+    struct os_mbuf *om;
 
-    ble_l2cap_sm_test_util_verify_tx_hdr(BLE_L2CAP_SM_OP_PAIR_RANDOM,
-                                         BLE_L2CAP_SM_PAIR_RANDOM_SZ);
-
-    ble_l2cap_sm_pair_random_parse(ble_hs_test_util_prev_tx->om_data,
-                                   ble_hs_test_util_prev_tx->om_len,
-                                   &cmd);
+    om = ble_l2cap_sm_test_util_verify_tx_hdr(BLE_L2CAP_SM_OP_PAIR_RANDOM,
+                                              BLE_L2CAP_SM_PAIR_RANDOM_SZ);
+    ble_l2cap_sm_pair_random_parse(om->om_data, om->om_len, &cmd);
 
     TEST_ASSERT(memcmp(cmd.value, exp_cmd->value, 16) == 0);
 }
@@ -298,13 +296,11 @@ ble_l2cap_sm_test_util_verify_tx_pair_fail(
     struct ble_l2cap_sm_pair_fail *exp_cmd)
 {
     struct ble_l2cap_sm_pair_fail cmd;
+    struct os_mbuf *om;
 
-    ble_l2cap_sm_test_util_verify_tx_hdr(BLE_L2CAP_SM_OP_PAIR_FAIL,
-                                         BLE_L2CAP_SM_PAIR_FAIL_SZ);
-
-    ble_l2cap_sm_pair_fail_parse(ble_hs_test_util_prev_tx->om_data,
-                                 ble_hs_test_util_prev_tx->om_len,
-                                 &cmd);
+    om = ble_l2cap_sm_test_util_verify_tx_hdr(BLE_L2CAP_SM_OP_PAIR_FAIL,
+                                              BLE_L2CAP_SM_PAIR_FAIL_SZ);
+    ble_l2cap_sm_pair_fail_parse(om->om_data, om->om_len, &cmd);
 
     TEST_ASSERT(cmd.reason == exp_cmd->reason);
 }
@@ -1337,6 +1333,8 @@ ble_l2cap_sm_test_util_us_lgcy_good(
     TEST_ASSERT(!conn->bhc_sec_state.enc_enabled);
     TEST_ASSERT(ble_l2cap_sm_dbg_num_procs() == 1);
 
+    /* Ensure keys are distributed, if necessary. */
+
     /* Ensure we sent the expected start encryption command. */
     ble_hs_test_util_tx_all();
     ble_l2cap_sm_test_util_verify_tx_start_enc(2, r, ediv, stk);
diff --git a/net/nimble/host/src/test/ble_l2cap_test.c b/net/nimble/host/src/test/ble_l2cap_test.c
index 9cde6421..0229a542 100644
--- a/net/nimble/host/src/test/ble_l2cap_test.c
+++ b/net/nimble/host/src/test/ble_l2cap_test.c
@@ -106,6 +106,36 @@ ble_l2cap_test_util_rx_update_rsp(struct ble_hs_conn *conn,
     return rc;
 }
 
+
+static struct os_mbuf *
+ble_l2cap_test_util_verify_tx_sig_hdr(uint8_t op, uint8_t id,
+                                      uint16_t payload_len,
+                                      struct ble_l2cap_sig_hdr *out_hdr)
+{
+    struct ble_l2cap_sig_hdr hdr;
+    struct os_mbuf *om;
+
+    om = ble_hs_test_util_prev_tx_dequeue();
+    TEST_ASSERT_FATAL(om != NULL);
+
+    TEST_ASSERT(OS_MBUF_PKTLEN(om) == BLE_L2CAP_SIG_HDR_SZ + payload_len);
+    ble_l2cap_sig_hdr_parse(om->om_data, om->om_len, &hdr);
+    TEST_ASSERT(hdr.op == op);
+    if (id != 0) {
+        TEST_ASSERT(hdr.identifier == id);
+    }
+    TEST_ASSERT(hdr.length == payload_len);
+
+    om->om_data += BLE_L2CAP_SIG_HDR_SZ;
+    om->om_len -= BLE_L2CAP_SIG_HDR_SZ;
+
+    if (out_hdr != NULL) {
+        *out_hdr = hdr;
+    }
+
+    return om;
+}
+
 /**
  * @return                      The L2CAP sig identifier in the request.
  */
@@ -115,21 +145,14 @@ ble_l2cap_test_util_verify_tx_update_req(
 {
     struct ble_l2cap_sig_update_req req;
     struct ble_l2cap_sig_hdr hdr;
+    struct os_mbuf *om;
 
-    TEST_ASSERT_FATAL(ble_hs_test_util_prev_tx != NULL);
-    TEST_ASSERT(OS_MBUF_PKTLEN(ble_hs_test_util_prev_tx) ==
-                BLE_L2CAP_SIG_HDR_SZ + BLE_L2CAP_SIG_UPDATE_REQ_SZ);
-    ble_l2cap_sig_hdr_parse(ble_hs_test_util_prev_tx->om_data,
-                            ble_hs_test_util_prev_tx->om_len, &hdr);
-
-    ble_hs_test_util_prev_tx->om_data += BLE_L2CAP_SIG_HDR_SZ;
-    ble_hs_test_util_prev_tx->om_len -= BLE_L2CAP_SIG_HDR_SZ;
+    om = ble_l2cap_test_util_verify_tx_sig_hdr(BLE_L2CAP_SIG_OP_UPDATE_REQ, 0,
+                                               BLE_L2CAP_SIG_UPDATE_REQ_SZ,
+                                               &hdr);
 
-    ble_l2cap_sig_update_req_parse(ble_hs_test_util_prev_tx->om_data,
-                                   ble_hs_test_util_prev_tx->om_len,
-                                   &req);
-    TEST_ASSERT(hdr.op == BLE_L2CAP_SIG_OP_UPDATE_REQ);
-    TEST_ASSERT(hdr.length == BLE_L2CAP_SIG_UPDATE_REQ_SZ);
+    /* Verify payload. */
+    ble_l2cap_sig_update_req_parse(om->om_data, om->om_len, &req);
     TEST_ASSERT(req.itvl_min == params->itvl_min);
     TEST_ASSERT(req.itvl_max == params->itvl_max);
     TEST_ASSERT(req.slave_latency == params->slave_latency);
@@ -142,23 +165,14 @@ static void
 ble_l2cap_test_util_verify_tx_update_rsp(uint8_t exp_id, uint16_t exp_result)
 {
     struct ble_l2cap_sig_update_rsp rsp;
-    struct ble_l2cap_sig_hdr hdr;
+    struct os_mbuf *om;
+
+    om = ble_l2cap_test_util_verify_tx_sig_hdr(BLE_L2CAP_SIG_OP_UPDATE_RSP,
+                                               exp_id,
+                                               BLE_L2CAP_SIG_UPDATE_RSP_SZ,
+                                               NULL);
 
-    TEST_ASSERT_FATAL(ble_hs_test_util_prev_tx != NULL);
-    TEST_ASSERT(OS_MBUF_PKTLEN(ble_hs_test_util_prev_tx) ==
-                BLE_L2CAP_SIG_HDR_SZ + BLE_L2CAP_SIG_UPDATE_RSP_SZ);
-    ble_l2cap_sig_hdr_parse(ble_hs_test_util_prev_tx->om_data,
-                            ble_hs_test_util_prev_tx->om_len, &hdr);
-
-    ble_hs_test_util_prev_tx->om_data += BLE_L2CAP_SIG_HDR_SZ;
-    ble_hs_test_util_prev_tx->om_len -= BLE_L2CAP_SIG_HDR_SZ;
-
-    ble_l2cap_sig_update_rsp_parse(ble_hs_test_util_prev_tx->om_data,
-                                   ble_hs_test_util_prev_tx->om_len,
-                                   &rsp);
-    TEST_ASSERT(hdr.op == BLE_L2CAP_SIG_OP_UPDATE_RSP);
-    TEST_ASSERT(hdr.identifier == exp_id);
-    TEST_ASSERT(hdr.length == BLE_L2CAP_SIG_UPDATE_RSP_SZ);
+    ble_l2cap_sig_update_rsp_parse(om->om_data, om->om_len, &rsp);
     TEST_ASSERT(rsp.result == exp_result);
 }
 
@@ -424,7 +438,7 @@ TEST_CASE(ble_l2cap_test_case_sig_unsol_rsp)
 
     /* Ensure we did not send anything in return. */
     ble_hs_test_util_tx_all();
-    TEST_ASSERT_FATAL(ble_hs_test_util_prev_tx == NULL);
+    TEST_ASSERT_FATAL(ble_hs_test_util_prev_tx_dequeue() == NULL);
 }
 
 /*****************************************************************************