/*
 * Copyright (c) 2020 Demant
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 *  Run this test from zephyr directory as:
 *
 *     ./scripts/twister --coverage -p native_posix -v -T tests/bluetooth/ctrl_isoal/
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <zephyr/fff.h>
#include <zephyr/types.h>
#include <zephyr/ztest.h>
#include <zephyr/ztest_error_hook.h>

/* Include the DUT */
#include "ll_sw/isoal.c"

DEFINE_FFF_GLOBALS;

/* #define DEBUG_TEST			(1) */
/* #define DEBUG_TRACE			(1) */

#define TEST_RX_PDU_PAYLAOD_MAX (40)
#define TEST_RX_PDU_SIZE	(TEST_RX_PDU_PAYLAOD_MAX + 2)

#define TEST_RX_SDU_FRAG_PAYLOAD_MAX (100)

#define LLID_TO_STR(llid)                                                                          \
	(llid == PDU_BIS_LLID_COMPLETE_END                                                         \
		 ? "COMPLETE_END"                                                                  \
		 : (llid == PDU_BIS_LLID_START_CONTINUE                                            \
			    ? "START_CONT"                                                         \
			    : (llid == PDU_BIS_LLID_FRAMED                                         \
				       ? "FRAMED"                                                  \
				       : (llid == PDU_BIS_LLID_CTRL ? "CTRL" : "?????"))))

#define DU_ERR_TO_STR(err)                                                                         \
	(err == 1 ? "Bit Errors" : (err == 2 ? "Data Lost" : (err == 0 ? "OK" : "Undefined!")))

#define STATE_TO_STR(s)                                                                            \
	(s == BT_ISO_SINGLE                                                                        \
		 ? "SINGLE"                                                                        \
		 : (s == BT_ISO_START                                                              \
			    ? "START"                                                              \
			    : (s == BT_ISO_CONT ? "CONT" : (s == BT_ISO_END ? "END" : "???"))))

#define ROLE_TO_STR(s)                                                                             \
	(s == BT_ROLE_BROADCAST                                                                    \
		 ? "Broadcast"                                                                     \
		 : (role == BT_CONN_ROLE_PERIPHERAL                                                \
			    ? "Peripheral"                                                         \
			    : (role == BT_CONN_ROLE_CENTRAL ? "Central" : "Undefined")))

#define FSM_TO_STR(s)                                                                              \
	(s == ISOAL_START ? "START"                                                                \
			  : (s == ISOAL_CONTINUE ? "CONTINUE"                                      \
						 : (s == ISOAL_ERR_SPOOL ? "ERR SPOOL" : "???")))

struct rx_pdu_meta_buffer {
	struct isoal_pdu_rx pdu_meta;
	struct node_rx_iso_meta meta;
	uint8_t pdu[TEST_RX_PDU_SIZE];
};

struct rx_sdu_frag_buffer {
	uint16_t write_loc;
	uint8_t sdu[TEST_RX_SDU_FRAG_PAYLOAD_MAX];
};

/**
 * Intializes a RX PDU buffer
 * @param[in] buf Pointer to buffer structure
 */
static void init_rx_pdu_buffer(struct rx_pdu_meta_buffer *buf)
{
	memset(buf, 0, sizeof(struct rx_pdu_meta_buffer));
	buf->pdu_meta.meta = &buf->meta;
	buf->pdu_meta.pdu = (struct pdu_iso *)&buf->pdu[0];
}

/**
 * Initializes a RX SDU buffer
 * @param[in] buf Pointer to buffer structure
 */
static void init_rx_sdu_buffer(struct rx_sdu_frag_buffer *buf)
{
	memset(buf, 0, sizeof(struct rx_sdu_frag_buffer));
}

#if defined(DEBUG_TEST)
/**
 * Print contents of PDU
 * @param[in] pdu_meta Pointer to PDU structure including meta information
 */
static void debug_print_rx_pdu(struct isoal_pdu_rx *pdu_meta)
{
	zassert_not_null(pdu_meta, "");

	PRINT("PDU %04d (%10d) : %12s [%10s] %03d: ", (uint32_t)pdu_meta->meta->payload_number,
	      (uint32_t)pdu_meta->meta->timestamp, LLID_TO_STR(pdu_meta->pdu->ll_id),
	      DU_ERR_TO_STR(pdu_meta->meta->status), pdu_meta->pdu->length);

	for (int i = 0; i < pdu_meta->pdu->length; i++) {
		PRINT("%02x ", pdu_meta->pdu->payload[i]);
	}

	PRINT("\n");
}

/**
 * Print contents of RX SDU
 * @param[in] sink_ctx Sink context provided when SDU is emitted
 * @param[in] buf      SDU data buffer pointer
 */
static void debug_print_rx_sdu(const struct isoal_sink *sink_ctx, uint8_t *buf)
{
	zassert_not_null(sink_ctx, "");
	zassert_not_null(buf, "");

	uint16_t len = sink_ctx->sdu_production.sdu_written;

	PRINT("\n");
	PRINT("SDU %04d (%10d) : %12s [%10s] %03d: ", sink_ctx->sdu_production.sdu.seqn,
	      sink_ctx->sdu_production.sdu.timestamp,
	      STATE_TO_STR(sink_ctx->sdu_production.sdu_state),
	      DU_ERR_TO_STR(sink_ctx->sdu_production.sdu.status), len);
	for (int i = 0; i < len; i++) {
		PRINT("%02x ", buf[i]);
	}
	PRINT("\n");
	PRINT("\n");
}
#else  /* DEBUG_TEST */
static void debug_print_rx_pdu(struct isoal_pdu_rx *pdu_meta) {}
static void debug_print_rx_sdu(const struct isoal_sink *sink_ctx, uint8_t *buf) {}
#endif /* DEBUG_TEST */

#if defined(DEBUG_TRACE)
/**
 * Print function trace
 * @param func   Function name
 * @param status Status
 */
static void debug_trace_func_call(const uint8_t *func, const uint8_t *status)
{
	PRINT("\n");
	PRINT("%s :: %s\n", func, status);
}
#else  /* DEBUG_TRACE */
static void debug_trace_func_call(const uint8_t *func, const uint8_t *status) {}
#endif /* DEBUG_TRACE */

/**
 * Creates an unframed PDU fragment according to provided parameters
 * @param[in]  llid           LLID as Start / Continue or Complete / End
 * @param[in]  dataptr        Test data to fill PDU payload
 * @param[in]  length         Length of PDU payload
 * @param[in]  payload_number Payload number (Meta Information)
 * @param[in]  timestamp      PDU reception Time (Meta Information)
 * @param[in]  status         PDU data validity
 * @param[out] pdu_meta       PDU buffer including meta structure
 */
static void create_unframed_pdu(uint8_t llid, uint8_t *dataptr, uint8_t length,
				uint64_t payload_number, uint32_t timestamp, uint8_t status,
				struct isoal_pdu_rx *pdu_meta)
{
	zassert_not_null(pdu_meta, "");
	zassert_not_null(pdu_meta->meta, "");
	zassert_not_null(pdu_meta->pdu, "");

	memset(pdu_meta->meta, 0, sizeof(*pdu_meta->meta));
	memset(pdu_meta->pdu, 0, sizeof(*pdu_meta->pdu));

	pdu_meta->meta->payload_number = payload_number;
	pdu_meta->meta->timestamp = timestamp;
	pdu_meta->meta->status = status;

	pdu_meta->pdu->ll_id = llid;
	pdu_meta->pdu->length = length;
	memcpy(pdu_meta->pdu->payload, dataptr, length);

	debug_print_rx_pdu(pdu_meta);
}

/**
 * Insert a new segment in the given PDU
 * @param[In]     sc          !Start / Continuation bit
 * @param[In]     cmplt       Complete bit
 * @param[In]     time_offset Time Offset (us)
 * @param[In]     dataptr     Pointer to data to fill in segment
 * @param[In]     length      Length of data
 * @param[In/Out] pdu_meta    PDU structure including meta information
 * @return                    PDU data location index
 */
static uint16_t insert_segment(bool sc, bool cmplt, uint32_t time_offset, uint8_t *dataptr,
			       uint8_t length, struct isoal_pdu_rx *pdu_meta)
{
	struct pdu_iso_sdu_sh seg_hdr;
	uint16_t pdu_payload_size;
	uint8_t hdr_write_size;
	uint16_t pdu_data_loc;

	pdu_payload_size = pdu_meta->pdu->length + length + PDU_ISO_SEG_HDR_SIZE +
			   (sc ? 0 : PDU_ISO_SEG_TIMEOFFSET_SIZE);
	hdr_write_size = PDU_ISO_SEG_HDR_SIZE + (sc ? 0 : PDU_ISO_SEG_TIMEOFFSET_SIZE);
	memset(&seg_hdr, 0, sizeof(seg_hdr));

	zassert_true(pdu_payload_size <= TEST_RX_PDU_PAYLAOD_MAX, "pdu_payload_size (%d)",
		     pdu_payload_size);

	seg_hdr.sc = sc;
	seg_hdr.cmplt = cmplt;
	seg_hdr.length = length + (sc ? 0 : PDU_ISO_SEG_TIMEOFFSET_SIZE);

	if (!sc) {
		seg_hdr.timeoffset = time_offset;
	}

	memcpy(&pdu_meta->pdu->payload[pdu_meta->pdu->length], &seg_hdr, hdr_write_size);
	pdu_meta->pdu->length += hdr_write_size;

	memcpy(&pdu_meta->pdu->payload[pdu_meta->pdu->length], dataptr, length);
	pdu_data_loc = pdu_meta->pdu->length;
	pdu_meta->pdu->length += length;

	debug_print_rx_pdu(pdu_meta);

	return pdu_data_loc;
}

/**
 * Create and fill in base information for a framed PDU
 * @param[In]     payload_number Payload number (Meta Information)
 * @param[In]     timestamp      Adjusted RX time stamp (CIS anchorpoint)
 * @param[In]     status         PDU error status
 * @param[In/Out] pdu_meta       PDU structure including meta information
 */
static void create_framed_pdu_base(uint64_t payload_number, uint32_t timestamp, uint8_t status,
				   struct isoal_pdu_rx *pdu_meta)
{
	zassert_not_null(pdu_meta, "");
	zassert_not_null(pdu_meta->meta, "");
	zassert_not_null(pdu_meta->pdu, "");

	memset(pdu_meta->meta, 0, sizeof(*pdu_meta->meta));
	memset(pdu_meta->pdu, 0, sizeof(*pdu_meta->pdu));

	pdu_meta->meta->payload_number = payload_number;
	pdu_meta->meta->timestamp = timestamp;
	pdu_meta->meta->status = status;

	pdu_meta->pdu->ll_id = PDU_BIS_LLID_FRAMED;
	pdu_meta->pdu->length = 0;

	debug_print_rx_pdu(pdu_meta);
}

/**
 * Adds a single SDU framed segment to the given PDU
 * @param[In]     dataptr     Pointer to data to fill in segment
 * @param[In]     length      Length of data
 * @param[In]     time_offset Time offset
 * @param[In/Out] pdu_meta    PDU structure including meta information
 * @return                    PDU data location index
 */
static uint16_t add_framed_pdu_single(uint8_t *dataptr, uint8_t length, uint32_t time_offset,
				      struct isoal_pdu_rx *pdu_meta)
{
	zassert_not_null(pdu_meta, "");
	zassert_not_null(pdu_meta->meta, "");
	zassert_not_null(pdu_meta->pdu, "");

	return insert_segment(false, true, time_offset, dataptr, length, pdu_meta);
}

/**
 * Adds a starting SDU framed segment to the given PDU
 * @param[In]     dataptr     Pointer to data to fill in segment
 * @param[In]     length      Length of data
 * @param[In]     time_offset Time offset
 * @param[In/Out] pdu_meta    PDU structure including meta information
 * @return                    PDU data location index
 */
static uint16_t add_framed_pdu_start(uint8_t *dataptr, uint8_t length, uint32_t time_offset,
				     struct isoal_pdu_rx *pdu_meta)
{
	zassert_not_null(pdu_meta, "");
	zassert_not_null(pdu_meta->meta, "");
	zassert_not_null(pdu_meta->pdu, "");

	return insert_segment(false, false, time_offset, dataptr, length, pdu_meta);
}

/**
 * Adds a continuation SDU framed segment to the given PDU
 * @param[In]     dataptr     Pointer to data to fill in segment
 * @param[In]     length      Length of data
 * @param[In/Out] pdu_meta    PDU structure including meta information
 * @return                    PDU data location index
 */
static uint16_t add_framed_pdu_cont(uint8_t *dataptr, uint8_t length, struct isoal_pdu_rx *pdu_meta)
{
	zassert_not_null(pdu_meta, "");
	zassert_not_null(pdu_meta->meta, "");
	zassert_not_null(pdu_meta->pdu, "");

	return insert_segment(true, false, 0, dataptr, length, pdu_meta);
}

/**
 * Adds an end SDU framed segment to the given PDU
 * @param[In]     dataptr     Pointer to data to fill in segment
 * @param[In]     length      Length of data
 * @param[In/Out] pdu_meta    PDU structure including meta information
 * @return                    PDU data location index
 */
static uint16_t add_framed_pdu_end(uint8_t *dataptr, uint8_t length, struct isoal_pdu_rx *pdu_meta)
{
	zassert_not_null(pdu_meta, "");
	zassert_not_null(pdu_meta->meta, "");
	zassert_not_null(pdu_meta->pdu, "");

	return insert_segment(true, true, 0, dataptr, length, pdu_meta);
}

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[5];
	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)
{
	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;
}

FAKE_VALUE_FUNC(isoal_status_t, sink_sdu_emit_test, const struct isoal_sink *,
		const struct isoal_sdu_produced *);

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

/**
 * 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_sdu_produced *valid_sdu)
{
	debug_trace_func_call(__func__, "IN");

	debug_print_rx_sdu(sink_ctx, ((struct rx_sdu_frag_buffer *)valid_sdu->contents.dbuf)->sdu);
	sink_sdu_emit_test_handler(*sink_ctx, *valid_sdu);

	return sink_sdu_emit_test_fake.return_val;
}

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)
{
	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;
}

/**
 * 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 * CONN_INT_UNIT_US;

	switch (role) {
	case BT_CONN_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 BT_CONN_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 BT_ROLE_BROADCAST:
		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;
}

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

	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;
}

/**
 * Initialize the given test data buffer with a ramp pattern
 * @param buf  Test data buffer pointer
 * @param size Length of test data
 */
static void init_test_data_buffer(uint8_t *buf, uint16_t size)
{
	zassert_not_null(buf, "");

	for (uint16_t i = 0; i < size; i++) {
		buf[i] = (uint8_t)(i & 0x00FF);
	}
}

/**
 * Test Suite	:	RX basic test
 *
 * Test creating and destroying sinks upto the maximum with randomized
 * configuration parameters.
 */
ZTEST(test_rx_basics, test_sink_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 * CONN_INT_UNIT_US;
		sdu_interval = sdu_interval_int * CONN_INT_UNIT_US;
		stream_sync_delay = iso_interval - 200;
		group_sync_delay = iso_interval - 50;
		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 BT_CONN_ROLE_PERIPHERAL:
			case BT_CONN_ROLE_CENTRAL:
			case BT_ROLE_BROADCAST:
				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.latency_framed,
					latency, "%s latency framed %d should be %d",
					ROLE_TO_STR(role),
					isoal_global.sink_state[sink_hdl[i]].session.latency_framed,
					latency);
			} else {
				zassert_equal(isoal_global.sink_state[sink_hdl[i]]
						      .session.latency_unframed,
					      latency, "%s latency unframed %d should be %d",
					      ROLE_TO_STR(role),
					      isoal_global.sink_state[sink_hdl[i]]
						      .session.latency_unframed,
					      latency);
			}

			zassert_equal(res, ISOAL_STATUS_OK, "Sink %d in role %s creation 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 * CONN_INT_UNIT_US) - (framed ? 100 : 0);
			iso_interval = iso_interval_int * CONN_INT_UNIT_US;
			stream_sync_delay = iso_interval - (200 * i);
			group_sync_delay = iso_interval - 50;
		}

		/* Destroy in order */
		for (int i = 0; i < CONFIG_BT_CTLR_ISOAL_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_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 = BT_CONN_ROLE_PERIPHERAL;
	burst_number = 1;
	flush_timeout = 1;
	framed = false;
	iso_interval_int = 1;
	sdu_interval = CONN_INT_UNIT_US;
	stream_sync_delay = CONN_INT_UNIT_US - 200;
	group_sync_delay = CONN_INT_UNIT_US - 50;

	res = isoal_init();
	zassert_equal(res, ISOAL_STATUS_OK, "res=0x%02x", res);

	res = isoal_reset();
	zassert_equal(res, ISOAL_STATUS_OK, "res=0x%02x", res);

	for (int i = 0; i < CONFIG_BT_CTLR_ISOAL_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 assertion when attempting to retrieve sink params for an invalid sink
 * handle.
 */
ZTEST(test_rx_basics, test_sink_invalid_ref)
{
	ztest_set_assert_valid(true);

	isoal_get_sink_param_ref(99);

	ztest_set_assert_valid(false);
}

/**
 * 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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = CONN_INT_UNIT_US;
	BN = 1;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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;
	latency = 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 = 1;
	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 */
	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.
 */
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_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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = CONN_INT_UNIT_US;
	BN = 1;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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;
	latency = 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 = 1;
	testdata_indx = 0;
	testdata_size = 23;
	sdu_size = 23;

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

	/* SDU should be emitted as it is complete */
	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 (White Box) */
	/* No padding PDUs expected, so 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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);

	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);
}

/**
 * Test Suite	:	RX unframed PDU reassembly
 *
 * Tests reassembly of two valid RX PDU into a single SDU.
 */
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_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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = CONN_INT_UNIT_US;
	BN = 2;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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 = 1;
	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 */
	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);

	/* Test recombine (Black Box) */
	sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK;
	push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer);

	sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK;

	/* 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 recombine (White Box) */
	/* Next state should wait for continuation or end */
	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));
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* PDU 2 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size += 10;

	/* Send PDU with end fragment  */
	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 */

	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);
}

/**
 * Test Suite	:	RX unframed PDU reassembly
 *
 * Tests reassembly of three SDUs where the end of the first two were not seen
 */
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_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[53];
	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 = CONN_INT_UNIT_US / 2;
	BN = 4;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* SDU 1 - PDU 1 -----------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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 = 1;
	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 */

	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);

	/* Test recombine (Black Box) */
	sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK;
	push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer);
	sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK;

	/* 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 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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);

	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* SDU 1 - PDU 2 -----------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size += 10;

	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);

	/* Test recombine (Black Box) */
	/* Should not allocate a new SDU */

	sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK;

	/* SDU emitted with errors as end fragment was not seen */
	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 (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));
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_ERRORS, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);

	/* SDU 2 - PDU 3 -----------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	init_rx_sdu_buffer(&rx_sdu_frag_buf);
	payload_number++;
	seqn++;
	pdu_timestamp += 200;
	sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency);
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size = 10;

	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);

	/* Test recombine (Black Box) */
	sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK;
	push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer);

	sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK;

	/* 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 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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* SDU 2 - PDU 4 */
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size += 10;

	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);

	/* Test recombine (Black Box) */
	/* Should not allocate a new SDU */

	sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK;

	/* SDU emitted with errors as end fragment was not seen */
	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 (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));
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_ERRORS, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);

	/* SDU 3 - PDU 5 -----------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	init_rx_sdu_buffer(&rx_sdu_frag_buf);
	payload_number++;
	seqn++;
	pdu_timestamp = 9249 + CONN_INT_UNIT_US;
	sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency);
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size = 10;

	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) */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);
}

/**
 * Test Suite	:	RX unframed PDU reassembly
 *
 * Tests reassembly of one SDUs in five fragments
 */
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_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[53];
	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 = CONN_INT_UNIT_US;
	BN = 5;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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 = 1;
	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 */

	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);

	/* Test recombine (Black Box) */
	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;

	/* 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 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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* PDU 2 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size += 10;

	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);

	/* Test recombine (Black Box) */
	/* Should not allocate a new SDU */

	sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK;

	/* 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 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));
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* PDU 3 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size += 10;

	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);

	/* Test recombine (Black Box) */
	/* Should not allocate a new SDU */

	sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK;

	/* 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 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));
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* PDU 4 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size += 10;

	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);

	/* Test recombine (Black Box) */
	/* Should not allocate a new SDU */

	sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK;

	/* 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 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));
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* PDU 5 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size += 10;

	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 */

	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 (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));
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);
}

/**
 * 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_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[40];
	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 = CONN_INT_UNIT_US;
	BN = 1;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	init_rx_sdu_buffer(&rx_sdu_frag_buf);
	init_test_data_buffer(testdata, 40);
	sdu_buffer.dbuf = &rx_sdu_frag_buf;
	sdu_buffer.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 = 1;
	testdata_indx = 0;
	testdata_size = 40;
	sdu_size = 20;

	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 */

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

	/* SDU 2 */
	init_rx_sdu_buffer(&rx_sdu_frag_buf);
	sdu_size = 20;

	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_history[0], NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_history[0], NULL);
	zassert_equal(20, sink_sdu_write_test_fake.arg2_history[0], NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_history[1], NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + 20], sink_sdu_write_test_fake.arg1_history[1],
			  NULL);
	zassert_equal(20, sink_sdu_write_test_fake.arg2_history[1], NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl],
			  sink_sdu_emit_test_fake.arg0_history[0], NULL);
	zassert_equal(BT_ISO_START,
		      sink_sdu_emit_test_handler_fake.arg0_history[0].sdu_production.sdu_state,
		      NULL);
	zassert_equal(sdu_size,
		      sink_sdu_emit_test_handler_fake.arg0_history[0].sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID,
		      sink_sdu_emit_test_handler_fake.arg1_history[0].status, NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_history[0].timestamp,
		      NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_history[0].seqn, NULL);
	zassert_equal(sdu_buffer.dbuf,
		      sink_sdu_emit_test_handler_fake.arg1_history[0].contents.dbuf, NULL);
	zassert_equal(sdu_buffer.size,
		      sink_sdu_emit_test_handler_fake.arg1_history[0].contents.size, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl],
			  sink_sdu_emit_test_fake.arg0_history[1], NULL);
	zassert_equal(BT_ISO_END,
		      sink_sdu_emit_test_handler_fake.arg0_history[1].sdu_production.sdu_state,
		      NULL);
	zassert_equal(sdu_size,
		      sink_sdu_emit_test_handler_fake.arg0_history[1].sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID,
		      sink_sdu_emit_test_handler_fake.arg1_history[1].status, NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_history[1].timestamp,
		      NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_history[1].seqn, NULL);
	zassert_equal(sdu_buffer.dbuf,
		      sink_sdu_emit_test_handler_fake.arg1_history[1].contents.dbuf, NULL);
	zassert_equal(sdu_buffer.size,
		      sink_sdu_emit_test_handler_fake.arg1_history[1].contents.size, NULL);
}

/**
 * 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_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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = CONN_INT_UNIT_US;
	BN = 1;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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 = 1;
	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 */

	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);

	/* Test recombine (Black Box) */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_ERRORS, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);

	/* PDU 2 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	init_rx_sdu_buffer(&rx_sdu_frag_buf);
	payload_number++;
	seqn++;
	pdu_timestamp += 200;
	sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency);
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size = 10;

	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) */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);
}

/**
 * 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_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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = CONN_INT_UNIT_US;
	BN = 1;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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 = 1;
	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 */

	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);

	/* Test recombine (Black Box) */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_ERRORS, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);

	/* PDU 2 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	init_rx_sdu_buffer(&rx_sdu_frag_buf);
	payload_number++;
	seqn++;
	pdu_timestamp = 9249 + CONN_INT_UNIT_US;
	sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency);
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size = 10;

	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);

	/* Test recombine (Black Box) */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_LOST_DATA, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);
}

/**
 * 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_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[43];
	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 = CONN_INT_UNIT_US;
	BN = 3;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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 = 1;
	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 */

	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);

	/* Test recombine (Black Box) */
	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;

	/* 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 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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* PDU 2 Not transferred to ISO-AL ------------------------------------*/
	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;

	/* PDU 3 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size += 10;

	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 */

	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 (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));
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_LOST_DATA, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);

	/* PDU 4 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	init_rx_sdu_buffer(&rx_sdu_frag_buf);
	payload_number++;
	seqn++;
	pdu_timestamp = 9249 + CONN_INT_UNIT_US;
	sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency);
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size = 10;

	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);

	/* Test recombine (Black Box) */
	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;

	/* 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 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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);
}

/**
 * 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_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_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[43];
	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 = CONN_INT_UNIT_US;
	BN = 3;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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 = 1;
	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 */

	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);

	/* Test recombine (Black Box) */
	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;

	/* 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 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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* PDU 2 Not transferred to ISO-AL ------------------------------------*/
	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;

	/* PDU 3 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size += 10;

	/* PDU status ISOAL_PDU_STATUS_ERRORS */
	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);

	/* Test recombine (Black Box) */
	/* Should not allocate a new SDU */

	sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK;

	/* Lost data should be higher priority */
	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 (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));
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_LOST_DATA, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);

	/* PDU 4 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	init_rx_sdu_buffer(&rx_sdu_frag_buf);
	payload_number++;
	seqn++;
	pdu_timestamp = 9249 + CONN_INT_UNIT_US;
	sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency);
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size = 10;

	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);

	/* Test recombine (Black Box) */
	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;

	/* 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 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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* PDU 5 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size += 10;

	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 */

	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 (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));
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);
}

/**
 * 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_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[43];
	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 = CONN_INT_UNIT_US;
	BN = 4;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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 = 1;
	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 */

	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);

	/* Test recombine (Black Box) */
	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;

	/* 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 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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* PDU 2 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size += 10;

	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 */

	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 (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));
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);

	/* PDU 3 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;

	/* PDU padding 1 */
	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);

	/* 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 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 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	payload_number++;
	pdu_timestamp += 200;

	/* PDU padding 2 */
	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);

	/* 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 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_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[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 = CONN_INT_UNIT_US;
	BN = 3;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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 = 1;
	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 */

	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);

	/* Test recombine (Black Box) */
	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;

	/* 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 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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* PDU 2 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;

	/* PDU padding 1 */
	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);

	/* 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 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 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	payload_number++;
	pdu_timestamp += 200;

	/* PDU padding 2 */
	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);

	/* Test recombine (Black Box) */
	/* Should not allocate a new SDU */

	/* SDU should not be written to */

	/* SDU emitted with errors as end fragment was not seen */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_ERRORS, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);
}

/**
 * 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_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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = CONN_INT_UNIT_US;
	BN = 3;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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 = 1;
	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 */

	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);

	/* Test recombine (Black Box) */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_ERRORS, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);

	/* PDU 2 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;

	/* PDU padding 1 */
	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);

	/* 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 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 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	payload_number++;
	pdu_timestamp += 200;

	/* PDU padding 2 */
	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);

	/* 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 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_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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = CONN_INT_UNIT_US;
	BN = 3;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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 = 1;
	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 */

	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);

	/* Test recombine (Black Box) */
	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;

	/* 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 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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* PDU 2 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;

	/* PDU with errors that appears as padding */
	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);

	/* Test recombine (Black Box) */
	/* Should not allocate a new SDU */

	/* SDU should not be written to */
	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 (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));

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_ERRORS, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);

	/* PDU 3 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	payload_number++;
	pdu_timestamp += 200;

	/* PDU padding 1 */
	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);

	/* 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 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_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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = CONN_INT_UNIT_US;
	BN = 3;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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 = 1;
	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 */

	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);

	/* Test recombine (Black Box) */
	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;

	/* 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 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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* PDU 2 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size += 10;

	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 */

	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 (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));
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);

	/* PDU 3 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;

	/* PDU padding with errors */
	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);

	/* 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 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_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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = CONN_INT_UNIT_US;
	BN = 1;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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 = 1;
	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 */

	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) */
	push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer);
	sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK;

	/* SDU should not be written to */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);
}

/**
 * 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_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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = CONN_INT_UNIT_US;
	BN = 2;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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 = 1;
	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 */

	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);

	/* Test recombine (Black Box) */
	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;

	/* 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 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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* PDU 2 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size += 10;

	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);

	/* Test recombine (Black Box) */
	/* Should not allocate a new SDU */

	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 (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));
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_ERRORS, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);
}

/**
 * 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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = CONN_INT_UNIT_US;
	BN = 2;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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 = 1;
	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*/
	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_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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = CONN_INT_UNIT_US;
	BN = 2;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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 = 1;
	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 */

	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);

	/* Test recombine (Black Box) */
	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;

	/* 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 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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* PDU 2 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size += 10;

	/* Invalid LLID - Valid PDU */
	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_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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = CONN_INT_UNIT_US;
	BN = 2;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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 = 1;
	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 */

	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);

	/* Test recombine (Black Box) */
	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;

	/* 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 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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* PDU 2 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size += 10;

	/* Invalid LLID - Valid PDU */
	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);

	/* Test recombine (Black Box) */
	/* Should not allocate a new SDU */

	sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK;

	/* SDU emitted with errors */
	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 (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));
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2], sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_ERRORS, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);
}

/**
 * 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_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;
	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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = ((iso_interval_int * CONN_INT_UNIT_US) / 3) + 5;
	BN = 3;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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 = 1;
	testdata_indx = 0;
	testdata_size = 23;
	sdu_size = 23;

	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 */

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[0] =
		add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx),
				      sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[0]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);
}

/**
 * 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_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;
	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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = ((iso_interval_int * CONN_INT_UNIT_US) / 3) + 5;
	BN = 3;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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 = 1;
	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 */

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[0] =
		add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx),
				     sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	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;

	/* 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 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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[0]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* PDU 2 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);

	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size += 10;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[1] =
		add_framed_pdu_cont(&testdata[testdata_indx], (testdata_size - testdata_indx),
				    &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	/* Should not allocate a new SDU */

	sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK;

	/* 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 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));
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[1]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* PDU 3 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);

	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size += 10;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[2] =
		add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx),
				   &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	/* Should not allocate a new SDU */

	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 (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));
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[2]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);
}

/**
 * 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_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];
	isoal_sdu_cnt_t seqn[2];
	uint64_t payload_number;
	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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = ((iso_interval_int * CONN_INT_UNIT_US) / 3) + 5;
	BN = 3;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	init_rx_sdu_buffer(&rx_sdu_frag_buf[0]);
	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] = 1;
	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 */

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[0] =
		add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx),
				     sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	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;

	/* 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 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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf[0], sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[0]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* PDU 2 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);

	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size[0] += 10;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[1] =
		add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx),
				   &rx_pdu_meta_buf.pdu_meta);

	sdu_timeoffset =
		sdu_timeoffset - sdu_interval > 0
			? sdu_timeoffset - sdu_interval
			: sdu_timeoffset + (iso_interval_int * CONN_INT_UNIT_US) - sdu_interval;
	sdu_timestamp[1] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset);
	seqn[1] = seqn[0] + 1;
	testdata_indx = testdata_size;
	testdata_size += 13;
	sdu_size[1] = 13;

	pdu_data_loc[2] =
		add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx),
				     sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	/* SDU 1 */
	sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK;
	sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK;

	/* SDU 2 */
	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;

	/* SDU 2 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 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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf[0], sink_sdu_write_test_fake.arg0_history[1], NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[1]],
			  sink_sdu_write_test_fake.arg1_history[1], NULL);
	zassert_equal(10, sink_sdu_write_test_fake.arg2_history[1], NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf[1], sink_sdu_write_test_fake.arg0_history[2], NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[2]],
			  sink_sdu_write_test_fake.arg1_history[2], NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_history[2],
		      NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size[0],
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written, NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp[0], sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn[0], sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer[0].dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer[0].size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);

	/* PDU 3 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);

	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size[1] += 10;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[3] =
		add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx),
				   &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	/* Should not allocate a new SDU */

	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 (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));
	zassert_equal_ptr(&rx_sdu_frag_buf[1], sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[3]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size[1],
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written, NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp[1], sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn[1], sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer[1].dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer[1].size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);
}

/**
 * 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_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];
	isoal_sdu_cnt_t seqn[3];
	uint64_t payload_number;
	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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = ((iso_interval_int * CONN_INT_UNIT_US) / 3) + 5;
	BN = 3;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	init_rx_sdu_buffer(&rx_sdu_frag_buf[0]);
	init_rx_sdu_buffer(&rx_sdu_frag_buf[1]);
	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] = 1;
	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 */

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[0] =
		add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx),
				     sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	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;

	/* 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 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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf[0], sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[0]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* PDU 2 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);

	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size[0] += 10;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[1] =
		add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx),
				   &rx_pdu_meta_buf.pdu_meta);

	sdu_timeoffset =
		sdu_timeoffset - sdu_interval > 0
			? sdu_timeoffset - sdu_interval
			: sdu_timeoffset + (iso_interval_int * CONN_INT_UNIT_US) - sdu_interval;
	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] =
		add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx),
				      sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	sdu_timeoffset =
		sdu_timeoffset - sdu_interval > 0
			? sdu_timeoffset - sdu_interval
			: sdu_timeoffset + (iso_interval_int * CONN_INT_UNIT_US) - sdu_interval;
	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] =
		add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx),
				     sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	/* SDU 1 */
	sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK;
	sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK;

	/* SDU 2 */
	/* Zero length SDU */
	push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[1]);
	sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK;

	/* SDU should not be written to */

	sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK;

	/* SDU 3 */
	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;

	/* SDU 2 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 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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf[0], sink_sdu_write_test_fake.arg0_history[1], NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[1]],
			  sink_sdu_write_test_fake.arg1_history[1], NULL);
	zassert_equal(10, sink_sdu_write_test_fake.arg2_history[1], NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf[2], sink_sdu_write_test_fake.arg0_history[2], NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[3]],
			  sink_sdu_write_test_fake.arg1_history[2], NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_history[2],
		      NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl],
			  sink_sdu_emit_test_fake.arg0_history[0], NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_history[0].sdu_production.sdu_state,
		      NULL);
	zassert_equal(sdu_size[0],
		      sink_sdu_emit_test_handler_fake.arg0_history[0].sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID,
		      sink_sdu_emit_test_handler_fake.arg1_history[0].status, NULL);
	zassert_equal(sdu_timestamp[0], sink_sdu_emit_test_handler_fake.arg1_history[0].timestamp,
		      NULL);
	zassert_equal(seqn[0], sink_sdu_emit_test_handler_fake.arg1_history[0].seqn, NULL);
	zassert_equal(sdu_buffer[0].dbuf,
		      sink_sdu_emit_test_handler_fake.arg1_history[0].contents.dbuf, NULL);
	zassert_equal(sdu_buffer[0].size,
		      sink_sdu_emit_test_handler_fake.arg1_history[0].contents.size, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl],
			  sink_sdu_emit_test_fake.arg0_history[1], NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_history[1].sdu_production.sdu_state,
		      NULL);
	zassert_equal(sdu_size[1],
		      sink_sdu_emit_test_handler_fake.arg0_history[1].sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID,
		      sink_sdu_emit_test_handler_fake.arg1_history[1].status, NULL);
	zassert_equal(sdu_timestamp[1], sink_sdu_emit_test_handler_fake.arg1_history[1].timestamp,
		      NULL);
	zassert_equal(seqn[1], sink_sdu_emit_test_handler_fake.arg1_history[1].seqn, NULL);
	zassert_equal(sdu_buffer[1].dbuf,
		      sink_sdu_emit_test_handler_fake.arg1_history[1].contents.dbuf, NULL);
	zassert_equal(sdu_buffer[1].size,
		      sink_sdu_emit_test_handler_fake.arg1_history[1].contents.size, NULL);

	/* PDU 3 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);

	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size[2] += 10;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[3] =
		add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx),
				   &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	/* Should not allocate a new SDU */

	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 (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));
	zassert_equal_ptr(&rx_sdu_frag_buf[2], sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[3]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size[2],
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written, NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp[2], sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn[2], sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer[2].dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer[2].size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);
}

/**
 * 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_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;
	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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = ((iso_interval_int * CONN_INT_UNIT_US) / 3) + 5;
	BN = 3;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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 = 1;
	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 */

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[0] =
		add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx),
				      sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[0]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);

	/* PDU 2 -------------------------------------------------------------*/
	/* Padding PDU */
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	init_rx_sdu_buffer(&rx_sdu_frag_buf);

	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	/* SDU should not be allocated */

	/* SDU should not be written */

	/* 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 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 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	init_rx_sdu_buffer(&rx_sdu_frag_buf);

	payload_number++;
	pdu_timestamp += 200;

	sdu_timeoffset =
		sdu_timeoffset - sdu_interval > 0
			? sdu_timeoffset - sdu_interval
			: sdu_timeoffset + (iso_interval_int * CONN_INT_UNIT_US) - sdu_interval;
	sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset);
	seqn++;
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size = 10;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[1] =
		add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx),
				      sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[1]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);
}

/**
 * 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_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;
	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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = ((iso_interval_int * CONN_INT_UNIT_US) / 3) + 5;
	BN = 3;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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 = 0;
	seqn = 1;
	testdata_indx = 0;
	testdata_size = 23;
	sdu_size = 0;

	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 */
	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_ERRORS,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[0] =
		add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx),
				      sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer);
	sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK;

	/* SDU should not be written to */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_ERRORS, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);

	/* PDU 2 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	init_rx_sdu_buffer(&rx_sdu_frag_buf);

	payload_number++;
	pdu_timestamp += 200;

	sdu_timeoffset =
		sdu_timeoffset - sdu_interval > 0
			? sdu_timeoffset - sdu_interval
			: sdu_timeoffset + (iso_interval_int * CONN_INT_UNIT_US) - sdu_interval;
	sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset);
	seqn++;
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size = 10;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[1] =
		add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx),
				      sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[1]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);
}

/**
 * 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)
{
	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;
	uint16_t pdu_data_loc[5];
	uint64_t payload_number;
	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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = ((iso_interval_int * CONN_INT_UNIT_US) / 3) + 5;
	BN = 3;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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 = 0;
	seqn = 1;
	testdata_indx = 0;
	testdata_size = 23;
	sdu_size = 0;

	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 */
	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_LOST_DATA,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[0] =
		add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx),
				      sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer);
	sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK;

	/* SDU should not be written to */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_LOST_DATA, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);

	/* PDU 2 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	init_rx_sdu_buffer(&rx_sdu_frag_buf);

	payload_number++;
	pdu_timestamp += 200;

	sdu_timeoffset =
		sdu_timeoffset - sdu_interval > 0
			? sdu_timeoffset - sdu_interval
			: sdu_timeoffset + (iso_interval_int * CONN_INT_UNIT_US) - sdu_interval;
	sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset);
	seqn++;
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size = 10;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[1] =
		add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx),
				      sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[1]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);
}

/**
 * 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_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;
	uint16_t pdu_data_loc[5];
	uint64_t payload_number;
	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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = ((iso_interval_int * CONN_INT_UNIT_US) / 3) + 5;
	BN = 3;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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 = 1;
	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 */

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[0] =
		add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx),
				      sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[0]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);

	/* PDU 2 -------------------------------------------------------------*/
	/* Not transferred to the ISO-AL */
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	init_rx_sdu_buffer(&rx_sdu_frag_buf);

	payload_number++;
	pdu_timestamp += 200;

	sdu_timeoffset =
		sdu_timeoffset - sdu_interval > 0
			? sdu_timeoffset - sdu_interval
			: sdu_timeoffset + (iso_interval_int * CONN_INT_UNIT_US) - sdu_interval;
	sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset);
	/* ISO-AL has no concept of time and is unable to detect than an SDU
	 * has been lost. Sequence number does not increment.
	 * seqn = seqn;
	 */
	testdata_indx = testdata_size;
	testdata_size += 10;

	/* PDU 3 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	init_rx_sdu_buffer(&rx_sdu_frag_buf);

	payload_number++;
	pdu_timestamp += 200;

	sdu_timeoffset =
		sdu_timeoffset - sdu_interval > 0
			? sdu_timeoffset - sdu_interval
			: sdu_timeoffset + (iso_interval_int * CONN_INT_UNIT_US) - sdu_interval;
	sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset);
	seqn++;
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size = 10;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[1] =
		add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx),
				      sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[1]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);
}

/**
 * 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_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;
	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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = ((iso_interval_int * CONN_INT_UNIT_US) / 3) + 5;
	BN = 3;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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 = 0;
	seqn = 1;
	testdata_indx = 0;
	testdata_size = 13;
	sdu_size = 0;

	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 */
	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_ERRORS,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[0] =
		add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx),
				     sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer);
	sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK;

	/* SDU should not be written to */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_ERRORS, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);

	/* PDU 2 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);

	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[1] =
		add_framed_pdu_cont(&testdata[testdata_indx], (testdata_size - testdata_indx),
				    &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 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 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);

	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[2] =
		add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx),
				   &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 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 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	init_rx_sdu_buffer(&rx_sdu_frag_buf);

	payload_number++;
	pdu_timestamp += 200;

	sdu_timeoffset =
		sdu_timeoffset - sdu_interval > 0
			? sdu_timeoffset - sdu_interval
			: sdu_timeoffset + (iso_interval_int * CONN_INT_UNIT_US) - sdu_interval;
	sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset);
	seqn++;
	testdata_indx = testdata_size;
	testdata_size += 13;
	sdu_size = 13;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[3] =
		add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx),
				      sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[3]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);
}

/**
 * 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_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;
	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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = ((iso_interval_int * CONN_INT_UNIT_US) / 3) + 5;
	BN = 3;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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 = 1;
	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 */
	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[0] =
		add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx),
				     sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	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;

	/* 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 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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[0]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* PDU 2 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);

	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_ERRORS,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[1] =
		add_framed_pdu_cont(&testdata[testdata_indx], (testdata_size - testdata_indx),
				    &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	/* Should not allocate a new SDU */

	/* SDU should not be written to */
	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 (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));

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_ERRORS, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);

	/* PDU 3 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);

	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[2] =
		add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx),
				   &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 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 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	init_rx_sdu_buffer(&rx_sdu_frag_buf);

	payload_number++;
	pdu_timestamp += 200;

	sdu_timeoffset =
		sdu_timeoffset - sdu_interval > 0
			? sdu_timeoffset - sdu_interval
			: sdu_timeoffset + (iso_interval_int * CONN_INT_UNIT_US) - sdu_interval;
	sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset);
	seqn++;
	testdata_indx = testdata_size;
	testdata_size += 13;
	sdu_size = 13;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[3] =
		add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx),
				      sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[3]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);
}

/**
 * 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_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;
	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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = ((iso_interval_int * CONN_INT_UNIT_US) / 3) + 5;
	BN = 3;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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 = 1;
	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 */
	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[0] =
		add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx),
				     sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	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;

	/* 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 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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[0]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* PDU 2 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);

	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size += 10;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[1] =
		add_framed_pdu_cont(&testdata[testdata_indx], (testdata_size - testdata_indx),
				    &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	/* Should not allocate a new SDU */

	sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK;

	/* 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 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));
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[1]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* PDU 3 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);

	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_ERRORS,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[2] =
		add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx),
				   &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	/* Should not allocate a new SDU */

	/* SDU should not be written to */
	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 (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));

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_ERRORS, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);

	/* PDU 4 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	init_rx_sdu_buffer(&rx_sdu_frag_buf);

	payload_number++;
	pdu_timestamp += 200;

	sdu_timeoffset =
		sdu_timeoffset - sdu_interval > 0
			? sdu_timeoffset - sdu_interval
			: sdu_timeoffset + (iso_interval_int * CONN_INT_UNIT_US) - sdu_interval;
	sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset);
	seqn++;
	testdata_indx = testdata_size;
	testdata_size += 13;
	sdu_size = 13;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[3] =
		add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx),
				      sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[3]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);
}

/**
 * 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_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;
	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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = ((iso_interval_int * CONN_INT_UNIT_US) / 3) + 5;
	BN = 3;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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 = 1;
	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 */
	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[0] =
		add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx),
				     sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	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;

	/* 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 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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[0]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* PDU 2 -------------------------------------------------------------*/
	/* PDU not transferred to the ISO-AL */
	init_rx_pdu_buffer(&rx_pdu_meta_buf);

	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;

	/* PDU 3 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);

	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[2] =
		add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx),
				   &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	/* Should not allocate a new SDU */

	/* SDU should not be written to */
	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 (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));

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_LOST_DATA, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);

	/* PDU 4 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	init_rx_sdu_buffer(&rx_sdu_frag_buf);

	payload_number++;
	pdu_timestamp += 200;

	sdu_timeoffset =
		sdu_timeoffset - sdu_interval > 0
			? sdu_timeoffset - sdu_interval
			: sdu_timeoffset + (iso_interval_int * CONN_INT_UNIT_US) - sdu_interval;
	sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset);
	seqn++;
	testdata_indx = testdata_size;
	testdata_size += 13;
	sdu_size = 13;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[3] =
		add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx),
				      sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[3]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);
}

/**
 * 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_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;
	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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = ((iso_interval_int * CONN_INT_UNIT_US) / 3) + 5;
	BN = 3;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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 = 1;
	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 */
	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[0] =
		add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx),
				     sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	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;

	/* 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 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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[0]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* PDU 2 -------------------------------------------------------------*/
	/* PDU not transferred to the ISO-AL */
	init_rx_pdu_buffer(&rx_pdu_meta_buf);

	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;

	/* PDU 3 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);

	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_ERRORS,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[2] =
		add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx),
				   &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	/* Should not allocate a new SDU */

	/* SDU should not be written to */
	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 (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));

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_LOST_DATA, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);

	/* PDU 4 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	init_rx_sdu_buffer(&rx_sdu_frag_buf);

	payload_number++;
	pdu_timestamp += 200;

	sdu_timeoffset =
		sdu_timeoffset - sdu_interval > 0
			? sdu_timeoffset - sdu_interval
			: sdu_timeoffset + (iso_interval_int * CONN_INT_UNIT_US) - sdu_interval;
	sdu_timestamp = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset);
	seqn++;
	testdata_indx = testdata_size;
	testdata_size += 13;
	sdu_size = 13;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[3] =
		add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx),
				      sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[3]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);
}

/**
 * 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_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];
	isoal_sdu_cnt_t seqn[2];
	uint64_t payload_number;
	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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = ((iso_interval_int * CONN_INT_UNIT_US) / 3) + 5;
	BN = 3;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	init_rx_sdu_buffer(&rx_sdu_frag_buf[0]);
	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] = 0;
	seqn[0] = 1;
	testdata_indx = 0;
	testdata_size = 13;
	sdu_size[0] = 0;

	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 */
	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_ERRORS,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[0] =
		add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx),
				     sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	push_custom_sink_sdu_alloc_test_output_buffer(&sdu_buffer[0]);
	sink_sdu_alloc_test_fake.return_val = ISOAL_STATUS_OK;

	/* SDU should not be written to */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size[0],
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written, NULL);
	zassert_equal(ISOAL_SDU_STATUS_ERRORS, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp[0], sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn[0], sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer[0].dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer[0].size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);

	/* PDU 2 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);

	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size[0] += 10;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[1] =
		add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx),
				   &rx_pdu_meta_buf.pdu_meta);

	sdu_timeoffset =
		sdu_timeoffset - sdu_interval > 0
			? sdu_timeoffset - sdu_interval
			: sdu_timeoffset + (iso_interval_int * CONN_INT_UNIT_US) - sdu_interval;
	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] =
		add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx),
				     sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	/* SDU 1 */
	/* SDU should not be written to */

	/* SDU shold not be emitted */

	/* SDU 2 */
	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;

	/* SDU 2 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 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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf[1], sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[2]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* PDU 3 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);

	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size[1] += 10;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[3] =
		add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx),
				   &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	/* Should not allocate a new SDU */

	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 (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));
	zassert_equal_ptr(&rx_sdu_frag_buf[1], sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[3]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size[1],
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written, NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp[1], sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn[1], sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer[1].dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer[1].size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);

	/* PDU 4 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	init_rx_sdu_buffer(&rx_sdu_frag_buf[0]);

	payload_number++;
	pdu_timestamp = 9249 + (iso_interval_int * CONN_INT_UNIT_US);

	sdu_timeoffset =
		sdu_timeoffset - sdu_interval > 0
			? sdu_timeoffset - sdu_interval
			: sdu_timeoffset + (iso_interval_int * CONN_INT_UNIT_US) - sdu_interval;
	sdu_timestamp[0] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset);
	seqn[0] = seqn[1] + 1;
	testdata_indx = testdata_size;
	testdata_size += 13;
	sdu_size[0] = 13;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[4] =
		add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx),
				      sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[4]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size[0],
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written, NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp[0], sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn[0], sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer[0].dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer[0].size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);
}

/**
 * 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_err2)
{
	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_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];
	isoal_sdu_cnt_t seqn[2];
	uint64_t payload_number;
	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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = ((iso_interval_int * CONN_INT_UNIT_US) / 3) + 5;
	BN = 3;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	init_rx_sdu_buffer(&rx_sdu_frag_buf[0]);
	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] = 1;
	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 */

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[0] =
		add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx),
				     sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	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;

	/* 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 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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf[0], sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[0]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* PDU 2 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);

	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;

	/* PDU with errors */
	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_ERRORS,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[1] =
		add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx),
				   &rx_pdu_meta_buf.pdu_meta);

	sdu_timeoffset =
		sdu_timeoffset - sdu_interval > 0
			? sdu_timeoffset - sdu_interval
			: sdu_timeoffset + (iso_interval_int * CONN_INT_UNIT_US) - sdu_interval;
	sdu_timestamp[1] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset);
	seqn[1] = seqn[0];
	testdata_indx = testdata_size;
	testdata_size += 17;
	sdu_size[1] = 0;

	pdu_data_loc[2] =
		add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx),
				     sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	/* SDU 1 */
	/* SDU should not be written to */
	sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK;

	/* SDU 2 */
	/* Should not be allocated */

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

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size[0],
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written, NULL);
	zassert_equal(ISOAL_SDU_STATUS_ERRORS, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp[0], sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn[0], sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer[0].dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer[0].size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);

	/* PDU 3 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);

	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[3] =
		add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx),
				   &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 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 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	init_rx_sdu_buffer(&rx_sdu_frag_buf[0]);

	payload_number++;
	pdu_timestamp = 9249 + (iso_interval_int * CONN_INT_UNIT_US);

	sdu_timeoffset =
		sdu_timeoffset - sdu_interval > 0
			? sdu_timeoffset - sdu_interval
			: sdu_timeoffset + (iso_interval_int * CONN_INT_UNIT_US) - sdu_interval;
	sdu_timestamp[0] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset);
	seqn[0] = seqn[1] + 1;
	testdata_indx = testdata_size;
	testdata_size += 13;
	sdu_size[0] = 13;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[4] =
		add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx),
				      sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[4]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size[0],
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written, NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp[0], sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn[0], sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer[0].dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer[0].size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);
}

/**
 * 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_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_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];
	isoal_sdu_cnt_t seqn[2];
	uint64_t payload_number;
	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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = ((iso_interval_int * CONN_INT_UNIT_US) / 3) + 5;
	BN = 3;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	init_rx_sdu_buffer(&rx_sdu_frag_buf[0]);
	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] = 1;
	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 */

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[0] =
		add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx),
				     sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	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;

	/* 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 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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf[0], sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[0]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* PDU 2 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);

	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;
	sdu_size[0] += 10;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[1] =
		add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx),
				   &rx_pdu_meta_buf.pdu_meta);

	sdu_timeoffset =
		sdu_timeoffset - sdu_interval > 0
			? sdu_timeoffset - sdu_interval
			: sdu_timeoffset + (iso_interval_int * CONN_INT_UNIT_US) - sdu_interval;
	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] =
		add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx),
				     sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	/* SDU 1 */
	sink_sdu_write_test_fake.return_val = ISOAL_STATUS_OK;
	sink_sdu_emit_test_fake.return_val = ISOAL_STATUS_OK;

	/* SDU 2 */
	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;

	/* SDU 2 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 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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf[0], sink_sdu_write_test_fake.arg0_history[1], NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[1]],
			  sink_sdu_write_test_fake.arg1_history[1], NULL);
	zassert_equal(10, sink_sdu_write_test_fake.arg2_history[1], NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf[1], sink_sdu_write_test_fake.arg0_history[2], NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[2]],
			  sink_sdu_write_test_fake.arg1_history[2], NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_history[2],
		      NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size[0],
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written, NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp[0], sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn[0], sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer[0].dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer[0].size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);

	/* PDU 3 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);

	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;
	/* SDU size does not change */

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_ERRORS,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[3] =
		add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx),
				   &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	/* Should not allocate a new SDU */

	/* SDU should not be written to */
	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 (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));

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size[1],
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written, NULL);
	zassert_equal(ISOAL_SDU_STATUS_ERRORS, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp[1], sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn[1], sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer[1].dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer[1].size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);

	/* PDU 4 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	init_rx_sdu_buffer(&rx_sdu_frag_buf[0]);

	payload_number++;
	pdu_timestamp = 9249 + (iso_interval_int * CONN_INT_UNIT_US);

	sdu_timeoffset =
		sdu_timeoffset - sdu_interval > 0
			? sdu_timeoffset - sdu_interval
			: sdu_timeoffset + (iso_interval_int * CONN_INT_UNIT_US) - sdu_interval;
	sdu_timestamp[0] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset);
	seqn[0] = seqn[1] + 1;
	testdata_indx = testdata_size;
	testdata_size += 13;
	sdu_size[0] = 13;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[4] =
		add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx),
				      sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[4]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size[0],
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written, NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp[0], sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn[0], sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer[0].dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer[0].size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);
}

/**
 * Test Suite	:	RX framed PDU recombination
 *
 * Tests recombination of two SDUs from three segmented PDUs with errors
 */
ZTEST(test_rx_framed, test_rx_framed_trppl_pdu_dbl_sdu_seq_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_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];
	isoal_sdu_cnt_t seqn[2];
	uint64_t payload_number;
	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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = ((iso_interval_int * CONN_INT_UNIT_US) / 3) + 5;
	BN = 3;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	init_rx_sdu_buffer(&rx_sdu_frag_buf[0]);
	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] = 1;
	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 */

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[0] =
		add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx),
				     sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	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;

	/* 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 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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf[0], sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[0]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* PDU 2 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);

	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;
	/* No change in SDU 1 size */

	sdu_timeoffset =
		sdu_timeoffset - sdu_interval > 0
			? sdu_timeoffset - sdu_interval
			: sdu_timeoffset + (iso_interval_int * CONN_INT_UNIT_US) - sdu_interval;
	sdu_timestamp[1] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset);
	/* ISO-AL has no concept of time and is unable to detect than an SDU
	 * has been lost. Sequence number does not increment.
	 */
	seqn[1] = seqn[0];
	testdata_indx = testdata_size;
	testdata_size += 17;
	sdu_size[1] = 0;

	/* PDU 3 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);

	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;
	/* SDU size does not change */

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[3] =
		add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx),
				   &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	/* Should not allocate a new SDU */

	/* SDU should not be written to */

	/* SDU 1 emitted with errors, SDU 2 lost */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size[0],
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written, NULL);
	zassert_equal(ISOAL_SDU_STATUS_LOST_DATA, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp[0], sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn[0], sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer[0].dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer[0].size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);

	/* PDU 4 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	init_rx_sdu_buffer(&rx_sdu_frag_buf[0]);

	payload_number++;
	pdu_timestamp = 9249 + (iso_interval_int * CONN_INT_UNIT_US);

	sdu_timeoffset =
		sdu_timeoffset - sdu_interval > 0
			? sdu_timeoffset - sdu_interval
			: sdu_timeoffset + (iso_interval_int * CONN_INT_UNIT_US) - sdu_interval;
	sdu_timestamp[0] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset);
	seqn[0] = seqn[1] + 1;
	testdata_indx = testdata_size;
	testdata_size += 13;
	sdu_size[0] = 13;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[4] =
		add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx),
				      sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[4]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size[0],
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written, NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp[0], sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn[0], sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer[0].dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer[0].size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);
}

/**
 * Test Suite	:	RX framed PDU recombination
 *
 * Tests recombination of two SDUs from three segmented PDUs with errors
 */
ZTEST(test_rx_framed, test_rx_framed_trppl_pdu_dbl_sdu_pdu_seq_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_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];
	isoal_sdu_cnt_t seqn[2];
	uint64_t payload_number;
	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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = ((iso_interval_int * CONN_INT_UNIT_US) / 3) + 5;
	BN = 3;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	init_rx_sdu_buffer(&rx_sdu_frag_buf[0]);
	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] = 1;
	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 */

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[0] =
		add_framed_pdu_start(&testdata[testdata_indx], (testdata_size - testdata_indx),
				     sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	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;

	/* 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 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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf[0], sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[0]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	/* PDU 2 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);

	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;
	/* No change in SDU 1 size */

	sdu_timeoffset =
		sdu_timeoffset - sdu_interval > 0
			? sdu_timeoffset - sdu_interval
			: sdu_timeoffset + (iso_interval_int * CONN_INT_UNIT_US) - sdu_interval;
	sdu_timestamp[1] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset);
	/* ISO-AL has no concept of time and is unable to detect than an SDU
	 * has been lost. Sequence number does not increment.
	 */
	seqn[1] = seqn[0];
	testdata_indx = testdata_size;
	testdata_size += 17;
	sdu_size[1] = 0;

	/* PDU 3 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);

	payload_number++;
	pdu_timestamp += 200;
	testdata_indx = testdata_size;
	testdata_size += 10;
	/* SDU size does not change */

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_ERRORS,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[3] =
		add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx),
				   &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	/* Should not allocate a new SDU */

	/* SDU should not be written to */

	/* SDU 1 emitted with errors, SDU 2 lost */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size[0],
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written, NULL);
	zassert_equal(ISOAL_SDU_STATUS_LOST_DATA, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp[0], sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn[0], sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer[0].dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer[0].size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);

	/* PDU 4 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	init_rx_sdu_buffer(&rx_sdu_frag_buf[0]);

	payload_number++;
	pdu_timestamp = 9249 + (iso_interval_int * CONN_INT_UNIT_US);

	sdu_timeoffset =
		sdu_timeoffset - sdu_interval > 0
			? sdu_timeoffset - sdu_interval
			: sdu_timeoffset + (iso_interval_int * CONN_INT_UNIT_US) - sdu_interval;
	sdu_timestamp[0] = (uint32_t)((int64_t)pdu_timestamp + latency - sdu_timeoffset);
	seqn[0] = seqn[1] + 1;
	testdata_indx = testdata_size;
	testdata_size += 13;
	sdu_size[0] = 13;

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[4] =
		add_framed_pdu_single(&testdata[testdata_indx], (testdata_size - testdata_indx),
				      sdu_timeoffset, &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);
	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_val, NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[4]],
			  sink_sdu_write_test_fake.arg1_val, NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_val, NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size[0],
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written, NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp[0], sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn[0], sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer[0].dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer[0].size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);
}

/**
 * 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_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;
	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 = BT_CONN_ROLE_PERIPHERAL;
	iso_interval_int = 1;
	sdu_interval = ((iso_interval_int * CONN_INT_UNIT_US) / 3) + 5;
	BN = 3;
	FT = 1;
	stream_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 200;
	group_sync_delay = (iso_interval_int * CONN_INT_UNIT_US) - 50;

	/* PDU 1 -------------------------------------------------------------*/
	init_rx_pdu_buffer(&rx_pdu_meta_buf);
	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 = 1;
	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 */

	create_framed_pdu_base(payload_number, pdu_timestamp, ISOAL_PDU_STATUS_VALID,
			       &rx_pdu_meta_buf.pdu_meta);
	pdu_data_loc[0] =
		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] =
		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;

	pdu_data_loc[2] =
		add_framed_pdu_end(&testdata[testdata_indx], (testdata_size - testdata_indx),
				   &rx_pdu_meta_buf.pdu_meta);

	/* Test recombine (Black Box) */
	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 (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));
	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_alloc_test_fake.arg0_val,
			  NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu_meta, sink_sdu_alloc_test_fake.arg1_val, NULL);

	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_history[0], NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[0]],
			  sink_sdu_write_test_fake.arg1_history[0], NULL);
	zassert_equal(13, sink_sdu_write_test_fake.arg2_history[0], NULL);

	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_history[1], NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[1]],
			  sink_sdu_write_test_fake.arg1_history[1], NULL);
	zassert_equal(5, sink_sdu_write_test_fake.arg2_history[1], NULL);

	zassert_equal_ptr(&rx_sdu_frag_buf, sink_sdu_write_test_fake.arg0_history[2], NULL);
	zassert_equal_ptr(&rx_pdu_meta_buf.pdu[2 + pdu_data_loc[2]],
			  sink_sdu_write_test_fake.arg1_history[2], NULL);
	zassert_equal((testdata_size - testdata_indx), sink_sdu_write_test_fake.arg2_history[2],
		      NULL);

	zassert_equal_ptr(&isoal_global.sink_state[sink_hdl], sink_sdu_emit_test_fake.arg0_val,
			  NULL);
	zassert_equal(BT_ISO_SINGLE,
		      sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_state, NULL);
	zassert_equal(sdu_size, sink_sdu_emit_test_handler_fake.arg0_val.sdu_production.sdu_written,
		      NULL);
	zassert_equal(ISOAL_SDU_STATUS_VALID, sink_sdu_emit_test_handler_fake.arg1_val.status,
		      NULL);
	zassert_equal(sdu_timestamp, sink_sdu_emit_test_handler_fake.arg1_val.timestamp, NULL);
	zassert_equal(seqn, sink_sdu_emit_test_handler_fake.arg1_val.seqn, NULL);
	zassert_equal(sdu_buffer.dbuf, sink_sdu_emit_test_handler_fake.arg1_val.contents.dbuf,
		      NULL);
	zassert_equal(sdu_buffer.size, sink_sdu_emit_test_handler_fake.arg1_val.contents.size,
		      NULL);
}

static void 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;
}

ZTEST_SUITE(test_rx_basics, NULL, NULL, common_before, NULL, NULL);
ZTEST_SUITE(test_rx_unframed, NULL, NULL, common_before, NULL, NULL);
ZTEST_SUITE(test_rx_framed, NULL, NULL, common_before, NULL, NULL);