OrgZephyr/zephyr
OrgZephyr
/
zephyr
mirror of https://github.com/zephyrproject-rtos/zephyr.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Revert "tests: Bluetooth: Mesh: Add tests to cover message publication" 

This reverts commit 9b99ab6896.

Signed-off-by: Henrik Brix Andersen <hebad@vestas.com>
This commit is contained in:
Henrik Brix Andersen 2021-12-20 22:27:39 +01:00 committed by Alberto Escolar
parent 38ce8d615d
commit b3c1eea269
5 changed files with 4 additions and 446 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
tests/bluetooth/bsim_bt/bsim_test_mesh/prj.conf
View File

@ -1,10 +1,10 @@
CONFIG_BT=y
CONFIG_BT_DEBUG_LOG=y
CONFIG_LOG_MODE_IMMEDIATE=y
CONFIG_ASSERT=y
CONFIG_SYS_CLOCK_TICKS_PER_SEC=1000
# Bluetooth configuration
CONFIG_BT=y
CONFIG_BT_DEBUG_LOG=y
CONFIG_BT_PRIVACY=n
CONFIG_BT_COMPANY_ID=0x0059
CONFIG_BT_DEVICE_NAME="Mesh test"

422
tests/bluetooth/bsim_bt/bsim_test_mesh/src/test_access.c
View File

@ -24,11 +24,6 @@ LOG_MODULE_REGISTER(LOG_MODULE_NAME, LOG_LEVEL_INF);
#define TEST_MESSAGE_OP_1 BT_MESH_MODEL_OP_1(0x11)
#define TEST_MESSAGE_OP_2 BT_MESH_MODEL_OP_1(0x12)
#define TEST_MESSAGE_OP_3 BT_MESH_MODEL_OP_1(0x13)
#define TEST_MESSAGE_OP_4 BT_MESH_MODEL_OP_1(0x14)
#define PUB_PERIOD_COUNT 3
#define RX_JITTER_MAX (10 + CONFIG_BT_MESH_NETWORK_TRANSMIT_COUNT * \
(CONFIG_BT_MESH_NETWORK_TRANSMIT_INTERVAL + 10))
static int model1_init(struct bt_mesh_model *model);
static int model2_init(struct bt_mesh_model *model);
@ -44,82 +39,6 @@ static uint8_t app_key[16] = { 0xaa };
static uint8_t net_key[16] = { 0xcc };
static struct bt_mesh_prov prov;
/* Test vector for periodic publication tests. */
static const struct {
uint8_t period;
uint8_t div;
int32_t period_ms;
} test_period[] = {
{ BT_MESH_PUB_PERIOD_100MS(5), 0, 500 },
{ BT_MESH_PUB_PERIOD_SEC(2), 0, 2000 },
{ BT_MESH_PUB_PERIOD_10SEC(1), 0, 10000 },
{ BT_MESH_PUB_PERIOD_SEC(3), 1, 1500 },
{ BT_MESH_PUB_PERIOD_10SEC(3), 3, 3750 },
};
/* Test vector for publication retransmissions tests. */
static const uint8_t test_transmit[] = {
BT_MESH_PUB_TRANSMIT(4, 50),
BT_MESH_PUB_TRANSMIT(3, 100),
BT_MESH_PUB_TRANSMIT(2, 200),
};
/* Test vector for canceling a message publication. */
static const struct {
uint8_t period;
uint8_t transmit;
uint8_t msgs;
int32_t sleep;
int32_t duration;
} test_cancel[] = {
/* Test cancelling periodic publication. */
{
BT_MESH_PUB_PERIOD_SEC(2), 0, 2,
2000 /* period */ + 100 /* margin */,
3 /* messages */ * 2000 /* period */
},
/* Test cancelling publication retransmission. */
{
BT_MESH_PUB_PERIOD_SEC(3), BT_MESH_PUB_TRANSMIT(3, 200), 3,
200 /* retransmission interval */ + 50 /* margin */,
3000 /* one period */
},
};
static struct k_sem publish_sem;
static bool publish_allow;
static int model1_update(struct bt_mesh_model *model)
{
model->pub->msg->data[1]++;
LOG_DBG("New pub: n: %d t: %d", model->pub->msg->data[1], k_uptime_get_32());
return publish_allow ? k_sem_give(&publish_sem), 0 : -1;
}
static int test_msg4_handler(struct bt_mesh_model *model,
struct bt_mesh_msg_ctx *ctx,
struct net_buf_simple *buf)
{
static uint8_t prev_num;
uint8_t num = net_buf_simple_pull_u8(buf);
LOG_DBG("Recv msg: n: %d t: %u", num, k_uptime_get_32());
/* Ensure that payload changes. */
ASSERT_TRUE(prev_num != num);
prev_num = num;
k_sem_give(&publish_sem);
return 0;
}
static struct bt_mesh_model_pub model_pub1 = {
.msg = NET_BUF_SIMPLE(BT_MESH_TX_SDU_MAX),
.update = model1_update,
};
static const struct bt_mesh_model_cb test_model1_cb = {
.init = model1_init,
};
@ -134,7 +53,6 @@ static const struct bt_mesh_model_cb test_model3_cb = {
static const struct bt_mesh_model_op model_op1[] = {
{ TEST_MESSAGE_OP_1, 0, test_msg_handler },
{ TEST_MESSAGE_OP_4, 0, test_msg4_handler },
BT_MESH_MODEL_OP_END
};
@ -153,7 +71,7 @@ static struct bt_mesh_cfg_cli cfg_cli;
static struct bt_mesh_model models[] = {
BT_MESH_MODEL_CFG_SRV,
BT_MESH_MODEL_CFG_CLI(&cfg_cli),
BT_MESH_MODEL_CB(TEST_MODEL_ID_1, model_op1, &model_pub1, NULL, &test_model1_cb),
BT_MESH_MODEL_CB(TEST_MODEL_ID_1, model_op1, NULL, NULL, &test_model1_cb),
BT_MESH_MODEL_CB(TEST_MODEL_ID_2, model_op2, NULL, NULL, &test_model2_cb),
BT_MESH_MODEL_CB(TEST_MODEL_ID_3, model_op3, NULL, NULL, &test_model3_cb),
};
@ -327,336 +245,6 @@ static void test_sub_ext_model(void)
PASS();
}
static void pub_param_set(uint8_t period, uint8_t transmit)
{
struct bt_mesh_cfg_mod_pub pub_params = {
.addr = UNICAST_ADDR2,
.uuid = NULL,
.cred_flag = false,
.app_idx = 0,
.ttl = 5,
.period = period,
.transmit = transmit,
};
uint8_t status;
int err;
err = bt_mesh_cfg_mod_pub_set(0, UNICAST_ADDR1, UNICAST_ADDR1, TEST_MODEL_ID_1,
&pub_params, &status);
if (err || status) {
FAIL("Mod pub set failed (err %d, status %u)", err, status);
}
}
static void msg4_publish(void)
{
struct bt_mesh_model *model = &models[2];
bt_mesh_model_msg_init(model->pub->msg, TEST_MESSAGE_OP_4);
net_buf_simple_add_u8(model->pub->msg, 1);
bt_mesh_model_publish(model);
}
static void pub_jitter_check(int32_t interval, uint8_t count)
{
int64_t timestamp = k_uptime_get();
int32_t jitter = 0;
int err;
for (size_t j = 0; j < count; j++) {
/* Every new publication will release semaphore in the update handler and the time
* between two consecutive publications will be measured.
*/
err = k_sem_take(&publish_sem, K_SECONDS(20));
if (err) {
FAIL("Send timed out");
}
int32_t time_delta = k_uptime_delta(&timestamp);
int32_t pub_delta = llabs(time_delta - interval);
jitter = MAX(pub_delta, jitter);
LOG_DBG("Send time: %d delta: %d jitter: %d", (int32_t)timestamp, time_delta,
jitter);
}
LOG_INF("Send jitter: %d", jitter);
ASSERT_TRUE(jitter <= 10);
}
static void recv_jitter_check(int32_t interval, uint8_t count)
{
int64_t timestamp;
uint32_t jitter = 0;
int err;
/* The measurment starts by the first received message. */
err = k_sem_take(&publish_sem, K_SECONDS(20));
if (err) {
FAIL("Recv timed out");
}
timestamp = k_uptime_get();
for (size_t j = 0; j < count; j++) {
/* Every new received message will release semaphore in the message handler and
* the time between two consecutive publications will be measured.
*/
err = k_sem_take(&publish_sem, K_SECONDS(20));
if (err) {
FAIL("Recv timed out");
}
int32_t time_delta = k_uptime_delta(&timestamp);
int32_t pub_delta = llabs(time_delta - interval);
jitter = MAX(pub_delta, jitter);
LOG_DBG("Recv time: %d delta: %d jitter: %d", (int32_t)timestamp, time_delta,
jitter);
}
LOG_INF("Recv jitter: %d", jitter);
ASSERT_TRUE(jitter <= RX_JITTER_MAX);
}
/* Test publish period states by publishing a message and checking interval between update handler
* calls.
*/
static void test_tx_period(void)
{
struct bt_mesh_model *model = &models[2];
bt_mesh_test_cfg_set(NULL, 60);
bt_mesh_device_setup(&prov, &local_comp);
provision(UNICAST_ADDR1);
common_configure(UNICAST_ADDR1);
k_sem_init(&publish_sem, 0, 1);
for (size_t i = 0; i < ARRAY_SIZE(test_period); i++) {
pub_param_set(test_period[i].period, 0);
model->pub->fast_period = test_period[i].div > 0;
model->pub->period_div = test_period[i].div;
LOG_INF("Publication period: %d", test_period[i].period_ms);
/* Start publishing messages and measure jitter. */
msg4_publish();
publish_allow = true;
pub_jitter_check(test_period[i].period_ms, PUB_PERIOD_COUNT);
/* Disable periodic publication before the next test iteration. */
publish_allow = false;
/* Let the receiver hit the first semaphore. */
k_sleep(K_SECONDS(1));
}
PASS();
}
/* Receive a periodically published message and check publication period by measuring interval
* between message handler calls.
*/
static void test_rx_period(void)
{
bt_mesh_test_cfg_set(NULL, 60);
bt_mesh_device_setup(&prov, &local_comp);
provision(UNICAST_ADDR2);
common_configure(UNICAST_ADDR2);
k_sem_init(&publish_sem, 0, 1);
for (size_t i = 0; i < ARRAY_SIZE(test_period); i++) {
recv_jitter_check(test_period[i].period_ms, PUB_PERIOD_COUNT);
}
PASS();
}
/* Test publish retransmit interval and count states by publishing a message and checking interval
* between update handler calls.
*/
static void test_tx_transmit(void)
{
struct bt_mesh_model *model = &models[2];
uint8_t status;
int err;
bt_mesh_test_cfg_set(NULL, 60);
bt_mesh_device_setup(&prov, &local_comp);
provision(UNICAST_ADDR1);
common_configure(UNICAST_ADDR1);
k_sem_init(&publish_sem, 0, 1);
/* Network retransmissions has to be disabled so that the legacy advertiser sleeps for the
* least possible time, which is 50ms. This will let the access layer publish a message
* with 50ms retransmission interval.
*/
err = bt_mesh_cfg_net_transmit_set(0, UNICAST_ADDR1,
BT_MESH_TRANSMIT(0, CONFIG_BT_MESH_NETWORK_TRANSMIT_INTERVAL),
&status);
if (err || status != BT_MESH_TRANSMIT(0, CONFIG_BT_MESH_NETWORK_TRANSMIT_INTERVAL)) {
FAIL("Net transmit set failed (err %d, status %u)", err,
status);
}
publish_allow = true;
model->pub->retr_update = true;
for (size_t i = 0; i < ARRAY_SIZE(test_transmit); i++) {
pub_param_set(0, test_transmit[i]);
int32_t interval = BT_MESH_PUB_TRANSMIT_INT(test_transmit[i]);
int count = BT_MESH_PUB_TRANSMIT_COUNT(test_transmit[i]);
LOG_INF("Retransmission interval: %d, count: %d", interval, count);
/* Start publishing messages and measure jitter. */
msg4_publish();
pub_jitter_check(interval, count);
/* Let the receiver hit the first semaphore. */
k_sleep(K_SECONDS(1));
}
PASS();
}
/* Receive a published message and check retransmission interval by measuring interval between
* message handler calls.
*/
static void test_rx_transmit(void)
{
bt_mesh_test_cfg_set(NULL, 60);
bt_mesh_device_setup(&prov, &local_comp);
provision(UNICAST_ADDR2);
common_configure(UNICAST_ADDR2);
k_sem_init(&publish_sem, 0, 1);
for (size_t i = 0; i < ARRAY_SIZE(test_transmit); i++) {
int32_t interval = BT_MESH_PUB_TRANSMIT_INT(test_transmit[i]);
int count = BT_MESH_PUB_TRANSMIT_COUNT(test_transmit[i]);
recv_jitter_check(interval, count);
}
PASS();
}
/* Cancel one of messages to be published and check that the next one is published when next period
* starts.
*/
static void test_tx_cancel(void)
{
struct bt_mesh_model *model = &models[2];
int err;
bt_mesh_test_cfg_set(NULL, 20);
bt_mesh_device_setup(&prov, &local_comp);
provision(UNICAST_ADDR1);
common_configure(UNICAST_ADDR1);
k_sem_init(&publish_sem, 0, 1);
model->pub->retr_update = true;
for (size_t i = 0; i < ARRAY_SIZE(test_cancel); i++) {
pub_param_set(test_cancel[i].period, test_cancel[i].transmit);
msg4_publish();
publish_allow = true;
int64_t timestamp = k_uptime_get();
/* Send few messages except one that is to be cancelled. */
for (size_t j = 0; j < test_cancel[i].msgs - 1; j++) {
err = k_sem_take(&publish_sem, K_SECONDS(20));
if (err) {
FAIL("Send timed out");
}
}
/* Cancel the next publication. */
publish_allow = false;
k_sleep(K_MSEC(test_cancel[i].sleep));
/* Reenable publication a wait for a next message to be published. */
publish_allow = true;
err = k_sem_take(&publish_sem, K_SECONDS(20));
if (err) {
FAIL("Send timed out");
}
/* Disable periodic publication before the next test iteration. */
publish_allow = false;
/* If the canceled message is also sent, the semaphore will be released earlier than
* expected.
*/
int32_t time_delta = k_uptime_delta(&timestamp);
int32_t jitter = llabs(time_delta - test_cancel[i].duration);
LOG_DBG("Send time: %d delta: %d", (int32_t)timestamp, time_delta);
LOG_INF("Send jitter: %d", jitter);
ASSERT_TRUE(jitter <= 10);
/* Let the receiver hit the first semaphore. */
k_sleep(K_SECONDS(1));
}
PASS();
}
/* Receive all published messages and ensure that cancelled message is not received. */
static void test_rx_cancel(void)
{
bt_mesh_test_cfg_set(NULL, 20);
bt_mesh_device_setup(&prov, &local_comp);
provision(UNICAST_ADDR2);
common_configure(UNICAST_ADDR2);
k_sem_init(&publish_sem, 0, 1);
for (size_t i = 0; i < ARRAY_SIZE(test_cancel); i++) {
int64_t timestamp;
int err;
/* Wait for the first published message. */
err = k_sem_take(&publish_sem, K_SECONDS(20));
if (err) {
FAIL("Recv timed out");
}
timestamp = k_uptime_get();
/* Wait for the rest messages to be published (incl. the next after cancelled one).
*/
for (size_t j = 0; j < test_cancel[i].msgs; j++) {
err = k_sem_take(&publish_sem, K_SECONDS(20));
if (err) {
FAIL("Recv timed out");
}
}
/* If the canceled message is received, the semaphore will be released earlier than
* expected.
*/
int32_t time_delta = k_uptime_delta(&timestamp);
int32_t jitter = llabs(time_delta - test_cancel[i].duration);
LOG_DBG("Recv time: %d delta: %d", (int32_t)timestamp, time_delta);
LOG_INF("Recv jitter: %d", jitter);
ASSERT_TRUE(jitter <= RX_JITTER_MAX);
}
PASS();
}
#define TEST_CASE(role, name, description) \
{ \
.test_id = "access_" #role "_" #name, \
@ -667,14 +255,8 @@ static void test_rx_cancel(void)
static const struct bst_test_instance test_access[] = {
TEST_CASE(tx, ext_model, "Access: tx data of extended models"),
TEST_CASE(sub, ext_model, "Access: data subscription of extended models"),
TEST_CASE(tx, period, "Access: Publish a message periodically"),
TEST_CASE(rx, period, "Access: Receive periodically published message"),
TEST_CASE(tx, transmit, "Access: Publish and retransmit message"),
TEST_CASE(rx, transmit, "Access: Receive retransmitted messages"),
TEST_CASE(tx, cancel, "Access: Cancel a message during publication"),
TEST_CASE(rx, cancel, "Access: Receive published messages except cancelled"),
TEST_CASE(sub, ext_model, "Access: data subscription of extended models"),
BSTEST_END_MARKER
};

8
tests/bluetooth/bsim_bt/bsim_test_mesh/tests_scripts/access/access_cancel.sh
View File

@ -1,8 +0,0 @@
#!/usr/bin/env bash
# Copyright 2021 Nordic Semiconductor
# SPDX-License-Identifier: Apache-2.0
source $(dirname "${BASH_SOURCE[0]}")/../../_mesh_test.sh
RunTest mesh_access_publication_cancel \
access_tx_cancel access_rx_cancel

8
tests/bluetooth/bsim_bt/bsim_test_mesh/tests_scripts/access/access_period.sh
View File

@ -1,8 +0,0 @@
#!/usr/bin/env bash
# Copyright 2021 Nordic Semiconductor
# SPDX-License-Identifier: Apache-2.0
source $(dirname "${BASH_SOURCE[0]}")/../../_mesh_test.sh
RunTest mesh_access_periodic_publication \
access_tx_period access_rx_period

8
tests/bluetooth/bsim_bt/bsim_test_mesh/tests_scripts/access/access_transmit.sh
View File

@ -1,8 +0,0 @@
#!/usr/bin/env bash
# Copyright 2021 Nordic Semiconductor
# SPDX-License-Identifier: Apache-2.0
source $(dirname "${BASH_SOURCE[0]}")/../../_mesh_test.sh
RunTest mesh_access_publication_retransmission \
access_tx_transmit access_rx_transmit