Google Git
Sign in
pigweed / third_party / github / zephyrproject-rtos / zephyr / d5775ea7baee424cdba1c31555065f980f7a7903 / . / tests / bluetooth / ctrl_isoal / src / sub_sets / isoal_test_tx.c
blob: e20de78ae4aeb04bb9f2dac20596bc6b70e4cb20 [file] [log] [blame]
/*
* Copyright (c) 2020 Demant
*
* SPDX-License-Identifier: Apache-2.0
*
* Run this test from zephyr directory as:
*
* ./scripts/twister --coverage -p native_posix -v -T tests/bluetooth/ctrl_isoal/
*
*/
/* Each segment header in a test would usually be written to when it is first
* inserted and again when the segment is finalized.
*/
#define EXPECTED_SEG_HDR_WRITES (2)
/*------------------ PDU Allocation Callback ---------------------------------*/
/* Fake function */
FAKE_VALUE_FUNC(isoal_status_t, source_pdu_alloc_test, struct isoal_pdu_buffer *);
/* Customized buffering for data returned in pdu_buffer */
/* Queue for pdu_buffer return data */
static struct {
struct isoal_pdu_buffer out[10];
size_t buffer_size;
size_t pos;
} custom_source_pdu_alloc_test_pdu_buffers;
/* Push to pdu_buffer queue */
static void push_custom_source_pdu_alloc_test_pdu_buffer(struct isoal_pdu_buffer *data)
{
size_t buffer_size = custom_source_pdu_alloc_test_pdu_buffers.buffer_size;
custom_source_pdu_alloc_test_pdu_buffers.out[buffer_size] = *data;
zassert_true(custom_source_pdu_alloc_test_pdu_buffers.buffer_size <=
ARRAY_SIZE(custom_source_pdu_alloc_test_pdu_buffers.out),
"Maximum PDU buffers reached!!");
custom_source_pdu_alloc_test_pdu_buffers.buffer_size++;
}
/* Customized routine for fake function */
static isoal_status_t custom_source_pdu_alloc_test(struct isoal_pdu_buffer *pdu_buffer)
{
isoal_test_debug_trace_func_call(__func__, "IN");
/* Return PDU buffer details as provided by the test */
size_t pos = custom_source_pdu_alloc_test_pdu_buffers.pos;
size_t buffer_size = custom_source_pdu_alloc_test_pdu_buffers.buffer_size;
zassert_not_null(pdu_buffer);
zassert_true(pos < buffer_size,
"No PDU buffers (Allocated %u, required %u)",
buffer_size,
pos);
(void)memcpy(pdu_buffer,
&custom_source_pdu_alloc_test_pdu_buffers.out[pos],
sizeof(*pdu_buffer));
custom_source_pdu_alloc_test_pdu_buffers.pos++;
return source_pdu_alloc_test_fake.return_val;
}
#define SET_NEXT_PDU_ALLOC_BUFFER(_buf) push_custom_source_pdu_alloc_test_pdu_buffer(_buf)
#define PDU_ALLOC_TEST_RETURNS(_status) source_pdu_alloc_test_fake.return_val = _status
#define ZASSERT_PDU_ALLOC_TEST_CALL_COUNT(_expected) \
zassert_equal(_expected, \
source_pdu_alloc_test_fake.call_count, \
"Expected %u got %u", \
_expected, \
source_pdu_alloc_test_fake.call_count)
/*------------------ PDU Write Callback --------------------------------------*/
/* Fake function */
FAKE_VALUE_FUNC(isoal_status_t,
source_pdu_write_test,
struct isoal_pdu_buffer *,
const size_t,
const uint8_t *,
const size_t);
FAKE_VOID_FUNC(source_pdu_write_test_handler, struct isoal_pdu_buffer);
/* Customized buffering for data returned in sdu_payload */
/* Queue for sdu_payload return data */
static struct {
uint8_t out[20][TEST_TX_SDU_FRAG_PAYLOAD_MAX];
size_t out_size[20];
size_t buffer_size;
size_t pos;
} custom_source_pdu_write_test_sdu_payloads;
/* Push to sdu_payload queue */
static void push_custom_source_pdu_write_test_sdu_payload(const uint8_t *data, const size_t length)
{
size_t buffer_size = custom_source_pdu_write_test_sdu_payloads.buffer_size;
zassert_true(length <= TEST_TX_SDU_FRAG_PAYLOAD_MAX,
"Length exceeds TEST_TX_SDU_FRAG_PAYLOAD_MAX");
memcpy(&custom_source_pdu_write_test_sdu_payloads.out[buffer_size][0], data, length);
custom_source_pdu_write_test_sdu_payloads.out_size[buffer_size] = length;
zassert_true(buffer_size <= ARRAY_SIZE(custom_source_pdu_write_test_sdu_payloads.out),
"Maximum SDU payloads reached!!");
custom_source_pdu_write_test_sdu_payloads.buffer_size++;
}
static void check_next_custom_source_pdu_write_test_sdu_payload(const uint8_t *data,
const size_t length)
{
size_t pos = custom_source_pdu_write_test_sdu_payloads.pos;
size_t buffer_size = custom_source_pdu_write_test_sdu_payloads.buffer_size;
zassert_true(pos < buffer_size, "%u exceeds received SDU payloads %u", pos, buffer_size);
zassert_equal(length,
custom_source_pdu_write_test_sdu_payloads.out_size[pos],
"Expected %u != received %u",
length,
custom_source_pdu_write_test_sdu_payloads.out_size[pos]);
for (size_t i = 0; i < custom_source_pdu_write_test_sdu_payloads.out_size[pos]; i++) {
zassert_equal(custom_source_pdu_write_test_sdu_payloads.out[pos][i],
data[i],
"deviation at index %u, expected %u, got %u",
i,
data[i],
custom_source_pdu_write_test_sdu_payloads.out[pos][i]);
}
custom_source_pdu_write_test_sdu_payloads.pos++;
}
/* Customized routine for fake function */
static isoal_status_t custom_source_pdu_write_test(struct isoal_pdu_buffer *pdu_buffer,
const size_t pdu_offset,
const uint8_t *sdu_payload,
const size_t consume_len)
{
isoal_test_debug_trace_func_call(__func__, "IN");
#if defined(DEBUG_TEST)
zassert_not_null(pdu_buffer, "");
zassert_not_null(sdu_payload, "");
zassert_false((pdu_offset + consume_len) > pdu_buffer->size,
"Write size of %u at offset %u exceeds buffer!",
consume_len,
pdu_offset);
/* Copy source to destination at given offset */
memcpy(&pdu_buffer->pdu->payload[pdu_offset], sdu_payload, consume_len);
#endif
/* Return SDU payload details as provided by the test */
zassert_not_null(sdu_payload, NULL);
source_pdu_write_test_handler(*pdu_buffer);
push_custom_source_pdu_write_test_sdu_payload(sdu_payload, consume_len);
return source_pdu_write_test_fake.return_val;
}
#define PDU_WRITE_TEST_RETURNS(_status) source_pdu_write_test_fake.return_val = _status;
#define ZASSERT_PDU_WRITE_TEST(_typ, _pdu_buffer, _pdu_offset, _sdu_payload, _consume_len) \
zassert_equal_ptr(_pdu_buffer.handle, \
source_pdu_write_test_handler_fake.arg0_##_typ.handle, \
"\t\t%p != %p", \
_pdu_buffer.handle, \
source_pdu_write_test_handler_fake.arg0_##_typ.handle); \
zassert_equal_ptr(_pdu_buffer.pdu, \
source_pdu_write_test_handler_fake.arg0_##_typ.pdu, \
"\t\t%p != %p", \
_pdu_buffer.pdu, \
source_pdu_write_test_handler_fake.arg0_##_typ.pdu); \
zassert_equal(_pdu_buffer.size, \
source_pdu_write_test_handler_fake.arg0_##_typ.size, \
"\t\t%u != %u", \
_pdu_buffer.size, \
source_pdu_write_test_handler_fake.arg0_##_typ.size); \
zassert_equal(_pdu_offset, \
source_pdu_write_test_fake.arg1_##_typ, \
"\t\t%u != %u", \
_pdu_offset, \
source_pdu_write_test_fake.arg1_##_typ); \
zassert_equal(_consume_len, \
source_pdu_write_test_fake.arg3_##_typ, \
"\t\t%u != %u", \
_consume_len, \
source_pdu_write_test_fake.arg3_##_typ); \
check_next_custom_source_pdu_write_test_sdu_payload((const uint8_t *)_sdu_payload, \
_consume_len);
#define ZASSERT_PDU_WRITE_TEST_CALL_COUNT(_expected) \
zassert_equal(_expected, \
source_pdu_write_test_fake.call_count, \
"Expected %u, got %u", \
_expected, \
source_pdu_write_test_fake.call_count);
/*------------------ PDU Emit Callback --------------------------------------*/
/**
* Emit the encoded node to the transmission queue
* @param node_tx TX node to enqueue
* @param handle CIS/BIS handle
* @return Error status of enqueue operation
*/
/* Fake function */
FAKE_VALUE_FUNC(isoal_status_t, source_pdu_emit_test, struct node_tx_iso *, const uint16_t);
FAKE_VOID_FUNC(source_pdu_emit_test_handler, struct node_tx_iso, struct pdu_iso);
/* Customized routine for fake function */
static isoal_status_t custom_source_pdu_emit_test(struct node_tx_iso *node_tx,
const uint16_t handle)
{
isoal_test_debug_trace_func_call(__func__, "IN");
zassert_not_null(node_tx);
zassert_not_null(node_tx->pdu);
source_pdu_emit_test_handler(*node_tx, *((struct pdu_iso *)node_tx->pdu));
isoal_test_debug_print_tx_pdu(node_tx);
return source_pdu_emit_test_fake.return_val;
}
#define PDU_EMIT_TEST_RETURNS(_status) source_pdu_emit_test_fake.return_val = _status
#define ZASSERT_PDU_EMIT_TEST(_typ, \
_node_tx, \
_payload_count, \
_sdu_fragments, \
_ll_id, \
_length, \
_handle) \
zassert_equal_ptr(_node_tx, \
source_pdu_emit_test_fake.arg0_##_typ, \
"\t\t%p != %p", \
_node_tx, \
source_pdu_emit_test_fake.arg0_##_typ); \
zassert_equal(_payload_count, \
source_pdu_emit_test_handler_fake.arg0_##_typ.payload_count, \
"\t\t%u != %u", \
_payload_count, \
source_pdu_emit_test_handler_fake.arg0_##_typ.payload_count); \
zassert_equal(_sdu_fragments, \
source_pdu_emit_test_handler_fake.arg0_##_typ.sdu_fragments, \
"\t\t%u != %u", \
_sdu_fragments, \
source_pdu_emit_test_handler_fake.arg0_##_typ.sdu_fragments); \
zassert_equal(_ll_id, \
source_pdu_emit_test_handler_fake.arg1_##_typ.ll_id, \
"\t\t%u != %u", \
_ll_id, \
source_pdu_emit_test_handler_fake.arg1_##_typ.ll_id); \
zassert_equal(_length, \
source_pdu_emit_test_handler_fake.arg1_##_typ.len, \
"\t\t%u != %u", \
_length, \
source_pdu_emit_test_handler_fake.arg1_##_typ.len); \
zassert_equal(bt_iso_handle(_handle), \
source_pdu_emit_test_fake.arg1_##_typ, \
"\t\t%08x != %08x", \
bt_iso_handle(_handle), \
source_pdu_emit_test_fake.arg1_##_typ)
#define ZASSERT_PDU_EMIT_TEST_CALL_COUNT(_expected) \
zassert_equal(_expected, \
source_pdu_emit_test_fake.call_count, \
"Expected %u, got %u", \
_expected, \
source_pdu_emit_test_fake.call_count)
/*------------------ PDU Release Callback --------------------------------------*/
/**
* Test releasing the given payload back to the memory pool.
* @param node_tx TX node to release or forward
* @param handle CIS/BIS handle
* @param status Reason for release
* @return Error status of release operation
*/
/* Fake function */
FAKE_VALUE_FUNC(isoal_status_t,
source_pdu_release_test,
struct node_tx_iso *,
const uint16_t,
const isoal_status_t);
/* Customized routine for fake function */
static isoal_status_t custom_source_pdu_release_test(struct node_tx_iso *node_tx,
const uint16_t handle,
const isoal_status_t status)
{
isoal_test_debug_trace_func_call(__func__, "IN");
return source_pdu_release_test_fake.return_val;
}
#define PDU_RELEASE_TEST_RETURNS(_status) source_pdu_release_test_fake.return_val = _status
#define ZASSERT_PDU_RELEASE_TEST(_typ, _node_tx, _handle, _status) \
zassert_equal_ptr(_node_tx, \
source_pdu_release_test_fake.arg0_##_typ, \
"\t\t%p != %p", \
_node_tx, \
source_pdu_release_test_fake.arg0_##_typ); \
zassert_equal(_handle, \
source_pdu_release_test_fake.arg1_##_typ, \
"\t\t%u != %u", \
_handle, \
source_pdu_release_test_fake.arg1_##_typ); \
zassert_equal(_status, \
source_pdu_release_test_fake.arg2_##_typ, \
"\t\t%u != %u", \
_status, \
source_pdu_release_test_fake.arg2_##_typ)
#define ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(_expected) \
zassert_equal(_expected, \
source_pdu_release_test_fake.call_count, \
"Expected %u, got %u", \
_expected, \
source_pdu_release_test_fake.call_count)
/**
* TX common setup before running tests
* @param f Input configuration parameters
*/
static void isoal_test_tx_common_before(void *f)
{
ARG_UNUSED(f);
custom_source_pdu_alloc_test_pdu_buffers.buffer_size = 0;
custom_source_pdu_alloc_test_pdu_buffers.pos = 0;
custom_source_pdu_write_test_sdu_payloads.buffer_size = 0;
custom_source_pdu_write_test_sdu_payloads.pos = 0;
RESET_FAKE(source_pdu_alloc_test);
RESET_FAKE(source_pdu_write_test);
RESET_FAKE(source_pdu_write_test_handler);
RESET_FAKE(source_pdu_emit_test);
RESET_FAKE(source_pdu_emit_test_handler);
RESET_FAKE(source_pdu_release_test);
FFF_RESET_HISTORY();
source_pdu_alloc_test_fake.custom_fake = custom_source_pdu_alloc_test;
source_pdu_write_test_fake.custom_fake = custom_source_pdu_write_test;
source_pdu_emit_test_fake.custom_fake = custom_source_pdu_emit_test;
source_pdu_release_test_fake.custom_fake = custom_source_pdu_release_test;
}
/**
* Wrapper totest time difference
* @param time_before Subtrahend
* @param time_after Minuend
* @param result Difference if valid
* @return Validity
*/
static bool isoal_get_time_diff_test(uint32_t time_before, uint32_t time_after, uint32_t *result)
{
bool valid = isoal_get_time_diff(time_before, time_after, result);
#if defined(DEBUG_TEST)
if (valid) {
PRINT("[isoal_get_time_diff] time_before %12lu time_after %12lu result %lu\n",
time_before,
time_after,
*result);
} else {
PRINT("[isoal_get_time_diff] time_before %12lu time_after %12lu result INVALID\n",
time_before,
time_after);
}
#endif
return valid;
}
/**
* Basic setup of a single source for any TX test
* @param handle Stream handle
* @param role Peripheral / Central / Broadcast
* @param framed PDU framing
* @param burst_number BN
* @param flush_timeout FT
* @param max_octets Max PDU Size
* @param sdu_interval SDU Interval (us)
* @param iso_interval_int ISO Interval (integer multiple of 1250us)
* @param stream_sync_delay CIS / BIS sync delay
* @param group_sync_delay CIG / BIG sync delay
* @return Newly created source handle
*/
static isoal_source_handle_t basic_tx_test_setup(uint16_t handle,
uint8_t role,
uint8_t framed,
uint8_t burst_number,
uint8_t flush_timeout,
uint8_t max_octets,
uint32_t sdu_interval,
uint16_t iso_interval_int,
uint32_t stream_sync_delay,
uint32_t group_sync_delay)
{
isoal_source_handle_t source_hdl;
isoal_status_t err;
#if defined(DEBUG_TEST)
PRINT("TX Test Setup:\n\tHandle 0x%04x\n\tRole %s\n\tFraming %s"
"\n\tBN %u\n\tFT %d\n\tMax PDU %u\n\tISO Interval %dus"
"\n\tSDU Interval %dus\n\tStream Sync Delay %dus"
"\n\tGroup Sync Delay %dus\n\n",
handle,
ROLE_TO_STR(role),
framed ? "Framed" : "Unframed",
burst_number,
flush_timeout,
max_octets,
(iso_interval_int * CONN_INT_UNIT_US),
sdu_interval,
stream_sync_delay,
group_sync_delay);
#endif
ztest_set_assert_valid(false);
err = isoal_init();
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
err = isoal_reset();
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Create a source based on global parameters */
err = isoal_source_create(handle,
role,
framed,
burst_number,
flush_timeout,
max_octets,
sdu_interval,
iso_interval_int,
stream_sync_delay,
group_sync_delay,
source_pdu_alloc_test,
source_pdu_write_test,
source_pdu_emit_test,
source_pdu_release_test,
&source_hdl);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Enable newly created source */
isoal_source_enable(source_hdl);
return source_hdl;
}
/**
* Creates a SDU fragment according to the provided configuration.
* @param[In] sdu_state Fragment type (Single / Start / Cont. / End)
* @param[In] dataptr Test data to fill SDU payload
* @param[In] length Length of SDU fragment
* @param[In] sdu_total_length Total size of the SDU
* @param[In] packet_number SDU packet sequence number
* @param[In] timestamp SDU timestamp at source
* @param[In] ref_point CIG / BIG reference point
* @param[In] target_event Event number requested
* @param[Out] sdu_tx SDU buffer
*/
static void isoal_test_create_sdu_fagment(uint8_t sdu_state,
uint8_t *dataptr,
uint16_t length,
uint16_t sdu_total_length,
uint16_t packet_number,
uint32_t timestamp,
uint32_t ref_point,
uint64_t target_event,
struct isoal_sdu_tx *sdu_tx)
{
sdu_tx->sdu_state = sdu_state;
sdu_tx->packet_sn = packet_number;
sdu_tx->iso_sdu_length = sdu_total_length;
sdu_tx->time_stamp = timestamp;
sdu_tx->grp_ref_point = ref_point;
sdu_tx->target_event = target_event;
memcpy(sdu_tx->dbuf, dataptr, length);
sdu_tx->size = length;
isoal_test_debug_print_tx_sdu(sdu_tx);
}
/**
* Test Suite : TX basic test
*
* Test creating and destroying sources upto the maximum, with randomized
* configuration parameters.
*/
ZTEST(test_tx_basics, test_source_isoal_test_create_destroy)
{
isoal_sink_handle_t source_hdl[CONFIG_BT_CTLR_ISOAL_SOURCES];
uint32_t stream_sync_delay;
uint32_t group_sync_delay;
uint8_t sdu_interval_int;
uint8_t iso_interval_int;
uint8_t flush_timeout;
uint32_t iso_interval;
uint32_t sdu_interval;
uint8_t burst_number;
uint8_t pdus_per_sdu;
uint8_t max_octets;
isoal_status_t res;
uint16_t handle;
bool framed;
res = isoal_init();
zassert_equal(res, ISOAL_STATUS_OK, "res = 0x%02x", res);
res = isoal_reset();
zassert_equal(res, ISOAL_STATUS_OK, "res = 0x%02x", res);
for (int role = 0; role <= 3; role++) {
/* 0 Central
* 1 Peripheral
* 2 Broadcast
* 3 Undefined
*/
handle = 0x8000;
burst_number = 0;
flush_timeout = 1;
framed = false;
max_octets = 40;
sdu_interval_int = 1;
iso_interval_int = 1;
iso_interval = iso_interval_int * CONN_INT_UNIT_US;
sdu_interval = sdu_interval_int * CONN_INT_UNIT_US;
stream_sync_delay = iso_interval - 200;
group_sync_delay = iso_interval - 50;
ztest_set_assert_valid(false);
for (int i = 0; i < CONFIG_BT_CTLR_ISOAL_SOURCES; i++) {
res = ISOAL_STATUS_ERR_UNSPECIFIED;
source_hdl[i] = 0xFF;
pdus_per_sdu = (burst_number * sdu_interval) / iso_interval;
res = isoal_source_create(handle,
role,
framed,
burst_number,
flush_timeout,
max_octets,
sdu_interval,
iso_interval_int,
stream_sync_delay,
group_sync_delay,
source_pdu_alloc_test,
source_pdu_write_test,
source_pdu_emit_test,
source_pdu_release_test,
&source_hdl[i]);
zassert_equal(isoal_global.source_allocated[source_hdl[i]],
ISOAL_ALLOC_STATE_TAKEN,
"");
zassert_equal(isoal_global.source_state[source_hdl[i]].session.pdus_per_sdu,
pdus_per_sdu,
"%s pdus_per_sdu %d should be %d for:\n\tBN %d"
"\n\tFT %d\n\tISO Interval %dus"
"\n\tSDU Interval %dus"
"\n\tStream Sync Delay %dus"
"\n\tGroup Sync Delay %dus",
(framed ? "Framed" : "Unframed"),
isoal_global.source_state[source_hdl[i]].session.pdus_per_sdu,
pdus_per_sdu,
burst_number,
flush_timeout,
iso_interval,
sdu_interval,
stream_sync_delay,
group_sync_delay);
zassert_equal(res,
ISOAL_STATUS_OK,
"Source %d in role %s creation failed!",
i,
ROLE_TO_STR(role));
isoal_source_enable(source_hdl[i]);
zassert_equal(isoal_global.source_state[source_hdl[i]].pdu_production.mode,
ISOAL_PRODUCTION_MODE_ENABLED,
"Source %d in role %s enable failed!",
i,
ROLE_TO_STR(role));
zassert_not_null(isoal_get_source_param_ref(source_hdl[i]), "");
framed = !framed;
burst_number++;
flush_timeout = (flush_timeout % 3) + 1;
max_octets += max_octets / 2;
sdu_interval_int++;
iso_interval_int = iso_interval_int * sdu_interval_int;
sdu_interval = (sdu_interval_int * CONN_INT_UNIT_US) - (framed ? 100 : 0);
iso_interval = iso_interval_int * CONN_INT_UNIT_US;
stream_sync_delay = iso_interval - (200 * i);
group_sync_delay = iso_interval - 50;
}
/* Destroy in order */
for (int i = 0; i < CONFIG_BT_CTLR_ISOAL_SOURCES; i++) {
isoal_source_destroy(source_hdl[i]);
zassert_equal(isoal_global.source_allocated[source_hdl[i]],
ISOAL_ALLOC_STATE_FREE,
"Source destruction failed!");
zassert_equal(isoal_global.source_state[source_hdl[i]].pdu_production.mode,
ISOAL_PRODUCTION_MODE_DISABLED,
"Source disable failed!");
}
}
}
/**
* Test Suite : TX basic test
*
* Test error return on exceeding the maximum number of sources available.
*/
ZTEST(test_tx_basics, test_source_isoal_test_create_err)
{
isoal_source_handle_t source_hdl[CONFIG_BT_CTLR_ISOAL_SOURCES + 1];
uint32_t stream_sync_delay;
uint32_t group_sync_delay;
uint8_t iso_interval_int;
uint8_t flush_timeout;
uint32_t sdu_interval;
uint8_t burst_number;
uint8_t max_octets;
isoal_status_t res;
uint16_t handle;
uint8_t role;
bool framed;
handle = 0x8000;
role = BT_CONN_ROLE_PERIPHERAL;
burst_number = 1;
max_octets = 40;
flush_timeout = 1;
framed = false;
iso_interval_int = 1;
sdu_interval = CONN_INT_UNIT_US;
stream_sync_delay = CONN_INT_UNIT_US - 200;
group_sync_delay = CONN_INT_UNIT_US - 50;
res = isoal_init();
zassert_equal(res, ISOAL_STATUS_OK, "res = 0x%02x", res);
res = isoal_reset();
zassert_equal(res, ISOAL_STATUS_OK, "res = 0x%02x", res);
for (int i = 0; i < CONFIG_BT_CTLR_ISOAL_SOURCES; i++) {
res = isoal_source_create(handle,
role,
framed,
burst_number,
flush_timeout,
max_octets,
sdu_interval,
iso_interval_int,
stream_sync_delay,
group_sync_delay,
source_pdu_alloc_test,
source_pdu_write_test,
source_pdu_emit_test,
source_pdu_release_test,
&source_hdl[i]);
zassert_equal(res,
ISOAL_STATUS_OK,
"Source %d in role %s creation failed!",
i,
ROLE_TO_STR(role));
}
res = isoal_source_create(handle,
role,
framed,
burst_number,
flush_timeout,
max_octets,
sdu_interval,
iso_interval_int,
stream_sync_delay,
group_sync_delay,
source_pdu_alloc_test,
source_pdu_write_test,
source_pdu_emit_test,
source_pdu_release_test,
&source_hdl[CONFIG_BT_CTLR_ISOAL_SOURCES]);
zassert_equal(res,
ISOAL_STATUS_ERR_SOURCE_ALLOC,
"Source creation did not return error as expected!");
}
/**
* Test Suite : TX basic test
*
* Test assertion when attempting to retrieve source params for an invalid source
* handle.
*/
ZTEST(test_tx_basics, test_source_invalid_ref)
{
ztest_set_assert_valid(true);
isoal_get_source_param_ref(99);
ztest_set_assert_valid(false);
}
/**
* Test Suite : TX unframed SDU fragmentation
*
* Tests fragmentation of a single SDU contained in a single fragment
* into a single PDU where Max PDU is less than the PDU buffer size
*/
ZTEST(test_tx_unframed, test_tx_unframed_1_sdu_1_frag_1_pdu_maxPDU)
{
uint8_t testdata[TEST_TX_PDU_PAYLOAD_MAX - 5];
struct tx_pdu_meta_buffer tx_pdu_meta_buf;
struct tx_sdu_frag_buffer tx_sdu_frag_buf;
struct isoal_pdu_buffer pdu_buffer;
isoal_source_handle_t source_hdl;
isoal_sdu_len_t sdu_total_size;
isoal_pdu_len_t pdu_write_size;
uint32_t stream_sync_delay;
uint64_t sdu_packet_number;
uint32_t group_sync_delay;
uint8_t iso_interval_int;
uint64_t payload_number;
uint32_t sdu_timestamp;
uint16_t testdata_indx;
uint16_t testdata_size;
uint16_t pdu_write_loc;
uint16_t sdu_read_loc;
uint64_t event_number;
uint32_t sdu_interval;
uint8_t sdu_fragments;
uint32_t ref_point;
isoal_status_t err;
uint8_t max_octets;
uint8_t role;
uint8_t BN;
uint8_t FT;
/* Settings */
role = BT_CONN_ROLE_PERIPHERAL;
iso_interval_int = 1;
sdu_interval = CONN_INT_UNIT_US;
max_octets = TEST_TX_PDU_PAYLOAD_MAX - 5;
BN = 1;
FT = 1;
stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;
/* SDU Frag 1 --------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
init_test_data_buffer(testdata, TEST_TX_PDU_PAYLOAD_MAX - 5);
pdu_buffer.handle = (void *)&tx_pdu_meta_buf.node_tx;
pdu_buffer.pdu = (struct pdu_iso *)tx_pdu_meta_buf.node_tx.pdu;
pdu_buffer.size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_packet_number = 2000;
event_number = 2000;
sdu_timestamp = 9249;
ref_point = sdu_timestamp + (iso_interval_int * CONN_INT_UNIT_US) - 50;
sdu_total_size = TEST_TX_PDU_PAYLOAD_MAX - 5;
testdata_indx = 0;
testdata_size = TEST_TX_PDU_PAYLOAD_MAX - 5;
payload_number = event_number * BN;
pdu_write_loc = 0;
sdu_read_loc = 0;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX - 5;
source_hdl = basic_tx_test_setup(0xADAD, /* Handle */
role, /* Role */
false, /* Framed */
BN, /* BN */
FT, /* FT */
max_octets, /* max_octets */
sdu_interval, /* SDU Interval */
iso_interval_int, /* ISO Interval */
stream_sync_delay, /* Stream Sync Delay */
group_sync_delay); /* Group Sync Delay */
isoal_test_create_sdu_fagment(BT_ISO_SINGLE,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
/* Test fragmentation (Black Box) */
/* Valid PDUs */
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
PDU_ALLOC_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_WRITE_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_EMIT_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_RELEASE_TEST_RETURNS(ISOAL_STATUS_OK);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* PDU 1 */
sdu_fragments = 1;
ZASSERT_PDU_WRITE_TEST(val,
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
ZASSERT_PDU_EMIT_TEST(val,
&tx_pdu_meta_buf.node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_COMPLETE_END,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* Test PDU release */
PDU_RELEASE_TEST_RETURNS(ISOAL_STATUS_OK);
isoal_tx_pdu_release(source_hdl, &tx_pdu_meta_buf.node_tx);
ZASSERT_PDU_RELEASE_TEST(val,
&tx_pdu_meta_buf.node_tx,
isoal_global.source_state[source_hdl].session.handle,
ISOAL_STATUS_OK);
}
/**
* Test Suite : TX unframed SDU fragmentation
*
* Tests fragmentation of a single SDU contained in a single fragment
* into a single PDU where Max PDU is greater than the PDU buffer size
*/
ZTEST(test_tx_unframed, test_tx_unframed_1_sdu_1_frag_1_pdu_bufSize)
{
uint8_t testdata[TEST_TX_PDU_PAYLOAD_MAX];
struct tx_pdu_meta_buffer tx_pdu_meta_buf;
struct tx_sdu_frag_buffer tx_sdu_frag_buf;
struct isoal_pdu_buffer pdu_buffer;
isoal_source_handle_t source_hdl;
isoal_sdu_len_t sdu_total_size;
isoal_pdu_len_t pdu_write_size;
uint32_t stream_sync_delay;
uint64_t sdu_packet_number;
uint32_t group_sync_delay;
uint8_t iso_interval_int;
uint64_t payload_number;
uint32_t sdu_timestamp;
uint16_t testdata_indx;
uint16_t testdata_size;
uint16_t pdu_write_loc;
uint16_t sdu_read_loc;
uint64_t event_number;
uint32_t sdu_interval;
uint8_t sdu_fragments;
uint32_t ref_point;
isoal_status_t err;
uint8_t max_octets;
uint8_t role;
uint8_t BN;
uint8_t FT;
/* Settings */
role = BT_CONN_ROLE_PERIPHERAL;
iso_interval_int = 1;
sdu_interval = CONN_INT_UNIT_US;
max_octets = TEST_TX_PDU_PAYLOAD_MAX + 5;
BN = 1;
FT = 1;
stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;
/* SDU Frag 1 --------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
init_test_data_buffer(testdata, TEST_TX_PDU_PAYLOAD_MAX);
pdu_buffer.handle = (void *)&tx_pdu_meta_buf.node_tx;
pdu_buffer.pdu = (struct pdu_iso *)tx_pdu_meta_buf.node_tx.pdu;
pdu_buffer.size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_packet_number = 2000;
event_number = 2000;
sdu_timestamp = 9249;
ref_point = sdu_timestamp + (iso_interval_int * CONN_INT_UNIT_US) - 50;
sdu_total_size = TEST_TX_PDU_PAYLOAD_MAX;
testdata_indx = 0;
testdata_size = TEST_TX_PDU_PAYLOAD_MAX;
payload_number = event_number * BN;
pdu_write_loc = 0;
sdu_read_loc = 0;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX;
source_hdl = basic_tx_test_setup(0xADAD, /* Handle */
role, /* Role */
false, /* Framed */
BN, /* BN */
FT, /* FT */
max_octets, /* max_octets */
sdu_interval, /* SDU Interval */
iso_interval_int, /* ISO Interval */
stream_sync_delay, /* Stream Sync Delay */
group_sync_delay); /* Group Sync Delay */
isoal_test_create_sdu_fagment(BT_ISO_SINGLE,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
/* Test fragmentation (Black Box) */
/* Valid PDUs */
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
PDU_ALLOC_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_WRITE_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_EMIT_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_RELEASE_TEST_RETURNS(ISOAL_STATUS_OK);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* PDU 1 */
sdu_fragments = 1;
ZASSERT_PDU_WRITE_TEST(val,
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
ZASSERT_PDU_EMIT_TEST(val,
&tx_pdu_meta_buf.node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_COMPLETE_END,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
}
/**
* Test Suite : TX unframed SDU fragmentation
*
* Tests fragmentation of a single SDU contained in a single fragment
* into three PDUs where Max PDU is less than the PDU buffer size
*/
ZTEST(test_tx_unframed, test_tx_unframed_1_sdu_1_frag_3_pdu)
{
struct tx_pdu_meta_buffer tx_pdu_meta_buf;
struct tx_sdu_frag_buffer tx_sdu_frag_buf;
struct isoal_pdu_buffer pdu_buffer;
isoal_source_handle_t source_hdl;
isoal_sdu_len_t sdu_total_size;
isoal_pdu_len_t pdu_write_size;
uint32_t stream_sync_delay;
uint64_t sdu_packet_number;
uint32_t group_sync_delay;
uint8_t iso_interval_int;
uint64_t payload_number;
uint32_t sdu_timestamp;
uint16_t testdata_indx;
uint16_t testdata_size;
uint16_t pdu_write_loc;
uint16_t sdu_read_loc;
uint64_t event_number;
uint32_t sdu_interval;
uint8_t sdu_fragments;
uint8_t testdata[100];
uint32_t ref_point;
isoal_status_t err;
uint8_t max_octets;
uint8_t role;
uint8_t BN;
uint8_t FT;
/* Settings */
role = BT_CONN_ROLE_PERIPHERAL;
iso_interval_int = 1;
sdu_interval = CONN_INT_UNIT_US;
max_octets = TEST_TX_PDU_PAYLOAD_MAX - 5;
BN = 3;
FT = 1;
stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;
/* SDU Frag 1 --------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
init_test_data_buffer(testdata, 100);
pdu_buffer.handle = (void *)&tx_pdu_meta_buf.node_tx;
pdu_buffer.pdu = (struct pdu_iso *)tx_pdu_meta_buf.node_tx.pdu;
pdu_buffer.size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_packet_number = 2000;
event_number = 2000;
sdu_timestamp = 9249;
ref_point = sdu_timestamp + (iso_interval_int * CONN_INT_UNIT_US) - 50;
sdu_total_size = 100;
testdata_indx = 0;
testdata_size = 100;
payload_number = event_number * BN;
source_hdl = basic_tx_test_setup(0xADAD, /* Handle */
role, /* Role */
false, /* Framed */
BN, /* BN */
FT, /* FT */
max_octets, /* max_octets */
sdu_interval, /* SDU Interval */
iso_interval_int, /* ISO Interval */
stream_sync_delay, /* Stream Sync Delay */
group_sync_delay); /* Group Sync Delay */
isoal_test_create_sdu_fagment(BT_ISO_SINGLE,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
/* Test fragmentation (Black Box) */
/* Valid PDUs */
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
PDU_ALLOC_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_WRITE_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_EMIT_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_RELEASE_TEST_RETURNS(ISOAL_STATUS_OK);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* PDU 1 */
pdu_write_loc = 0;
sdu_read_loc = 0;
pdu_write_size = max_octets;
sdu_fragments = 0;
ZASSERT_PDU_WRITE_TEST(history[0],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
ZASSERT_PDU_EMIT_TEST(history[0],
&tx_pdu_meta_buf.node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_START_CONTINUE,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU 2 */
payload_number++;
sdu_read_loc += pdu_write_size;
sdu_fragments = 0;
ZASSERT_PDU_WRITE_TEST(history[1],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
ZASSERT_PDU_EMIT_TEST(history[1],
&tx_pdu_meta_buf.node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_START_CONTINUE,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU 3 */
payload_number++;
sdu_read_loc += pdu_write_size;
pdu_write_size = 30;
sdu_fragments++;
ZASSERT_PDU_WRITE_TEST(history[2],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
ZASSERT_PDU_EMIT_TEST(history[2],
&tx_pdu_meta_buf.node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_COMPLETE_END,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
}
/**
* Test Suite : TX unframed SDU fragmentation
*
* Tests fragmentation of a single SDU contained in three fragments
* into a single PDU where Max PDU is greater than the PDU buffer size
*/
ZTEST(test_tx_unframed, test_tx_unframed_1_sdu_3_frag_1_pdu)
{
struct tx_pdu_meta_buffer tx_pdu_meta_buf;
struct tx_sdu_frag_buffer tx_sdu_frag_buf;
struct isoal_pdu_buffer pdu_buffer;
isoal_source_handle_t source_hdl;
isoal_sdu_len_t sdu_total_size;
isoal_pdu_len_t pdu_write_size;
uint32_t stream_sync_delay;
uint64_t sdu_packet_number;
uint32_t group_sync_delay;
uint8_t iso_interval_int;
uint64_t payload_number;
uint32_t sdu_timestamp;
uint16_t testdata_indx;
uint16_t testdata_size;
uint16_t pdu_write_loc;
uint16_t sdu_read_loc;
uint64_t event_number;
uint32_t sdu_interval;
uint8_t sdu_fragments;
uint8_t testdata[TEST_TX_PDU_PAYLOAD_MAX];
uint32_t ref_point;
isoal_status_t err;
uint8_t max_octets;
uint8_t role;
uint8_t BN;
uint8_t FT;
/* Settings */
role = BT_CONN_ROLE_PERIPHERAL;
iso_interval_int = 1;
sdu_interval = CONN_INT_UNIT_US;
max_octets = TEST_TX_PDU_PAYLOAD_MAX + 5;
BN = 1;
FT = 1;
stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;
/* SDU Frag 1 --------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
init_test_data_buffer(testdata, TEST_TX_PDU_PAYLOAD_MAX);
pdu_buffer.handle = (void *)&tx_pdu_meta_buf.node_tx;
pdu_buffer.pdu = (struct pdu_iso *)tx_pdu_meta_buf.node_tx.pdu;
pdu_buffer.size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_packet_number = 2000;
event_number = 2000;
sdu_timestamp = 9249;
ref_point = sdu_timestamp + (iso_interval_int * CONN_INT_UNIT_US) - 50;
sdu_total_size = TEST_TX_PDU_PAYLOAD_MAX;
testdata_indx = 0;
testdata_size = TEST_TX_PDU_PAYLOAD_MAX / 3;
payload_number = event_number * BN;
sdu_fragments = 0;
source_hdl = basic_tx_test_setup(0xADAD, /* Handle */
role, /* Role */
false, /* Framed */
BN, /* BN */
FT, /* FT */
max_octets, /* max_octets */
sdu_interval, /* SDU Interval */
iso_interval_int, /* ISO Interval */
stream_sync_delay, /* Stream Sync Delay */
group_sync_delay); /* Group Sync Delay */
isoal_test_create_sdu_fagment(BT_ISO_START,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
/* Test fragmentation (Black Box) */
/* Valid PDUs */
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
PDU_ALLOC_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_WRITE_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_EMIT_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_RELEASE_TEST_RETURNS(ISOAL_STATUS_OK);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* PDU 1 */
pdu_write_loc = 0;
sdu_read_loc = 0;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX / 3;
sdu_fragments++;
ZASSERT_PDU_WRITE_TEST(history[0],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
/* PDU should not be emitted */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(0);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* SDU Frag 2 --------------------------------------------------------*/
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
sdu_timestamp += 10;
testdata_indx += testdata_size;
testdata_size += TEST_TX_PDU_PAYLOAD_MAX / 3;
isoal_test_create_sdu_fagment(BT_ISO_CONT,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test fragmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
pdu_write_loc = pdu_write_size;
pdu_write_size += TEST_TX_PDU_PAYLOAD_MAX / 3;
sdu_read_loc = testdata_indx;
sdu_fragments++;
/* PDU should not be allocated */
ZASSERT_PDU_ALLOC_TEST_CALL_COUNT(1);
ZASSERT_PDU_WRITE_TEST(history[1],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
/* PDU should not be emitted */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(0);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* SDU Frag 3 --------------------------------------------------------*/
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
sdu_timestamp += 10;
testdata_indx = testdata_size;
testdata_size = TEST_TX_PDU_PAYLOAD_MAX;
isoal_test_create_sdu_fagment(BT_ISO_END,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test fragmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
pdu_write_loc = pdu_write_size;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_read_loc = testdata_indx;
sdu_fragments++;
/* PDU should not be allocated */
ZASSERT_PDU_ALLOC_TEST_CALL_COUNT(1);
ZASSERT_PDU_WRITE_TEST(history[2],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
ZASSERT_PDU_EMIT_TEST(history[0],
&tx_pdu_meta_buf.node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_COMPLETE_END,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
}
/**
* Test Suite : TX unframed SDU fragmentation
*
* Tests fragmentation of a single SDU contained in three fragments
* into two PDUs where Max PDU is greater than the PDU buffer size
*/
ZTEST(test_tx_unframed, test_tx_unframed_1_sdu_3_frag_2_pdu)
{
struct tx_pdu_meta_buffer tx_pdu_meta_buf[2];
struct tx_sdu_frag_buffer tx_sdu_frag_buf;
struct isoal_pdu_buffer pdu_buffer[2];
isoal_source_handle_t source_hdl;
isoal_sdu_len_t sdu_total_size;
isoal_pdu_len_t pdu_write_size;
uint32_t stream_sync_delay;
uint64_t sdu_packet_number;
uint32_t group_sync_delay;
uint8_t iso_interval_int;
uint64_t payload_number;
uint32_t sdu_timestamp;
uint16_t testdata_indx;
uint16_t testdata_size;
uint16_t pdu_write_loc;
uint16_t sdu_read_loc;
uint64_t event_number;
uint32_t sdu_interval;
uint8_t sdu_fragments;
uint8_t testdata[TEST_TX_PDU_PAYLOAD_MAX * 2];
uint32_t ref_point;
isoal_status_t err;
uint8_t max_octets;
uint8_t role;
uint8_t BN;
uint8_t FT;
/* Settings */
role = BT_CONN_ROLE_PERIPHERAL;
iso_interval_int = 1;
sdu_interval = CONN_INT_UNIT_US;
max_octets = TEST_TX_PDU_PAYLOAD_MAX + 5;
BN = 2;
FT = 1;
stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;
/* SDU Frag 1 --------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[0]);
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[1]);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
init_test_data_buffer(testdata, TEST_TX_PDU_PAYLOAD_MAX * 2);
pdu_buffer[0].handle = (void *)&tx_pdu_meta_buf[0].node_tx;
pdu_buffer[0].pdu = (struct pdu_iso *)tx_pdu_meta_buf[0].node_tx.pdu;
pdu_buffer[0].size = TEST_TX_PDU_PAYLOAD_MAX;
pdu_buffer[1].handle = (void *)&tx_pdu_meta_buf[1].node_tx;
pdu_buffer[1].pdu = (struct pdu_iso *)tx_pdu_meta_buf[1].node_tx.pdu;
pdu_buffer[1].size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_packet_number = 2000;
event_number = 2000;
sdu_timestamp = 9249;
ref_point = sdu_timestamp + (iso_interval_int * CONN_INT_UNIT_US) - 50;
sdu_total_size = TEST_TX_PDU_PAYLOAD_MAX * 2;
testdata_indx = 0;
testdata_size = (TEST_TX_PDU_PAYLOAD_MAX * 2) / 3;
sdu_fragments = 0;
source_hdl = basic_tx_test_setup(0xADAD, /* Handle */
role, /* Role */
false, /* Framed */
BN, /* BN */
FT, /* FT */
max_octets, /* max_octets */
sdu_interval, /* SDU Interval */
iso_interval_int, /* ISO Interval */
stream_sync_delay, /* Stream Sync Delay */
group_sync_delay); /* Group Sync Delay */
isoal_test_create_sdu_fagment(BT_ISO_START,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
/* Test fragmentation (Black Box) */
/* Valid PDUs */
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[0]);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[1]);
PDU_ALLOC_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_WRITE_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_EMIT_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_RELEASE_TEST_RETURNS(ISOAL_STATUS_OK);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* PDU 1 */
payload_number = event_number * BN;
pdu_write_loc = 0;
sdu_read_loc = 0;
pdu_write_size = (TEST_TX_PDU_PAYLOAD_MAX * 2) / 3;
sdu_fragments++;
ZASSERT_PDU_WRITE_TEST(history[0],
pdu_buffer[0],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
/* PDU should not be emitted */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(0);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* SDU Frag 2 --------------------------------------------------------*/
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
sdu_timestamp += 10;
testdata_indx += testdata_size;
testdata_size += (TEST_TX_PDU_PAYLOAD_MAX * 2) / 3;
isoal_test_create_sdu_fagment(BT_ISO_CONT,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test fragmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
pdu_write_loc = pdu_write_size;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_read_loc = testdata_indx;
/* PDU should not be allocated (Allocated for PDU 2) */
ZASSERT_PDU_ALLOC_TEST_CALL_COUNT(2);
ZASSERT_PDU_WRITE_TEST(history[1],
pdu_buffer[0],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
ZASSERT_PDU_EMIT_TEST(history[0],
&tx_pdu_meta_buf[0].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_START_CONTINUE,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* PDU 2 */
payload_number++;
sdu_read_loc = pdu_write_size;
pdu_write_size = testdata_size - testdata_indx - (pdu_write_size - pdu_write_loc);
pdu_write_loc = 0;
sdu_fragments = 1;
ZASSERT_PDU_WRITE_TEST(history[2],
pdu_buffer[1],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
/* PDU should not be emitted */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(1);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* SDU Frag 3 --------------------------------------------------------*/
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
sdu_timestamp += 10;
testdata_indx = testdata_size;
testdata_size = TEST_TX_PDU_PAYLOAD_MAX * 2;
isoal_test_create_sdu_fagment(BT_ISO_END,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test fragmentation (Black Box) */
/* Valid PDUs */
/* PDU 2 */
pdu_write_loc = pdu_write_size;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_read_loc = testdata_indx;
sdu_fragments++;
/* PDU should not be allocated */
ZASSERT_PDU_ALLOC_TEST_CALL_COUNT(2);
ZASSERT_PDU_WRITE_TEST(history[3],
pdu_buffer[1],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
ZASSERT_PDU_EMIT_TEST(history[1],
&tx_pdu_meta_buf[1].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_COMPLETE_END,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
}
/**
* Test Suite : TX unframed SDU fragmentation
*
* Tests boundary conditions for the time difference function
*/
ZTEST(test_tx_unframed, test_tx_time_diff)
{
uint32_t time_before;
uint32_t time_after;
uint32_t result;
bool valid;
result = 0;
/* Check that the difference from maximum to 0 is 1 */
time_before = ISOAL_TIME_WRAPPING_POINT_US;
time_after = 0;
valid = isoal_get_time_diff_test(time_before, time_after, &result);
zassert_true(valid, NULL);
zassert_equal(result, 1, "%lu != %lu", result, 1);
/* Check that if time_before is ahead of time_after the result is
* invalid
*/
time_before = 0;
time_after = ISOAL_TIME_WRAPPING_POINT_US;
valid = isoal_get_time_diff_test(time_before, time_after, &result);
zassert_false(valid, NULL);
time_before = ISOAL_TIME_WRAPPING_POINT_US;
time_after = ISOAL_TIME_WRAPPING_POINT_US - 1;
valid = isoal_get_time_diff_test(time_before, time_after, &result);
zassert_false(valid, NULL);
time_before = 1;
time_after = 0;
valid = isoal_get_time_diff_test(time_before, time_after, &result);
zassert_false(valid, NULL);
time_before = ISOAL_TIME_MID_POINT_US;
time_after = ISOAL_TIME_MID_POINT_US - 1;
valid = isoal_get_time_diff_test(time_before, time_after, &result);
zassert_false(valid, NULL);
time_before = ISOAL_TIME_MID_POINT_US + 1;
time_after = ISOAL_TIME_MID_POINT_US;
valid = isoal_get_time_diff_test(time_before, time_after, &result);
zassert_false(valid, NULL);
time_before = ISOAL_TIME_MID_POINT_US + 1;
time_after = ISOAL_TIME_MID_POINT_US - 1;
valid = isoal_get_time_diff_test(time_before, time_after, &result);
zassert_false(valid, NULL);
/* Check valid results that are 0 */
time_before = 0;
time_after = 0;
valid = isoal_get_time_diff_test(time_before, time_after, &result);
zassert_true(valid, NULL);
zassert_equal(result, 0, "%lu != %lu", result, 0);
time_before = ISOAL_TIME_WRAPPING_POINT_US;
time_after = ISOAL_TIME_WRAPPING_POINT_US;
valid = isoal_get_time_diff_test(time_before, time_after, &result);
zassert_true(valid, NULL);
zassert_equal(result, 0, "%lu != %lu", result, 0);
time_before = ISOAL_TIME_MID_POINT_US;
time_after = ISOAL_TIME_MID_POINT_US;
valid = isoal_get_time_diff_test(time_before, time_after, &result);
zassert_true(valid, NULL);
zassert_equal(result, 0, "%lu != %lu", result, 0);
/* Check valid results across the mid-point */
time_before = ISOAL_TIME_MID_POINT_US;
time_after = ISOAL_TIME_MID_POINT_US + 1;
valid = isoal_get_time_diff_test(time_before, time_after, &result);
zassert_true(valid, NULL);
zassert_equal(result, 1, "%lu != %lu", result, 1);
time_before = ISOAL_TIME_MID_POINT_US - 1;
time_after = ISOAL_TIME_MID_POINT_US;
valid = isoal_get_time_diff_test(time_before, time_after, &result);
zassert_true(valid, NULL);
zassert_equal(result, 1, "%lu != %lu", result, 1);
time_before = ISOAL_TIME_MID_POINT_US - 1;
time_after = ISOAL_TIME_MID_POINT_US + 1;
valid = isoal_get_time_diff_test(time_before, time_after, &result);
zassert_true(valid, NULL);
zassert_equal(result, 2, "%lu != %lu", result, 2);
}
/**
* Test Suite : TX unframed SDU fragmentation
*
* Tests fragmentation of a single SDU contained in a single fragment
* into a single PDU where Max PDU is less than the PDU buffer size
*/
ZTEST(test_tx_unframed, test_tx_unframed_2_sdu_1_frag_2_pdu_ts_wrap1)
{
struct tx_pdu_meta_buffer tx_pdu_meta_buf;
struct tx_sdu_frag_buffer tx_sdu_frag_buf;
uint32_t tx_sync_timestamp_expected;
struct isoal_pdu_buffer pdu_buffer;
isoal_source_handle_t source_hdl;
uint32_t tx_sync_offset_expected;
isoal_sdu_len_t sdu_total_size;
isoal_pdu_len_t pdu_write_size;
uint16_t tx_sync_seq_expected;
uint32_t stream_sync_delay;
uint64_t sdu_packet_number;
uint32_t tx_sync_timestamp;
uint32_t group_sync_delay;
uint8_t iso_interval_int;
uint64_t payload_number;
uint32_t tx_sync_offset;
uint32_t sdu_timestamp;
uint16_t testdata_indx;
uint16_t testdata_size;
uint16_t pdu_write_loc;
uint16_t sdu_read_loc;
uint64_t event_number;
uint32_t sdu_interval;
uint8_t sdu_fragments;
uint8_t testdata[33];
uint16_t tx_sync_seq;
uint32_t ref_point;
isoal_status_t err;
uint8_t max_octets;
uint8_t role;
uint8_t BN;
uint8_t FT;
/* Settings */
role = BT_CONN_ROLE_PERIPHERAL;
iso_interval_int = 1;
sdu_interval = CONN_INT_UNIT_US;
max_octets = TEST_TX_PDU_PAYLOAD_MAX - 5;
BN = 1;
FT = 1;
stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;
/* SDU Frag 1 --------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
init_test_data_buffer(testdata, 33);
pdu_buffer.handle = (void *)&tx_pdu_meta_buf.node_tx;
pdu_buffer.pdu = (struct pdu_iso *)tx_pdu_meta_buf.node_tx.pdu;
pdu_buffer.size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_packet_number = 2000;
event_number = 2000;
sdu_timestamp = ISOAL_TIME_WRAPPING_POINT_US;
ref_point = ISOAL_TIME_WRAPPING_POINT_US;
sdu_total_size = 23;
testdata_indx = 0;
testdata_size = 23;
payload_number = event_number * BN;
pdu_write_loc = 0;
sdu_read_loc = 0;
pdu_write_size = 23;
source_hdl = basic_tx_test_setup(0xADAD, /* Handle */
role, /* Role */
false, /* Framed */
BN, /* BN */
FT, /* FT */
max_octets, /* max_octets */
sdu_interval, /* SDU Interval */
iso_interval_int, /* ISO Interval */
stream_sync_delay, /* Stream Sync Delay */
group_sync_delay); /* Group Sync Delay */
isoal_test_create_sdu_fagment(BT_ISO_SINGLE,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
PDU_ALLOC_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_WRITE_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_EMIT_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_RELEASE_TEST_RETURNS(ISOAL_STATUS_OK);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test fragmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
sdu_fragments = 1;
ZASSERT_PDU_WRITE_TEST(history[0],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
ZASSERT_PDU_EMIT_TEST(history[0],
&tx_pdu_meta_buf.node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_COMPLETE_END,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* SDU 2 Frag 1 ------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
sdu_packet_number++;
sdu_timestamp = sdu_interval - 1;
sdu_total_size = 10;
testdata_indx = 0;
testdata_size = 10;
sdu_fragments = 0;
isoal_test_create_sdu_fagment(BT_ISO_SINGLE,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test fragmentation (Black Box) */
/* Valid PDUs */
/* PDU 3 */
payload_number++;
pdu_write_loc = 0;
sdu_read_loc = 0;
pdu_write_size = testdata_size;
sdu_fragments++;
ZASSERT_PDU_WRITE_TEST(history[1],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
ZASSERT_PDU_EMIT_TEST(history[1],
&tx_pdu_meta_buf.node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_COMPLETE_END,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* Check TX Sync info */
tx_sync_seq_expected = 2;
tx_sync_timestamp_expected = (iso_interval_int * CONN_INT_UNIT_US) - 1;
tx_sync_offset_expected = 0;
err = isoal_tx_get_sync_info(source_hdl, &tx_sync_seq, &tx_sync_timestamp, &tx_sync_offset);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
zassert_equal(tx_sync_seq, tx_sync_seq_expected, "%u != %u", tx_sync_seq, 2);
zassert_equal(tx_sync_timestamp, tx_sync_timestamp_expected, "%u != %u", tx_sync_seq, 2);
zassert_equal(tx_sync_offset, tx_sync_offset_expected, "%u != %u", tx_sync_seq, 0);
}
/**
* Test Suite : TX unframed SDU fragmentation
*
* Tests fragmentation of two SDUs containing three fragments each
* into two PDUs each where Max PDU is greater than the PDU buffer size
*/
ZTEST(test_tx_unframed, test_tx_unframed_2_sdu_3_frag_4_pdu)
{
struct tx_pdu_meta_buffer tx_pdu_meta_buf[2];
struct tx_sdu_frag_buffer tx_sdu_frag_buf;
struct isoal_pdu_buffer pdu_buffer[2];
isoal_source_handle_t source_hdl;
isoal_sdu_len_t sdu_total_size;
isoal_pdu_len_t pdu_write_size;
uint32_t stream_sync_delay;
uint64_t sdu_packet_number;
uint32_t group_sync_delay;
uint8_t iso_interval_int;
uint64_t payload_number;
uint32_t sdu_timestamp;
uint16_t testdata_indx;
uint16_t testdata_size;
uint16_t pdu_write_loc;
uint16_t sdu_read_loc;
uint64_t event_number;
uint32_t sdu_interval;
uint8_t sdu_fragments;
uint8_t testdata[TEST_TX_PDU_PAYLOAD_MAX * 2];
uint32_t ref_point;
isoal_status_t err;
uint8_t max_octets;
uint8_t role;
uint8_t BN;
uint8_t FT;
/* Settings */
role = BT_CONN_ROLE_PERIPHERAL;
iso_interval_int = 2;
sdu_interval = CONN_INT_UNIT_US;
max_octets = TEST_TX_PDU_PAYLOAD_MAX + 5;
BN = 4;
FT = 1;
stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;
/* SDU 1 Frag 1 ------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[0]);
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[1]);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
init_test_data_buffer(testdata, TEST_TX_PDU_PAYLOAD_MAX * 2);
pdu_buffer[0].handle = (void *)&tx_pdu_meta_buf[0].node_tx;
pdu_buffer[0].pdu = (struct pdu_iso *)tx_pdu_meta_buf[0].node_tx.pdu;
pdu_buffer[0].size = TEST_TX_PDU_PAYLOAD_MAX;
pdu_buffer[1].handle = (void *)&tx_pdu_meta_buf[1].node_tx;
pdu_buffer[1].pdu = (struct pdu_iso *)tx_pdu_meta_buf[1].node_tx.pdu;
pdu_buffer[1].size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_packet_number = 2000;
event_number = 2000;
sdu_timestamp = 9249;
ref_point = sdu_timestamp + (iso_interval_int * CONN_INT_UNIT_US) - 50;
sdu_total_size = TEST_TX_PDU_PAYLOAD_MAX * 2;
testdata_indx = 0;
testdata_size = (TEST_TX_PDU_PAYLOAD_MAX * 2) / 3;
sdu_fragments = 0;
source_hdl = basic_tx_test_setup(0xADAD, /* Handle */
role, /* Role */
false, /* Framed */
BN, /* BN */
FT, /* FT */
max_octets, /* max_octets */
sdu_interval, /* SDU Interval */
iso_interval_int, /* ISO Interval */
stream_sync_delay, /* Stream Sync Delay */
group_sync_delay); /* Group Sync Delay */
isoal_test_create_sdu_fagment(BT_ISO_START,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[0]);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[1]);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[0]);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[1]);
PDU_ALLOC_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_WRITE_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_EMIT_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_RELEASE_TEST_RETURNS(ISOAL_STATUS_OK);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test fragmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
payload_number = event_number * BN;
pdu_write_loc = 0;
sdu_read_loc = 0;
pdu_write_size = (TEST_TX_PDU_PAYLOAD_MAX * 2) / 3;
sdu_fragments++;
ZASSERT_PDU_ALLOC_TEST_CALL_COUNT(1);
ZASSERT_PDU_WRITE_TEST(history[0],
pdu_buffer[0],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
/* PDU should not be emitted */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(0);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* SDU 1 Frag 2 ------------------------------------------------------*/
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
sdu_timestamp += 10;
testdata_indx += testdata_size;
testdata_size += (TEST_TX_PDU_PAYLOAD_MAX * 2) / 3;
isoal_test_create_sdu_fagment(BT_ISO_CONT,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test fragmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
pdu_write_loc = pdu_write_size;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_read_loc = testdata_indx;
ZASSERT_PDU_WRITE_TEST(history[1],
pdu_buffer[0],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
ZASSERT_PDU_EMIT_TEST(history[0],
&tx_pdu_meta_buf[0].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_START_CONTINUE,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* PDU 2 */
payload_number++;
sdu_read_loc = pdu_write_size;
pdu_write_size = testdata_size - testdata_indx - (pdu_write_size - pdu_write_loc);
pdu_write_loc = 0;
sdu_fragments = 1;
ZASSERT_PDU_ALLOC_TEST_CALL_COUNT(2);
ZASSERT_PDU_WRITE_TEST(history[2],
pdu_buffer[1],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
/* PDU should not be emitted */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(1);
/* SDU 1 Frag 3 ------------------------------------------------------*/
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
sdu_timestamp += 10;
testdata_indx = testdata_size;
testdata_size = TEST_TX_PDU_PAYLOAD_MAX * 2;
isoal_test_create_sdu_fagment(BT_ISO_END,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test fragmentation (Black Box) */
/* Valid PDUs */
/* PDU 2 */
pdu_write_loc = pdu_write_size;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_read_loc = testdata_indx;
sdu_fragments++;
/* PDU should not be allocated */
ZASSERT_PDU_ALLOC_TEST_CALL_COUNT(2);
ZASSERT_PDU_WRITE_TEST(history[3],
pdu_buffer[1],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
ZASSERT_PDU_EMIT_TEST(history[1],
&tx_pdu_meta_buf[1].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_COMPLETE_END,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* SDU 2 Frag 1 ------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[0]);
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[1]);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
init_test_data_buffer(testdata, TEST_TX_PDU_PAYLOAD_MAX * 2);
sdu_packet_number++;
event_number = 2000;
sdu_timestamp = 9249 + sdu_interval;
sdu_total_size = TEST_TX_PDU_PAYLOAD_MAX * 2;
testdata_indx = 0;
testdata_size = (TEST_TX_PDU_PAYLOAD_MAX * 2) / 3;
sdu_fragments = 0;
isoal_test_create_sdu_fagment(BT_ISO_START,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test fragmentation (Black Box) */
/* Valid PDUs */
/* PDU 3 */
payload_number++;
pdu_write_loc = 0;
sdu_read_loc = 0;
pdu_write_size = (TEST_TX_PDU_PAYLOAD_MAX * 2) / 3;
sdu_fragments++;
ZASSERT_PDU_ALLOC_TEST_CALL_COUNT(3);
ZASSERT_PDU_WRITE_TEST(history[4],
pdu_buffer[0],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
/* PDU should not be emitted */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(2);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* SDU 2 Frag 2 ------------------------------------------------------*/
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
sdu_timestamp += 10;
testdata_indx += testdata_size;
testdata_size += (TEST_TX_PDU_PAYLOAD_MAX * 2) / 3;
isoal_test_create_sdu_fagment(BT_ISO_CONT,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test fragmentation (Black Box) */
/* Valid PDUs */
/* PDU 3 */
pdu_write_loc = pdu_write_size;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_read_loc = testdata_indx;
ZASSERT_PDU_WRITE_TEST(history[5],
pdu_buffer[0],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
ZASSERT_PDU_EMIT_TEST(history[2],
&tx_pdu_meta_buf[0].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_START_CONTINUE,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* PDU 4 */
payload_number++;
sdu_read_loc = pdu_write_size;
pdu_write_size = testdata_size - testdata_indx - (pdu_write_size - pdu_write_loc);
pdu_write_loc = 0;
sdu_fragments = 1;
ZASSERT_PDU_ALLOC_TEST_CALL_COUNT(4);
ZASSERT_PDU_WRITE_TEST(history[6],
pdu_buffer[1],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
/* PDU should not be emitted */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(3);
/* SDU 2 Frag 3 ------------------------------------------------------*/
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
sdu_timestamp += 10;
testdata_indx = testdata_size;
testdata_size = TEST_TX_PDU_PAYLOAD_MAX * 2;
isoal_test_create_sdu_fagment(BT_ISO_END,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test fragmentation (Black Box) */
/* Valid PDUs */
/* PDU 4 */
pdu_write_loc = pdu_write_size;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_read_loc = testdata_indx;
sdu_fragments++;
/* PDU should not be allocated */
ZASSERT_PDU_ALLOC_TEST_CALL_COUNT(4);
ZASSERT_PDU_WRITE_TEST(history[7],
pdu_buffer[1],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
ZASSERT_PDU_EMIT_TEST(history[3],
&tx_pdu_meta_buf[1].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_COMPLETE_END,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
}
/**
* Test Suite : TX unframed SDU fragmentation
*
* Tests fragmentation of two SDUs containing three fragments each
* into two PDUs each where Max PDU is greater than the PDU buffer size
* with padding
*/
ZTEST(test_tx_unframed, test_tx_unframed_2_sdu_3_frag_4_pdu_padding)
{
struct tx_pdu_meta_buffer tx_pdu_meta_buf[3];
struct tx_sdu_frag_buffer tx_sdu_frag_buf;
struct isoal_pdu_buffer pdu_buffer[3];
isoal_source_handle_t source_hdl;
isoal_sdu_len_t sdu_total_size;
isoal_pdu_len_t pdu_write_size;
uint32_t stream_sync_delay;
uint64_t sdu_packet_number;
uint32_t group_sync_delay;
uint8_t iso_interval_int;
uint64_t payload_number;
uint32_t sdu_timestamp;
uint16_t testdata_indx;
uint16_t testdata_size;
uint16_t pdu_write_loc;
uint16_t sdu_read_loc;
uint64_t event_number;
uint32_t sdu_interval;
uint8_t sdu_fragments;
uint8_t testdata[TEST_TX_PDU_PAYLOAD_MAX * 2];
uint32_t ref_point;
isoal_status_t err;
uint8_t max_octets;
uint8_t role;
uint8_t BN;
uint8_t FT;
/* Settings */
role = BT_CONN_ROLE_PERIPHERAL;
iso_interval_int = 2;
sdu_interval = CONN_INT_UNIT_US;
max_octets = TEST_TX_PDU_PAYLOAD_MAX + 5;
BN = 8;
FT = 1;
stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;
/* SDU 1 Frag 1 ------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[0]);
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[1]);
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[2]);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
init_test_data_buffer(testdata, TEST_TX_PDU_PAYLOAD_MAX * 2);
pdu_buffer[0].handle = (void *)&tx_pdu_meta_buf[0].node_tx;
pdu_buffer[0].pdu = (struct pdu_iso *)tx_pdu_meta_buf[0].node_tx.pdu;
pdu_buffer[0].size = TEST_TX_PDU_PAYLOAD_MAX;
pdu_buffer[1].handle = (void *)&tx_pdu_meta_buf[1].node_tx;
pdu_buffer[1].pdu = (struct pdu_iso *)tx_pdu_meta_buf[1].node_tx.pdu;
pdu_buffer[1].size = TEST_TX_PDU_PAYLOAD_MAX;
pdu_buffer[2].handle = (void *)&tx_pdu_meta_buf[2].node_tx;
pdu_buffer[2].pdu = (struct pdu_iso *)tx_pdu_meta_buf[2].node_tx.pdu;
pdu_buffer[2].size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_packet_number = 2000;
event_number = 2000;
sdu_timestamp = 9249;
ref_point = sdu_timestamp + (iso_interval_int * CONN_INT_UNIT_US) - 50;
sdu_total_size = TEST_TX_PDU_PAYLOAD_MAX * 2;
testdata_indx = 0;
testdata_size = (TEST_TX_PDU_PAYLOAD_MAX * 2) / 3;
sdu_fragments = 0;
source_hdl = basic_tx_test_setup(0xADAD, /* Handle */
role, /* Role */
false, /* Framed */
BN, /* BN */
FT, /* FT */
max_octets, /* max_octets */
sdu_interval, /* SDU Interval */
iso_interval_int, /* ISO Interval */
stream_sync_delay, /* Stream Sync Delay */
group_sync_delay); /* Group Sync Delay */
isoal_test_create_sdu_fagment(BT_ISO_START,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[0]);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[1]);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[0]);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[2]);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[0]);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[1]);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[0]);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[2]);
PDU_ALLOC_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_WRITE_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_EMIT_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_RELEASE_TEST_RETURNS(ISOAL_STATUS_OK);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test fragmentation (Black Box) */
/* Valid PDUs */
/* PDU 2 */
payload_number = event_number * BN;
pdu_write_loc = 0;
sdu_read_loc = 0;
pdu_write_size = (TEST_TX_PDU_PAYLOAD_MAX * 2) / 3;
sdu_fragments++;
ZASSERT_PDU_ALLOC_TEST_CALL_COUNT(1);
ZASSERT_PDU_WRITE_TEST(history[0],
pdu_buffer[0],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
/* PDU should not be emitted */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(0);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* SDU 1 Frag 2 ------------------------------------------------------*/
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
sdu_timestamp += 10;
testdata_indx += testdata_size;
testdata_size += (TEST_TX_PDU_PAYLOAD_MAX * 2) / 3;
isoal_test_create_sdu_fagment(BT_ISO_CONT,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test fragmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
pdu_write_loc = pdu_write_size;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_read_loc = testdata_indx;
ZASSERT_PDU_WRITE_TEST(history[1],
pdu_buffer[0],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
ZASSERT_PDU_EMIT_TEST(history[0],
&tx_pdu_meta_buf[0].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_START_CONTINUE,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU 2 */
payload_number++;
sdu_read_loc = pdu_write_size;
pdu_write_size = testdata_size - testdata_indx - (pdu_write_size - pdu_write_loc);
pdu_write_loc = 0;
sdu_fragments = 1;
ZASSERT_PDU_ALLOC_TEST_CALL_COUNT(2);
ZASSERT_PDU_WRITE_TEST(history[2],
pdu_buffer[1],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
/* PDU should not be emitted */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(1);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* SDU 1 Frag 3 ------------------------------------------------------*/
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
sdu_timestamp += 10;
testdata_indx = testdata_size;
testdata_size = TEST_TX_PDU_PAYLOAD_MAX * 2;
isoal_test_create_sdu_fagment(BT_ISO_END,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test fragmentation (Black Box) */
/* Valid PDUs */
/* PDU 2 */
pdu_write_loc = pdu_write_size;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_read_loc = testdata_indx;
sdu_fragments++;
ZASSERT_PDU_WRITE_TEST(history[3],
pdu_buffer[1],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
ZASSERT_PDU_EMIT_TEST(history[1],
&tx_pdu_meta_buf[1].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_COMPLETE_END,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* Padding PDUs */
/* Padding 1 */
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[0]);
payload_number++;
pdu_write_size = 0;
sdu_fragments = 0;
/* PDU should not be written to */
ZASSERT_PDU_WRITE_TEST_CALL_COUNT(4);
ZASSERT_PDU_EMIT_TEST(history[2],
&tx_pdu_meta_buf[0].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_START_CONTINUE,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* Padding 2 */
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[2]);
payload_number++;
pdu_write_size = 0;
sdu_fragments = 0;
ZASSERT_PDU_ALLOC_TEST_CALL_COUNT(4);
/* PDU should not be written to */
ZASSERT_PDU_WRITE_TEST_CALL_COUNT(4);
ZASSERT_PDU_EMIT_TEST(history[3],
&tx_pdu_meta_buf[2].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_START_CONTINUE,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* SDU 2 Frag 1 ------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[0]);
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[1]);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
init_test_data_buffer(testdata, TEST_TX_PDU_PAYLOAD_MAX * 2);
sdu_packet_number++;
event_number = 2000;
sdu_timestamp = 9249 + sdu_interval;
sdu_total_size = TEST_TX_PDU_PAYLOAD_MAX * 2;
testdata_indx = 0;
testdata_size = (TEST_TX_PDU_PAYLOAD_MAX * 2) / 3;
sdu_fragments = 0;
isoal_test_create_sdu_fagment(BT_ISO_START,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test fragmentation (Black Box) */
/* Valid PDUs */
/* PDU 3 */
payload_number++;
pdu_write_loc = 0;
sdu_read_loc = 0;
pdu_write_size = (TEST_TX_PDU_PAYLOAD_MAX * 2) / 3;
sdu_fragments++;
ZASSERT_PDU_ALLOC_TEST_CALL_COUNT(5);
ZASSERT_PDU_WRITE_TEST(history[4],
pdu_buffer[0],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
/* PDU should not be emitted */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(4);
/* PDU release not expected (No Error) */
/* SDU 2 Frag 2 ------------------------------------------------------*/
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
sdu_timestamp += 10;
testdata_indx += testdata_size;
testdata_size += (TEST_TX_PDU_PAYLOAD_MAX * 2) / 3;
isoal_test_create_sdu_fagment(BT_ISO_CONT,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test fragmentation (Black Box) */
/* Valid PDUs */
/* PDU 3 */
pdu_write_loc = pdu_write_size;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_read_loc = testdata_indx;
ZASSERT_PDU_WRITE_TEST(history[5],
pdu_buffer[0],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
ZASSERT_PDU_EMIT_TEST(history[4],
&tx_pdu_meta_buf[0].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_START_CONTINUE,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU 4 */
payload_number++;
sdu_read_loc = pdu_write_size;
pdu_write_size = testdata_size - testdata_indx - (pdu_write_size - pdu_write_loc);
pdu_write_loc = 0;
sdu_fragments = 1;
ZASSERT_PDU_ALLOC_TEST_CALL_COUNT(6);
ZASSERT_PDU_WRITE_TEST(history[6],
pdu_buffer[1],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
/* PDU should not be emitted */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(5);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* SDU 2 Frag 3 ------------------------------------------------------*/
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
sdu_timestamp += 10;
testdata_indx = testdata_size;
testdata_size = TEST_TX_PDU_PAYLOAD_MAX * 2;
isoal_test_create_sdu_fagment(BT_ISO_END,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test fragmentation (Black Box) */
/* Valid PDUs */
/* PDU 4 */
pdu_write_loc = pdu_write_size;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_read_loc = testdata_indx;
sdu_fragments++;
ZASSERT_PDU_WRITE_TEST(history[7],
pdu_buffer[1],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
ZASSERT_PDU_EMIT_TEST(history[5],
&tx_pdu_meta_buf[1].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_COMPLETE_END,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* Padding PDUs */
/* Padding 3 */
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[0]);
payload_number++;
pdu_write_size = 0;
sdu_fragments = 0;
/* PDU should not be written to */
ZASSERT_PDU_WRITE_TEST_CALL_COUNT(8);
ZASSERT_PDU_EMIT_TEST(history[6],
&tx_pdu_meta_buf[0].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_START_CONTINUE,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* Padding 4 */
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[2]);
payload_number++;
pdu_write_size = 0;
sdu_fragments = 0;
ZASSERT_PDU_ALLOC_TEST_CALL_COUNT(8);
/* PDU should not be written to */
ZASSERT_PDU_WRITE_TEST_CALL_COUNT(8);
ZASSERT_PDU_EMIT_TEST(history[7],
&tx_pdu_meta_buf[2].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_START_CONTINUE,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
}
/**
* Test Suite : TX unframed SDU fragmentation
*
* Tests fragmentation of a single SDU contained in a single fragment
* into a single PDU where Max PDU is less than the PDU buffer size,
* followed by padding
*/
ZTEST(test_tx_unframed, test_tx_unframed_1_zero_sdu_1_frag_1_pdu_maxPDU_padding)
{
struct tx_pdu_meta_buffer tx_pdu_meta_buf[3];
struct tx_sdu_frag_buffer tx_sdu_frag_buf;
struct isoal_pdu_buffer pdu_buffer[3];
isoal_source_handle_t source_hdl;
isoal_sdu_len_t sdu_total_size;
isoal_pdu_len_t pdu_write_size;
uint32_t stream_sync_delay;
uint64_t sdu_packet_number;
uint32_t group_sync_delay;
uint8_t iso_interval_int;
uint64_t payload_number;
uint32_t sdu_timestamp;
uint16_t testdata_indx;
uint16_t testdata_size;
uint16_t pdu_write_loc;
uint16_t sdu_read_loc;
uint64_t event_number;
uint32_t sdu_interval;
uint8_t sdu_fragments;
uint8_t testdata[1];
uint32_t ref_point;
isoal_status_t err;
uint8_t max_octets;
uint8_t role;
uint8_t BN;
uint8_t FT;
/* Settings */
role = BT_CONN_ROLE_PERIPHERAL;
iso_interval_int = 1;
sdu_interval = CONN_INT_UNIT_US;
max_octets = TEST_TX_PDU_PAYLOAD_MAX - 5;
BN = 3;
FT = 1;
stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;
/* SDU 1 Frag 1 ------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[0]);
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[1]);
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[2]);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
init_test_data_buffer(testdata, 1);
pdu_buffer[0].handle = (void *)&tx_pdu_meta_buf[0].node_tx;
pdu_buffer[0].pdu = (struct pdu_iso *)tx_pdu_meta_buf[0].node_tx.pdu;
pdu_buffer[0].size = TEST_TX_PDU_PAYLOAD_MAX;
pdu_buffer[1].handle = (void *)&tx_pdu_meta_buf[1].node_tx;
pdu_buffer[1].pdu = (struct pdu_iso *)tx_pdu_meta_buf[1].node_tx.pdu;
pdu_buffer[1].size = TEST_TX_PDU_PAYLOAD_MAX;
pdu_buffer[2].handle = (void *)&tx_pdu_meta_buf[2].node_tx;
pdu_buffer[2].pdu = (struct pdu_iso *)tx_pdu_meta_buf[2].node_tx.pdu;
pdu_buffer[2].size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_packet_number = 2000;
event_number = 2000;
sdu_timestamp = 9249;
ref_point = sdu_timestamp + (iso_interval_int * CONN_INT_UNIT_US) - 50;
sdu_total_size = 0;
testdata_indx = 0;
testdata_size = 0;
payload_number = event_number * BN;
pdu_write_loc = 0;
sdu_read_loc = 0;
pdu_write_size = 0;
source_hdl = basic_tx_test_setup(0xADAD, /* Handle */
role, /* Role */
false, /* Framed */
BN, /* BN */
FT, /* FT */
max_octets, /* max_octets */
sdu_interval, /* SDU Interval */
iso_interval_int, /* ISO Interval */
stream_sync_delay, /* Stream Sync Delay */
group_sync_delay); /* Group Sync Delay */
isoal_test_create_sdu_fagment(BT_ISO_SINGLE,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[0]);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[1]);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[2]);
PDU_ALLOC_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_WRITE_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_EMIT_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_RELEASE_TEST_RETURNS(ISOAL_STATUS_OK);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test fragmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
sdu_fragments = 1;
/* PDU should not be written to */
ZASSERT_PDU_WRITE_TEST_CALL_COUNT(0);
ZASSERT_PDU_EMIT_TEST(history[0],
&tx_pdu_meta_buf[0].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_COMPLETE_END,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* Padding PDUs */
/* Padding 1 */
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[1]);
payload_number++;
pdu_write_size = 0;
sdu_fragments = 0;
/* PDU should not be written to */
ZASSERT_PDU_WRITE_TEST_CALL_COUNT(0);
ZASSERT_PDU_EMIT_TEST(history[1],
&tx_pdu_meta_buf[1].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_START_CONTINUE,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* Padding 2 */
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[2]);
payload_number++;
pdu_write_size = 0;
sdu_fragments = 0;
ZASSERT_PDU_ALLOC_TEST_CALL_COUNT(3);
/* PDU should not be written to */
ZASSERT_PDU_WRITE_TEST_CALL_COUNT(0);
ZASSERT_PDU_EMIT_TEST(history[2],
&tx_pdu_meta_buf[2].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_START_CONTINUE,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
}
/**
* Test Suite : TX unframed SDU fragmentation
*
* Tests fragmentation of a single SDU contained in a single fragment,
* where PDU allocation fails
*/
ZTEST(test_tx_unframed, test_tx_unframed_1_sdu_1_frag_pdu_alloc_err)
{
struct tx_pdu_meta_buffer tx_pdu_meta_buf;
struct tx_sdu_frag_buffer tx_sdu_frag_buf;
struct isoal_pdu_buffer pdu_buffer;
isoal_source_handle_t source_hdl;
isoal_sdu_len_t sdu_total_size;
isoal_pdu_len_t pdu_write_size;
uint32_t stream_sync_delay;
uint64_t sdu_packet_number;
uint32_t group_sync_delay;
uint8_t iso_interval_int;
uint64_t payload_number;
uint32_t sdu_timestamp;
uint16_t testdata_indx;
uint16_t testdata_size;
uint16_t pdu_write_loc;
uint16_t sdu_read_loc;
uint64_t event_number;
uint32_t sdu_interval;
uint8_t sdu_fragments;
uint8_t testdata[TEST_TX_PDU_PAYLOAD_MAX - 5];
uint32_t ref_point;
isoal_status_t err;
uint8_t max_octets;
uint8_t role;
uint8_t BN;
uint8_t FT;
/* Settings */
role = BT_CONN_ROLE_PERIPHERAL;
iso_interval_int = 1;
sdu_interval = CONN_INT_UNIT_US;
max_octets = TEST_TX_PDU_PAYLOAD_MAX - 5;
BN = 1;
FT = 1;
stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;
/* SDU Frag 1 --------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
init_test_data_buffer(testdata, TEST_TX_PDU_PAYLOAD_MAX - 5);
pdu_buffer.handle = NULL;
pdu_buffer.pdu = NULL;
pdu_buffer.size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_packet_number = 2000;
event_number = 2000;
sdu_timestamp = 9249;
ref_point = sdu_timestamp + (iso_interval_int * CONN_INT_UNIT_US) - 50;
sdu_total_size = TEST_TX_PDU_PAYLOAD_MAX - 5;
testdata_indx = 0;
testdata_size = TEST_TX_PDU_PAYLOAD_MAX - 5;
payload_number = event_number * BN;
pdu_write_loc = 0;
sdu_read_loc = 0;
pdu_write_size = 0;
source_hdl = basic_tx_test_setup(0xADAD, /* Handle */
role, /* Role */
false, /* Framed */
BN, /* BN */
FT, /* FT */
max_octets, /* max_octets */
sdu_interval, /* SDU Interval */
iso_interval_int, /* ISO Interval */
stream_sync_delay, /* Stream Sync Delay */
group_sync_delay); /* Group Sync Delay */
isoal_test_create_sdu_fagment(BT_ISO_SINGLE,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
PDU_ALLOC_TEST_RETURNS(ISOAL_STATUS_ERR_PDU_ALLOC);
PDU_WRITE_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_EMIT_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_RELEASE_TEST_RETURNS(ISOAL_STATUS_OK);
ztest_set_assert_valid(true);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
ztest_set_assert_valid(false);
zassert_equal(err, ISOAL_STATUS_ERR_PDU_ALLOC, "err = 0x%02x", err);
/* Test fragmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
sdu_fragments = 1;
ZASSERT_PDU_ALLOC_TEST_CALL_COUNT(1);
/* PDU should not be written to */
ZASSERT_PDU_WRITE_TEST_CALL_COUNT(0);
/* PDU should not be emitted */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(0);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
}
/**
* Test Suite : TX unframed SDU fragmentation
*
* Tests fragmentation of a single SDU contained in a single fragment
* into a single PDU where Max PDU is less than the PDU buffer size,
* where PDU emit fails
*/
ZTEST(test_tx_unframed, test_tx_unframed_1_sdu_1_frag_pdu_emit_err)
{
struct tx_pdu_meta_buffer tx_pdu_meta_buf;
struct tx_sdu_frag_buffer tx_sdu_frag_buf;
struct isoal_pdu_buffer pdu_buffer;
isoal_source_handle_t source_hdl;
isoal_sdu_len_t sdu_total_size;
isoal_pdu_len_t pdu_write_size;
uint32_t stream_sync_delay;
uint64_t sdu_packet_number;
uint32_t group_sync_delay;
uint8_t iso_interval_int;
uint64_t payload_number;
uint32_t sdu_timestamp;
uint16_t testdata_indx;
uint16_t testdata_size;
uint16_t pdu_write_loc;
uint16_t sdu_read_loc;
uint64_t event_number;
uint32_t sdu_interval;
uint8_t sdu_fragments;
uint8_t testdata[TEST_TX_PDU_PAYLOAD_MAX - 5];
uint32_t ref_point;
isoal_status_t err;
uint8_t max_octets;
uint8_t role;
uint8_t BN;
uint8_t FT;
/* Settings */
role = BT_CONN_ROLE_PERIPHERAL;
iso_interval_int = 1;
sdu_interval = CONN_INT_UNIT_US;
max_octets = TEST_TX_PDU_PAYLOAD_MAX - 5;
BN = 1;
FT = 1;
stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;
/* SDU Frag 1 --------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
init_test_data_buffer(testdata, TEST_TX_PDU_PAYLOAD_MAX - 5);
pdu_buffer.handle = (void *)&tx_pdu_meta_buf.node_tx;
pdu_buffer.pdu = (struct pdu_iso *)tx_pdu_meta_buf.node_tx.pdu;
pdu_buffer.size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_packet_number = 2000;
event_number = 2000;
sdu_timestamp = 9249;
ref_point = sdu_timestamp + (iso_interval_int * CONN_INT_UNIT_US) - 50;
sdu_total_size = TEST_TX_PDU_PAYLOAD_MAX - 5;
testdata_indx = 0;
testdata_size = TEST_TX_PDU_PAYLOAD_MAX - 5;
payload_number = event_number * BN;
pdu_write_loc = 0;
sdu_read_loc = 0;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX - 5;
source_hdl = basic_tx_test_setup(0xADAD, /* Handle */
role, /* Role */
false, /* Framed */
BN, /* BN */
FT, /* FT */
max_octets, /* max_octets */
sdu_interval, /* SDU Interval */
iso_interval_int, /* ISO Interval */
stream_sync_delay, /* Stream Sync Delay */
group_sync_delay); /* Group Sync Delay */
isoal_test_create_sdu_fagment(BT_ISO_SINGLE,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
PDU_ALLOC_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_WRITE_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_EMIT_TEST_RETURNS(ISOAL_STATUS_ERR_PDU_EMIT);
PDU_RELEASE_TEST_RETURNS(ISOAL_STATUS_OK);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_ERR_PDU_EMIT, "err = 0x%02x", err);
/* Test fragmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
sdu_fragments = 1;
ZASSERT_PDU_ALLOC_TEST_CALL_COUNT(1);
ZASSERT_PDU_WRITE_TEST(history[0],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
ZASSERT_PDU_EMIT_TEST(history[0],
&tx_pdu_meta_buf.node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_COMPLETE_END,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
ZASSERT_PDU_RELEASE_TEST(
history[0],
&tx_pdu_meta_buf.node_tx,
bt_iso_handle(isoal_global.source_state[source_hdl].session.handle),
ISOAL_STATUS_ERR_PDU_EMIT);
}
/**
* Test Suite : TX unframed SDU fragmentation
*
* Tests fragmentation of a single SDU contained in a single fragment
* into a single PDU such that it does not insert a skew into the stream.
*/
ZTEST(test_tx_unframed, test_tx_unframed_4_sdu_1_frag_4_pdu_stream_loc)
{
struct tx_pdu_meta_buffer tx_pdu_meta_buf;
struct tx_sdu_frag_buffer tx_sdu_frag_buf;
uint32_t tx_sync_timestamp_expected;
struct isoal_pdu_buffer pdu_buffer;
isoal_source_handle_t source_hdl;
uint32_t tx_sync_offset_expected;
isoal_sdu_len_t sdu_total_size;
isoal_pdu_len_t pdu_write_size;
uint16_t tx_sync_seq_expected;
uint32_t stream_sync_delay;
uint64_t sdu_packet_number;
uint32_t tx_sync_timestamp;
uint32_t group_sync_delay;
uint8_t iso_interval_int;
uint64_t payload_number;
uint32_t tx_sync_offset;
uint32_t sdu_timestamp;
uint16_t testdata_indx;
uint16_t testdata_size;
uint16_t pdu_write_loc;
uint16_t sdu_read_loc;
uint64_t event_number;
uint32_t sdu_interval;
uint8_t sdu_fragments;
uint8_t testdata[53];
uint16_t tx_sync_seq;
uint32_t ref_point;
isoal_status_t err;
uint8_t max_octets;
uint8_t role;
uint8_t BN;
uint8_t FT;
/* Settings */
role = BT_CONN_ROLE_PERIPHERAL;
iso_interval_int = 1;
sdu_interval = CONN_INT_UNIT_US / 2;
max_octets = TEST_TX_PDU_PAYLOAD_MAX - 5;
BN = 2;
FT = 1;
stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;
/* SDU Frag 1 --------------------------------------------------------*/
/* Sets initial fragmentation status */
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
init_test_data_buffer(testdata, sizeof(testdata));
pdu_buffer.handle = (void *)&tx_pdu_meta_buf.node_tx;
pdu_buffer.pdu = (struct pdu_iso *)tx_pdu_meta_buf.node_tx.pdu;
pdu_buffer.size = TEST_TX_PDU_PAYLOAD_MAX;
event_number = 2000;
sdu_packet_number = (event_number * BN);
sdu_timestamp = 9249;
ref_point = sdu_timestamp + (iso_interval_int * CONN_INT_UNIT_US) - 50;
sdu_total_size = 23;
testdata_indx = 0;
testdata_size = 23;
payload_number = event_number * BN;
pdu_write_loc = 0;
sdu_read_loc = 0;
pdu_write_size = 23;
source_hdl = basic_tx_test_setup(0xADAD, /* Handle */
role, /* Role */
false, /* Framed */
BN, /* BN */
FT, /* FT */
max_octets, /* max_octets */
sdu_interval, /* SDU Interval */
iso_interval_int, /* ISO Interval */
stream_sync_delay, /* Stream Sync Delay */
group_sync_delay); /* Group Sync Delay */
isoal_test_create_sdu_fagment(BT_ISO_SINGLE,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
PDU_ALLOC_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_WRITE_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_EMIT_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_RELEASE_TEST_RETURNS(ISOAL_STATUS_OK);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test fragmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
sdu_fragments = 1;
ZASSERT_PDU_WRITE_TEST(history[0],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
ZASSERT_PDU_EMIT_TEST(history[0],
&tx_pdu_meta_buf.node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_COMPLETE_END,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* Check TX Sync info */
tx_sync_seq_expected = 1;
tx_sync_timestamp_expected = ref_point;
tx_sync_offset_expected = 0;
err = isoal_tx_get_sync_info(source_hdl, &tx_sync_seq, &tx_sync_timestamp, &tx_sync_offset);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
zassert_equal(tx_sync_seq, tx_sync_seq_expected, "%u != %u", tx_sync_seq, 2);
zassert_equal(tx_sync_timestamp, tx_sync_timestamp_expected, "%u != %u", tx_sync_seq, 2);
zassert_equal(tx_sync_offset, tx_sync_offset_expected, "%u != %u", tx_sync_seq, 0);
/* SDU 2 Frag 1 ------------------------------------------------------*/
/* Check correct position in stream based on the SDU packet number */
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
sdu_packet_number += 29;
sdu_timestamp += ((iso_interval_int * CONN_INT_UNIT_US) * 15) - sdu_interval;
event_number += 15;
ref_point += (iso_interval_int * CONN_INT_UNIT_US) * 15;
sdu_total_size = 10;
testdata_indx = testdata_size;
testdata_size += 10;
sdu_fragments = 0;
isoal_test_create_sdu_fagment(BT_ISO_SINGLE,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test fragmentation (Black Box) */
/* Valid PDUs */
/* PDU 2 */
payload_number += 29;
pdu_write_loc = 0;
sdu_read_loc = testdata_indx;
pdu_write_size = (testdata_size - testdata_indx);
sdu_fragments++;
ZASSERT_PDU_WRITE_TEST(history[1],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
ZASSERT_PDU_EMIT_TEST(history[1],
&tx_pdu_meta_buf.node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_COMPLETE_END,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* Check TX Sync info */
tx_sync_seq_expected += 29;
tx_sync_timestamp_expected = ref_point - (iso_interval_int * CONN_INT_UNIT_US);
tx_sync_offset_expected = 0;
err = isoal_tx_get_sync_info(source_hdl, &tx_sync_seq, &tx_sync_timestamp, &tx_sync_offset);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
zassert_equal(tx_sync_seq, tx_sync_seq_expected, "%u != %u", tx_sync_seq, 2);
zassert_equal(tx_sync_timestamp, tx_sync_timestamp_expected, "%u != %u", tx_sync_seq, 2);
zassert_equal(tx_sync_offset, tx_sync_offset_expected, "%u != %u", tx_sync_seq, 0);
/* SDU 3 Frag 1 ------------------------------------------------------*/
/* Check correct position in stream based on the SDU time stamp */
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
/* Same SDU packet sequence number for testing */
/* Time stamp just before the exact multiple of the SDU interval */
sdu_timestamp += ((iso_interval_int * CONN_INT_UNIT_US) * 15) - 1;
event_number += 15;
ref_point += (iso_interval_int * CONN_INT_UNIT_US) * 15;
sdu_total_size = 10;
testdata_indx = testdata_size;
testdata_size += 10;
sdu_fragments = 0;
isoal_test_create_sdu_fagment(BT_ISO_SINGLE,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test fragmentation (Black Box) */
/* Valid PDUs */
/* PDU 3 */
payload_number += 30;
pdu_write_loc = 0;
sdu_read_loc = testdata_indx;
pdu_write_size = (testdata_size - testdata_indx);
sdu_fragments++;
ZASSERT_PDU_WRITE_TEST(history[2],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
ZASSERT_PDU_EMIT_TEST(history[2],
&tx_pdu_meta_buf.node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_COMPLETE_END,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* Check TX Sync info */
tx_sync_seq_expected += 30;
tx_sync_timestamp_expected = ref_point - (iso_interval_int * CONN_INT_UNIT_US);
tx_sync_offset_expected = 0;
err = isoal_tx_get_sync_info(source_hdl, &tx_sync_seq, &tx_sync_timestamp, &tx_sync_offset);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
zassert_equal(tx_sync_seq, tx_sync_seq_expected, "%u != %u", tx_sync_seq, 2);
zassert_equal(tx_sync_timestamp, tx_sync_timestamp_expected, "%u != %u", tx_sync_seq, 2);
zassert_equal(tx_sync_offset, tx_sync_offset_expected, "%u != %u", tx_sync_seq, 0);
/* SDU 4 Frag 1 ------------------------------------------------------*/
/* Check correct position in stream based on the SDU time stamp */
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
/* Same SDU packet sequence number for testing */
/* Time stamp just after the exact multiple of the SDU interval.
* +1 (reset to exact multiple of SDU interval from the last SDU)
* +1 (push the time stamp 1us beyond the multiple mark)
*/
sdu_timestamp += ((iso_interval_int * CONN_INT_UNIT_US) * 15) + 1 + 1;
event_number += 15;
ref_point += (iso_interval_int * CONN_INT_UNIT_US) * 15;
sdu_total_size = 10;
testdata_indx = testdata_size;
testdata_size += 10;
sdu_fragments = 0;
isoal_test_create_sdu_fagment(BT_ISO_SINGLE,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test fragmentation (Black Box) */
/* Valid PDUs */
/* PDU 3 */
payload_number += 30;
pdu_write_loc = 0;
sdu_read_loc = testdata_indx;
pdu_write_size = (testdata_size - testdata_indx);
sdu_fragments++;
ZASSERT_PDU_WRITE_TEST(history[3],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
ZASSERT_PDU_EMIT_TEST(history[3],
&tx_pdu_meta_buf.node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_COMPLETE_END,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* Check TX Sync info */
tx_sync_seq_expected += 30;
tx_sync_timestamp_expected = ref_point - (iso_interval_int * CONN_INT_UNIT_US);
tx_sync_offset_expected = 0;
err = isoal_tx_get_sync_info(source_hdl, &tx_sync_seq, &tx_sync_timestamp, &tx_sync_offset);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
zassert_equal(tx_sync_seq, tx_sync_seq_expected, "%u != %u", tx_sync_seq, 2);
zassert_equal(tx_sync_timestamp, tx_sync_timestamp_expected, "%u != %u", tx_sync_seq, 2);
zassert_equal(tx_sync_offset, tx_sync_offset_expected, "%u != %u", tx_sync_seq, 0);
}
/**
* Test Suite : TX framed SDU segmentation
*
* Tests segmentation of a single SDU contained in a single fragment
* into a single PDU where Max PDU is less than the PDU buffer size
*/
ZTEST(test_tx_framed, test_tx_framed_1_sdu_1_frag_1_pdu_maxPDU)
{
uint8_t testdata[TEST_TX_PDU_PAYLOAD_MAX - 5 -
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE)];
struct tx_pdu_meta_buffer tx_pdu_meta_buf;
struct tx_sdu_frag_buffer tx_sdu_frag_buf;
struct isoal_pdu_buffer pdu_buffer;
isoal_source_handle_t source_hdl;
struct pdu_iso_sdu_sh seg_hdr[2];
isoal_sdu_len_t sdu_total_size;
isoal_pdu_len_t pdu_write_size;
uint32_t stream_sync_delay;
uint64_t sdu_packet_number;
uint32_t group_sync_delay;
uint8_t iso_interval_int;
uint64_t payload_number;
uint32_t sdu_timestamp;
uint16_t testdata_indx;
uint16_t testdata_size;
uint16_t pdu_write_loc;
uint16_t sdu_read_loc;
uint64_t event_number;
uint32_t sdu_interval;
uint8_t sdu_fragments;
uint16_t pdu_hdr_loc;
uint32_t ref_point;
isoal_status_t err;
uint8_t max_octets;
uint8_t role;
uint8_t BN;
uint8_t FT;
/* Settings */
role = BT_CONN_ROLE_PERIPHERAL;
iso_interval_int = 1;
sdu_interval = CONN_INT_UNIT_US + 50;
max_octets = TEST_TX_PDU_PAYLOAD_MAX - 5;
BN = 1;
FT = 1;
stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;
/* SDU Frag 1 --------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
init_test_data_buffer(testdata,
TEST_TX_PDU_PAYLOAD_MAX - 5 -
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE));
(void)memset(&seg_hdr, 0, sizeof(seg_hdr));
pdu_buffer.handle = (void *)&tx_pdu_meta_buf.node_tx;
pdu_buffer.pdu = (struct pdu_iso *)tx_pdu_meta_buf.node_tx.pdu;
pdu_buffer.size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_packet_number = 2000;
event_number = 2000;
sdu_timestamp = 9249;
ref_point = sdu_timestamp + (iso_interval_int * CONN_INT_UNIT_US) - 50;
sdu_total_size =
TEST_TX_PDU_PAYLOAD_MAX - 5 - (PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE);
testdata_indx = 0;
testdata_size =
TEST_TX_PDU_PAYLOAD_MAX - 5 - (PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE);
payload_number = event_number * BN;
source_hdl = basic_tx_test_setup(0xADAD, /* Handle */
role, /* Role */
true, /* Framed */
BN, /* BN */
FT, /* FT */
max_octets, /* max_octets */
sdu_interval, /* SDU Interval */
iso_interval_int, /* ISO Interval */
stream_sync_delay, /* Stream Sync Delay */
group_sync_delay); /* Group Sync Delay */
isoal_test_create_sdu_fagment(BT_ISO_SINGLE,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
PDU_ALLOC_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_WRITE_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_EMIT_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_RELEASE_TEST_RETURNS(ISOAL_STATUS_OK);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
seg_hdr[0].sc = 0;
seg_hdr[0].cmplt = 0;
seg_hdr[0].timeoffset = ref_point - sdu_timestamp;
seg_hdr[0].len = PDU_ISO_SEG_TIMEOFFSET_SIZE;
pdu_hdr_loc = 0;
pdu_write_loc = PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE;
sdu_read_loc = 0;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX - 5;
sdu_fragments = 1;
ZASSERT_PDU_WRITE_TEST(history[0],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[0],
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE));
ZASSERT_PDU_WRITE_TEST(history[1],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[1] = seg_hdr[0];
seg_hdr[1].cmplt = 1;
seg_hdr[1].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[2],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[1],
PDU_ISO_SEG_HDR_SIZE);
ZASSERT_PDU_EMIT_TEST(history[0],
&tx_pdu_meta_buf.node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* Test PDU release */
isoal_tx_pdu_release(source_hdl, &tx_pdu_meta_buf.node_tx);
ZASSERT_PDU_RELEASE_TEST(history[0],
&tx_pdu_meta_buf.node_tx,
isoal_global.source_state[source_hdl].session.handle,
ISOAL_STATUS_OK);
}
/**
* Test Suite : TX framed SDU segmentation
*
* Tests segmentation of a single SDU contained in a single fragment
* into a single PDU where Max PDU is greater than the PDU buffer size
*/
ZTEST(test_tx_framed, test_tx_framed_1_sdu_1_frag_1_pdu_bufSize)
{
uint8_t testdata[TEST_TX_PDU_PAYLOAD_MAX -
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE)];
struct tx_pdu_meta_buffer tx_pdu_meta_buf;
struct tx_sdu_frag_buffer tx_sdu_frag_buf;
struct isoal_pdu_buffer pdu_buffer;
isoal_source_handle_t source_hdl;
struct pdu_iso_sdu_sh seg_hdr[2];
isoal_sdu_len_t sdu_total_size;
isoal_pdu_len_t pdu_write_size;
uint32_t stream_sync_delay;
uint64_t sdu_packet_number;
uint32_t group_sync_delay;
uint8_t iso_interval_int;
uint64_t payload_number;
uint32_t sdu_timestamp;
uint16_t testdata_indx;
uint16_t testdata_size;
uint16_t pdu_write_loc;
uint16_t sdu_read_loc;
uint64_t event_number;
uint32_t sdu_interval;
uint8_t sdu_fragments;
uint16_t pdu_hdr_loc;
uint32_t ref_point;
isoal_status_t err;
uint8_t max_octets;
uint8_t role;
uint8_t BN;
uint8_t FT;
/* Settings */
role = BT_CONN_ROLE_PERIPHERAL;
iso_interval_int = 1;
sdu_interval = CONN_INT_UNIT_US + 50;
max_octets = TEST_TX_PDU_PAYLOAD_MAX + 5;
BN = 1;
FT = 1;
stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;
/* SDU Frag 1 --------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
init_test_data_buffer(testdata,
TEST_TX_PDU_PAYLOAD_MAX -
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE));
(void)memset(seg_hdr, 0, sizeof(seg_hdr));
pdu_buffer.handle = (void *)&tx_pdu_meta_buf.node_tx;
pdu_buffer.pdu = (struct pdu_iso *)tx_pdu_meta_buf.node_tx.pdu;
pdu_buffer.size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_packet_number = 2000;
event_number = 2000;
sdu_timestamp = 9249;
ref_point = sdu_timestamp + (iso_interval_int * CONN_INT_UNIT_US) - 50;
sdu_total_size =
TEST_TX_PDU_PAYLOAD_MAX - (PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE);
testdata_indx = 0;
testdata_size =
TEST_TX_PDU_PAYLOAD_MAX - (PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE);
payload_number = event_number * BN;
source_hdl = basic_tx_test_setup(0xADAD, /* Handle */
role, /* Role */
true, /* Framed */
BN, /* BN */
FT, /* FT */
max_octets, /* max_octets */
sdu_interval, /* SDU Interval */
iso_interval_int, /* ISO Interval */
stream_sync_delay, /* Stream Sync Delay */
group_sync_delay); /* Group Sync Delay */
isoal_test_create_sdu_fagment(BT_ISO_SINGLE,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
PDU_ALLOC_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_WRITE_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_EMIT_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_RELEASE_TEST_RETURNS(ISOAL_STATUS_OK);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
seg_hdr[0].sc = 0;
seg_hdr[0].cmplt = 0;
seg_hdr[0].timeoffset = ref_point - sdu_timestamp;
seg_hdr[0].len = PDU_ISO_SEG_TIMEOFFSET_SIZE;
pdu_hdr_loc = 0;
pdu_write_loc = PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE;
sdu_read_loc = 0;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_fragments = 1;
ZASSERT_PDU_WRITE_TEST(history[0],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[0],
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE));
ZASSERT_PDU_WRITE_TEST(history[1],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[1] = seg_hdr[0];
seg_hdr[1].cmplt = 1;
seg_hdr[1].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[2],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[1],
PDU_ISO_SEG_HDR_SIZE);
ZASSERT_PDU_EMIT_TEST(history[0],
&tx_pdu_meta_buf.node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
}
/**
* Test Suite : TX framed SDU segmentation
*
* Tests segmentation of a single SDU contained in a single fragment
* into three PDUs where Max PDU is less than the PDU buffer size
*/
ZTEST(test_tx_framed, test_tx_framed_1_sdu_1_frag_3_pdu)
{
uint8_t testdata[100 - ((3 * PDU_ISO_SEG_HDR_SIZE) + PDU_ISO_SEG_TIMEOFFSET_SIZE)];
struct tx_pdu_meta_buffer tx_pdu_meta_buf;
struct tx_sdu_frag_buffer tx_sdu_frag_buf;
struct isoal_pdu_buffer pdu_buffer;
isoal_source_handle_t source_hdl;
struct pdu_iso_sdu_sh seg_hdr[2 * 3];
isoal_sdu_len_t sdu_total_size;
isoal_pdu_len_t pdu_write_size;
uint32_t stream_sync_delay;
uint64_t sdu_packet_number;
uint32_t group_sync_delay;
uint8_t iso_interval_int;
uint64_t payload_number;
uint32_t sdu_timestamp;
uint16_t testdata_indx;
uint16_t testdata_size;
uint16_t pdu_write_loc;
uint16_t sdu_read_loc;
uint64_t event_number;
uint32_t sdu_interval;
uint8_t sdu_fragments;
uint16_t pdu_hdr_loc;
uint32_t ref_point;
isoal_status_t err;
uint8_t max_octets;
uint8_t role;
uint8_t BN;
uint8_t FT;
/* Settings */
role = BT_CONN_ROLE_PERIPHERAL;
iso_interval_int = 1;
sdu_interval = CONN_INT_UNIT_US + 50;
max_octets = TEST_TX_PDU_PAYLOAD_MAX - 5;
BN = 3;
FT = 1;
stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;
/* SDU Frag 1 --------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
init_test_data_buffer(testdata,
100 - ((3 * PDU_ISO_SEG_HDR_SIZE) + PDU_ISO_SEG_TIMEOFFSET_SIZE));
(void)memset(seg_hdr, 0, sizeof(seg_hdr));
pdu_buffer.handle = (void *)&tx_pdu_meta_buf.node_tx;
pdu_buffer.pdu = (struct pdu_iso *)tx_pdu_meta_buf.node_tx.pdu;
pdu_buffer.size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_packet_number = 2000;
event_number = 2000;
sdu_timestamp = 9249;
ref_point = sdu_timestamp + (iso_interval_int * CONN_INT_UNIT_US) - 50;
sdu_total_size = 100 - ((3 * PDU_ISO_SEG_HDR_SIZE) + PDU_ISO_SEG_TIMEOFFSET_SIZE);
testdata_indx = 0;
testdata_size = 100 - ((3 * PDU_ISO_SEG_HDR_SIZE) + PDU_ISO_SEG_TIMEOFFSET_SIZE);
payload_number = event_number * BN;
source_hdl = basic_tx_test_setup(0xADAD, /* Handle */
role, /* Role */
true, /* Framed */
BN, /* BN */
FT, /* FT */
max_octets, /* max_octets */
sdu_interval, /* SDU Interval */
iso_interval_int, /* ISO Interval */
stream_sync_delay, /* Stream Sync Delay */
group_sync_delay); /* Group Sync Delay */
isoal_test_create_sdu_fagment(BT_ISO_SINGLE,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
PDU_ALLOC_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_WRITE_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_EMIT_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_RELEASE_TEST_RETURNS(ISOAL_STATUS_OK);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
seg_hdr[0].sc = 0;
seg_hdr[0].cmplt = 0;
seg_hdr[0].timeoffset = ref_point - sdu_timestamp;
seg_hdr[0].len = PDU_ISO_SEG_TIMEOFFSET_SIZE;
pdu_hdr_loc = 0;
pdu_write_loc = PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE;
sdu_read_loc = 0;
pdu_write_size = max_octets;
sdu_fragments = 0;
ZASSERT_PDU_WRITE_TEST(history[0],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[0],
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE));
ZASSERT_PDU_WRITE_TEST(history[1],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[1] = seg_hdr[0];
seg_hdr[1].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[2],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[1],
PDU_ISO_SEG_HDR_SIZE);
ZASSERT_PDU_EMIT_TEST(history[0],
&tx_pdu_meta_buf.node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU 2 */
payload_number++;
seg_hdr[2].sc = 1;
seg_hdr[2].cmplt = 0;
seg_hdr[2].timeoffset = 0;
seg_hdr[2].len = 0;
pdu_hdr_loc = 0;
sdu_read_loc += (pdu_write_size - pdu_write_loc);
pdu_write_loc = PDU_ISO_SEG_HDR_SIZE;
pdu_write_size = max_octets;
sdu_fragments = 0;
ZASSERT_PDU_WRITE_TEST(history[3],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[2],
PDU_ISO_SEG_HDR_SIZE);
ZASSERT_PDU_WRITE_TEST(history[4],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[3] = seg_hdr[2];
seg_hdr[3].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[5],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[3],
PDU_ISO_SEG_HDR_SIZE);
ZASSERT_PDU_EMIT_TEST(history[1],
&tx_pdu_meta_buf.node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU 3 */
payload_number++;
seg_hdr[4].sc = 1;
seg_hdr[4].cmplt = 0;
seg_hdr[4].timeoffset = 0;
seg_hdr[4].len = 0;
pdu_hdr_loc = 0;
sdu_read_loc += (pdu_write_size - pdu_write_loc);
pdu_write_loc = PDU_ISO_SEG_HDR_SIZE;
pdu_write_size =
sdu_total_size -
((2 * max_octets) - (2 * PDU_ISO_SEG_HDR_SIZE) - PDU_ISO_SEG_TIMEOFFSET_SIZE) +
pdu_write_loc;
sdu_fragments++;
ZASSERT_PDU_WRITE_TEST(history[6],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[4],
PDU_ISO_SEG_HDR_SIZE);
ZASSERT_PDU_WRITE_TEST(history[7],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[5] = seg_hdr[4];
seg_hdr[5].cmplt = 1;
seg_hdr[5].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[8],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[5],
PDU_ISO_SEG_HDR_SIZE);
ZASSERT_PDU_EMIT_TEST(history[2],
&tx_pdu_meta_buf.node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
}
/**
* Test Suite : TX framed SDU segmentation
*
* Tests segmentation of a single SDU contained in three fragments
* into a single PDU where Max PDU is greater than the PDU buffer size
*/
ZTEST(test_tx_framed, test_tx_framed_1_sdu_3_frag_1_pdu)
{
uint8_t testdata[TEST_TX_PDU_PAYLOAD_MAX -
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE)];
struct tx_pdu_meta_buffer tx_pdu_meta_buf;
struct tx_sdu_frag_buffer tx_sdu_frag_buf;
struct isoal_pdu_buffer pdu_buffer;
isoal_source_handle_t source_hdl;
struct pdu_iso_sdu_sh seg_hdr[2];
isoal_sdu_len_t sdu_total_size;
isoal_pdu_len_t pdu_write_size;
uint32_t stream_sync_delay;
uint64_t sdu_packet_number;
uint32_t group_sync_delay;
uint8_t iso_interval_int;
uint64_t payload_number;
uint32_t sdu_timestamp;
uint16_t testdata_indx;
uint16_t testdata_size;
uint16_t pdu_write_loc;
uint16_t sdu_read_loc;
uint64_t event_number;
uint32_t sdu_interval;
uint8_t sdu_fragments;
uint16_t pdu_hdr_loc;
uint32_t ref_point;
isoal_status_t err;
uint8_t max_octets;
uint8_t role;
uint8_t BN;
uint8_t FT;
/* Settings */
role = BT_CONN_ROLE_PERIPHERAL;
iso_interval_int = 1;
sdu_interval = CONN_INT_UNIT_US + 50;
max_octets = TEST_TX_PDU_PAYLOAD_MAX + 5;
BN = 1;
FT = 1;
stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;
/* SDU Frag 1 --------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
init_test_data_buffer(testdata,
TEST_TX_PDU_PAYLOAD_MAX -
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE));
(void)memset(seg_hdr, 0, sizeof(seg_hdr));
pdu_buffer.handle = (void *)&tx_pdu_meta_buf.node_tx;
pdu_buffer.pdu = (struct pdu_iso *)tx_pdu_meta_buf.node_tx.pdu;
pdu_buffer.size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_packet_number = 2000;
event_number = 2000;
sdu_timestamp = 9249;
ref_point = sdu_timestamp + (iso_interval_int * CONN_INT_UNIT_US) - 50;
sdu_total_size =
TEST_TX_PDU_PAYLOAD_MAX - (PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE);
testdata_indx = 0;
testdata_size =
(TEST_TX_PDU_PAYLOAD_MAX - (PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE)) /
3;
payload_number = event_number * BN;
sdu_fragments = 0;
source_hdl = basic_tx_test_setup(0xADAD, /* Handle */
role, /* Role */
true, /* Framed */
BN, /* BN */
FT, /* FT */
max_octets, /* max_octets */
sdu_interval, /* SDU Interval */
iso_interval_int, /* ISO Interval */
stream_sync_delay, /* Stream Sync Delay */
group_sync_delay); /* Group Sync Delay */
isoal_test_create_sdu_fagment(BT_ISO_START,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
PDU_ALLOC_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_WRITE_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_EMIT_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_RELEASE_TEST_RETURNS(ISOAL_STATUS_OK);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
seg_hdr[0].sc = 0;
seg_hdr[0].cmplt = 0;
seg_hdr[0].timeoffset = ref_point - sdu_timestamp;
seg_hdr[0].len = PDU_ISO_SEG_TIMEOFFSET_SIZE;
pdu_hdr_loc = 0;
pdu_write_loc = PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE;
sdu_read_loc = 0;
pdu_write_size =
((TEST_TX_PDU_PAYLOAD_MAX - (PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE)) /
3) +
pdu_write_loc;
sdu_fragments++;
ZASSERT_PDU_WRITE_TEST(history[0],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[0],
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE));
ZASSERT_PDU_WRITE_TEST(history[1],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[1] = seg_hdr[0];
seg_hdr[1].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[2],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[1],
PDU_ISO_SEG_HDR_SIZE);
/* PDU should not be emitted */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(0);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* SDU Frag 2 --------------------------------------------------------*/
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
sdu_timestamp += 10;
testdata_indx += testdata_size;
testdata_size +=
(TEST_TX_PDU_PAYLOAD_MAX - (PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE)) /
3;
isoal_test_create_sdu_fagment(BT_ISO_CONT,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
pdu_write_loc = pdu_write_size;
pdu_write_size +=
((TEST_TX_PDU_PAYLOAD_MAX - (PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE)) /
3);
sdu_read_loc = testdata_indx;
sdu_fragments++;
/* PDU should not be allocated */
ZASSERT_PDU_ALLOC_TEST_CALL_COUNT(1);
ZASSERT_PDU_WRITE_TEST(history[3],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[1].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[4],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[1],
PDU_ISO_SEG_HDR_SIZE);
/* PDU should not be emitted */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(0);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* SDU Frag 3 --------------------------------------------------------*/
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
sdu_timestamp += 10;
testdata_indx = testdata_size;
testdata_size =
TEST_TX_PDU_PAYLOAD_MAX - (PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE);
isoal_test_create_sdu_fagment(BT_ISO_END,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
pdu_write_loc = pdu_write_size;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_read_loc = testdata_indx;
sdu_fragments++;
/* PDU should not be allocated */
ZASSERT_PDU_ALLOC_TEST_CALL_COUNT(1);
ZASSERT_PDU_WRITE_TEST(history[5],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[1].cmplt = 1;
seg_hdr[1].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[6],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[1],
PDU_ISO_SEG_HDR_SIZE);
ZASSERT_PDU_EMIT_TEST(history[0],
&tx_pdu_meta_buf.node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
}
/**
* Test Suite : TX framed SDU segmentation
*
* Tests segmentation of a single SDU contained in three fragments
* into two PDUs where Max PDU is greater than the PDU buffer size
*/
ZTEST(test_tx_framed, test_tx_framed_1_sdu_3_frag_2_pdu)
{
uint8_t testdata[(TEST_TX_PDU_PAYLOAD_MAX * 2) -
((PDU_ISO_SEG_HDR_SIZE * 2) + PDU_ISO_SEG_TIMEOFFSET_SIZE)];
struct tx_pdu_meta_buffer tx_pdu_meta_buf[2];
struct tx_sdu_frag_buffer tx_sdu_frag_buf;
struct isoal_pdu_buffer pdu_buffer[2];
struct pdu_iso_sdu_sh seg_hdr[2 * 2];
isoal_source_handle_t source_hdl;
isoal_sdu_len_t sdu_total_size;
isoal_pdu_len_t pdu_write_size;
uint32_t stream_sync_delay;
uint64_t sdu_packet_number;
uint32_t group_sync_delay;
uint8_t iso_interval_int;
uint64_t payload_number;
uint32_t sdu_timestamp;
uint16_t testdata_indx;
uint16_t testdata_size;
uint16_t pdu_write_loc;
uint16_t sdu_read_loc;
uint64_t event_number;
uint32_t sdu_interval;
uint8_t sdu_fragments;
uint16_t pdu_hdr_loc;
uint32_t ref_point;
isoal_status_t err;
uint8_t max_octets;
uint8_t role;
uint8_t BN;
uint8_t FT;
/* Settings */
role = BT_CONN_ROLE_PERIPHERAL;
iso_interval_int = 1;
sdu_interval = CONN_INT_UNIT_US + 50;
max_octets = TEST_TX_PDU_PAYLOAD_MAX + 5;
BN = 2;
FT = 1;
stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;
/* SDU Frag 1 --------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[0]);
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[1]);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
init_test_data_buffer(testdata,
(TEST_TX_PDU_PAYLOAD_MAX * 2) -
((PDU_ISO_SEG_HDR_SIZE * 2) + PDU_ISO_SEG_TIMEOFFSET_SIZE));
(void)memset(seg_hdr, 0, sizeof(seg_hdr));
pdu_buffer[0].handle = (void *)&tx_pdu_meta_buf[0].node_tx;
pdu_buffer[0].pdu = (struct pdu_iso *)tx_pdu_meta_buf[0].node_tx.pdu;
pdu_buffer[0].size = TEST_TX_PDU_PAYLOAD_MAX;
pdu_buffer[1].handle = (void *)&tx_pdu_meta_buf[1].node_tx;
pdu_buffer[1].pdu = (struct pdu_iso *)tx_pdu_meta_buf[1].node_tx.pdu;
pdu_buffer[1].size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_packet_number = 2000;
event_number = 2000;
sdu_timestamp = 9249;
ref_point = sdu_timestamp + (iso_interval_int * CONN_INT_UNIT_US) - 50;
sdu_total_size = (TEST_TX_PDU_PAYLOAD_MAX * 2) -
((PDU_ISO_SEG_HDR_SIZE * 2) + PDU_ISO_SEG_TIMEOFFSET_SIZE);
testdata_indx = 0;
testdata_size = ((TEST_TX_PDU_PAYLOAD_MAX * 2) -
((PDU_ISO_SEG_HDR_SIZE * 2) + PDU_ISO_SEG_TIMEOFFSET_SIZE)) /
3;
sdu_fragments = 0;
source_hdl = basic_tx_test_setup(0xADAD, /* Handle */
role, /* Role */
true, /* Framed */
BN, /* BN */
FT, /* FT */
max_octets, /* max_octets */
sdu_interval, /* SDU Interval */
iso_interval_int, /* ISO Interval */
stream_sync_delay, /* Stream Sync Delay */
group_sync_delay); /* Group Sync Delay */
isoal_test_create_sdu_fagment(BT_ISO_START,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[0]);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[1]);
PDU_ALLOC_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_WRITE_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_EMIT_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_RELEASE_TEST_RETURNS(ISOAL_STATUS_OK);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
payload_number = event_number * BN;
seg_hdr[0].sc = 0;
seg_hdr[0].cmplt = 0;
seg_hdr[0].timeoffset = ref_point - sdu_timestamp;
seg_hdr[0].len = PDU_ISO_SEG_TIMEOFFSET_SIZE;
pdu_hdr_loc = 0;
pdu_write_loc = PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE;
sdu_read_loc = 0;
pdu_write_size = (((TEST_TX_PDU_PAYLOAD_MAX * 2) -
((PDU_ISO_SEG_HDR_SIZE * 2) + PDU_ISO_SEG_TIMEOFFSET_SIZE)) /
3) +
pdu_write_loc;
sdu_fragments++;
ZASSERT_PDU_WRITE_TEST(history[0],
pdu_buffer[0],
pdu_hdr_loc,
&seg_hdr[0],
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE));
ZASSERT_PDU_WRITE_TEST(history[1],
pdu_buffer[0],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[1] = seg_hdr[0];
seg_hdr[1].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[2],
pdu_buffer[0],
pdu_hdr_loc,
&seg_hdr[1],
PDU_ISO_SEG_HDR_SIZE);
/* PDU should not be emitted */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(0);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* SDU Frag 2 --------------------------------------------------------*/
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
sdu_timestamp += 10;
testdata_indx += testdata_size;
testdata_size += ((TEST_TX_PDU_PAYLOAD_MAX * 2) -
((PDU_ISO_SEG_HDR_SIZE * 2) + PDU_ISO_SEG_TIMEOFFSET_SIZE)) /
3;
isoal_test_create_sdu_fagment(BT_ISO_CONT,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
pdu_write_loc = pdu_write_size;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_read_loc = testdata_indx;
/* PDU should not be allocated */
ZASSERT_PDU_WRITE_TEST(history[3],
pdu_buffer[0],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[1].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[4],
pdu_buffer[0],
pdu_hdr_loc,
&seg_hdr[1],
PDU_ISO_SEG_HDR_SIZE);
ZASSERT_PDU_EMIT_TEST(history[0],
&tx_pdu_meta_buf[0].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU 2 */
payload_number++;
seg_hdr[2].sc = 1;
seg_hdr[2].cmplt = 0;
seg_hdr[2].timeoffset = 0;
seg_hdr[2].len = 0;
sdu_read_loc = (pdu_write_size - pdu_write_loc) + testdata_indx;
pdu_write_size = testdata_size - testdata_indx - (pdu_write_size - pdu_write_loc) +
PDU_ISO_SEG_HDR_SIZE;
pdu_hdr_loc = 0;
pdu_write_loc = PDU_ISO_SEG_HDR_SIZE;
sdu_fragments = 1;
ZASSERT_PDU_WRITE_TEST(history[5],
pdu_buffer[1],
pdu_hdr_loc,
&seg_hdr[2],
PDU_ISO_SEG_HDR_SIZE);
ZASSERT_PDU_WRITE_TEST(history[6],
pdu_buffer[1],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[3] = seg_hdr[2];
seg_hdr[3].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[7],
pdu_buffer[1],
pdu_hdr_loc,
&seg_hdr[3],
PDU_ISO_SEG_HDR_SIZE);
/* PDU should not be emitted */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(1);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* SDU Frag 3 --------------------------------------------------------*/
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
sdu_timestamp += 10;
testdata_indx = testdata_size;
testdata_size = (TEST_TX_PDU_PAYLOAD_MAX * 2) -
((PDU_ISO_SEG_HDR_SIZE * 2) + PDU_ISO_SEG_TIMEOFFSET_SIZE);
isoal_test_create_sdu_fagment(BT_ISO_END,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 2 */
pdu_write_loc = pdu_write_size;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_read_loc = testdata_indx;
sdu_fragments++;
/* PDU should not be allocated */
ZASSERT_PDU_ALLOC_TEST_CALL_COUNT(2);
ZASSERT_PDU_WRITE_TEST(history[8],
pdu_buffer[1],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[3].cmplt = 1;
seg_hdr[3].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[9],
pdu_buffer[1],
pdu_hdr_loc,
&seg_hdr[3],
PDU_ISO_SEG_HDR_SIZE);
ZASSERT_PDU_EMIT_TEST(history[1],
&tx_pdu_meta_buf[1].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
}
/**
* Test Suite : TX framed SDU segmentation
*
* Tests segmentation of two SDUs containing three fragments each
* into two PDUs each where Max PDU is greater than the PDU buffer size
*/
ZTEST(test_tx_framed, test_tx_framed_2_sdu_3_frag_4_pdu)
{
uint8_t testdata[(TEST_TX_PDU_PAYLOAD_MAX * 2) -
((PDU_ISO_SEG_HDR_SIZE * 2) + PDU_ISO_SEG_TIMEOFFSET_SIZE)];
struct tx_pdu_meta_buffer tx_pdu_meta_buf[2];
struct tx_sdu_frag_buffer tx_sdu_frag_buf;
struct isoal_pdu_buffer pdu_buffer[2];
struct pdu_iso_sdu_sh seg_hdr[2 * 2];
isoal_source_handle_t source_hdl;
isoal_sdu_len_t sdu_total_size;
isoal_pdu_len_t pdu_write_size;
uint32_t stream_sync_delay;
uint64_t sdu_packet_number;
uint32_t group_sync_delay;
uint8_t iso_interval_int;
uint64_t payload_number;
uint32_t sdu_timestamp;
uint16_t testdata_indx;
uint16_t testdata_size;
uint16_t pdu_write_loc;
uint16_t sdu_read_loc;
uint64_t event_number;
uint32_t sdu_interval;
uint8_t sdu_fragments;
uint16_t pdu_hdr_loc;
uint32_t ref_point;
isoal_status_t err;
uint8_t max_octets;
uint8_t role;
uint8_t BN;
uint8_t FT;
/* Settings */
role = BT_CONN_ROLE_PERIPHERAL;
iso_interval_int = 2;
sdu_interval = CONN_INT_UNIT_US + 50;
max_octets = TEST_TX_PDU_PAYLOAD_MAX + 5;
BN = 4;
FT = 1;
stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;
/* SDU 1 Frag 1 ------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[0]);
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[1]);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
init_test_data_buffer(testdata,
(TEST_TX_PDU_PAYLOAD_MAX * 2) -
((PDU_ISO_SEG_HDR_SIZE * 2) + PDU_ISO_SEG_TIMEOFFSET_SIZE));
(void)memset(&seg_hdr, 0, sizeof(seg_hdr));
pdu_buffer[0].handle = (void *)&tx_pdu_meta_buf[0].node_tx;
pdu_buffer[0].pdu = (struct pdu_iso *)tx_pdu_meta_buf[0].node_tx.pdu;
pdu_buffer[0].size = TEST_TX_PDU_PAYLOAD_MAX;
pdu_buffer[1].handle = (void *)&tx_pdu_meta_buf[1].node_tx;
pdu_buffer[1].pdu = (struct pdu_iso *)tx_pdu_meta_buf[1].node_tx.pdu;
pdu_buffer[1].size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_packet_number = 2000;
event_number = 2000;
sdu_timestamp = 9249;
ref_point = 9249 + (iso_interval_int * CONN_INT_UNIT_US) - 50;
sdu_total_size = (TEST_TX_PDU_PAYLOAD_MAX * 2) -
((PDU_ISO_SEG_HDR_SIZE * 2) + PDU_ISO_SEG_TIMEOFFSET_SIZE);
testdata_indx = 0;
testdata_size = ((TEST_TX_PDU_PAYLOAD_MAX * 2) -
((PDU_ISO_SEG_HDR_SIZE * 2) + PDU_ISO_SEG_TIMEOFFSET_SIZE)) /
3;
sdu_fragments = 0;
source_hdl = basic_tx_test_setup(0xADAD, /* Handle */
role, /* Role */
true, /* Framed */
BN, /* BN */
FT, /* FT */
max_octets, /* max_octets */
sdu_interval, /* SDU Interval */
iso_interval_int, /* ISO Interval */
stream_sync_delay, /* Stream Sync Delay */
group_sync_delay); /* Group Sync Delay */
isoal_test_create_sdu_fagment(BT_ISO_START,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[0]);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[1]);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[0]);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[1]);
PDU_ALLOC_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_WRITE_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_EMIT_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_RELEASE_TEST_RETURNS(ISOAL_STATUS_OK);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
payload_number = event_number * BN;
seg_hdr[0].sc = 0;
seg_hdr[0].cmplt = 0;
seg_hdr[0].timeoffset = ref_point - sdu_timestamp;
seg_hdr[0].len = PDU_ISO_SEG_TIMEOFFSET_SIZE;
pdu_hdr_loc = 0;
pdu_write_loc = PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE;
sdu_read_loc = 0;
pdu_write_size = (((TEST_TX_PDU_PAYLOAD_MAX * 2) -
((PDU_ISO_SEG_HDR_SIZE * 2) + PDU_ISO_SEG_TIMEOFFSET_SIZE)) /
3) +
pdu_write_loc;
sdu_fragments++;
ZASSERT_PDU_WRITE_TEST(history[0],
pdu_buffer[0],
pdu_hdr_loc,
&seg_hdr[0],
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE));
ZASSERT_PDU_WRITE_TEST(history[1],
pdu_buffer[0],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[1] = seg_hdr[0];
seg_hdr[1].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[2],
pdu_buffer[0],
pdu_hdr_loc,
&seg_hdr[1],
PDU_ISO_SEG_HDR_SIZE);
/* PDU should not be emitted */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(0);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* SDU 1 Frag 2 ------------------------------------------------------*/
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
sdu_timestamp += 10;
testdata_indx += testdata_size;
testdata_size += ((TEST_TX_PDU_PAYLOAD_MAX * 2) -
((PDU_ISO_SEG_HDR_SIZE * 2) + PDU_ISO_SEG_TIMEOFFSET_SIZE)) /
3;
isoal_test_create_sdu_fagment(BT_ISO_CONT,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
pdu_write_loc = pdu_write_size;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_read_loc = testdata_indx;
ZASSERT_PDU_WRITE_TEST(history[3],
pdu_buffer[0],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
/* PDU should not be allocated */
seg_hdr[1].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[4],
pdu_buffer[0],
pdu_hdr_loc,
&seg_hdr[1],
PDU_ISO_SEG_HDR_SIZE);
ZASSERT_PDU_EMIT_TEST(history[0],
&tx_pdu_meta_buf[0].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU 2 */
payload_number++;
seg_hdr[2].sc = 1;
seg_hdr[2].cmplt = 0;
seg_hdr[2].timeoffset = 0;
seg_hdr[2].len = 0;
sdu_read_loc = (pdu_write_size - pdu_write_loc) + testdata_indx;
pdu_write_size = testdata_size - testdata_indx - (pdu_write_size - pdu_write_loc) +
PDU_ISO_SEG_HDR_SIZE;
pdu_hdr_loc = 0;
pdu_write_loc = PDU_ISO_SEG_HDR_SIZE;
sdu_fragments = 1;
ZASSERT_PDU_WRITE_TEST(history[5],
pdu_buffer[1],
pdu_hdr_loc,
&seg_hdr[2],
PDU_ISO_SEG_HDR_SIZE);
ZASSERT_PDU_WRITE_TEST(history[6],
pdu_buffer[1],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[3] = seg_hdr[2];
seg_hdr[3].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[7],
pdu_buffer[1],
pdu_hdr_loc,
&seg_hdr[3],
PDU_ISO_SEG_HDR_SIZE);
/* PDU should not be emitted */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(1);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* SDU 1 Frag 3 ------------------------------------------------------*/
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
sdu_timestamp += 10;
testdata_indx = testdata_size;
testdata_size = (TEST_TX_PDU_PAYLOAD_MAX * 2) -
((PDU_ISO_SEG_HDR_SIZE * 2) + PDU_ISO_SEG_TIMEOFFSET_SIZE);
isoal_test_create_sdu_fagment(BT_ISO_END,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 2 */
pdu_write_loc = pdu_write_size;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_read_loc = testdata_indx;
sdu_fragments++;
/* PDU should not be allocated */
ZASSERT_PDU_WRITE_TEST(history[8],
pdu_buffer[1],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[3].cmplt = 1;
seg_hdr[3].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[9],
pdu_buffer[1],
pdu_hdr_loc,
&seg_hdr[3],
PDU_ISO_SEG_HDR_SIZE);
ZASSERT_PDU_EMIT_TEST(history[1],
&tx_pdu_meta_buf[1].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* SDU 2 Frag 1 ------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[0]);
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[1]);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
sdu_packet_number++;
event_number = 2000;
sdu_timestamp = 9249 + sdu_interval;
ref_point = 9249 + (iso_interval_int * CONN_INT_UNIT_US) - 50;
sdu_total_size = (TEST_TX_PDU_PAYLOAD_MAX * 2) -
((PDU_ISO_SEG_HDR_SIZE * 2) + PDU_ISO_SEG_TIMEOFFSET_SIZE);
testdata_indx = 0;
testdata_size = ((TEST_TX_PDU_PAYLOAD_MAX * 2) -
((PDU_ISO_SEG_HDR_SIZE * 2) + PDU_ISO_SEG_TIMEOFFSET_SIZE)) /
3;
sdu_fragments = 0;
isoal_test_create_sdu_fagment(BT_ISO_START,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 3 */
payload_number++;
seg_hdr[0].sc = 0;
seg_hdr[0].cmplt = 0;
seg_hdr[0].timeoffset = ref_point - sdu_timestamp;
seg_hdr[0].len = PDU_ISO_SEG_TIMEOFFSET_SIZE;
pdu_hdr_loc = 0;
pdu_write_loc = PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE;
sdu_read_loc = 0;
pdu_write_size = (((TEST_TX_PDU_PAYLOAD_MAX * 2) -
((PDU_ISO_SEG_HDR_SIZE * 2) + PDU_ISO_SEG_TIMEOFFSET_SIZE)) /
3) +
pdu_write_loc;
sdu_fragments++;
ZASSERT_PDU_WRITE_TEST(history[10],
pdu_buffer[0],
pdu_hdr_loc,
&seg_hdr[0],
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE));
ZASSERT_PDU_WRITE_TEST(history[11],
pdu_buffer[0],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[1] = seg_hdr[0];
seg_hdr[1].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[12],
pdu_buffer[0],
pdu_hdr_loc,
&seg_hdr[1],
PDU_ISO_SEG_HDR_SIZE);
/* PDU should not be emitted */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(2);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* SDU 2 Frag 2 ------------------------------------------------------*/
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
sdu_timestamp += 10;
testdata_indx += testdata_size;
testdata_size += ((TEST_TX_PDU_PAYLOAD_MAX * 2) -
((PDU_ISO_SEG_HDR_SIZE * 2) + PDU_ISO_SEG_TIMEOFFSET_SIZE)) /
3;
isoal_test_create_sdu_fagment(BT_ISO_CONT,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 3 */
pdu_write_loc = pdu_write_size;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_read_loc = testdata_indx;
/* PDU should not be allocated */
ZASSERT_PDU_WRITE_TEST(history[13],
pdu_buffer[0],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[1].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[14],
pdu_buffer[0],
pdu_hdr_loc,
&seg_hdr[1],
PDU_ISO_SEG_HDR_SIZE);
ZASSERT_PDU_EMIT_TEST(history[2],
&tx_pdu_meta_buf[0].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU 4 */
payload_number++;
seg_hdr[2].sc = 1;
seg_hdr[2].cmplt = 0;
seg_hdr[2].timeoffset = 0;
seg_hdr[2].len = 0;
sdu_read_loc = (pdu_write_size - pdu_write_loc) + testdata_indx;
pdu_write_size = testdata_size - testdata_indx - (pdu_write_size - pdu_write_loc) +
PDU_ISO_SEG_HDR_SIZE;
pdu_hdr_loc = 0;
pdu_write_loc = PDU_ISO_SEG_HDR_SIZE;
sdu_fragments = 1;
ZASSERT_PDU_WRITE_TEST(history[15],
pdu_buffer[1],
pdu_hdr_loc,
&seg_hdr[2],
PDU_ISO_SEG_HDR_SIZE);
ZASSERT_PDU_WRITE_TEST(history[16],
pdu_buffer[1],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[3] = seg_hdr[2];
seg_hdr[3].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[17],
pdu_buffer[1],
pdu_hdr_loc,
&seg_hdr[3],
PDU_ISO_SEG_HDR_SIZE);
/* PDU should not be emitted */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(3);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* SDU 2 Frag 3 ------------------------------------------------------*/
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
sdu_timestamp += 10;
testdata_indx = testdata_size;
testdata_size = (TEST_TX_PDU_PAYLOAD_MAX * 2) -
((PDU_ISO_SEG_HDR_SIZE * 2) + PDU_ISO_SEG_TIMEOFFSET_SIZE);
isoal_test_create_sdu_fagment(BT_ISO_END,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 4 */
pdu_write_loc = pdu_write_size;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_read_loc = testdata_indx;
sdu_fragments++;
/* PDU should not be allocated */
ZASSERT_PDU_ALLOC_TEST_CALL_COUNT(4);
ZASSERT_PDU_WRITE_TEST(history[18],
pdu_buffer[1],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[3].cmplt = 1;
seg_hdr[3].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[19],
pdu_buffer[1],
pdu_hdr_loc,
&seg_hdr[3],
PDU_ISO_SEG_HDR_SIZE);
ZASSERT_PDU_EMIT_TEST(history[3],
&tx_pdu_meta_buf[1].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
}
/**
* Test Suite : TX framed SDU segmentation
*
* Tests segmentation of two SDUs containing three fragments each
* into two PDUs each where Max PDU is greater than the PDU buffer size
* with padding
*/
ZTEST(test_tx_framed, test_tx_framed_2_sdu_3_frag_4_pdu_padding)
{
const uint8_t number_of_pdus = 2;
const uint8_t number_of_sdu_frags = 3;
const uint8_t testdata_size_max = MAX_FRAMED_PDU_PAYLOAD(number_of_pdus);
const uint8_t number_of_seg_hdr_buf = EXPECTED_SEG_HDR_WRITES * number_of_pdus;
struct tx_pdu_meta_buffer tx_pdu_meta_buf[number_of_pdus];
struct pdu_iso_sdu_sh seg_hdr[number_of_seg_hdr_buf];
struct isoal_pdu_buffer pdu_buffer[number_of_pdus];
struct tx_sdu_frag_buffer tx_sdu_frag_buf;
uint8_t testdata[testdata_size_max];
isoal_source_handle_t source_hdl;
isoal_sdu_len_t sdu_total_size;
isoal_pdu_len_t pdu_write_size;
uint32_t stream_sync_delay;
uint64_t sdu_packet_number;
uint32_t group_sync_delay;
uint8_t iso_interval_int;
uint64_t payload_number;
uint32_t sdu_timestamp;
uint16_t testdata_indx;
uint16_t testdata_size;
uint16_t pdu_write_loc;
uint16_t sdu_read_loc;
uint64_t event_number;
uint32_t sdu_interval;
uint8_t sdu_fragments;
uint16_t pdu_hdr_loc;
uint32_t ref_point;
isoal_status_t err;
uint8_t max_octets;
uint8_t role;
uint8_t BN;
uint8_t FT;
/* Settings */
role = BT_CONN_ROLE_PERIPHERAL;
iso_interval_int = 2;
sdu_interval = CONN_INT_UNIT_US + 50;
max_octets = TEST_TX_PDU_PAYLOAD_MAX + 5;
BN = 6;
FT = 1;
stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;
/* SDU 1 Frag 1 ------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[0]);
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[1]);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
init_test_data_buffer(testdata, testdata_size_max);
(void)memset(&seg_hdr, 0, sizeof(seg_hdr));
pdu_buffer[0].handle = (void *)&tx_pdu_meta_buf[0].node_tx;
pdu_buffer[0].pdu = (struct pdu_iso *)tx_pdu_meta_buf[0].node_tx.pdu;
pdu_buffer[0].size = TEST_TX_PDU_PAYLOAD_MAX;
pdu_buffer[1].handle = (void *)&tx_pdu_meta_buf[1].node_tx;
pdu_buffer[1].pdu = (struct pdu_iso *)tx_pdu_meta_buf[1].node_tx.pdu;
pdu_buffer[1].size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_packet_number = 2000;
event_number = 2000;
sdu_timestamp = 9249;
ref_point = 9249 + (iso_interval_int * CONN_INT_UNIT_US) - 50;
sdu_total_size = testdata_size_max;
testdata_indx = 0;
testdata_size = testdata_size_max / number_of_sdu_frags;
sdu_fragments = 0;
source_hdl = basic_tx_test_setup(0xADAD, /* Handle */
role, /* Role */
true, /* Framed */
BN, /* BN */
FT, /* FT */
max_octets, /* max_octets */
sdu_interval, /* SDU Interval */
iso_interval_int, /* ISO Interval */
stream_sync_delay, /* Stream Sync Delay */
group_sync_delay); /* Group Sync Delay */
isoal_test_create_sdu_fagment(BT_ISO_START,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[0]);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[1]);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[0]);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[1]);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[0]);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[1]);
PDU_ALLOC_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_WRITE_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_EMIT_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_RELEASE_TEST_RETURNS(ISOAL_STATUS_OK);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
payload_number = event_number * BN;
seg_hdr[0].sc = 0;
seg_hdr[0].cmplt = 0;
seg_hdr[0].timeoffset = ref_point - sdu_timestamp;
seg_hdr[0].len = PDU_ISO_SEG_TIMEOFFSET_SIZE;
pdu_hdr_loc = 0;
pdu_write_loc = PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE;
sdu_read_loc = 0;
pdu_write_size = (testdata_size_max / number_of_sdu_frags) + pdu_write_loc;
sdu_fragments++;
ZASSERT_PDU_WRITE_TEST(history[0],
pdu_buffer[0],
pdu_hdr_loc,
&seg_hdr[0],
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE));
ZASSERT_PDU_WRITE_TEST(history[1],
pdu_buffer[0],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[1] = seg_hdr[0];
seg_hdr[1].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[2],
pdu_buffer[0],
pdu_hdr_loc,
&seg_hdr[1],
PDU_ISO_SEG_HDR_SIZE);
/* PDU should not be emitted */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(0);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* SDU 1 Frag 2 ------------------------------------------------------*/
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
sdu_timestamp += 10;
testdata_indx += testdata_size;
testdata_size += testdata_size_max / number_of_sdu_frags;
isoal_test_create_sdu_fagment(BT_ISO_CONT,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
pdu_write_loc = pdu_write_size;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_read_loc = testdata_indx;
ZASSERT_PDU_WRITE_TEST(history[3],
pdu_buffer[0],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
/* PDU should not be allocated */
seg_hdr[1].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[4],
pdu_buffer[0],
pdu_hdr_loc,
&seg_hdr[1],
PDU_ISO_SEG_HDR_SIZE);
ZASSERT_PDU_EMIT_TEST(history[0],
&tx_pdu_meta_buf[0].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU 2 */
payload_number++;
seg_hdr[2].sc = 1;
seg_hdr[2].cmplt = 0;
seg_hdr[2].timeoffset = 0;
seg_hdr[2].len = 0;
sdu_read_loc = (pdu_write_size - pdu_write_loc) + testdata_indx;
pdu_write_size = testdata_size - testdata_indx - (pdu_write_size - pdu_write_loc) +
PDU_ISO_SEG_HDR_SIZE;
pdu_hdr_loc = 0;
pdu_write_loc = PDU_ISO_SEG_HDR_SIZE;
sdu_fragments = 1;
ZASSERT_PDU_WRITE_TEST(history[5],
pdu_buffer[1],
pdu_hdr_loc,
&seg_hdr[2],
PDU_ISO_SEG_HDR_SIZE);
ZASSERT_PDU_WRITE_TEST(history[6],
pdu_buffer[1],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[3] = seg_hdr[2];
seg_hdr[3].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[7],
pdu_buffer[1],
pdu_hdr_loc,
&seg_hdr[3],
PDU_ISO_SEG_HDR_SIZE);
/* PDU should not be emitted */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(1);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* SDU 1 Frag 3 ------------------------------------------------------*/
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
sdu_timestamp += 10;
testdata_indx = testdata_size;
testdata_size = testdata_size_max;
isoal_test_create_sdu_fagment(BT_ISO_END,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 2 */
pdu_write_loc = pdu_write_size;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_read_loc = testdata_indx;
sdu_fragments++;
/* PDU should not be allocated */
ZASSERT_PDU_WRITE_TEST(history[8],
pdu_buffer[1],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[3].cmplt = 1;
seg_hdr[3].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[9],
pdu_buffer[1],
pdu_hdr_loc,
&seg_hdr[3],
PDU_ISO_SEG_HDR_SIZE);
ZASSERT_PDU_EMIT_TEST(history[1],
&tx_pdu_meta_buf[1].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* SDU 2 Frag 1 ------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[0]);
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[1]);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
sdu_packet_number++;
event_number = 2000;
sdu_timestamp = 9249 + sdu_interval;
ref_point = 9249 + (iso_interval_int * CONN_INT_UNIT_US) - 50;
sdu_total_size = testdata_size_max;
testdata_indx = 0;
testdata_size = testdata_size_max / number_of_sdu_frags;
sdu_fragments = 0;
isoal_test_create_sdu_fagment(BT_ISO_START,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 3 */
payload_number++;
seg_hdr[0].sc = 0;
seg_hdr[0].cmplt = 0;
seg_hdr[0].timeoffset = ref_point - sdu_timestamp;
seg_hdr[0].len = PDU_ISO_SEG_TIMEOFFSET_SIZE;
pdu_hdr_loc = 0;
pdu_write_loc = PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE;
sdu_read_loc = 0;
pdu_write_size = (testdata_size_max / number_of_sdu_frags) + pdu_write_loc;
sdu_fragments++;
ZASSERT_PDU_WRITE_TEST(history[10],
pdu_buffer[0],
pdu_hdr_loc,
&seg_hdr[0],
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE));
ZASSERT_PDU_WRITE_TEST(history[11],
pdu_buffer[0],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[1] = seg_hdr[0];
seg_hdr[1].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[12],
pdu_buffer[0],
pdu_hdr_loc,
&seg_hdr[1],
PDU_ISO_SEG_HDR_SIZE);
/* PDU should not be emitted */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(2);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* SDU 2 Frag 2 ------------------------------------------------------*/
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
sdu_timestamp += 10;
testdata_indx += testdata_size;
testdata_size += testdata_size_max / number_of_sdu_frags;
isoal_test_create_sdu_fagment(BT_ISO_CONT,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 3 */
pdu_write_loc = pdu_write_size;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_read_loc = testdata_indx;
/* PDU should not be allocated */
ZASSERT_PDU_WRITE_TEST(history[13],
pdu_buffer[0],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[1].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[14],
pdu_buffer[0],
pdu_hdr_loc,
&seg_hdr[1],
PDU_ISO_SEG_HDR_SIZE);
ZASSERT_PDU_EMIT_TEST(history[2],
&tx_pdu_meta_buf[0].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU 4 */
payload_number++;
seg_hdr[2].sc = 1;
seg_hdr[2].cmplt = 0;
seg_hdr[2].timeoffset = 0;
seg_hdr[2].len = 0;
sdu_read_loc = (pdu_write_size - pdu_write_loc) + testdata_indx;
pdu_write_size = testdata_size - testdata_indx - (pdu_write_size - pdu_write_loc) +
PDU_ISO_SEG_HDR_SIZE;
pdu_hdr_loc = 0;
pdu_write_loc = PDU_ISO_SEG_HDR_SIZE;
sdu_fragments = 1;
ZASSERT_PDU_WRITE_TEST(history[15],
pdu_buffer[1],
pdu_hdr_loc,
&seg_hdr[2],
PDU_ISO_SEG_HDR_SIZE);
ZASSERT_PDU_WRITE_TEST(history[16],
pdu_buffer[1],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[3] = seg_hdr[2];
seg_hdr[3].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[17],
pdu_buffer[1],
pdu_hdr_loc,
&seg_hdr[3],
PDU_ISO_SEG_HDR_SIZE);
/* PDU should not be emitted */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(3);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* SDU 2 Frag 3 ------------------------------------------------------*/
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
sdu_timestamp += 10;
testdata_indx = testdata_size;
testdata_size = testdata_size_max;
isoal_test_create_sdu_fagment(BT_ISO_END,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 4 */
pdu_write_loc = pdu_write_size;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_read_loc = testdata_indx;
sdu_fragments++;
/* PDU should not be allocated */
ZASSERT_PDU_ALLOC_TEST_CALL_COUNT(4);
ZASSERT_PDU_WRITE_TEST(history[18],
pdu_buffer[1],
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[3].cmplt = 1;
seg_hdr[3].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[19],
pdu_buffer[1],
pdu_hdr_loc,
&seg_hdr[3],
PDU_ISO_SEG_HDR_SIZE);
ZASSERT_PDU_EMIT_TEST(history[3],
&tx_pdu_meta_buf[1].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* Send Event Timeout ----------------------------------------------- */
isoal_tx_event_prepare(source_hdl, event_number);
/* PDU 5 (Padding) */
payload_number++;
pdu_write_size = 0;
sdu_fragments = 0;
/* PDU should not be written to */
ZASSERT_PDU_WRITE_TEST_CALL_COUNT(20);
ZASSERT_PDU_EMIT_TEST(history[4],
&tx_pdu_meta_buf[0].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU 6 (Padding) */
payload_number++;
sdu_fragments = 0;
/* PDU should not be written to */
ZASSERT_PDU_WRITE_TEST_CALL_COUNT(20);
ZASSERT_PDU_EMIT_TEST(history[5],
&tx_pdu_meta_buf[1].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
}
/**
* Test Suite : TX framed SDU segmentation
*
* Tests segmentation of a single SDU contained in a single fragment
* into a single PDU where Max PDU is greater than the PDU buffer size,
* where the reference point has to be advanced due to the payload number not
* matching the actual target event
*/
ZTEST(test_tx_framed, test_tx_framed_2_sdu_1_frag_2_pdu_refPoint2)
{
uint8_t testdata[(TEST_TX_PDU_PAYLOAD_MAX -
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE)) *
2];
struct tx_pdu_meta_buffer tx_pdu_meta_buf;
struct tx_sdu_frag_buffer tx_sdu_frag_buf;
struct isoal_pdu_buffer pdu_buffer;
isoal_source_handle_t source_hdl;
struct pdu_iso_sdu_sh seg_hdr[2];
isoal_sdu_len_t sdu_total_size;
isoal_pdu_len_t pdu_write_size;
uint32_t stream_sync_delay;
uint64_t sdu_packet_number;
uint32_t group_sync_delay;
uint8_t iso_interval_int;
uint64_t payload_number;
uint32_t sdu_timestamp;
uint16_t testdata_indx;
uint16_t testdata_size;
uint16_t pdu_write_loc;
uint16_t sdu_read_loc;
uint64_t event_number;
uint32_t sdu_interval;
uint8_t sdu_fragments;
uint16_t pdu_hdr_loc;
uint32_t ref_point;
isoal_status_t err;
uint8_t max_octets;
uint8_t role;
uint8_t BN;
uint8_t FT;
/* Settings */
role = BT_CONN_ROLE_PERIPHERAL;
iso_interval_int = 1;
sdu_interval = CONN_INT_UNIT_US + 50;
max_octets = TEST_TX_PDU_PAYLOAD_MAX + 5;
BN = 1;
FT = 1;
stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;
/* SDU 1 Frag 1 ------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
init_test_data_buffer(
testdata,
(TEST_TX_PDU_PAYLOAD_MAX - (PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE)) *
2);
(void)memset(seg_hdr, 0, sizeof(seg_hdr));
pdu_buffer.handle = (void *)&tx_pdu_meta_buf.node_tx;
pdu_buffer.pdu = (struct pdu_iso *)tx_pdu_meta_buf.node_tx.pdu;
pdu_buffer.size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_packet_number = 2000;
event_number = 2000;
sdu_timestamp = 9249;
ref_point = sdu_timestamp + (iso_interval_int * CONN_INT_UNIT_US) - 50;
sdu_total_size =
TEST_TX_PDU_PAYLOAD_MAX - (PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE);
testdata_indx = 0;
testdata_size =
TEST_TX_PDU_PAYLOAD_MAX - (PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE);
payload_number = event_number * BN;
source_hdl = basic_tx_test_setup(0xADAD, /* Handle */
role, /* Role */
true, /* Framed */
BN, /* BN */
FT, /* FT */
max_octets, /* max_octets */
sdu_interval, /* SDU Interval */
iso_interval_int, /* ISO Interval */
stream_sync_delay, /* Stream Sync Delay */
group_sync_delay); /* Group Sync Delay */
isoal_test_create_sdu_fagment(BT_ISO_SINGLE,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
PDU_ALLOC_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_WRITE_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_EMIT_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_RELEASE_TEST_RETURNS(ISOAL_STATUS_OK);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
seg_hdr[0].sc = 0;
seg_hdr[0].cmplt = 0;
seg_hdr[0].timeoffset = ref_point - sdu_timestamp;
seg_hdr[0].len = PDU_ISO_SEG_TIMEOFFSET_SIZE;
pdu_hdr_loc = 0;
pdu_write_loc = PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE;
sdu_read_loc = 0;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_fragments = 1;
ZASSERT_PDU_WRITE_TEST(history[0],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[0],
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE));
ZASSERT_PDU_WRITE_TEST(history[1],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[1] = seg_hdr[0];
seg_hdr[1].cmplt = 1;
seg_hdr[1].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[2],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[1],
PDU_ISO_SEG_HDR_SIZE);
ZASSERT_PDU_EMIT_TEST(history[0],
&tx_pdu_meta_buf.node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* SDU 2 Frag 1 ------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
memset(seg_hdr, 0, sizeof(seg_hdr));
sdu_packet_number++;
sdu_timestamp = 9249 + sdu_interval;
sdu_total_size =
TEST_TX_PDU_PAYLOAD_MAX - (PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE);
testdata_indx = 0;
testdata_size =
TEST_TX_PDU_PAYLOAD_MAX - (PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE);
payload_number = event_number * BN;
isoal_test_create_sdu_fagment(BT_ISO_SINGLE,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 2 */
/* Advance the target event and the reference point to what it should be */
event_number++;
ref_point += iso_interval_int * CONN_INT_UNIT_US;
payload_number++;
seg_hdr[0].sc = 0;
seg_hdr[0].cmplt = 0;
seg_hdr[0].timeoffset = ref_point - sdu_timestamp;
seg_hdr[0].len = PDU_ISO_SEG_TIMEOFFSET_SIZE;
pdu_hdr_loc = 0;
pdu_write_loc = PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE;
sdu_read_loc = 0;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_fragments = 1;
ZASSERT_PDU_WRITE_TEST(history[3],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[0],
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE));
ZASSERT_PDU_WRITE_TEST(history[4],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[1] = seg_hdr[0];
seg_hdr[1].cmplt = 1;
seg_hdr[1].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[5],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[1],
PDU_ISO_SEG_HDR_SIZE);
ZASSERT_PDU_EMIT_TEST(history[1],
&tx_pdu_meta_buf.node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
}
/**
* Test Suite : TX framed SDU segmentation
*
* Tests segmentation of a single SDU contained in a single fragment
* into a single PDU where Max PDU is greater than the PDU buffer size,
* where the reference point has to be advanced as it is earlier than the
* time stamp
*/
ZTEST(test_tx_framed, test_tx_framed_1_sdu_1_frag_1_pdu_refPoint3)
{
uint8_t testdata[(TEST_TX_PDU_PAYLOAD_MAX -
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE)) *
2];
struct tx_pdu_meta_buffer tx_pdu_meta_buf;
struct tx_sdu_frag_buffer tx_sdu_frag_buf;
struct isoal_pdu_buffer pdu_buffer;
isoal_source_handle_t source_hdl;
struct pdu_iso_sdu_sh seg_hdr[2];
isoal_sdu_len_t sdu_total_size;
isoal_pdu_len_t pdu_write_size;
uint32_t stream_sync_delay;
uint64_t sdu_packet_number;
uint32_t group_sync_delay;
uint8_t iso_interval_int;
uint64_t payload_number;
uint32_t sdu_timestamp;
uint16_t testdata_indx;
uint16_t testdata_size;
uint16_t pdu_write_loc;
uint16_t sdu_read_loc;
uint64_t event_number;
uint32_t sdu_interval;
uint8_t sdu_fragments;
uint16_t pdu_hdr_loc;
uint32_t ref_point;
isoal_status_t err;
uint8_t max_octets;
uint8_t role;
uint8_t BN;
uint8_t FT;
/* Settings */
role = BT_CONN_ROLE_PERIPHERAL;
iso_interval_int = 1;
sdu_interval = CONN_INT_UNIT_US + 50;
max_octets = TEST_TX_PDU_PAYLOAD_MAX + 5;
BN = 1;
FT = 1;
stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;
/* SDU 1 Frag 1 ------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
init_test_data_buffer(
testdata,
(TEST_TX_PDU_PAYLOAD_MAX - (PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE)) *
2);
(void)memset(seg_hdr, 0, sizeof(seg_hdr));
pdu_buffer.handle = (void *)&tx_pdu_meta_buf.node_tx;
pdu_buffer.pdu = (struct pdu_iso *)tx_pdu_meta_buf.node_tx.pdu;
pdu_buffer.size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_packet_number = 2000;
event_number = 2000;
sdu_timestamp = 9249;
ref_point = sdu_timestamp - 50;
sdu_total_size =
TEST_TX_PDU_PAYLOAD_MAX - (PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE);
testdata_indx = 0;
testdata_size =
TEST_TX_PDU_PAYLOAD_MAX - (PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE);
payload_number = event_number * BN;
source_hdl = basic_tx_test_setup(0xADAD, /* Handle */
role, /* Role */
true, /* Framed */
BN, /* BN */
FT, /* FT */
max_octets, /* max_octets */
sdu_interval, /* SDU Interval */
iso_interval_int, /* ISO Interval */
stream_sync_delay, /* Stream Sync Delay */
group_sync_delay); /* Group Sync Delay */
isoal_test_create_sdu_fagment(BT_ISO_SINGLE,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
PDU_ALLOC_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_WRITE_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_EMIT_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_RELEASE_TEST_RETURNS(ISOAL_STATUS_OK);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
/* Advance the target event and the reference point to what it should be */
event_number++;
ref_point += iso_interval_int * CONN_INT_UNIT_US;
payload_number = event_number * BN;
seg_hdr[0].sc = 0;
seg_hdr[0].cmplt = 0;
seg_hdr[0].timeoffset = ref_point - sdu_timestamp;
seg_hdr[0].len = PDU_ISO_SEG_TIMEOFFSET_SIZE;
pdu_hdr_loc = 0;
pdu_write_loc = PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE;
sdu_read_loc = 0;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_fragments = 1;
ZASSERT_PDU_WRITE_TEST(history[0],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[0],
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE));
ZASSERT_PDU_WRITE_TEST(history[1],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[1] = seg_hdr[0];
seg_hdr[1].cmplt = 1;
seg_hdr[1].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[2],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[1],
PDU_ISO_SEG_HDR_SIZE);
ZASSERT_PDU_EMIT_TEST(history[0],
&tx_pdu_meta_buf.node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
}
/**
* Test Suite : TX framed SDU segmentation
*
* Tests segmentation of a single SDU contained in a single fragment
* into a single PDU where Max PDU is greater than the PDU buffer size,
* where the reference point has to be advanced due to the payload number not
* matching the actual target event with a focus on the wrapping point of the
* controller's clock
*/
ZTEST(test_tx_framed, test_tx_framed_2_sdu_1_frag_2_pdu_ts_wrap1)
{
uint8_t testdata[(TEST_TX_PDU_PAYLOAD_MAX -
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE)) *
2];
struct tx_pdu_meta_buffer tx_pdu_meta_buf;
struct tx_sdu_frag_buffer tx_sdu_frag_buf;
struct isoal_pdu_buffer pdu_buffer;
isoal_source_handle_t source_hdl;
struct pdu_iso_sdu_sh seg_hdr[2];
isoal_sdu_len_t sdu_total_size;
isoal_pdu_len_t pdu_write_size;
uint32_t stream_sync_delay;
uint64_t sdu_packet_number;
uint32_t group_sync_delay;
uint8_t iso_interval_int;
uint64_t payload_number;
uint32_t sdu_timestamp;
uint16_t testdata_indx;
uint16_t testdata_size;
uint16_t pdu_write_loc;
uint16_t sdu_read_loc;
uint64_t event_number;
uint32_t sdu_interval;
uint8_t sdu_fragments;
uint16_t pdu_hdr_loc;
uint32_t ref_point;
isoal_status_t err;
uint8_t max_octets;
uint8_t role;
uint8_t BN;
uint8_t FT;
/* Settings */
role = BT_CONN_ROLE_PERIPHERAL;
iso_interval_int = 1;
sdu_interval = CONN_INT_UNIT_US + 50;
max_octets = TEST_TX_PDU_PAYLOAD_MAX + 5;
BN = 1;
FT = 1;
stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;
/* SDU 1 Frag 1 ------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
init_test_data_buffer(
testdata,
(TEST_TX_PDU_PAYLOAD_MAX - (PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE)) *
2);
(void)memset(seg_hdr, 0, sizeof(seg_hdr));
pdu_buffer.handle = (void *)&tx_pdu_meta_buf.node_tx;
pdu_buffer.pdu = (struct pdu_iso *)tx_pdu_meta_buf.node_tx.pdu;
pdu_buffer.size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_packet_number = 2000;
event_number = 2000;
sdu_timestamp = ISOAL_TIME_WRAPPING_POINT_US;
ref_point = 100;
sdu_total_size =
TEST_TX_PDU_PAYLOAD_MAX - (PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE);
testdata_indx = 0;
testdata_size =
TEST_TX_PDU_PAYLOAD_MAX - (PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE);
payload_number = event_number * BN;
source_hdl = basic_tx_test_setup(0xADAD, /* Handle */
role, /* Role */
true, /* Framed */
BN, /* BN */
FT, /* FT */
max_octets, /* max_octets */
sdu_interval, /* SDU Interval */
iso_interval_int, /* ISO Interval */
stream_sync_delay, /* Stream Sync Delay */
group_sync_delay); /* Group Sync Delay */
isoal_test_create_sdu_fagment(BT_ISO_SINGLE,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
PDU_ALLOC_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_WRITE_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_EMIT_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_RELEASE_TEST_RETURNS(ISOAL_STATUS_OK);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
seg_hdr[0].sc = 0;
seg_hdr[0].cmplt = 0;
seg_hdr[0].timeoffset = 101;
seg_hdr[0].len = PDU_ISO_SEG_TIMEOFFSET_SIZE;
pdu_hdr_loc = 0;
pdu_write_loc = PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE;
sdu_read_loc = 0;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_fragments = 1;
ZASSERT_PDU_WRITE_TEST(history[0],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[0],
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE));
ZASSERT_PDU_WRITE_TEST(history[1],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[1] = seg_hdr[0];
seg_hdr[1].cmplt = 1;
seg_hdr[1].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[2],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[1],
PDU_ISO_SEG_HDR_SIZE);
ZASSERT_PDU_EMIT_TEST(history[0],
&tx_pdu_meta_buf.node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* SDU 2 Frag 1 ------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
memset(seg_hdr, 0, sizeof(seg_hdr));
sdu_packet_number++;
sdu_timestamp = sdu_interval - 1;
sdu_total_size =
TEST_TX_PDU_PAYLOAD_MAX - (PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE);
testdata_indx = 0;
testdata_size =
TEST_TX_PDU_PAYLOAD_MAX - (PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE);
payload_number = event_number * BN;
isoal_test_create_sdu_fagment(BT_ISO_SINGLE,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 2 */
/* Advance the target event and the reference point to what it should be */
event_number++;
ref_point += iso_interval_int * CONN_INT_UNIT_US;
payload_number++;
seg_hdr[0].sc = 0;
seg_hdr[0].cmplt = 0;
seg_hdr[0].timeoffset = ref_point - sdu_timestamp;
seg_hdr[0].len = PDU_ISO_SEG_TIMEOFFSET_SIZE;
pdu_hdr_loc = 0;
pdu_write_loc = PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE;
sdu_read_loc = 0;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_fragments = 1;
ZASSERT_PDU_WRITE_TEST(history[3],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[0],
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE));
ZASSERT_PDU_WRITE_TEST(history[4],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[1] = seg_hdr[0];
seg_hdr[1].cmplt = 1;
seg_hdr[1].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[5],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[1],
PDU_ISO_SEG_HDR_SIZE);
ZASSERT_PDU_EMIT_TEST(history[1],
&tx_pdu_meta_buf.node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
}
/**
* Test Suite : TX framed SDU segmentation
*
* Tests segmentation of a single SDU contained in a single fragment
* into a single PDU where Max PDU is less than the PDU buffer size
*/
ZTEST(test_tx_framed, test_tx_framed_1_zero_sdu_1_frag_1_pdu_maxPDU)
{
struct tx_pdu_meta_buffer tx_pdu_meta_buf;
struct tx_sdu_frag_buffer tx_sdu_frag_buf;
struct isoal_pdu_buffer pdu_buffer;
isoal_source_handle_t source_hdl;
struct pdu_iso_sdu_sh seg_hdr[2];
isoal_sdu_len_t sdu_total_size;
isoal_pdu_len_t pdu_write_size;
uint32_t stream_sync_delay;
uint64_t sdu_packet_number;
uint32_t group_sync_delay;
uint8_t iso_interval_int;
uint64_t payload_number;
uint32_t sdu_timestamp;
uint16_t testdata_indx;
uint16_t testdata_size;
uint16_t pdu_write_loc;
uint16_t sdu_read_loc;
uint64_t event_number;
uint32_t sdu_interval;
uint8_t sdu_fragments;
uint16_t pdu_hdr_loc;
uint8_t testdata[1];
uint32_t ref_point;
isoal_status_t err;
uint8_t max_octets;
uint8_t role;
uint8_t BN;
uint8_t FT;
/* Settings */
role = BT_CONN_ROLE_PERIPHERAL;
iso_interval_int = 1;
sdu_interval = CONN_INT_UNIT_US + 50;
max_octets = TEST_TX_PDU_PAYLOAD_MAX - 5;
BN = 1;
FT = 1;
stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;
/* SDU Frag 1 --------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
init_test_data_buffer(testdata, 1);
(void)memset(seg_hdr, 0, sizeof(seg_hdr));
pdu_buffer.handle = (void *)&tx_pdu_meta_buf.node_tx;
pdu_buffer.pdu = (struct pdu_iso *)tx_pdu_meta_buf.node_tx.pdu;
pdu_buffer.size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_packet_number = 2000;
event_number = 2000;
sdu_timestamp = 9249;
ref_point = sdu_timestamp + (iso_interval_int * CONN_INT_UNIT_US) - 50;
sdu_total_size =
TEST_TX_PDU_PAYLOAD_MAX - 5 - (PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE);
testdata_indx = 0;
testdata_size = 0;
payload_number = event_number * BN;
source_hdl = basic_tx_test_setup(0xADAD, /* Handle */
role, /* Role */
true, /* Framed */
BN, /* BN */
FT, /* FT */
max_octets, /* max_octets */
sdu_interval, /* SDU Interval */
iso_interval_int, /* ISO Interval */
stream_sync_delay, /* Stream Sync Delay */
group_sync_delay); /* Group Sync Delay */
isoal_test_create_sdu_fagment(BT_ISO_SINGLE,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
PDU_ALLOC_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_WRITE_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_EMIT_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_RELEASE_TEST_RETURNS(ISOAL_STATUS_OK);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
seg_hdr[0].sc = 0;
seg_hdr[0].cmplt = 0;
seg_hdr[0].timeoffset = ref_point - sdu_timestamp;
seg_hdr[0].len = PDU_ISO_SEG_TIMEOFFSET_SIZE;
pdu_hdr_loc = 0;
pdu_write_loc = PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE;
sdu_read_loc = 0;
pdu_write_size = pdu_write_loc;
sdu_fragments = 1;
ZASSERT_PDU_WRITE_TEST(history[0],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[0],
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE));
seg_hdr[1] = seg_hdr[0];
seg_hdr[1].cmplt = 1;
seg_hdr[1].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[1],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[1],
PDU_ISO_SEG_HDR_SIZE);
/* PDU should not be emitted */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(0);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* Send Event Timeout ----------------------------------------------- */
isoal_tx_event_prepare(source_hdl, event_number);
ZASSERT_PDU_EMIT_TEST(history[0],
&tx_pdu_meta_buf.node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
}
/**
* Test Suite : TX framed SDU segmentation
*
* Tests segmentation of a single SDU contained in a single fragment
* into a single PDU followed by padding
*/
ZTEST(test_tx_framed, test_tx_framed_1_zero_sdu_1_frag_1_pdu_padding)
{
struct tx_pdu_meta_buffer tx_pdu_meta_buf[3];
struct tx_sdu_frag_buffer tx_sdu_frag_buf;
struct isoal_pdu_buffer pdu_buffer[3];
isoal_source_handle_t source_hdl;
struct pdu_iso_sdu_sh seg_hdr[2];
isoal_sdu_len_t sdu_total_size;
isoal_pdu_len_t pdu_write_size;
uint32_t stream_sync_delay;
uint64_t sdu_packet_number;
uint32_t group_sync_delay;
uint8_t iso_interval_int;
uint64_t payload_number;
uint32_t sdu_timestamp;
uint16_t testdata_indx;
uint16_t testdata_size;
uint16_t pdu_write_loc;
uint16_t sdu_read_loc;
uint64_t event_number;
uint32_t sdu_interval;
uint8_t sdu_fragments;
uint16_t pdu_hdr_loc;
uint8_t testdata[1];
uint32_t ref_point;
isoal_status_t err;
uint8_t max_octets;
uint8_t role;
uint8_t BN;
uint8_t FT;
/* Settings */
role = BT_CONN_ROLE_PERIPHERAL;
iso_interval_int = 1;
sdu_interval = CONN_INT_UNIT_US + 50;
max_octets = TEST_TX_PDU_PAYLOAD_MAX - 5;
BN = 3;
FT = 1;
stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;
/* SDU Frag 1 --------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[0]);
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[1]);
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf[2]);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
init_test_data_buffer(testdata, 1);
(void)memset(seg_hdr, 0, sizeof(seg_hdr));
pdu_buffer[0].handle = (void *)&tx_pdu_meta_buf[0].node_tx;
pdu_buffer[0].pdu = (struct pdu_iso *)tx_pdu_meta_buf[0].node_tx.pdu;
pdu_buffer[0].size = TEST_TX_PDU_PAYLOAD_MAX;
pdu_buffer[1].handle = (void *)&tx_pdu_meta_buf[1].node_tx;
pdu_buffer[1].pdu = (struct pdu_iso *)tx_pdu_meta_buf[1].node_tx.pdu;
pdu_buffer[1].size = TEST_TX_PDU_PAYLOAD_MAX;
pdu_buffer[2].handle = (void *)&tx_pdu_meta_buf[2].node_tx;
pdu_buffer[2].pdu = (struct pdu_iso *)tx_pdu_meta_buf[2].node_tx.pdu;
pdu_buffer[2].size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_packet_number = 2000;
event_number = 2000;
sdu_timestamp = 9249;
ref_point = sdu_timestamp + (iso_interval_int * CONN_INT_UNIT_US) - 50;
sdu_total_size =
TEST_TX_PDU_PAYLOAD_MAX - 5 - (PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE);
testdata_indx = 0;
testdata_size = 0;
payload_number = event_number * BN;
source_hdl = basic_tx_test_setup(0xADAD, /* Handle */
role, /* Role */
true, /* Framed */
BN, /* BN */
FT, /* FT */
max_octets, /* max_octets */
sdu_interval, /* SDU Interval */
iso_interval_int, /* ISO Interval */
stream_sync_delay, /* Stream Sync Delay */
group_sync_delay); /* Group Sync Delay */
isoal_test_create_sdu_fagment(BT_ISO_SINGLE,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[0]);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[1]);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer[2]);
PDU_ALLOC_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_WRITE_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_EMIT_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_RELEASE_TEST_RETURNS(ISOAL_STATUS_OK);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
seg_hdr[0].sc = 0;
seg_hdr[0].cmplt = 0;
seg_hdr[0].timeoffset = ref_point - sdu_timestamp;
seg_hdr[0].len = PDU_ISO_SEG_TIMEOFFSET_SIZE;
pdu_hdr_loc = 0;
pdu_write_loc = PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE;
sdu_read_loc = 0;
pdu_write_size = pdu_write_loc;
sdu_fragments = 1;
ZASSERT_PDU_WRITE_TEST(history[0],
pdu_buffer[0],
pdu_hdr_loc,
&seg_hdr[0],
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE));
seg_hdr[1] = seg_hdr[0];
seg_hdr[1].cmplt = 1;
seg_hdr[1].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[1], pdu_buffer[0],
pdu_hdr_loc,
&seg_hdr[1],
PDU_ISO_SEG_HDR_SIZE);
/* PDU should not be emitted */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(0);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* Send Event Timeout ----------------------------------------------- */
isoal_tx_event_prepare(source_hdl, event_number);
ZASSERT_PDU_EMIT_TEST(history[0], &tx_pdu_meta_buf[0].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU 2 (Padding) */
payload_number++;
pdu_write_size = 0;
sdu_fragments = 0;
/* PDU should not be written to */
ZASSERT_PDU_WRITE_TEST_CALL_COUNT(2);
ZASSERT_PDU_EMIT_TEST(history[1], &tx_pdu_meta_buf[1].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU 3 (Padding) */
payload_number++;
sdu_fragments = 0;
/* PDU should not be written to */
ZASSERT_PDU_WRITE_TEST_CALL_COUNT(2);
ZASSERT_PDU_EMIT_TEST(history[2], &tx_pdu_meta_buf[2].node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
}
/**
* Test Suite : TX framed SDU segmentation
*
* Tests segmentation of a single SDU contained in a single fragment,
* where PDU allocation fails
*/
ZTEST(test_tx_framed, test_tx_framed_1_sdu_1_frag_pdu_alloc_err)
{
uint8_t testdata[TEST_TX_PDU_PAYLOAD_MAX - 5 -
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE)];
struct tx_pdu_meta_buffer tx_pdu_meta_buf;
struct tx_sdu_frag_buffer tx_sdu_frag_buf;
struct isoal_pdu_buffer pdu_buffer;
isoal_source_handle_t source_hdl;
struct pdu_iso_sdu_sh seg_hdr[2];
isoal_sdu_len_t sdu_total_size;
isoal_pdu_len_t pdu_write_size;
uint32_t stream_sync_delay;
uint64_t sdu_packet_number;
uint32_t group_sync_delay;
uint8_t iso_interval_int;
uint64_t payload_number;
uint32_t sdu_timestamp;
uint16_t testdata_indx;
uint16_t testdata_size;
uint16_t pdu_write_loc;
uint16_t sdu_read_loc;
uint64_t event_number;
uint32_t sdu_interval;
uint8_t sdu_fragments;
uint16_t pdu_hdr_loc;
uint32_t ref_point;
isoal_status_t err;
uint8_t max_octets;
uint8_t role;
uint8_t BN;
uint8_t FT;
/* Settings */
role = BT_CONN_ROLE_PERIPHERAL;
iso_interval_int = 1;
sdu_interval = CONN_INT_UNIT_US + 50;
max_octets = TEST_TX_PDU_PAYLOAD_MAX - 5;
BN = 1;
FT = 1;
stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;
/* SDU Frag 1 --------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
init_test_data_buffer(testdata,
TEST_TX_PDU_PAYLOAD_MAX - 5 -
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE));
(void)memset(seg_hdr, 0, sizeof(seg_hdr));
pdu_buffer.handle = NULL;
pdu_buffer.pdu = NULL;
pdu_buffer.size = 0;
sdu_packet_number = 2000;
event_number = 2000;
sdu_timestamp = 9249;
ref_point = sdu_timestamp + (iso_interval_int * CONN_INT_UNIT_US) - 50;
sdu_total_size =
TEST_TX_PDU_PAYLOAD_MAX - 5 - (PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE);
testdata_indx = 0;
testdata_size =
TEST_TX_PDU_PAYLOAD_MAX - 5 - (PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE);
payload_number = event_number * BN;
source_hdl = basic_tx_test_setup(0xADAD, /* Handle */
role, /* Role */
true, /* Framed */
BN, /* BN */
FT, /* FT */
max_octets, /* max_octets */
sdu_interval, /* SDU Interval */
iso_interval_int, /* ISO Interval */
stream_sync_delay, /* Stream Sync Delay */
group_sync_delay); /* Group Sync Delay */
isoal_test_create_sdu_fagment(BT_ISO_SINGLE,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
PDU_ALLOC_TEST_RETURNS(ISOAL_STATUS_ERR_PDU_ALLOC);
PDU_WRITE_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_EMIT_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_RELEASE_TEST_RETURNS(ISOAL_STATUS_OK);
ztest_set_assert_valid(true);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
ztest_set_assert_valid(false);
zassert_equal(err, ISOAL_STATUS_ERR_PDU_ALLOC, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
seg_hdr[0].sc = 0;
seg_hdr[0].cmplt = 0;
seg_hdr[0].timeoffset = ref_point - sdu_timestamp;
seg_hdr[0].len = PDU_ISO_SEG_TIMEOFFSET_SIZE;
pdu_hdr_loc = 0;
pdu_write_loc = PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE;
sdu_read_loc = 0;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX - 5;
sdu_fragments = 1;
/* PDU should not be written to */
ZASSERT_PDU_WRITE_TEST_CALL_COUNT(0);
/* PDU should not be emitted */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(0);
/* PDU release not expected (No Emit Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
}
/**
* Test Suite : TX framed SDU segmentation
*
* Tests segmentation of a single SDU contained in a single fragment
* into a single PDU where Max PDU is less than the PDU buffer size,
* where PDU emit fails
*/
ZTEST(test_tx_framed, test_tx_framed_1_sdu_1_frag_pdu_emit_err)
{
uint8_t testdata[TEST_TX_PDU_PAYLOAD_MAX - 5 -
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE)];
struct tx_pdu_meta_buffer tx_pdu_meta_buf;
struct tx_sdu_frag_buffer tx_sdu_frag_buf;
struct isoal_pdu_buffer pdu_buffer;
isoal_source_handle_t source_hdl;
struct pdu_iso_sdu_sh seg_hdr[2];
isoal_sdu_len_t sdu_total_size;
isoal_pdu_len_t pdu_write_size;
uint32_t stream_sync_delay;
uint64_t sdu_packet_number;
uint32_t group_sync_delay;
uint8_t iso_interval_int;
uint64_t payload_number;
uint32_t sdu_timestamp;
uint16_t testdata_indx;
uint16_t testdata_size;
uint16_t pdu_write_loc;
uint16_t sdu_read_loc;
uint64_t event_number;
uint32_t sdu_interval;
uint8_t sdu_fragments;
uint16_t pdu_hdr_loc;
uint32_t ref_point;
isoal_status_t err;
uint8_t max_octets;
uint8_t role;
uint8_t BN;
uint8_t FT;
/* Settings */
role = BT_CONN_ROLE_PERIPHERAL;
iso_interval_int = 1;
sdu_interval = CONN_INT_UNIT_US + 50;
max_octets = TEST_TX_PDU_PAYLOAD_MAX - 5;
BN = 1;
FT = 1;
stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;
/* SDU Frag 1 --------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
init_test_data_buffer(testdata,
TEST_TX_PDU_PAYLOAD_MAX - 5 -
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE));
(void)memset(seg_hdr, 0, sizeof(seg_hdr));
pdu_buffer.handle = (void *)&tx_pdu_meta_buf.node_tx;
pdu_buffer.pdu = (struct pdu_iso *)tx_pdu_meta_buf.node_tx.pdu;
pdu_buffer.size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_packet_number = 2000;
event_number = 2000;
sdu_timestamp = 9249;
ref_point = sdu_timestamp + (iso_interval_int * CONN_INT_UNIT_US) - 50;
sdu_total_size =
TEST_TX_PDU_PAYLOAD_MAX - 5 - (PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE);
testdata_indx = 0;
testdata_size =
TEST_TX_PDU_PAYLOAD_MAX - 5 - (PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE);
payload_number = event_number * BN;
source_hdl = basic_tx_test_setup(0xADAD, /* Handle */
role, /* Role */
true, /* Framed */
BN, /* BN */
FT, /* FT */
max_octets, /* max_octets */
sdu_interval, /* SDU Interval */
iso_interval_int, /* ISO Interval */
stream_sync_delay, /* Stream Sync Delay */
group_sync_delay); /* Group Sync Delay */
isoal_test_create_sdu_fagment(BT_ISO_SINGLE,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
PDU_ALLOC_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_WRITE_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_EMIT_TEST_RETURNS(ISOAL_STATUS_ERR_PDU_EMIT);
PDU_RELEASE_TEST_RETURNS(ISOAL_STATUS_OK);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_ERR_PDU_EMIT, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
seg_hdr[0].sc = 0;
seg_hdr[0].cmplt = 0;
seg_hdr[0].timeoffset = ref_point - sdu_timestamp;
seg_hdr[0].len = PDU_ISO_SEG_TIMEOFFSET_SIZE;
pdu_hdr_loc = 0;
pdu_write_loc = PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE;
sdu_read_loc = 0;
pdu_write_size = TEST_TX_PDU_PAYLOAD_MAX - 5;
sdu_fragments = 1;
ZASSERT_PDU_WRITE_TEST(history[0],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[0],
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE));
ZASSERT_PDU_WRITE_TEST(history[1],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[1] = seg_hdr[0];
seg_hdr[1].cmplt = 1;
seg_hdr[1].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[2],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[1],
PDU_ISO_SEG_HDR_SIZE);
ZASSERT_PDU_EMIT_TEST(history[0],
&tx_pdu_meta_buf.node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
ZASSERT_PDU_RELEASE_TEST(
history[0],
&tx_pdu_meta_buf.node_tx,
bt_iso_handle(isoal_global.source_state[source_hdl].session.handle),
ISOAL_STATUS_ERR_PDU_EMIT);
}
/**
* Test Suite : TX framed SDU segmentation
*
* Tests segmentation of a single SDU contained in a single fragment
* into a single PDU, relying on the ISO event deadline to release the PDU.
*/
ZTEST(test_tx_framed, test_tx_framed_2_sdu_1_frag_pdu_timeout)
{
uint8_t testdata[40];
struct tx_pdu_meta_buffer tx_pdu_meta_buf;
struct tx_sdu_frag_buffer tx_sdu_frag_buf;
struct isoal_pdu_buffer pdu_buffer;
isoal_source_handle_t source_hdl;
struct pdu_iso_sdu_sh seg_hdr[2];
isoal_sdu_len_t sdu_total_size;
isoal_pdu_len_t pdu_write_size;
uint32_t stream_sync_delay;
uint64_t sdu_packet_number;
uint32_t group_sync_delay;
uint16_t iso_interval_int;
uint64_t payload_number;
uint32_t sdu_timestamp;
uint16_t testdata_indx;
uint16_t testdata_size;
uint16_t pdu_write_loc;
uint16_t sdu_read_loc;
uint64_t event_number;
uint32_t sdu_interval;
uint8_t sdu_fragments;
uint16_t pdu_hdr_loc;
uint32_t ref_point;
isoal_status_t err;
uint8_t max_octets;
uint8_t role;
uint8_t BN;
uint8_t FT;
/* Settings */
role = BT_CONN_ROLE_PERIPHERAL;
iso_interval_int = 800;
sdu_interval = 500000;
max_octets = TEST_TX_PDU_PAYLOAD_MAX + 5;
BN = 1;
FT = 1;
stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;
/* SDU 1 Frag 1 ------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
init_test_data_buffer(testdata, 40);
(void)memset(seg_hdr, 0, sizeof(seg_hdr));
pdu_buffer.handle = (void *)&tx_pdu_meta_buf.node_tx;
pdu_buffer.pdu = (struct pdu_iso *)tx_pdu_meta_buf.node_tx.pdu;
pdu_buffer.size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_packet_number = 0;
event_number = 2000;
sdu_timestamp = 9249;
ref_point = sdu_timestamp + (iso_interval_int * CONN_INT_UNIT_US) - 50;
sdu_total_size =
TEST_TX_PDU_PAYLOAD_MAX - (PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE);
testdata_indx = 0;
testdata_size = 10;
payload_number = event_number * BN;
source_hdl = basic_tx_test_setup(0xADAD, /* Handle */
role, /* Role */
true, /* Framed */
BN, /* BN */
FT, /* FT */
max_octets, /* max_octets */
sdu_interval, /* SDU Interval */
iso_interval_int, /* ISO Interval */
stream_sync_delay, /* Stream Sync Delay */
group_sync_delay); /* Group Sync Delay */
isoal_test_create_sdu_fagment(BT_ISO_SINGLE,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
PDU_ALLOC_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_WRITE_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_EMIT_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_RELEASE_TEST_RETURNS(ISOAL_STATUS_OK);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
seg_hdr[0].sc = 0;
seg_hdr[0].cmplt = 0;
seg_hdr[0].timeoffset = ref_point - sdu_timestamp;
seg_hdr[0].len = PDU_ISO_SEG_TIMEOFFSET_SIZE;
pdu_hdr_loc = 0;
pdu_write_loc = PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE;
sdu_read_loc = 0;
pdu_write_size = pdu_write_loc + testdata_size;
sdu_fragments = 1;
ZASSERT_PDU_WRITE_TEST(history[0],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[0],
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE));
ZASSERT_PDU_WRITE_TEST(history[1],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[1] = seg_hdr[0];
seg_hdr[1].cmplt = 1;
seg_hdr[1].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[2],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[1],
PDU_ISO_SEG_HDR_SIZE);
/* PDU should not be emitted */
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* Test PDU release */
/* Simulate interleaving by setting context active flag */
isoal_global.source_state[source_hdl].context_active = true;
isoal_tx_event_prepare(source_hdl, event_number);
isoal_global.source_state[source_hdl].context_active = false;
/* SDU 2 Frag 1 ------------------------------------------------------*/
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
memset(seg_hdr, 0, sizeof(seg_hdr));
sdu_packet_number++;
sdu_timestamp = 9249 + sdu_interval;
sdu_total_size = 10;
testdata_indx = testdata_size;
testdata_size += 10;
isoal_test_create_sdu_fagment(BT_ISO_SINGLE,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 - Seg 2 */
seg_hdr[0].sc = 0;
seg_hdr[0].cmplt = 0;
seg_hdr[0].timeoffset = ref_point - sdu_timestamp;
seg_hdr[0].len = PDU_ISO_SEG_TIMEOFFSET_SIZE;
pdu_hdr_loc = 10 + PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE;
pdu_write_loc = pdu_hdr_loc + PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE;
sdu_read_loc = testdata_indx;
pdu_write_size = pdu_write_loc + 10;
sdu_fragments++;
/* PDU should not be allocated */
ZASSERT_PDU_WRITE_TEST(history[3],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[0],
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE));
ZASSERT_PDU_WRITE_TEST(history[4],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[1] = seg_hdr[0];
seg_hdr[1].cmplt = 1;
seg_hdr[1].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[5],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[1],
PDU_ISO_SEG_HDR_SIZE);
ZASSERT_PDU_EMIT_TEST(history[0],
&tx_pdu_meta_buf.node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* SDU 3 Frag 1 ------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
memset(seg_hdr, 0, sizeof(seg_hdr));
event_number++;
sdu_packet_number++;
sdu_timestamp = sdu_timestamp + sdu_interval;
ref_point = ref_point + (iso_interval_int * CONN_INT_UNIT_US);
sdu_total_size = 20;
testdata_indx = testdata_size;
testdata_size += 20;
isoal_test_create_sdu_fagment(BT_ISO_SINGLE,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 - Seg 2 */
seg_hdr[0].sc = 0;
seg_hdr[0].cmplt = 0;
seg_hdr[0].timeoffset = ref_point - sdu_timestamp;
seg_hdr[0].len = PDU_ISO_SEG_TIMEOFFSET_SIZE;
pdu_hdr_loc = 0;
pdu_write_loc = PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE;
sdu_read_loc = testdata_indx;
pdu_write_size = pdu_write_loc + sdu_total_size;
sdu_fragments = 1;
payload_number++;
ZASSERT_PDU_WRITE_TEST(history[6],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[0],
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE));
ZASSERT_PDU_WRITE_TEST(history[7],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[1] = seg_hdr[0];
seg_hdr[1].cmplt = 1;
seg_hdr[1].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[8],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[1],
PDU_ISO_SEG_HDR_SIZE);
/* PDU emit not expected */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(1);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* Test PDU release */
isoal_tx_event_prepare(source_hdl, event_number);
ZASSERT_PDU_EMIT_TEST(history[1],
&tx_pdu_meta_buf.node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
}
/**
* Test Suite : TX framed EBQ test IAL-CIS-FRA-PER-BV07C
*
* Tests packing multiple SDU segments into the same PDU and release on event
* timeout.
*/
ZTEST(test_tx_framed_ebq, test_tx_framed_cis_fra_per_bv07c)
{
uint8_t testdata[40];
struct tx_pdu_meta_buffer tx_pdu_meta_buf;
struct tx_sdu_frag_buffer tx_sdu_frag_buf;
struct isoal_pdu_buffer pdu_buffer;
isoal_source_handle_t source_hdl;
struct pdu_iso_sdu_sh seg_hdr[2];
isoal_sdu_len_t sdu_total_size;
isoal_pdu_len_t pdu_write_size;
uint32_t stream_sync_delay;
uint64_t sdu_packet_number;
uint32_t group_sync_delay;
uint16_t iso_interval_int;
uint64_t payload_number;
uint32_t sdu_timestamp;
uint16_t testdata_indx;
uint16_t testdata_size;
uint16_t pdu_write_loc;
uint16_t sdu_read_loc;
uint64_t event_number;
uint32_t sdu_interval;
uint8_t sdu_fragments;
uint16_t pdu_hdr_loc;
uint32_t ref_point;
isoal_status_t err;
uint8_t max_octets;
uint8_t role;
uint8_t BN;
uint8_t FT;
/* Settings */
role = BT_CONN_ROLE_PERIPHERAL;
iso_interval_int = 800;
sdu_interval = 500000;
max_octets = TEST_TX_PDU_PAYLOAD_MAX + 5;
BN = 1;
FT = 1;
stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;
/* SDU 1 Frag 1 ------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
init_test_data_buffer(testdata, 40);
(void)memset(seg_hdr, 0, sizeof(seg_hdr));
pdu_buffer.handle = (void *)&tx_pdu_meta_buf.node_tx;
pdu_buffer.pdu = (struct pdu_iso *)tx_pdu_meta_buf.node_tx.pdu;
pdu_buffer.size = TEST_TX_PDU_PAYLOAD_MAX;
sdu_packet_number = 0;
event_number = 0;
sdu_timestamp = 9249;
ref_point = sdu_timestamp + (iso_interval_int * CONN_INT_UNIT_US) - 50;
sdu_total_size = 10;
testdata_indx = 0;
testdata_size = 10;
payload_number = event_number * BN;
source_hdl = basic_tx_test_setup(0xADAD, /* Handle */
role, /* Role */
true, /* Framed */
BN, /* BN */
FT, /* FT */
max_octets, /* max_octets */
sdu_interval, /* SDU Interval */
iso_interval_int, /* ISO Interval */
stream_sync_delay, /* Stream Sync Delay */
group_sync_delay); /* Group Sync Delay */
isoal_test_create_sdu_fagment(BT_ISO_SINGLE,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
SET_NEXT_PDU_ALLOC_BUFFER(&pdu_buffer);
PDU_ALLOC_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_WRITE_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_EMIT_TEST_RETURNS(ISOAL_STATUS_OK);
PDU_RELEASE_TEST_RETURNS(ISOAL_STATUS_OK);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 */
seg_hdr[0].sc = 0;
seg_hdr[0].cmplt = 0;
seg_hdr[0].timeoffset = ref_point - sdu_timestamp;
seg_hdr[0].len = PDU_ISO_SEG_TIMEOFFSET_SIZE;
pdu_hdr_loc = 0;
pdu_write_loc = PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE;
sdu_read_loc = 0;
pdu_write_size = pdu_write_loc + testdata_size;
sdu_fragments = 1;
ZASSERT_PDU_WRITE_TEST(history[0],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[0],
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE));
ZASSERT_PDU_WRITE_TEST(history[1],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[1] = seg_hdr[0];
seg_hdr[1].cmplt = 1;
seg_hdr[1].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[2],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[1],
PDU_ISO_SEG_HDR_SIZE);
/* PDU should not be emitted */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(0);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* SDU 2 Frag 1 ------------------------------------------------------*/
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
memset(seg_hdr, 0, sizeof(seg_hdr));
sdu_packet_number++;
sdu_timestamp = sdu_timestamp + sdu_interval;
sdu_total_size = 10;
testdata_indx = testdata_size;
testdata_size += 10;
isoal_test_create_sdu_fagment(BT_ISO_SINGLE,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 - Seg 2 */
seg_hdr[0].sc = 0;
seg_hdr[0].cmplt = 0;
seg_hdr[0].timeoffset = ref_point - sdu_timestamp;
seg_hdr[0].len = PDU_ISO_SEG_TIMEOFFSET_SIZE;
pdu_hdr_loc = 10 + PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE;
pdu_write_loc = pdu_hdr_loc + PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE;
sdu_read_loc = testdata_indx;
pdu_write_size = pdu_write_loc + 10;
sdu_fragments++;
/* PDU should not be allocated */
ZASSERT_PDU_WRITE_TEST(history[3],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[0],
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE));
ZASSERT_PDU_WRITE_TEST(history[4],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[1] = seg_hdr[0];
seg_hdr[1].cmplt = 1;
seg_hdr[1].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[5],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[1],
PDU_ISO_SEG_HDR_SIZE);
/* PDU emit not expected */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(0);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* Test PDU release */
isoal_tx_event_prepare(source_hdl, event_number);
ZASSERT_PDU_EMIT_TEST(history[0],
&tx_pdu_meta_buf.node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
/* SDU 3 Frag 1 ------------------------------------------------------*/
isoal_test_init_tx_pdu_buffer(&tx_pdu_meta_buf);
isoal_test_init_tx_sdu_buffer(&tx_sdu_frag_buf);
memset(seg_hdr, 0, sizeof(seg_hdr));
event_number++;
sdu_packet_number++;
sdu_timestamp = sdu_timestamp + sdu_interval;
ref_point = ref_point + (iso_interval_int * CONN_INT_UNIT_US);
sdu_total_size = 20;
testdata_indx = testdata_size;
testdata_size += 20;
isoal_test_create_sdu_fagment(BT_ISO_SINGLE,
&testdata[testdata_indx],
(testdata_size - testdata_indx),
sdu_total_size,
sdu_packet_number,
sdu_timestamp,
ref_point,
event_number,
&tx_sdu_frag_buf.sdu_tx);
err = isoal_tx_sdu_fragment(source_hdl, &tx_sdu_frag_buf.sdu_tx);
zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err);
/* Test segmentation (Black Box) */
/* Valid PDUs */
/* PDU 1 - Seg 2 */
seg_hdr[0].sc = 0;
seg_hdr[0].cmplt = 0;
seg_hdr[0].timeoffset = ref_point - sdu_timestamp;
seg_hdr[0].len = PDU_ISO_SEG_TIMEOFFSET_SIZE;
pdu_hdr_loc = 0;
pdu_write_loc = PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE;
sdu_read_loc = testdata_indx;
pdu_write_size = pdu_write_loc + sdu_total_size;
sdu_fragments = 1;
payload_number++;
ZASSERT_PDU_WRITE_TEST(history[6],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[0],
(PDU_ISO_SEG_HDR_SIZE + PDU_ISO_SEG_TIMEOFFSET_SIZE));
ZASSERT_PDU_WRITE_TEST(history[7],
pdu_buffer,
pdu_write_loc,
&testdata[sdu_read_loc],
(pdu_write_size - pdu_write_loc));
seg_hdr[1] = seg_hdr[0];
seg_hdr[1].cmplt = 1;
seg_hdr[1].len += (pdu_write_size - pdu_write_loc);
ZASSERT_PDU_WRITE_TEST(history[8],
pdu_buffer,
pdu_hdr_loc,
&seg_hdr[1],
PDU_ISO_SEG_HDR_SIZE);
/* PDU emit not expected */
ZASSERT_PDU_EMIT_TEST_CALL_COUNT(1);
/* PDU release not expected (No Error) */
ZASSERT_PDU_RELEASE_TEST_CALL_COUNT(0);
/* Test PDU release */
isoal_tx_event_prepare(source_hdl, event_number);
ZASSERT_PDU_EMIT_TEST(history[1],
&tx_pdu_meta_buf.node_tx,
payload_number,
sdu_fragments,
PDU_BIS_LLID_FRAMED,
pdu_write_size,
isoal_global.source_state[source_hdl].session.handle);
}