adafruit-mirror/zephyr
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 9

Bluetooth: Host: bsim: Refactor common files

Browse source 
This commit deals mainly with bsim tests which have `common.c/h` files.
It does the following changes:
* Use functionality from the `babbelkit` library for common functions
  related to flags, test progression (failing, passing etc.) and
  synchronization between two devices. Locally defined equivalents are
  removed.
* Remove the `common.c/h` containing only functionality that is provided
  by the `babblekit` library.
* Remove the `test_pre_init_f` and `test_tick_f` functions (commonly
  implemented as `test_init` and `test_tick`) from the modified tests.
  These functions are not needed as they were only used to fail the test
  if a device didn't complete the test within a certain time frame. This
  is already handled by the `sim_length` argument used in the test
  scripts.
* Changes use of `atol` to `strtol` as the prior is against Zephyr
  coding guidelines.

Signed-off-by: Håvard Reierstad <haavard.reierstad@nordicsemi.no>
This commit is contained in:
Håvard Reierstad 2025-01-15 12:30:27 +01:00 committed by Benjamin Cabé
parent bc7c717c41
commit fe923670a9
123 changed files with 1012 additions and 2619 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
tests/bsim/bluetooth/host/adv/encrypted/css_sample_data/CMakeLists.txt
View file

@ -5,6 +5,9 @@ cmake_minimum_required(VERSION 3.20.0)
find_package(Zephyr HINTS $ENV{ZEPHYR_BASE})
project(bsim_test_ead_css_sample_data)
add_subdirectory(${ZEPHYR_BASE}/tests/bsim/babblekit babblekit)
target_link_libraries(app PRIVATE babblekit)
target_sources(app PRIVATE
src/main.c
src/common.c

21
tests/bsim/bluetooth/host/adv/encrypted/css_sample_data/src/central.c
View file

@ -2,6 +2,7 @@
* SPDX-License-Identifier: Apache-2.0
*/
#include "babblekit/testcase.h"
#include "common.h"
extern const struct test_sample_data *sample_data;
@ -19,9 +20,8 @@ static bool data_parse_cb(struct bt_data *data, void *user_data)
if (decrypted_data_size != sample_data->size_ad_data) {
LOG_ERR("Size of decrypted data: %d", decrypted_data_size);
LOG_ERR("Size of sample data: %d", sample_data->size_ad_data);
FAIL("Computed size of data does not match the size of the data from the "
"sample. (data set %d)\n",
data_set);
TEST_FAIL("Computed size of data does not match the size of the data from "
"the sample. (data set %d)", data_set);
}
if (memcmp(sample_data->randomizer_little_endian, data->data,
@ -31,7 +31,7 @@ static bool data_parse_cb(struct bt_data *data, void *user_data)
LOG_ERR("Expected Randomizer from sample: %s",
bt_hex(sample_data->randomizer_little_endian,
BT_EAD_RANDOMIZER_SIZE));
FAIL("Received Randomizer does not match the expected one.\n");
TEST_FAIL("Received Randomizer does not match the expected one.");
}
net_buf_simple_init_with_data(&decrypted_buf, decrypted_payload,
@ -40,22 +40,21 @@ static bool data_parse_cb(struct bt_data *data, void *user_data)
err = bt_ead_decrypt(sample_data->session_key, sample_data->iv, data->data,
data->data_len, decrypted_buf.data);
if (err != 0) {
FAIL("Error during decryption.\n");
TEST_FAIL("Error during decryption.");
} else if (memcmp(decrypted_buf.data, sample_data->ad_data, decrypted_data_size)) {
LOG_HEXDUMP_ERR(decrypted_buf.data, decrypted_data_size,
"Decrypted data from bt_ead_decrypt:");
LOG_HEXDUMP_ERR(sample_data->ad_data, sample_data->size_ad_data,
"Expected data from sample:");
FAIL("Decrypted AD data does not match expected sample data. (data set "
"%d)\n",
data_set);
TEST_FAIL("Decrypted AD data does not match expected sample data. (data set"
" %d)", data_set);
}
LOG_HEXDUMP_DBG(decrypted_buf.data, decrypted_data_size, "Raw decrypted data: ");
bt_data_parse(&decrypted_buf, &data_parse_cb, NULL);
PASS("Central test passed. (data set %d)\n", data_set);
TEST_PASS("Central test passed. (data set %d)", data_set);
return false;
}
@ -86,7 +85,7 @@ static void start_scan(void)
err = bt_le_scan_start(BT_LE_SCAN_PASSIVE, device_found);
if (err) {
FAIL("Scanning failed to start (err %d)\n", err);
TEST_FAIL("Scanning failed to start (err %d)", err);
}
LOG_DBG("Scanning successfully started");
@ -100,7 +99,7 @@ void test_central(void)
err = bt_enable(NULL);
if (err) {
FAIL("Bluetooth init failed (err %d)\n", err);
TEST_FAIL("Bluetooth init failed (err %d)", err);
}
LOG_DBG("Bluetooth initialized");

23
tests/bsim/bluetooth/host/adv/encrypted/css_sample_data/src/common.h
View file

@ -46,29 +46,6 @@ int bt_test_ead_encrypt(const uint8_t session_key[BT_EAD_KEY_SIZE],
const uint8_t randomizer[BT_EAD_RANDOMIZER_SIZE], const uint8_t *payload,
size_t payload_size, uint8_t *encrypted_payload);
#define FAIL(...) \
do { \
bst_result = Failed; \
bs_trace_error_time_line(__VA_ARGS__); \
} while (0)
#define PASS(...) \
do { \
bst_result = Passed; \
bs_trace_info_time(1, __VA_ARGS__); \
} while (0)
extern enum bst_result_t bst_result;
#define CREATE_FLAG(flag) static atomic_t flag = (atomic_t) false
#define SET_FLAG(flag) (void)atomic_set(&flag, (atomic_t) true)
#define GET_FLAG(flag) (bool)atomic_get(&flag)
#define UNSET_FLAG(flag) (void)atomic_set(&flag, (atomic_t) false)
#define WAIT_FOR_FLAG(flag) \
while (!(bool)atomic_get(&flag)) { \
(void)k_sleep(K_MSEC(1)); \
}
LOG_MODULE_DECLARE(bt_bsim_ead_sample_data, CONFIG_BT_EAD_LOG_LEVEL);
struct test_sample_data {

26
tests/bsim/bluetooth/host/adv/encrypted/css_sample_data/src/main.c
View file

@ -2,51 +2,25 @@
* SPDX-License-Identifier: Apache-2.0
*/
#include "bs_types.h"
#include "bs_tracing.h"
#include "bstests.h"
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(bt_bsim_ead_sample_data, CONFIG_BT_EAD_LOG_LEVEL);
extern enum bst_result_t bst_result;
#define WAIT_TIME_S 20
#define WAIT_TIME (WAIT_TIME_S * 1e6)
extern void test_central(void);
extern void test_peripheral(void);
extern void test_args_parse(int argc, char *argv[]);
void test_tick(bs_time_t HW_device_time)
{
if (bst_result != Passed) {
bst_result = Failed;
bs_trace_error_time_line("Test failed (not passed after %d seconds)\n",
WAIT_TIME_S);
}
}
static void test_ead_sample_data_init(void)
{
bst_ticker_set_next_tick_absolute(WAIT_TIME);
bst_result = In_progress;
}
static const struct bst_test_instance test_def[] = {
{
.test_id = "central",
.test_descr = "Central device",
.test_pre_init_f = test_ead_sample_data_init,
.test_tick_f = test_tick,
.test_main_f = test_central,
.test_args_f = test_args_parse,
},
{
.test_id = "peripheral",
.test_descr = "Peripheral device",
.test_pre_init_f = test_ead_sample_data_init,
.test_tick_f = test_tick,
.test_main_f = test_peripheral,
.test_args_f = test_args_parse,
},

23
tests/bsim/bluetooth/host/adv/encrypted/css_sample_data/src/peripheral.c
View file

@ -2,6 +2,7 @@
* SPDX-License-Identifier: Apache-2.0
*/
#include "babblekit/testcase.h"
#include "common.h"
extern const struct test_sample_data *sample_data;
@ -25,7 +26,7 @@ static void create_adv(struct bt_le_ext_adv **adv)
err = bt_le_ext_adv_create(&params, NULL, adv);
if (err) {
FAIL("Failed to create advertiser (%d)\n", err);
TEST_FAIL("Failed to create advertiser (%d)", err);
}
}
@ -42,7 +43,7 @@ static void start_adv(struct bt_le_ext_adv *adv)
err = bt_le_ext_adv_start(adv, &start_params);
if (err) {
FAIL("Failed to start advertiser (%d)\n", err);
TEST_FAIL("Failed to start advertiser (%d)", err);
}
LOG_DBG("Advertiser started");
@ -60,23 +61,21 @@ static void set_ad_data(struct bt_le_ext_adv *adv)
if (size_ead != sample_data->size_ead) {
LOG_ERR("Size of ead: %zu\n", size_ead);
LOG_ERR("Size of sample_ead: %zu", sample_data->size_ead);
FAIL("Computed size of encrypted data does not match the size of the encrypted "
"data from the sample. (data set %d)\n",
data_set);
TEST_FAIL("Computed size of encrypted data does not match the size of the encrypted"
" data from the sample. (data set %d)", data_set);
}
err = bt_test_ead_encrypt(sample_data->session_key, sample_data->iv,
sample_data->randomizer_little_endian, sample_data->ad_data,
size_ad_data, ead);
if (err != 0) {
FAIL("Error during encryption.\n");
TEST_FAIL("Error during encryption.");
} else if (memcmp(ead, sample_data->ead, sample_data->size_ead) != 0) {
LOG_HEXDUMP_ERR(ead, size_ead, "Encrypted data from bt_ead_encrypt:");
LOG_HEXDUMP_ERR(sample_data->ead, sample_data->size_ead,
"Encrypted data from sample:");
FAIL("Encrypted AD data does not match the ones provided in the sample. (data set "
"%d)\n",
data_set);
TEST_FAIL("Encrypted AD data does not match the ones provided in the sample. (data"
" set %d)", data_set);
}
LOG_HEXDUMP_DBG(ead, size_ead, "Encrypted data:");
@ -87,10 +86,10 @@ static void set_ad_data(struct bt_le_ext_adv *adv)
err = bt_le_ext_adv_set_data(adv, &ead_struct, 1, NULL, 0);
if (err) {
FAIL("Failed to set advertising data (%d)\n", err);
TEST_FAIL("Failed to set advertising data (%d)", err);
}
PASS("Peripheral test passed. (data set %d)\n", data_set);
TEST_PASS("Peripheral test passed. (data set %d)", data_set);
}
void test_peripheral(void)
@ -102,7 +101,7 @@ void test_peripheral(void)
err = bt_enable(NULL);
if (err) {
FAIL("Bluetooth init failed (err %d)\n", err);
TEST_FAIL("Bluetooth init failed (err %d)", err);
}
LOG_DBG("Bluetooth initialized");

4
tests/bsim/bluetooth/host/adv/encrypted/css_sample_data/test_scripts/run_tests.sh
View file

@ -21,7 +21,7 @@ Execute ./"$test_exe" \
-RealEncryption=1 -argstest data-set="${data_set}"
Execute ./bs_2G4_phy_v1 -v=${verbosity_level} -s="${simulation_id}_${data_set}" \
-D=2 -sim_length=60e6 $@
-D=2 -sim_length=20e6 $@
wait_for_background_jobs
@ -36,6 +36,6 @@ Execute ./"$test_exe" \
-RealEncryption=1 -argstest data-set="${data_set}"
Execute ./bs_2G4_phy_v1 -v=${verbosity_level} -s="${simulation_id}_${data_set}" \
-D=2 -sim_length=60e6 $@
-D=2 -sim_length=20e6 $@
wait_for_background_jobs

6
tests/bsim/bluetooth/host/adv/extended/CMakeLists.txt
View file

@ -6,10 +6,8 @@ cmake_minimum_required(VERSION 3.20.0)
find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
project(bsim_test_ext_adv)
target_sources(app PRIVATE
src/common.c
)
add_subdirectory(${ZEPHYR_BASE}/tests/bsim/babblekit babblekit)
target_link_libraries(app PRIVATE babblekit)
target_sources_ifdef(CONFIG_BT_CENTRAL app PRIVATE
src/ext_adv_scanner.c

24
tests/bsim/bluetooth/host/adv/extended/src/common.c
View file

@ -1,24 +0,0 @@
/**
* Copyright (c) 2024 Croxel, Inc.
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <zephyr/kernel.h>
#include "bstests.h"
#include "common.h"
extern enum bst_result_t bst_result;
void test_tick(bs_time_t HW_device_time)
{
if (bst_result != Passed) {
FAIL("test failed (not passed after %i seconds)\n", WAIT_SECONDS);
}
}
void test_init(void)
{
bst_ticker_set_next_tick_absolute(WAIT_TIME);
bst_result = In_progress;
}

53
tests/bsim/bluetooth/host/adv/extended/src/common.h
View file

@ -1,53 +0,0 @@
/**
* Copyright (c) 2024 Croxel, Inc.
*
* SPDX-License-Identifier: Apache-2.0
*/
#ifndef ZEPHYR_TEST_BSIM_BT_EXT_ADV_TEST_
#define ZEPHYR_TEST_BSIM_BT_EXT_ADV_TEST_
#include <zephyr/kernel.h>
#include "bs_types.h"
#include "bs_tracing.h"
#include "time_machine.h"
#include "bstests.h"
#define WAIT_SECONDS 30 /* seconds */
#define WAIT_TIME (WAIT_SECONDS * USEC_PER_SEC) /* microseconds*/
#define CREATE_FLAG(flag) static atomic_t flag = (atomic_t)false
#define SET_FLAG(flag) (void)atomic_set(&flag, (atomic_t) true)
#define TEST_FLAG(flag) (atomic_get(&flag) == (atomic_t)true)
#define UNSET_FLAG(flag) (void)atomic_set(&flag, (atomic_t) false)
#define WAIT_FOR_FLAG(flag) \
while (!(bool)atomic_get(&flag)) { \
(void)k_sleep(K_MSEC(1)); \
}
#define WAIT_FOR_FLAG_UNSET(flag) \
while ((bool)atomic_get(&flag)) { \
(void)k_sleep(K_MSEC(1)); \
}
#define TAKE_FLAG(flag) \
while (!(bool)atomic_cas(&flag, true, false)) { \
(void)k_sleep(K_MSEC(1)); \
}
#define FAIL(...) \
do { \
bst_result = Failed; \
bs_trace_error_time_line(__VA_ARGS__); \
} while (0)
#define PASS(...) \
do { \
bst_result = Passed; \
bs_trace_info_time(1, "PASSED: " __VA_ARGS__); \
} while (0)
void test_tick(bs_time_t HW_device_time);
void test_init(void);
#endif /* ZEPHYR_TEST_BSIM_BT_EXT_ADV_TEST_ */

32
tests/bsim/bluetooth/host/adv/extended/src/ext_adv_advertiser.c
View file

@ -5,12 +5,8 @@
*/
#include <zephyr/kernel.h>
#include "common.h"
#include "bs_types.h"
#include "bs_tracing.h"
#include "time_machine.h"
#include "bstests.h"
#include "babblekit/testcase.h"
#include "babblekit/flags.h"
#include <zephyr/types.h>
#include <zephyr/sys/printk.h>
@ -22,8 +18,8 @@ extern enum bst_result_t bst_result;
static struct bt_conn *g_conn;
CREATE_FLAG(flag_connected);
CREATE_FLAG(flag_conn_recycled);
static DEFINE_FLAG(flag_connected);
static DEFINE_FLAG(flag_conn_recycled);
static void common_init(void)
{
@ -32,7 +28,7 @@ static void common_init(void)
err = bt_enable(NULL);
if (err) {
FAIL("Bluetooth init failed: %d\n", err);
TEST_FAIL("Bluetooth init failed: %d", err);
return;
}
printk("Bluetooth initialized\n");
@ -103,7 +99,7 @@ static void disconnect_from_target(void)
err = bt_conn_disconnect(g_conn, BT_HCI_ERR_REMOTE_USER_TERM_CONN);
if (err) {
FAIL("BT Disconnect failed: %d\n", err);
TEST_FAIL("BT Disconnect failed: %d", err);
return;
}
}
@ -115,13 +111,13 @@ static void connected(struct bt_conn *conn, uint8_t err)
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
if (err != BT_HCI_ERR_SUCCESS) {
FAIL("Failed to connect to %s: %u\n", addr, err);
TEST_FAIL("Failed to connect to %s: %u", addr, err);
return;
}
printk("Connected to %s\n", addr);
if (g_conn != NULL) {
FAIL("Attempt to override connection object without clean-up\n");
TEST_FAIL("Attempt to override connection object without clean-up");
return;
}
g_conn = bt_conn_ref(conn);
@ -182,7 +178,7 @@ static void main_ext_adv_advertiser(void)
ext_adv = NULL;
PASS("Extended advertiser passed\n");
TEST_PASS("Extended advertiser passed");
}
static void adv_connect_and_disconnect_cycle(void)
@ -228,7 +224,7 @@ static void main_ext_conn_adv_advertiser(void)
ext_adv = NULL;
PASS("Extended advertiser passed\n");
TEST_PASS("Extended advertiser passed");
}
static void main_ext_conn_adv_advertiser_x5(void)
@ -252,7 +248,7 @@ static void main_ext_conn_adv_advertiser_x5(void)
delete_adv_set(ext_adv);
ext_adv = NULL;
PASS("Extended advertiser passed\n");
TEST_PASS("Extended advertiser passed");
}
static const struct bst_test_instance ext_adv_advertiser[] = {
@ -260,16 +256,12 @@ static const struct bst_test_instance ext_adv_advertiser[] = {
.test_id = "ext_adv_advertiser",
.test_descr = "Basic extended advertising test. "
"Will just start extended advertising.",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = main_ext_adv_advertiser
},
{
.test_id = "ext_adv_conn_advertiser",
.test_descr = "Basic connectable extended advertising test. "
"Starts extended advertising, and restarts it after disconnecting",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = main_ext_conn_adv_advertiser
},
{
@ -277,8 +269,6 @@ static const struct bst_test_instance ext_adv_advertiser[] = {
.test_descr = "Basic connectable extended advertising test. "
"Starts extended advertising, and restarts it after disconnecting, "
"repeated over 5 times",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = main_ext_conn_adv_advertiser_x5
},
BSTEST_END_MARKER

39
tests/bsim/bluetooth/host/adv/extended/src/ext_adv_scanner.c
View file

@ -5,12 +5,8 @@
*/
#include <zephyr/kernel.h>
#include "common.h"
#include "bs_types.h"
#include "bs_tracing.h"
#include "time_machine.h"
#include "bstests.h"
#include "babblekit/testcase.h"
#include "babblekit/flags.h"
#include <zephyr/types.h>
#include <zephyr/sys/printk.h>
@ -22,9 +18,9 @@ extern enum bst_result_t bst_result;
static struct bt_conn *g_conn;
CREATE_FLAG(flag_ext_adv_seen);
CREATE_FLAG(flag_connected);
CREATE_FLAG(flag_conn_recycled);
static DEFINE_FLAG(flag_ext_adv_seen);
static DEFINE_FLAG(flag_connected);
static DEFINE_FLAG(flag_conn_recycled);
static void connected(struct bt_conn *conn, uint8_t err)
{
@ -33,7 +29,7 @@ static void connected(struct bt_conn *conn, uint8_t err)
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
if (err != BT_HCI_ERR_SUCCESS) {
FAIL("Failed to connect to %s: %u\n", addr, err);
TEST_FAIL("Failed to connect to %s: %u", addr, err);
bt_conn_unref(g_conn);
g_conn = NULL;
return;
@ -93,21 +89,20 @@ static void scan_recv(const struct bt_le_scan_recv_info *info,
SET_FLAG(flag_ext_adv_seen);
}
if (!TEST_FLAG(flag_connected) &&
info->adv_props & BT_GAP_ADV_PROP_CONNECTABLE) {
if (!IS_FLAG_SET(flag_connected) && info->adv_props & BT_GAP_ADV_PROP_CONNECTABLE) {
int err;
printk("Stopping scan\n");
err = bt_le_scan_stop();
if (err) {
FAIL("Failed to stop scan: %d", err);
TEST_FAIL("Failed to stop scan: %d", err);
return;
}
err = bt_conn_le_create(info->addr, BT_CONN_LE_CREATE_CONN,
BT_LE_CONN_PARAM_DEFAULT, &g_conn);
if (err) {
FAIL("Could not connect to peer: %d", err);
TEST_FAIL("Could not connect to peer: %d", err);
return;
}
}
@ -124,7 +119,7 @@ static void common_init(void)
err = bt_enable(NULL);
if (err) {
FAIL("Bluetooth init failed: %d\n", err);
TEST_FAIL("Bluetooth init failed: %d", err);
return;
}
@ -141,7 +136,7 @@ static void start_scan(void)
printk("Start scanning...");
err = bt_le_scan_start(BT_LE_SCAN_PASSIVE, NULL);
if (err) {
FAIL("Failed to start scan: %d\n", err);
TEST_FAIL("Failed to start scan: %d", err);
return;
}
printk("done.\n");
@ -156,7 +151,7 @@ static void main_ext_adv_scanner(void)
WAIT_FOR_FLAG(flag_ext_adv_seen);
PASS("Extended adv scanner passed\n");
TEST_PASS("Extended adv scanner passed");
}
static void scan_connect_and_disconnect_cycle(void)
@ -191,7 +186,7 @@ static void main_ext_adv_conn_scanner(void)
printk("Waiting to extended advertisements (again)...\n");
WAIT_FOR_FLAG(flag_ext_adv_seen);
PASS("Extended adv scanner passed\n");
TEST_PASS("Extended adv scanner passed");
}
static void main_ext_adv_conn_scanner_x5(void)
@ -207,7 +202,7 @@ static void main_ext_adv_conn_scanner_x5(void)
printk("Waiting to extended advertisements (again)...\n");
WAIT_FOR_FLAG(flag_ext_adv_seen);
PASS("Extended adv scanner x5 passed\n");
TEST_PASS("Extended adv scanner x5 passed");
}
static const struct bst_test_instance ext_adv_scanner[] = {
@ -215,8 +210,6 @@ static const struct bst_test_instance ext_adv_scanner[] = {
.test_id = "ext_adv_scanner",
.test_descr = "Basic extended advertising scanning test. "
"Will just scan an extended advertiser.",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = main_ext_adv_scanner
},
{
@ -224,8 +217,6 @@ static const struct bst_test_instance ext_adv_scanner[] = {
.test_descr = "Basic extended advertising scanning test. "
"Will scan an extended advertiser, connect "
"and verify it's detected after disconnection",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = main_ext_adv_conn_scanner
},
{
@ -234,8 +225,6 @@ static const struct bst_test_instance ext_adv_scanner[] = {
"Will scan an extended advertiser, connect "
"and verify it's detected after disconnection,"
"repeated over 5 times",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = main_ext_adv_conn_scanner_x5
},
BSTEST_END_MARKER

3
tests/bsim/bluetooth/host/adv/periodic/CMakeLists.txt
View file

@ -5,6 +5,9 @@ cmake_minimum_required(VERSION 3.20.0)
find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
project(bsim_test_audio)
add_subdirectory(${ZEPHYR_BASE}/tests/bsim/babblekit babblekit)
target_link_libraries(app PRIVATE babblekit)
target_sources(app PRIVATE
src/common.c
src/main.c

15
tests/bsim/bluetooth/host/adv/periodic/src/common.c
View file

@ -6,21 +6,6 @@
#include "common.h"
extern enum bst_result_t bst_result;
void test_tick(bs_time_t HW_device_time)
{
if (bst_result != Passed) {
FAIL("test failed (not passed after %i seconds)\n", WAIT_SECONDS);
}
}
void test_init(void)
{
bst_ticker_set_next_tick_absolute(WAIT_TIME);
bst_result = In_progress;
}
uint8_t mfg_data[254] = {
0xFF, 0xFF, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C,
0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B,

45
tests/bsim/bluetooth/host/adv/periodic/src/common.h
View file

@ -9,50 +9,7 @@
#ifndef ZEPHYR_TEST_BSIM_BT_AUDIO_TEST_
#define ZEPHYR_TEST_BSIM_BT_AUDIO_TEST_
#include <zephyr/kernel.h>
#include "bs_types.h"
#include "bs_tracing.h"
#include "time_machine.h"
#include "bstests.h"
#include <zephyr/types.h>
#include <stddef.h>
#include <errno.h>
#include <zephyr/sys_clock.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/uuid.h>
#include <zephyr/bluetooth/gatt.h>
#define WAIT_SECONDS 15 /* seconds */
#define WAIT_TIME (WAIT_SECONDS * USEC_PER_SEC) /* microseconds*/
#define CREATE_FLAG(flag) static atomic_t flag = (atomic_t)false
#define SET_FLAG(flag) (void)atomic_set(&flag, (atomic_t)true)
#define UNSET_FLAG(flag) (void)atomic_set(&flag, (atomic_t)false)
#define TEST_FLAG(flag) (atomic_get(&flag) == (atomic_t)true)
#define WAIT_FOR_FLAG(flag) \
while (!(bool)atomic_get(&flag)) { \
(void)k_sleep(K_MSEC(1)); \
}
#define FAIL(...) \
do { \
bst_result = Failed; \
bs_trace_error_time_line(__VA_ARGS__); \
} while (0)
#define PASS(...) \
do { \
bst_result = Passed; \
bs_trace_info_time(1, "PASSED: " __VA_ARGS__); \
} while (0)
void test_tick(bs_time_t HW_device_time);
void test_init(void);
#include <stdint.h>
extern uint8_t mfg_data[254];

44
tests/bsim/bluetooth/host/adv/periodic/src/per_adv_advertiser.c
View file

@ -3,26 +3,28 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <errno.h>
#include <zephyr/kernel.h>
#include "bs_types.h"
#include "bs_tracing.h"
#include "time_machine.h"
#include "bstests.h"
#include <zephyr/types.h>
#include <zephyr/sys_clock.h>
#include <zephyr/sys/printk.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/uuid.h>
#include <zephyr/bluetooth/gatt.h>
#include "babblekit/testcase.h"
#include "babblekit/flags.h"
#include "common.h"
extern enum bst_result_t bst_result;
static struct bt_conn *g_conn;
CREATE_FLAG(flag_connected);
CREATE_FLAG(flag_bonded);
static DEFINE_FLAG(flag_connected);
static DEFINE_FLAG(flag_bonded);
static void connected(struct bt_conn *conn, uint8_t err)
{
@ -31,7 +33,7 @@ static void connected(struct bt_conn *conn, uint8_t err)
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
if (err != BT_HCI_ERR_SUCCESS) {
FAIL("Failed to connect to %s: %u\n", addr, err);
TEST_FAIL("Failed to connect to %s: %u", addr, err);
return;
}
@ -75,7 +77,7 @@ static void common_init(void)
err = bt_enable(NULL);
if (err) {
FAIL("Bluetooth init failed: %d\n", err);
TEST_FAIL("Bluetooth init failed: %d", err);
return;
}
printk("Bluetooth initialized\n");
@ -249,7 +251,7 @@ static void main_per_adv_advertiser(void)
delete_adv_set(per_adv);
per_adv = NULL;
PASS("Periodic advertiser passed\n");
TEST_PASS("Periodic advertiser passed");
}
#if defined(CONFIG_BT_CTLR_PHY_CODED)
@ -273,7 +275,7 @@ static void main_per_adv_advertiser_coded(void)
delete_adv_set(per_adv);
per_adv = NULL;
PASS("Periodic advertiser coded PHY passed\n");
TEST_PASS("Periodic advertiser coded PHY passed");
}
#endif /* CONFIG_BT_CTLR_PHY_CODED */
@ -305,7 +307,7 @@ static void main_per_adv_conn_advertiser(void)
delete_adv_set(conn_adv);
conn_adv = NULL;
PASS("Periodic advertiser passed\n");
TEST_PASS("Periodic advertiser passed");
}
static void main_per_adv_conn_privacy_advertiser(void)
@ -341,7 +343,7 @@ static void main_per_adv_conn_privacy_advertiser(void)
delete_adv_set(conn_adv);
conn_adv = NULL;
PASS("Periodic advertiser passed\n");
TEST_PASS("Periodic advertiser passed");
}
static void main_per_adv_long_data_advertiser(void)
@ -366,7 +368,7 @@ static void main_per_adv_long_data_advertiser(void)
delete_adv_set(per_adv);
per_adv = NULL;
#endif
PASS("Periodic long data advertiser passed\n");
TEST_PASS("Periodic long data advertiser passed");
}
static const struct bst_test_instance per_adv_advertiser[] = {
@ -374,8 +376,6 @@ static const struct bst_test_instance per_adv_advertiser[] = {
.test_id = "per_adv_advertiser",
.test_descr = "Basic periodic advertising test. "
"Will just start periodic advertising.",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = main_per_adv_advertiser
},
#if defined(CONFIG_BT_CTLR_PHY_CODED)
@ -383,8 +383,6 @@ static const struct bst_test_instance per_adv_advertiser[] = {
.test_id = "per_adv_advertiser_coded_phy",
.test_descr = "Basic periodic advertising test on Coded PHY. "
"Advertiser and periodic advertiser uses Coded PHY",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = main_per_adv_advertiser_coded
},
#endif /* CONFIG_BT_CTLR_PHY_CODED */
@ -392,24 +390,18 @@ static const struct bst_test_instance per_adv_advertiser[] = {
.test_id = "per_adv_conn_advertiser",
.test_descr = "Periodic advertising test with concurrent ACL "
"and PA sync.",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = main_per_adv_conn_advertiser
},
{
.test_id = "per_adv_conn_privacy_advertiser",
.test_descr = "Periodic advertising test with concurrent ACL "
"with bonding and PA sync.",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = main_per_adv_conn_privacy_advertiser
},
{
.test_id = "per_adv_long_data_advertiser",
.test_descr = "Periodic advertising test with a longer data length. "
"To test the reassembly of large data packets",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = main_per_adv_long_data_advertiser
},
BSTEST_END_MARKER

72
tests/bsim/bluetooth/host/adv/periodic/src/per_adv_sync.c
View file

@ -3,18 +3,20 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <errno.h>
#include <zephyr/kernel.h>
#include "bs_types.h"
#include "bs_tracing.h"
#include "time_machine.h"
#include "bstests.h"
#include <zephyr/types.h>
#include <zephyr/sys_clock.h>
#include <zephyr/sys/printk.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/uuid.h>
#include <zephyr/bluetooth/gatt.h>
#include "babblekit/testcase.h"
#include "babblekit/flags.h"
#include "common.h"
extern enum bst_result_t bst_result;
@ -23,12 +25,12 @@ static struct bt_conn *g_conn;
static bt_addr_le_t per_addr;
static uint8_t per_sid;
CREATE_FLAG(flag_connected);
CREATE_FLAG(flag_bonded);
CREATE_FLAG(flag_per_adv);
CREATE_FLAG(flag_per_adv_sync);
CREATE_FLAG(flag_per_adv_sync_lost);
CREATE_FLAG(flag_per_adv_recv);
static DEFINE_FLAG(flag_connected);
static DEFINE_FLAG(flag_bonded);
static DEFINE_FLAG(flag_per_adv);
static DEFINE_FLAG(flag_per_adv_sync);
static DEFINE_FLAG(flag_per_adv_sync_lost);
static DEFINE_FLAG(flag_per_adv_recv);
static void connected(struct bt_conn *conn, uint8_t err)
{
@ -37,7 +39,7 @@ static void connected(struct bt_conn *conn, uint8_t err)
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
if (err != BT_HCI_ERR_SUCCESS) {
FAIL("Failed to connect to %s: %u\n", addr, err);
TEST_FAIL("Failed to connect to %s: %u", addr, err);
return;
}
@ -77,24 +79,24 @@ static struct bt_conn_auth_info_cb auto_info_cbs = {
static void scan_recv(const struct bt_le_scan_recv_info *info,
struct net_buf_simple *buf)
{
if (!TEST_FLAG(flag_connected) &&
if (!IS_FLAG_SET(flag_connected) &&
info->adv_props & BT_GAP_ADV_PROP_CONNECTABLE) {
int err;
printk("Stopping scan\n");
err = bt_le_scan_stop();
if (err != 0) {
FAIL("Failed to stop scan: %d", err);
TEST_FAIL("Failed to stop scan: %d", err);
return;
}
err = bt_conn_le_create(info->addr, BT_CONN_LE_CREATE_CONN,
BT_LE_CONN_PARAM_DEFAULT, &g_conn);
if (err != 0) {
FAIL("Could not connect to peer: %d", err);
TEST_FAIL("Could not connect to peer: %d", err);
return;
}
} else if (!TEST_FLAG(flag_per_adv) && info->interval != 0U) {
} else if (!IS_FLAG_SET(flag_per_adv) && info->interval != 0U) {
per_sid = info->sid;
bt_addr_le_copy(&per_addr, info->addr);
@ -142,7 +144,7 @@ static void recv_cb(struct bt_le_per_adv_sync *recv_sync,
char le_addr[BT_ADDR_LE_STR_LEN];
uint8_t buf_data_len;
if (TEST_FLAG(flag_per_adv_recv)) {
if (IS_FLAG_SET(flag_per_adv_recv)) {
return;
}
@ -154,7 +156,7 @@ static void recv_cb(struct bt_le_per_adv_sync *recv_sync,
buf_data_len = (uint8_t)net_buf_simple_pull_le16(buf);
if (buf->data[0] - 1 != sizeof(mfg_data) ||
memcmp(buf->data, mfg_data, sizeof(mfg_data))) {
FAIL("Unexpected adv data received\n");
TEST_FAIL("Unexpected adv data received");
}
net_buf_simple_pull(buf, ARRAY_SIZE(mfg_data));
}
@ -175,7 +177,7 @@ static void common_init(void)
err = bt_enable(NULL);
if (err) {
FAIL("Bluetooth init failed: %d\n", err);
TEST_FAIL("Bluetooth init failed: %d", err);
return;
}
@ -195,7 +197,7 @@ static void start_scan(void)
BT_LE_SCAN_CODED_ACTIVE : BT_LE_SCAN_ACTIVE,
NULL);
if (err) {
FAIL("Failed to start scan: %d\n", err);
TEST_FAIL("Failed to start scan: %d", err);
return;
}
printk("done.\n");
@ -214,7 +216,7 @@ static void create_pa_sync(struct bt_le_per_adv_sync **sync)
sync_create_param.timeout = 0x0a;
err = bt_le_per_adv_sync_create(&sync_create_param, sync);
if (err) {
FAIL("Failed to create periodic advertising sync: %d\n", err);
TEST_FAIL("Failed to create periodic advertising sync: %d", err);
return;
}
printk("done.\n");
@ -231,7 +233,7 @@ static void start_bonding(void)
printk("Setting security...");
err = bt_conn_set_security(g_conn, BT_SECURITY_L2);
if (err) {
FAIL("Failed to set security: %d\n", err);
TEST_FAIL("Failed to set security: %d", err);
return;
}
printk("done.\n");
@ -253,7 +255,7 @@ static void main_per_adv_sync(void)
printk("Waiting for periodic sync lost...\n");
WAIT_FOR_FLAG(flag_per_adv_sync_lost);
PASS("Periodic advertising sync passed\n");
TEST_PASS("Periodic advertising sync passed");
}
static void main_per_adv_sync_app_not_scanning(void)
@ -271,7 +273,7 @@ static void main_per_adv_sync_app_not_scanning(void)
printk("Stopping scan\n");
err = bt_le_scan_stop();
if (err != 0) {
FAIL("Failed to stop scan: %d", err);
TEST_FAIL("Failed to stop scan: %d", err);
return;
}
@ -280,7 +282,7 @@ static void main_per_adv_sync_app_not_scanning(void)
printk("Waiting for periodic sync lost...\n");
WAIT_FOR_FLAG(flag_per_adv_sync_lost);
PASS("Periodic advertising sync passed\n");
TEST_PASS("Periodic advertising sync passed");
}
static void main_per_adv_conn_sync(void)
@ -305,7 +307,7 @@ static void main_per_adv_conn_sync(void)
printk("Waiting for periodic sync lost...\n");
WAIT_FOR_FLAG(flag_per_adv_sync_lost);
PASS("Periodic advertising sync passed\n");
TEST_PASS("Periodic advertising sync passed");
}
static void main_per_adv_conn_privacy_sync(void)
@ -336,7 +338,7 @@ static void main_per_adv_conn_privacy_sync(void)
printk("Waiting for periodic sync lost...\n");
WAIT_FOR_FLAG(flag_per_adv_sync_lost);
PASS("Periodic advertising sync passed\n");
TEST_PASS("Periodic advertising sync passed");
}
static void main_per_adv_long_data_sync(void)
@ -359,7 +361,7 @@ static void main_per_adv_long_data_sync(void)
printk("Waiting for periodic sync lost...\n");
WAIT_FOR_FLAG(flag_per_adv_sync_lost);
#endif
PASS("Periodic advertising long data sync passed\n");
TEST_PASS("Periodic advertising long data sync passed");
}
static const struct bst_test_instance per_adv_sync[] = {
@ -367,8 +369,6 @@ static const struct bst_test_instance per_adv_sync[] = {
.test_id = "per_adv_sync",
.test_descr = "Basic periodic advertising sync test. "
"Will just sync to a periodic advertiser.",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = main_per_adv_sync
},
{
@ -376,8 +376,6 @@ static const struct bst_test_instance per_adv_sync[] = {
.test_descr = "Basic periodic advertising sync test but where "
"the app stopped scanning before creating sync."
"Expect the host to start scanning automatically.",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = main_per_adv_sync_app_not_scanning
},
{
@ -385,8 +383,6 @@ static const struct bst_test_instance per_adv_sync[] = {
.test_descr = "Periodic advertising sync test, but where there "
"is a connection between the advertiser and the "
"synchronized device.",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = main_per_adv_conn_sync
},
{
@ -394,8 +390,6 @@ static const struct bst_test_instance per_adv_sync[] = {
.test_descr = "Periodic advertising sync test, but where "
"advertiser and synchronized device are bonded and using "
"privacy",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = main_per_adv_conn_privacy_sync
},
{
@ -403,8 +397,6 @@ static const struct bst_test_instance per_adv_sync[] = {
.test_descr = "Periodic advertising sync test with larger "
"data length. Test is used to verify that "
"reassembly of long data is handeled correctly.",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = main_per_adv_long_data_sync
},
BSTEST_END_MARKER

2
tests/bsim/bluetooth/host/adv/periodic/tests_scripts/per_adv.sh
View file

@ -21,6 +21,6 @@ Execute ./bs_${BOARD_TS}_tests_bsim_bluetooth_host_adv_periodic_prj_conf \
-testid=per_adv_sync -rs=6
Execute ./bs_2G4_phy_v1 -v=${verbosity_level} -s=${simulation_id} \
-D=2 -sim_length=20e6 $@
-D=2 -sim_length=15e6 $@
wait_for_background_jobs

2
tests/bsim/bluetooth/host/adv/periodic/tests_scripts/per_adv_app_not_scanning.sh
View file

@ -21,6 +21,6 @@ Execute ./bs_${BOARD_TS}_tests_bsim_bluetooth_host_adv_periodic_prj_conf \
-testid=per_adv_sync_app_not_scanning -rs=6
Execute ./bs_2G4_phy_v1 -v=${verbosity_level} -s=${simulation_id} \
-D=2 -sim_length=20e6 $@
-D=2 -sim_length=15e6 $@
wait_for_background_jobs

2
tests/bsim/bluetooth/host/adv/periodic/tests_scripts/per_adv_app_not_scanning_coded.sh
View file

@ -22,6 +22,6 @@ Execute ./bs_${BOARD_TS}_tests_bsim_bluetooth_host_adv_periodic_prj_coded_conf \
-testid=per_adv_sync_app_not_scanning -rs=6
Execute ./bs_2G4_phy_v1 -v=${verbosity_level} -s=${simulation_id} \
-D=2 -sim_length=20e6 $@
-D=2 -sim_length=15e6 $@
wait_for_background_jobs

2
tests/bsim/bluetooth/host/adv/periodic/tests_scripts/per_adv_conn.sh
View file

@ -21,6 +21,6 @@ Execute ./bs_${BOARD_TS}_tests_bsim_bluetooth_host_adv_periodic_prj_conf \
-testid=per_adv_conn_sync -rs=6
Execute ./bs_2G4_phy_v1 -v=${verbosity_level} -s=${simulation_id} \
-D=2 -sim_length=20e6 $@
-D=2 -sim_length=15e6 $@
wait_for_background_jobs

2
tests/bsim/bluetooth/host/adv/periodic/tests_scripts/per_adv_conn_privacy.sh
View file

@ -22,6 +22,6 @@ Execute ./bs_${BOARD_TS}_tests_bsim_bluetooth_host_adv_periodic_prj_conf \
-testid=per_adv_conn_privacy_sync -rs=6
Execute ./bs_2G4_phy_v1 -v=${verbosity_level} -s=${simulation_id} \
-D=2 -sim_length=20e6 $@
-D=2 -sim_length=15e6 $@
wait_for_background_jobs

2
tests/bsim/bluetooth/host/adv/periodic/tests_scripts/per_adv_long_data.sh
View file

@ -22,6 +22,6 @@ Execute ./bs_${BOARD_TS}_tests_bsim_bluetooth_host_adv_periodic_prj_long_data_co
-testid=per_adv_long_data_sync -rs=6
Execute ./bs_2G4_phy_v1 -v=${verbosity_level} -s=${simulation_id} \
-D=2 -sim_length=20e6 $@
-D=2 -sim_length=15e6 $@
wait_for_background_jobs

2
tests/bsim/bluetooth/host/att/eatt/CMakeLists.txt
View file

@ -5,6 +5,8 @@ cmake_minimum_required(VERSION 3.20.0)
find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
project(bsim_test_host)
add_subdirectory(${ZEPHYR_BASE}/tests/bsim/babblekit babblekit)
target_link_libraries(app PRIVATE babblekit)
target_sources(app PRIVATE
src/common.c

79
tests/bsim/bluetooth/host/att/eatt/src/common.c
View file

@ -6,6 +6,7 @@
* SPDX-License-Identifier: Apache-2.0
*/
#include "babblekit/testcase.h"
#include "common.h"
#include "argparse.h"
@ -30,7 +31,7 @@ static void connected(struct bt_conn *conn, uint8_t conn_err)
default_conn = NULL;
}
FAIL("Failed to connect to %s (%u)\n", addr, conn_err);
TEST_FAIL("Failed to connect to %s (%u)", addr, conn_err);
return;
}
@ -77,44 +78,30 @@ static void device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type,
err = bt_le_scan_stop();
if (err) {
FAIL("Stop LE scan failed (err %d)\n", err);
TEST_FAIL("Stop LE scan failed (err %d)", err);
}
err = bt_conn_le_create(addr, BT_CONN_LE_CREATE_CONN, BT_LE_CONN_PARAM_DEFAULT,
&default_conn);
if (err) {
FAIL("Create conn failed (err %d)\n", err);
TEST_FAIL("Create conn failed (err %d)", err);
}
printk("Device connected\n");
}
void test_init(void)
{
bst_ticker_set_next_tick_absolute(60e6); /* 60 seconds */
bst_result = In_progress;
}
void test_tick(bs_time_t HW_device_time)
{
if (bst_result != Passed) {
bst_result = Failed;
bs_trace_error_time_line("Test eatt finished.\n");
}
}
void central_setup_and_connect(void)
{
int err;
err = bt_enable(NULL);
if (err) {
FAIL("Can't enable Bluetooth (err %d)\n", err);
TEST_FAIL("Can't enable Bluetooth (err %d)", err);
}
err = bt_le_scan_start(BT_LE_SCAN_ACTIVE, device_found);
if (err) {
FAIL("Scanning failed to start (err %d)\n", err);
TEST_FAIL("Scanning failed to start (err %d)", err);
}
while (!is_connected) {
@ -123,7 +110,7 @@ void central_setup_and_connect(void)
err = bt_conn_set_security(default_conn, BT_SECURITY_L2);
if (err) {
FAIL("Failed to start encryption procedure\n");
TEST_FAIL("Failed to start encryption procedure");
}
while (!is_encrypted) {
@ -137,12 +124,12 @@ void peripheral_setup_and_connect(void)
err = bt_enable(NULL);
if (err) {
FAIL("Can't enable Bluetooth (err %d)\n", err);
TEST_FAIL("Can't enable Bluetooth (err %d)", err);
}
err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_1, ad, ARRAY_SIZE(ad), NULL, 0);
if (err) {
FAIL("Advertising failed to start (err %d)\n", err);
TEST_FAIL("Advertising failed to start (err %d)", err);
}
while (!is_connected) {
@ -168,56 +155,10 @@ void disconnect(void)
err = bt_conn_disconnect(default_conn, BT_HCI_ERR_REMOTE_USER_TERM_CONN);
if (err) {
FAIL("Disconnection failed (err %d)\n", err);
TEST_FAIL("Disconnection failed (err %d)", err);
}
while (is_connected) {
k_sleep(K_MSEC(100));
}
}
#define CHANNEL_ID 0
#define MSG_SIZE 1
void backchannel_init(void)
{
uint device_number = get_device_nbr();
uint peer_number = device_number ^ 1;
uint device_numbers[] = { peer_number };
uint channel_numbers[] = { CHANNEL_ID };
uint *ch;
ch = bs_open_back_channel(device_number, device_numbers, channel_numbers,
ARRAY_SIZE(channel_numbers));
if (!ch) {
FAIL("Unable to open backchannel\n");
}
}
void backchannel_sync_send(void)
{
uint8_t sync_msg[MSG_SIZE] = { get_device_nbr() };
printk("Sending sync\n");
bs_bc_send_msg(CHANNEL_ID, sync_msg, ARRAY_SIZE(sync_msg));
}
void backchannel_sync_wait(void)
{
uint8_t sync_msg[MSG_SIZE];
while (true) {
if (bs_bc_is_msg_received(CHANNEL_ID) > 0) {
bs_bc_receive_msg(CHANNEL_ID, sync_msg, ARRAY_SIZE(sync_msg));
if (sync_msg[0] != get_device_nbr()) {
/* Received a message from another device, exit */
break;
}
}
k_sleep(K_MSEC(1));
}
printk("Sync received\n");
}

31
tests/bsim/bluetooth/host/att/eatt/src/common.h
View file

@ -17,32 +17,6 @@
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/att.h>
#include "bs_types.h"
#include "bs_tracing.h"
#include "bstests.h"
#include "bs_pc_backchannel.h"
extern enum bst_result_t bst_result;
#define CREATE_FLAG(flag) static atomic_t flag = (atomic_t)false
#define SET_FLAG(flag) (void)atomic_set(&flag, (atomic_t)true)
#define WAIT_FOR_FLAG(flag) \
while (!(bool)atomic_get(&flag)) { \
(void)k_sleep(K_MSEC(1)); \
}
#define FAIL(...) \
do { \
bst_result = Failed; \
bs_trace_error_time_line(__VA_ARGS__); \
} while (0)
#define PASS(...) \
do { \
bst_result = Passed; \
bs_trace_info_time(1, __VA_ARGS__); \
} while (0)
extern volatile int num_eatt_channels;
extern struct bt_conn *default_conn;
@ -50,8 +24,3 @@ void central_setup_and_connect(void);
void peripheral_setup_and_connect(void);
void wait_for_disconnect(void);
void disconnect(void);
void test_init(void);
void test_tick(bs_time_t HW_device_time);
void backchannel_init(void);
void backchannel_sync_send(void);
void backchannel_sync_wait(void);

9
tests/bsim/bluetooth/host/att/eatt/src/main_autoconnect.c
View file

@ -6,6 +6,7 @@
* SPDX-License-Identifier: Apache-2.0
*/
#include "babblekit/testcase.h"
#include "common.h"
static void test_peripheral_main(void)
@ -21,7 +22,7 @@ static void test_peripheral_main(void)
disconnect();
PASS("EATT Peripheral tests Passed\n");
TEST_PASS("EATT Peripheral tests Passed");
}
static void test_central_main(void)
@ -34,22 +35,18 @@ static void test_central_main(void)
wait_for_disconnect();
PASS("EATT Central tests Passed\n");
TEST_PASS("EATT Central tests Passed");
}
static const struct bst_test_instance test_def[] = {
{
.test_id = "peripheral_autoconnect",
.test_descr = "Peripheral autoconnect",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_peripheral_main,
},
{
.test_id = "central_autoconnect",
.test_descr = "Central autoconnect",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_central_main,
},
BSTEST_END_MARKER,

26
tests/bsim/bluetooth/host/att/eatt/src/main_collision.c
View file

@ -6,25 +6,27 @@
* SPDX-License-Identifier: Apache-2.0
*/
#include "babblekit/testcase.h"
#include "babblekit/sync.h"
#include "common.h"
static void test_peripheral_main(void)
{
int err;
backchannel_init();
TEST_ASSERT(bk_sync_init() == 0, "Failed to open backchannel");
peripheral_setup_and_connect();
/*
* we need to sync with peer to ensure that we get collisions
*/
backchannel_sync_send();
backchannel_sync_wait();
bk_sync_send();
bk_sync_wait();
err = bt_eatt_connect(default_conn, CONFIG_BT_EATT_MAX);
if (err) {
FAIL("Sending credit based connection request failed (err %d)\n", err);
TEST_FAIL("Sending credit based connection request failed (err %d)", err);
}
while (bt_eatt_count(default_conn) < CONFIG_BT_EATT_MAX) {
@ -36,23 +38,23 @@ static void test_peripheral_main(void)
disconnect();
PASS("EATT Peripheral tests Passed\n");
TEST_PASS("EATT Peripheral tests Passed");
}
static void test_central_main(void)
{
int err;
backchannel_init();
TEST_ASSERT(bk_sync_init() == 0, "Failed to open backchannel");
central_setup_and_connect();
backchannel_sync_wait();
backchannel_sync_send();
bk_sync_wait();
bk_sync_send();
err = bt_eatt_connect(default_conn, CONFIG_BT_EATT_MAX);
if (err) {
FAIL("Sending credit based connection request failed (err %d)\n", err);
TEST_FAIL("Sending credit based connection request failed (err %d)", err);
}
while (bt_eatt_count(default_conn) < CONFIG_BT_EATT_MAX) {
@ -61,22 +63,18 @@ static void test_central_main(void)
wait_for_disconnect();
PASS("EATT Central tests Passed\n");
TEST_PASS("EATT Central tests Passed");
}
static const struct bst_test_instance test_def[] = {
{
.test_id = "peripheral",
.test_descr = "Peripheral Collision",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_peripheral_main,
},
{
.test_id = "central",
.test_descr = "Central Collision",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_central_main,
},
BSTEST_END_MARKER,

9
tests/bsim/bluetooth/host/att/eatt/src/main_lowres.c
View file

@ -6,6 +6,7 @@
* SPDX-License-Identifier: Apache-2.0
*/
#include "babblekit/testcase.h"
#include "common.h"
static void test_peripheral_main(void)
@ -18,7 +19,7 @@ static void test_peripheral_main(void)
disconnect();
PASS("EATT Peripheral tests Passed\n");
TEST_PASS("EATT Peripheral tests Passed");
}
static void test_central_main(void)
@ -35,22 +36,18 @@ static void test_central_main(void)
wait_for_disconnect();
PASS("EATT Central tests Passed\n");
TEST_PASS("EATT Central tests Passed");
}
static const struct bst_test_instance test_def[] = {
{
.test_id = "peripheral_lowres",
.test_descr = "Peripheral lowres",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_peripheral_main,
},
{
.test_id = "central_lowres",
.test_descr = "Central lowres",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_central_main,
},
BSTEST_END_MARKER,

35
tests/bsim/bluetooth/host/att/eatt/src/main_reconfigure.c
View file

@ -6,13 +6,16 @@
* SPDX-License-Identifier: Apache-2.0
*/
#include "babblekit/testcase.h"
#include "babblekit/flags.h"
#include "babblekit/sync.h"
#include "common.h"
#include <zephyr/bluetooth/gatt.h>
#define NEW_MTU 100
CREATE_FLAG(flag_reconfigured);
static DEFINE_FLAG(flag_reconfigured);
void att_mtu_updated(struct bt_conn *conn, uint16_t tx, uint16_t rx)
{
@ -29,7 +32,7 @@ static struct bt_gatt_cb cb = {
static void test_peripheral_main(void)
{
backchannel_init();
TEST_ASSERT(bk_sync_init() == 0, "Failed to open backchannel");
peripheral_setup_and_connect();
@ -39,25 +42,25 @@ static void test_peripheral_main(void)
while (bt_eatt_count(default_conn) < CONFIG_BT_EATT_MAX) {
k_sleep(K_MSEC(10));
}
backchannel_sync_send();
backchannel_sync_wait();
bk_sync_send();
bk_sync_wait();
WAIT_FOR_FLAG(flag_reconfigured);
backchannel_sync_send();
bk_sync_send();
/* Wait for the reconfigured flag on the other end */
backchannel_sync_wait();
bk_sync_wait();
disconnect();
PASS("EATT Peripheral tests Passed\n");
TEST_PASS("EATT Peripheral tests Passed");
}
static void test_central_main(void)
{
int err;
backchannel_init();
TEST_ASSERT(bk_sync_init() == 0, "Failed to open backchannel");
central_setup_and_connect();
@ -69,35 +72,31 @@ static void test_central_main(void)
err = bt_eatt_reconfigure(default_conn, NEW_MTU);
if (err < 0) {
FAIL("Reconfigure failed (%d)\n", err);
TEST_FAIL("Reconfigure failed (%d)", err);
}
backchannel_sync_send();
backchannel_sync_wait();
bk_sync_send();
bk_sync_wait();
WAIT_FOR_FLAG(flag_reconfigured);
backchannel_sync_send();
bk_sync_send();
/* Wait for the reconfigured flag on the other end */
backchannel_sync_wait();
bk_sync_wait();
wait_for_disconnect();
PASS("EATT Central tests Passed\n");
TEST_PASS("EATT Central tests Passed");
}
static const struct bst_test_instance test_def[] = {
{
.test_id = "peripheral_reconfigure",
.test_descr = "Peripheral reconfigure",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_peripheral_main,
},
{
.test_id = "central_reconfigure",
.test_descr = "Central reconfigure",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_central_main,
},
BSTEST_END_MARKER,

2
tests/bsim/bluetooth/host/att/eatt/tests_scripts/autoconnect.sh
View file

@ -17,6 +17,6 @@ Execute ./bs_${BOARD_TS}_tests_bsim_bluetooth_host_att_eatt_prj_autoconnect_conf
-v=${verbosity_level} -s=${simulation_id} -d=1 -testid=peripheral_autoconnect -RealEncryption=1
Execute ./bs_2G4_phy_v1 -v=${verbosity_level} -s=${simulation_id} \
-D=2 -sim_length=200e6 $@
-D=2 -sim_length=60e6 $@
wait_for_background_jobs

2
tests/bsim/bluetooth/host/att/eatt/tests_scripts/collision.sh
View file

@ -17,6 +17,6 @@ Execute ./bs_${BOARD_TS}_tests_bsim_bluetooth_host_att_eatt_prj_collision_conf \
-v=${verbosity_level} -s=${simulation_id} -d=1 -testid=peripheral -RealEncryption=1
Execute ./bs_2G4_phy_v1 -v=${verbosity_level} -s=${simulation_id} \
-D=2 -sim_length=200e6 $@
-D=2 -sim_length=60e6 $@
wait_for_background_jobs

2
tests/bsim/bluetooth/host/att/eatt/tests_scripts/lowres.sh
View file

@ -16,6 +16,6 @@ Execute ./bs_${BOARD_TS}_tests_bsim_bluetooth_host_att_eatt_prj_lowres_conf \
-v=${verbosity_level} -s=${simulation_id} -d=1 -testid=peripheral_lowres -RealEncryption=1
Execute ./bs_2G4_phy_v1 -v=${verbosity_level} -s=${simulation_id} \
-D=2 -sim_length=200e6 $@
-D=2 -sim_length=60e6 $@
wait_for_background_jobs

2
tests/bsim/bluetooth/host/att/eatt/tests_scripts/multiple_conn.sh
View file

@ -17,6 +17,6 @@ Execute ./bs_${BOARD_TS}_tests_bsim_bluetooth_host_att_eatt_prj_multiple_conn_co
-v=${verbosity_level} -s=${simulation_id} -d=1 -testid=peripheral -RealEncryption=1
Execute ./bs_2G4_phy_v1 -v=${verbosity_level} -s=${simulation_id} \
-D=2 -sim_length=200e6 $@
-D=2 -sim_length=60e6 $@
wait_for_background_jobs

3
tests/bsim/bluetooth/host/att/eatt_notif/CMakeLists.txt
View file

@ -5,6 +5,9 @@ cmake_minimum_required(VERSION 3.20.0)
find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
project(bsim_test_eatt_notif)
add_subdirectory(${ZEPHYR_BASE}/tests/bsim/babblekit babblekit)
target_link_libraries(app PRIVATE babblekit)
FILE(GLOB app_sources src/*.c)
target_sources(app PRIVATE ${app_sources} )

47
tests/bsim/bluetooth/host/att/eatt_notif/src/client_test.c
View file

@ -14,16 +14,25 @@
* on EATT channels.
*/
#include <stddef.h>
#include <errno.h>
#include <zephyr/kernel.h>
#include <zephyr/types.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/gatt.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/uuid.h>
#include <zephyr/bluetooth/gatt.h>
#include <zephyr/bluetooth/att.h>
#include "babblekit/testcase.h"
#include "babblekit/flags.h"
#include "babblekit/sync.h"
#include "common.h"
CREATE_FLAG(flag_is_connected);
CREATE_FLAG(flag_discover_complete);
CREATE_FLAG(flag_is_encrypted);
static DEFINE_FLAG(flag_is_connected);
static DEFINE_FLAG(flag_discover_complete);
static DEFINE_FLAG(flag_is_encrypted);
static struct bt_conn *g_conn;
static const struct bt_gatt_attr *local_attr;
@ -42,7 +51,7 @@ static void connected(struct bt_conn *conn, uint8_t err)
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
if (err != 0) {
FAIL("Failed to connect to %s (%u)\n", addr, err);
TEST_FAIL("Failed to connect to %s (%u)", addr, err);
return;
}
@ -103,14 +112,14 @@ void device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type,
printk("Stopping scan\n");
err = bt_le_scan_stop();
if (err != 0) {
FAIL("Could not stop scan: %d");
TEST_FAIL("Could not stop scan: %d");
return;
}
err = bt_conn_le_create(addr, BT_CONN_LE_CREATE_CONN,
BT_LE_CONN_PARAM_DEFAULT, &g_conn);
if (err != 0) {
FAIL("Could not connect to peer: %d", err);
TEST_FAIL("Could not connect to peer: %d", err);
}
}
@ -157,7 +166,7 @@ static void gatt_discover(void)
err = bt_gatt_discover(g_conn, &discover_params);
if (err != 0) {
FAIL("Discover failed(err %d)\n", err);
TEST_FAIL("Discover failed(err %d)", err);
}
}
@ -172,16 +181,16 @@ static void test_main(void)
{
int err;
device_sync_init(PERIPHERAL_ID);
TEST_ASSERT(bk_sync_init() == 0, "Failed to open backchannel");
err = bt_enable(NULL);
if (err != 0) {
FAIL("Bluetooth enable failed (err %d)\n", err);
TEST_FAIL("Bluetooth enable failed (err %d)", err);
}
err = bt_le_scan_start(BT_LE_SCAN_PASSIVE, device_found);
if (err != 0) {
FAIL("Scanning failed to start (err %d)\n", err);
TEST_FAIL("Scanning failed to start (err %d)", err);
}
printk("Scanning successfully started\n");
@ -190,14 +199,14 @@ static void test_main(void)
err = bt_conn_set_security(g_conn, BT_SECURITY_L2);
if (err) {
FAIL("Failed to start encryption procedure\n");
TEST_FAIL("Failed to start encryption procedure");
}
WAIT_FOR_FLAG(flag_is_encrypted);
err = bt_eatt_connect(g_conn, CONFIG_BT_EATT_MAX);
if (err) {
FAIL("Sending credit based connection request failed (err %d)\n", err);
TEST_FAIL("Sending credit based connection request failed (err %d)", err);
}
/* Wait for the channels to be connected */
@ -206,7 +215,7 @@ static void test_main(void)
}
printk("Waiting for sync\n");
device_sync_wait();
bk_sync_wait();
local_attr = &g_svc.attrs[1];
@ -227,7 +236,7 @@ static void test_main(void)
printk("Connecting %d bearers\n", EATT_BEARERS_TEST);
err = bt_eatt_connect(g_conn, EATT_BEARERS_TEST);
if (err) {
FAIL("Sending credit based connection request failed (err %d)\n", err);
TEST_FAIL("Sending credit based connection request failed (err %d)", err);
}
/* Wait for the channels to be connected */
@ -237,22 +246,20 @@ static void test_main(void)
printk("############# Send notifications during discovery request\n");
gatt_discover();
while (!TEST_FLAG(flag_discover_complete)) {
while (!IS_FLAG_SET(flag_discover_complete)) {
printk("Notifying...\n");
send_notification();
}
printk("Sending final sync\n");
device_sync_send();
bk_sync_send();
PASS("Client Passed\n");
TEST_PASS("Client Passed");
}
static const struct bst_test_instance test_vcs[] = {
{
.test_id = "client",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_main
},
BSTEST_END_MARKER

67
tests/bsim/bluetooth/host/att/eatt_notif/src/common.c
View file

@ -1,67 +0,0 @@
/*
* Copyright (c) 2022 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "common.h"
#include <zephyr/logging/log.h>
#define LOG_MODULE_NAME common
LOG_MODULE_REGISTER(LOG_MODULE_NAME, LOG_LEVEL_DBG);
void test_tick(bs_time_t HW_device_time)
{
if (bst_result != Passed) {
FAIL("test failed (not passed after %i seconds)\n", WAIT_TIME);
}
}
void test_init(void)
{
bst_ticker_set_next_tick_absolute(WAIT_TIME);
bst_result = In_progress;
}
/* Call in init functions*/
void device_sync_init(uint device_nbr)
{
uint peer;
if (device_nbr == CENTRAL_ID) {
peer = PERIPHERAL_ID;
} else {
peer = CENTRAL_ID;
}
uint dev_nbrs[BACK_CHANNELS] = { peer };
uint channel_nbrs[BACK_CHANNELS] = { 0 };
const uint *ch = bs_open_back_channel(device_nbr, dev_nbrs, channel_nbrs, BACK_CHANNELS);
if (!ch) {
LOG_ERR("bs_open_back_channel failed!");
}
}
/* Call it to make peer to proceed.*/
void device_sync_send(void)
{
uint8_t msg[1] = "S";
bs_bc_send_msg(0, msg, sizeof(msg));
}
/* Wait until peer send sync*/
void device_sync_wait(void)
{
int size_msg_received = 0;
uint8_t msg;
while (!size_msg_received) {
size_msg_received = bs_bc_is_msg_received(0);
k_sleep(K_MSEC(1));
}
bs_bc_receive_msg(0, &msg, size_msg_received);
}

53
tests/bsim/bluetooth/host/att/eatt_notif/src/common.h
View file

@ -6,49 +6,6 @@
* SPDX-License-Identifier: Apache-2.0
*/
#include <zephyr/kernel.h>
#include "bs_types.h"
#include "bs_tracing.h"
#include "time_machine.h"
#include "bstests.h"
#include <zephyr/types.h>
#include <stddef.h>
#include <errno.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/uuid.h>
#include <zephyr/bluetooth/gatt.h>
#include "bs_pc_backchannel.h"
extern enum bst_result_t bst_result;
#define WAIT_TIME (30 * 1e6) /*seconds*/
#define CREATE_FLAG(flag) static atomic_t flag = (atomic_t)false
#define SET_FLAG(flag) (void)atomic_set(&flag, (atomic_t)true)
#define UNSET_FLAG(flag) (void)atomic_set(&flag, (atomic_t)false)
#define TEST_FLAG(flag) (atomic_get(&flag) == (atomic_t)true)
#define WAIT_FOR_FLAG(flag) \
while (!(bool)atomic_get(&flag)) { \
(void)k_sleep(K_MSEC(1)); \
}
#define FAIL(...) \
do { \
bst_result = Failed; \
bs_trace_error_time_line(__VA_ARGS__); \
} while (0)
#define PASS(...) \
do { \
bst_result = Passed; \
bs_trace_info_time(1, __VA_ARGS__); \
} while (0)
#define CHRC_SIZE 10
#define LONG_CHRC_SIZE 40
@ -63,13 +20,3 @@ extern enum bst_result_t bst_result;
#define TEST_LONG_CHRC_UUID \
BT_UUID_DECLARE_128(0x01, 0x23, 0x45, 0x67, 0x89, 0x01, 0x02, 0x03, \
0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0xFF, 0x11)
#define CENTRAL_ID 0
#define PERIPHERAL_ID 1
#define BACK_CHANNELS 1
void test_tick(bs_time_t HW_device_time);
void test_init(void);
void device_sync_init(uint device_nbr);
void device_sync_send(void);
void device_sync_wait(void);

42
tests/bsim/bluetooth/host/att/eatt_notif/src/server_test.c
View file

@ -4,15 +4,27 @@
* SPDX-License-Identifier: Apache-2.0
*/
#include "common.h"
#include <stddef.h>
#include <errno.h>
#include <zephyr/kernel.h>
#include <zephyr/types.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/uuid.h>
#include <zephyr/bluetooth/gatt.h>
#include <zephyr/bluetooth/att.h>
CREATE_FLAG(flag_discover_complete);
#include "babblekit/testcase.h"
#include "babblekit/flags.h"
#include "babblekit/sync.h"
#include "common.h"
static DEFINE_FLAG(flag_discover_complete);
extern enum bst_result_t bst_result;
CREATE_FLAG(flag_is_connected);
static DEFINE_FLAG(flag_is_connected);
static struct bt_conn *g_conn;
@ -23,7 +35,7 @@ static void connected(struct bt_conn *conn, uint8_t err)
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
if (err != 0) {
FAIL("Failed to connect to %s (%u)\n", addr, err);
TEST_FAIL("Failed to connect to %s (%u)", addr, err);
return;
}
@ -65,7 +77,7 @@ static uint8_t discover_func(struct bt_conn *conn,
if (attr == NULL) {
if (chrc_handle == 0) {
FAIL("Did not discover chrc (%x)", chrc_handle);
TEST_FAIL("Did not discover chrc (%x)", chrc_handle);
}
(void)memset(params, 0, sizeof(*params));
@ -86,7 +98,7 @@ static uint8_t discover_func(struct bt_conn *conn,
err = bt_gatt_discover(conn, params);
if (err != 0) {
FAIL("Discover failed (err %d)\n", err);
TEST_FAIL("Discover failed (err %d)", err);
}
return BT_GATT_ITER_STOP;
@ -119,7 +131,7 @@ static void gatt_discover(void)
err = bt_gatt_discover(g_conn, &discover_params);
if (err != 0) {
FAIL("Discover failed(err %d)\n", err);
TEST_FAIL("Discover failed(err %d)", err);
}
printk("Discovery complete\n");
@ -146,7 +158,7 @@ void subscribed_cb(struct bt_conn *conn, uint8_t err,
params->ccc_handle);
printk("Sending sync to peer\n");
device_sync_send();
bk_sync_send();
}
static struct bt_gatt_discover_params disc_params;
@ -168,7 +180,7 @@ static void gatt_subscribe(void)
printk("Subscribing: val %x\n", chrc_handle);
err = bt_gatt_subscribe(g_conn, &subscribe_params);
if (err != 0) {
FAIL("Subscription failed(err %d)\n", err);
TEST_FAIL("Subscription failed(err %d)", err);
}
}
@ -179,11 +191,11 @@ static void test_main(void)
BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR))
};
device_sync_init(CENTRAL_ID);
TEST_ASSERT(bk_sync_init() == 0, "Failed to open backchannel");
err = bt_enable(NULL);
if (err != 0) {
FAIL("Bluetooth init failed (err %d)\n", err);
TEST_FAIL("Bluetooth init failed (err %d)", err);
return;
}
@ -191,7 +203,7 @@ static void test_main(void)
err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_1, ad, ARRAY_SIZE(ad), NULL, 0);
if (err != 0) {
FAIL("Advertising failed to start (err %d)\n", err);
TEST_FAIL("Advertising failed to start (err %d)", err);
return;
}
@ -209,16 +221,14 @@ static void test_main(void)
gatt_subscribe();
printk("Waiting for final sync\n");
device_sync_wait();
bk_sync_wait();
PASS("Server Passed\n");
TEST_PASS("Server Passed");
}
static const struct bst_test_instance test_server[] = {
{
.test_id = "server",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_main
},
BSTEST_END_MARKER

2
tests/bsim/bluetooth/host/att/eatt_notif/test_scripts/eatt_notif.sh
View file

@ -19,6 +19,6 @@ Execute ./bs_${BOARD_TS}_tests_bsim_bluetooth_host_att_eatt_notif_prj_conf \
-v=${verbosity_level} -s=${simulation_id} -d=1 -testid=server -RealEncryption=1
Execute ./bs_2G4_phy_v1 -v=${verbosity_level} -s=${simulation_id} \
-D=2 -sim_length=60e6 $@
-D=2 -sim_length=30e6 $@
wait_for_background_jobs

3
tests/bsim/bluetooth/host/gatt/authorization/CMakeLists.txt
View file

@ -5,6 +5,9 @@ cmake_minimum_required(VERSION 3.20.0)
find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
project(bsim_test_gatt_authorization)
add_subdirectory(${ZEPHYR_BASE}/tests/bsim/babblekit babblekit)
target_link_libraries(app PRIVATE babblekit)
FILE(GLOB app_sources src/*.c)
target_sources(app PRIVATE ${app_sources} )

20
tests/bsim/bluetooth/host/gatt/authorization/src/common.c
View file

@ -1,20 +0,0 @@
/*
* Copyright (c) 2024 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "common.h"
void test_tick(bs_time_t HW_device_time)
{
if (bst_result != Passed) {
FAIL("test failed (not passed after %i seconds)\n", WAIT_TIME);
}
}
void test_init(void)
{
bst_ticker_set_next_tick_absolute(WAIT_TIME);
bst_result = In_progress;
}

44
tests/bsim/bluetooth/host/gatt/authorization/src/common.h
View file

@ -6,47 +6,6 @@
* SPDX-License-Identifier: Apache-2.0
*/
#include <zephyr/kernel.h>
#include "bs_types.h"
#include "bs_tracing.h"
#include "time_machine.h"
#include "bstests.h"
#include <zephyr/types.h>
#include <stddef.h>
#include <errno.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/uuid.h>
#include <zephyr/bluetooth/gatt.h>
extern enum bst_result_t bst_result;
#define WAIT_TIME (30 * 1e6) /*seconds*/
#define CREATE_FLAG(flag) static atomic_t flag = (atomic_t)false
#define SET_FLAG(flag) (void)atomic_set(&flag, (atomic_t)true)
#define UNSET_FLAG(flag) (void)atomic_set(&flag, (atomic_t)false)
#define WAIT_FOR_FLAG(flag) \
while (!(bool)atomic_get(&flag)) { \
(void)k_sleep(K_MSEC(1)); \
}
#define FAIL(...) \
do { \
bst_result = Failed; \
bs_trace_error_time_line(__VA_ARGS__); \
} while (0)
#define PASS(...) \
do { \
bst_result = Passed; \
bs_trace_info_time(1, __VA_ARGS__); \
} while (0)
#define CHRC_SIZE 10
#define TEST_SERVICE_UUID \
@ -68,6 +27,3 @@ extern enum bst_result_t bst_result;
#define TEST_CP_CHRC_UUID \
BT_UUID_DECLARE_128(0x01, 0x23, 0x45, 0x67, 0x89, 0x01, 0x02, 0x03, \
0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0xF0, 0x00)
void test_tick(bs_time_t HW_device_time);
void test_init(void);

54
tests/bsim/bluetooth/host/gatt/authorization/src/gatt_client_test.c
View file

@ -4,15 +4,25 @@
* SPDX-License-Identifier: Apache-2.0
*/
#include <zephyr/kernel.h>
#include <zephyr/types.h>
#include <stddef.h>
#include <errno.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/uuid.h>
#include <zephyr/bluetooth/gatt.h>
#include "babblekit/testcase.h"
#include "babblekit/flags.h"
#include "common.h"
CREATE_FLAG(flag_is_connected);
CREATE_FLAG(flag_discover_complete);
CREATE_FLAG(flag_write_complete);
CREATE_FLAG(flag_read_complete);
static DEFINE_FLAG(flag_is_connected);
static DEFINE_FLAG(flag_discover_complete);
static DEFINE_FLAG(flag_write_complete);
static DEFINE_FLAG(flag_read_complete);
static struct bt_conn *g_conn;
static uint16_t unhandled_chrc_handle;
@ -31,7 +41,7 @@ static void connected(struct bt_conn *conn, uint8_t err)
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
if (err != 0) {
FAIL("Failed to connect to %s (%u)\n", addr, err);
TEST_FAIL("Failed to connect to %s (%u)", addr, err);
return;
}
@ -86,14 +96,14 @@ void device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type,
printk("Stopping scan\n");
err = bt_le_scan_stop();
if (err != 0) {
FAIL("Could not stop scan: %d");
TEST_FAIL("Could not stop scan: %d");
return;
}
err = bt_conn_le_create(addr, BT_CONN_LE_CREATE_CONN,
BT_LE_CONN_PARAM_DEFAULT, &g_conn);
if (err != 0) {
FAIL("Could not connect to peer: %d", err);
TEST_FAIL("Could not connect to peer: %d", err);
}
}
@ -107,7 +117,7 @@ static uint8_t discover_func(struct bt_conn *conn,
if (unhandled_chrc_handle == 0 ||
unauthorized_chrc_handle == 0 ||
authorized_chrc_handle == 0) {
FAIL("Did not discover required characterstics");
TEST_FAIL("Did not discover required characterstics");
}
(void)memset(params, 0, sizeof(*params));
@ -128,7 +138,7 @@ static uint8_t discover_func(struct bt_conn *conn,
err = bt_gatt_discover(conn, params);
if (err != 0) {
FAIL("Discover failed (err %d)\n", err);
TEST_FAIL("Discover failed (err %d)", err);
}
return BT_GATT_ITER_STOP;
@ -168,7 +178,7 @@ static void gatt_discover(void)
err = bt_gatt_discover(g_conn, &discover_params);
if (err != 0) {
FAIL("Discover failed(err %d)\n", err);
TEST_FAIL("Discover failed(err %d)", err);
}
WAIT_FOR_FLAG(flag_discover_complete);
@ -179,11 +189,11 @@ static void gatt_write_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_write_params *params)
{
if ((err != BT_ATT_ERR_SUCCESS) && (params->handle != unauthorized_chrc_handle)) {
FAIL("Write failed on authorized characteristics: 0x%02X\n", err);
TEST_FAIL("Write failed on authorized characteristics: 0x%02X", err);
}
if ((err != BT_ATT_ERR_AUTHORIZATION) && (params->handle == unauthorized_chrc_handle)) {
FAIL("Write failed on unauthorized characteristics: 0x%02X\n", err);
TEST_FAIL("Write failed on unauthorized characteristics: 0x%02X", err);
}
(void)memset(params, 0, sizeof(*params));
@ -207,7 +217,7 @@ static void gatt_write(uint16_t handle)
err = bt_gatt_write(g_conn, &write_params);
if (err != 0) {
FAIL("bt_gatt_write failed: %d\n", err);
TEST_FAIL("bt_gatt_write failed: %d", err);
}
WAIT_FOR_FLAG(flag_write_complete);
@ -231,7 +241,7 @@ static void gatt_cp_write(void)
err = bt_gatt_write(g_conn, &write_params);
if (err != 0) {
FAIL("bt_gatt_write failed: %d\n", err);
TEST_FAIL("bt_gatt_write failed: %d", err);
}
WAIT_FOR_FLAG(flag_write_complete);
@ -244,16 +254,16 @@ static uint8_t gatt_read_cb(struct bt_conn *conn, uint8_t err,
{
if ((err != BT_ATT_ERR_SUCCESS) &&
(params->single.handle != unauthorized_chrc_handle)) {
FAIL("Read failed on authorized characteristics: 0x%02X\n", err);
TEST_FAIL("Read failed on authorized characteristics: 0x%02X", err);
if ((length != CHRC_SIZE) || (memcmp(data, chrc_data, length) != 0)) {
FAIL("chrc data different than expected", err);
TEST_FAIL("chrc data different than expected: 0x%02X", err);
}
}
if ((err != BT_ATT_ERR_AUTHORIZATION) &&
(params->single.handle == unauthorized_chrc_handle)) {
FAIL("Read failed on unauthorized characteristics: 0x%02X\n", err);
TEST_FAIL("Read failed on unauthorized characteristics: 0x%02X", err);
}
(void)memset(params, 0, sizeof(*params));
@ -279,7 +289,7 @@ static void gatt_read(uint16_t handle)
err = bt_gatt_read(g_conn, &read_params);
if (err != 0) {
FAIL("bt_gatt_read failed: %d\n", err);
TEST_FAIL("bt_gatt_read failed: %d", err);
}
WAIT_FOR_FLAG(flag_read_complete);
@ -301,12 +311,12 @@ static void test_main(void)
err = bt_enable(NULL);
if (err != 0) {
FAIL("Bluetooth discover failed (err %d)\n", err);
TEST_FAIL("Bluetooth discover failed (err %d)", err);
}
err = bt_le_scan_start(BT_LE_SCAN_PASSIVE, device_found);
if (err != 0) {
FAIL("Scanning failed to start (err %d)\n", err);
TEST_FAIL("Scanning failed to start (err %d)", err);
}
printk("Scanning successfully started\n");
@ -324,14 +334,12 @@ static void test_main(void)
printk("Interacting with the authorized characteristic\n");
gatt_interact(authorized_chrc_handle);
PASS("GATT client Passed\n");
TEST_PASS("GATT client Passed");
}
static const struct bst_test_instance test_vcs[] = {
{
.test_id = "gatt_client",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_main
},
BSTEST_END_MARKER

33
tests/bsim/bluetooth/host/gatt/authorization/src/gatt_server_test.c
View file

@ -4,11 +4,24 @@
* SPDX-License-Identifier: Apache-2.0
*/
#include <zephyr/kernel.h>
#include <zephyr/types.h>
#include <stddef.h>
#include <errno.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/uuid.h>
#include <zephyr/bluetooth/gatt.h>
#include "babblekit/testcase.h"
#include "babblekit/flags.h"
#include "common.h"
extern enum bst_result_t bst_result;
CREATE_FLAG(flag_is_chrc_ctx_validated);
static DEFINE_FLAG(flag_is_chrc_ctx_validated);
static struct bt_conn *g_conn;
@ -19,7 +32,7 @@ static void connected(struct bt_conn *conn, uint8_t err)
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
if (err != 0) {
FAIL("Failed to connect to %s (%u)\n", addr, err);
TEST_FAIL("Failed to connect to %s (%u)", addr, err);
return;
}
@ -87,7 +100,7 @@ static ssize_t write_test_chrc(struct test_chrc_ctx *chrc_ctx,
}
if (flags != 0) {
FAIL("Invalid flags %u\n", flags);
TEST_FAIL("Invalid flags %u", flags);
return BT_GATT_ERR(BT_ATT_ERR_UNLIKELY);
}
@ -240,14 +253,14 @@ static ssize_t write_cp_chrc(struct bt_conn *conn,
pass = authorized_chrc_operation_validate();
log_str = "authorized";
} else {
FAIL("Invalid value of CP write counter %u\n", cp_write_cnt);
TEST_FAIL("Invalid value of CP write counter %u", cp_write_cnt);
return BT_GATT_ERR(BT_ATT_ERR_UNLIKELY);
}
if (pass) {
printk("Correct context for %s chrc\n", log_str);
} else {
FAIL("Invalid context for %s chrc\n", log_str);
TEST_FAIL("Invalid context for %s chrc", log_str);
return BT_GATT_ERR(BT_ATT_ERR_UNLIKELY);
}
@ -327,7 +340,7 @@ static void test_main(void)
err = bt_gatt_authorization_cb_register(&gatt_authorization_callbacks);
if (err) {
FAIL("Registering GATT authorization callbacks failed (err %d)\n", err);
TEST_FAIL("Registering GATT authorization callbacks failed (err %d)", err);
return;
}
@ -335,7 +348,7 @@ static void test_main(void)
err = bt_enable(NULL);
if (err != 0) {
FAIL("Bluetooth init failed (err %d)\n", err);
TEST_FAIL("Bluetooth init failed (err %d)", err);
return;
}
@ -343,7 +356,7 @@ static void test_main(void)
err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_1, ad, ARRAY_SIZE(ad), NULL, 0);
if (err != 0) {
FAIL("Advertising failed to start (err %d)\n", err);
TEST_FAIL("Advertising failed to start (err %d)", err);
return;
}
@ -351,14 +364,12 @@ static void test_main(void)
WAIT_FOR_FLAG(flag_is_chrc_ctx_validated);
PASS("GATT server passed\n");
TEST_PASS("GATT server passed");
}
static const struct bst_test_instance test_gatt_server[] = {
{
.test_id = "gatt_server",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_main
},
BSTEST_END_MARKER

2
tests/bsim/bluetooth/host/gatt/authorization/test_scripts/gatt.sh
View file

@ -17,6 +17,6 @@ Execute ./bs_${BOARD_TS}_tests_bsim_bluetooth_host_gatt_authorization_prj_conf \
-v=${verbosity_level} -s=${simulation_id} -d=1 -testid=gatt_server
Execute ./bs_2G4_phy_v1 -v=${verbosity_level} -s=${simulation_id} \
-D=2 -sim_length=60e6 $@
-D=2 -sim_length=30e6 $@
wait_for_background_jobs

3
tests/bsim/bluetooth/host/gatt/caching/CMakeLists.txt
View file

@ -5,6 +5,9 @@ cmake_minimum_required(VERSION 3.20.0)
find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
project(bsim_test_gatt)
add_subdirectory(${ZEPHYR_BASE}/tests/bsim/babblekit babblekit)
target_link_libraries(app PRIVATE babblekit)
FILE(GLOB app_sources src/*.c)
target_sources(app PRIVATE ${app_sources} )

66
tests/bsim/bluetooth/host/gatt/caching/src/common.c
View file

@ -1,66 +0,0 @@
/*
* Copyright (c) 2022 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "common.h"
#include "argparse.h"
void test_tick(bs_time_t HW_device_time)
{
if (bst_result != Passed) {
FAIL("test failed (not passed after %i seconds)\n", WAIT_TIME);
}
}
void test_init(void)
{
bst_ticker_set_next_tick_absolute(WAIT_TIME);
bst_result = In_progress;
}
#define CHANNEL_ID 0
#define MSG_SIZE 1
void backchannel_init(void)
{
uint device_number = get_device_nbr();
uint peer_number = device_number ^ 1;
uint device_numbers[] = { peer_number };
uint channel_numbers[] = { CHANNEL_ID };
uint *ch;
ch = bs_open_back_channel(device_number, device_numbers, channel_numbers,
ARRAY_SIZE(channel_numbers));
if (!ch) {
FAIL("Unable to open backchannel\n");
}
}
void backchannel_sync_send(void)
{
uint8_t sync_msg[MSG_SIZE] = { get_device_nbr() };
printk("Sending sync\n");
bs_bc_send_msg(CHANNEL_ID, sync_msg, ARRAY_SIZE(sync_msg));
}
void backchannel_sync_wait(void)
{
uint8_t sync_msg[MSG_SIZE];
while (true) {
if (bs_bc_is_msg_received(CHANNEL_ID) > 0) {
bs_bc_receive_msg(CHANNEL_ID, sync_msg, ARRAY_SIZE(sync_msg));
if (sync_msg[0] != get_device_nbr()) {
/* Received a message from another device, exit */
break;
}
}
k_sleep(K_MSEC(1));
}
printk("Sync received\n");
}

50
tests/bsim/bluetooth/host/gatt/caching/src/common.h
View file

@ -6,50 +6,6 @@
* SPDX-License-Identifier: Apache-2.0
*/
#include <zephyr/kernel.h>
#include "bs_types.h"
#include "bs_tracing.h"
#include "time_machine.h"
#include "bstests.h"
#include "bs_pc_backchannel.h"
#include <zephyr/types.h>
#include <stddef.h>
#include <errno.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/uuid.h>
#include <zephyr/bluetooth/gatt.h>
extern enum bst_result_t bst_result;
#define WAIT_TIME (60 * 1e6) /*seconds*/
#define CREATE_FLAG(flag) static atomic_t flag = (atomic_t)false
#define SET_FLAG(flag) (void)atomic_set(&flag, (atomic_t)true)
#define UNSET_FLAG(flag) (void)atomic_set(&flag, (atomic_t)false)
#define WAIT_FOR_FLAG(flag) \
while (!(bool)atomic_get(&flag)) { \
(void)k_sleep(K_MSEC(1)); \
}
#define FAIL(...) \
do { \
bst_result = Failed; \
bs_trace_error_time_line(__VA_ARGS__); \
} while (0)
#define PASS(...) \
do { \
bst_result = Passed; \
bs_trace_info_time(1, __VA_ARGS__); \
} while (0)
#define CHRC_SIZE 10
#define TEST_SERVICE_UUID \
BT_UUID_DECLARE_128(0x01, 0x23, 0x45, 0x67, 0x89, 0x01, 0x02, 0x03, \
0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x00, 0x00)
@ -61,9 +17,3 @@ extern enum bst_result_t bst_result;
#define TEST_ADDITIONAL_CHRC_UUID \
BT_UUID_DECLARE_128(0x01, 0x23, 0x45, 0x67, 0x89, 0x01, 0x02, 0x03, \
0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0xFF, 0x11)
void test_tick(bs_time_t HW_device_time);
void test_init(void);
void backchannel_init(void);
void backchannel_sync_send(void);
void backchannel_sync_wait(void);

105
tests/bsim/bluetooth/host/gatt/caching/src/gatt_client_test.c
View file

@ -4,18 +4,29 @@
* SPDX-License-Identifier: Apache-2.0
*/
#include <zephyr/kernel.h>
#include <zephyr/types.h>
#include <stddef.h>
#include <errno.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/uuid.h>
#include <zephyr/bluetooth/gatt.h>
#include "babblekit/testcase.h"
#include "babblekit/flags.h"
#include "babblekit/sync.h"
#include "common.h"
CREATE_FLAG(flag_is_connected);
CREATE_FLAG(flag_discover_complete);
CREATE_FLAG(flag_write_complete);
CREATE_FLAG(flag_chan_1_read);
CREATE_FLAG(flag_chan_2_read);
CREATE_FLAG(flag_db_hash_read);
CREATE_FLAG(flag_encrypted);
static DEFINE_FLAG(flag_is_connected);
static DEFINE_FLAG(flag_discover_complete);
static DEFINE_FLAG(flag_write_complete);
static DEFINE_FLAG(flag_chan_1_read);
static DEFINE_FLAG(flag_chan_2_read);
static DEFINE_FLAG(flag_db_hash_read);
static DEFINE_FLAG(flag_encrypted);
static struct bt_conn *g_conn;
static uint16_t chrc_handle;
@ -29,7 +40,7 @@ static void connected(struct bt_conn *conn, uint8_t err)
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
if (err != 0) {
FAIL("Failed to connect to %s (%u)\n", addr, err);
TEST_FAIL("Failed to connect to %s (%u)", addr, err);
return;
}
@ -60,9 +71,9 @@ static void disconnected(struct bt_conn *conn, uint8_t reason)
void security_changed(struct bt_conn *conn, bt_security_t level, enum bt_security_err err)
{
if (err != BT_SECURITY_ERR_SUCCESS) {
FAIL("Encryption failed\n");
TEST_FAIL("Encryption failed");
} else if (level < BT_SECURITY_L2) {
FAIL("Insufficient security\n");
TEST_FAIL("Insufficient security");
} else {
SET_FLAG(flag_encrypted);
}
@ -94,14 +105,14 @@ void device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type, struct ne
printk("Stopping scan\n");
err = bt_le_scan_stop();
if (err != 0) {
FAIL("Could not stop scan (err %d)\n");
TEST_FAIL("Could not stop scan (err %d)");
return;
}
err = bt_conn_le_create(addr, BT_CONN_LE_CREATE_CONN, BT_LE_CONN_PARAM_DEFAULT, &g_conn);
if (err != 0) {
FAIL("Could not connect to peer (err %d)", err);
TEST_FAIL("Could not connect to peer (err %d)", err);
}
}
@ -112,7 +123,7 @@ static uint8_t discover_func(struct bt_conn *conn, const struct bt_gatt_attr *at
if (attr == NULL) {
if (chrc_handle == 0) {
FAIL("Did not discover chrc (%x)\n", chrc_handle);
TEST_FAIL("Did not discover chrc (%x)", chrc_handle);
}
(void)memset(params, 0, sizeof(*params));
@ -133,7 +144,7 @@ static uint8_t discover_func(struct bt_conn *conn, const struct bt_gatt_attr *at
err = bt_gatt_discover(conn, params);
if (err != 0) {
FAIL("Discover failed (err %d)\n", err);
TEST_FAIL("Discover failed (err %d)", err);
}
return BT_GATT_ITER_STOP;
@ -171,7 +182,7 @@ static void gatt_discover(const struct bt_uuid *uuid, uint8_t type)
err = bt_gatt_discover(g_conn, &discover_params);
if (err != 0) {
FAIL("Discover failed(err %d)\n", err);
TEST_FAIL("Discover failed (err %d)", err);
}
WAIT_FOR_FLAG(flag_discover_complete);
@ -203,10 +214,10 @@ static struct bt_gatt_read_params db_hash_read = {
.chan_opt = BT_ATT_CHAN_OPT_NONE,
};
void expect_status(uint8_t err, uint8_t status)
static void expect_status(uint8_t err, uint8_t status)
{
if (err != status) {
FAIL("Unexpected status from read: 0x%02X, expected 0x%02X\n", err, status);
TEST_FAIL("Unexpected status from read: 0x%02X, expected 0x%02X", err, status);
}
}
@ -224,7 +235,7 @@ static uint8_t gatt_read_expect_success_cb(struct bt_conn *conn, uint8_t err,
} else if (params == &chan_2_read) {
SET_FLAG(flag_chan_2_read);
} else {
FAIL("Unexpected params\n");
TEST_FAIL("Unexpected params");
}
return 0;
@ -242,7 +253,7 @@ static uint8_t gatt_read_expect_err_unlikely_cb(struct bt_conn *conn, uint8_t er
} else if (params == &chan_2_read) {
SET_FLAG(flag_chan_2_read);
} else {
FAIL("Unexpected params\n");
TEST_FAIL("Unexpected params");
}
return 0;
@ -260,7 +271,7 @@ static uint8_t gatt_read_expect_err_out_of_sync_cb(struct bt_conn *conn, uint8_t
} else if (params == &chan_2_read) {
SET_FLAG(flag_chan_2_read);
} else {
FAIL("Unexpected params\n");
TEST_FAIL("Unexpected params");
}
return 0;
@ -274,14 +285,14 @@ static void gatt_read(struct bt_gatt_read_params *read_params)
err = bt_gatt_read(g_conn, read_params);
if (err != 0) {
FAIL("bt_gatt_read failed: %d\n", err);
TEST_FAIL("bt_gatt_read failed: %d", err);
}
}
static void write_cb(struct bt_conn *conn, uint8_t err, struct bt_gatt_write_params *params)
{
if (err != BT_ATT_ERR_SUCCESS) {
FAIL("Write failed: 0x%02X\n", err);
TEST_FAIL("Write failed: 0x%02X", err);
}
SET_FLAG(flag_write_complete);
@ -310,7 +321,7 @@ static void enable_robust_caching(void)
err = bt_gatt_write(g_conn, &write_params);
if (err) {
FAIL("bt_gatt_write failed (err %d)\n", err);
TEST_FAIL("bt_gatt_write failed (err %d)", err);
}
WAIT_FOR_FLAG(flag_write_complete);
@ -321,16 +332,16 @@ static void test_main_common(bool connect_eatt)
{
int err;
backchannel_init();
TEST_ASSERT(bk_sync_init() == 0, "Failed to open backchannel");
err = bt_enable(NULL);
if (err != 0) {
FAIL("Bluetooth discover failed (err %d)\n", err);
TEST_FAIL("Bluetooth discover failed (err %d)", err);
}
err = bt_le_scan_start(BT_LE_SCAN_PASSIVE, device_found);
if (err != 0) {
FAIL("Scanning failed to start (err %d)\n", err);
TEST_FAIL("Scanning failed to start (err %d)", err);
}
printk("Scanning successfully started\n");
@ -339,7 +350,7 @@ static void test_main_common(bool connect_eatt)
err = bt_conn_set_security(g_conn, BT_SECURITY_L2);
if (err) {
FAIL("Failed to start encryption procedure\n");
TEST_FAIL("Failed to start encryption procedure");
}
WAIT_FOR_FLAG(flag_encrypted);
@ -357,10 +368,10 @@ static void test_main_common(bool connect_eatt)
}
/* Tell the server to register additional service */
backchannel_sync_send();
bk_sync_send();
/* Wait for new service to be added by server */
backchannel_sync_wait();
bk_sync_wait();
chan_1_read.single.handle = chrc_handle;
chan_2_read.single.handle = chrc_handle;
@ -386,9 +397,9 @@ static void test_main_db_hash_read_eatt(void)
WAIT_FOR_FLAG(flag_chan_2_read);
/* Signal to server that reads are done */
backchannel_sync_send();
bk_sync_send();
PASS("GATT client Passed\n");
TEST_PASS("GATT client Passed");
}
static void test_main_out_of_sync_eatt(void)
@ -423,9 +434,9 @@ static void test_main_out_of_sync_eatt(void)
WAIT_FOR_FLAG(flag_chan_2_read);
/* Signal to server that reads are done */
backchannel_sync_send();
bk_sync_send();
PASS("GATT client Passed\n");
TEST_PASS("GATT client Passed");
}
static void test_main_retry_reads_eatt(void)
@ -455,9 +466,9 @@ static void test_main_retry_reads_eatt(void)
WAIT_FOR_FLAG(flag_chan_2_read);
/* Signal to server that reads are done */
backchannel_sync_send();
bk_sync_send();
PASS("GATT client Passed\n");
TEST_PASS("GATT client Passed");
}
static void test_main_db_hash_read_no_eatt(void)
@ -476,9 +487,9 @@ static void test_main_db_hash_read_no_eatt(void)
WAIT_FOR_FLAG(flag_chan_1_read);
/* Signal to server that reads are done */
backchannel_sync_send();
bk_sync_send();
PASS("GATT client Passed\n");
TEST_PASS("GATT client Passed");
}
static void test_main_out_of_sync_no_eatt(void)
@ -501,9 +512,9 @@ static void test_main_out_of_sync_no_eatt(void)
WAIT_FOR_FLAG(flag_chan_1_read);
/* Signal to server that reads are done */
backchannel_sync_send();
bk_sync_send();
PASS("GATT client Passed\n");
TEST_PASS("GATT client Passed");
}
static void test_main_retry_reads_no_eatt(void)
@ -521,46 +532,34 @@ static void test_main_retry_reads_no_eatt(void)
WAIT_FOR_FLAG(flag_chan_1_read);
/* Signal to server that reads are done */
backchannel_sync_send();
bk_sync_send();
PASS("GATT client Passed\n");
TEST_PASS("GATT client Passed");
}
static const struct bst_test_instance test_vcs[] = {
{
.test_id = "gatt_client_db_hash_read_eatt",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_main_db_hash_read_eatt,
},
{
.test_id = "gatt_client_out_of_sync_eatt",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_main_out_of_sync_eatt,
},
{
.test_id = "gatt_client_retry_reads_eatt",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_main_retry_reads_eatt,
},
{
.test_id = "gatt_client_db_hash_read_no_eatt",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_main_db_hash_read_no_eatt,
},
{
.test_id = "gatt_client_out_of_sync_no_eatt",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_main_out_of_sync_no_eatt,
},
{
.test_id = "gatt_client_retry_reads_no_eatt",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_main_retry_reads_no_eatt,
},
BSTEST_END_MARKER,

43
tests/bsim/bluetooth/host/gatt/caching/src/gatt_server_test.c
View file

@ -4,12 +4,26 @@
* SPDX-License-Identifier: Apache-2.0
*/
#include <zephyr/kernel.h>
#include <zephyr/types.h>
#include <stddef.h>
#include <errno.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/uuid.h>
#include <zephyr/bluetooth/gatt.h>
#include "babblekit/testcase.h"
#include "babblekit/flags.h"
#include "babblekit/sync.h"
#include "common.h"
extern enum bst_result_t bst_result;
CREATE_FLAG(flag_is_connected);
CREATE_FLAG(flag_is_encrypted);
static DEFINE_FLAG(flag_is_connected);
static DEFINE_FLAG(flag_is_encrypted);
static struct bt_conn *g_conn;
@ -20,7 +34,7 @@ static void connected(struct bt_conn *conn, uint8_t err)
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
if (err != 0) {
FAIL("Failed to connect to %s (%u)\n", addr, err);
TEST_FAIL("Failed to connect to %s (%u)", addr, err);
return;
}
@ -63,6 +77,7 @@ BT_CONN_CB_DEFINE(conn_callbacks) = {
.security_changed = security_changed,
};
#define CHRC_SIZE 10
#define ARRAY_ITEM(i, _) i
static const uint8_t chrc_data[] = { LISTIFY(CHRC_SIZE, ARRAY_ITEM, (,)) }; /* 1, 2, 3 ... */
@ -90,11 +105,11 @@ static void test_main_common(bool connect_eatt)
const struct bt_data ad[] = { BT_DATA_BYTES(BT_DATA_FLAGS,
(BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)) };
backchannel_init();
TEST_ASSERT(bk_sync_init() == 0, "Failed to open backchannel");
err = bt_enable(NULL);
if (err != 0) {
FAIL("Bluetooth init failed (err %d)\n", err);
TEST_FAIL("Bluetooth init failed (err %d)", err);
return;
}
@ -103,7 +118,7 @@ static void test_main_common(bool connect_eatt)
err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_1, ad, ARRAY_SIZE(ad), NULL, 0);
if (err != 0) {
FAIL("Advertising failed to start (err %d)\n", err);
TEST_FAIL("Advertising failed to start (err %d)", err);
return;
}
@ -117,28 +132,28 @@ static void test_main_common(bool connect_eatt)
err = bt_eatt_connect(g_conn, CONFIG_BT_EATT_MAX);
if (err) {
FAIL("Failed to connect EATT channels (err %d)\n", err);
TEST_FAIL("Failed to connect EATT channels (err %d)", err);
return;
}
}
/* Wait for client to do discovery and configuration */
backchannel_sync_wait();
bk_sync_wait();
printk("Registering additional service\n");
err = bt_gatt_service_register(&additional_gatt_service);
if (err < 0) {
FAIL("Registering additional service failed (err %d)\n", err);
TEST_FAIL("Registering additional service failed (err %d)", err);
}
/* Signal to client that additional service is registered */
backchannel_sync_send();
bk_sync_send();
/* Wait for client to be done reading */
backchannel_sync_wait();
bk_sync_wait();
PASS("GATT server passed\n");
TEST_PASS("GATT server passed");
}
static void test_main_eatt(void)
@ -154,14 +169,10 @@ static void test_main_no_eatt(void)
static const struct bst_test_instance test_gatt_server[] = {
{
.test_id = "gatt_server_eatt",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_main_eatt,
},
{
.test_id = "gatt_server_no_eatt",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_main_no_eatt,
},
BSTEST_END_MARKER,

4
tests/bsim/bluetooth/host/gatt/ccc_store/CMakeLists.txt
View file

@ -12,9 +12,11 @@ endif()
find_package(Zephyr HINTS $ENV{ZEPHYR_BASE})
project(bsim_test_ccc_store)
add_subdirectory(${ZEPHYR_BASE}/tests/bsim/babblekit babblekit)
target_link_libraries(app PRIVATE babblekit)
target_sources(app PRIVATE
src/main.c
src/common.c
src/central.c
src/peripheral.c

73
tests/bsim/bluetooth/host/gatt/ccc_store/src/central.c
View file

@ -22,14 +22,17 @@
#include "settings.h"
#include "argparse.h"
#include "bs_pc_backchannel.h"
#include "babblekit/testcase.h"
#include "babblekit/flags.h"
#include "babblekit/sync.h"
#define SERVER_CHAN 0
CREATE_FLAG(connected_flag);
CREATE_FLAG(disconnected_flag);
CREATE_FLAG(security_updated_flag);
CREATE_FLAG(notification_received_flag);
static DEFINE_FLAG(connected_flag);
static DEFINE_FLAG(disconnected_flag);
static DEFINE_FLAG(security_updated_flag);
static DEFINE_FLAG(notification_received_flag);
#define BT_UUID_DUMMY_SERVICE BT_UUID_DECLARE_128(DUMMY_SERVICE_TYPE)
#define BT_UUID_DUMMY_SERVICE_NOTIFY BT_UUID_DECLARE_128(DUMMY_SERVICE_NOTIFY_TYPE)
@ -38,7 +41,7 @@ static struct bt_conn *default_conn;
static struct bt_conn_cb central_cb;
CREATE_FLAG(gatt_subscribed_flag);
static DEFINE_FLAG(gatt_subscribed_flag);
static uint8_t notify_cb(struct bt_conn *conn, struct bt_gatt_subscribe_params *params,
const void *data, uint16_t length)
@ -88,7 +91,7 @@ static void ccc_subscribe(void)
err = bt_gatt_subscribe(default_conn, &subscribe_params);
if (err) {
FAIL("Failed to subscribe (att err %d)", err);
TEST_FAIL("Failed to subscribe (att err %d)", err);
}
WAIT_FOR_FLAG(gatt_subscribed_flag);
@ -106,13 +109,13 @@ static void device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type,
err = bt_le_scan_stop();
if (err) {
FAIL("Failed to stop scanner (err %d)\n", err);
TEST_FAIL("Failed to stop scanner (err %d)", err);
}
err = bt_conn_le_create(addr, BT_CONN_LE_CREATE_CONN, BT_LE_CONN_PARAM_DEFAULT,
&default_conn);
if (err) {
FAIL("Could not connect to peer: %s (err %d)\n", addr_str, err);
TEST_FAIL("Could not connect to peer: %s (err %d)", addr_str, err);
}
}
@ -125,7 +128,7 @@ static void connected(struct bt_conn *conn, uint8_t err)
bt_addr_le_to_str(addr, addr_str, sizeof(addr_str));
if (err) {
FAIL("Failed to connect to %s (err %d)\n", addr_str, err);
TEST_FAIL("Failed to connect to %s (err %d)", addr_str, err);
}
LOG_DBG("Connected: %s", addr_str);
@ -173,7 +176,7 @@ static void start_scan(void)
err = bt_le_scan_start(BT_LE_SCAN_PASSIVE, device_found);
if (err) {
FAIL("Scanning failed to start (err %d)\n", err);
TEST_FAIL("Scanning failed to start (err %d)", err);
}
LOG_DBG("Scanning successfully started");
@ -185,7 +188,7 @@ static void disconnect(void)
err = bt_conn_disconnect(default_conn, BT_HCI_ERR_REMOTE_USER_TERM_CONN);
if (err) {
FAIL("Disconnection failed (err %d)\n", err);
TEST_FAIL("Disconnection failed (err %d)", err);
}
WAIT_FOR_FLAG(disconnected_flag);
@ -205,7 +208,7 @@ static void connect_pair_subscribe(void)
err = bt_conn_set_security(default_conn, BT_SECURITY_L2);
if (err != 0) {
FAIL("Failed to set security (err %d)\n", err);
TEST_FAIL("Failed to set security (err %d)", err);
}
WAIT_FOR_FLAG(security_updated_flag);
@ -215,9 +218,9 @@ static void connect_pair_subscribe(void)
ccc_subscribe();
/* confirm to server that we subscribed */
backchannel_sync_send(SERVER_CHAN, SERVER_ID);
bk_sync_send();
/* wait for server to check that the subscribtion is well registered */
backchannel_sync_wait(SERVER_CHAN, SERVER_ID);
bk_sync_wait();
WAIT_FOR_FLAG(notification_received_flag);
UNSET_FLAG(notification_received_flag);
@ -234,21 +237,21 @@ static void connect_restore_sec(void)
err = bt_conn_set_security(default_conn, BT_SECURITY_L2);
if (err != 0) {
FAIL("Failed to set security (err %d)\n", err);
TEST_FAIL("Failed to set security (err %d)", err);
}
WAIT_FOR_FLAG(security_updated_flag);
UNSET_FLAG(security_updated_flag);
/* check local subscription state */
if (GET_FLAG(gatt_subscribed_flag) == false) {
FAIL("Not subscribed\n");
if (!IS_FLAG_SET(gatt_subscribed_flag)) {
TEST_FAIL("Not subscribed");
}
/* notify the end of security update to server */
backchannel_sync_send(SERVER_CHAN, SERVER_ID);
bk_sync_send();
/* wait for server to check that the subscribtion has been restored */
backchannel_sync_wait(SERVER_CHAN, SERVER_ID);
bk_sync_wait();
WAIT_FOR_FLAG(notification_received_flag);
UNSET_FLAG(notification_received_flag);
@ -256,26 +259,6 @@ static void connect_restore_sec(void)
/* Util functions */
void central_backchannel_init(void)
{
uint device_number = get_device_nbr();
uint channel_numbers[1] = {
0,
};
uint device_numbers[1];
uint num_ch = 1;
uint *ch;
device_numbers[0] = SERVER_ID;
LOG_DBG("Opening back channels for device %d", device_number);
ch = bs_open_back_channel(device_number, device_numbers, channel_numbers, num_ch);
if (!ch) {
FAIL("Unable to open backchannel\n");
}
LOG_DBG("Back channels for device %d opened", device_number);
}
static void set_public_addr(void)
{
bt_addr_le_t addr = {BT_ADDR_LE_RANDOM, {{0x0A, 0x89, 0x67, 0x45, 0x23, 0xC1}}};
@ -293,12 +276,12 @@ void run_central(int times)
central_cb.disconnected = disconnected;
central_cb.security_changed = security_changed;
central_backchannel_init();
TEST_ASSERT(bk_sync_init() == 0);
set_public_addr();
err = bt_enable(NULL);
if (err) {
FAIL("Bluetooth init failed (err %d)\n", err);
TEST_FAIL("Bluetooth init failed (err %d)", err);
}
LOG_DBG("Bluetooth initialized");
@ -307,12 +290,12 @@ void run_central(int times)
err = settings_load();
if (err) {
FAIL("Settings load failed (err %d)\n", err);
TEST_FAIL("Settings load failed (err %d)", err);
}
err = bt_unpair(BT_ID_DEFAULT, BT_ADDR_LE_ANY);
if (err) {
FAIL("Unpairing failed (err %d)\n", err);
TEST_FAIL("Unpairing failed (err %d)", err);
}
connect_pair_subscribe();
@ -323,5 +306,5 @@ void run_central(int times)
disconnect();
}
PASS("Central test passed\n");
TEST_PASS("Central test passed");
}

38
tests/bsim/bluetooth/host/gatt/ccc_store/src/common.c
View file

@ -1,38 +0,0 @@
/* Copyright (c) 2023 Nordic Semiconductor ASA
* SPDX-License-Identifier: Apache-2.0
*/
#include <stdint.h>
#include "common.h"
#include "argparse.h"
#include "bs_pc_backchannel.h"
void backchannel_sync_send(uint channel, uint device_nbr)
{
uint8_t sync_msg[BC_MSG_SIZE] = {get_device_nbr(), device_nbr}; /* src, dst */
bs_bc_send_msg(channel, sync_msg, ARRAY_SIZE(sync_msg));
}
void backchannel_sync_wait(uint channel, uint device_nbr)
{
uint8_t sync_msg[BC_MSG_SIZE];
LOG_DBG("Wait for %d on channel %d", device_nbr, channel);
while (true) {
if (bs_bc_is_msg_received(channel) > 0) {
bs_bc_receive_msg(channel, sync_msg, ARRAY_SIZE(sync_msg));
if (sync_msg[0] == device_nbr && sync_msg[1] == get_device_nbr()) {
break;
}
}
k_msleep(1);
}
LOG_DBG("Sync received");
}

39
tests/bsim/bluetooth/host/gatt/ccc_store/src/common.h
View file

@ -2,39 +2,8 @@
* SPDX-License-Identifier: Apache-2.0
*/
#include <zephyr/kernel.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/settings/settings.h>
#include <zephyr/logging/log.h>
#include "bs_tracing.h"
#include "bstests.h"
#define FAIL(...) \
do { \
bst_result = Failed; \
bs_trace_error_time_line(__VA_ARGS__); \
} while (0)
#define PASS(...) \
do { \
bst_result = Passed; \
bs_trace_info_time(1, __VA_ARGS__); \
} while (0)
extern enum bst_result_t bst_result;
#define CREATE_FLAG(flag) static atomic_t flag = (atomic_t) false
#define SET_FLAG(flag) (void)atomic_set(&flag, (atomic_t) true)
#define GET_FLAG(flag) (bool)atomic_get(&flag)
#define UNSET_FLAG(flag) (void)atomic_set(&flag, (atomic_t) false)
#define WAIT_FOR_FLAG(flag) \
while (!(bool)atomic_get(&flag)) { \
(void)k_sleep(K_MSEC(1)); \
}
LOG_MODULE_DECLARE(bt_bsim_ccc_store, LOG_LEVEL_DBG);
#define DUMMY_SERVICE_TYPE BT_UUID_128_ENCODE(0x2e2b8dc3, 0x06e0, 0x4f93, 0x9bb2, 0x734091c356f0)
@ -46,11 +15,3 @@ LOG_MODULE_DECLARE(bt_bsim_ccc_store, LOG_LEVEL_DBG);
#define VAL_HANDLE 18
#define CCC_HANDLE 19
#define BC_MSG_SIZE 2
#define CLIENT_ID 0
#define SERVER_ID 1
void backchannel_sync_send(uint channel, uint device_nbr);
void backchannel_sync_wait(uint channel, uint device_nbr);

41
tests/bsim/bluetooth/host/gatt/ccc_store/src/main.c
View file

@ -4,32 +4,13 @@
#include <zephyr/kernel.h>
#include "bs_types.h"
#include "bs_tracing.h"
#include "bstests.h"
#include <string.h>
#include <stdlib.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(bt_bsim_ccc_store, LOG_LEVEL_DBG);
#define FAIL(...) \
do { \
bst_result = Failed; \
bs_trace_error_time_line(__VA_ARGS__); \
} while (0)
#define PASS(...) \
do { \
bst_result = Passed; \
bs_trace_info_time(1, __VA_ARGS__); \
} while (0)
extern enum bst_result_t bst_result;
#define WAIT_TIME_S 60
#define WAIT_TIME (WAIT_TIME_S * 1e6)
static int n_times;
extern void run_peripheral(int times);
@ -45,41 +26,23 @@ static void peripheral_main(void)
run_peripheral(n_times);
}
void test_tick(bs_time_t HW_device_time)
{
if (bst_result != Passed) {
bst_result = Failed;
bs_trace_error_time_line("Test failed (not passed after %d seconds)\n",
WAIT_TIME_S);
}
}
static void test_args(int argc, char **argv)
{
__ASSERT(argc == 1, "Please specify only 1 test argument\n");
n_times = atol(argv[0]);
}
static void test_ccc_store_init(void)
{
bst_ticker_set_next_tick_absolute(WAIT_TIME);
n_times = strtol(argv[0], NULL, 10);
}
static const struct bst_test_instance test_def[] = {
{
.test_id = "central",
.test_descr = "Central device",
.test_pre_init_f = test_ccc_store_init,
.test_tick_f = test_tick,
.test_main_f = central_main,
.test_args_f = test_args,
},
{
.test_id = "peripheral",
.test_descr = "Peripheral device",
.test_pre_init_f = test_ccc_store_init,
.test_tick_f = test_tick,
.test_main_f = peripheral_main,
.test_args_f = test_args,
},

63
tests/bsim/bluetooth/host/gatt/ccc_store/src/peripheral.c
View file

@ -20,15 +20,17 @@
#include "settings.h"
#include "argparse.h"
#include "bs_pc_backchannel.h"
#include "babblekit/testcase.h"
#include "babblekit/flags.h"
#include "babblekit/sync.h"
#define CLIENT_CHAN 0
CREATE_FLAG(connected_flag);
CREATE_FLAG(disconnected_flag);
CREATE_FLAG(security_updated_flag);
static DEFINE_FLAG(connected_flag);
static DEFINE_FLAG(disconnected_flag);
static DEFINE_FLAG(security_updated_flag);
CREATE_FLAG(ccc_cfg_changed_flag);
static DEFINE_FLAG(ccc_cfg_changed_flag);
static const struct bt_uuid_128 dummy_service = BT_UUID_INIT_128(DUMMY_SERVICE_TYPE);
@ -61,7 +63,7 @@ static void create_adv(struct bt_le_ext_adv **adv)
err = bt_le_ext_adv_create(BT_LE_ADV_CONN_FAST_1, NULL, adv);
if (err) {
FAIL("Failed to create advertiser (%d)\n", err);
TEST_FAIL("Failed to create advertiser (%d)", err);
}
}
@ -78,7 +80,7 @@ static void start_adv(struct bt_le_ext_adv *adv)
err = bt_le_ext_adv_start(adv, &start_params);
if (err) {
FAIL("Failed to start advertiser (err %d)\n", err);
TEST_FAIL("Failed to start advertiser (err %d)", err);
}
LOG_DBG("Advertiser started");
@ -90,7 +92,7 @@ static void stop_adv(struct bt_le_ext_adv *adv)
err = bt_le_ext_adv_stop(adv);
if (err) {
FAIL("Failed to stop advertiser (err %d)\n", err);
TEST_FAIL("Failed to stop advertiser (err %d)", err);
}
}
@ -101,7 +103,7 @@ static void connected(struct bt_conn *conn, uint8_t err)
bt_addr_le_to_str(bt_conn_get_dst(conn), addr_str, sizeof(addr_str));
if (err) {
FAIL("Failed to connect to %s (err %d)\n", addr_str, err);
TEST_FAIL("Failed to connect to %s (err %d)", addr_str, err);
}
LOG_DBG("Connected: %s", addr_str);
@ -160,7 +162,7 @@ static void send_value_notification(void)
err = bt_gatt_notify(default_conn, attr, &value, sizeof(value));
if (err != 0) {
FAIL("Failed to send notification (err %d)\n", err);
TEST_FAIL("Failed to send notification (err %d)", err);
}
value++;
@ -176,17 +178,17 @@ static void connect_pair_check_subscribtion(struct bt_le_ext_adv *adv)
UNSET_FLAG(security_updated_flag);
/* wait for confirmation of subscribtion from good client */
backchannel_sync_wait(CLIENT_CHAN, CLIENT_ID);
bk_sync_wait();
/* check that subscribtion request did not fail */
if (!is_peer_subscribed(default_conn)) {
FAIL("Client did not subscribed\n");
TEST_FAIL("Client did not subscribed");
}
stop_adv(adv);
/* confirm to client that the subscribtion has been well registered */
backchannel_sync_send(CLIENT_CHAN, CLIENT_ID);
bk_sync_send();
send_value_notification();
}
@ -201,42 +203,23 @@ static void connect_restore_sec_check_subscribtion(struct bt_le_ext_adv *adv)
UNSET_FLAG(security_updated_flag);
/* wait for client end of security update */
backchannel_sync_wait(CLIENT_CHAN, CLIENT_ID);
bk_sync_wait();
/* check that subscribtion has been restored */
if (!is_peer_subscribed(default_conn)) {
FAIL("Client is not subscribed\n");
TEST_FAIL("Client is not subscribed");
} else {
LOG_DBG("Client is subscribed");
}
/* confirm to good client that the subscribtion has been well restored */
backchannel_sync_send(CLIENT_CHAN, CLIENT_ID);
bk_sync_send();
send_value_notification();
}
/* Util functions */
void peripheral_backchannel_init(void)
{
uint device_number = get_device_nbr();
uint channel_numbers[1] = {
0,
};
uint device_numbers[1] = {
CLIENT_ID,
};
uint num_ch = 1;
uint *ch;
LOG_DBG("Opening back channels for device %d", device_number);
ch = bs_open_back_channel(device_number, device_numbers, channel_numbers, num_ch);
if (!ch) {
FAIL("Unable to open backchannel\n");
}
}
static void check_ccc_handle(void)
{
struct bt_gatt_attr *service_notify_attr =
@ -269,11 +252,11 @@ void run_peripheral(int times)
peripheral_cb.disconnected = disconnected;
peripheral_cb.security_changed = security_changed;
peripheral_backchannel_init();
TEST_ASSERT(bk_sync_init() == 0);
err = bt_enable(NULL);
if (err) {
FAIL("Bluetooth init failed (err %d)\n", err);
TEST_FAIL("Bluetooth init failed (err %d)", err);
}
LOG_DBG("Bluetooth initialized");
@ -284,12 +267,12 @@ void run_peripheral(int times)
err = settings_load();
if (err) {
FAIL("Settings load failed (err %d)\n", err);
TEST_FAIL("Settings load failed (err %d)", err);
}
err = bt_unpair(BT_ID_DEFAULT, BT_ADDR_LE_ANY);
if (err) {
FAIL("Unpairing failed (err %d)\n", err);
TEST_FAIL("Unpairing failed (err %d)", err);
}
create_adv(&adv);
@ -302,5 +285,5 @@ void run_peripheral(int times)
WAIT_FOR_FLAG(disconnected_flag);
}
PASS("Peripheral test passed\n");
TEST_PASS("Peripheral test passed");
}

3
tests/bsim/bluetooth/host/gatt/general/CMakeLists.txt
View file

@ -5,6 +5,9 @@ cmake_minimum_required(VERSION 3.20.0)
find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
project(bsim_test_gatt)
add_subdirectory(${ZEPHYR_BASE}/tests/bsim/babblekit babblekit)
target_link_libraries(app PRIVATE babblekit)
FILE(GLOB app_sources src/*.c)
target_sources(app PRIVATE ${app_sources} )

20
tests/bsim/bluetooth/host/gatt/general/src/common.c
View file

@ -1,20 +0,0 @@
/*
* Copyright (c) 2022 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "common.h"
void test_tick(bs_time_t HW_device_time)
{
if (bst_result != Passed) {
FAIL("test failed (not passed after %i seconds)\n", WAIT_TIME);
}
}
void test_init(void)
{
bst_ticker_set_next_tick_absolute(WAIT_TIME);
bst_result = In_progress;
}

44
tests/bsim/bluetooth/host/gatt/general/src/common.h
View file

@ -6,47 +6,6 @@
* SPDX-License-Identifier: Apache-2.0
*/
#include <zephyr/kernel.h>
#include "bs_types.h"
#include "bs_tracing.h"
#include "time_machine.h"
#include "bstests.h"
#include <zephyr/types.h>
#include <stddef.h>
#include <errno.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/uuid.h>
#include <zephyr/bluetooth/gatt.h>
extern enum bst_result_t bst_result;
#define WAIT_TIME (30 * 1e6) /*seconds*/
#define CREATE_FLAG(flag) static atomic_t flag = (atomic_t)false
#define SET_FLAG(flag) (void)atomic_set(&flag, (atomic_t)true)
#define UNSET_FLAG(flag) (void)atomic_set(&flag, (atomic_t)false)
#define WAIT_FOR_FLAG(flag) \
while (!(bool)atomic_get(&flag)) { \
(void)k_sleep(K_MSEC(1)); \
}
#define FAIL(...) \
do { \
bst_result = Failed; \
bs_trace_error_time_line(__VA_ARGS__); \
} while (0)
#define PASS(...) \
do { \
bst_result = Passed; \
bs_trace_info_time(1, __VA_ARGS__); \
} while (0)
#define CHRC_SIZE 10
#define LONG_CHRC_SIZE 40
@ -69,6 +28,3 @@ extern enum bst_result_t bst_result;
#define TEST_LESC_CHRC_UUID \
BT_UUID_DECLARE_128(0x01, 0x23, 0x45, 0x67, 0x89, 0x01, 0x02, 0x03, \
0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0xFF, 0x33)
void test_tick(bs_time_t HW_device_time);
void test_init(void);

66
tests/bsim/bluetooth/host/gatt/general/src/gatt_client_test.c
View file

@ -4,16 +4,27 @@
* SPDX-License-Identifier: Apache-2.0
*/
#include <zephyr/kernel.h>
#include <zephyr/types.h>
#include <stddef.h>
#include <errno.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/uuid.h>
#include <zephyr/bluetooth/gatt.h>
#include "babblekit/testcase.h"
#include "babblekit/flags.h"
#include "common.h"
CREATE_FLAG(flag_is_connected);
CREATE_FLAG(flag_discover_complete);
CREATE_FLAG(flag_security_changed);
CREATE_FLAG(flag_write_complete);
CREATE_FLAG(flag_read_complete);
static DEFINE_FLAG(flag_is_connected);
static DEFINE_FLAG(flag_discover_complete);
static DEFINE_FLAG(flag_security_changed);
static DEFINE_FLAG(flag_write_complete);
static DEFINE_FLAG(flag_read_complete);
static struct bt_conn *g_conn;
static uint16_t chrc_handle;
@ -36,7 +47,7 @@ static void connected(struct bt_conn *conn, uint8_t err)
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
if (err != 0) {
FAIL("Failed to connect to %s (%u)\n", addr, err);
TEST_FAIL("Failed to connect to %s (%u)", addr, err);
return;
}
@ -68,7 +79,7 @@ static void disconnected(struct bt_conn *conn, uint8_t reason)
static void security_changed(struct bt_conn *conn, bt_security_t level, enum bt_security_err err)
{
if (err != BT_SECURITY_ERR_SUCCESS) {
FAIL("Security failed (err %d)\n", err);
TEST_FAIL("Security failed (err %d)", err);
} else {
SET_FLAG(flag_security_changed);
}
@ -101,14 +112,14 @@ void device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type,
printk("Stopping scan\n");
err = bt_le_scan_stop();
if (err != 0) {
FAIL("Could not stop scan: %d\n");
TEST_FAIL("Could not stop scan: %d");
return;
}
err = bt_conn_le_create(addr, BT_CONN_LE_CREATE_CONN,
BT_LE_CONN_PARAM_DEFAULT, &g_conn);
if (err != 0) {
FAIL("Could not connect to peer: %d\n", err);
TEST_FAIL("Could not connect to peer: %d", err);
}
}
@ -120,7 +131,7 @@ static uint8_t discover_func(struct bt_conn *conn,
if (attr == NULL) {
if (chrc_handle == 0 || long_chrc_handle == 0) {
FAIL("Did not discover chrc (%x) or long_chrc (%x)\n", chrc_handle,
TEST_FAIL("Did not discover chrc (%x) or long_chrc (%x)", chrc_handle,
long_chrc_handle);
}
@ -142,7 +153,7 @@ static uint8_t discover_func(struct bt_conn *conn,
err = bt_gatt_discover(conn, params);
if (err != 0) {
FAIL("Discover failed (err %d)\n", err);
TEST_FAIL("Discover failed (err %d)", err);
}
return BT_GATT_ITER_STOP;
@ -182,7 +193,7 @@ static void gatt_discover(void)
err = bt_gatt_discover(g_conn, &discover_params);
if (err != 0) {
FAIL("Discover failed(err %d)\n", err);
TEST_FAIL("Discover failed(err %d)", err);
}
WAIT_FOR_FLAG(flag_discover_complete);
@ -196,7 +207,7 @@ static void update_security(void)
printk("Updating security\n");
err = bt_conn_set_security(g_conn, BT_SECURITY_L2);
if (err != 0) {
FAIL("Set security failed (err %d)\n", err);
TEST_FAIL("Set security failed (err %d)", err);
}
WAIT_FOR_FLAG(flag_security_changed);
@ -241,13 +252,13 @@ static void gatt_write(uint16_t handle, uint8_t expect_att_err)
err = bt_gatt_write(g_conn, &write_params);
if (err != 0) {
FAIL("bt_gatt_write failed: %d\n", err);
TEST_FAIL("bt_gatt_write failed: %d", err);
}
WAIT_FOR_FLAG(flag_write_complete);
if (att_err != expect_att_err) {
FAIL("Write failed: 0x%02X\n", att_err);
TEST_FAIL("Write failed: 0x%02X", att_err);
}
printk("success\n");
@ -270,7 +281,8 @@ static uint8_t gatt_read_cb(struct bt_conn *conn, uint8_t err,
if (data != NULL) {
if (data_received_size + length > sizeof(data_received)) {
FAIL("Invalid amount of data received: %u\n", data_received_size + length);
TEST_FAIL("Invalid amount of data received: %u",
data_received_size + length);
} else {
memcpy(&data_received[data_received_size], data, length);
data_received_size += length;
@ -282,23 +294,25 @@ static uint8_t gatt_read_cb(struct bt_conn *conn, uint8_t err,
if (params->single.handle == chrc_handle) {
if (data_received_size != CHRC_SIZE ||
memcmp(data_received, chrc_data, data_received_size) != 0) {
FAIL("chrc data different than expected (%u %u)\n", length, CHRC_SIZE);
TEST_FAIL("chrc data different than expected (%u %u)", length, CHRC_SIZE);
}
} else if (params->single.handle == long_chrc_handle) {
if (data_received_size != LONG_CHRC_SIZE ||
memcmp(data_received, long_chrc_data, data_received_size) != 0) {
FAIL("long_chrc data different than expected (%u %u)\n", length,
TEST_FAIL("long_chrc data different than expected (%u %u)", length,
LONG_CHRC_SIZE);
}
} else if (params->single.handle == enc_chrc_handle) {
if (data_received_size != CHRC_SIZE ||
memcmp(data_received, chrc_data, data_received_size) != 0) {
FAIL("enc_chrc data different than expected (%u %u)\n", length, CHRC_SIZE);
TEST_FAIL("enc_chrc data different than expected (%u %u)", length,
CHRC_SIZE);
}
} else if (params->single.handle == lesc_chrc_handle) {
if (data_received_size != CHRC_SIZE ||
memcmp(data_received, chrc_data, data_received_size) != 0) {
FAIL("lesc_chrc data different than expected (%u %u)\n", length, CHRC_SIZE);
TEST_FAIL("lesc_chrc data different than expected (%u %u)", length,
CHRC_SIZE);
}
}
@ -335,13 +349,13 @@ static void gatt_read(uint16_t handle, uint8_t expect_att_err)
err = bt_gatt_read(g_conn, &read_params);
if (err != 0) {
FAIL("bt_gatt_read failed: %d\n", err);
TEST_FAIL("bt_gatt_read failed: %d", err);
}
WAIT_FOR_FLAG(flag_read_complete);
if (att_err != expect_att_err) {
FAIL("Read failed: 0x%02X\n", att_err);
TEST_FAIL("Read failed: 0x%02X", att_err);
}
printk("success\n");
@ -355,12 +369,12 @@ static void test_main(void)
err = bt_enable(NULL);
if (err != 0) {
FAIL("Bluetooth discover failed (err %d)\n", err);
TEST_FAIL("Bluetooth discover failed (err %d)", err);
}
err = bt_le_scan_start(BT_LE_SCAN_PASSIVE, device_found);
if (err != 0) {
FAIL("Scanning failed to start (err %d)\n", err);
TEST_FAIL("Scanning failed to start (err %d)", err);
}
printk("Scanning successfully started\n");
@ -389,14 +403,12 @@ static void test_main(void)
gatt_write(lesc_chrc_handle, BT_ATT_ERR_SUCCESS);
gatt_read(lesc_chrc_handle, BT_ATT_ERR_SUCCESS);
PASS("GATT client Passed\n");
TEST_PASS("GATT client Passed");
}
static const struct bst_test_instance test_vcs[] = {
{
.test_id = "gatt_client",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_main
},
BSTEST_END_MARKER

28
tests/bsim/bluetooth/host/gatt/general/src/gatt_server_test.c
View file

@ -4,11 +4,25 @@
* SPDX-License-Identifier: Apache-2.0
*/
#include <zephyr/kernel.h>
#include <zephyr/types.h>
#include <stddef.h>
#include <errno.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/uuid.h>
#include <zephyr/bluetooth/gatt.h>
#include "babblekit/testcase.h"
#include "babblekit/flags.h"
#include "common.h"
extern enum bst_result_t bst_result;
CREATE_FLAG(flag_is_connected);
static DEFINE_FLAG(flag_is_connected);
static struct bt_conn *g_conn;
@ -19,7 +33,7 @@ static void connected(struct bt_conn *conn, uint8_t err)
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
if (err != 0) {
FAIL("Failed to connect to %s (%u)\n", addr, err);
TEST_FAIL("Failed to connect to %s (%u)", addr, err);
return;
}
@ -79,7 +93,7 @@ static ssize_t write_test_chrc(struct bt_conn *conn,
}
if (flags != 0) {
FAIL("Invalid flags %u\n", flags);
TEST_FAIL("Invalid flags %u", flags);
return BT_GATT_ERR(BT_ATT_ERR_UNLIKELY);
}
@ -155,7 +169,7 @@ static void test_main(void)
err = bt_enable(NULL);
if (err != 0) {
FAIL("Bluetooth init failed (err %d)\n", err);
TEST_FAIL("Bluetooth init failed (err %d)", err);
return;
}
@ -163,7 +177,7 @@ static void test_main(void)
err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_1, ad, ARRAY_SIZE(ad), NULL, 0);
if (err != 0) {
FAIL("Advertising failed to start (err %d)\n", err);
TEST_FAIL("Advertising failed to start (err %d)", err);
return;
}
@ -171,14 +185,12 @@ static void test_main(void)
WAIT_FOR_FLAG(flag_is_connected);
PASS("GATT server passed\n");
TEST_PASS("GATT server passed");
}
static const struct bst_test_instance test_gatt_server[] = {
{
.test_id = "gatt_server",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_main
},
BSTEST_END_MARKER

2
tests/bsim/bluetooth/host/gatt/general/test_scripts/gatt.sh
View file

@ -21,6 +21,6 @@ Execute ./bs_${BOARD_TS}_tests_bsim_bluetooth_host_gatt_general_prj_conf \
-v=${verbosity_level} -s=${simulation_id} -d=1 -testid=gatt_server -RealEncryption=1
Execute ./bs_2G4_phy_v1 -v=${verbosity_level} -s=${simulation_id} \
-D=2 -sim_length=60e6 $@
-D=2 -sim_length=30e6 $@
wait_for_background_jobs

3
tests/bsim/bluetooth/host/gatt/notify/CMakeLists.txt
View file

@ -5,6 +5,9 @@ cmake_minimum_required(VERSION 3.20.0)
find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
project(bsim_test_gatt)
add_subdirectory(${ZEPHYR_BASE}/tests/bsim/babblekit babblekit)
target_link_libraries(app PRIVATE babblekit)
FILE(GLOB app_sources src/*.c)
target_sources(app PRIVATE ${app_sources} )

20
tests/bsim/bluetooth/host/gatt/notify/src/common.c
View file

@ -1,20 +0,0 @@
/*
* Copyright (c) 2022 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "common.h"
void test_tick(bs_time_t HW_device_time)
{
if (bst_result != Passed) {
FAIL("test failed (not passed after %i seconds)\n", WAIT_TIME);
}
}
void test_init(void)
{
bst_ticker_set_next_tick_absolute(WAIT_TIME);
bst_result = In_progress;
}

44
tests/bsim/bluetooth/host/gatt/notify/src/common.h
View file

@ -6,46 +6,7 @@
* SPDX-License-Identifier: Apache-2.0
*/
#include <zephyr/kernel.h>
#include "bs_types.h"
#include "bs_tracing.h"
#include "time_machine.h"
#include "bstests.h"
#include <zephyr/types.h>
#include <stddef.h>
#include <errno.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/uuid.h>
#include <zephyr/bluetooth/gatt.h>
extern enum bst_result_t bst_result;
#define WAIT_TIME (60 * 1e6) /*seconds*/
#define CREATE_FLAG(flag) static atomic_t flag = (atomic_t)false
#define SET_FLAG(flag) (void)atomic_set(&flag, (atomic_t)true)
#define UNSET_FLAG(flag) (void)atomic_set(&flag, (atomic_t)false)
#define WAIT_FOR_FLAG(flag) \
while (!(bool)atomic_get(&flag)) { \
(void)k_sleep(K_MSEC(1)); \
}
#define FAIL(...) \
do { \
bst_result = Failed; \
bs_trace_error_time_line(__VA_ARGS__); \
} while (0)
#define PASS(...) \
do { \
bst_result = Passed; \
bs_trace_info_time(1, __VA_ARGS__); \
} while (0)
#include <zephyr/toolchain.h>
#define CHRC_SIZE 10
#define LONG_CHRC_SIZE 40
@ -62,8 +23,5 @@ extern enum bst_result_t bst_result;
BT_UUID_DECLARE_128(0x01, 0x23, 0x45, 0x67, 0x89, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, \
0x07, 0x08, 0x09, 0xFF, 0x11)
void test_tick(bs_time_t HW_device_time);
void test_init(void);
#define NOTIFICATION_COUNT 10
BUILD_ASSERT(NOTIFICATION_COUNT % 2 == 0);

74
tests/bsim/bluetooth/host/gatt/notify/src/gatt_client_test.c
View file

@ -4,16 +4,26 @@
* SPDX-License-Identifier: Apache-2.0
*/
#include <stddef.h>
#include <errno.h>
#include <zephyr/kernel.h>
#include <zephyr/types.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/uuid.h>
#include <zephyr/bluetooth/gatt.h>
#include "babblekit/testcase.h"
#include "babblekit/flags.h"
#include "common.h"
CREATE_FLAG(flag_is_connected);
CREATE_FLAG(flag_is_encrypted);
CREATE_FLAG(flag_discover_complete);
CREATE_FLAG(flag_short_subscribed);
CREATE_FLAG(flag_long_subscribed);
static DEFINE_FLAG(flag_is_connected);
static DEFINE_FLAG(flag_is_encrypted);
static DEFINE_FLAG(flag_discover_complete);
static DEFINE_FLAG(flag_short_subscribed);
static DEFINE_FLAG(flag_long_subscribed);
static struct bt_conn *g_conn;
static uint16_t chrc_handle;
@ -27,7 +37,7 @@ static void connected(struct bt_conn *conn, uint8_t err)
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
if (err != 0) {
FAIL("Failed to connect to %s (%u)\n", addr, err);
TEST_FAIL("Failed to connect to %s (%u)", addr, err);
return;
}
@ -57,9 +67,9 @@ static void disconnected(struct bt_conn *conn, uint8_t reason)
void security_changed(struct bt_conn *conn, bt_security_t level, enum bt_security_err err)
{
if (err) {
FAIL("Encryption failer (%d)\n", err);
TEST_FAIL("Encryption failure (%d)", err);
} else if (level < BT_SECURITY_L2) {
FAIL("Insufficient sec level (%d)\n", level);
TEST_FAIL("Insufficient sec level (%d)", level);
} else {
SET_FLAG(flag_is_encrypted);
}
@ -91,13 +101,13 @@ void device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type, struct ne
printk("Stopping scan\n");
err = bt_le_scan_stop();
if (err != 0) {
FAIL("Could not stop scan: %d");
TEST_FAIL("Could not stop scan: %d");
return;
}
err = bt_conn_le_create(addr, BT_CONN_LE_CREATE_CONN, BT_LE_CONN_PARAM_DEFAULT, &g_conn);
if (err != 0) {
FAIL("Could not connect to peer: %d", err);
TEST_FAIL("Could not connect to peer: %d", err);
}
}
@ -108,7 +118,7 @@ static uint8_t discover_func(struct bt_conn *conn, const struct bt_gatt_attr *at
if (attr == NULL) {
if (chrc_handle == 0 || long_chrc_handle == 0) {
FAIL("Did not discover chrc (%x) or long_chrc (%x)", chrc_handle,
TEST_FAIL("Did not discover chrc (%x) or long_chrc (%x)", chrc_handle,
long_chrc_handle);
}
@ -130,7 +140,7 @@ static uint8_t discover_func(struct bt_conn *conn, const struct bt_gatt_attr *at
err = bt_gatt_discover(conn, params);
if (err != 0) {
FAIL("Discover failed (err %d)\n", err);
TEST_FAIL("Discover failed (err %d)", err);
}
return BT_GATT_ITER_STOP;
@ -165,7 +175,7 @@ static void gatt_discover(enum bt_att_chan_opt opt)
err = bt_gatt_discover(g_conn, &discover_params);
if (err != 0) {
FAIL("Discover failed(err %d)\n", err);
TEST_FAIL("Discover failed(err %d)", err);
}
WAIT_FOR_FLAG(flag_discover_complete);
@ -176,7 +186,7 @@ static void test_short_subscribed(struct bt_conn *conn, uint8_t err,
struct bt_gatt_subscribe_params *params)
{
if (err) {
FAIL("Subscribe failed (err %d)\n", err);
TEST_FAIL("Subscribe failed (err %d)", err);
}
SET_FLAG(flag_short_subscribed);
@ -189,7 +199,7 @@ static void test_short_subscribed(struct bt_conn *conn, uint8_t err,
if (params->value_handle == chrc_handle) {
printk("Subscribed to short characteristic\n");
} else {
FAIL("Unknown handle %d\n", params->value_handle);
TEST_FAIL("Unknown handle %d", params->value_handle);
}
}
@ -197,7 +207,7 @@ static void test_long_subscribed(struct bt_conn *conn, uint8_t err,
struct bt_gatt_subscribe_params *params)
{
if (err) {
FAIL("Subscribe failed (err %d)\n", err);
TEST_FAIL("Subscribe failed (err %d)", err);
}
SET_FLAG(flag_long_subscribed);
@ -210,7 +220,7 @@ static void test_long_subscribed(struct bt_conn *conn, uint8_t err,
if (params->value_handle == long_chrc_handle) {
printk("Subscribed to long characteristic\n");
} else {
FAIL("Unknown handle %d\n", params->value_handle);
TEST_FAIL("Unknown handle %d", params->value_handle);
}
}
@ -250,7 +260,7 @@ static void gatt_subscribe_short(enum bt_att_chan_opt opt)
sub_params_short.chan_opt = opt;
err = bt_gatt_subscribe(g_conn, &sub_params_short);
if (err < 0) {
FAIL("Failed to subscribe\n");
TEST_FAIL("Failed to subscribe");
} else {
printk("Subscribe request sent\n");
}
@ -264,7 +274,7 @@ static void gatt_unsubscribe_short(enum bt_att_chan_opt opt)
sub_params_short.chan_opt = opt;
err = bt_gatt_unsubscribe(g_conn, &sub_params_short);
if (err < 0) {
FAIL("Failed to unsubscribe\n");
TEST_FAIL("Failed to unsubscribe");
} else {
printk("Unsubscribe request sent\n");
}
@ -279,7 +289,7 @@ static void gatt_subscribe_long(enum bt_att_chan_opt opt)
sub_params_long.chan_opt = opt;
err = bt_gatt_subscribe(g_conn, &sub_params_long);
if (err < 0) {
FAIL("Failed to subscribe\n");
TEST_FAIL("Failed to subscribe");
} else {
printk("Subscribe request sent\n");
}
@ -294,7 +304,7 @@ static void gatt_unsubscribe_long(enum bt_att_chan_opt opt)
sub_params_long.chan_opt = opt;
err = bt_gatt_unsubscribe(g_conn, &sub_params_long);
if (err < 0) {
FAIL("Failed to unsubscribe\n");
TEST_FAIL("Failed to unsubscribe");
} else {
printk("Unsubscribe request sent\n");
}
@ -306,12 +316,12 @@ static void setup(void)
err = bt_enable(NULL);
if (err != 0) {
FAIL("Bluetooth discover failed (err %d)\n", err);
TEST_FAIL("Bluetooth discover failed (err %d)", err);
}
err = bt_le_scan_start(BT_LE_SCAN_PASSIVE, device_found);
if (err != 0) {
FAIL("Scanning failed to start (err %d)\n", err);
TEST_FAIL("Scanning failed to start (err %d)", err);
}
printk("Scanning successfully started\n");
@ -320,7 +330,7 @@ static void setup(void)
err = bt_conn_set_security(g_conn, BT_SECURITY_L2);
if (err) {
FAIL("Starting encryption procedure failed (%d)\n", err);
TEST_FAIL("Starting encryption procedure failed (%d)", err);
}
WAIT_FOR_FLAG(flag_is_encrypted);
@ -354,7 +364,7 @@ static void test_main_none(void)
printk("Unsubscribed\n");
PASS("GATT client Passed\n");
TEST_PASS("GATT client Passed");
}
static void test_main_unenhanced(void)
@ -380,7 +390,7 @@ static void test_main_unenhanced(void)
printk("Unsubscribed\n");
PASS("GATT client Passed\n");
TEST_PASS("GATT client Passed");
}
static void test_main_enhanced(void)
@ -406,7 +416,7 @@ static void test_main_enhanced(void)
printk("Unsubscribed\n");
PASS("GATT client Passed\n");
TEST_PASS("GATT client Passed");
}
static void test_main_mixed(void)
@ -432,32 +442,24 @@ static void test_main_mixed(void)
printk("Unsubscribed\n");
PASS("GATT client Passed\n");
TEST_PASS("GATT client Passed");
}
static const struct bst_test_instance test_vcs[] = {
{
.test_id = "gatt_client_none",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_main_none,
},
{
.test_id = "gatt_client_unenhanced",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_main_unenhanced,
},
{
.test_id = "gatt_client_enhanced",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_main_enhanced,
},
{
.test_id = "gatt_client_mixed",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_main_mixed,
},
BSTEST_END_MARKER,

44
tests/bsim/bluetooth/host/gatt/notify/src/gatt_server_test.c
View file

@ -3,14 +3,26 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <stddef.h>
#include <errno.h>
#include <zephyr/kernel.h>
#include <zephyr/types.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/uuid.h>
#include <zephyr/bluetooth/gatt.h>
#include "babblekit/testcase.h"
#include "babblekit/flags.h"
#include "common.h"
extern enum bst_result_t bst_result;
CREATE_FLAG(flag_is_connected);
CREATE_FLAG(flag_short_subscribe);
CREATE_FLAG(flag_long_subscribe);
static DEFINE_FLAG(flag_is_connected);
static DEFINE_FLAG(flag_short_subscribe);
static DEFINE_FLAG(flag_long_subscribe);
static struct bt_conn *g_conn;
@ -25,7 +37,7 @@ static void connected(struct bt_conn *conn, uint8_t err)
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
if (err != 0) {
FAIL("Failed to connect to %s (%u)\n", addr, err);
TEST_FAIL("Failed to connect to %s (%u)", addr, err);
return;
}
@ -137,7 +149,7 @@ static void short_notify(enum bt_att_chan_opt opt)
if (err == -ENOMEM) {
k_sleep(K_MSEC(10));
} else if (err) {
FAIL("Short notify failed (err %d)\n", err);
TEST_FAIL("Short notify failed (err %d)", err);
}
} while (err);
}
@ -163,7 +175,7 @@ static void long_notify(enum bt_att_chan_opt opt)
if (err == -ENOMEM) {
k_sleep(K_MSEC(10));
} else if (err) {
FAIL("Long notify failed (err %d)\n", err);
TEST_FAIL("Long notify failed (err %d)", err);
}
} while (err);
}
@ -177,7 +189,7 @@ static void setup(void)
err = bt_enable(NULL);
if (err != 0) {
FAIL("Bluetooth init failed (err %d)\n", err);
TEST_FAIL("Bluetooth init failed (err %d)", err);
return;
}
@ -185,7 +197,7 @@ static void setup(void)
err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_1, ad, ARRAY_SIZE(ad), NULL, 0);
if (err != 0) {
FAIL("Advertising failed to start (err %d)\n", err);
TEST_FAIL("Advertising failed to start (err %d)", err);
return;
}
@ -215,7 +227,7 @@ static void test_main_none(void)
k_sleep(K_MSEC(100));
}
PASS("GATT server passed\n");
TEST_PASS("GATT server passed");
}
static void test_main_enhanced(void)
@ -231,7 +243,7 @@ static void test_main_enhanced(void)
k_sleep(K_MSEC(100));
}
PASS("GATT server passed\n");
TEST_PASS("GATT server passed");
}
static void test_main_unenhanced(void)
@ -247,7 +259,7 @@ static void test_main_unenhanced(void)
k_sleep(K_MSEC(100));
}
PASS("GATT server passed\n");
TEST_PASS("GATT server passed");
}
static void test_main_mixed(void)
@ -263,32 +275,24 @@ static void test_main_mixed(void)
k_sleep(K_MSEC(100));
}
PASS("GATT server passed\n");
TEST_PASS("GATT server passed");
}
static const struct bst_test_instance test_gatt_server[] = {
{
.test_id = "gatt_server_none",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_main_none,
},
{
.test_id = "gatt_server_unenhanced",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_main_unenhanced,
},
{
.test_id = "gatt_server_enhanced",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_main_enhanced,
},
{
.test_id = "gatt_server_mixed",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_main_mixed,
},
BSTEST_END_MARKER,

5
tests/bsim/bluetooth/host/gatt/settings/src/main.c
View file

@ -4,6 +4,7 @@
* SPDX-License-Identifier: Apache-2.0
*/
#include <stdlib.h>
#include "utils.h"
#include "main.h"
#include "argparse.h"
@ -41,8 +42,8 @@ static void test_args(int argc, char **argv)
{
__ASSERT(argc == 3, "Please specify only 3 test arguments\n");
test_round = atol(argv[0]);
final_round = atol(argv[1]);
test_round = strtol(argv[0], NULL, 10);
final_round = strtol(argv[1], NULL, 10);
settings_file = argv[2];
bs_trace_raw(0, "Test round %u\n", test_round);

1
tests/bsim/bluetooth/host/iso/bis/CMakeLists.txt
View file

@ -10,7 +10,6 @@ add_subdirectory(${ZEPHYR_BASE}/tests/bsim/babblekit babblekit)
target_link_libraries(app PRIVATE babblekit)
target_sources(app PRIVATE
src/common.c
src/bis_broadcaster.c
src/bis_receiver.c
src/main.c

7
tests/bsim/bluetooth/host/iso/bis/src/bis_broadcaster.c
View file

@ -3,9 +3,6 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "common.h"
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/iso.h>
#include <zephyr/logging/log.h>
@ -308,15 +305,11 @@ static const struct bst_test_instance test_def[] = {
{
.test_id = "broadcaster",
.test_descr = "Minimal BIS broadcaster that broadcast ISO data",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_main,
},
{
.test_id = "broadcaster_disable",
.test_descr = "BIS broadcaster that tests bt_disable for ISO",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_main_disable,
},
BSTEST_END_MARKER,

3
tests/bsim/bluetooth/host/iso/bis/src/bis_receiver.c
View file

@ -5,7 +5,6 @@
*/
#include <stdint.h>
#include "common.h"
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/gap.h>
@ -270,8 +269,6 @@ static const struct bst_test_instance test_def[] = {
{
.test_id = "receiver",
.test_descr = "receiver",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_main,
},
BSTEST_END_MARKER,

31
tests/bsim/bluetooth/host/iso/bis/src/common.c
View file

@ -1,31 +0,0 @@
/*
* Copyright (c) 2024 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <string.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/addr.h>
#include <zephyr/sys/printk.h>
#include <zephyr/sys/util.h>
#include "babblekit/flags.h"
#include "babblekit/testcase.h"
#include "common.h"
extern enum bst_result_t bst_result;
void test_init(void)
{
bst_result = In_progress;
bst_ticker_set_next_tick_absolute(WAIT_TIME);
}
void test_tick(bs_time_t HW_device_time)
{
if (bst_result != Passed) {
TEST_FAIL("Test failed (not passed after %" PRIu64 " us)", WAIT_TIME);
}
}

16
tests/bsim/bluetooth/host/iso/bis/src/common.h
View file

@ -1,16 +0,0 @@
/*
* Common functions and helpers for ISO broadcast tests
*
* Copyright (c) 2024 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "bs_types.h"
#include "bs_tracing.h"
#include "bstests.h"
#define WAIT_TIME (30e6) /* 30 seconds*/
void test_init(void);
void test_tick(bs_time_t HW_device_time);

3
tests/bsim/bluetooth/host/iso/cis/CMakeLists.txt
View file

@ -18,6 +18,9 @@ zephyr_include_directories(
)
add_subdirectory(${ZEPHYR_BASE}/tests/bluetooth/common/testlib testlib)
add_subdirectory(${ZEPHYR_BASE}/tests/bsim/babblekit babblekit)
target_link_libraries(app PRIVATE
testlib
babblekit
)

59
tests/bsim/bluetooth/host/iso/cis/src/cis_central.c
View file

@ -4,6 +4,8 @@
* SPDX-License-Identifier: Apache-2.0
*/
#include "babblekit/testcase.h"
#include "babblekit/flags.h"
#include "common.h"
#include <zephyr/bluetooth/bluetooth.h>
@ -25,7 +27,7 @@ NET_BUF_POOL_FIXED_DEFINE(tx_pool, ENQUEUE_COUNT, BT_ISO_SDU_BUF_SIZE(CONFIG_BT_
BUILD_ASSERT(CONFIG_BT_ISO_MAX_CHAN > 1, "CONFIG_BT_ISO_MAX_CHAN shall be at least 2");
CREATE_FLAG(flag_iso_connected);
static DEFINE_FLAG(flag_iso_connected);
static void send_data_cb(struct k_work *work)
{
@ -35,7 +37,7 @@ static void send_data_cb(struct k_work *work)
struct net_buf *buf;
int ret;
if (!TEST_FLAG(flag_iso_connected)) {
if (!IS_FLAG_SET(flag_iso_connected)) {
/* TX has been aborted */
return;
}
@ -86,7 +88,7 @@ static void device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type,
err = bt_le_scan_stop();
if (err) {
FAIL("Failed to stop scanning (err %d)\n", err);
TEST_FAIL("Failed to stop scanning (err %d)", err);
return;
}
@ -94,7 +96,7 @@ static void device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type,
err = bt_conn_le_create(addr, BT_CONN_LE_CREATE_CONN, BT_LE_CONN_PARAM_DEFAULT,
&default_conn);
if (err) {
FAIL("Failed to create connection (err %d)\n", err);
TEST_FAIL("Failed to create connection (err %d)", err);
return;
}
@ -132,14 +134,14 @@ static void sdu_sent_cb(struct bt_iso_chan *chan)
enqueue_cnt++;
if (!TEST_FLAG(flag_iso_connected)) {
if (!IS_FLAG_SET(flag_iso_connected)) {
/* TX has been aborted */
return;
}
err = k_work_schedule(&iso_send_work, K_NO_WAIT);
if (err < 0) {
FAIL("Failed to schedule TX for chan %p: %d\n", chan, err);
TEST_FAIL("Failed to schedule TX for chan %p: %d", chan, err);
}
}
@ -164,7 +166,7 @@ static void init(void)
err = bt_enable(NULL);
if (err != 0) {
FAIL("Bluetooth enable failed (err %d)\n", err);
TEST_FAIL("Bluetooth enable failed (err %d)", err);
return;
}
@ -208,7 +210,7 @@ static void create_cig(size_t iso_channels)
err = bt_iso_cig_create(&param, &cig);
if (err != 0) {
FAIL("Failed to create CIG (%d)\n", err);
TEST_FAIL("Failed to create CIG (%d)", err);
return;
}
@ -224,14 +226,14 @@ static int reconfigure_cig_interval(struct bt_iso_cig_param *param)
param->p_to_c_interval = param->c_to_p_interval;
err = bt_iso_cig_reconfigure(cig, param);
if (err != 0) {
FAIL("Failed to reconfigure CIG to new interval (%d)\n", err);
TEST_FAIL("Failed to reconfigure CIG to new interval (%d)", err);
return err;
}
err = bt_iso_cig_reconfigure(cig, param);
if (err != 0) {
FAIL("Failed to reconfigure CIG to same interval (%d)\n", err);
TEST_FAIL("Failed to reconfigure CIG to same interval (%d)", err);
return err;
}
@ -241,7 +243,7 @@ static int reconfigure_cig_interval(struct bt_iso_cig_param *param)
param->p_to_c_interval = 2500; /* us */
err = bt_iso_cig_reconfigure(cig, param);
if (err != 0) {
FAIL("Failed to reconfigure CIG to new interval (%d)\n", err);
TEST_FAIL("Failed to reconfigure CIG to new interval (%d)", err);
return err;
}
@ -259,7 +261,7 @@ static int reconfigure_cig_latency(struct bt_iso_cig_param *param)
param->p_to_c_latency = param->c_to_p_latency;
err = bt_iso_cig_reconfigure(cig, param);
if (err != 0) {
FAIL("Failed to reconfigure CIG latency (%d)\n", err);
TEST_FAIL("Failed to reconfigure CIG latency (%d)", err);
return err;
}
@ -268,7 +270,7 @@ static int reconfigure_cig_latency(struct bt_iso_cig_param *param)
param->p_to_c_latency = 40; /* ms */
err = bt_iso_cig_reconfigure(cig, param);
if (err != 0) {
FAIL("Failed to reconfigure CIG for different latencies (%d)\n", err);
TEST_FAIL("Failed to reconfigure CIG for different latencies (%d)", err);
return err;
}
@ -293,7 +295,7 @@ static void reconfigure_cig(void)
err = bt_iso_cig_reconfigure(cig, &param);
if (err != 0) {
FAIL("Failed to reconfigure CIS to new RTN (%d)\n", err);
TEST_FAIL("Failed to reconfigure CIS to new RTN (%d)", err);
return;
}
@ -316,7 +318,8 @@ static void reconfigure_cig(void)
err = bt_iso_cig_reconfigure(cig, &param);
if (err != 0) {
FAIL("Failed to reconfigure CIG with new CIS and original parameters (%d)\n", err);
TEST_FAIL("Failed to reconfigure CIG with new CIS and original parameters (%d)",
err);
return;
}
@ -328,12 +331,12 @@ static void connect_acl(void)
err = bt_le_scan_start(BT_LE_SCAN_PASSIVE, device_found);
if (err != 0) {
FAIL("Scanning failed to start (err %d)\n", err);
TEST_FAIL("Scanning failed to start (err %d)", err);
return;
}
WAIT_FOR_FLAG_SET(flag_connected);
WAIT_FOR_FLAG(flag_connected);
}
static void connect_cis(void)
@ -346,12 +349,12 @@ static void connect_cis(void)
err = bt_iso_chan_connect(&connect_param, 1);
if (err) {
FAIL("Failed to connect ISO (%d)\n", err);
TEST_FAIL("Failed to connect ISO (%d)", err);
return;
}
WAIT_FOR_FLAG_SET(flag_iso_connected);
WAIT_FOR_FLAG(flag_iso_connected);
}
static void disconnect_cis(void)
@ -360,7 +363,7 @@ static void disconnect_cis(void)
err = bt_iso_chan_disconnect(default_chan);
if (err) {
FAIL("Failed to disconnect ISO (err %d)\n", err);
TEST_FAIL("Failed to disconnect ISO (err %d)", err);
return;
}
@ -374,7 +377,7 @@ static void disconnect_acl(void)
err = bt_conn_disconnect(default_conn, BT_HCI_ERR_REMOTE_USER_TERM_CONN);
if (err) {
FAIL("Failed to disconnect ACL (err %d)\n", err);
TEST_FAIL("Failed to disconnect ACL (err %d)", err);
return;
}
@ -388,7 +391,7 @@ static void terminate_cig(void)
err = bt_iso_cig_terminate(cig);
if (err != 0) {
FAIL("Failed to terminate CIG (%d)\n", err);
TEST_FAIL("Failed to terminate CIG (%d)", err);
return;
}
@ -404,7 +407,7 @@ static void reset_bluetooth(void)
err = bt_disable();
if (err != 0) {
FAIL("Failed to disable (%d)\n", err);
TEST_FAIL("Failed to disable (%d)", err);
return;
}
@ -414,7 +417,7 @@ static void reset_bluetooth(void)
err = bt_enable(NULL);
if (err != 0) {
FAIL("Failed to re-enable (%d)\n", err);
TEST_FAIL("Failed to re-enable (%d)", err);
return;
}
@ -436,7 +439,7 @@ static void test_main(void)
disconnect_acl();
terminate_cig();
PASS("Test passed\n");
TEST_PASS("Test passed");
}
static void test_main_disable(void)
@ -464,22 +467,18 @@ static void test_main_disable(void)
disconnect_acl();
terminate_cig();
PASS("Disable test passed\n");
TEST_PASS("Disable test passed");
}
static const struct bst_test_instance test_def[] = {
{
.test_id = "central",
.test_descr = "Central",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_main,
},
{
.test_id = "central_disable",
.test_descr = "CIS central that tests bt_disable for ISO",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_main_disable,
},
BSTEST_END_MARKER,

20
tests/bsim/bluetooth/host/iso/cis/src/cis_peripheral.c
View file

@ -6,6 +6,8 @@
#include <stdbool.h>
#include "babblekit/testcase.h"
#include "babblekit/flags.h"
#include "common.h"
#include <zephyr/bluetooth/bluetooth.h>
@ -16,7 +18,7 @@
extern enum bst_result_t bst_result;
CREATE_FLAG(flag_data_received);
static DEFINE_FLAG(flag_data_received);
static const struct bt_data ad[] = {
BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)),
@ -85,7 +87,7 @@ static int iso_accept(const struct bt_iso_accept_info *info, struct bt_iso_chan
printk("Incoming request from %p\n", (void *)info->acl);
if (iso_chan.iso) {
FAIL("No channels available\n");
TEST_FAIL("No channels available");
return -ENOMEM;
}
@ -120,7 +122,7 @@ static void init(void)
err = bt_enable(NULL);
if (err) {
FAIL("Bluetooth enable failed (err %d)\n", err);
TEST_FAIL("Bluetooth enable failed (err %d)", err);
return;
}
@ -133,7 +135,7 @@ static void init(void)
err = bt_iso_server_register(&iso_server);
if (err) {
FAIL("Unable to register ISO server (err %d)\n", err);
TEST_FAIL("Unable to register ISO server (err %d)", err);
return;
}
@ -145,14 +147,14 @@ static void adv_connect(void)
err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_1, ad, ARRAY_SIZE(ad), NULL, 0);
if (err) {
FAIL("Advertising failed to start (err %d)\n", err);
TEST_FAIL("Advertising failed to start (err %d)", err);
return;
}
printk("Advertising successfully started\n");
WAIT_FOR_FLAG_SET(flag_connected);
WAIT_FOR_FLAG(flag_connected);
}
static void test_main(void)
@ -163,8 +165,8 @@ static void test_main(void)
adv_connect();
bt_testlib_conn_wait_free();
if (TEST_FLAG(flag_data_received)) {
PASS("Test passed\n");
if (IS_FLAG_SET(flag_data_received)) {
TEST_PASS("Test passed");
}
}
}
@ -173,8 +175,6 @@ static const struct bst_test_instance test_def[] = {
{
.test_id = "peripheral",
.test_descr = "Peripheral",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_main,
},
BSTEST_END_MARKER,

17
tests/bsim/bluetooth/host/iso/cis/src/common.c
View file

@ -10,6 +10,8 @@
#include <zephyr/sys/printk.h>
#include <zephyr/sys/util.h>
#include "babblekit/testcase.h"
#include "babblekit/flags.h"
#include "common.h"
extern enum bst_result_t bst_result;
@ -31,7 +33,7 @@ static void connected(struct bt_conn *conn, uint8_t err)
bt_conn_unref(default_conn);
default_conn = NULL;
FAIL("Failed to connect to %s (0x%02x)\n", addr, err);
TEST_FAIL("Failed to connect to %s (0x%02x)", addr, err);
return;
}
@ -72,16 +74,3 @@ BT_CONN_CB_DEFINE(conn_callbacks) = {
.disconnected = disconnected,
.le_param_updated = conn_param_updated_cb,
};
void test_init(void)
{
bst_result = In_progress;
bst_ticker_set_next_tick_absolute(WAIT_TIME);
}
void test_tick(bs_time_t HW_device_time)
{
if (bst_result != Passed) {
FAIL("Test failed (not passed after %i us)\n", WAIT_TIME);
}
}

34
tests/bsim/bluetooth/host/iso/cis/src/common.h
View file

@ -10,40 +10,6 @@
#include <zephyr/sys/atomic.h>
#include "bs_types.h"
#include "bs_tracing.h"
#include "bstests.h"
#define CREATE_FLAG(flag) static atomic_t flag = (atomic_t) false
#define SET_FLAG(flag) (void)atomic_set(&flag, (atomic_t) true)
#define UNSET_FLAG(flag) (void)atomic_set(&flag, (atomic_t) false)
#define TEST_FLAG(flag) (atomic_get(&flag) == (atomic_t) true)
#define WAIT_FOR_FLAG_SET(flag) \
while (!(bool)atomic_get(&flag)) { \
(void)k_sleep(K_MSEC(1)); \
}
#define WAIT_FOR_FLAG_UNSET(flag) \
while ((bool)atomic_get(&flag)) { \
(void)k_sleep(K_MSEC(1)); \
}
#define WAIT_TIME (30e6) /* 30 seconds*/
#define FAIL(...) \
do { \
bst_result = Failed; \
bs_trace_error_time_line(__VA_ARGS__); \
} while (0)
#define PASS(...) \
do { \
bst_result = Passed; \
bs_trace_info_time(1, __VA_ARGS__); \
} while (0)
extern struct bt_conn *default_conn;
extern atomic_t flag_connected;
extern atomic_t flag_conn_updated;
void test_init(void);
void test_tick(bs_time_t HW_device_time);

3
tests/bsim/bluetooth/host/l2cap/credits/CMakeLists.txt
View file

@ -5,6 +5,9 @@ cmake_minimum_required(VERSION 3.20.0)
find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
project(bsim_test_l2cap_credits)
add_subdirectory(${ZEPHYR_BASE}/tests/bsim/babblekit babblekit)
target_link_libraries(app PRIVATE babblekit)
FILE(GLOB app_sources src/*.c)
target_sources(app PRIVATE ${app_sources} )

22
tests/bsim/bluetooth/host/l2cap/credits/src/common.c
View file

@ -1,22 +0,0 @@
/*
* Copyright (c) 2022 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "common.h"
extern enum bst_result_t bst_result;
void test_init(void)
{
bst_ticker_set_next_tick_absolute(WAIT_TIME);
bst_result = In_progress;
}
void test_tick(bs_time_t HW_device_time)
{
if (bst_result != Passed) {
FAIL("test failed (not passed after %i seconds)\n", WAIT_SECONDS);
}
}

57
tests/bsim/bluetooth/host/l2cap/credits/src/common.h
View file

@ -1,57 +0,0 @@
/*
* Common functions and helpers for L2CAP tests
*
* Copyright (c) 2022 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <stddef.h>
#include <zephyr/types.h>
#include <zephyr/sys/util.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/l2cap.h>
#include "bs_types.h"
#include "bs_tracing.h"
#include "bstests.h"
#include "bs_pc_backchannel.h"
extern enum bst_result_t bst_result;
#define CREATE_FLAG(flag) static atomic_t flag = (atomic_t)false
#define SET_FLAG(flag) (void)atomic_set(&flag, (atomic_t)true)
#define UNSET_FLAG(flag) (void)atomic_set(&flag, (atomic_t)false)
#define TEST_FLAG(flag) (atomic_get(&flag) == (atomic_t)true)
#define WAIT_FOR_FLAG_SET(flag) \
while (!(bool)atomic_get(&flag)) { \
(void)k_sleep(K_MSEC(1)); \
}
#define WAIT_FOR_FLAG_UNSET(flag) \
while ((bool)atomic_get(&flag)) { \
(void)k_sleep(K_MSEC(1)); \
}
#define WAIT_SECONDS 30 /* seconds */
#define WAIT_TIME (WAIT_SECONDS * USEC_PER_SEC) /* microseconds*/
#define FAIL(...) \
do { \
bst_result = Failed; \
bs_trace_error_time_line(__VA_ARGS__); \
} while (0)
#define PASS(...) \
do { \
bst_result = Passed; \
bs_trace_info_time(1, __VA_ARGS__); \
} while (0)
#define ASSERT(expr, ...) if (!(expr)) {FAIL(__VA_ARGS__); }
void test_init(void);
void test_tick(bs_time_t HW_device_time);

64
tests/bsim/bluetooth/host/l2cap/credits/src/main.c
View file

@ -6,15 +6,25 @@
* SPDX-License-Identifier: Apache-2.0
*/
#include "bstests.h"
#include "common.h"
#include <stddef.h>
#include <zephyr/types.h>
#include <zephyr/sys/util.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/l2cap.h>
#include "babblekit/testcase.h"
#include "babblekit/flags.h"
#define LOG_MODULE_NAME main
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(LOG_MODULE_NAME, LOG_LEVEL_DBG);
CREATE_FLAG(is_connected);
CREATE_FLAG(flag_l2cap_connected);
static DEFINE_FLAG(is_connected);
static DEFINE_FLAG(flag_l2cap_connected);
#define L2CAP_MPS CONFIG_BT_L2CAP_TX_MTU
#define SDU_NUM 3
@ -44,7 +54,7 @@ int l2cap_chan_send(struct bt_l2cap_chan *chan, uint8_t *data, size_t len)
struct net_buf *buf = net_buf_alloc(&sdu_pool, K_NO_WAIT);
if (buf == NULL) {
FAIL("No more memory\n");
TEST_FAIL("No more memory");
return -ENOMEM;
}
@ -53,7 +63,7 @@ int l2cap_chan_send(struct bt_l2cap_chan *chan, uint8_t *data, size_t len)
int ret = bt_l2cap_chan_send(chan, buf);
ASSERT(ret >= 0, "Failed sending: err %d", ret);
TEST_ASSERT(ret >= 0, "Failed sending: err %d", ret);
LOG_DBG("sent %d len %d", ret, len);
return ret;
@ -94,7 +104,7 @@ int recv_cb(struct bt_l2cap_chan *chan, struct net_buf *buf)
rx_cnt++;
/* Verify SDU data matches TX'd data. */
ASSERT(memcmp(buf->data, tx_data, buf->len) == 0, "RX data doesn't match TX");
TEST_ASSERT(memcmp(buf->data, tx_data, buf->len) == 0, "RX data doesn't match TX");
/* Keep a ref for a few seconds: this will make the allocation fail, as
* there is only 1 buffer in the pool.
@ -160,7 +170,7 @@ static int l2cap_server_register(bt_security_t sec_level)
int err = bt_l2cap_server_register(&test_l2cap_server);
ASSERT(err == 0, "Failed to register l2cap server.");
TEST_ASSERT(err == 0, "Failed to register l2cap server.");
return test_l2cap_server.psm;
}
@ -172,7 +182,7 @@ static void connected(struct bt_conn *conn, uint8_t conn_err)
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
if (conn_err) {
FAIL("Failed to connect to %s (%u)", addr, conn_err);
TEST_FAIL("Failed to connect to %s (%u)", addr, conn_err);
return;
}
@ -204,7 +214,7 @@ static void disconnect_device(struct bt_conn *conn, void *data)
SET_FLAG(is_connected);
err = bt_conn_disconnect(conn, BT_HCI_ERR_REMOTE_USER_TERM_CONN);
ASSERT(!err, "Failed to initate disconnect (err %d)", err);
TEST_ASSERT(!err, "Failed to initate disconnect (err %d)", err);
LOG_DBG("Waiting for disconnection...");
WAIT_FOR_FLAG_UNSET(is_connected);
@ -222,7 +232,7 @@ static void test_peripheral_main(void)
err = bt_enable(NULL);
if (err) {
FAIL("Can't enable Bluetooth (err %d)", err);
TEST_FAIL("Can't enable Bluetooth (err %d)", err);
return;
}
@ -230,13 +240,13 @@ static void test_peripheral_main(void)
LOG_DBG("Connectable advertising...");
err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_1, NULL, 0, NULL, 0);
if (err) {
FAIL("Advertising failed to start (err %d)", err);
TEST_FAIL("Advertising failed to start (err %d)", err);
return;
}
LOG_DBG("Advertising started.");
LOG_DBG("Peripheral waiting for connection...");
WAIT_FOR_FLAG_SET(is_connected);
WAIT_FOR_FLAG(is_connected);
LOG_DBG("Peripheral Connected.");
int psm = l2cap_server_register(BT_SECURITY_L1);
@ -261,9 +271,9 @@ static void test_peripheral_main(void)
bt_conn_foreach(BT_CONN_TYPE_LE, disconnect_device, NULL);
LOG_INF("Total received: %d", rx_cnt);
ASSERT(rx_cnt == SDU_NUM, "Did not receive expected no of SDUs\n");
TEST_ASSERT(rx_cnt == SDU_NUM, "Did not receive expected no of SDUs\n");
PASS("L2CAP CREDITS Peripheral passed\n");
TEST_PASS("L2CAP CREDITS Peripheral passed");
}
static void device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type,
@ -275,7 +285,7 @@ static void device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type,
err = bt_le_scan_stop();
if (err) {
FAIL("Stop LE scan failed (err %d)", err);
TEST_FAIL("Stop LE scan failed (err %d)", err);
return;
}
@ -288,7 +298,7 @@ static void device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type,
param = BT_LE_CONN_PARAM_DEFAULT;
err = bt_conn_le_create(addr, BT_CONN_LE_CREATE_CONN, param, &conn);
if (err) {
FAIL("Create conn failed (err %d)", err);
TEST_FAIL("Create conn failed (err %d)", err);
return;
}
}
@ -306,10 +316,10 @@ static void connect_peripheral(void)
int err = bt_le_scan_start(&scan_param, device_found);
ASSERT(!err, "Scanning failed to start (err %d)\n", err);
TEST_ASSERT(!err, "Scanning failed to start (err %d)\n", err);
LOG_DBG("Central initiating connection...");
WAIT_FOR_FLAG_SET(is_connected);
WAIT_FOR_FLAG(is_connected);
}
static void connect_l2cap_channel(struct bt_conn *conn, void *data)
@ -323,9 +333,9 @@ static void connect_l2cap_channel(struct bt_conn *conn, void *data)
UNSET_FLAG(flag_l2cap_connected);
err = bt_l2cap_chan_connect(conn, &le_chan->chan, 0x0080);
ASSERT(!err, "Error connecting l2cap channel (err %d)\n", err);
TEST_ASSERT(!err, "Error connecting l2cap channel (err %d)\n", err);
WAIT_FOR_FLAG_SET(flag_l2cap_connected);
WAIT_FOR_FLAG(flag_l2cap_connected);
}
static void connect_l2cap_ecred_channel(struct bt_conn *conn, void *data)
@ -340,9 +350,9 @@ static void connect_l2cap_ecred_channel(struct bt_conn *conn, void *data)
UNSET_FLAG(flag_l2cap_connected);
err = bt_l2cap_ecred_chan_connect(conn, chan_list, 0x0080);
ASSERT(!err, "Error connecting l2cap channel (err %d)\n", err);
TEST_ASSERT(!err, "Error connecting l2cap channel (err %d)\n", err);
WAIT_FOR_FLAG_SET(flag_l2cap_connected);
WAIT_FOR_FLAG(flag_l2cap_connected);
}
static void test_central_main(void)
@ -356,7 +366,7 @@ static void test_central_main(void)
}
err = bt_enable(NULL);
ASSERT(err == 0, "Can't enable Bluetooth (err %d)\n", err);
TEST_ASSERT(err == 0, "Can't enable Bluetooth (err %d)\n", err);
LOG_DBG("Central Bluetooth initialized.");
connect_peripheral();
@ -380,22 +390,18 @@ static void test_central_main(void)
WAIT_FOR_FLAG_UNSET(is_connected);
LOG_DBG("Peripheral disconnected.");
PASS("L2CAP CREDITS Central passed\n");
TEST_PASS("L2CAP CREDITS Central passed");
}
static const struct bst_test_instance test_def[] = {
{
.test_id = "peripheral",
.test_descr = "Peripheral L2CAP CREDITS",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_peripheral_main
},
{
.test_id = "central",
.test_descr = "Central L2CAP CREDITS",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_central_main
},
BSTEST_END_MARKER

4
tests/bsim/bluetooth/host/l2cap/credits_seg_recv/CMakeLists.txt
View file

@ -5,8 +5,10 @@ cmake_minimum_required(VERSION 3.20.0)
find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
project(bsim_test_l2cap_credits_seg_recv)
add_subdirectory(${ZEPHYR_BASE}/tests/bsim/babblekit babblekit)
target_link_libraries(app PRIVATE babblekit)
target_sources(app PRIVATE
src/common.c
src/main.c
)

22
tests/bsim/bluetooth/host/l2cap/credits_seg_recv/src/common.c
View file

@ -1,22 +0,0 @@
/*
* Copyright (c) 2023 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "common.h"
extern enum bst_result_t bst_result;
void test_init(void)
{
bst_ticker_set_next_tick_absolute(WAIT_TIME);
bst_result = In_progress;
}
void test_tick(bs_time_t HW_device_time)
{
if (bst_result != Passed) {
FAIL("test failed (not passed after %i seconds)\n", WAIT_SECONDS);
}
}

57
tests/bsim/bluetooth/host/l2cap/credits_seg_recv/src/common.h
View file

@ -1,57 +0,0 @@
/*
* Common functions and helpers for L2CAP tests
*
* Copyright (c) 2023 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <stddef.h>
#include <zephyr/types.h>
#include <zephyr/sys/util.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/l2cap.h>
#include "bs_types.h"
#include "bs_tracing.h"
#include "bstests.h"
#include "bs_pc_backchannel.h"
extern enum bst_result_t bst_result;
#define CREATE_FLAG(flag) static atomic_t flag = (atomic_t)false
#define SET_FLAG(flag) (void)atomic_set(&flag, (atomic_t)true)
#define UNSET_FLAG(flag) (void)atomic_set(&flag, (atomic_t)false)
#define TEST_FLAG(flag) (atomic_get(&flag) == (atomic_t)true)
#define WAIT_FOR_FLAG_SET(flag) \
while (!(bool)atomic_get(&flag)) { \
(void)k_sleep(K_MSEC(1)); \
}
#define WAIT_FOR_FLAG_UNSET(flag) \
while ((bool)atomic_get(&flag)) { \
(void)k_sleep(K_MSEC(1)); \
}
#define WAIT_SECONDS 30 /* seconds */
#define WAIT_TIME (WAIT_SECONDS * USEC_PER_SEC) /* microseconds*/
#define FAIL(...) \
do { \
bst_result = Failed; \
bs_trace_error_time_line(__VA_ARGS__); \
} while (0)
#define PASS(...) \
do { \
bst_result = Passed; \
bs_trace_info_time(1, __VA_ARGS__); \
} while (0)
#define ASSERT(expr, ...) if (!(expr)) {FAIL(__VA_ARGS__); }
void test_init(void);
void test_tick(bs_time_t HW_device_time);

67
tests/bsim/bluetooth/host/l2cap/credits_seg_recv/src/main.c
View file

@ -4,15 +4,25 @@
* SPDX-License-Identifier: Apache-2.0
*/
#include "bstests.h"
#include "common.h"
#include <stddef.h>
#include <zephyr/types.h>
#include <zephyr/sys/util.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/l2cap.h>
#include "babblekit/testcase.h"
#include "babblekit/flags.h"
#define LOG_MODULE_NAME main
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(LOG_MODULE_NAME, LOG_LEVEL_DBG);
CREATE_FLAG(is_connected);
CREATE_FLAG(flag_l2cap_connected);
static DEFINE_FLAG(is_connected);
static DEFINE_FLAG(flag_l2cap_connected);
#define L2CAP_MPS CONFIG_BT_L2CAP_TX_MTU
#define SDU_NUM 3
@ -44,7 +54,7 @@ int l2cap_chan_send(struct bt_l2cap_chan *chan, uint8_t *data, size_t len)
buf = net_buf_alloc(&sdu_pool, K_NO_WAIT);
if (buf == NULL) {
FAIL("No more memory\n");
TEST_FAIL("No more memory");
return -ENOMEM;
}
@ -53,7 +63,7 @@ int l2cap_chan_send(struct bt_l2cap_chan *chan, uint8_t *data, size_t len)
ret = bt_l2cap_chan_send(chan, buf);
ASSERT(ret >= 0, "Failed sending: err %d", ret);
TEST_ASSERT(ret >= 0, "Failed sending: err %d", ret);
LOG_DBG("sent %d len %d", ret, len);
return ret;
@ -88,10 +98,11 @@ void recv_cb(struct bt_l2cap_chan *l2cap_chan, size_t sdu_len, off_t seg_offset,
{
LOG_DBG("sdu len %u frag offset %u frag len %u", sdu_len, seg_offset, seg->len);
ASSERT(sdu_len == sizeof(tx_data), "Recv SDU length does not match send length.");
TEST_ASSERT(sdu_len == sizeof(tx_data), "Recv SDU length does not match send length.");
/* Verify SDU data matches TX'd data. */
ASSERT(memcmp(seg->data, &tx_data[seg_offset], seg->len) == 0, "RX data doesn't match TX");
TEST_ASSERT(memcmp(seg->data, &tx_data[seg_offset], seg->len) == 0,
"RX data doesn't match TX");
if (seg_offset + seg->len == sdu_len) {
/* Don't give credits right away. The taker of this
@ -171,7 +182,7 @@ static int l2cap_server_register(bt_security_t sec_level)
err = bt_l2cap_server_register(&test_l2cap_server);
ASSERT(err == 0, "Failed to register l2cap server.");
TEST_ASSERT(err == 0, "Failed to register l2cap server.");
return test_l2cap_server.psm;
}
@ -183,7 +194,7 @@ static void connected(struct bt_conn *conn, uint8_t conn_err)
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
if (conn_err) {
FAIL("Failed to connect to %s (%u)", addr, conn_err);
TEST_FAIL("Failed to connect to %s (%u)", addr, conn_err);
return;
}
@ -215,7 +226,7 @@ static void disconnect_device(struct bt_conn *conn, void *data)
SET_FLAG(is_connected);
err = bt_conn_disconnect(conn, BT_HCI_ERR_REMOTE_USER_TERM_CONN);
ASSERT(!err, "Failed to initate disconnect (err %d)", err);
TEST_ASSERT(!err, "Failed to initate disconnect (err %d)", err);
LOG_DBG("Waiting for disconnection...");
WAIT_FOR_FLAG_UNSET(is_connected);
@ -235,7 +246,7 @@ static void test_peripheral_main(void)
err = bt_enable(NULL);
if (err) {
FAIL("Can't enable Bluetooth (err %d)", err);
TEST_FAIL("Can't enable Bluetooth (err %d)", err);
return;
}
@ -243,13 +254,13 @@ static void test_peripheral_main(void)
LOG_DBG("Connectable advertising...");
err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_1, NULL, 0, NULL, 0);
if (err) {
FAIL("Advertising failed to start (err %d)", err);
TEST_FAIL("Advertising failed to start (err %d)", err);
return;
}
LOG_DBG("Advertising started.");
LOG_DBG("Peripheral waiting for connection...");
WAIT_FOR_FLAG_SET(is_connected);
WAIT_FOR_FLAG(is_connected);
LOG_DBG("Peripheral Connected.");
psm = l2cap_server_register(BT_SECURITY_L1);
@ -274,9 +285,9 @@ static void test_peripheral_main(void)
bt_conn_foreach(BT_CONN_TYPE_LE, disconnect_device, NULL);
LOG_INF("Total received: %d", rx_cnt);
ASSERT(rx_cnt == SDU_NUM, "Did not receive expected no of SDUs\n");
TEST_ASSERT(rx_cnt == SDU_NUM, "Did not receive expected no of SDUs");
PASS("L2CAP CREDITS Peripheral passed\n");
TEST_PASS("L2CAP CREDITS Peripheral passed");
}
static void device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type,
@ -289,7 +300,7 @@ static void device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type,
err = bt_le_scan_stop();
if (err) {
FAIL("Stop LE scan failed (err %d)", err);
TEST_FAIL("Stop LE scan failed (err %d)", err);
return;
}
@ -300,7 +311,7 @@ static void device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type,
param = BT_LE_CONN_PARAM_DEFAULT;
err = bt_conn_le_create(addr, BT_CONN_LE_CREATE_CONN, param, &conn);
if (err) {
FAIL("Create conn failed (err %d)", err);
TEST_FAIL("Create conn failed (err %d)", err);
return;
}
}
@ -319,10 +330,10 @@ static void connect_peripheral(void)
err = bt_le_scan_start(&scan_param, device_found);
ASSERT(!err, "Scanning failed to start (err %d)\n", err);
TEST_ASSERT(!err, "Scanning failed to start (err %d)", err);
LOG_DBG("Central initiating connection...");
WAIT_FOR_FLAG_SET(is_connected);
WAIT_FOR_FLAG(is_connected);
}
static void connect_l2cap_channel(struct bt_conn *conn, void *data)
@ -346,9 +357,9 @@ static void connect_l2cap_channel(struct bt_conn *conn, void *data)
bt_l2cap_chan_give_credits(&le_chan->chan, 1);
err = bt_l2cap_chan_connect(conn, &le_chan->chan, 0x0080);
ASSERT(!err, "Error connecting l2cap channel (err %d)\n", err);
TEST_ASSERT(!err, "Error connecting l2cap channel (err %d)", err);
WAIT_FOR_FLAG_SET(flag_l2cap_connected);
WAIT_FOR_FLAG(flag_l2cap_connected);
}
static void connect_l2cap_ecred_channel(struct bt_conn *conn, void *data)
@ -373,9 +384,9 @@ static void connect_l2cap_ecred_channel(struct bt_conn *conn, void *data)
bt_l2cap_chan_give_credits(&le_chan->chan, 1);
err = bt_l2cap_ecred_chan_connect(conn, chan_list, 0x0080);
ASSERT(!err, "Error connecting l2cap channel (err %d)\n", err);
TEST_ASSERT(!err, "Error connecting l2cap channel (err %d)", err);
WAIT_FOR_FLAG_SET(flag_l2cap_connected);
WAIT_FOR_FLAG(flag_l2cap_connected);
}
static void test_central_main(void)
@ -390,7 +401,7 @@ static void test_central_main(void)
}
err = bt_enable(NULL);
ASSERT(err == 0, "Can't enable Bluetooth (err %d)\n", err);
TEST_ASSERT(err == 0, "Can't enable Bluetooth (err %d)", err);
LOG_DBG("Central Bluetooth initialized.");
connect_peripheral();
@ -414,19 +425,15 @@ static void test_central_main(void)
WAIT_FOR_FLAG_UNSET(is_connected);
LOG_DBG("Peripheral disconnected.");
PASS("L2CAP CREDITS Central passed\n");
TEST_PASS("L2CAP CREDITS Central passed");
}
static const struct bst_test_instance test_def[] = {
{.test_id = "peripheral",
.test_descr = "Peripheral L2CAP CREDITS",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_peripheral_main},
{.test_id = "central",
.test_descr = "Central L2CAP CREDITS",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_central_main},
BSTEST_END_MARKER,
};

3
tests/bsim/bluetooth/host/l2cap/general/CMakeLists.txt
View file

@ -5,6 +5,9 @@ cmake_minimum_required(VERSION 3.20.0)
find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
project(bsim_test_l2cap)
add_subdirectory(${ZEPHYR_BASE}/tests/bsim/babblekit babblekit)
target_link_libraries(app PRIVATE babblekit)
FILE(GLOB app_sources src/*.c)
target_sources(app PRIVATE ${app_sources} )

68
tests/bsim/bluetooth/host/l2cap/general/src/common.c
View file

@ -1,68 +0,0 @@
/*
* Copyright (c) 2022 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "common.h"
#define LOG_MODULE_NAME common
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(LOG_MODULE_NAME, LOG_LEVEL_DBG);
extern enum bst_result_t bst_result;
void test_init(void)
{
bst_result = In_progress;
bst_ticker_set_next_tick_absolute(WAIT_TIME);
}
void test_tick(bs_time_t HW_device_time)
{
if (bst_result != Passed) {
FAIL("test failed (not passed after %i us)\n", WAIT_TIME);
}
}
/* Call in init functions*/
void device_sync_init(uint device_nbr)
{
uint peer = CENTRAL_ID;
if (device_nbr == CENTRAL_ID) {
peer = PERIPHERAL_ID;
}
uint dev_nbrs[BACK_CHANNELS] = {peer};
uint channel_nbrs[BACK_CHANNELS] = {0};
uint *ch = bs_open_back_channel(device_nbr, dev_nbrs, channel_nbrs, BACK_CHANNELS);
if (!ch) {
LOG_ERR("bs_open_back_channel failed!");
}
}
/* Call it to make peer to proceed.*/
void device_sync_send(void)
{
uint8_t msg[1] = "S";
bs_bc_send_msg(0, msg, sizeof(msg));
}
/* Wait until peer send sync*/
void device_sync_wait(void)
{
int size_msg_received = 0;
uint8_t msg;
while (!size_msg_received) {
size_msg_received = bs_bc_is_msg_received(0);
k_sleep(K_MSEC(1));
}
bs_bc_receive_msg(0, &msg, size_msg_received);
}

59
tests/bsim/bluetooth/host/l2cap/general/src/common.h
View file

@ -1,59 +0,0 @@
/*
* Common functions and helpers for L2CAP tests
*
* Copyright (c) 2022 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <stddef.h>
#include <zephyr/types.h>
#include <zephyr/sys/util.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/l2cap.h>
#include "bs_types.h"
#include "bs_tracing.h"
#include "bstests.h"
#include "bs_pc_backchannel.h"
#define CREATE_FLAG(flag) static atomic_t flag = (atomic_t)false
#define SET_FLAG(flag) (void)atomic_set(&flag, (atomic_t)true)
#define UNSET_FLAG(flag) (void)atomic_set(&flag, (atomic_t)false)
#define TEST_FLAG(flag) (atomic_get(&flag) == (atomic_t)true)
#define WAIT_FOR_FLAG_SET(flag) \
while (!(bool)atomic_get(&flag)) { \
(void)k_sleep(K_MSEC(1)); \
}
#define WAIT_FOR_FLAG_UNSET(flag) \
while ((bool)atomic_get(&flag)) { \
(void)k_sleep(K_MSEC(1)); \
}
#define WAIT_TIME (60e6) /* 60 seconds*/
#define FAIL(...) \
do { \
bst_result = Failed; \
bs_trace_error_time_line(__VA_ARGS__); \
} while (0)
#define PASS(...) \
do { \
bst_result = Passed; \
bs_trace_info_time(1, __VA_ARGS__); \
} while (0)
#define CENTRAL_ID 0
#define PERIPHERAL_ID 1
#define BACK_CHANNELS 1
void test_init(void);
void test_tick(bs_time_t HW_device_time);
void device_sync_init(uint device_nbr);
void device_sync_send(void);
void device_sync_wait(void);

89
tests/bsim/bluetooth/host/l2cap/general/src/main_l2cap_ecred.c
View file

@ -6,7 +6,19 @@
* SPDX-License-Identifier: Apache-2.0
*/
#include "common.h"
#include <stddef.h>
#include <zephyr/types.h>
#include <zephyr/sys/util.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/l2cap.h>
#include "babblekit/testcase.h"
#include "babblekit/flags.h"
#include "babblekit/sync.h"
#define LOG_MODULE_NAME main_l2cap_ecred
#include <zephyr/logging/log.h>
@ -54,8 +66,8 @@ struct channel {
};
static struct channel channels[L2CAP_CHANNELS];
CREATE_FLAG(is_connected);
CREATE_FLAG(unsequenced_data);
static DEFINE_FLAG(is_connected);
static DEFINE_FLAG(unsequenced_data);
#define T_STACK_SIZE 512
#define T_PRIORITY 5
@ -90,22 +102,23 @@ static int chan_recv_cb(struct bt_l2cap_chan *l2cap_chan, struct net_buf *buf)
LOG_DBG("received_iterration %i sdus_received %i, chan_id: %d, data_length: %d",
received_iterration, chan->sdus_received, chan->chan_id, buf->len);
if (!TEST_FLAG(unsequenced_data) && received_iterration != chan->sdus_received) {
FAIL("Received out of sequence data.");
if (!IS_FLAG_SET(unsequenced_data) && received_iterration != chan->sdus_received) {
TEST_FAIL("Received out of sequence data.");
}
const int retval = memcmp(buf->data + sizeof(received_iterration),
chan->payload + sizeof(received_iterration),
buf->len - sizeof(received_iterration));
if (retval) {
FAIL("Payload received didn't match expected value memcmp returned %i", retval);
TEST_FAIL("Payload received didn't match expected value memcmp returned %i",
retval);
}
/*By the time we rx on long msg channel we should have already rx on short msg channel*/
if (chan->chan_id == 0) {
if (channels[SHORT_MSG_CHAN_IDX].sdus_received !=
(channels[LONG_MSG_CHAN_IDX].sdus_received + 1)) {
FAIL("Didn't receive on short msg channel first");
TEST_FAIL("Didn't receive on short msg channel first");
}
}
@ -232,7 +245,7 @@ static void connect_num_channels(uint8_t num_l2cap_channels)
struct channel *chan = get_free_channel();
if (!chan) {
FAIL("failed, chan not free");
TEST_FAIL("failed, chan not free");
return;
}
@ -243,7 +256,7 @@ static void connect_num_channels(uint8_t num_l2cap_channels)
servers[0].psm);
if (err) {
FAIL("can't connect ecred %d ", err);
TEST_FAIL("can't connect ecred %d ", err);
}
}
@ -297,7 +310,7 @@ static void register_l2cap_server(void)
server = get_free_server();
if (!server) {
FAIL("Failed to get free server");
TEST_FAIL("Failed to get free server");
return;
}
@ -305,7 +318,7 @@ static void register_l2cap_server(void)
server->psm = 0;
if (bt_l2cap_server_register(server) < 0) {
FAIL("Failed to get free server");
TEST_FAIL("Failed to get free server");
return;
}
@ -319,7 +332,7 @@ static void connected(struct bt_conn *conn, uint8_t conn_err)
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
if (conn_err) {
FAIL("Failed to connect to %s (%u)", addr, conn_err);
TEST_FAIL("Failed to connect to %s (%u)", addr, conn_err);
bt_conn_unref(default_conn);
default_conn = NULL;
return;
@ -340,7 +353,7 @@ static void disconnected(struct bt_conn *conn, uint8_t reason)
LOG_DBG("%s (reason 0x%02x)", addr, reason);
if (default_conn != conn) {
FAIL("Conn mismatch disconnect %s %s)", default_conn, conn);
TEST_FAIL("Conn mismatch disconnect %s %s)", default_conn, conn);
return;
}
@ -363,7 +376,7 @@ static void send_sdu(int iteration, int chan_idx, int bytes)
sys_put_le32(iteration, channels[chan_idx].payload);
if (channels[chan_idx].buf != 0) {
FAIL("Buf should have been deallocated by now");
TEST_FAIL("Buf should have been deallocated by now");
return;
}
@ -374,7 +387,7 @@ static void send_sdu(int iteration, int chan_idx, int bytes)
}
if (buf == NULL) {
FAIL("Failed to get buff on ch %i, iteration %i should never happen", chan_idx,
TEST_FAIL("Failed to get buff on ch %i, iteration %i should never happen", chan_idx,
chan_idx);
}
@ -388,7 +401,7 @@ static void send_sdu(int iteration, int chan_idx, int bytes)
LOG_DBG("bt_l2cap_chan_send returned: %i", ret);
if (ret < 0) {
FAIL("Error: send failed error: %i", ret);
TEST_FAIL("Error: send failed error: %i", ret);
channels[chan_idx].buf = 0;
net_buf_unref(buf);
}
@ -412,7 +425,7 @@ static void send_sdu_concurrently(void)
&channels[k].work);
if (err < 0) {
FAIL("Failed to submit work to the queue, error: %d", err);
TEST_FAIL("Failed to submit work to the queue, error: %d", err);
}
}
@ -436,14 +449,14 @@ static int change_mtu_on_channels(int num_channels, int new_mtu)
static void test_peripheral_main(void)
{
device_sync_init(PERIPHERAL_ID);
TEST_ASSERT(bk_sync_init() == 0, "Failed to open backchannel");
LOG_DBG("*L2CAP ECRED Peripheral started*");
init_workqs();
int err;
err = bt_enable(NULL);
if (err) {
FAIL("Can't enable Bluetooth (err %d)", err);
TEST_FAIL("Can't enable Bluetooth (err %d)", err);
return;
}
@ -451,13 +464,13 @@ static void test_peripheral_main(void)
LOG_DBG("Connectable advertising...");
err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_1, ad, ARRAY_SIZE(ad), NULL, 0);
if (err) {
FAIL("Advertising failed to start (err %d)", err);
TEST_FAIL("Advertising failed to start (err %d)", err);
return;
}
LOG_DBG("Advertising started.");
LOG_DBG("Peripheral waiting for connection...");
WAIT_FOR_FLAG_SET(is_connected);
WAIT_FOR_FLAG(is_connected);
LOG_DBG("Peripheral Connected.");
register_l2cap_server();
connect_num_channels(L2CAP_CHANNELS);
@ -472,7 +485,7 @@ static void test_peripheral_main(void)
k_sem_take(&all_chan_conn_sem, K_FOREVER);
LOG_DBG("Send sync after reconnection");
device_sync_send();
bk_sync_send();
/* Send bytes on both channels and expect ch 1 to receive all of them before ch 0 *********/
LOG_DBG("############# Send bytes on both channels concurrently");
@ -483,20 +496,20 @@ static void test_peripheral_main(void)
err = change_mtu_on_channels(L2CAP_CHANNELS, CONFIG_BT_L2CAP_TX_MTU + 10);
if (err) {
FAIL("MTU change failed (err %d)\n", err);
TEST_FAIL("MTU change failed (err %d)", err);
}
/* Read from both devices (Central and Peripheral) at the same time **********************/
LOG_DBG("############# Read from both devices (Central and Peripheral) at the same time");
LOG_DBG("Wait for sync before sending the msg");
device_sync_wait();
bk_sync_wait();
LOG_DBG("Received sync");
send_sdu(0, 1, 10);
k_sem_take(&sent_sem, K_FOREVER);
disconnect_all_channels();
WAIT_FOR_FLAG_UNSET(is_connected);
PASS("L2CAP ECRED Peripheral tests Passed");
TEST_PASS("L2CAP ECRED Peripheral tests Passed");
bs_trace_silent_exit(0);
}
@ -508,14 +521,14 @@ static void device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type,
err = bt_le_scan_stop();
if (err) {
FAIL("Stop LE scan failed (err %d)", err);
TEST_FAIL("Stop LE scan failed (err %d)", err);
return;
}
param = BT_LE_CONN_PARAM_DEFAULT;
err = bt_conn_le_create(addr, BT_CONN_LE_CREATE_CONN, param, &default_conn);
if (err) {
FAIL("Create conn failed (err %d)", err);
TEST_FAIL("Create conn failed (err %d)", err);
return;
}
}
@ -529,40 +542,40 @@ static void test_central_main(void)
.window = BT_GAP_SCAN_FAST_WINDOW,
};
device_sync_init(CENTRAL_ID);
TEST_ASSERT(bk_sync_init() == 0, "Failed to open backchannel");
LOG_DBG("*L2CAP ECRED Central started*");
int err;
err = bt_enable(NULL);
if (err) {
FAIL("Can't enable Bluetooth (err %d)\n", err);
TEST_FAIL("Can't enable Bluetooth (err %d)", err);
return;
}
LOG_DBG("Central Bluetooth initialized.\n");
err = bt_le_scan_start(&scan_param, device_found);
if (err) {
FAIL("Scanning failed to start (err %d)\n", err);
TEST_FAIL("Scanning failed to start (err %d)", err);
return;
}
LOG_DBG("Scanning successfully started\n");
LOG_DBG("Central waiting for connection...\n");
WAIT_FOR_FLAG_SET(is_connected);
WAIT_FOR_FLAG(is_connected);
LOG_DBG("Central Connected.\n");
register_l2cap_server();
LOG_DBG("Wait for sync after reconnection");
device_sync_wait();
bk_sync_wait();
LOG_DBG("Received sync");
/* Read from both devices (Central and Peripheral) at the same time **********************/
LOG_DBG("############# Read from both devices (Central and Peripheral) at the same time");
LOG_DBG("Send sync for SDU send");
SET_FLAG(unsequenced_data);
device_sync_send();
bk_sync_send();
send_sdu(0, 1, 10);
/* Wait until all of the channels are disconnected */
@ -577,7 +590,7 @@ static void test_central_main(void)
if (channels[LONG_MSG_CHAN_IDX].sdus_received < SDU_SEND_COUNT ||
channels[SHORT_MSG_CHAN_IDX].sdus_received < SDU_SEND_COUNT) {
FAIL("received less than %i", SDU_SEND_COUNT);
TEST_FAIL("received less than %i", SDU_SEND_COUNT);
}
/* Disconnect */
@ -587,28 +600,24 @@ static void test_central_main(void)
LOG_DBG("Central tried to disconnect");
if (err) {
FAIL("Disconnection failed (err %d)", err);
TEST_FAIL("Disconnection failed (err %d)", err);
return;
}
LOG_DBG("Central Disconnected.");
PASS("L2CAP ECRED Central tests Passed\n");
TEST_PASS("L2CAP ECRED Central tests Passed");
}
static const struct bst_test_instance test_def[] = {
{
.test_id = "peripheral",
.test_descr = "Peripheral L2CAP ECRED",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_peripheral_main
},
{
.test_id = "central",
.test_descr = "Central L2CAP ECRED",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_central_main
},
BSTEST_END_MARKER

3
tests/bsim/bluetooth/host/l2cap/many_conns/CMakeLists.txt
View file

@ -5,6 +5,9 @@ cmake_minimum_required(VERSION 3.20.0)
find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
project(bsim_test_l2cap_stress)
add_subdirectory(${ZEPHYR_BASE}/tests/bsim/babblekit babblekit)
target_link_libraries(app PRIVATE babblekit)
FILE(GLOB app_sources src/*.c)
target_sources(app PRIVATE ${app_sources} )

22
tests/bsim/bluetooth/host/l2cap/many_conns/src/common.c
View file

@ -1,22 +0,0 @@
/*
* Copyright (c) 2024 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "common.h"
extern enum bst_result_t bst_result;
void test_init(void)
{
bst_ticker_set_next_tick_absolute(WAIT_TIME);
bst_result = In_progress;
}
void test_tick(bs_time_t HW_device_time)
{
if (bst_result != Passed) {
FAIL("test failed (not passed after %i seconds)\n", WAIT_SECONDS);
}
}

57
tests/bsim/bluetooth/host/l2cap/many_conns/src/common.h
View file

@ -1,57 +0,0 @@
/*
* Common functions and helpers for L2CAP tests
*
* Copyright (c) 2024 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <stddef.h>
#include <zephyr/types.h>
#include <zephyr/sys/util.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/l2cap.h>
#include "bs_types.h"
#include "bs_tracing.h"
#include "bstests.h"
#include "bs_pc_backchannel.h"
extern enum bst_result_t bst_result;
#define CREATE_FLAG(flag) static atomic_t flag = (atomic_t)false
#define SET_FLAG(flag) (void)atomic_set(&flag, (atomic_t)true)
#define UNSET_FLAG(flag) (void)atomic_set(&flag, (atomic_t)false)
#define TEST_FLAG(flag) (atomic_get(&flag) == (atomic_t)true)
#define WAIT_FOR_FLAG_SET(flag) \
while (!(bool)atomic_get(&flag)) { \
(void)k_sleep(K_MSEC(1)); \
}
#define WAIT_FOR_FLAG_UNSET(flag) \
while ((bool)atomic_get(&flag)) { \
(void)k_sleep(K_MSEC(1)); \
}
#define WAIT_SECONDS 400 /* seconds */
#define WAIT_TIME (WAIT_SECONDS * USEC_PER_SEC) /* microseconds*/
#define FAIL(...) \
do { \
bst_result = Failed; \
bs_trace_error_time_line(__VA_ARGS__); \
} while (0)
#define PASS(...) \
do { \
bst_result = Passed; \
bs_trace_info_time(1, __VA_ARGS__); \
} while (0)
#define ASSERT(expr, ...) if (!(expr)) {FAIL(__VA_ARGS__); }
void test_init(void);
void test_tick(bs_time_t HW_device_time);

67
tests/bsim/bluetooth/host/l2cap/many_conns/src/main.c
View file

@ -6,15 +6,25 @@
* SPDX-License-Identifier: Apache-2.0
*/
#include "bstests.h"
#include "common.h"
#include <stddef.h>
#include <zephyr/types.h>
#include <zephyr/sys/util.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/l2cap.h>
#include "babblekit/testcase.h"
#include "babblekit/flags.h"
#define LOG_MODULE_NAME main
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(LOG_MODULE_NAME, LOG_LEVEL_INF);
CREATE_FLAG(is_connected);
CREATE_FLAG(flag_l2cap_connected);
static DEFINE_FLAG(is_connected);
static DEFINE_FLAG(flag_l2cap_connected);
#define NUM_PERIPHERALS CONFIG_BT_MAX_CONN
#define L2CAP_CHANS NUM_PERIPHERALS
@ -47,7 +57,7 @@ struct test_ctx *get_ctx(struct bt_l2cap_chan *chan)
struct bt_l2cap_le_chan *le_chan = CONTAINER_OF(chan, struct bt_l2cap_le_chan, chan);
struct test_ctx *ctx = CONTAINER_OF(le_chan, struct test_ctx, le_chan);
ASSERT(ctx >= &contexts[0] &&
TEST_ASSERT(ctx >= &contexts[0] &&
ctx <= &contexts[L2CAP_CHANS], "memory corruption");
return ctx;
@ -59,14 +69,14 @@ int l2cap_chan_send(struct bt_l2cap_chan *chan, uint8_t *data, size_t len)
struct net_buf *buf = net_buf_alloc(&sdu_tx_pool, K_NO_WAIT);
ASSERT(buf, "No more memory\n");
TEST_ASSERT(buf, "No more memory");
net_buf_reserve(buf, BT_L2CAP_SDU_CHAN_SEND_RESERVE);
net_buf_add_mem(buf, data, len);
int ret = bt_l2cap_chan_send(chan, buf);
ASSERT(ret >= 0, "Failed sending: err %d", ret);
TEST_ASSERT(ret >= 0, "Failed sending: err %d", ret);
LOG_DBG("sent %d len %d", ret, len);
return ret;
@ -187,7 +197,7 @@ static int l2cap_server_register(bt_security_t sec_level)
int err = bt_l2cap_server_register(&test_l2cap_server);
ASSERT(err == 0, "Failed to register l2cap server.");
TEST_ASSERT(err == 0, "Failed to register l2cap server.");
return test_l2cap_server.psm;
}
@ -198,7 +208,7 @@ static void connected(struct bt_conn *conn, uint8_t conn_err)
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
ASSERT(!conn_err, "Failed to connect to %s (%u)", addr, conn_err);
TEST_ASSERT(!conn_err, "Failed to connect to %s (%u)", addr, conn_err);
LOG_DBG("%s", addr);
@ -229,7 +239,7 @@ static void disconnect_device(struct bt_conn *conn, void *data)
SET_FLAG(is_connected);
err = bt_conn_disconnect(conn, BT_HCI_ERR_REMOTE_USER_TERM_CONN);
ASSERT(!err, "Failed to initate disconnect (err %d)", err);
TEST_ASSERT(!err, "Failed to initate disconnect (err %d)", err);
LOG_DBG("Waiting for disconnection...");
WAIT_FOR_FLAG_UNSET(is_connected);
@ -246,16 +256,16 @@ static void test_peripheral_main(void)
}
err = bt_enable(NULL);
ASSERT(!err, "Can't enable Bluetooth (err %d)", err);
TEST_ASSERT(!err, "Can't enable Bluetooth (err %d)", err);
LOG_DBG("Peripheral Bluetooth initialized.");
LOG_DBG("Connectable advertising...");
err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_1, NULL, 0, NULL, 0);
ASSERT(!err, "Advertising failed to start (err %d)", err);
TEST_ASSERT(!err, "Advertising failed to start (err %d)", err);
LOG_DBG("Advertising started.");
LOG_DBG("Peripheral waiting for connection...");
WAIT_FOR_FLAG_SET(is_connected);
WAIT_FOR_FLAG(is_connected);
LOG_DBG("Peripheral Connected.");
int psm = l2cap_server_register(BT_SECURITY_L1);
@ -271,9 +281,9 @@ static void test_peripheral_main(void)
WAIT_FOR_FLAG_UNSET(is_connected);
LOG_INF("Total received: %d", rx_cnt);
ASSERT(rx_cnt == SDU_NUM, "Did not receive expected no of SDUs\n");
TEST_ASSERT(rx_cnt == SDU_NUM, "Did not receive expected no of SDUs");
PASS("L2CAP LATENCY Peripheral passed\n");
TEST_PASS("L2CAP LATENCY Peripheral passed");
}
static void device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type,
@ -284,7 +294,7 @@ static void device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type,
int err;
err = bt_le_scan_stop();
ASSERT(!err, "Stop LE scan failed (err %d)", err);
TEST_ASSERT(!err, "Stop LE scan failed (err %d)", err);
char str[BT_ADDR_LE_STR_LEN];
@ -294,7 +304,7 @@ static void device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type,
param = BT_LE_CONN_PARAM_DEFAULT;
err = bt_conn_le_create(addr, BT_CONN_LE_CREATE_CONN, param, &conn);
ASSERT(!err, "Create conn failed (err %d)", err);
TEST_ASSERT(!err, "Create conn failed (err %d)", err);
}
static void connect_peripheral(void)
@ -310,10 +320,10 @@ static void connect_peripheral(void)
int err = bt_le_scan_start(&scan_param, device_found);
ASSERT(!err, "Scanning failed to start (err %d)\n", err);
TEST_ASSERT(!err, "Scanning failed to start (err %d)", err);
LOG_DBG("Central initiating connection...");
WAIT_FOR_FLAG_SET(is_connected);
WAIT_FOR_FLAG(is_connected);
}
static void connect_l2cap_channel(struct bt_conn *conn, void *data)
@ -321,7 +331,7 @@ static void connect_l2cap_channel(struct bt_conn *conn, void *data)
int err;
struct test_ctx *ctx = alloc_test_context();
ASSERT(ctx, "No more available test contexts\n");
TEST_ASSERT(ctx, "No more available test contexts");
struct bt_l2cap_le_chan *le_chan = &ctx->le_chan;
@ -330,9 +340,9 @@ static void connect_l2cap_channel(struct bt_conn *conn, void *data)
UNSET_FLAG(flag_l2cap_connected);
err = bt_l2cap_chan_connect(conn, &le_chan->chan, 0x0080);
ASSERT(!err, "Error connecting l2cap channel (err %d)\n", err);
TEST_ASSERT(!err, "Error connecting l2cap channel (err %d)", err);
WAIT_FOR_FLAG_SET(flag_l2cap_connected);
WAIT_FOR_FLAG(flag_l2cap_connected);
}
#define L2CAP_LE_CID_DYN_START 0x0040
@ -363,8 +373,7 @@ void bt_test_l2cap_data_pull_spy(struct bt_conn *conn,
return;
}
ASSERT(uptime == last_pull_time,
"Too much delay servicing ready channels\n");
TEST_ASSERT(uptime == last_pull_time, "Too much delay servicing ready channels");
}
static void test_central_main(void)
@ -378,7 +387,7 @@ static void test_central_main(void)
}
err = bt_enable(NULL);
ASSERT(err == 0, "Can't enable Bluetooth (err %d)\n", err);
TEST_ASSERT(err == 0, "Can't enable Bluetooth (err %d)", err);
LOG_DBG("Central Bluetooth initialized.");
/* Connect all peripherals */
@ -407,7 +416,7 @@ static void test_central_main(void)
LOG_DBG("Wait until all transfers are completed.");
int remaining_tx_total;
/* Assertion that the `pull` callback gets serviced for all connections
/* TEST_Assertion that the `pull` callback gets serviced for all connections
* at the same time is handled in bt_l2cap_data_pull_spy().
*/
@ -426,22 +435,18 @@ static void test_central_main(void)
}
LOG_DBG("All peripherals disconnected.");
PASS("L2CAP LATENCY Central passed\n");
TEST_PASS("L2CAP LATENCY Central passed");
}
static const struct bst_test_instance test_def[] = {
{
.test_id = "peripheral",
.test_descr = "Peripheral L2CAP LATENCY",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_peripheral_main
},
{
.test_id = "central",
.test_descr = "Central L2CAP LATENCY",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_central_main
},
BSTEST_END_MARKER

4
tests/bsim/bluetooth/host/l2cap/send_on_connect/CMakeLists.txt
View file

@ -5,8 +5,10 @@ cmake_minimum_required(VERSION 3.20.0)
find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
project(bsim_test_l2cap_send_on_connect)
add_subdirectory(${ZEPHYR_BASE}/tests/bsim/babblekit babblekit)
target_link_libraries(app PRIVATE babblekit)
target_sources(app PRIVATE
src/common.c
src/main_l2cap_send_on_connect.c
src/main.c
)

22
tests/bsim/bluetooth/host/l2cap/send_on_connect/src/common.c
View file

@ -1,22 +0,0 @@
/*
* Copyright (c) 2022 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "common.h"
extern enum bst_result_t bst_result;
void test_init(void)
{
bst_result = In_progress;
bst_ticker_set_next_tick_absolute(WAIT_TIME);
}
void test_tick(bs_time_t HW_device_time)
{
if (bst_result != Passed) {
FAIL("test failed (not passed after %i us)\n", WAIT_TIME);
}
}

44
tests/bsim/bluetooth/host/l2cap/send_on_connect/src/common.h
View file

@ -1,44 +0,0 @@
/*
* Common functions and helpers for L2CAP tests
*
* Copyright (c) 2022 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <stddef.h>
#include "bs_types.h"
#include "bs_tracing.h"
#include "bstests.h"
#define CREATE_FLAG(flag) static atomic_t flag = (atomic_t)false
#define SET_FLAG(flag) (void)atomic_set(&flag, (atomic_t)true)
#define UNSET_FLAG(flag) (void)atomic_set(&flag, (atomic_t)false)
#define WAIT_FOR_FLAG_SET(flag) \
while (!(bool)atomic_get(&flag)) { \
(void)k_sleep(K_MSEC(1)); \
}
#define WAIT_FOR_FLAG_UNSET(flag) \
while ((bool)atomic_get(&flag)) { \
(void)k_sleep(K_MSEC(1)); \
}
#define WAIT_TIME (30e6) /* 30 seconds*/
#define FAIL(...) \
do { \
bst_result = Failed; \
bs_trace_error_time_line(__VA_ARGS__); \
} while (0)
#define PASS(...) \
do { \
bst_result = Passed; \
bs_trace_info_time(1, __VA_ARGS__); \
} while (0)
void test_init(void);
void test_tick(bs_time_t HW_device_time);

62
tests/bsim/bluetooth/host/l2cap/send_on_connect/src/main_l2cap_send_on_connect.c
View file

@ -4,20 +4,22 @@
* SPDX-License-Identifier: Apache-2.0
*/
#include "common.h"
#include <stddef.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/l2cap.h>
#include "babblekit/testcase.h"
#include "babblekit/flags.h"
extern enum bst_result_t bst_result;
static struct bt_conn *default_conn;
#define PSM 0x80
CREATE_FLAG(is_connected);
CREATE_FLAG(chan_connected);
CREATE_FLAG(data_received);
static DEFINE_FLAG(is_connected);
static DEFINE_FLAG(chan_connected);
static DEFINE_FLAG(data_received);
#define DATA_BYTE_VAL 0xBB
@ -32,7 +34,7 @@ static void chan_connected_cb(struct bt_l2cap_chan *l2cap_chan)
/* Send data immediately on L2CAP connection */
buf = net_buf_alloc(&buf_pool, K_NO_WAIT);
if (!buf) {
FAIL("Buffer allocation failed\n");
TEST_FAIL("Buffer allocation failed");
}
(void)net_buf_reserve(buf, BT_L2CAP_SDU_CHAN_SEND_RESERVE);
@ -41,7 +43,7 @@ static void chan_connected_cb(struct bt_l2cap_chan *l2cap_chan)
/* Try to send data */
err = bt_l2cap_chan_send(l2cap_chan, buf);
if (err < 0) {
FAIL("Could not send data, error %d\n", err);
TEST_FAIL("Could not send data, error %d", err);
}
SET_FLAG(chan_connected);
@ -59,7 +61,7 @@ static int chan_recv_cb(struct bt_l2cap_chan *chan, struct net_buf *buf)
(void)chan;
if ((buf->len != 1) || (buf->data[0] != DATA_BYTE_VAL)) {
FAIL("Unexpected data received");
TEST_FAIL("Unexpected data received");
}
SET_FLAG(data_received);
@ -100,12 +102,12 @@ static void connect_l2cap_channel(void)
if (IS_ENABLED(CONFIG_BT_L2CAP_ECRED)) {
err = bt_l2cap_ecred_chan_connect(default_conn, chans, server.psm);
if (err) {
FAIL("Failed to send ecred connection request (err %d)\n", err);
TEST_FAIL("Failed to send ecred connection request (err %d)", err);
}
} else {
err = bt_l2cap_chan_connect(default_conn, &channel.chan, server.psm);
if (err) {
FAIL("Failed to send connection request (err %d)\n", err);
TEST_FAIL("Failed to send connection request (err %d)", err);
}
}
}
@ -116,7 +118,7 @@ static void register_l2cap_server(void)
err = bt_l2cap_server_register(&server);
if (err < 0) {
FAIL("Failed to get free server (err %d)\n");
TEST_FAIL("Failed to get free server (err %d)", err);
return;
}
}
@ -124,7 +126,7 @@ static void register_l2cap_server(void)
static void connected(struct bt_conn *conn, uint8_t err)
{
if (err) {
FAIL("Failed to connect (err %d)\n", err);
TEST_FAIL("Failed to connect (err %d)", err);
bt_conn_unref(default_conn);
default_conn = NULL;
return;
@ -138,7 +140,7 @@ static void connected(struct bt_conn *conn, uint8_t err)
static void disconnected(struct bt_conn *conn, uint8_t reason)
{
if (default_conn != conn) {
FAIL("Connection mismatch %p %p)\n", default_conn, conn);
TEST_FAIL("Connection mismatch %p %p)", default_conn, conn);
return;
}
@ -160,14 +162,14 @@ static void device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type,
err = bt_le_scan_stop();
if (err) {
FAIL("Failed to stop scanning (err %d)\n", err);
TEST_FAIL("Failed to stop scanning (err %d)", err);
return;
}
param = BT_LE_CONN_PARAM_DEFAULT;
err = bt_conn_le_create(addr, BT_CONN_LE_CREATE_CONN, param, &default_conn);
if (err) {
FAIL("Failed to create connection (err %d)\n", err);
TEST_FAIL("Failed to create connection (err %d)", err);
return;
}
}
@ -181,7 +183,7 @@ static void test_peripheral_main(void)
err = bt_enable(NULL);
if (err != 0) {
FAIL("Bluetooth init failed (err %d)\n", err);
TEST_FAIL("Bluetooth init failed (err %d)", err);
return;
}
@ -189,19 +191,19 @@ static void test_peripheral_main(void)
err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_1, ad, ARRAY_SIZE(ad), NULL, 0);
if (err != 0) {
FAIL("Advertising failed to start (err %d)\n", err);
TEST_FAIL("Advertising failed to start (err %d)", err);
return;
}
WAIT_FOR_FLAG_SET(is_connected);
WAIT_FOR_FLAG(is_connected);
WAIT_FOR_FLAG_SET(chan_connected);
WAIT_FOR_FLAG(chan_connected);
WAIT_FOR_FLAG_SET(data_received);
WAIT_FOR_FLAG(data_received);
WAIT_FOR_FLAG_UNSET(is_connected);
PASS("Test passed\n");
TEST_PASS("Test passed");
}
static void test_central_main(void)
@ -210,45 +212,41 @@ static void test_central_main(void)
err = bt_enable(NULL);
if (err != 0) {
FAIL("Bluetooth init failed (err %d)\n", err);
TEST_FAIL("Bluetooth init failed (err %d)", err);
}
err = bt_le_scan_start(BT_LE_SCAN_PASSIVE, device_found);
if (err != 0) {
FAIL("Scanning failed to start (err %d)\n", err);
TEST_FAIL("Scanning failed to start (err %d)", err);
}
WAIT_FOR_FLAG_SET(is_connected);
WAIT_FOR_FLAG(is_connected);
connect_l2cap_channel();
WAIT_FOR_FLAG_SET(chan_connected);
WAIT_FOR_FLAG(chan_connected);
WAIT_FOR_FLAG_SET(data_received);
WAIT_FOR_FLAG(data_received);
err = bt_conn_disconnect(default_conn, BT_HCI_ERR_REMOTE_USER_TERM_CONN);
if (err) {
FAIL("Failed to disconnect (err %d)\n", err);
TEST_FAIL("Failed to disconnect (err %d)", err);
return;
}
WAIT_FOR_FLAG_UNSET(is_connected);
PASS("Test passed\n");
TEST_PASS("Test passed");
}
static const struct bst_test_instance test_def[] = {
{
.test_id = "peripheral",
.test_descr = "Peripheral",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_peripheral_main,
},
{
.test_id = "central",
.test_descr = "Central",
.test_pre_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_central_main,
},
BSTEST_END_MARKER,

3
tests/bsim/bluetooth/host/l2cap/stress/CMakeLists.txt
View file

@ -5,6 +5,9 @@ cmake_minimum_required(VERSION 3.20.0)
find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
project(bsim_test_l2cap_stress)
add_subdirectory(${ZEPHYR_BASE}/tests/bsim/babblekit babblekit)
target_link_libraries(app PRIVATE babblekit)
FILE(GLOB app_sources src/*.c)
target_sources(app PRIVATE ${app_sources} )

22
tests/bsim/bluetooth/host/l2cap/stress/src/common.c
View file

@ -1,22 +0,0 @@
/*
* Copyright (c) 2022 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "common.h"
extern enum bst_result_t bst_result;
void test_init(void)
{
bst_ticker_set_next_tick_absolute(WAIT_TIME);
bst_result = In_progress;
}
void test_tick(bs_time_t HW_device_time)
{
if (bst_result != Passed) {
FAIL("test failed (not passed after %i seconds)\n", WAIT_SECONDS);
}
}

Some files were not shown because too many files have changed in this diff Show more