/* * Copyright (c) 2022 Demant * * SPDX-License-Identifier: Apache-2.0 */ FAKE_VALUE_FUNC(isoal_status_t, sink_sdu_alloc_test, const struct isoal_sink *, const struct isoal_pdu_rx *, struct isoal_sdu_buffer *); static struct { struct isoal_sdu_buffer *out[6]; size_t buffer_size; size_t pos; } custom_sink_sdu_alloc_test_output_buffer; static void push_custom_sink_sdu_alloc_test_output_buffer(struct isoal_sdu_buffer *buf) { custom_sink_sdu_alloc_test_output_buffer .out[custom_sink_sdu_alloc_test_output_buffer.buffer_size++] = buf; zassert_true(custom_sink_sdu_alloc_test_output_buffer.buffer_size <= ARRAY_SIZE(custom_sink_sdu_alloc_test_output_buffer.out), NULL); } /** * Callback test fixture to be provided for RX sink creation. Allocates a new * SDU buffer. * @param[in] sink_ctx Sink context provided by ISO-AL * @param[in] valid_pdu PDU currently being reassembled * @param[out] sdu_buffer SDU buffer information return structure * @return Status of operation */ static isoal_status_t custom_sink_sdu_alloc_test(const struct isoal_sink *sink_ctx, const struct isoal_pdu_rx *valid_pdu, struct isoal_sdu_buffer *sdu_buffer) { isoal_test_debug_trace_func_call(__func__, "IN"); /* Return SDU buffer details as provided by the test */ zassert_not_null(sdu_buffer, NULL); zassert_true(custom_sink_sdu_alloc_test_output_buffer.pos < custom_sink_sdu_alloc_test_output_buffer.buffer_size, NULL); memcpy(sdu_buffer, custom_sink_sdu_alloc_test_output_buffer .out[custom_sink_sdu_alloc_test_output_buffer.pos++], sizeof(*sdu_buffer)); return sink_sdu_alloc_test_fake.return_val; } #define ZASSERT_ISOAL_SDU_ALLOC_TEST(_typ, _sink, _pdu) \ zassert_equal_ptr(_sink, \ sink_sdu_alloc_test_fake.arg0_##_typ, \ "\t\tExpected alloc sink at %p, got %p.", \ _sink, \ sink_sdu_alloc_test_fake.arg0_##_typ); \ zassert_equal_ptr(_pdu, \ sink_sdu_alloc_test_fake.arg1_##_typ, \ "\t\tExpected alloc PDU buffer at %p, got %p.", \ _pdu, \ sink_sdu_alloc_test_fake.arg1_##_typ) #define ZASSERT_ISOAL_SDU_ALLOC_TEST_CALL_COUNT(_expected) \ zassert_equal(_expected, \ sink_sdu_alloc_test_fake.call_count, \ "Expected alloc called %u times, actual %u.", \ _expected, \ sink_sdu_alloc_test_fake.call_count) FAKE_VALUE_FUNC(isoal_status_t, sink_sdu_emit_test, const struct isoal_sink *, const struct isoal_emitted_sdu_frag *, const struct isoal_emitted_sdu *); /** * This handler is called by custom_sink_sdu_emit_test using the non pointer versions of the * function's arguments. The tests are asserting on the argument content, since sink_sdu_emit_test() * is called multiple times with the same pointer (but different content) this additional fake is * used to store the history of the content. */ FAKE_VOID_FUNC(sink_sdu_emit_test_handler, struct isoal_sink, struct isoal_emitted_sdu_frag, struct isoal_emitted_sdu); /** * Callback test fixture to be provided for RX sink creation. Emits provided * SDU in buffer * @param[in] sink_ctx Sink context provided by ISO-AL * @param[in] valid_sdu SDU buffer and details of SDU to be emitted * @return Status of operation */ static isoal_status_t custom_sink_sdu_emit_test(const struct isoal_sink *sink_ctx, const struct isoal_emitted_sdu_frag *sdu_frag, const struct isoal_emitted_sdu *sdu) { isoal_test_debug_trace_func_call(__func__, "IN"); isoal_test_debug_print_rx_sdu(sink_ctx, sdu_frag, sdu); sink_sdu_emit_test_handler(*sink_ctx, *sdu_frag, *sdu); return sink_sdu_emit_test_fake.return_val; } #define ZASSERT_ISOAL_SDU_EMIT_TEST(_typ, \ _sink, \ _state, \ _frag_sz, \ _frag_status, \ _timestamp, \ _sn, \ _dbuf, \ _dbuf_sz, \ _total_sz, \ _sdu_status) \ zassert_equal_ptr(_sink, \ sink_sdu_emit_test_fake.arg0_##_typ, \ "\t\tExpected sink at %p, got %p.", \ _sink, \ sink_sdu_emit_test_fake.arg0_##_typ); \ zassert_equal(_state, \ sink_sdu_emit_test_handler_fake.arg1_##_typ.sdu_state, \ "\t\tExpected SDU state '%s', got '%s'.", \ STATE_TO_STR(_state), \ STATE_TO_STR(sink_sdu_emit_test_handler_fake.arg1_##_typ.sdu_state)); \ zassert_equal(_frag_sz, \ sink_sdu_emit_test_handler_fake.arg1_##_typ.sdu_frag_size, \ "\t\tExpected SDU frag of size %u, got %u.", \ _frag_sz, \ sink_sdu_emit_test_handler_fake.arg1_##_typ.sdu_frag_size); \ zassert_equal(_frag_status, \ sink_sdu_emit_test_handler_fake.arg1_##_typ.sdu.status, \ "\t\tExpected SDU with status '%s', got '%s'.", \ DU_ERR_TO_STR(_frag_status), \ DU_ERR_TO_STR(sink_sdu_emit_test_handler_fake.arg1_##_typ.sdu.status)); \ zassert_equal(_timestamp, \ sink_sdu_emit_test_handler_fake.arg1_##_typ.sdu.timestamp, \ "\t\tExpected SDU with timestamp %u, got %u.", \ _timestamp, \ sink_sdu_emit_test_handler_fake.arg1_##_typ.sdu.timestamp); \ zassert_equal(_sn, \ sink_sdu_emit_test_handler_fake.arg1_##_typ.sdu.sn, \ "\t\tExpected SDU with sequence number %u, got %u.", \ _sn, \ sink_sdu_emit_test_handler_fake.arg1_##_typ.sdu.sn); \ zassert_equal_ptr(_dbuf, \ sink_sdu_emit_test_handler_fake.arg1_##_typ.sdu.contents.dbuf, \ "\t\tExpected SDU data buffer at %p, got %p.", \ _dbuf, \ sink_sdu_emit_test_handler_fake.arg1_##_typ.sdu.contents.dbuf); \ zassert_equal(_dbuf_sz, \ sink_sdu_emit_test_handler_fake.arg1_##_typ.sdu.contents.size, \ "\t\tExpected SDU data buffer of size %u, got %u.", \ _dbuf_sz, \ sink_sdu_emit_test_handler_fake.arg1_##_typ.sdu.contents.size); \ zassert_equal(_total_sz, \ sink_sdu_emit_test_handler_fake.arg2_##_typ.total_sdu_size, \ "\t\tExpected total size of SDU %u,got %u.", \ _total_sz, \ sink_sdu_emit_test_handler_fake.arg2_##_typ.total_sdu_size); \ zassert_equal(_sdu_status, \ sink_sdu_emit_test_handler_fake.arg2_##_typ.collated_status, \ "\t\tExpected SDU with status '%s', got '%s'.", \ DU_ERR_TO_STR(_sdu_status), \ DU_ERR_TO_STR(sink_sdu_emit_test_handler_fake.arg2_##_typ.collated_status)) #define ZASSERT_ISOAL_SDU_EMIT_TEST_CALL_COUNT(_expected) \ zassert_equal(_expected, \ sink_sdu_emit_test_fake.call_count, \ "Expected emit called %u times, actual %u.", \ _expected, \ sink_sdu_emit_test_fake.call_count) FAKE_VALUE_FUNC(isoal_status_t, sink_sdu_write_test, void *, const uint8_t *, const size_t); /** * Callback test fixture to be provided for RX sink creation. Writes provided * data into target SDU buffer. * @param dbuf SDU buffer (Includes current write location field) * @param pdu_payload Current PDU being reassembled by ISO-AL * @param consume_len Length of data to transfer * @return Status of the operation */ static isoal_status_t custom_sink_sdu_write_test(void *dbuf, const uint8_t *pdu_payload, const size_t consume_len) { isoal_test_debug_trace_func_call(__func__, "IN"); #if defined(DEBUG_TEST) zassert_not_null(dbuf, ""); zassert_not_null(pdu_payload, ""); struct rx_sdu_frag_buffer *rx_sdu_frag_buf; rx_sdu_frag_buf = (struct rx_sdu_frag_buffer *)dbuf; memcpy(&rx_sdu_frag_buf->sdu[rx_sdu_frag_buf->write_loc], pdu_payload, consume_len); rx_sdu_frag_buf->write_loc += consume_len; #endif return sink_sdu_write_test_fake.return_val; } #define ZASSERT_ISOAL_SDU_WRITE_TEST(_typ, _frag_buf, _payload_buf, _length) \ zassert_equal_ptr(_frag_buf, \ sink_sdu_write_test_fake.arg0_##_typ, \ "\t\tExpected write buffer at %p, got %p.", \ _frag_buf, \ sink_sdu_write_test_fake.arg0_##_typ); \ zassert_equal_ptr(_payload_buf, \ sink_sdu_write_test_fake.arg1_##_typ, \ "\t\tExpected write source at %p, got %p.", \ _payload_buf, \ sink_sdu_write_test_fake.arg1_##_typ); \ zassert_equal(_length, \ sink_sdu_write_test_fake.arg2_##_typ, \ "\t\tExpected write length of %u, got %u.", \ _length, \ sink_sdu_write_test_fake.arg2_##_typ) #define ZASSERT_ISOAL_SDU_WRITE_TEST_CALL_COUNT(_expected) \ zassert_equal(_expected, \ sink_sdu_write_test_fake.call_count, \ "Expected write called %u times, actual %u.", \ _expected, \ sink_sdu_write_test_fake.call_count) /** * RX common setup before running tests * @param f Input configuration parameters */ static void isoal_test_rx_common_before(void *f) { ARG_UNUSED(f); custom_sink_sdu_alloc_test_output_buffer.buffer_size = 0; custom_sink_sdu_alloc_test_output_buffer.pos = 0; RESET_FAKE(sink_sdu_alloc_test); RESET_FAKE(sink_sdu_write_test); RESET_FAKE(sink_sdu_emit_test); RESET_FAKE(sink_sdu_emit_test_handler); FFF_RESET_HISTORY(); sink_sdu_alloc_test_fake.custom_fake = custom_sink_sdu_alloc_test; sink_sdu_write_test_fake.custom_fake = custom_sink_sdu_write_test; sink_sdu_emit_test_fake.custom_fake = custom_sink_sdu_emit_test; } /** * Cacluate RX latency based on role and framing * @param role Peripheral / Central / Broadcast * @param framed PDU framing (Framed / Unframed) * @param flush_timeout FT * @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 Latency (signed) */ static int32_t calc_rx_latency_by_role(uint8_t role, uint8_t framed, uint8_t flush_timeout, uint32_t sdu_interval, uint16_t iso_interval_int, uint32_t stream_sync_delay, uint32_t group_sync_delay) { int32_t latency; uint32_t iso_interval; latency = 0; iso_interval = iso_interval_int * ISO_INT_UNIT_US; switch (role) { case ISOAL_ROLE_PERIPHERAL: if (framed) { latency = stream_sync_delay + sdu_interval + (flush_timeout * iso_interval); } else { latency = stream_sync_delay + ((flush_timeout - 1) * iso_interval); } break; case ISOAL_ROLE_CENTRAL: if (framed) { latency = stream_sync_delay - group_sync_delay; } else { latency = stream_sync_delay - group_sync_delay - (((iso_interval / sdu_interval) - 1) * iso_interval); } break; case ISOAL_ROLE_BROADCAST_SINK: if (framed) { latency = group_sync_delay + sdu_interval + iso_interval; } else { latency = group_sync_delay; } break; default: zassert_unreachable("Invalid role!"); break; } #if defined(DEBUG_TEST) PRINT("Latency %s calculated %dus.\n", framed ? "framed" : "unframed", latency); PRINT("\tFT %d\n\tISO Interval %dus\n\tSDU Interval %dus" "\n\tStream Sync Delay %dus\n\tGroup Sync Delay %dus\n\n", flush_timeout, iso_interval, sdu_interval, stream_sync_delay, group_sync_delay); #endif return latency; } static uint32_t get_next_time_offset(uint32_t time_offset, uint32_t iso_interval_us, uint32_t sdu_interval_us, bool next_event_expected) { uint32_t result; if (time_offset > sdu_interval_us) { result = time_offset - sdu_interval_us; #if defined(DEBUG_TEST) PRINT("Increment time offset for same event %lu --> %lu\n", time_offset, result); #endif zassert_false(next_event_expected); } else { result = time_offset + iso_interval_us - sdu_interval_us; #if defined(DEBUG_TEST) PRINT("Increment time offset for next event %lu --> %lu\n", time_offset, result); #endif zassert_true(next_event_expected); } return result; } /** * @breif Wrapper to test time wrapping * @param time_now Current time value * @param time_diff Time difference (signed) * @return Wrapped time after difference */ static uint32_t isoal_get_wrapped_time_test(uint32_t time_now, int32_t time_diff) { uint32_t result = isoal_get_wrapped_time_us(time_now, time_diff); #if defined(DEBUG_TEST) PRINT("[isoal_get_wrapped_time_us] time_now %12lu time_diff %12ld result %lu\n", time_now, time_diff, result); #endif return result; } /** * Basic setup of a single sink for any RX test * @param handle Stream handle * @param role Peripheral / Central / Broadcast * @param framed PDU framing * @param burst_number BN * @param flush_timeout FT * @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 sink handle */ static isoal_sink_handle_t basic_rx_test_setup(uint16_t handle, uint8_t role, uint8_t framed, uint8_t burst_number, uint8_t flush_timeout, uint32_t sdu_interval, uint16_t iso_interval_int, uint32_t stream_sync_delay, uint32_t group_sync_delay) { isoal_sink_handle_t sink_hdl; isoal_status_t err; #if defined(DEBUG_TEST) PRINT("RX Test Setup:\n\tHandle 0x%04x\n\tRole %s\n\tFraming %s" "\n\tBN %u\n\tFT %d\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, (iso_interval_int * ISO_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 sink based on global parameters */ err = isoal_sink_create(handle, role, framed, burst_number, flush_timeout, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay, sink_sdu_alloc_test, sink_sdu_emit_test, sink_sdu_write_test, &sink_hdl); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Enable newly created sink */ isoal_sink_enable(sink_hdl); return sink_hdl; } /** * Test Suite : RX basic test * * Test creating and destroying sinks upto the maximum with randomized * configuration parameters. */ ZTEST(test_rx_basics, test_sink_isoal_test_create_destroy) { isoal_sink_handle_t sink_hdl[CONFIG_BT_CTLR_ISOAL_SINKS]; 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; isoal_status_t res; uint16_t handle; int32_t latency; 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; sdu_interval_int = 1; iso_interval_int = 1; iso_interval = iso_interval_int * ISO_INT_UNIT_US; sdu_interval = sdu_interval_int * ISO_INT_UNIT_US; stream_sync_delay = iso_interval - 200; group_sync_delay = iso_interval - 50; latency = 0; ztest_set_assert_valid(false); for (int i = 0; i < CONFIG_BT_CTLR_ISOAL_SINKS; i++) { res = ISOAL_STATUS_ERR_UNSPECIFIED; sink_hdl[i] = 0xFF; pdus_per_sdu = (burst_number * sdu_interval) / iso_interval; switch (role) { case ISOAL_ROLE_PERIPHERAL: case ISOAL_ROLE_CENTRAL: case ISOAL_ROLE_BROADCAST_SINK: latency = calc_rx_latency_by_role(role, framed, flush_timeout, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); break; default: ztest_set_assert_valid(true); break; } res = isoal_sink_create(handle, role, framed, burst_number, flush_timeout, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay, sink_sdu_alloc_test, sink_sdu_emit_test, sink_sdu_write_test, &sink_hdl[i]); zassert_equal(isoal_global.sink_allocated[sink_hdl[i]], ISOAL_ALLOC_STATE_TAKEN, ""); zassert_equal(isoal_global.sink_state[sink_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.sink_state[sink_hdl[i]].session.pdus_per_sdu, pdus_per_sdu, burst_number, flush_timeout, iso_interval, sdu_interval, stream_sync_delay, group_sync_delay); if (framed) { zassert_equal( isoal_global.sink_state[sink_hdl[i]].session.sdu_sync_const, latency, "%s latency framed %d should be %d", ROLE_TO_STR(role), isoal_global.sink_state[sink_hdl[i]].session.sdu_sync_const, latency); } else { zassert_equal( isoal_global.sink_state[sink_hdl[i]].session.sdu_sync_const, latency, "%s latency unframed %d should be %d", ROLE_TO_STR(role), isoal_global.sink_state[sink_hdl[i]].session.sdu_sync_const, latency); } zassert_equal(res, ISOAL_STATUS_OK, "Sink %d in role %s creation failed!", i, ROLE_TO_STR(role)); isoal_sink_enable(sink_hdl[i]); zassert_equal(isoal_global.sink_state[sink_hdl[i]].sdu_production.mode, ISOAL_PRODUCTION_MODE_ENABLED, "Sink %d in role %s enable failed!", i, ROLE_TO_STR(role)); framed = !framed; burst_number++; flush_timeout = (flush_timeout % 3) + 1; sdu_interval_int++; iso_interval_int = iso_interval_int * sdu_interval_int; sdu_interval = (sdu_interval_int * ISO_INT_UNIT_US) - (framed ? 100 : 0); iso_interval = iso_interval_int * ISO_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_SINKS; i++) { isoal_sink_destroy(sink_hdl[i]); zassert_equal(isoal_global.sink_allocated[sink_hdl[i]], ISOAL_ALLOC_STATE_FREE, "Sink destruction failed!"); zassert_equal(isoal_global.sink_state[sink_hdl[i]].sdu_production.mode, ISOAL_PRODUCTION_MODE_DISABLED, "Sink disable failed!"); } } } /** * Test Suite : RX basic test * * Test error return on exceeding the maximum number of sinks available. */ ZTEST(test_rx_basics, test_sink_isoal_test_create_err) { isoal_sink_handle_t sink_hdl[CONFIG_BT_CTLR_ISOAL_SINKS + 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; isoal_status_t res; uint16_t handle; uint8_t role; bool framed; handle = 0x8000; role = ISOAL_ROLE_PERIPHERAL; burst_number = 1; flush_timeout = 1; framed = false; iso_interval_int = 1; sdu_interval = ISO_INT_UNIT_US; stream_sync_delay = ISO_INT_UNIT_US - 200; group_sync_delay = ISO_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_SINKS; i++) { res = isoal_sink_create(handle, role, framed, burst_number, flush_timeout, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay, sink_sdu_alloc_test, sink_sdu_emit_test, sink_sdu_write_test, &sink_hdl[i]); zassert_equal(res, ISOAL_STATUS_OK, "Sink %d in role %s creation failed!", i, ROLE_TO_STR(role)); } res = isoal_sink_create(handle, role, framed, burst_number, flush_timeout, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay, sink_sdu_alloc_test, sink_sdu_emit_test, sink_sdu_write_test, &sink_hdl[CONFIG_BT_CTLR_ISOAL_SINKS]); zassert_equal(res, ISOAL_STATUS_ERR_SINK_ALLOC, "Sink creation did not return error as expected!"); } /** * Test Suite : RX basic test * * Test error return when receiving PDUs for a disabled sink. */ ZTEST(test_rx_basics, test_sink_disable) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint64_t payload_number; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[23]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ISO_INT_UNIT_US; BN = 1; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 23); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 2000; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, false, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); seqn = 0; testdata_indx = 0; testdata_size = 23; sdu_size = 0; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ false, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ /* Disable the sink */ isoal_sink_disable(sink_hdl); /* Send SDU in a single PDU */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_COMPLETE_END, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Test recombine (Black Box) */ /* Should not allocate a new SDU */ /* SDU should not be written to */ /* SDU should not be emitted */ err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); } /** * Test Suite : RX unframed PDU reassembly * * Tests reassembly of a single valid RX PDU into an SDU. * * Expected Sequence: * -- Total of 1 SDUs released across 1 events * -- Event 1: PDU0 Valid SDU 0 Unframed Single * -----> SDU 0 Valid (Released) * */ ZTEST(test_rx_unframed, test_rx_unframed_single_pdu) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint64_t payload_number; uint16_t total_sdu_size; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[23]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ISO_INT_UNIT_US; BN = 1; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 0 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 23); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 2000; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, false, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); seqn = 0; testdata_indx = 0; testdata_size = 23; sdu_size = 23; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ false, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ /* Send SDU in a single PDU */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_COMPLETE_END, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 -------------------------------------------------------------*/ /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ /* No padding PDUs expected, so move to waiting for start fragment */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX unframed PDU reassembly * * Tests boundary conditions of time wrapping function */ ZTEST(test_rx_unframed, test_rx_time_wrapping) { const uint32_t time_wrapping_point = ISOAL_TIME_WRAPPING_POINT_US; uint32_t expected_result; int32_t time_diff; uint32_t time_now; uint32_t result; /* Maximum negative difference from 0 */ time_now = 0; time_diff = (time_wrapping_point == UINT32_MAX ? INT32_MIN : -ISOAL_TIME_WRAPPING_POINT_US); expected_result = ISOAL_TIME_WRAPPING_POINT_US + time_diff + 1; result = isoal_get_wrapped_time_test(time_now, time_diff); zassert_equal(result, expected_result, "%lu != %lu", result, expected_result); /* Maximum negative difference from maximum time */ time_now = ISOAL_TIME_WRAPPING_POINT_US; time_diff = (time_wrapping_point == UINT32_MAX ? INT32_MIN : -ISOAL_TIME_WRAPPING_POINT_US); expected_result = ISOAL_TIME_WRAPPING_POINT_US + time_diff; result = isoal_get_wrapped_time_test(time_now, time_diff); zassert_equal(result, expected_result, "%lu != %lu", result, expected_result); /* Maximum positive difference from maximum time */ time_now = ISOAL_TIME_WRAPPING_POINT_US; time_diff = (time_wrapping_point == UINT32_MAX ? INT32_MAX : ISOAL_TIME_WRAPPING_POINT_US); expected_result = time_diff - 1; result = isoal_get_wrapped_time_test(time_now, time_diff); zassert_equal(result, expected_result, "%lu != %lu", result, expected_result); } /** * Test Suite : RX unframed PDU reassembly * * Tests time wrapping in reassembly of a single valid RX PDU into an SDU. * * Expected Sequence: * -- Total of 1 SDUs released across 1 events * -- Event 1: PDU0 Valid SDU 0 Unframed Single * -----> SDU 0 Valid (Released) * */ ZTEST(test_rx_unframed, test_rx_unframed_single_pdu_ts_wrap1) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint64_t payload_number; uint16_t total_sdu_size; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[23]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ISO_INT_UNIT_US; BN = 1; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 0 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 23); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 2000; latency = calc_rx_latency_by_role(role, false, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); /* SDU time stamp should wrap back to 0 */ pdu_timestamp = (ISOAL_TIME_WRAPPING_POINT_US - latency) + 1; sdu_timestamp = 0; seqn = 0; testdata_indx = 0; testdata_size = 23; sdu_size = 23; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ false, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ /* Send SDU in a single PDU */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_COMPLETE_END, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 -------------------------------------------------------------*/ /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ /* No padding PDUs expected, so move to waiting for start fragment */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX unframed PDU reassembly * * Tests time wrapping in reassembly of a single valid RX PDU into an SDU. * * Expected Sequence: * -- Total of 1 SDUs released across 1 events * -- Event 1: PDU0 Valid SDU 0 Unframed Single * -----> SDU 0 Valid (Released) * */ ZTEST(test_rx_unframed, test_rx_unframed_single_pdu_ts_wrap2) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint64_t payload_number; uint16_t total_sdu_size; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[23]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_CENTRAL; iso_interval_int = 1; sdu_interval = ISO_INT_UNIT_US; BN = 1; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 0 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 23); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 2000; latency = calc_rx_latency_by_role(role, false, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); /* SDU time stamp should wrap back to max time */ pdu_timestamp = (-latency) - 1; sdu_timestamp = ISOAL_TIME_WRAPPING_POINT_US; seqn = 0; testdata_indx = 0; testdata_size = 23; sdu_size = 23; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ false, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ /* Send SDU in a single PDU */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_COMPLETE_END, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 -------------------------------------------------------------*/ /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ /* No padding PDUs expected, so move to waiting for start fragment */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX unframed PDU reassembly * * Tests reassembly of two valid RX PDU into a single SDU. * * Expected Sequence: * -- Total of 1 SDUs released across 1 events * -- Event 1: PDU0 Valid SDU 0 Unframed Start * PDU1 Valid SDU 0 Unframed End * -----> SDU 0 Valid (Released) * */ ZTEST(test_rx_unframed, test_rx_unframed_dbl_pdu) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint64_t payload_number; uint16_t total_sdu_size; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[23]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ISO_INT_UNIT_US; BN = 2; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 0 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 23); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 2000; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, false, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size = 13; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ false, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ /* Send PDU with start fragment */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 -------------------------------------------------------------*/ /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST_CALL_COUNT(0); /* Test recombine (White Box) */ /* No padding PDUs expected, so move to waiting for start fragment */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size += 10; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); /* Send PDU with end fragment */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_COMPLETE_END, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 -------------------------------------------------------------*/ /* Test recombine (Black Box) */ /* Should not allocate a new SDU */ ZASSERT_ISOAL_SDU_ALLOC_TEST_CALL_COUNT(1); /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ /* As two PDUs per SDU, no padding is expected */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX unframed PDU reassembly * * Tests reassembly of three SDUs where the end of the first two were not seen * * Expected Sequence: * -- Total of 1 SDUs released across 1 events * -- Event 1: PDU0 Valid SDU 0 Unframed Start * PDU1 Valid SDU 0 Unframed Cont. * -----> SDU 0 Bit Errors (Released) * PDU2 Valid SDU 1 Unframed Start * PDU3 Valid SDU 1 Unframed Cont. * -----> SDU 1 Bit Errors (Released) * -- Event 2: PDU4 Valid SDU 2 Unframed Single * -----> SDU 2 Valid (Released) * */ ZTEST(test_rx_unframed, test_rx_unframed_dbl_split) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint64_t payload_number; uint16_t total_sdu_size; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[53]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ISO_INT_UNIT_US / 2; BN = 4; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* SDU 0 - PDU 0 -----------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 53); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 2000; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, false, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size = 13; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ false, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 -------------------------------------------------------------*/ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be not emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST_CALL_COUNT(0); /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* SDU 0 - PDU 1 -----------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size += 10; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_ERRORS, ISOAL_SDU_STATUS_ERRORS); isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 -------------------------------------------------------------*/ /* A new SDU should not be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST_CALL_COUNT(1); /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_ERRORS, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); /* SDU 1 - PDU 2 -----------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); payload_number++; seqn++; sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency + sdu_interval); testdata_indx = testdata_size; testdata_size += 10; sdu_size = 10; isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 1 -------------------------------------------------------------*/ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST_CALL_COUNT(1); /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* SDU 1 - PDU 3 -----------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size += 10; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_ERRORS, ISOAL_SDU_STATUS_ERRORS); isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 1 -------------------------------------------------------------*/ /* A new SDU should not be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST_CALL_COUNT(2); /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_ERRORS, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); /* SDU 2 - PDU 4 -----------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); payload_number++; seqn++; pdu_timestamp = 9249 + ISO_INT_UNIT_US; sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); testdata_indx = testdata_size; testdata_size += 10; sdu_size = 10; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); isoal_test_create_unframed_pdu(PDU_BIS_LLID_COMPLETE_END, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 2 -------------------------------------------------------------*/ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ /* Expecting padding PDU as PDUs per SDU is 2 */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); } /** * Test Suite : RX unframed PDU reassembly * * Tests reassembly of one SDUs in five fragments * * Expected Sequence: * -- Total of 1 SDUs released across 1 events * -- Event 1: PDU0 Valid SDU 0 Unframed Start * PDU1 Valid SDU 0 Unframed Cont. * PDU2 Valid SDU 0 Unframed Cont. * PDU3 Valid SDU 0 Unframed Cont. * PDU4 Valid SDU 0 Unframed End * -----> SDU 0 Valid (Released) * */ ZTEST(test_rx_unframed, test_rx_unframed_multi_split) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint64_t payload_number; uint16_t total_sdu_size; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[53]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ISO_INT_UNIT_US; BN = 5; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 0 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 53); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 2000; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, false, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size = 13; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ false, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 -------------------------------------------------------------*/ /* SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST_CALL_COUNT(0); /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size += 10; isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 -------------------------------------------------------------*/ /* A new SDU should not be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST_CALL_COUNT(1); /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST_CALL_COUNT(0); /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 3 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size += 10; isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 -------------------------------------------------------------*/ /* A new SDU should not be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST_CALL_COUNT(1); /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST_CALL_COUNT(0); /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 3 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size += 10; isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 -------------------------------------------------------------*/ /* A new SDU should not be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST_CALL_COUNT(1); /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST_CALL_COUNT(0); /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 4 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size += 10; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); isoal_test_create_unframed_pdu(PDU_BIS_LLID_COMPLETE_END, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 -------------------------------------------------------------*/ /* A new SDU should not be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST_CALL_COUNT(1); /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX unframed PDU reassembly * * Tests reassembly of one SDUs in five fragments where the SDU buffer size is * reached * * Expected Sequence: * -- Total of 1 SDUs released across 1 events * -- Event 1: PDU0 Valid SDU 0 Unframed Start * PDU1 Valid SDU 0 Unframed Cont. * -----> SDU 0 Valid Frag 1 (Released) * PDU2 Valid SDU 0 Unframed Cont. * -----> SDU 0 Valid Frag 2 (Released) * PDU3 Valid SDU 0 Unframed Cont. * PDU4 Valid SDU 0 Unframed End * -----> SDU 0 Valid Frag 3 (Released) * */ ZTEST(test_rx_unframed, test_rx_unframed_multi_split_on_border) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint64_t payload_number; uint16_t total_sdu_size; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[100]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ISO_INT_UNIT_US; BN = 5; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 0 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 100); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = 40; payload_number = 2000; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, false, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); seqn = 0; testdata_indx = 0; testdata_size = 17; sdu_size = 17; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ false, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 - Frag 1 ----------------------------------------------------*/ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST_CALL_COUNT(0); /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 23; sdu_size += 23; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, 100); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 - Frag 1 ----------------------------------------------------*/ /* A new SDU should not be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST_CALL_COUNT(1); /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_START, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 2 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 40; sdu_size = 40; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, 100); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 - Frag 2 ----------------------------------------------------*/ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_CONT, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 3 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size = 10; isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 - Frag 3 ----------------------------------------------------*/ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST_CALL_COUNT(2); /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 4 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size += 10; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, 100); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); isoal_test_create_unframed_pdu(PDU_BIS_LLID_COMPLETE_END, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 - Frag 3 ----------------------------------------------------*/ /* A new SDU should not be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST_CALL_COUNT(3); /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_END, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX unframed PDU reassembly * * Tests reassembly of one SDUs sent in one PDU when the SDU fragment size is * small, resulting in multiple SDU fragments released during reassembly */ ZTEST(test_rx_unframed, test_rx_unframed_long_pdu_short_sdu) { struct rx_sdu_frag_buffer rx_sdu_frag_buf[2]; struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct isoal_sdu_buffer sdu_buffer[2]; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint64_t payload_number; uint16_t total_sdu_size; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[40]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ISO_INT_UNIT_US; BN = 1; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[0]); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[1]); init_test_data_buffer(testdata, 40); sdu_buffer[0].dbuf = &rx_sdu_frag_buf[0]; sdu_buffer[1].dbuf = &rx_sdu_frag_buf[1]; sdu_buffer[0].size = 20; sdu_buffer[1].size = 20; payload_number = 2000; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, false, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); seqn = 0; testdata_indx = 0; testdata_size = 40; sdu_size = 20; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, 40); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ false, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_COMPLETE_END, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[0]); push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[1]); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* SDU 1 */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(history[0], &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(history[0], &rx_sdu_frag_buf[0], /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ 20); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(history[0], &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_START, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[0].dbuf, /* Buffer */ sdu_buffer[0].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* SDU 2 */ sdu_size = 20; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, 40); /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(history[1], &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(history[1], &rx_sdu_frag_buf[1], /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + 20], /* PDU payload */ 20); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(history[1], &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_END, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[1].dbuf, /* Buffer */ sdu_buffer[1].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX unframed PDU reassembly * * Tests reassembly of two SDUs where the end fragment of the first was not seen */ ZTEST(test_rx_unframed, test_rx_unframed_dbl_pdu_prem) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint64_t payload_number; uint16_t total_sdu_size; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[23]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ISO_INT_UNIT_US; BN = 1; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 23); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 2000; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, false, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size = 13; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_ERRORS, ISOAL_SDU_STATUS_ERRORS); sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ false, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_ERRORS, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); /* PDU 2 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); payload_number++; seqn++; sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); testdata_indx = testdata_size; testdata_size += 10; sdu_size = 10; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); isoal_test_create_unframed_pdu(PDU_BIS_LLID_COMPLETE_END, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX unframed PDU reassembly * * Tests reassembly of SDUs with PDU errors */ ZTEST(test_rx_unframed, test_rx_unframed_single_pdu_err) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint64_t payload_number; uint16_t total_sdu_size; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[23]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ISO_INT_UNIT_US; BN = 1; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 23); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 2000; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, false, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size = 0; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_ERRORS, ISOAL_SDU_STATUS_ERRORS); sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ false, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_COMPLETE_END, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_ERRORS, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should not be written */ ZASSERT_ISOAL_SDU_WRITE_TEST_CALL_COUNT(0); /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_ERRORS, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); /* PDU 2 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); payload_number++; seqn++; pdu_timestamp = 9249 + ISO_INT_UNIT_US; sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); testdata_indx = testdata_size; testdata_size += 10; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); isoal_test_create_unframed_pdu(PDU_BIS_LLID_COMPLETE_END, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_LOST_DATA, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should not be written */ ZASSERT_ISOAL_SDU_WRITE_TEST_CALL_COUNT(0); /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_PDU_STATUS_LOST_DATA, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX unframed PDU reassembly * * Tests reassembly of SDUs where PDUs are not in sequence */ ZTEST(test_rx_unframed, test_rx_unframed_seq_err) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint64_t payload_number; uint16_t total_sdu_size; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[43]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ISO_INT_UNIT_US; BN = 3; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 43); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 2000; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, false, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size = 13; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ false, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 2 Not transferred to ISO-AL ------------------------------------*/ payload_number++; testdata_indx = testdata_size; testdata_size += 10; /* PDU 3 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size += 10; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); isoal_test_create_unframed_pdu(PDU_BIS_LLID_COMPLETE_END, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should not be allocated */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_LOST_DATA, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ /* PDU count will not have reached 3 as one PDU was not received, so * last_pdu will not be set and the state should remain in Error * Spooling. */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); /* PDU 4 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); payload_number++; seqn++; pdu_timestamp = 9249 + ISO_INT_UNIT_US; sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); testdata_indx = testdata_size; testdata_size += 10; sdu_size = 10; isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ /* Test recombine (White Box) */ /* Detecting the transition from an end fragment to a start fragment * should have triggered the monitoring code to pull the state machine * out of Eroor spooling and directly into the start of a new SDU. As * this was not an end fragment, the next state should be continue. */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); } /** * Test Suite : RX unframed PDU reassembly * * Tests reassembly of SDUs where PDUs are not in sequence with errors * Tests error prioritization */ ZTEST(test_rx_unframed, test_rx_unframed_seq_pdu_err1) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint64_t payload_number; uint16_t total_sdu_size; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[43]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ISO_INT_UNIT_US; BN = 3; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 43); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, false, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size = 13; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ false, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 2 Not transferred to ISO-AL ------------------------------------*/ payload_number++; testdata_indx = testdata_size; testdata_size += 10; /* PDU 3 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); /* PDU status ISOAL_PDU_STATUS_ERRORS */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_COMPLETE_END, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_ERRORS, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should not be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST_CALL_COUNT(1); /* SDU payload should not be written */ ZASSERT_ISOAL_SDU_WRITE_TEST_CALL_COUNT(1); /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_LOST_DATA, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ /* PDU count will not have reached 3 as one PDU was not received, so * last_pdu will not be set and the state should remain in Error * Spooling. */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); /* PDU 4 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); payload_number++; seqn++; pdu_timestamp = 9249 + ISO_INT_UNIT_US; sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); testdata_indx = testdata_size; testdata_size += 10; sdu_size = 10; isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ /* Test recombine (White Box) */ /* Detecting the transition from an end fragment to a start fragment * should have triggered the monitoring code to pull the state machine * out of Eroor spooling and directly into the start of a new SDU. As * this was not an end fragment, the next state should be continue. */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 5 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size += 10; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); isoal_test_create_unframed_pdu(PDU_BIS_LLID_COMPLETE_END, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should not be allocated */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ /* Expecting padding so state should be Error Spooling */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); } /** * Test Suite : RX unframed PDU reassembly * * Tests reassembly of SDUs where PDUs are not in sequence with errors * Tests releasing and collating information for buffered SDUs when an error in * reception occurs. */ ZTEST(test_rx_unframed, test_rx_unframed_seq_pdu_err2) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint64_t payload_number; uint16_t total_sdu_size; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[80]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ISO_INT_UNIT_US; BN = 3; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 80); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = 40; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, false, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); seqn = 0; testdata_indx = 0; testdata_size = 40; sdu_size = 40; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, 50); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_LOST_DATA); sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ false, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_START, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 2 Not transferred to ISO-AL ------------------------------------*/ payload_number++; testdata_indx = testdata_size; testdata_size += 10; /* PDU 3 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size = 0; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, 50); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); /* PDU status ISOAL_PDU_STATUS_ERRORS */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_COMPLETE_END, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_ERRORS, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should not be written */ ZASSERT_ISOAL_SDU_WRITE_TEST_CALL_COUNT(1); /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_END, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_LOST_DATA, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ /* PDU count will not have reached 3 as one PDU was not received, so * last_pdu will not be set and the state should remain in Error * Spooling. */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); /* PDU 4 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); payload_number++; seqn++; pdu_timestamp = 9249 + ISO_INT_UNIT_US; sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); testdata_indx = testdata_size; testdata_size += 10; sdu_size = 10; isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ /* Test recombine (White Box) */ /* Detecting the transition from an end fragment to a start fragment * should have triggered the monitoring code to pull the state machine * out of Eroor spooling and directly into the start of a new SDU. As * this was not an end fragment, the next state should be continue. */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 5 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size += 10; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); isoal_test_create_unframed_pdu(PDU_BIS_LLID_COMPLETE_END, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* Should not allocate a new SDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ /* Expecting padding so state should be Error Spooling */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); } /** * Test Suite : RX unframed PDU reassembly * * Tests reassembly of SDUs where valid PDUs are followed by padding */ ZTEST(test_rx_unframed, test_rx_unframed_padding) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint64_t payload_number; uint16_t total_sdu_size; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[43]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ISO_INT_UNIT_US; BN = 4; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 43); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, false, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size = 13; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ false, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 2 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size += 10; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); isoal_test_create_unframed_pdu(PDU_BIS_LLID_COMPLETE_END, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should not be allocated */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ /* Expecting padding PDUs so should be in Error Spool state */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); /* PDU 3 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; /* PDU padding 1 */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* Should not allocate a new SDU */ /* SDU should not be written to */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); /* PDU 4 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; /* PDU padding 2 */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* Should not allocate a new SDU */ /* SDU should not be written to */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX unframed PDU reassembly * * Tests reassembly of SDUs with padding where the end was not seen */ ZTEST(test_rx_unframed, test_rx_unframed_padding_no_end) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint64_t payload_number; uint16_t total_sdu_size; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[33]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ISO_INT_UNIT_US; BN = 3; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 33); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, false, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size = 13; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ false, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 2 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; /* PDU padding 1 */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* Should not allocate a new SDU */ /* SDU should not be written to */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 3 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_ERRORS, ISOAL_SDU_STATUS_ERRORS); /* PDU padding 2 */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should not be allocated */ /* SDU payload should not be written */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_ERRORS, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX unframed PDU reassembly * * Tests reassembly of SDUs where only padding has been received without any * other valid PDUs. */ ZTEST(test_rx_unframed, test_rx_unframed_padding_only) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint64_t payload_number; uint16_t total_sdu_size; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = BT_CONN_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ISO_INT_UNIT_US; BN = 3; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, false, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); seqn = 0; testdata_indx = 0; testdata_size = 0; sdu_size = 0; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ false, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ /* PDU padding 1 */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, NULL, 0, payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* Should not allocate a new SDU */ ZASSERT_ISOAL_SDU_ALLOC_TEST_CALL_COUNT(0); /* SDU should not be written to */ ZASSERT_ISOAL_SDU_WRITE_TEST_CALL_COUNT(0); /* SDU should not be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST_CALL_COUNT(0); /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 2 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; /* PDU padding 2 */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, NULL, 0, payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* Should not allocate a new SDU */ ZASSERT_ISOAL_SDU_ALLOC_TEST_CALL_COUNT(0); /* SDU should not be written to */ ZASSERT_ISOAL_SDU_WRITE_TEST_CALL_COUNT(0); /* SDU should not be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST_CALL_COUNT(0); /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 3 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); /* PDU padding 3 */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, NULL, 0, payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU should not be written to */ ZASSERT_ISOAL_SDU_WRITE_TEST_CALL_COUNT(0); /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_LOST_DATA, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX unframed PDU reassembly * * Tests reassembly of SDUs with padding where the end was not seen where * padding is leads the data (not an expected case). */ ZTEST(test_rx_unframed, test_rx_unframed_padding_leading) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint64_t payload_number; uint16_t total_sdu_size; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[33]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = BT_CONN_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ISO_INT_UNIT_US; BN = 3; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 33); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, false, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); seqn = 0; testdata_indx = 0; testdata_size = 0; sdu_size = 0; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ false, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* Should not allocate a new SDU */ ZASSERT_ISOAL_SDU_ALLOC_TEST_CALL_COUNT(0); /* SDU should not be written to */ ZASSERT_ISOAL_SDU_WRITE_TEST_CALL_COUNT(0); /* SDU should not be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST_CALL_COUNT(0); /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 2 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; /* PDU padding 1 */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* Should not allocate a new SDU */ ZASSERT_ISOAL_SDU_ALLOC_TEST_CALL_COUNT(0); /* SDU should not be written to */ ZASSERT_ISOAL_SDU_WRITE_TEST_CALL_COUNT(0); /* SDU should not be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST_CALL_COUNT(0); /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 3 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_size = 13; sdu_size = 13; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_ERRORS, ISOAL_SDU_STATUS_ERRORS); isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_ERRORS, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX unframed PDU reassembly * * Tests reassembly of a SDU where there is an error in the first PDU followed * by valid padding PDUs */ ZTEST(test_rx_unframed, test_rx_unframed_padding_error1) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint64_t payload_number; uint16_t total_sdu_size; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[13]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ISO_INT_UNIT_US; BN = 3; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 13); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, false, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size = 0; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_ERRORS, ISOAL_SDU_STATUS_ERRORS); sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ false, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_ERRORS, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should not be written */ ZASSERT_ISOAL_SDU_WRITE_TEST_CALL_COUNT(0); /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_ERRORS, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); /* PDU 2 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; /* PDU padding 1 */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* Should not allocate a new SDU */ /* SDU should not be written to */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); /* PDU 3 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; /* PDU padding 2 */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* Should not allocate a new SDU */ /* SDU should not be written to */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX unframed PDU reassembly * * Tests reassembly of a SDU where the second PDU is corrupted and appears to * be a padding PDU */ ZTEST(test_rx_unframed, test_rx_unframed_padding_error2) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint64_t payload_number; uint16_t total_sdu_size; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[13]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ISO_INT_UNIT_US; BN = 3; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 13); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, false, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size = 13; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ false, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 2 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_ERRORS, ISOAL_SDU_STATUS_ERRORS); /* PDU with errors that appears as padding */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_ERRORS, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should not be allocated */ /* SDU payload should not be written */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_ERRORS, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); /* PDU 3 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; /* PDU padding 1 */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* Should not allocate a new SDU */ /* SDU should not be written to */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX unframed PDU reassembly * * Tests reassembly of a SDU where only the padding PDU has errors */ ZTEST(test_rx_unframed, test_rx_unframed_padding_error3) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint64_t payload_number; uint16_t total_sdu_size; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[23]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ISO_INT_UNIT_US; BN = 3; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 23); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, false, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size = 13; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ false, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 2 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size += 10; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); isoal_test_create_unframed_pdu(PDU_BIS_LLID_COMPLETE_END, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should not be allocated */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); /* PDU 3 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; /* PDU padding with errors */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_ERRORS, &rx_pdu_meta_buf.pdu_meta); err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* Should not allocate a new SDU */ /* SDU should not be written to */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX unframed PDU reassembly * * Tests reassembly of a zero length SDU */ ZTEST(test_rx_unframed, test_rx_unframed_zero_len_packet) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint64_t payload_number; uint16_t total_sdu_size; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[13]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ISO_INT_UNIT_US; BN = 1; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 13); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, false, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); seqn = 0; testdata_indx = 0; testdata_size = 0; sdu_size = 0; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ false, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_COMPLETE_END, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should not be written */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX unframed PDU reassembly * * Tests reassembly of SDUs where PDUs are not in sequence followed by a zero * length SDU */ ZTEST(test_rx_unframed, test_rx_unframed_seq_err_zero_length) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint64_t payload_number; uint16_t total_sdu_size; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[43]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ISO_INT_UNIT_US; BN = 3; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 43); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 2000; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, false, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size = 13; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ false, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 2 Not transferred to ISO-AL ------------------------------------*/ payload_number++; testdata_indx = testdata_size; testdata_size += 10; /* PDU 3 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size += 10; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); isoal_test_create_unframed_pdu(PDU_BIS_LLID_COMPLETE_END, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should not be allocated */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_LOST_DATA, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ /* PDU count will not have reached 3 as one PDU was not received, so * last_pdu will not be set and the state should remain in Error * Spooling. */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); /* PDU 4 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); payload_number++; seqn++; pdu_timestamp = 9249 + ISO_INT_UNIT_US; sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); testdata_indx = testdata_size; sdu_size = 0; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); isoal_test_create_unframed_pdu(PDU_BIS_LLID_COMPLETE_END, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should not be written */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ /* Detecting the transition from an end fragment to a start fragment * should have triggered the monitoring code to pull the state machine * out of Eroor spooling and directly into the start of a new SDU. As * this was not a zero length SDU, the next state should be Error * Spooling to dispense with padding PDUs. */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); } /** * Test Suite : RX unframed PDU reassembly * * Tests reassembly of a SDU in two PDUs where the end was not seen and BN is * two which should return to FSM start after reassembly */ ZTEST(test_rx_unframed, test_rx_unframed_dbl_pdu_no_end) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint64_t payload_number; uint16_t total_sdu_size; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[23]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ISO_INT_UNIT_US; BN = 2; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 23); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, false, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size = 13; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ false, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 2 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size += 10; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_ERRORS, ISOAL_SDU_STATUS_ERRORS); isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should not be allocated */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_ERRORS, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX unframed PDU reassembly * * Tests assertion on receiving a PDU with an invalid LLID without errors as * the first PDU of the SDU */ ZTEST(test_rx_unframed, test_rx_unframed_dbl_pdu_invalid_llid1) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint64_t payload_number; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[13]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ISO_INT_UNIT_US; BN = 2; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 13); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, false, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size = 13; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ false, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ /* Invalid LLID - Valid PDU*/ isoal_test_create_unframed_pdu(PDU_BIS_LLID_FRAMED, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Test recombine (Black Box) */ /* expecting an assertion */ ztest_set_assert_valid(true); err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); ztest_set_assert_valid(false); } /** * Test Suite : RX unframed PDU reassembly * * Tests assertion on receiving a PDU with an invalid LLID without errors as * the second PDU of the SDU */ ZTEST(test_rx_unframed, test_rx_unframed_dbl_pdu_invalid_llid2) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint64_t payload_number; uint16_t total_sdu_size; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[23]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ISO_INT_UNIT_US; BN = 2; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 23); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, false, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size = 13; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ false, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 2 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size += 10; /* Invalid LLID - Valid PDU */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_FRAMED, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Test recombine (Black Box) */ /* Expecting an assertion */ ztest_set_assert_valid(true); err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); ztest_set_assert_valid(false); } /** * Test Suite : RX unframed PDU reassembly * * Tests receiving a PDU with an invalid LLID with errors. This should not * result in a assertion as it could happen if a RX reaches it's flush timeout. */ ZTEST(test_rx_unframed, test_rx_unframed_dbl_pdu_invalid_llid2_pdu_err) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint64_t payload_number; uint16_t total_sdu_size; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[23]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ISO_INT_UNIT_US; BN = 2; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 23); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, false, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size = 13; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ false, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_START_CONTINUE, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 2 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_ERRORS, ISOAL_SDU_STATUS_ERRORS); /* Invalid LLID - Valid PDU */ isoal_test_create_unframed_pdu(PDU_BIS_LLID_FRAMED, &testdata[testdata_indx], (testdata_size - testdata_indx), payload_number, pdu_timestamp, ISOAL_PDU_STATUS_ERRORS, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should not be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST_CALL_COUNT(1); /* SDU payload should not be written */ ZASSERT_ISOAL_SDU_WRITE_TEST_CALL_COUNT(1); /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_ERRORS, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX framed PDU recombination * * Tests recombination of a single SDU from a single segmented PDU */ ZTEST(test_rx_framed, test_rx_framed_single_pdu_single_sdu) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint16_t pdu_data_loc[5]; uint64_t payload_number; uint16_t total_sdu_size; uint32_t sdu_timeoffset; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[23]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ((iso_interval_int * ISO_INT_UNIT_US) / 3) + 5; BN = 3; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 23); memset(pdu_data_loc, 0, sizeof(pdu_data_loc)); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, true, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timeoffset = group_sync_delay - 50; sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); seqn = 0; testdata_indx = 0; testdata_size = 23; sdu_size = 23; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ true, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[0] = isoal_test_add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[0]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX framed PDU recombination * * Tests time wrapping recombination of a single SDU from a single segmented PDU */ ZTEST(test_rx_framed, test_rx_framed_single_pdu_single_sdu_ts_wrap1) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint16_t pdu_data_loc[5]; uint64_t payload_number; uint16_t total_sdu_size; uint32_t sdu_timeoffset; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[23]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ((iso_interval_int * ISO_INT_UNIT_US) / 3) + 5; BN = 3; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 23); memset(pdu_data_loc, 0, sizeof(pdu_data_loc)); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; latency = calc_rx_latency_by_role(role, true, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timeoffset = group_sync_delay - 50; pdu_timestamp = ISOAL_TIME_WRAPPING_POINT_US - latency + sdu_timeoffset + 1; sdu_timestamp = 0; seqn = 0; testdata_indx = 0; testdata_size = 23; sdu_size = 23; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ true, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[0] = isoal_test_add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[0]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX framed PDU recombination * * Tests reverse time wrapping in reassembly of a single valid RX PDU into an * SDU. */ ZTEST(test_rx_framed, test_rx_framed_single_pdu_single_sdu_ts_wrap2) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint16_t pdu_data_loc[5]; uint64_t payload_number; uint16_t total_sdu_size; uint32_t sdu_timeoffset; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[23]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_CENTRAL; iso_interval_int = 1; sdu_interval = ((iso_interval_int * ISO_INT_UNIT_US) / 3) + 5; BN = 3; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 23); memset(pdu_data_loc, 0, sizeof(pdu_data_loc)); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; latency = calc_rx_latency_by_role(role, true, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timeoffset = group_sync_delay - 50; pdu_timestamp = (-latency) + sdu_timeoffset - 1; sdu_timestamp = ISOAL_TIME_WRAPPING_POINT_US; seqn = 0; testdata_indx = 0; testdata_size = 23; sdu_size = 23; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ true, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[0] = isoal_test_add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[0]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX framed PDU recombination * * Tests recombination of a single SDU from three segmented PDUs */ ZTEST(test_rx_framed, test_rx_framed_trppl_pdu_single_sdu) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint16_t pdu_data_loc[5]; uint64_t payload_number; uint16_t total_sdu_size; uint32_t sdu_timeoffset; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[33]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ((iso_interval_int * ISO_INT_UNIT_US) / 3) + 5; BN = 3; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 33); memset(pdu_data_loc, 0, sizeof(pdu_data_loc)); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, true, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timeoffset = group_sync_delay - 50; sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size = 13; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ true, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[0] = isoal_test_add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[0]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 2 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size += 10; isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[1] = isoal_test_add_framed_pdu_cont(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should not be allocated */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[1]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 3 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size += 10; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[2] = isoal_test_add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should not be allocated */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[2]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX framed PDU recombination * * Tests recombination of two SDUs from three segmented PDUs */ ZTEST(test_rx_framed, test_rx_framed_trppl_pdu_dbl_sdu) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf[2]; struct isoal_sdu_buffer sdu_buffer[2]; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size[2]; uint8_t iso_interval_int; uint32_t sdu_timestamp[2]; uint16_t pdu_data_loc[5]; uint32_t iso_interval_us; uint64_t payload_number; uint16_t total_sdu_size; uint32_t sdu_timeoffset; uint32_t pdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; isoal_sdu_cnt_t seqn; uint32_t sdu_interval; uint8_t testdata[46]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; iso_interval_us = (iso_interval_int * ISO_INT_UNIT_US); sdu_interval = (iso_interval_us / 3) + 5; BN = 3; FT = 1; stream_sync_delay = iso_interval_us - 200; group_sync_delay = iso_interval_us - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[0]); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[1]); init_test_data_buffer(testdata, 46); memset(pdu_data_loc, 0, sizeof(pdu_data_loc)); sdu_buffer[0].dbuf = &rx_sdu_frag_buf[0]; sdu_buffer[1].dbuf = &rx_sdu_frag_buf[1]; sdu_buffer[0].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; sdu_buffer[1].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, true, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timeoffset = group_sync_delay - 50; sdu_timestamp[0] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size[0] = 13; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ true, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[0] = isoal_test_add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[0]); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf[0], /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[0]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 2 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size[0] += 10; isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[1] = isoal_test_add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, false); sdu_timestamp[1] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); testdata_indx = testdata_size; testdata_size += 13; sdu_size[1] = 13; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size[0], sdu_size[0]); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); pdu_data_loc[2] = isoal_test_add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[1]); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* SDU 1 */ /* A new SDU should not be allocated */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(history[1], &rx_sdu_frag_buf[0], /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[1]], /* PDU payload */ 10); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size[0], /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp[0], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[0].dbuf, /* Buffer */ sdu_buffer[0].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* SDU 2 */ seqn++; /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf[1], /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[2]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 3 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size[1] += 10; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size[1], sdu_size[1]); isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[3] = isoal_test_add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should not be allocated */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf[1], /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[3]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size[1], /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp[1], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[1].dbuf, /* Buffer */ sdu_buffer[1].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX framed PDU recombination * * Tests recombination of a zero length SDU */ ZTEST(test_rx_framed, test_rx_framed_zero_length_sdu) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf[3]; struct isoal_sdu_buffer sdu_buffer[3]; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size[3]; uint8_t iso_interval_int; uint32_t sdu_timestamp[3]; uint16_t pdu_data_loc[5]; uint32_t iso_interval_us; isoal_sdu_cnt_t seqn[3]; uint64_t payload_number; uint16_t total_sdu_size; uint32_t sdu_timeoffset; uint32_t pdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; uint8_t testdata[46]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; iso_interval_us = iso_interval_int * ISO_INT_UNIT_US; sdu_interval = (iso_interval_us / 3) + 5; BN = 3; FT = 1; stream_sync_delay = iso_interval_us - 200; group_sync_delay = iso_interval_us - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[0]); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[1]); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[2]); init_test_data_buffer(testdata, 46); memset(pdu_data_loc, 0, sizeof(pdu_data_loc)); sdu_buffer[0].dbuf = &rx_sdu_frag_buf[0]; sdu_buffer[1].dbuf = &rx_sdu_frag_buf[1]; sdu_buffer[2].dbuf = &rx_sdu_frag_buf[2]; sdu_buffer[0].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; sdu_buffer[1].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; sdu_buffer[2].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, true, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timeoffset = group_sync_delay - 50; sdu_timestamp[0] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); seqn[0] = 0; testdata_indx = 0; testdata_size = 13; sdu_size[0] = 13; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ true, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[0] = isoal_test_add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[0]); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf[0], /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[0]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 2 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size[0] += 10; isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[1] = isoal_test_add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, false); sdu_timestamp[1] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); seqn[1] = seqn[0] + 1; testdata_indx = testdata_size; sdu_size[1] = 0; /* Zero length SDU */ pdu_data_loc[2] = isoal_test_add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, false); sdu_timestamp[2] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); seqn[2] = seqn[1] + 1; testdata_indx = testdata_size; testdata_size += 10; sdu_size[2] = 10; pdu_data_loc[3] = isoal_test_add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[1]); push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[2]); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* SDU 1 */ total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size[0], sdu_size[0]); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); /* A new SDU should not be allocated */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(history[1], &rx_sdu_frag_buf[0], /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[1]], /* PDU payload */ 10); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(history[0], &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size[0], /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp[0], /* Timestamp */ seqn[0], /* Seq. number */ sdu_buffer[0].dbuf, /* Buffer */ sdu_buffer[0].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* SDU 2 */ total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size[1], sdu_size[1]); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(history[1], &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should not be written */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(history[1], &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size[1], /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp[1], /* Timestamp */ seqn[1], /* Seq. number */ sdu_buffer[1].dbuf, /* Buffer */ sdu_buffer[1].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* SDU 3 */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf[2], /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[3]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 3 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size[2] += 10; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size[2], sdu_size[2]); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[3] = isoal_test_add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should not be allocated */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf[2], /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[3]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size[2], /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp[2], /* Timestamp */ seqn[2], /* Seq. number */ sdu_buffer[2].dbuf, /* Buffer */ sdu_buffer[2].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX framed PDU recombination * * Tests recombination of a single SDU from a single segmented PDU followed by * padding */ ZTEST(test_rx_framed, test_rx_framed_dbl_pdu_dbl_sdu_padding) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint16_t pdu_data_loc[5]; uint32_t iso_interval_us; uint64_t payload_number; uint16_t total_sdu_size; uint32_t sdu_timeoffset; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[33]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; iso_interval_us = iso_interval_int * ISO_INT_UNIT_US; sdu_interval = (iso_interval_us / 3) + 5; BN = 3; FT = 1; stream_sync_delay = iso_interval_us - 200; group_sync_delay = iso_interval_us - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 33); memset(pdu_data_loc, 0, sizeof(pdu_data_loc)); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, true, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timeoffset = group_sync_delay - 50; sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size = 13; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ true, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[0] = isoal_test_add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[0]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); /* PDU 2 -------------------------------------------------------------*/ /* Padding PDU */ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); payload_number++; testdata_indx = testdata_size; isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* SDU should not be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST_CALL_COUNT(1); /* SDU should not be written */ ZASSERT_ISOAL_SDU_WRITE_TEST_CALL_COUNT(1); /* SDU should not be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST_CALL_COUNT(1); /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); /* PDU 3 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); payload_number++; sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, false); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); seqn++; testdata_indx = testdata_size; testdata_size += 10; sdu_size = 10; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[1] = isoal_test_add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[1]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX framed PDU recombination * * Tests release of SDUs when receiving only padding PDUs * * Expected Sequence: * -- Total of 3 SDUs released across 2 events * -- Event 1: PDU0 Valid Framed Padding * PDU1 Valid Framed Padding * PDU2 Valid Framed Padding * Event 2: PDU3 Valid SDU 3 Framed Single * -----> SDU 0 Lost (Released) * -----> SDU 1 Lost (Released) * -----> SDU 2 Lost (Released) * -----> SDU 3 Valid (Released) * PDU4 N/A * PDU5 N/A * */ ZTEST(test_rx_framed, test_rx_framed_padding_only) { const uint8_t number_of_pdus = 3; const uint8_t testdata_size_max = 20; struct rx_sdu_frag_buffer rx_sdu_frag_buf[4]; struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct isoal_sdu_buffer sdu_buffer[4]; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint32_t iso_interval_us; uint64_t payload_number; uint16_t total_sdu_size; uint32_t sdu_timeoffset; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint16_t pdu_data_loc; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[testdata_size_max]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = BT_CONN_ROLE_PERIPHERAL; iso_interval_int = 1; iso_interval_us = iso_interval_int * ISO_INT_UNIT_US; sdu_interval = (iso_interval_us / number_of_pdus) + 5; BN = 3; FT = 1; stream_sync_delay = iso_interval_us - 200; group_sync_delay = iso_interval_us - 50; /* PDU 0 -------------------------------------------------------------*/ /* Padding PDU */ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[0]); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[1]); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[2]); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[3]); init_test_data_buffer(testdata, testdata_size_max); pdu_data_loc = 0; sdu_buffer[0].dbuf = &rx_sdu_frag_buf[0]; sdu_buffer[1].dbuf = &rx_sdu_frag_buf[1]; sdu_buffer[2].dbuf = &rx_sdu_frag_buf[2]; sdu_buffer[3].dbuf = &rx_sdu_frag_buf[3]; sdu_buffer[0].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; sdu_buffer[1].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; sdu_buffer[2].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; sdu_buffer[3].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, true, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timeoffset = group_sync_delay - 50; sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - iso_interval_us); seqn = 0; testdata_indx = testdata_size = 0; sdu_size = 0; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ true, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should not be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST_CALL_COUNT(0); /* SDU payload should not be written */ ZASSERT_ISOAL_SDU_WRITE_TEST_CALL_COUNT(0); /* SDU payload should not be emitted */ ZASSERT_ISOAL_SDU_WRITE_TEST_CALL_COUNT(0); /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); /* PDU 1 -------------------------------------------------------------*/ /* Padding PDU */ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* SDU should not be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST_CALL_COUNT(0); /* SDU should not be written */ ZASSERT_ISOAL_SDU_WRITE_TEST_CALL_COUNT(0); /* SDU should not be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST_CALL_COUNT(0); /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); /* PDU 2 -------------------------------------------------------------*/ /* Padding PDU */ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* SDU should not be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST_CALL_COUNT(0); /* SDU should not be written */ ZASSERT_ISOAL_SDU_WRITE_TEST_CALL_COUNT(0); /* SDU should not be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST_CALL_COUNT(0); /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); /* SDU 0 -------------------------------------------------------------*/ /* Missing */ /* SDU 1 -------------------------------------------------------------*/ /* Missing */ sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, false); /* SDU 2 -------------------------------------------------------------*/ /* Missing */ sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, false); /* PDU 3 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; pdu_timestamp += iso_interval_us; testdata_indx = 0; testdata_size = testdata_size_max; sdu_size = testdata_size_max; sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, true); isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc = isoal_test_add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[0]); push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[1]); push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[2]); push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[3]); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 -------------------------------------------------------------*/ total_sdu_size = COLLATED_RX_SDU_INFO(0, 0); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(history[0], &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(history[0], &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ 0, /* Frag size */ ISOAL_SDU_STATUS_LOST_DATA, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[0].dbuf, /* Buffer */ sdu_buffer[0].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* SDU 1 -------------------------------------------------------------*/ seqn++; total_sdu_size = COLLATED_RX_SDU_INFO(0, 0); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); sdu_timestamp += sdu_interval; /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(history[1], &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(history[1], &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ 0, /* Frag size */ ISOAL_SDU_STATUS_LOST_DATA, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[1].dbuf, /* Buffer */ sdu_buffer[1].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* SDU 2 -------------------------------------------------------------*/ seqn++; total_sdu_size = COLLATED_RX_SDU_INFO(0, 0); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); sdu_timestamp += sdu_interval; /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(history[2], &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(history[2], &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ 0, /* Frag size */ ISOAL_SDU_STATUS_LOST_DATA, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[2].dbuf, /* Buffer */ sdu_buffer[2].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* SDU 3 -------------------------------------------------------------*/ seqn++; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf[3], /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[3].dbuf, /* Buffer */ sdu_buffer[3].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX framed PDU recombination * * Tests release of SDUs when receiving only padding PDUs * * Expected Sequence: * -- Total of 3 SDUs released across 2 events * -- Event 1: PDU0 Valid Framed Padding * PDU1 Valid Framed Padding * PDU2 Valid Framed Padding * Event 2: PDU3 Errors SDU 3 Framed Single * -----> SDU 0 Lost (Released) * -----> SDU 1 Lost (Released) * -----> SDU 2 Lost (Released) * -----> SDU 3 Bit Errors (Released) * PDU4 N/A * PDU5 N/A * */ ZTEST(test_rx_framed, test_rx_framed_padding_only_pdu_err) { const uint8_t number_of_pdus = 3; const uint8_t testdata_size_max = 20; struct rx_sdu_frag_buffer rx_sdu_frag_buf[3]; struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct isoal_sdu_buffer sdu_buffer[4]; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint32_t iso_interval_us; uint64_t payload_number; uint16_t total_sdu_size; uint32_t sdu_timeoffset; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint16_t pdu_data_loc; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[testdata_size_max]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = BT_CONN_ROLE_PERIPHERAL; iso_interval_int = 1; iso_interval_us = iso_interval_int * ISO_INT_UNIT_US; sdu_interval = (iso_interval_us / number_of_pdus) + 5; BN = 3; FT = 1; stream_sync_delay = iso_interval_us - 200; group_sync_delay = iso_interval_us - 50; /* PDU 0 -------------------------------------------------------------*/ /* Padding PDU */ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[0]); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[1]); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[2]); init_test_data_buffer(testdata, testdata_size_max); pdu_data_loc = 0; sdu_buffer[0].dbuf = &rx_sdu_frag_buf[0]; sdu_buffer[1].dbuf = &rx_sdu_frag_buf[1]; sdu_buffer[2].dbuf = &rx_sdu_frag_buf[2]; sdu_buffer[3].dbuf = &rx_sdu_frag_buf[2]; sdu_buffer[0].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; sdu_buffer[1].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; sdu_buffer[2].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; sdu_buffer[3].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, true, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timeoffset = group_sync_delay - 50; sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - iso_interval_us); seqn = 0; testdata_indx = testdata_size = 0; sdu_size = 0; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ true, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should not be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST_CALL_COUNT(0); /* SDU payload should not be written */ ZASSERT_ISOAL_SDU_WRITE_TEST_CALL_COUNT(0); /* SDU payload should not be emitted */ ZASSERT_ISOAL_SDU_WRITE_TEST_CALL_COUNT(0); /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); /* PDU 1 -------------------------------------------------------------*/ /* Padding PDU */ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* SDU should not be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST_CALL_COUNT(0); /* SDU should not be written */ ZASSERT_ISOAL_SDU_WRITE_TEST_CALL_COUNT(0); /* SDU should not be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST_CALL_COUNT(0); /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); /* PDU 2 -------------------------------------------------------------*/ /* Padding PDU */ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* SDU should not be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST_CALL_COUNT(0); /* SDU should not be written */ ZASSERT_ISOAL_SDU_WRITE_TEST_CALL_COUNT(0); /* SDU should not be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST_CALL_COUNT(0); /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); /* SDU 0 -------------------------------------------------------------*/ /* Missing */ /* SDU 1 -------------------------------------------------------------*/ /* Missing */ sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, false); /* SDU 2 -------------------------------------------------------------*/ /* Missing */ sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, false); /* PDU 3 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; pdu_timestamp += iso_interval_us; testdata_indx = 0; testdata_size = testdata_size_max; sdu_size = testdata_size_max; sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, true); isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_ERRORS, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc = isoal_test_add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[0]); push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[1]); push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[2]); push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[3]); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 -------------------------------------------------------------*/ total_sdu_size = COLLATED_RX_SDU_INFO(0, 0); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(history[0], &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(history[0], &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ 0, /* Frag size */ ISOAL_SDU_STATUS_LOST_DATA, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[0].dbuf, /* Buffer */ sdu_buffer[0].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* SDU 1 -------------------------------------------------------------*/ seqn++; total_sdu_size = COLLATED_RX_SDU_INFO(0, 0); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); sdu_timestamp += sdu_interval; /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(history[1], &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(history[1], &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ 0, /* Frag size */ ISOAL_SDU_STATUS_LOST_DATA, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[1].dbuf, /* Buffer */ sdu_buffer[1].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* SDU 2 -------------------------------------------------------------*/ seqn++; total_sdu_size = COLLATED_RX_SDU_INFO(0, 0); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); sdu_timestamp += sdu_interval; /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(history[2], &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(history[2], &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ 0, /* Frag size */ ISOAL_SDU_STATUS_LOST_DATA, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[2].dbuf, /* Buffer */ sdu_buffer[2].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* SDU 3 -------------------------------------------------------------*/ seqn++; total_sdu_size = COLLATED_RX_SDU_INFO(0, 0); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_ERRORS, ISOAL_SDU_STATUS_ERRORS); sdu_timestamp += sdu_interval; /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ 0, /* Frag size */ ISOAL_SDU_STATUS_ERRORS, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[3].dbuf, /* Buffer */ sdu_buffer[3].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX framed PDU recombination * * Tests recombination of a single SDU from a single segmented PDU with errors, * followed by a valid PDU */ ZTEST(test_rx_framed, test_rx_framed_dbl_pdu_dbl_sdu_pdu_err1) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint16_t pdu_data_loc[5]; uint32_t iso_interval_us; uint64_t payload_number; uint16_t total_sdu_size; uint32_t sdu_timeoffset; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[33]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; iso_interval_us = iso_interval_int * ISO_INT_UNIT_US; sdu_interval = (iso_interval_us / 3) + 5; BN = 3; FT = 1; stream_sync_delay = iso_interval_us - 200; group_sync_delay = iso_interval_us - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 33); memset(pdu_data_loc, 0, sizeof(pdu_data_loc)); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, true, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timeoffset = group_sync_delay - 50; /* PDU will have errors. Time stamp is only an approximation */ sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - iso_interval_us); seqn = 0; testdata_indx = 0; testdata_size = 23; sdu_size = 0; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_ERRORS, ISOAL_SDU_STATUS_ERRORS); sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ true, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ /* PDU with errors */ isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_ERRORS, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[0] = isoal_test_add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should not be written */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_ERRORS, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); /* PDU 2 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); payload_number++; sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, false); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); seqn++; testdata_indx = testdata_size; testdata_size += 10; sdu_size = 10; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[1] = isoal_test_add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[1]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX framed PDU recombination * * Tests recombination of a single SDU from a single segmented PDU with errors, * followed by a valid PDU */ ZTEST(test_rx_framed, test_rx_framed_dbl_pdu_dbl_sdu_pdu_err2) { const uint8_t test_data_size = 33; const uint8_t max_sdu_burst = 2; struct rx_sdu_frag_buffer rx_sdu_frag_buf[max_sdu_burst]; struct isoal_sdu_buffer sdu_buffer[max_sdu_burst]; isoal_sdu_status_t collated_status[max_sdu_burst]; struct rx_pdu_meta_buffer rx_pdu_meta_buf; isoal_sdu_len_t sdu_size[max_sdu_burst]; uint16_t total_sdu_size[max_sdu_burst]; uint32_t sdu_timestamp[max_sdu_burst]; uint8_t testdata[test_data_size]; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; uint8_t iso_interval_int; uint16_t pdu_data_loc[5]; uint32_t iso_interval_us; uint64_t payload_number; uint32_t sdu_timeoffset; uint32_t pdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; iso_interval_us = iso_interval_int * ISO_INT_UNIT_US; sdu_interval = (iso_interval_us / 3) + 5; BN = 3; FT = 1; stream_sync_delay = iso_interval_us - 200; group_sync_delay = iso_interval_us - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[0]); init_test_data_buffer(testdata, test_data_size); memset(pdu_data_loc, 0, sizeof(pdu_data_loc)); sdu_buffer[0].dbuf = &rx_sdu_frag_buf[0]; sdu_buffer[0].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; sdu_buffer[1].dbuf = &rx_sdu_frag_buf[1]; sdu_buffer[1].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, true, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timeoffset = group_sync_delay - 50; /* PDU will have errors. Time stamp is only an approximation */ sdu_timestamp[0] = (uint32_t)((int64_t)pdu_timestamp + latency - iso_interval_us); seqn = 0; testdata_indx = 0; testdata_size = 23; sdu_size[0] = 0; total_sdu_size[0] = COLLATED_RX_SDU_INFO(sdu_size[0], sdu_size[0]); collated_status[0] = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ true, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ /* PDU with errors */ isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_LOST_DATA, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[0] = isoal_test_add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[0]); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should not be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST_CALL_COUNT(0); /* SDU payload should not be written */ ZASSERT_ISOAL_SDU_WRITE_TEST_CALL_COUNT(0); /* SDU should not be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST_CALL_COUNT(0); /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); /* PDU 2 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[1]); payload_number++; sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, false); sdu_timestamp[1] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); testdata_indx = testdata_size; testdata_size += 10; sdu_size[1] = 10; total_sdu_size[1] = COLLATED_RX_SDU_INFO(sdu_size[1], sdu_size[1]); collated_status[1] = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[1] = isoal_test_add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[1]); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* SDU 0 -------------------------------------------------------------*/ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(history[0], &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should not be written */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(history[0], &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size[0], /* Frag size */ ISOAL_SDU_STATUS_LOST_DATA, /* Frag status */ sdu_timestamp[0], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[0].dbuf, /* Buffer */ sdu_buffer[0].size, /* Buffer size */ total_sdu_size[0], /* Total size */ collated_status[0]); /* SDU status */ /* SDU 1 -------------------------------------------------------------*/ seqn++; /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST_CALL_COUNT(1); ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf[1], /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[1]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size[1], /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp[1], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[1].dbuf, /* Buffer */ sdu_buffer[1].size, /* Buffer size */ total_sdu_size[1], /* Total size */ collated_status[1]); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX framed PDU recombination * * Tests recombination of a single SDU from a single segmented PDU with errors, * mainly focussing on the release of SDUs buffered before the PDU with errors * was received. The first PDU triggers a release of a filled SDU and the * reception of the second PDU is expected to trigger allocation and release of * a new SDU to indicate the error and the status information should be collated * accordingly. */ ZTEST(test_rx_framed, test_rx_framed_dbl_pdu_dbl_sdu_pdu_err3) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint16_t pdu_data_loc[5]; uint64_t payload_number; uint16_t total_sdu_size; uint32_t sdu_timeoffset; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[50]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ((iso_interval_int * ISO_INT_UNIT_US) / 3) + 5; BN = 3; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 50); memset(pdu_data_loc, 0, sizeof(pdu_data_loc)); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = 35; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, true, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timeoffset = group_sync_delay - 50; sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); seqn = 0; testdata_indx = 0; testdata_size = 35; sdu_size = 35; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, 35); collated_status = COLLATED_RX_SDU_INFO(ISOAL_PDU_STATUS_VALID, ISOAL_SDU_STATUS_LOST_DATA); sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ true, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ /* PDU with errors */ isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[0] = isoal_test_add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[0]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_START, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 2 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 15; sdu_size = 0; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, 35); collated_status = COLLATED_RX_SDU_INFO(ISOAL_PDU_STATUS_LOST_DATA, ISOAL_PDU_STATUS_LOST_DATA); isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_LOST_DATA, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[1] = isoal_test_add_framed_pdu_cont(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should not be written */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_END, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_LOST_DATA, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); } /** * Test Suite : RX framed PDU recombination * * Tests recombination of a single SDU from a single segmented PDU with errors, * followed by a valid PDU */ ZTEST(test_rx_framed, test_rx_framed_dbl_pdu_dbl_sdu_seq_err1) { struct rx_sdu_frag_buffer rx_sdu_frag_buf[2]; struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct isoal_sdu_buffer sdu_buffer[2]; isoal_sdu_status_t collated_status[2]; isoal_sink_handle_t sink_hdl; isoal_sdu_len_t sdu_size[2]; uint16_t total_sdu_size[2]; uint32_t stream_sync_delay; uint32_t group_sync_delay; uint32_t sdu_timestamp[2]; uint8_t iso_interval_int; uint16_t pdu_data_loc[5]; uint32_t iso_interval_us; uint64_t payload_number; uint32_t sdu_timeoffset; uint32_t pdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[33]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; iso_interval_us = iso_interval_int * ISO_INT_UNIT_US; sdu_interval = (iso_interval_us / 3) + 5; BN = 3; FT = 1; stream_sync_delay = iso_interval_us - 200; group_sync_delay = iso_interval_us - 50; /* PDU 0 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[0]); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[1]); init_test_data_buffer(testdata, 33); memset(pdu_data_loc, 0, sizeof(pdu_data_loc)); sdu_buffer[0].dbuf = &rx_sdu_frag_buf[0]; sdu_buffer[1].dbuf = &rx_sdu_frag_buf[1]; sdu_buffer[0].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; sdu_buffer[1].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, true, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timeoffset = group_sync_delay - 50; sdu_timestamp[0] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size[0] = 13; total_sdu_size[0] = COLLATED_RX_SDU_INFO(sdu_size[0], sdu_size[0]); collated_status[0] = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ true, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[0] = isoal_test_add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[0]); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf[0], /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[0]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size[0], /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp[0], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[0].dbuf, /* Buffer */ sdu_buffer[0].size, /* Buffer size */ total_sdu_size[0], /* Total size */ collated_status[0]); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); /* PDU 1 -------------------------------------------------------------*/ /* Not transferred to the ISO-AL */ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[0]); payload_number++; sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, false); sdu_timestamp[0] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); testdata_indx = testdata_size; testdata_size += 10; sdu_size[0] = 0; total_sdu_size[0] = COLLATED_RX_SDU_INFO(sdu_size[0], sdu_size[0]); collated_status[0] = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); /* PDU 2 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[1]); payload_number++; sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, false); sdu_timestamp[1] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); testdata_indx = testdata_size; testdata_size += 10; sdu_size[1] = 10; total_sdu_size[1] = COLLATED_RX_SDU_INFO(sdu_size[1], sdu_size[1]); collated_status[1] = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[1] = isoal_test_add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[0]); push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[1]); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* SDU 2 -------------------------------------------------------------*/ seqn++; /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(history[1], &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should not be written */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(history[1], &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size[0], /* Frag size */ ISOAL_SDU_STATUS_LOST_DATA, /* Frag status */ sdu_timestamp[0], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[0].dbuf, /* Buffer */ sdu_buffer[0].size, /* Buffer size */ total_sdu_size[0], /* Total size */ collated_status[0]); /* SDU status */ /* SDU 3 -------------------------------------------------------------*/ seqn++; /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf[1], /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[1]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size[1], /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp[1], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[1].dbuf, /* Buffer */ sdu_buffer[1].size, /* Buffer size */ total_sdu_size[1], /* Total size */ collated_status[1]); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX framed PDU recombination * * Tests recombination of a single SDU from three segmented PDUs with errors */ ZTEST(test_rx_framed, test_rx_framed_trppl_pdu_single_sdu_pdu_err1) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint16_t pdu_data_loc[5]; uint32_t iso_interval_us; uint64_t payload_number; uint16_t total_sdu_size; uint32_t sdu_timeoffset; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[46]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; iso_interval_us = iso_interval_int * ISO_INT_UNIT_US; sdu_interval = iso_interval_us + 5; BN = 3; FT = 1; stream_sync_delay = iso_interval_us - 200; group_sync_delay = iso_interval_us - 50; /* PDU 0 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 46); memset(pdu_data_loc, 0, sizeof(pdu_data_loc)); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, true, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timeoffset = group_sync_delay - 50; sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - iso_interval_us); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size = 0; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_ERRORS, ISOAL_SDU_STATUS_ERRORS); sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ true, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ /* PDU with errors */ isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_ERRORS, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[0] = isoal_test_add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 -------------------------------------------------------------*/ /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should not be written */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_ERRORS, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[1] = isoal_test_add_framed_pdu_cont(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* Should not allocate a new SDU */ /* SDU should not be written to */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); /* PDU 2 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[2] = isoal_test_add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* Should not allocate a new SDU */ /* SDU should not be written to */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); /* PDU 3 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); payload_number++; pdu_timestamp += iso_interval_us; sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, true); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); seqn++; testdata_indx = testdata_size; testdata_size += 13; sdu_size = 13; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[3] = isoal_test_add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 1 -------------------------------------------------------------*/ /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[3]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX framed PDU recombination * * Tests recombination of a single SDU from three segmented PDUs with errors */ ZTEST(test_rx_framed, test_rx_framed_trppl_pdu_single_sdu_pdu_err2) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint16_t pdu_data_loc[5]; uint32_t iso_interval_us; uint64_t payload_number; uint16_t total_sdu_size; uint32_t sdu_timeoffset; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[46]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; iso_interval_us = iso_interval_int * ISO_INT_UNIT_US; sdu_interval = (iso_interval_us / 3) + 5; BN = 3; FT = 1; stream_sync_delay = iso_interval_us - 200; group_sync_delay = iso_interval_us - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 46); memset(pdu_data_loc, 0, sizeof(pdu_data_loc)); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, true, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timeoffset = group_sync_delay - 50; sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size = 13; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ true, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ /* PDU with errors */ isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[0] = isoal_test_add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[0]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 2 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_ERRORS, ISOAL_SDU_STATUS_ERRORS); isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_ERRORS, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[1] = isoal_test_add_framed_pdu_cont(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should not be allocated */ /* SDU payload should not be written */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_ERRORS, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); /* PDU 3 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[2] = isoal_test_add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* Should not allocate a new SDU */ /* SDU should not be written to */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); /* PDU 4 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); payload_number++; sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, false); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); seqn++; testdata_indx = testdata_size; testdata_size += 13; sdu_size = 13; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[3] = isoal_test_add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[3]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX framed PDU recombination * * Tests recombination of a single SDU from three segmented PDUs with errors */ ZTEST(test_rx_framed, test_rx_framed_trppl_pdu_single_sdu_pdu_err3) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint16_t pdu_data_loc[5]; uint32_t iso_interval_us; uint64_t payload_number; uint16_t total_sdu_size; uint32_t sdu_timeoffset; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[46]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; iso_interval_us = iso_interval_int * ISO_INT_UNIT_US; sdu_interval = (iso_interval_us / 3) + 5; BN = 3; FT = 1; stream_sync_delay = iso_interval_us - 200; group_sync_delay = iso_interval_us - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 46); memset(pdu_data_loc, 0, sizeof(pdu_data_loc)); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, true, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timeoffset = group_sync_delay - 50; sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size = 13; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ true, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ /* PDU with errors */ isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[0] = isoal_test_add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[0]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 2 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size += 10; isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[1] = isoal_test_add_framed_pdu_cont(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should not be allocated */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[1]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 3 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_ERRORS, ISOAL_SDU_STATUS_ERRORS); isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_ERRORS, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[2] = isoal_test_add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should not be allocated */ /* SDU payload should not be written */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_ERRORS, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); /* PDU 4 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); payload_number++; sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, false); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); seqn++; testdata_indx = testdata_size; testdata_size += 13; sdu_size = 13; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[3] = isoal_test_add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[3]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX framed PDU recombination * * Tests recombination of a single SDU from three segmented PDUs with errors */ ZTEST(test_rx_framed, test_rx_framed_trppl_pdu_single_sdu_seq_err1) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint16_t pdu_data_loc[5]; uint32_t iso_interval_us; uint64_t payload_number; uint16_t total_sdu_size; uint32_t sdu_timeoffset; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[46]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; iso_interval_us = iso_interval_int * ISO_INT_UNIT_US; sdu_interval = (iso_interval_us / 3) + 5; BN = 3; FT = 1; stream_sync_delay = iso_interval_us - 200; group_sync_delay = iso_interval_us - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 46); memset(pdu_data_loc, 0, sizeof(pdu_data_loc)); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, true, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timeoffset = group_sync_delay - 50; sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size = 13; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ true, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ /* PDU with errors */ isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[0] = isoal_test_add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[0]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 2 -------------------------------------------------------------*/ /* PDU not transferred to the ISO-AL */ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; /* PDU 3 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[2] = isoal_test_add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should not be allocated */ /* SDU payload should not be written */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_LOST_DATA, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); /* PDU 4 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); payload_number++; sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, false); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); seqn++; testdata_indx = testdata_size; testdata_size += 13; sdu_size = 13; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[3] = isoal_test_add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[3]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX framed PDU recombination * * Tests recombination of a single SDU from three segmented PDUs with errors */ ZTEST(test_rx_framed, test_rx_framed_trppl_pdu_single_sdu_pdu_seq_err1) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint16_t pdu_data_loc[5]; uint32_t iso_interval_us; uint64_t payload_number; uint16_t total_sdu_size; uint32_t sdu_timeoffset; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[46]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; iso_interval_us = iso_interval_int * ISO_INT_UNIT_US; sdu_interval = (iso_interval_us / 3) + 5; BN = 3; FT = 1; stream_sync_delay = iso_interval_us - 200; group_sync_delay = iso_interval_us - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 46); memset(pdu_data_loc, 0, sizeof(pdu_data_loc)); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, true, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timeoffset = group_sync_delay - 50; sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size = 13; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ true, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ /* PDU with errors */ isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[0] = isoal_test_add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[0]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 2 -------------------------------------------------------------*/ /* PDU not transferred to the ISO-AL */ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; /* PDU 3 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_ERRORS, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[2] = isoal_test_add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should not be allocated */ /* SDU payload should not be written */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_LOST_DATA, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); /* PDU 4 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); payload_number++; sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, false); sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); seqn++; testdata_indx = testdata_size; testdata_size += 13; sdu_size = 13; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[3] = isoal_test_add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[3]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX framed PDU recombination * * Tests recombination of two SDUs from three segmented PDUs */ ZTEST(test_rx_framed, test_rx_framed_trppl_pdu_dbl_sdu_pdu_err1) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf[2]; struct isoal_sdu_buffer sdu_buffer[2]; isoal_sdu_status_t collated_status[2]; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size[2]; uint16_t total_sdu_size[2]; uint8_t iso_interval_int; uint32_t sdu_timestamp[2]; uint16_t pdu_data_loc[5]; uint32_t iso_interval_us; uint64_t payload_number; uint32_t sdu_timeoffset; uint32_t pdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[63]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; iso_interval_us = iso_interval_int * ISO_INT_UNIT_US; sdu_interval = (iso_interval_us / 3) + 5; BN = 3; FT = 1; stream_sync_delay = iso_interval_us - 200; group_sync_delay = iso_interval_us - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[0]); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[1]); init_test_data_buffer(testdata, 63); memset(pdu_data_loc, 0, sizeof(pdu_data_loc)); sdu_buffer[0].dbuf = &rx_sdu_frag_buf[0]; sdu_buffer[1].dbuf = &rx_sdu_frag_buf[1]; sdu_buffer[0].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; sdu_buffer[1].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, true, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timeoffset = group_sync_delay - 50; /* PDU will have errors. Time stamp is only an approximation */ sdu_timestamp[0] = (uint32_t)((int64_t)pdu_timestamp + latency - iso_interval_us); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size[0] = 0; total_sdu_size[0] = COLLATED_RX_SDU_INFO(sdu_size[0], sdu_size[0]); collated_status[0] = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_ERRORS, ISOAL_SDU_STATUS_ERRORS); sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ true, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ /* PDU with errors */ isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_ERRORS, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[0] = isoal_test_add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[0]); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* SDU 1 -------------------------------------------------------------*/ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should not be written */ ZASSERT_ISOAL_SDU_WRITE_TEST_CALL_COUNT(0); /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size[0], /* Frag size */ ISOAL_SDU_STATUS_ERRORS, /* Frag status */ sdu_timestamp[0], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[0].dbuf, /* Buffer */ sdu_buffer[0].size, /* Buffer size */ total_sdu_size[0], /* Total size */ collated_status[0]); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); /* PDU 2 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size[0] += 10; isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[1] = isoal_test_add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, false); sdu_timestamp[1] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); testdata_indx = testdata_size; testdata_size += 17; sdu_size[1] = 17; pdu_data_loc[2] = isoal_test_add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[1]); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* SDU 1 -------------------------------------------------------------*/ /* SDU payload should not be written */ /* SDU shold not be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST_CALL_COUNT(1); /* SDU 2 -------------------------------------------------------------*/ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf[1], /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[2]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 3 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size[1] += 10; total_sdu_size[1] = COLLATED_RX_SDU_INFO(sdu_size[1], sdu_size[1]); collated_status[1] = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[3] = isoal_test_add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* SDU 2 -------------------------------------------------------------*/ seqn++; /* A new SDU should not be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST_CALL_COUNT(2); /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf[1], /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[3]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size[1], /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp[1], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[1].dbuf, /* Buffer */ sdu_buffer[1].size, /* Buffer size */ total_sdu_size[1], /* Total size */ collated_status[1]); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); /* SDU 3 -------------------------------------------------------------*/ /* Missing */ sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, false); sdu_timestamp[1] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); sdu_size[1] = 0; total_sdu_size[1] = COLLATED_RX_SDU_INFO(sdu_size[1], sdu_size[1]); collated_status[1] = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); /* PDU 4 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[0]); payload_number++; pdu_timestamp = 9249 + iso_interval_us; sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, true); sdu_timestamp[0] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); testdata_indx = testdata_size; testdata_size += 13; sdu_size[0] = 13; total_sdu_size[0] = COLLATED_RX_SDU_INFO(sdu_size[0], sdu_size[0]); collated_status[0] = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[4] = isoal_test_add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[1]); push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[0]); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* SDU 3 -------------------------------------------------------------*/ seqn++; /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(history[2], &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should not be written */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(history[2], &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size[1], /* Frag size */ ISOAL_SDU_STATUS_LOST_DATA, /* Frag status */ sdu_timestamp[1], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[1].dbuf, /* Buffer */ sdu_buffer[1].size, /* Buffer size */ total_sdu_size[1], /* Total size */ collated_status[1]); /* SDU status */ /* SDU 4 -------------------------------------------------------------*/ seqn++; /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf[0], /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[4]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size[0], /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp[0], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[0].dbuf, /* Buffer */ sdu_buffer[0].size, /* Buffer size */ total_sdu_size[0], /* Total size */ collated_status[0]); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX framed PDU recombination * * Tests handling errors in the middle of a stream, where the errors occur * across the end of one SDU and into the start of the next SDU. * * Expected Sequence: * -- Total of 4 SDUs released across 2 events * -- Event 1: PDU0 Valid SDU 0 Framed Start * PDU1 Errors SDU 0 Framed End * SDU 1 Framed Start * -----> SDU 0 Bit Errors (Released) * PDU2 Valid SDU 1 Framed End * Missing SDU 2 * Event 2: PDU3 Valid SDU 3 Framed Single * -----> SDU 1 Lost (Released) * -----> SDU 2 Lost (Released) * -----> SDU 3 Valid (Released) * PDU4 N/A * PDU5 N/A */ ZTEST(test_rx_framed, test_rx_framed_trppl_pdu_dbl_sdu_pdu_err2) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf[3]; struct isoal_sdu_buffer sdu_buffer[3]; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size[2]; uint8_t iso_interval_int; uint32_t sdu_timestamp[3]; uint16_t pdu_data_loc[5]; uint32_t iso_interval_us; uint64_t payload_number; uint16_t total_sdu_size; uint32_t sdu_timeoffset; uint32_t pdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[63]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; iso_interval_us = iso_interval_int * ISO_INT_UNIT_US; sdu_interval = (iso_interval_us / 3) + 5; BN = 3; FT = 1; stream_sync_delay = iso_interval_us - 200; group_sync_delay = iso_interval_us - 50; /* PDU 0 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[0]); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[1]); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[2]); init_test_data_buffer(testdata, 63); memset(pdu_data_loc, 0, sizeof(pdu_data_loc)); sdu_buffer[0].dbuf = &rx_sdu_frag_buf[0]; sdu_buffer[1].dbuf = &rx_sdu_frag_buf[1]; sdu_buffer[2].dbuf = &rx_sdu_frag_buf[2]; sdu_buffer[0].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; sdu_buffer[1].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; sdu_buffer[2].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, true, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timeoffset = group_sync_delay - 50; sdu_timestamp[0] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size[0] = 13; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ true, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[0] = isoal_test_add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[0]); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 -------------------------------------------------------------*/ /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf[0], /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[0]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size[0], sdu_size[0]); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_ERRORS, ISOAL_SDU_STATUS_ERRORS); /* PDU with errors */ isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_ERRORS, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[1] = isoal_test_add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, false); sdu_timestamp[1] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); testdata_indx = testdata_size; testdata_size += 17; sdu_size[1] = 0; pdu_data_loc[2] = isoal_test_add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 -------------------------------------------------------------*/ /* Test recombine (Black Box) */ /* A new SDU should not be allocated */ /* SDU payload should not be written */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size[0], /* Frag size */ ISOAL_SDU_STATUS_ERRORS, /* Frag status */ sdu_timestamp[0], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[0].dbuf, /* Buffer */ sdu_buffer[0].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* SDU 1 -------------------------------------------------------------*/ /* A new SDU should not be allocated */ /* SDU payload should not be written */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); /* PDU 2 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[3] = isoal_test_add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 1 -------------------------------------------------------------*/ /* Test recombine (Black Box) */ /* Should not allocate a new SDU */ /* SDU should not be written to */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); /* SDU 2 -------------------------------------------------------------*/ /* Missing */ sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, false); sdu_timestamp[2] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); /* PDU 4 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[0]); payload_number++; pdu_timestamp = 9249 + (iso_interval_int * ISO_INT_UNIT_US); sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, true); sdu_timestamp[0] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); testdata_indx = testdata_size; testdata_size += 13; sdu_size[0] = 13; isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[4] = isoal_test_add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[1]); push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[2]); push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[0]); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 1 -------------------------------------------------------------*/ seqn++; total_sdu_size = COLLATED_RX_SDU_INFO(0, 0); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(history[1], &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(history[1], &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ 0, /* Frag size */ ISOAL_SDU_STATUS_LOST_DATA, /* Frag status */ sdu_timestamp[1], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[1].dbuf, /* Buffer */ sdu_buffer[1].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* SDU 2 -------------------------------------------------------------*/ seqn++; total_sdu_size = COLLATED_RX_SDU_INFO(0, 0); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(history[2], &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(history[2], &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ 0, /* Frag size */ ISOAL_SDU_STATUS_LOST_DATA, /* Frag status */ sdu_timestamp[2], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[2].dbuf, /* Buffer */ sdu_buffer[2].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* SDU 3 -------------------------------------------------------------*/ seqn++; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size[0], sdu_size[0]); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf[0], /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[4]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size[0], /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp[0], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[0].dbuf, /* Buffer */ sdu_buffer[0].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX framed PDU recombination * * Tests handling errors in the middle of a stream, where the errors occur * at the end of the SDU. * * Expected Sequence: * -- Total of 4 SDUs released across 2 events * -- Event 1: PDU0 Valid SDU 0 Framed Start * PDU1 Valid SDU 0 Framed End * SDU 1 Framed Start * -----> SDU 0 Valid (Released) * PDU2 Errors SDU 1 Framed End * -----> SDU 1 Bit Errors (Released) * Missing SDU 2 * Event 2: PDU3 Valid SDU 3 Framed Single * -----> SDU 2 Lost (Released) * -----> SDU 3 Valid (Released) * PDU4 N/A * PDU5 N/A */ ZTEST(test_rx_framed, test_rx_framed_trppl_pdu_dbl_sdu_pdu_err3) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf[2]; struct isoal_sdu_buffer sdu_buffer[2]; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size[2]; uint8_t iso_interval_int; uint32_t sdu_timestamp[2]; uint16_t pdu_data_loc[5]; uint32_t iso_interval_us; uint64_t payload_number; uint16_t total_sdu_size; uint32_t sdu_timeoffset; uint32_t pdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[63]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; iso_interval_us = iso_interval_int * ISO_INT_UNIT_US; sdu_interval = (iso_interval_us / 3) + 5; BN = 3; FT = 1; stream_sync_delay = iso_interval_us - 200; group_sync_delay = iso_interval_us - 50; /* PDU 0 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[0]); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[1]); init_test_data_buffer(testdata, 63); memset(pdu_data_loc, 0, sizeof(pdu_data_loc)); sdu_buffer[0].dbuf = &rx_sdu_frag_buf[0]; sdu_buffer[1].dbuf = &rx_sdu_frag_buf[1]; sdu_buffer[0].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; sdu_buffer[1].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, true, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timeoffset = group_sync_delay - 50; sdu_timestamp[0] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size[0] = 13; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ true, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[0] = isoal_test_add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[0]); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 -------------------------------------------------------------*/ /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf[0], /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[0]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size[0] += 10; isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[1] = isoal_test_add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, false); sdu_timestamp[1] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); testdata_indx = testdata_size; testdata_size += 17; sdu_size[1] = 17; pdu_data_loc[2] = isoal_test_add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[1]); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 -------------------------------------------------------------*/ /* Test recombine (Black Box) */ total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size[0], sdu_size[0]); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); /* A new SDU should not be allocated */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(history[1], &rx_sdu_frag_buf[0], /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[1]], /* PDU payload */ 10); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size[0], /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp[0], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[0].dbuf, /* Buffer */ sdu_buffer[0].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* SDU 1 -------------------------------------------------------------*/ seqn++; /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(history[1], &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf[1], /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[2]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 2 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; /* SDU size does not change */ total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size[1], sdu_size[1]); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_ERRORS, ISOAL_SDU_STATUS_ERRORS); isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_ERRORS, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[3] = isoal_test_add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 1 -------------------------------------------------------------*/ /* Test recombine (Black Box) */ /* A new SDU should not be allocated */ /* SDU payload should not be written */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size[1], /* Frag size */ ISOAL_SDU_STATUS_ERRORS, /* Frag status */ sdu_timestamp[1], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[1].dbuf, /* Buffer */ sdu_buffer[1].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); /* SDU 2 -------------------------------------------------------------*/ /* Missing */ sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, false); sdu_timestamp[1] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); /* PDU 3 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[0]); payload_number++; pdu_timestamp = 9249 + (iso_interval_int * ISO_INT_UNIT_US); sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, true); sdu_timestamp[0] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); testdata_indx = testdata_size; testdata_size += 13; sdu_size[0] = 13; isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[4] = isoal_test_add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[1]); push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[0]); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 2 -------------------------------------------------------------*/ seqn++; total_sdu_size = COLLATED_RX_SDU_INFO(0, 0); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(history[2], &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should not be written */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(history[2], &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ 0, /* Frag size */ ISOAL_SDU_STATUS_LOST_DATA, /* Frag status */ sdu_timestamp[1], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[1].dbuf, /* Buffer */ sdu_buffer[1].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* SDU 3 -------------------------------------------------------------*/ seqn++; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size[0], sdu_size[0]); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf[0], /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[4]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size[0], /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp[0], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[0].dbuf, /* Buffer */ sdu_buffer[0].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX framed PDU recombination * * Tests handling missing PDU (sequence) errors in the middle of a stream, where * the errors occur across the end of one SDU and into the start of the next * SDU. * * Expected Sequence: * -- Total of 4 SDUs released across 2 events * -- Event 1: PDU0 Valid SDU 0 Framed Start * PDU1 Missing SDU 0 Framed End * SDU 1 Framed Start * -----> SDU 0 Valid (Released) * PDU2 Valid SDU 1 Framed End * Missing SDU 2 * Event 2: PDU3 Valid SDU 3 Framed Single * -----> SDU 1 Lost (Released) * -----> SDU 2 Lost (Released) * -----> SDU 3 Valid (Released) * PDU4 N/A * PDU5 N/A */ ZTEST(test_rx_framed, test_rx_framed_trppl_pdu_dbl_sdu_seq_err1) { struct rx_sdu_frag_buffer rx_sdu_frag_buf[3]; struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct isoal_sdu_buffer sdu_buffer[3]; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; isoal_sdu_len_t sdu_size[2]; uint32_t stream_sync_delay; uint32_t group_sync_delay; uint8_t iso_interval_int; uint32_t sdu_timestamp[3]; uint16_t pdu_data_loc[5]; uint32_t iso_interval_us; uint64_t payload_number; uint16_t total_sdu_size; uint32_t sdu_timeoffset; uint32_t pdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[63]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; iso_interval_us = iso_interval_int * ISO_INT_UNIT_US; sdu_interval = (iso_interval_us / 3) + 5; BN = 3; FT = 1; stream_sync_delay = iso_interval_us - 200; group_sync_delay = iso_interval_us - 50; /* PDU 0 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[0]); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[1]); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[2]); init_test_data_buffer(testdata, 63); memset(pdu_data_loc, 0, sizeof(pdu_data_loc)); sdu_buffer[0].dbuf = &rx_sdu_frag_buf[0]; sdu_buffer[1].dbuf = &rx_sdu_frag_buf[1]; sdu_buffer[2].dbuf = &rx_sdu_frag_buf[2]; sdu_buffer[0].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; sdu_buffer[1].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; sdu_buffer[2].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, true, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timeoffset = group_sync_delay - 50; sdu_timestamp[0] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size[0] = 13; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ true, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[0] = isoal_test_add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[0]); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 -------------------------------------------------------------*/ /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[0]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST_CALL_COUNT(0); /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 2 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; /* No change in SDU 1 size */ /* SDU 1 -------------------------------------------------------------*/ sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, false); sdu_timestamp[1] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); testdata_indx = testdata_size; testdata_size += 17; sdu_size[1] = 0; /* PDU 3 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; /* SDU size does not change */ total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size[0], sdu_size[0]); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[3] = isoal_test_add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 -------------------------------------------------------------*/ /* Test recombine (Black Box) */ /* A new SDU should not be allocated */ ZASSERT_ISOAL_SDU_EMIT_TEST_CALL_COUNT(1); /* SDU payload should not be written */ ZASSERT_ISOAL_SDU_EMIT_TEST_CALL_COUNT(1); /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size[0], /* Frag size */ ISOAL_SDU_STATUS_LOST_DATA, /* Frag status */ sdu_timestamp[0], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[0].dbuf, /* Buffer */ sdu_buffer[0].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* SDU 1 -------------------------------------------------------------*/ /* Lost */ /* SDU 2 -------------------------------------------------------------*/ /* Missing */ sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, false); sdu_timestamp[2] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); /* PDU 4 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[0]); payload_number++; pdu_timestamp = 9249 + (iso_interval_int * ISO_INT_UNIT_US); sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, true); sdu_timestamp[0] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); testdata_indx = testdata_size; testdata_size += 13; sdu_size[0] = 13; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size[0], sdu_size[0]); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[4] = isoal_test_add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[1]); push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[2]); push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[0]); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 1 -------------------------------------------------------------*/ seqn++; total_sdu_size = COLLATED_RX_SDU_INFO(0, 0); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(history[1], &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU should not be written */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(history[1], &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ 0, /* Frag size */ ISOAL_SDU_STATUS_LOST_DATA, /* Frag status */ sdu_timestamp[1], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[1].dbuf, /* Buffer */ sdu_buffer[1].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* SDU 2 -------------------------------------------------------------*/ seqn++; total_sdu_size = COLLATED_RX_SDU_INFO(0, 0); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(history[2], &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU should not be written */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(history[2], &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ 0, /* Frag size */ ISOAL_SDU_STATUS_LOST_DATA, /* Frag status */ sdu_timestamp[2], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[2].dbuf, /* Buffer */ sdu_buffer[2].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* SDU 3 -------------------------------------------------------------*/ seqn++; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size[0], sdu_size[0]); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf[0], /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[4]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size[0], /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp[0], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[0].dbuf, /* Buffer */ sdu_buffer[0].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); } /** * Test Suite : RX framed PDU recombination * * Tests handling missing PDU (sequence) errors followed by bit errors in the * middle of a stream, where the errors occur across the end of one SDU and * into the start of the next SDU. * * Expected Sequence: * -- Total of 4 SDUs released across 2 events * -- Event 1: PDU0 Valid SDU 0 Framed Start * PDU1 Missing SDU 0 Framed End * SDU 1 Framed Start * -----> SDU 0 Lost (Released) * PDU2 Errors SDU 1 Framed End * Missing SDU 2 * Event 2: PDU3 Valid SDU 3 Framed Single * -----> SDU 1 Lost (Released) * -----> SDU 2 Lost (Released) * -----> SDU 3 Valid (Released) * PDU4 N/A * PDU5 N/A */ ZTEST(test_rx_framed, test_rx_framed_trppl_pdu_dbl_sdu_pdu_seq_err1) { struct rx_sdu_frag_buffer rx_sdu_frag_buf[3]; struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct isoal_sdu_buffer sdu_buffer[3]; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size[2]; uint8_t iso_interval_int; uint32_t sdu_timestamp[3]; uint16_t pdu_data_loc[5]; uint32_t iso_interval_us; uint64_t payload_number; uint16_t total_sdu_size; uint32_t sdu_timeoffset; uint32_t pdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[63]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; iso_interval_us = iso_interval_int * ISO_INT_UNIT_US; sdu_interval = (iso_interval_us / 3) + 5; BN = 3; FT = 1; stream_sync_delay = iso_interval_us - 200; group_sync_delay = iso_interval_us - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[0]); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[1]); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[2]); init_test_data_buffer(testdata, 63); memset(pdu_data_loc, 0, sizeof(pdu_data_loc)); sdu_buffer[0].dbuf = &rx_sdu_frag_buf[0]; sdu_buffer[1].dbuf = &rx_sdu_frag_buf[1]; sdu_buffer[2].dbuf = &rx_sdu_frag_buf[2]; sdu_buffer[0].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; sdu_buffer[1].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; sdu_buffer[2].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, true, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timeoffset = group_sync_delay - 50; sdu_timestamp[0] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size[0] = 13; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ true, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[0] = isoal_test_add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[0]); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 -------------------------------------------------------------*/ /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf[0], /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[0]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST_CALL_COUNT(0); /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 2 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; /* No change in SDU 0 size */ /* SDU 1 -------------------------------------------------------------*/ sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, false); sdu_timestamp[1] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); testdata_indx = testdata_size; testdata_size += 17; sdu_size[1] = 0; /* PDU 3 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; /* SDU size does not change */ total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size[0], sdu_size[0]); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_ERRORS, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[3] = isoal_test_add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 -------------------------------------------------------------*/ /* Test recombine (Black Box) */ /* A new SDU should not be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST_CALL_COUNT(1); /* SDU payload should not be written */ ZASSERT_ISOAL_SDU_WRITE_TEST_CALL_COUNT(1); /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size[0], /* Frag size */ ISOAL_SDU_STATUS_LOST_DATA, /* Frag status */ sdu_timestamp[0], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[0].dbuf, /* Buffer */ sdu_buffer[0].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* SDU 1 -------------------------------------------------------------*/ /* Lost */ /* SDU 2 -------------------------------------------------------------*/ /* Missing */ sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, false); sdu_timestamp[2] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); /* PDU 4 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[0]); payload_number++; pdu_timestamp = 9249 + (iso_interval_int * ISO_INT_UNIT_US); sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, true); sdu_timestamp[0] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); testdata_indx = testdata_size; testdata_size += 13; sdu_size[0] = 13; isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[4] = isoal_test_add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[1]); push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[2]); push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[0]); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 1 -------------------------------------------------------------*/ seqn++; total_sdu_size = COLLATED_RX_SDU_INFO(0, 0); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(history[1], &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(history[1], &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ 0, /* Frag size */ ISOAL_SDU_STATUS_LOST_DATA, /* Frag status */ sdu_timestamp[1], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[1].dbuf, /* Buffer */ sdu_buffer[1].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* SDU 2 -------------------------------------------------------------*/ seqn++; total_sdu_size = COLLATED_RX_SDU_INFO(0, 0); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(history[2], &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(history[2], &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ 0, /* Frag size */ ISOAL_SDU_STATUS_LOST_DATA, /* Frag status */ sdu_timestamp[2], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[2].dbuf, /* Buffer */ sdu_buffer[2].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* SDU 3 -------------------------------------------------------------*/ seqn++; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size[0], sdu_size[0]); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[4]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size[0], /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp[0], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[0].dbuf, /* Buffer */ sdu_buffer[0].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX framed PDU recombination * * Tests recombination of a single SDU from a single segmented PDU which is * invalid as it contains multiple segments from the same SDU. */ ZTEST(test_rx_framed, test_rx_framed_single_invalid_pdu_single_sdu) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint16_t pdu_data_loc[5]; uint64_t payload_number; uint16_t total_sdu_size; uint32_t sdu_timeoffset; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[25]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ((iso_interval_int * ISO_INT_UNIT_US) / 3) + 5; BN = 3; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 25); memset(pdu_data_loc, 0, sizeof(pdu_data_loc)); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, true, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timeoffset = group_sync_delay - 50; sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size = 13; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ true, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[0] = isoal_test_add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); testdata_indx = testdata_size; testdata_size += 5; sdu_size += 5; pdu_data_loc[1] = isoal_test_add_framed_pdu_cont(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); testdata_indx = testdata_size; testdata_size += 7; sdu_size += 7; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); pdu_data_loc[2] = isoal_test_add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(history[0], &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[0]], /* PDU payload */ 13); /* Size */ ZASSERT_ISOAL_SDU_WRITE_TEST(history[1], &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[1]], /* PDU payload */ 5); /* Size */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[2]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX framed PDU recombination * * Tests recombination of a single SDU from a single segmented PDU which is * invalid as it contains multiple segments from the same SDU with incorrect * header info */ ZTEST(test_rx_framed, test_rx_framed_single_invalid_pdu_single_sdu_hdr_err) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf; struct isoal_sdu_buffer sdu_buffer; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size; uint8_t iso_interval_int; uint16_t pdu_data_loc[5]; uint64_t payload_number; uint16_t total_sdu_size; uint32_t sdu_timeoffset; uint32_t pdu_timestamp; uint32_t sdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[21]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; sdu_interval = ((iso_interval_int * ISO_INT_UNIT_US) / 3) + 5; BN = 3; FT = 1; stream_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 200; group_sync_delay = (iso_interval_int * ISO_INT_UNIT_US) - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf); init_test_data_buffer(testdata, 21); memset(pdu_data_loc, 0, sizeof(pdu_data_loc)); sdu_buffer.dbuf = &rx_sdu_frag_buf; sdu_buffer.size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, true, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timeoffset = group_sync_delay - 50; sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); seqn = 0; testdata_indx = 0; testdata_size = 3; sdu_size = 3; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ true, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[0] = isoal_test_add_framed_pdu_cont(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); testdata_indx = testdata_size; testdata_size += 4; sdu_size += 4; pdu_data_loc[1] = isoal_test_add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); testdata_indx = testdata_size; testdata_size += 4; sdu_size += 4; pdu_data_loc[2] = isoal_test_add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); testdata_indx = testdata_size; testdata_size += 4; sdu_size += 4; pdu_data_loc[3] = isoal_test_add_framed_pdu_cont(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); testdata_indx = testdata_size; testdata_size += 6; sdu_size += 6; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size, sdu_size); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); pdu_data_loc[4] = isoal_test_add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_ERR_UNSPECIFIED, "err = 0x%02x", err); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(history[0], &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[0]], /* PDU payload */ 3); /* Size */ ZASSERT_ISOAL_SDU_WRITE_TEST(history[1], &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[1]], /* PDU payload */ 4); /* Size */ ZASSERT_ISOAL_SDU_WRITE_TEST(history[2], &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[2]], /* PDU payload */ 4); /* Size */ ZASSERT_ISOAL_SDU_WRITE_TEST(history[3], &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[3]], /* PDU payload */ 4); /* Size */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf, /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[4]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size, /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp, /* Timestamp */ seqn, /* Seq. number */ sdu_buffer.dbuf, /* Buffer */ sdu_buffer.size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX framed PDU recombination * * Tests handling an error in the length of an SDU seqment where the CRC check * does not fail. * * Expected Sequence: * -- Total of 2 SDUs released across 1 event * -- Event 1: PDU0 valid SDU 0 Framed Start (Seg Error) * -----> SDU 0 Lost (Released) * PDU1 Valid SDU 0 Framed End * SDU 1 Framed Start * PDU2 Valid SDU 1 Framed End * -----> SDU 1 Valid (Released) * * Qualification: * IAL/CIS/FRA/PER/BI-01-C * IAL/CIS/FRA/PER/BI-02-C */ ZTEST(test_rx_framed, test_rx_framed_trppl_pdu_dbl_sdu_seg_err1) { struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct rx_sdu_frag_buffer rx_sdu_frag_buf[2]; struct isoal_sdu_buffer sdu_buffer[2]; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; uint32_t stream_sync_delay; uint32_t group_sync_delay; isoal_sdu_len_t sdu_size[2]; uint8_t iso_interval_int; uint32_t sdu_timestamp[2]; uint16_t pdu_data_loc[5]; uint32_t iso_interval_us; isoal_sdu_cnt_t seqn[2]; uint64_t payload_number; uint16_t total_sdu_size; uint32_t sdu_timeoffset; uint32_t pdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; uint8_t testdata[63]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; iso_interval_us = iso_interval_int * ISO_INT_UNIT_US; sdu_interval = (iso_interval_us / 3) + 5; BN = 3; FT = 1; stream_sync_delay = iso_interval_us - 200; group_sync_delay = iso_interval_us - 50; /* PDU 0 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[0]); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[1]); init_test_data_buffer(testdata, 63); memset(pdu_data_loc, 0, sizeof(pdu_data_loc)); sdu_buffer[0].dbuf = &rx_sdu_frag_buf[0]; sdu_buffer[1].dbuf = &rx_sdu_frag_buf[1]; sdu_buffer[0].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; sdu_buffer[1].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, true, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timeoffset = group_sync_delay - 50; sdu_timestamp[0] = (uint32_t)((int64_t)pdu_timestamp + latency - iso_interval_us); seqn[0] = 0; testdata_indx = 0; testdata_size = 13; sdu_size[0] = 0; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size[0], sdu_size[0]); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ true, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ /* PDU with errors */ isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[0] = isoal_test_add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set an invalid length and incomplete header */ rx_pdu_meta_buf.pdu_meta.pdu->len = 3; /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[0]); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 -------------------------------------------------------------*/ /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should not be written */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size[0], /* Frag size */ ISOAL_SDU_STATUS_LOST_DATA, /* Frag status */ sdu_timestamp[0], /* Timestamp */ seqn[0], /* Seq. number */ sdu_buffer[0].dbuf, /* Buffer */ sdu_buffer[0].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size[0] += 10; isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[1] = isoal_test_add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, false); sdu_timestamp[1] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); seqn[1] = seqn[0] + 1; testdata_indx = testdata_size; testdata_size += 17; sdu_size[1] = 17; pdu_data_loc[2] = isoal_test_add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[1]); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 -------------------------------------------------------------*/ /* Test recombine (Black Box) */ /* A new SDU should not be allocated */ /* SDU payload should not be written */ /* SDU should not be emitted */ /* SDU 1 -------------------------------------------------------------*/ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf[1], /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[2]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST_CALL_COUNT(1); /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 2 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size[1] += 10; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size[1], sdu_size[1]); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[3] = isoal_test_add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 1 -------------------------------------------------------------*/ /* Test recombine (Black Box) */ /* A new SDU should not be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST_CALL_COUNT(2); /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf[1], /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[3]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size[1], /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp[1], /* Timestamp */ seqn[1], /* Seq. number */ sdu_buffer[1].dbuf, /* Buffer */ sdu_buffer[1].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); } /** * Test Suite : RX framed PDU recombination * * Tests recombination of two SDUs from three segmented PDUs where there is a * length error in the second SDU's segments that does not cause the CRC to * fail. * * Expected Sequence: * -- Total of 4 SDUs released across 2 event * -- Event 1: PDU0 valid SDU 0 Framed Start * PDU1 Valid SDU 0 Framed End * SDU 1 Framed Start (Seg Error) * -----> SDU 0 Valid (Released) * -----> SDU 1 Lost (Released) * PDU2 Valid SDU 1 Framed End * Missing SDU 2 * -- Event 2: PDU3 valid SDU 3 Framed Single * -----> SDU 2 Lost (Released) * -----> SDU 3 Valid (Released) * PDU4 N/A * PDU5 N/A * * Qualification: * IAL/CIS/FRA/PER/BI-01-C * IAL/CIS/FRA/PER/BI-02-C */ ZTEST(test_rx_framed, test_rx_framed_trppl_pdu_dbl_sdu_seg_err2) { struct rx_sdu_frag_buffer rx_sdu_frag_buf[2]; struct rx_pdu_meta_buffer rx_pdu_meta_buf; struct isoal_sdu_buffer sdu_buffer[2]; isoal_sdu_status_t collated_status; isoal_sink_handle_t sink_hdl; isoal_sdu_len_t sdu_size[2]; uint32_t stream_sync_delay; uint32_t group_sync_delay; uint32_t sdu_timestamp[2]; uint8_t iso_interval_int; uint16_t pdu_data_loc[5]; uint32_t iso_interval_us; uint64_t payload_number; uint16_t total_sdu_size; uint32_t sdu_timeoffset; uint32_t pdu_timestamp; uint16_t testdata_indx; uint16_t testdata_size; uint32_t sdu_interval; isoal_sdu_cnt_t seqn; uint8_t testdata[63]; isoal_status_t err; uint32_t latency; uint8_t role; uint8_t BN; uint8_t FT; /* Settings */ role = ISOAL_ROLE_PERIPHERAL; iso_interval_int = 1; iso_interval_us = iso_interval_int * ISO_INT_UNIT_US; sdu_interval = (iso_interval_us / 3) + 5; BN = 3; FT = 1; stream_sync_delay = iso_interval_us - 200; group_sync_delay = iso_interval_us - 50; /* PDU 1 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[0]); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[1]); init_test_data_buffer(testdata, 63); memset(pdu_data_loc, 0, sizeof(pdu_data_loc)); sdu_buffer[0].dbuf = &rx_sdu_frag_buf[0]; sdu_buffer[1].dbuf = &rx_sdu_frag_buf[1]; sdu_buffer[0].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; sdu_buffer[1].size = TEST_RX_SDU_FRAG_PAYLOAD_MAX; payload_number = 1000 * BN; pdu_timestamp = 9249; latency = calc_rx_latency_by_role(role, true, FT, sdu_interval, iso_interval_int, stream_sync_delay, group_sync_delay); sdu_timeoffset = group_sync_delay - 50; sdu_timestamp[0] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); seqn = 0; testdata_indx = 0; testdata_size = 13; sdu_size[0] = 13; sink_hdl = basic_rx_test_setup(0xADAD, /* Handle */ role, /* Role */ true, /* Framed */ BN, /* BN */ FT, /* FT */ sdu_interval, /* SDU Interval */ iso_interval_int, /* ISO Interval */ stream_sync_delay, /* Stream Sync Delay */ group_sync_delay); /* Group Sync Delay */ isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[0] = isoal_test_add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[0]); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 -------------------------------------------------------------*/ /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf[0], /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[0]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should not be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST_CALL_COUNT(0); /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_CONTINUE, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_CONTINUE)); /* PDU 2 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; sdu_size[0] += 10; isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[1] = isoal_test_add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, false); sdu_timestamp[1] = sdu_timestamp[0] + sdu_interval; testdata_indx = testdata_size; testdata_size += 17; sdu_size[1] = 0; pdu_data_loc[2] = isoal_test_add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set an invalid length */ rx_pdu_meta_buf.pdu_meta.pdu->len -= 5; /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[1]); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 0 -------------------------------------------------------------*/ total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size[0], sdu_size[0]); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); /* Test recombine (Black Box) */ /* A new SDU should not be allocated */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf[0], /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[1]], /* PDU payload */ 10); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(history[0], &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size[0], /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp[0], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[0].dbuf, /* Buffer */ sdu_buffer[0].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* SDU 1 -------------------------------------------------------------*/ seqn++; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size[1], sdu_size[1]); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should not be written */ ZASSERT_ISOAL_SDU_WRITE_TEST_CALL_COUNT(2); /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size[1], /* Frag size */ ISOAL_SDU_STATUS_LOST_DATA, /* Frag status */ sdu_timestamp[1], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[1].dbuf, /* Buffer */ sdu_buffer[1].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); /* PDU 3 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); payload_number++; testdata_indx = testdata_size; testdata_size += 10; /* SDU size does not change */ isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[3] = isoal_test_add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx), &rx_pdu_meta_buf.pdu_meta); err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 2 -------------------------------------------------------------*/ /* Missing */ sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, false); sdu_timestamp[1] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); /* SDU 1 -------------------------------------------------------------*/ /* Test recombine (Black Box) */ /* Should not allocate a new SDU */ ZASSERT_ISOAL_SDU_ALLOC_TEST_CALL_COUNT(2); /* SDU should not be written to */ ZASSERT_ISOAL_SDU_WRITE_TEST_CALL_COUNT(2); /* SDU should not be emitted */ ZASSERT_ISOAL_SDU_WRITE_TEST_CALL_COUNT(2); /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_ERR_SPOOL, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_ERR_SPOOL)); /* PDU 4 -------------------------------------------------------------*/ isoal_test_init_rx_pdu_buffer(&rx_pdu_meta_buf); isoal_test_init_rx_sdu_buffer(&rx_sdu_frag_buf[0]); payload_number++; pdu_timestamp = 9249 + (iso_interval_int * ISO_INT_UNIT_US); sdu_timeoffset = get_next_time_offset(sdu_timeoffset, iso_interval_us, sdu_interval, true); sdu_timestamp[0] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset); testdata_indx = testdata_size; testdata_size += 13; sdu_size[0] = 13; isoal_test_create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID, &rx_pdu_meta_buf.pdu_meta); pdu_data_loc[4] = isoal_test_add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx), sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta); /* Set callback function return values */ push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[1]); push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[0]); sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK; sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK; err = isoal_rx_pdu_recombine(sink_hdl, &rx_pdu_meta_buf.pdu_meta); zassert_equal(err, ISOAL_STATUS_OK, "err = 0x%02x", err); /* SDU 2 -------------------------------------------------------------*/ seqn++; total_sdu_size = COLLATED_RX_SDU_INFO(0, 0); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_LOST_DATA, ISOAL_SDU_STATUS_LOST_DATA); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(history[2], &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(history[2], &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ 0, /* Frag size */ ISOAL_SDU_STATUS_LOST_DATA, /* Frag status */ sdu_timestamp[1], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[1].dbuf, /* Buffer */ sdu_buffer[1].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* SDU 3 -------------------------------------------------------------*/ seqn++; total_sdu_size = COLLATED_RX_SDU_INFO(sdu_size[0], sdu_size[0]); collated_status = COLLATED_RX_SDU_INFO(ISOAL_SDU_STATUS_VALID, ISOAL_SDU_STATUS_VALID); /* Test recombine (Black Box) */ /* A new SDU should be allocated */ ZASSERT_ISOAL_SDU_ALLOC_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ &rx_pdu_meta_buf.pdu_meta); /* PDU */ /* SDU payload should be written */ ZASSERT_ISOAL_SDU_WRITE_TEST(val, &rx_sdu_frag_buf[0], /* SDU buffer */ &rx_pdu_meta_buf.pdu[3 + pdu_data_loc[4]], /* PDU payload */ (testdata_size - testdata_indx)); /* Size */ /* SDU should be emitted */ ZASSERT_ISOAL_SDU_EMIT_TEST(val, &isoal_global.sink_state[sink_hdl], /* Sink */ BT_ISO_SINGLE, /* Frag state */ sdu_size[0], /* Frag size */ ISOAL_SDU_STATUS_VALID, /* Frag status */ sdu_timestamp[0], /* Timestamp */ seqn, /* Seq. number */ sdu_buffer[0].dbuf, /* Buffer */ sdu_buffer[0].size, /* Buffer size */ total_sdu_size, /* Total size */ collated_status); /* SDU status */ /* Test recombine (White Box) */ zassert_equal(isoal_global.sink_state[sink_hdl].sdu_production.fsm, ISOAL_START, "FSM state %s should be %s!", FSM_TO_STR(isoal_global.sink_state[sink_hdl].sdu_production.fsm), FSM_TO_STR(ISOAL_START)); }