tests/bluetooth/df/connectionless_cte_chains/src/test_remove_cte_from_chain.c - third_party/github/zephyrproject-rtos/zephyr - Git at Google

 /*
  * Copyright (c) 2021 Nordic Semiconductor ASA
  *
  * SPDX-License-Identifier: Apache-2.0
  */

 #include <zephyr/kernel.h>
 #include <stddef.h>
 #include <zephyr/ztest.h>

 #include <zephyr/bluetooth/bluetooth.h>
 #include <zephyr/bluetooth/hci.h>
 #include <zephyr/sys/byteorder.h>
 #include <host/hci_core.h>

 #include "util/util.h"
 #include "util/memq.h"
 #include "util/mem.h"
 #include "util/dbuf.h"

 #include "pdu.h"

 #include "lll.h"
 #include "lll/lll_adv_types.h"
 #include "lll_adv.h"
 #include "lll/lll_adv_pdu.h"
 #include "lll/lll_adv_internal.h"
 #include "lll_adv_sync.h"
 #include "lll/lll_df_types.h"

 #include "ull_adv_types.h"
 #include "ull_adv_internal.h"

 #include "ll.h"
 #include "common.h"

 #define TEST_ADV_SET_HANDLE 0
 #define TEST_CTE_COUNT 3
 #define TEST_PER_ADV_CHAIN_LENGTH 5
 #define TEST_PER_ADV_CHAIN_INCREASED_LENGTH 7
 #define TEST_PER_ADV_CHAIN_DECREASED_LENGTH (TEST_CTE_COUNT - 1)
 #define TEST_PER_ADV_SINGLE_PDU 1
 #define TEST_CTE_SINGLE 1
 /* It does not matter for purpose of this tests what is the type or length of CTE used. */
 #define TEST_CTE_TYPE BT_HCI_LE_AOD_CTE_2US

 ZTEST(test_add_cte_to_per_adv_chain, test_remove_cte_from_chain_extended_to_tx_all_cte)
 {
 	struct ll_adv_set *adv;
 	uint8_t handle;
 	int err;

 	/* Setup for test */
 	adv = common_create_adv_set(TEST_ADV_SET_HANDLE);
 	common_prepare_df_cfg(adv, TEST_CTE_COUNT);
 	common_create_per_adv_chain(adv, TEST_PER_ADV_SINGLE_PDU);

 	handle = ull_adv_handle_get(adv);

 	ll_df_set_cl_cte_tx_enable(handle, true);

 	err = ll_df_set_cl_cte_tx_enable(handle, false);
 	zassert_equal(err, 0,
 		      "Unexpected error while disabling CTE for periodic advertising chain, err: %d",
 		      err);
 	/* Validate result */
 	common_validate_per_adv_chain(adv, TEST_PER_ADV_SINGLE_PDU);

 	common_teardown(adv);
 }

 ZTEST(test_add_cte_to_per_adv_chain, test_remove_cte_from_chain_where_each_pdu_includes_cte)
 {
 	struct ll_adv_set *adv;
 	uint8_t handle;
 	int err;

 	/* Setup for test */
 	adv = common_create_adv_set(TEST_ADV_SET_HANDLE);
 	/* Use the same number for PDUs in a chain as for CTE request */
 	common_prepare_df_cfg(adv, TEST_CTE_COUNT);
 	common_create_per_adv_chain(adv, TEST_CTE_COUNT);

 	handle = ull_adv_handle_get(adv);

 	err = ll_df_set_cl_cte_tx_enable(handle, true);
 	zassert_equal(err, 0,
 		      "Unexpected error while enabling CTE for periodic advertising chain, err: %d",
 		      err);

 	err = ll_df_set_cl_cte_tx_enable(handle, false);
 	zassert_equal(err, 0,
 		      "Unexpected error while disabling CTE for periodic advertising chain, err: %d",
 		      err);
 	/* Validate result */
 	common_validate_per_adv_chain(adv, TEST_CTE_COUNT);

 	common_teardown(adv);
 }

 ZTEST(test_add_cte_to_per_adv_chain, test_remove_cte_from_chain_with_more_pdu_than_cte)
 {
 	struct ll_adv_set *adv;
 	uint8_t handle;
 	int err;

 	/* Setup for test */
 	adv = common_create_adv_set(TEST_ADV_SET_HANDLE);
 	/* Use the same number for PDUs in a chain as for CTE request */
 	common_prepare_df_cfg(adv, TEST_CTE_COUNT);
 	common_create_per_adv_chain(adv, TEST_PER_ADV_CHAIN_LENGTH);

 	handle = ull_adv_handle_get(adv);

 	ll_df_set_cl_cte_tx_enable(handle, true);

 	err = ll_df_set_cl_cte_tx_enable(handle, false);
 	zassert_equal(err, 0,
 		      "Unexpected error while disabling CTE for periodic advertising chain, err: %d",
 		      err);
 	/* Validate result */
 	common_validate_per_adv_chain(adv, TEST_PER_ADV_CHAIN_LENGTH);

 	common_teardown(adv);
 }

 ZTEST(test_add_cte_to_per_adv_chain, test_remove_cte_from_single_pdu_chain)
 {
 	struct ll_adv_set *adv;
 	uint8_t handle;
 	int err;

 	/* Setup for test */
 	adv = common_create_adv_set(TEST_ADV_SET_HANDLE);
 	/* Use the same number for PDUs in a chain as for CTE request */
 	common_prepare_df_cfg(adv, TEST_CTE_SINGLE);
 	common_create_per_adv_chain(adv, TEST_PER_ADV_SINGLE_PDU);

 	handle = ull_adv_handle_get(adv);

 	ll_df_set_cl_cte_tx_enable(handle, true);

 	err = ll_df_set_cl_cte_tx_enable(handle, false);
 	zassert_equal(err, 0,
 		      "Unexpected error while disabling CTE for periodic advertising chain, err: %d",
 		      err);
 	/* Validate result */
 	common_validate_per_adv_chain(adv, TEST_PER_ADV_SINGLE_PDU);

 	common_teardown(adv);
 }

 static void remove_cte_from_chain_after_enqueue_to_lll(
 	uint8_t cte_count, uint8_t init_chain_length,
 	uint8_t expected_mem_pdu_used_count_for_enable,
 	uint8_t expected_mem_pdu_used_count_for_disable,
 	uint8_t expected_pdu_in_chain_after_cte_disable, uint8_t updated_chain_length,
 	uint8_t expected_end_fifo_free_pdu_count, bool new_chain_before_cte_disable)
 {
 	uint32_t pdu_mem_cnt_expected, pdu_mem_cnt;
 	struct pdu_adv *pdu_prev, *pdu_new;
 	struct ll_adv_set *adv;
 	uint32_t pdu_fifo_cnt;
 	uint8_t handle;
 	uint8_t upd;
 	int err;

 	pdu_mem_cnt_expected = lll_adv_pdu_mem_free_count_get();

 	/* Setup for test */
 	adv = common_create_adv_set(TEST_ADV_SET_HANDLE);
 	/* Use smaller number of CTE for request than number of PDUs in an initial chain.
 	 * In such situation chain should not be extended and PDUs pool should be not affected.
 	 */
 	common_prepare_df_cfg(adv, cte_count);
 	common_create_per_adv_chain(adv, init_chain_length);

 	handle = ull_adv_handle_get(adv);

 	err = ll_df_set_cl_cte_tx_enable(handle, true);
 	zassert_equal(err, 0,
 		      "Unexpected error while enabling CTE for periodic advertising chain, err: %d",
 		      err);

 	/* Swap PDU double buffer and get new latest PDU data */
 	pdu_new = lll_adv_sync_data_latest_get(adv->lll.sync, NULL, &upd);
 	zassert_not_equal(pdu_new, NULL,
 			  "Unexpected value of new PDU pointer after PDU double buffer swap");

 	pdu_prev = lll_adv_sync_data_peek(adv->lll.sync, NULL);
 	zassert_equal(pdu_prev, pdu_new,
 		      "Unexpected value of previous PDU pointer after PDU double buffer swap");

 	/* Free PDUs fifo should hold single PDU released during double buffer swap. The PDU
 	 * was allocated during advertising set creation.
 	 */
 	pdu_fifo_cnt = lll_adv_free_pdu_fifo_count_get();
 	zassert_equal(pdu_fifo_cnt, TEST_PER_ADV_SINGLE_PDU,
 		      "Unexpected number of free PDUs in a fifo: %d", pdu_fifo_cnt);

 	/* Expected free PDUs count is decreased by:
 	 * - single PDU allocated during advertising set creation,
 	 * - number of PDUs allocated for per. adv. chain to Tx CTE
 	 */
 	pdu_mem_cnt_expected -= expected_mem_pdu_used_count_for_enable;
 	pdu_mem_cnt = lll_adv_pdu_mem_free_count_get();
 	zassert_equal(pdu_mem_cnt, pdu_mem_cnt_expected,
 		      "Unexpected amount of free PDUs memory: %d, expected %d", pdu_mem_cnt,
 		      pdu_mem_cnt_expected);

 	if (new_chain_before_cte_disable) {
 		common_create_per_adv_chain(adv, updated_chain_length);
 	}

 	err = ll_df_set_cl_cte_tx_enable(handle, false);
 	zassert_equal(err, 0,
 		      "Unexpected error while disabling CTE for periodic advertising chain, err: %d",
 		      err);
 	/* Validate result */
 	common_validate_per_adv_chain(adv, expected_pdu_in_chain_after_cte_disable);

 	/* Swap PDU double buffer to check correctness of release former PDUs */
 	pdu_new = lll_adv_sync_data_latest_get(adv->lll.sync, NULL, &upd);
 	zassert_not_equal(pdu_new, NULL,
 			  "Unexpected value of PDU pointer after PDU double buffer swap");

 	/* Validate number of released PDUs */

 	/* Number of free PDUs in a fifo is a number of released PDUs from former periodic
 	 * advertising chain. One free PDU that had been in a fifo was used for allocation of
 	 * the new PDU without CTE.
 	 */
 	pdu_fifo_cnt = lll_adv_free_pdu_fifo_count_get();
 	zassert_equal(pdu_fifo_cnt, expected_end_fifo_free_pdu_count,
 		      "Unexpected number of free PDUs in a fifo: %d", pdu_fifo_cnt);

 	/* Number of free PDUs in memory pool may decreased. Single PDU for AUX_SYNC_IND was
 	 * acquired from free PDUs fifo. The memory pool will decrease by number of non empty PDUs
 	 * in a chain subtracted by 1 (PDU taken from free PDUs fifo).
 	 */
 	pdu_mem_cnt_expected -= expected_mem_pdu_used_count_for_disable;

 	pdu_mem_cnt = lll_adv_pdu_mem_free_count_get();
 	zassert_equal(pdu_mem_cnt, pdu_mem_cnt_expected,
 		      "Unexpected amount of free PDUs memory: %d, expected %d", pdu_mem_cnt,
 		      pdu_mem_cnt_expected);

 	common_teardown(adv);
 }

 ZTEST(test_add_cte_to_per_adv_chain,
 	test_remove_cte_from_chain_extended_to_tx_all_cte_after_enqueue_to_lll)
 {
 	uint8_t cte_count = TEST_CTE_COUNT;
 	uint8_t init_chain_length = TEST_PER_ADV_SINGLE_PDU;
 	uint8_t expected_mem_pdu_used_count_for_enable = TEST_CTE_COUNT + TEST_PER_ADV_SINGLE_PDU;
 	uint8_t expected_mem_pdu_used_count_for_disable = 0;
 	uint8_t expected_pdu_in_chain_after_cte_disable = TEST_PER_ADV_SINGLE_PDU;
 	uint8_t updated_chain_length = 0;
 	uint8_t expected_end_fifo_free_pdu_count = TEST_CTE_COUNT;
 	bool new_chain_before_cte_disable = false;

 	remove_cte_from_chain_after_enqueue_to_lll(
 		cte_count, init_chain_length, expected_mem_pdu_used_count_for_enable,
 		expected_mem_pdu_used_count_for_disable, expected_pdu_in_chain_after_cte_disable,
 		updated_chain_length, expected_end_fifo_free_pdu_count,
 		new_chain_before_cte_disable);
 }

 ZTEST(test_add_cte_to_per_adv_chain,
 	test_remove_cte_from_chain_with_more_pdu_than_cte_after_enqueue_to_lll)
 {
 	uint8_t cte_count = TEST_CTE_COUNT;
 	uint8_t init_chain_length = TEST_PER_ADV_CHAIN_LENGTH;
 	uint8_t expected_mem_pdu_used_count_for_enable =
 		TEST_PER_ADV_CHAIN_LENGTH + TEST_PER_ADV_SINGLE_PDU;
 	uint8_t expected_mem_pdu_used_count_for_disable =
 		TEST_PER_ADV_CHAIN_LENGTH - TEST_PER_ADV_SINGLE_PDU;
 	uint8_t expected_pdu_in_chain_after_cte_disable = TEST_PER_ADV_CHAIN_LENGTH;
 	uint8_t updated_chain_length = 0;
 	uint8_t expected_end_fifo_free_pdu_count = TEST_PER_ADV_CHAIN_LENGTH;
 	bool new_chain_before_cte_disable = false;

 	remove_cte_from_chain_after_enqueue_to_lll(
 		cte_count, init_chain_length, expected_mem_pdu_used_count_for_enable,
 		expected_mem_pdu_used_count_for_disable, expected_pdu_in_chain_after_cte_disable,
 		updated_chain_length, expected_end_fifo_free_pdu_count,
 		new_chain_before_cte_disable);
 }

 ZTEST(test_add_cte_to_per_adv_chain,
 	test_remove_cte_from_chain_length_increased_after_enqueue_to_lll)
 {
 	uint8_t cte_count = TEST_CTE_COUNT;
 	uint8_t init_chain_length = TEST_PER_ADV_CHAIN_LENGTH;
 	uint8_t expected_mem_pdu_used_count_for_enable =
 		TEST_PER_ADV_CHAIN_LENGTH + TEST_PER_ADV_SINGLE_PDU;
 	uint8_t expected_mem_pdu_used_count_for_disable =
 		TEST_PER_ADV_CHAIN_INCREASED_LENGTH - TEST_PER_ADV_SINGLE_PDU;
 	uint8_t expected_pdu_in_chain_after_cte_disable = TEST_PER_ADV_CHAIN_INCREASED_LENGTH;
 	uint8_t updated_chain_length = TEST_PER_ADV_CHAIN_INCREASED_LENGTH;
 	uint8_t expected_end_fifo_free_pdu_count = TEST_PER_ADV_CHAIN_LENGTH;
 	bool new_chain_before_cte_disable = true;

 	remove_cte_from_chain_after_enqueue_to_lll(
 		cte_count, init_chain_length, expected_mem_pdu_used_count_for_enable,
 		expected_mem_pdu_used_count_for_disable, expected_pdu_in_chain_after_cte_disable,
 		updated_chain_length, expected_end_fifo_free_pdu_count,
 		new_chain_before_cte_disable);
 }

 ZTEST(test_add_cte_to_per_adv_chain,
 	test_remove_cte_from_chain_length_decreased_after_enqueue_to_lll)
 {
 	uint8_t cte_count = TEST_CTE_COUNT;
 	uint8_t init_chain_length = TEST_PER_ADV_CHAIN_LENGTH;
 	uint8_t expected_mem_pdu_used_count_for_enable =
 		TEST_PER_ADV_CHAIN_LENGTH + TEST_PER_ADV_SINGLE_PDU;
 	uint8_t expected_mem_pdu_used_count_for_disable =
 		TEST_PER_ADV_CHAIN_DECREASED_LENGTH - TEST_PER_ADV_SINGLE_PDU;
 	uint8_t expected_pdu_in_chain_after_cte_disable = TEST_PER_ADV_CHAIN_DECREASED_LENGTH;
 	uint8_t updated_chain_length = TEST_PER_ADV_CHAIN_DECREASED_LENGTH;
 	uint8_t expected_end_fifo_free_pdu_count = TEST_PER_ADV_CHAIN_LENGTH;
 	bool new_chain_before_cte_disable = true;

 	remove_cte_from_chain_after_enqueue_to_lll(
 		cte_count, init_chain_length, expected_mem_pdu_used_count_for_enable,
 		expected_mem_pdu_used_count_for_disable, expected_pdu_in_chain_after_cte_disable,
 		updated_chain_length, expected_end_fifo_free_pdu_count,
 		new_chain_before_cte_disable);
 }

 ZTEST_SUITE(test_remove_cte_from_per_adv_chain, NULL, NULL, NULL, NULL, NULL);
	/*
	* Copyright (c) 2021 Nordic Semiconductor ASA
	*
	* SPDX-License-Identifier: Apache-2.0
	*/

	#include <zephyr/kernel.h>
	#include <stddef.h>
	#include <zephyr/ztest.h>

	#include <zephyr/bluetooth/bluetooth.h>
	#include <zephyr/bluetooth/hci.h>
	#include <zephyr/sys/byteorder.h>
	#include <host/hci_core.h>

	#include "util/util.h"
	#include "util/memq.h"
	#include "util/mem.h"
	#include "util/dbuf.h"

	#include "pdu.h"

	#include "lll.h"
	#include "lll/lll_adv_types.h"
	#include "lll_adv.h"
	#include "lll/lll_adv_pdu.h"
	#include "lll/lll_adv_internal.h"
	#include "lll_adv_sync.h"
	#include "lll/lll_df_types.h"

	#include "ull_adv_types.h"
	#include "ull_adv_internal.h"

	#include "ll.h"
	#include "common.h"

	#define TEST_ADV_SET_HANDLE 0
	#define TEST_CTE_COUNT 3
	#define TEST_PER_ADV_CHAIN_LENGTH 5
	#define TEST_PER_ADV_CHAIN_INCREASED_LENGTH 7
	#define TEST_PER_ADV_CHAIN_DECREASED_LENGTH (TEST_CTE_COUNT - 1)
	#define TEST_PER_ADV_SINGLE_PDU 1
	#define TEST_CTE_SINGLE 1
	/* It does not matter for purpose of this tests what is the type or length of CTE used. */
	#define TEST_CTE_TYPE BT_HCI_LE_AOD_CTE_2US

	ZTEST(test_add_cte_to_per_adv_chain, test_remove_cte_from_chain_extended_to_tx_all_cte)
	{
	struct ll_adv_set *adv;
	uint8_t handle;
	int err;

	/* Setup for test */
	adv = common_create_adv_set(TEST_ADV_SET_HANDLE);
	common_prepare_df_cfg(adv, TEST_CTE_COUNT);
	common_create_per_adv_chain(adv, TEST_PER_ADV_SINGLE_PDU);

	handle = ull_adv_handle_get(adv);

	ll_df_set_cl_cte_tx_enable(handle, true);

	err = ll_df_set_cl_cte_tx_enable(handle, false);
	zassert_equal(err, 0,
	"Unexpected error while disabling CTE for periodic advertising chain, err: %d",
	err);
	/* Validate result */
	common_validate_per_adv_chain(adv, TEST_PER_ADV_SINGLE_PDU);

	common_teardown(adv);
	}

	ZTEST(test_add_cte_to_per_adv_chain, test_remove_cte_from_chain_where_each_pdu_includes_cte)
	{
	struct ll_adv_set *adv;
	uint8_t handle;
	int err;

	/* Setup for test */
	adv = common_create_adv_set(TEST_ADV_SET_HANDLE);
	/* Use the same number for PDUs in a chain as for CTE request */
	common_prepare_df_cfg(adv, TEST_CTE_COUNT);
	common_create_per_adv_chain(adv, TEST_CTE_COUNT);

	handle = ull_adv_handle_get(adv);

	err = ll_df_set_cl_cte_tx_enable(handle, true);
	zassert_equal(err, 0,
	"Unexpected error while enabling CTE for periodic advertising chain, err: %d",
	err);

	err = ll_df_set_cl_cte_tx_enable(handle, false);
	zassert_equal(err, 0,
	"Unexpected error while disabling CTE for periodic advertising chain, err: %d",
	err);
	/* Validate result */
	common_validate_per_adv_chain(adv, TEST_CTE_COUNT);

	common_teardown(adv);
	}

	ZTEST(test_add_cte_to_per_adv_chain, test_remove_cte_from_chain_with_more_pdu_than_cte)
	{
	struct ll_adv_set *adv;
	uint8_t handle;
	int err;

	/* Setup for test */
	adv = common_create_adv_set(TEST_ADV_SET_HANDLE);
	/* Use the same number for PDUs in a chain as for CTE request */
	common_prepare_df_cfg(adv, TEST_CTE_COUNT);
	common_create_per_adv_chain(adv, TEST_PER_ADV_CHAIN_LENGTH);

	handle = ull_adv_handle_get(adv);

	ll_df_set_cl_cte_tx_enable(handle, true);

	err = ll_df_set_cl_cte_tx_enable(handle, false);
	zassert_equal(err, 0,
	"Unexpected error while disabling CTE for periodic advertising chain, err: %d",
	err);
	/* Validate result */
	common_validate_per_adv_chain(adv, TEST_PER_ADV_CHAIN_LENGTH);

	common_teardown(adv);
	}

	ZTEST(test_add_cte_to_per_adv_chain, test_remove_cte_from_single_pdu_chain)
	{
	struct ll_adv_set *adv;
	uint8_t handle;
	int err;

	/* Setup for test */
	adv = common_create_adv_set(TEST_ADV_SET_HANDLE);
	/* Use the same number for PDUs in a chain as for CTE request */
	common_prepare_df_cfg(adv, TEST_CTE_SINGLE);
	common_create_per_adv_chain(adv, TEST_PER_ADV_SINGLE_PDU);

	handle = ull_adv_handle_get(adv);

	ll_df_set_cl_cte_tx_enable(handle, true);

	err = ll_df_set_cl_cte_tx_enable(handle, false);
	zassert_equal(err, 0,
	"Unexpected error while disabling CTE for periodic advertising chain, err: %d",
	err);
	/* Validate result */
	common_validate_per_adv_chain(adv, TEST_PER_ADV_SINGLE_PDU);

	common_teardown(adv);
	}

	static void remove_cte_from_chain_after_enqueue_to_lll(
	uint8_t cte_count, uint8_t init_chain_length,
	uint8_t expected_mem_pdu_used_count_for_enable,
	uint8_t expected_mem_pdu_used_count_for_disable,
	uint8_t expected_pdu_in_chain_after_cte_disable, uint8_t updated_chain_length,
	uint8_t expected_end_fifo_free_pdu_count, bool new_chain_before_cte_disable)
	{
	uint32_t pdu_mem_cnt_expected, pdu_mem_cnt;
	struct pdu_adv pdu_prev, pdu_new;
	struct ll_adv_set *adv;
	uint32_t pdu_fifo_cnt;
	uint8_t handle;
	uint8_t upd;
	int err;

	pdu_mem_cnt_expected = lll_adv_pdu_mem_free_count_get();

	/* Setup for test */
	adv = common_create_adv_set(TEST_ADV_SET_HANDLE);
	/* Use smaller number of CTE for request than number of PDUs in an initial chain.
	* In such situation chain should not be extended and PDUs pool should be not affected.
	*/
	common_prepare_df_cfg(adv, cte_count);
	common_create_per_adv_chain(adv, init_chain_length);

	handle = ull_adv_handle_get(adv);

	err = ll_df_set_cl_cte_tx_enable(handle, true);
	zassert_equal(err, 0,
	"Unexpected error while enabling CTE for periodic advertising chain, err: %d",
	err);

	/* Swap PDU double buffer and get new latest PDU data */
	pdu_new = lll_adv_sync_data_latest_get(adv->lll.sync, NULL, &upd);
	zassert_not_equal(pdu_new, NULL,
	"Unexpected value of new PDU pointer after PDU double buffer swap");

	pdu_prev = lll_adv_sync_data_peek(adv->lll.sync, NULL);
	zassert_equal(pdu_prev, pdu_new,
	"Unexpected value of previous PDU pointer after PDU double buffer swap");

	/* Free PDUs fifo should hold single PDU released during double buffer swap. The PDU
	* was allocated during advertising set creation.
	*/
	pdu_fifo_cnt = lll_adv_free_pdu_fifo_count_get();
	zassert_equal(pdu_fifo_cnt, TEST_PER_ADV_SINGLE_PDU,
	"Unexpected number of free PDUs in a fifo: %d", pdu_fifo_cnt);

	/* Expected free PDUs count is decreased by:
	* - single PDU allocated during advertising set creation,
	* - number of PDUs allocated for per. adv. chain to Tx CTE
	*/
	pdu_mem_cnt_expected -= expected_mem_pdu_used_count_for_enable;
	pdu_mem_cnt = lll_adv_pdu_mem_free_count_get();
	zassert_equal(pdu_mem_cnt, pdu_mem_cnt_expected,
	"Unexpected amount of free PDUs memory: %d, expected %d", pdu_mem_cnt,
	pdu_mem_cnt_expected);

	if (new_chain_before_cte_disable) {
	common_create_per_adv_chain(adv, updated_chain_length);
	}

	err = ll_df_set_cl_cte_tx_enable(handle, false);
	zassert_equal(err, 0,
	"Unexpected error while disabling CTE for periodic advertising chain, err: %d",
	err);
	/* Validate result */
	common_validate_per_adv_chain(adv, expected_pdu_in_chain_after_cte_disable);

	/* Swap PDU double buffer to check correctness of release former PDUs */
	pdu_new = lll_adv_sync_data_latest_get(adv->lll.sync, NULL, &upd);
	zassert_not_equal(pdu_new, NULL,
	"Unexpected value of PDU pointer after PDU double buffer swap");

	/* Validate number of released PDUs */

	/* Number of free PDUs in a fifo is a number of released PDUs from former periodic
	* advertising chain. One free PDU that had been in a fifo was used for allocation of
	* the new PDU without CTE.
	*/
	pdu_fifo_cnt = lll_adv_free_pdu_fifo_count_get();
	zassert_equal(pdu_fifo_cnt, expected_end_fifo_free_pdu_count,
	"Unexpected number of free PDUs in a fifo: %d", pdu_fifo_cnt);

	/* Number of free PDUs in memory pool may decreased. Single PDU for AUX_SYNC_IND was
	* acquired from free PDUs fifo. The memory pool will decrease by number of non empty PDUs
	* in a chain subtracted by 1 (PDU taken from free PDUs fifo).
	*/
	pdu_mem_cnt_expected -= expected_mem_pdu_used_count_for_disable;

	pdu_mem_cnt = lll_adv_pdu_mem_free_count_get();
	zassert_equal(pdu_mem_cnt, pdu_mem_cnt_expected,
	"Unexpected amount of free PDUs memory: %d, expected %d", pdu_mem_cnt,
	pdu_mem_cnt_expected);

	common_teardown(adv);
	}

	ZTEST(test_add_cte_to_per_adv_chain,
	test_remove_cte_from_chain_extended_to_tx_all_cte_after_enqueue_to_lll)
	{
	uint8_t cte_count = TEST_CTE_COUNT;
	uint8_t init_chain_length = TEST_PER_ADV_SINGLE_PDU;
	uint8_t expected_mem_pdu_used_count_for_enable = TEST_CTE_COUNT + TEST_PER_ADV_SINGLE_PDU;
	uint8_t expected_mem_pdu_used_count_for_disable = 0;
	uint8_t expected_pdu_in_chain_after_cte_disable = TEST_PER_ADV_SINGLE_PDU;
	uint8_t updated_chain_length = 0;
	uint8_t expected_end_fifo_free_pdu_count = TEST_CTE_COUNT;
	bool new_chain_before_cte_disable = false;

	remove_cte_from_chain_after_enqueue_to_lll(
	cte_count, init_chain_length, expected_mem_pdu_used_count_for_enable,
	expected_mem_pdu_used_count_for_disable, expected_pdu_in_chain_after_cte_disable,
	updated_chain_length, expected_end_fifo_free_pdu_count,
	new_chain_before_cte_disable);
	}

	ZTEST(test_add_cte_to_per_adv_chain,
	test_remove_cte_from_chain_with_more_pdu_than_cte_after_enqueue_to_lll)
	{
	uint8_t cte_count = TEST_CTE_COUNT;
	uint8_t init_chain_length = TEST_PER_ADV_CHAIN_LENGTH;
	uint8_t expected_mem_pdu_used_count_for_enable =
	TEST_PER_ADV_CHAIN_LENGTH + TEST_PER_ADV_SINGLE_PDU;
	uint8_t expected_mem_pdu_used_count_for_disable =
	TEST_PER_ADV_CHAIN_LENGTH - TEST_PER_ADV_SINGLE_PDU;
	uint8_t expected_pdu_in_chain_after_cte_disable = TEST_PER_ADV_CHAIN_LENGTH;
	uint8_t updated_chain_length = 0;
	uint8_t expected_end_fifo_free_pdu_count = TEST_PER_ADV_CHAIN_LENGTH;
	bool new_chain_before_cte_disable = false;

	remove_cte_from_chain_after_enqueue_to_lll(
	cte_count, init_chain_length, expected_mem_pdu_used_count_for_enable,
	expected_mem_pdu_used_count_for_disable, expected_pdu_in_chain_after_cte_disable,
	updated_chain_length, expected_end_fifo_free_pdu_count,
	new_chain_before_cte_disable);
	}

	ZTEST(test_add_cte_to_per_adv_chain,
	test_remove_cte_from_chain_length_increased_after_enqueue_to_lll)
	{
	uint8_t cte_count = TEST_CTE_COUNT;
	uint8_t init_chain_length = TEST_PER_ADV_CHAIN_LENGTH;
	uint8_t expected_mem_pdu_used_count_for_enable =
	TEST_PER_ADV_CHAIN_LENGTH + TEST_PER_ADV_SINGLE_PDU;
	uint8_t expected_mem_pdu_used_count_for_disable =
	TEST_PER_ADV_CHAIN_INCREASED_LENGTH - TEST_PER_ADV_SINGLE_PDU;
	uint8_t expected_pdu_in_chain_after_cte_disable = TEST_PER_ADV_CHAIN_INCREASED_LENGTH;
	uint8_t updated_chain_length = TEST_PER_ADV_CHAIN_INCREASED_LENGTH;
	uint8_t expected_end_fifo_free_pdu_count = TEST_PER_ADV_CHAIN_LENGTH;
	bool new_chain_before_cte_disable = true;

	remove_cte_from_chain_after_enqueue_to_lll(
	cte_count, init_chain_length, expected_mem_pdu_used_count_for_enable,
	expected_mem_pdu_used_count_for_disable, expected_pdu_in_chain_after_cte_disable,
	updated_chain_length, expected_end_fifo_free_pdu_count,
	new_chain_before_cte_disable);
	}

	ZTEST(test_add_cte_to_per_adv_chain,
	test_remove_cte_from_chain_length_decreased_after_enqueue_to_lll)
	{
	uint8_t cte_count = TEST_CTE_COUNT;
	uint8_t init_chain_length = TEST_PER_ADV_CHAIN_LENGTH;
	uint8_t expected_mem_pdu_used_count_for_enable =
	TEST_PER_ADV_CHAIN_LENGTH + TEST_PER_ADV_SINGLE_PDU;
	uint8_t expected_mem_pdu_used_count_for_disable =
	TEST_PER_ADV_CHAIN_DECREASED_LENGTH - TEST_PER_ADV_SINGLE_PDU;
	uint8_t expected_pdu_in_chain_after_cte_disable = TEST_PER_ADV_CHAIN_DECREASED_LENGTH;
	uint8_t updated_chain_length = TEST_PER_ADV_CHAIN_DECREASED_LENGTH;
	uint8_t expected_end_fifo_free_pdu_count = TEST_PER_ADV_CHAIN_LENGTH;
	bool new_chain_before_cte_disable = true;

	remove_cte_from_chain_after_enqueue_to_lll(
	cte_count, init_chain_length, expected_mem_pdu_used_count_for_enable,
	expected_mem_pdu_used_count_for_disable, expected_pdu_in_chain_after_cte_disable,
	updated_chain_length, expected_end_fifo_free_pdu_count,
	new_chain_before_cte_disable);
	}

	ZTEST_SUITE(test_remove_cte_from_per_adv_chain, NULL, NULL, NULL, NULL, NULL);