tests: Bluetooth: Add BT Tester GAP smoke test

Add a babblesim test of the BT Tester doing a GAP smoke test
connecting 2 BT testers using BTP.

The purpose of this is to further increase the test coverage
of the BT Tester in CI, as it is only being built, and runtime
errors are typically not caught.

Signed-off-by: Emil Gydesen <emil.gydesen@nordicsemi.no>

tests/bluetooth/tester/CMakeLists.txt

@@ -7,6 +7,13 @@ LIST(APPEND QEMU_EXTRA_FLAGS -serial unix:/tmp/bt-stack-tester)
 find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
 project(tester)
 
+if(CONFIG_SOC_SERIES_BSIM_NRFXX)
+zephyr_include_directories(
+  ${BSIM_COMPONENTS_PATH}/libUtilv1/src/
+  ${BSIM_COMPONENTS_PATH}/libPhyComv1/src/
+  )
+endif() # CONFIG_SOC_SERIES_BSIM_NRFXX
+
 zephyr_library_include_directories(${ZEPHYR_BASE}/samples/bluetooth)
 zephyr_library_include_directories(${ZEPHYR_BASE}/subsys/bluetooth/mesh)
 zephyr_library_include_directories(${ZEPHYR_BASE}/subsys/bluetooth/host)

tests/bluetooth/tester/boards/nrf52_bsim.conf

@@ -0,0 +1,13 @@
+# CONFIG_TEST enforces minimal logging, which we don't want
+CONFIG_TEST=n
+
+CONFIG_ASSERT=y
+CONFIG_THREAD_NAME=y
+
+CONFIG_LOG=y
+CONFIG_LOG_BACKEND_SHOW_COLOR=y
+
+CONFIG_LOG_DEFAULT_LEVEL=3
+CONFIG_BTTESTER_LOG_LEVEL_DBG=y
+
+CONFIG_UART_PIPE=n

tests/bluetooth/tester/boards/nrf5340bsim_nrf5340_cpuapp.conf

@@ -0,0 +1,13 @@
+# CONFIG_TEST enforces minimal logging, which we don't want
+CONFIG_TEST=n
+
+CONFIG_ASSERT=y
+CONFIG_THREAD_NAME=y
+
+CONFIG_LOG=y
+CONFIG_LOG_BACKEND_SHOW_COLOR=y
+
+CONFIG_LOG_DEFAULT_LEVEL=3
+CONFIG_BTTESTER_LOG_LEVEL_DBG=y
+
+CONFIG_UART_PIPE=n

tests/bluetooth/tester/src/btp.c

@@ -185,6 +185,19 @@ static void uart_send(const uint8_t *data, size_t len)
 {
 	uart_pipe_send(data, len);
 }
+#elif defined(CONFIG_SOC_SERIES_BSIM_NRFXX)
+extern void btp_register_tester(uint8_t *buffer, size_t len, uart_pipe_recv_cb cb);
+extern void btp_send_to_bsim(const uint8_t *data, size_t len);
+
+static void uart_init(uint8_t *data)
+{
+	btp_register_tester(data, BTP_MTU, recv_cb);
+}
+
+static void uart_send(const uint8_t *data, size_t len)
+{
+	btp_send_to_bsim(data, len);
+}
 #else /* !CONFIG_UART_PIPE */
 static uint8_t *recv_buf;
 static size_t recv_off;

tests/bluetooth/tester/src/btp/btp.h

@@ -87,6 +87,8 @@
 
 #define BTP_STATUS_VAL(err) (err) ? BTP_STATUS_FAILED : BTP_STATUS_SUCCESS
 
+#define BTP_EVENT_OPCODE 0x80
+
 /* TODO indicate delay response, should be removed when all commands are
  * converted to cmd+status+ev pattern
  */

tests/bluetooth/tester/src/btp_gap.c

@@ -723,8 +723,9 @@ static uint8_t start_advertising(const void *cmd, uint16_t cmd_len,
 	 * type.
 	 */
 	if ((cmd_len < sizeof(*cp)) ||
-	    (cmd_len != sizeof(*cp) + cp->adv_data_len + cp->scan_rsp_len +
-			    sizeof(duration) + sizeof(own_addr_type))) {
+	    (cmd_len != sizeof(*cp) + cp->adv_data_len + cp->scan_rsp_len + sizeof(duration) +
+				sizeof(own_addr_type))) {
+		LOG_DBG("Invalid command length: %u", cmd_len);
 		return BTP_STATUS_FAILED;
 	}
 
@@ -759,6 +760,7 @@ static uint8_t start_advertising(const void *cmd, uint16_t cmd_len,
 
 	err = tester_gap_create_adv_instance(&param, own_addr_type, ad, adv_len, sd, sd_len, NULL);
 	if (err != 0) {
+		LOG_DBG("Failed to create adv instance: %d", err);
 		return BTP_STATUS_FAILED;
 	}
 
@@ -771,7 +773,7 @@ static uint8_t start_advertising(const void *cmd, uint16_t cmd_len,
 
 	/* BTP API don't allow to set empty scan response data. */
 	if (err < 0) {
-		LOG_ERR("Failed to start advertising");
+		LOG_ERR("Failed to start advertising: %d");
 
 		return BTP_STATUS_FAILED;
 	}

tests/bluetooth/tester/src/main.c

@@ -2,14 +2,22 @@
 
 /*
  * Copyright (c) 2015-2016 Intel Corporation
+ * Copyright (c) 2025 Nordic Semiconductor ASA
  *
  * SPDX-License-Identifier: Apache-2.0
  */
 
+#include <zephyr/autoconf.h>
+
 #include <zephyr/kernel.h>
+#include <zephyr/sys/util_macro.h>
 #include <zephyr/types.h>
 #include <zephyr/toolchain.h>
 
+#if defined(CONFIG_SOC_SERIES_BSIM_NRFXX)
+#include "bstests.h"
+#endif /* CONFIG_SOC_SERIES_BSIM_NRFXX */
+
 #include <zephyr/logging/log.h>
 #define LOG_MODULE_NAME bttester_main
 LOG_MODULE_REGISTER(LOG_MODULE_NAME, CONFIG_BTTESTER_LOG_LEVEL);
@@ -19,5 +27,10 @@ LOG_MODULE_REGISTER(LOG_MODULE_NAME, CONFIG_BTTESTER_LOG_LEVEL);
 int main(void)
 {
 	tester_init();
+
+#if defined(CONFIG_SOC_SERIES_BSIM_NRFXX)
+	bst_main();
+#endif /* CONFIG_SOC_SERIES_BSIM_NRFXX */
+
 	return 0;
 }

tests/bsim/bluetooth/tester/CMakeLists.txt

@@ -0,0 +1,29 @@
+# SPDX-License-Identifier: Apache-2.0
+
+cmake_minimum_required(VERSION 3.20.0)
+
+find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
+project(tester_bsim)
+
+# Add the BSIM tester
+add_subdirectory(${ZEPHYR_BASE}/tests/bluetooth/tester ${CMAKE_BINARY_DIR}/tester_build)
+
+# This contains babblesim-specific helpers, e.g. device synchronization.
+add_subdirectory(${ZEPHYR_BASE}/tests/bsim/babblekit babblekit)
+target_link_libraries(app PRIVATE babblekit)
+
+# Add the testlib
+add_subdirectory(${ZEPHYR_BASE}/tests/bluetooth/common/testlib testlib)
+target_link_libraries(app PRIVATE testlib)
+
+zephyr_include_directories(
+  ${BSIM_COMPONENTS_PATH}/libUtilv1/src/
+  ${BSIM_COMPONENTS_PATH}/libPhyComv1/src/
+  )
+
+target_sources(app PRIVATE
+  src/btp.c
+  src/gap_central.c
+  src/gap_peripheral.c
+  src/test_main.c
+)

tests/bsim/bluetooth/tester/Kconfig

@@ -0,0 +1,4 @@
+# Copyright (c) 2024-2025 Nordic Semiconductor ASA
+# SPDX-License-Identifier: Apache-2.0
+
+source "${ZEPHYR_BASE}/tests/bluetooth/tester/Kconfig"

tests/bsim/bluetooth/tester/Kconfig.sysbuild

@@ -0,0 +1,10 @@
+# Copyright (c) 2023-2025 Nordic Semiconductor ASA
+# SPDX-License-Identifier: Apache-2.0
+
+source "${ZEPHYR_BASE}/tests/bluetooth/tester/Kconfig.sysbuild"
+
+config NATIVE_SIMULATOR_PRIMARY_MCU_INDEX
+	int
+	# Let's pass the test arguments to the application MCU test
+	# otherwise by default they would have gone to the net core.
+	default 0 if $(BOARD_TARGET_STRING) = "NRF5340BSIM_NRF5340_CPUAPP"

tests/bsim/bluetooth/tester/prj.conf

@@ -0,0 +1,2 @@
+# Please build using the sample configuration file:
+# ${ZEPHYR_BASE}/tests/bluetooth/tester/prj.conf

tests/bsim/bluetooth/tester/src/btp.c

@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) 2025 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include <stdint.h>
+#include <stddef.h>
+#include <string.h>
+
+#include <zephyr/drivers/uart_pipe.h>
+#include <zephyr/kernel.h>
+#include <zephyr/logging/log.h>
+#include <zephyr/sys/util.h>
+#include <zephyr/sys_clock.h>
+
+#include "babblekit/testcase.h"
+
+#include "btp/btp.h"
+
+LOG_MODULE_REGISTER(bsim_btp, CONFIG_BTTESTER_LOG_LEVEL);
+
+static uint8_t *btp_buffer;
+static size_t btp_buffer_len;
+static uart_pipe_recv_cb btp_cb;
+
+K_MSGQ_DEFINE(btp_rsp_queue, BTP_MTU, 2, 4);
+K_MSGQ_DEFINE(btp_evt_queue, BTP_MTU, 100, 4);
+
+static void wait_for_response(const struct btp_hdr *cmd_hdr)
+{
+	const struct btp_hdr *rsp_hdr;
+	uint8_t rsp_buffer[BTP_MTU + sizeof(*rsp_hdr)];
+	int err;
+
+	err = k_msgq_get(&btp_rsp_queue, rsp_buffer, K_SECONDS(1));
+	TEST_ASSERT(err == 0, "err %d", err);
+
+	rsp_hdr = (struct btp_hdr *)rsp_buffer;
+	TEST_ASSERT(rsp_hdr->len <= BTP_MTU, "len %u > %d", rsp_hdr->len, BTP_MTU);
+
+	LOG_DBG("rsp service %u and opcode %u len %u", cmd_hdr->service, cmd_hdr->opcode,
+		rsp_hdr->len);
+
+	/* If rsp_hdr->len > 0 then the response contains extra data which is sent in a separate
+	 * evt
+	 */
+	if (rsp_hdr->len > 0) {
+		err = k_msgq_get(&btp_rsp_queue, rsp_buffer + sizeof(*rsp_hdr), K_SECONDS(1));
+		TEST_ASSERT(err == 0, "err %d", err);
+	}
+
+	TEST_ASSERT(rsp_hdr->service == cmd_hdr->service && rsp_hdr->opcode == cmd_hdr->opcode);
+}
+
+/* BTP communication is inspired from `uart_pipe_rx` to achieve a similar API */
+void btp_send_to_tester(const uint8_t *data, size_t len)
+{
+	const struct btp_hdr *cmd_hdr;
+	size_t offset = len;
+
+	TEST_ASSERT(data != NULL);
+	TEST_ASSERT(btp_buffer != NULL);
+	TEST_ASSERT(len <= btp_buffer_len, "len %zu > %zu", len, btp_buffer_len);
+	TEST_ASSERT(len > sizeof(*cmd_hdr), "len %zu <= %zu", len, sizeof(*cmd_hdr));
+
+	memcpy(btp_buffer, data, len);
+
+	cmd_hdr = (const struct btp_hdr *)data;
+	LOG_DBG("cmd service %u and opcode %u", cmd_hdr->service, cmd_hdr->opcode);
+	btp_buffer = btp_cb(btp_buffer, &offset);
+	TEST_ASSERT(offset == 0U);
+
+	wait_for_response(cmd_hdr);
+}
+
+void btp_register_tester(uint8_t *buffer, size_t len, uart_pipe_recv_cb cb)
+{
+	TEST_ASSERT(cb != NULL);
+	TEST_ASSERT(buffer != NULL);
+	TEST_ASSERT(len > sizeof(struct btp_hdr), "len %zu", len);
+	TEST_ASSERT(len <= BTP_MTU, "len %zu > %d", len, BTP_MTU);
+
+	btp_buffer = buffer;
+	btp_buffer_len = len;
+	btp_cb = cb;
+
+	LOG_INF("btp registered with %p %zu %p", buffer, len, cb);
+}
+
+void btp_send_to_bsim(const uint8_t *data, size_t len)
+{
+	static const struct btp_hdr *hdr;
+	uint8_t buffer[BTP_MTU] = {};
+	bool clear_hdr;
+
+	TEST_ASSERT(len >= 0);
+	TEST_ASSERT(data != NULL);
+	TEST_ASSERT(len <= BTP_MTU, "len %zu < %d", len, BTP_MTU);
+	TEST_ASSERT((hdr == NULL && len == sizeof(*hdr)) || (hdr != NULL && len == hdr->len),
+		    "len %zu hdr %p (%u)", len, hdr, hdr == NULL ? 0 : hdr->len);
+
+	memcpy(buffer, data, len);
+
+	/* tester_send_with_index keeps the header intact when sending a packet with additional data
+	 * determined by hdr->len. Because of this, we can keep a reference to the received header
+	 * while awaiting the additional data
+	 */
+	if (hdr == NULL) {
+		hdr = (const struct btp_hdr *)data;
+		LOG_DBG("hdr service %u and opcode %u", hdr->service, hdr->opcode);
+		clear_hdr = hdr->len == 0; /* we are not awaiting additional data if hdr->len == 0*/
+	} else {
+		clear_hdr = true;
+	}
+
+	TEST_ASSERT(hdr->opcode != BTP_STATUS, "hdr service %u", hdr->service);
+
+	if (hdr->opcode < BTP_EVENT_OPCODE) {
+		int err;
+
+		err = k_msgq_put(&btp_rsp_queue, buffer, K_NO_WAIT);
+		TEST_ASSERT(err == 0, "err %d", err);
+	} else {
+		if (k_msgq_put(&btp_evt_queue, buffer, K_NO_WAIT) != 0) {
+			int err;
+
+			/* Discard the oldest message and put the new message */
+			err = k_msgq_get(&btp_evt_queue, NULL, K_NO_WAIT);
+			TEST_ASSERT(err == 0, "err %d", err);
+			err = k_msgq_put(&btp_evt_queue, buffer, K_NO_WAIT);
+			TEST_ASSERT(err == 0, "err %d", err);
+		}
+	}
+
+	if (clear_hdr) {
+		hdr = NULL;
+	}
+}
+
+void btp_wait_for_evt(const struct btp_hdr evt_hdr)
+{
+	LOG_DBG("Waiting for evt with service %u and opcode %u", evt_hdr.service, evt_hdr.opcode);
+
+	while (true) {
+		const struct btp_hdr *hdr;
+		uint8_t evt_buffer[BTP_MTU];
+		int err;
+
+		err = k_msgq_get(&btp_evt_queue, evt_buffer, K_FOREVER);
+		TEST_ASSERT(err == 0, "err %d", err);
+
+		hdr = (struct btp_hdr *)evt_buffer;
+		LOG_DBG("evt service %u and opcode %u", hdr->service, hdr->opcode);
+		if (hdr->service == evt_hdr.service && hdr->opcode == evt_hdr.opcode) {
+			return;
+		}
+	}
+}