| /* |
| * 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); |
| } |