tests/bluetooth/bsim_bt/bsim_test_mesh/src/test_provision.c - third_party/github/zephyrproject-rtos/zephyr - Git at Google

 /*
  * Copyright (c) 2021 Lingao Meng
  *
  * SPDX-License-Identifier: Apache-2.0
  */
 #include "mesh_test.h"
 #include "mesh/net.h"
 #include "argparse.h"

 #include <sys/byteorder.h>

 #define LOG_MODULE_NAME mesh_prov

 #include <logging/log.h>
 LOG_MODULE_REGISTER(LOG_MODULE_NAME);

 /*
  * Provision layer tests:
  *   Tests both the provisioner and device role in various scenarios.
  */

 #define PROV_MULTI_COUNT 3
 #define PROV_REPROV_COUNT 10

 enum test_flags {
 	IS_PROVISIONER,

 	TEST_FLAGS,
 };

 static ATOMIC_DEFINE(flags, TEST_FLAGS);
 extern const struct bt_mesh_comp comp;
 extern const uint8_t test_net_key[16];
 extern const uint8_t test_app_key[16];

 /* Timeout semaphore */
 static struct k_sem prov_sem;
 static uint16_t prov_addr = 0x0002;
 static uint16_t current_dev_addr;
 static const uint8_t dev_key[16] = { 0x01, 0x02, 0x03, 0x04, 0x05 };
 static uint8_t dev_uuid[16] = { 0x6c, 0x69, 0x6e, 0x67, 0x61, 0x6f };

 #define WAIT_TIME 60 /*seconds*/

 static void test_device_init(void)
 {
 	/* Ensure that the UUID is unique: */
 	dev_uuid[6] = '0' + get_device_nbr();

 	bt_mesh_test_cfg_set(NULL, WAIT_TIME);
 }

 static void test_provisioner_init(void)
 {
 	atomic_set_bit(flags, IS_PROVISIONER);
 	bt_mesh_test_cfg_set(NULL, WAIT_TIME);
 }

 static void unprovisioned_beacon(uint8_t uuid[16],
 				 bt_mesh_prov_oob_info_t oob_info,
 				 uint32_t *uri_hash)
 {
 	if (!atomic_test_bit(flags, IS_PROVISIONER)) {
 		return;
 	}

 	bt_mesh_provision_adv(uuid, 0, prov_addr, 0);
 }

 static void prov_complete(uint16_t net_idx, uint16_t addr)
 {
 	if (!atomic_test_bit(flags, IS_PROVISIONER)) {
 		k_sem_give(&prov_sem);
 	}
 }

 static void prov_node_added(uint16_t net_idx, uint8_t uuid[16], uint16_t addr,
 			    uint8_t num_elem)
 {
 	LOG_INF("Device 0x%04x provisioned", prov_addr);
 	current_dev_addr = prov_addr++;
 	k_sem_give(&prov_sem);
 }

 static void prov_reset(void)
 {
 	ASSERT_OK(bt_mesh_prov_enable(BT_MESH_PROV_ADV));
 }

 static struct bt_mesh_prov prov = {
 	.uuid = dev_uuid,
 	.unprovisioned_beacon = unprovisioned_beacon,
 	.complete = prov_complete,
 	.node_added = prov_node_added,
 	.reset = prov_reset,
 };

 /** @brief Verify that this device pb-adv provision.
  */
 static void test_device_pb_adv_no_oob(void)
 {
 	k_sem_init(&prov_sem, 0, 1);

 	bt_mesh_device_setup(&prov, &comp);

 	ASSERT_OK(bt_mesh_prov_enable(BT_MESH_PROV_ADV));

 	LOG_INF("Mesh initialized\n");

 	/* Keep a long timeout so the prov multi case has time to finish: */
 	ASSERT_OK(k_sem_take(&prov_sem, K_SECONDS(40)));

 	PASS();
 }

 /** @brief Verify that this device can be reprovisioned after resets
  */
 static void test_device_pb_adv_reprovision(void)
 {
 	k_sem_init(&prov_sem, 0, 1);

 	bt_mesh_device_setup(&prov, &comp);

 	ASSERT_OK(bt_mesh_prov_enable(BT_MESH_PROV_ADV));

 	LOG_INF("Mesh initialized\n");

 	for (int i = 0; i < PROV_REPROV_COUNT; i++) {
 		/* Keep a long timeout so the prov multi case has time to finish: */
 		LOG_INF("Dev prov loop #%d, waiting for prov ...\n", i);
 		ASSERT_OK(k_sem_take(&prov_sem, K_SECONDS(5)));
 	}

 	PASS();
 }

 /** @brief Verify that this provisioner pb-adv provision.
  */
 static void test_provisioner_pb_adv_no_oob(void)
 {
 	k_sem_init(&prov_sem, 0, 1);

 	bt_mesh_device_setup(&prov, &comp);

 	ASSERT_OK(bt_mesh_cdb_create(test_net_key));

 	ASSERT_OK(bt_mesh_provision(test_net_key, 0, 0, 0, 0x0001, dev_key));

 	ASSERT_OK(k_sem_take(&prov_sem, K_SECONDS(5)));

 	PASS();
 }

 /** @brief Verify that the provisioner can provision multiple devices in a row
  */
 static void test_provisioner_pb_adv_multi(void)
 {
 	k_sem_init(&prov_sem, 0, 1);

 	bt_mesh_device_setup(&prov, &comp);

 	ASSERT_OK(bt_mesh_cdb_create(test_net_key));

 	ASSERT_OK(bt_mesh_provision(test_net_key, 0, 0, 0, 0x0001, dev_key));

 	for (int i = 0; i < PROV_MULTI_COUNT; i++) {
 		ASSERT_OK(k_sem_take(&prov_sem, K_SECONDS(20)));
 	}

 	PASS();
 }

 /** @brief Verify that when the IV Update flag is set to zero at the
  * time of provisioning, internal IV update counter is also zero.
  */
 static void test_provisioner_iv_update_flag_zero(void)
 {
 	uint8_t flags = 0x00;

 	bt_mesh_device_setup(&prov, &comp);

 	ASSERT_OK(bt_mesh_provision(test_net_key, 0, flags, 0, 0x0001, dev_key));

 	if (bt_mesh.ivu_duration != 0) {
 		FAIL("IV Update duration counter is not 0 when IV Update flag is zero");
 	}

 	PASS();
 }

 /** @brief Verify that when the IV Update flag is set to one at the
  * time of provisioning, internal IV update counter is set to 96 hours.
  */
 static void test_provisioner_iv_update_flag_one(void)
 {
 	uint8_t flags = 0x02; /* IV Update flag bit set to 1 */

 	bt_mesh_device_setup(&prov, &comp);

 	ASSERT_OK(bt_mesh_provision(test_net_key, 0, flags, 0, 0x0001, dev_key));

 	if (bt_mesh.ivu_duration != 96) {
 		FAIL("IV Update duration counter is not 96 when IV Update flag is one");
 	}

 	bt_mesh_reset();

 	if (bt_mesh.ivu_duration != 0) {
 		FAIL("IV Update duration counter is not reset to 0");
 	}

 	PASS();
 }

 /** @brief Verify that the provisioner can provision a device multiple times after resets
  */
 static void test_provisioner_pb_adv_reprovision(void)
 {
 	k_sem_init(&prov_sem, 0, 1);

 	bt_mesh_device_setup(&prov, &comp);

 	ASSERT_OK(bt_mesh_cdb_create(test_net_key));

 	ASSERT_OK(bt_mesh_provision(test_net_key, 0, 0, 0, 0x0001, dev_key));

 	for (int i = 0; i < PROV_REPROV_COUNT; i++) {
 		LOG_INF("Provisioner prov loop #%d, waiting for prov ...\n", i);
 		ASSERT_OK(k_sem_take(&prov_sem, K_SECONDS(20)));

 		uint8_t status;
 		size_t subs_count = 1;
 		uint16_t sub;
 		struct bt_mesh_cfg_mod_pub healthpub = { 0 };
 		struct bt_mesh_cdb_node *node;

 		/* Check that publication and subscription are reset after last iteration */
 		ASSERT_OK(bt_mesh_cfg_mod_sub_get(0, current_dev_addr, current_dev_addr,
 						  BT_MESH_MODEL_ID_HEALTH_SRV, &status, &sub,
 						  &subs_count));
 		ASSERT_EQUAL(0, status);
 		ASSERT_TRUE(subs_count == 0);

 		ASSERT_OK(bt_mesh_cfg_mod_pub_get(0, current_dev_addr, current_dev_addr,
 						  BT_MESH_MODEL_ID_HEALTH_SRV, &healthpub,
 						  &status));
 		ASSERT_EQUAL(0, status);
 		ASSERT_TRUE(healthpub.addr == BT_MESH_ADDR_UNASSIGNED, "Pub not cleared");


 		/* Set pub and sub to check that they are reset */
 		healthpub.addr = 0xc001;
 		healthpub.app_idx = 0;
 		healthpub.cred_flag = false;
 		healthpub.ttl = 10;
 		healthpub.period = BT_MESH_PUB_PERIOD_10SEC(1);
 		healthpub.transmit = BT_MESH_TRANSMIT(3, 100);

 		ASSERT_OK(bt_mesh_cfg_app_key_add(0, current_dev_addr, 0, 0, test_app_key,
 						  &status));
 		ASSERT_EQUAL(0, status);

 		ASSERT_OK(bt_mesh_cfg_mod_app_bind(0, current_dev_addr, current_dev_addr, 0x0,
 						   BT_MESH_MODEL_ID_HEALTH_SRV, &status));
 		ASSERT_EQUAL(0, status);

 		ASSERT_OK(bt_mesh_cfg_mod_sub_add(0, current_dev_addr, current_dev_addr, 0xc000,
 						  BT_MESH_MODEL_ID_HEALTH_SRV, &status));
 		ASSERT_EQUAL(0, status);

 		ASSERT_OK(bt_mesh_cfg_mod_pub_set(0, current_dev_addr, current_dev_addr,
 						  BT_MESH_MODEL_ID_HEALTH_SRV, &healthpub,
 						  &status));
 		ASSERT_EQUAL(0, status);

 		ASSERT_OK(bt_mesh_cfg_node_reset(0, current_dev_addr, (bool *)&status));

 		node = bt_mesh_cdb_node_get(current_dev_addr);
 		bt_mesh_cdb_node_del(node, true);
 	}

 	PASS();
 }

 #define TEST_CASE(role, name, description)                                     \
 	{                                                                      \
 		.test_id = "prov_" #role "_" #name, .test_descr = description, \
 		.test_post_init_f = test_##role##_init,                        \
 		.test_tick_f = bt_mesh_test_timeout,                           \
 		.test_main_f = test_##role##_##name,                           \
 	}

 static const struct bst_test_instance test_connect[] = {
 	TEST_CASE(device, pb_adv_no_oob,
 		  "Device: pb-adv provisioning use no-oob method"),
 	TEST_CASE(device, pb_adv_reprovision,
 		  "Device: pb-adv provisioning, reprovision"),
 	TEST_CASE(provisioner, pb_adv_no_oob,
 		  "Provisioner: pb-adv provisioning use no-oob method"),
 	TEST_CASE(provisioner, pb_adv_multi,
 		  "Provisioner: pb-adv provisioning multiple devices"),
 	TEST_CASE(provisioner, iv_update_flag_zero,
 		  "Provisioner: effect on ivu_duration when IV Update flag is set to zero"),
 	TEST_CASE(provisioner, iv_update_flag_one,
 		  "Provisioner: effect on ivu_duration when IV Update flag is set to one"),
 	TEST_CASE(provisioner, pb_adv_reprovision,
 		  "Provisioner: pb-adv provisioning, resetting and reprovisioning multiple times."),

 	BSTEST_END_MARKER
 };

 struct bst_test_list *test_provision_install(struct bst_test_list *tests)
 {
 	tests = bst_add_tests(tests, test_connect);
 	return tests;
 }
	/*
	* Copyright (c) 2021 Lingao Meng
	*
	* SPDX-License-Identifier: Apache-2.0
	*/
	#include "mesh_test.h"
	#include "mesh/net.h"
	#include "argparse.h"

	#include <sys/byteorder.h>

	#define LOG_MODULE_NAME mesh_prov

	#include <logging/log.h>
	LOG_MODULE_REGISTER(LOG_MODULE_NAME);

	/*
	* Provision layer tests:
	* Tests both the provisioner and device role in various scenarios.
	*/

	#define PROV_MULTI_COUNT 3
	#define PROV_REPROV_COUNT 10

	enum test_flags {
	IS_PROVISIONER,

	TEST_FLAGS,
	};

	static ATOMIC_DEFINE(flags, TEST_FLAGS);
	extern const struct bt_mesh_comp comp;
	extern const uint8_t test_net_key[16];
	extern const uint8_t test_app_key[16];

	/* Timeout semaphore */
	static struct k_sem prov_sem;
	static uint16_t prov_addr = 0x0002;
	static uint16_t current_dev_addr;
	static const uint8_t dev_key[16] = { 0x01, 0x02, 0x03, 0x04, 0x05 };
	static uint8_t dev_uuid[16] = { 0x6c, 0x69, 0x6e, 0x67, 0x61, 0x6f };

	#define WAIT_TIME 60 /seconds/

	static void test_device_init(void)
	{
	/* Ensure that the UUID is unique: */
	dev_uuid[6] = '0' + get_device_nbr();

	bt_mesh_test_cfg_set(NULL, WAIT_TIME);
	}

	static void test_provisioner_init(void)
	{
	atomic_set_bit(flags, IS_PROVISIONER);
	bt_mesh_test_cfg_set(NULL, WAIT_TIME);
	}

	static void unprovisioned_beacon(uint8_t uuid[16],
	bt_mesh_prov_oob_info_t oob_info,
	uint32_t *uri_hash)
	{
	if (!atomic_test_bit(flags, IS_PROVISIONER)) {
	return;
	}

	bt_mesh_provision_adv(uuid, 0, prov_addr, 0);
	}

	static void prov_complete(uint16_t net_idx, uint16_t addr)
	{
	if (!atomic_test_bit(flags, IS_PROVISIONER)) {
	k_sem_give(&prov_sem);
	}
	}

	static void prov_node_added(uint16_t net_idx, uint8_t uuid[16], uint16_t addr,
	uint8_t num_elem)
	{
	LOG_INF("Device 0x%04x provisioned", prov_addr);
	current_dev_addr = prov_addr++;
	k_sem_give(&prov_sem);
	}

	static void prov_reset(void)
	{
	ASSERT_OK(bt_mesh_prov_enable(BT_MESH_PROV_ADV));
	}

	static struct bt_mesh_prov prov = {
	.uuid = dev_uuid,
	.unprovisioned_beacon = unprovisioned_beacon,
	.complete = prov_complete,
	.node_added = prov_node_added,
	.reset = prov_reset,
	};

	/** @brief Verify that this device pb-adv provision.
	*/
	static void test_device_pb_adv_no_oob(void)
	{
	k_sem_init(&prov_sem, 0, 1);

	bt_mesh_device_setup(&prov, &comp);

	ASSERT_OK(bt_mesh_prov_enable(BT_MESH_PROV_ADV));

	LOG_INF("Mesh initialized\n");

	/* Keep a long timeout so the prov multi case has time to finish: */
	ASSERT_OK(k_sem_take(&prov_sem, K_SECONDS(40)));

	PASS();
	}

	/** @brief Verify that this device can be reprovisioned after resets
	*/
	static void test_device_pb_adv_reprovision(void)
	{
	k_sem_init(&prov_sem, 0, 1);

	bt_mesh_device_setup(&prov, &comp);

	ASSERT_OK(bt_mesh_prov_enable(BT_MESH_PROV_ADV));

	LOG_INF("Mesh initialized\n");

	for (int i = 0; i < PROV_REPROV_COUNT; i++) {
	/* Keep a long timeout so the prov multi case has time to finish: */
	LOG_INF("Dev prov loop #%d, waiting for prov ...\n", i);
	ASSERT_OK(k_sem_take(&prov_sem, K_SECONDS(5)));
	}

	PASS();
	}

	/** @brief Verify that this provisioner pb-adv provision.
	*/
	static void test_provisioner_pb_adv_no_oob(void)
	{
	k_sem_init(&prov_sem, 0, 1);

	bt_mesh_device_setup(&prov, &comp);

	ASSERT_OK(bt_mesh_cdb_create(test_net_key));

	ASSERT_OK(bt_mesh_provision(test_net_key, 0, 0, 0, 0x0001, dev_key));

	ASSERT_OK(k_sem_take(&prov_sem, K_SECONDS(5)));

	PASS();
	}

	/** @brief Verify that the provisioner can provision multiple devices in a row
	*/
	static void test_provisioner_pb_adv_multi(void)
	{
	k_sem_init(&prov_sem, 0, 1);

	bt_mesh_device_setup(&prov, &comp);

	ASSERT_OK(bt_mesh_cdb_create(test_net_key));

	ASSERT_OK(bt_mesh_provision(test_net_key, 0, 0, 0, 0x0001, dev_key));

	for (int i = 0; i < PROV_MULTI_COUNT; i++) {
	ASSERT_OK(k_sem_take(&prov_sem, K_SECONDS(20)));
	}

	PASS();
	}

	/** @brief Verify that when the IV Update flag is set to zero at the
	* time of provisioning, internal IV update counter is also zero.
	*/
	static void test_provisioner_iv_update_flag_zero(void)
	{
	uint8_t flags = 0x00;

	bt_mesh_device_setup(&prov, &comp);

	ASSERT_OK(bt_mesh_provision(test_net_key, 0, flags, 0, 0x0001, dev_key));

	if (bt_mesh.ivu_duration != 0) {
	FAIL("IV Update duration counter is not 0 when IV Update flag is zero");
	}

	PASS();
	}

	/** @brief Verify that when the IV Update flag is set to one at the
	* time of provisioning, internal IV update counter is set to 96 hours.
	*/
	static void test_provisioner_iv_update_flag_one(void)
	{
	uint8_t flags = 0x02; /* IV Update flag bit set to 1 */

	bt_mesh_device_setup(&prov, &comp);

	ASSERT_OK(bt_mesh_provision(test_net_key, 0, flags, 0, 0x0001, dev_key));

	if (bt_mesh.ivu_duration != 96) {
	FAIL("IV Update duration counter is not 96 when IV Update flag is one");
	}

	bt_mesh_reset();

	if (bt_mesh.ivu_duration != 0) {
	FAIL("IV Update duration counter is not reset to 0");
	}

	PASS();
	}

	/** @brief Verify that the provisioner can provision a device multiple times after resets
	*/
	static void test_provisioner_pb_adv_reprovision(void)
	{
	k_sem_init(&prov_sem, 0, 1);

	bt_mesh_device_setup(&prov, &comp);

	ASSERT_OK(bt_mesh_cdb_create(test_net_key));

	ASSERT_OK(bt_mesh_provision(test_net_key, 0, 0, 0, 0x0001, dev_key));

	for (int i = 0; i < PROV_REPROV_COUNT; i++) {
	LOG_INF("Provisioner prov loop #%d, waiting for prov ...\n", i);
	ASSERT_OK(k_sem_take(&prov_sem, K_SECONDS(20)));

	uint8_t status;
	size_t subs_count = 1;
	uint16_t sub;
	struct bt_mesh_cfg_mod_pub healthpub = { 0 };
	struct bt_mesh_cdb_node *node;

	/* Check that publication and subscription are reset after last iteration */
	ASSERT_OK(bt_mesh_cfg_mod_sub_get(0, current_dev_addr, current_dev_addr,
	BT_MESH_MODEL_ID_HEALTH_SRV, &status, &sub,
	&subs_count));
	ASSERT_EQUAL(0, status);
	ASSERT_TRUE(subs_count == 0);

	ASSERT_OK(bt_mesh_cfg_mod_pub_get(0, current_dev_addr, current_dev_addr,
	BT_MESH_MODEL_ID_HEALTH_SRV, &healthpub,
	&status));
	ASSERT_EQUAL(0, status);
	ASSERT_TRUE(healthpub.addr == BT_MESH_ADDR_UNASSIGNED, "Pub not cleared");


	/* Set pub and sub to check that they are reset */
	healthpub.addr = 0xc001;
	healthpub.app_idx = 0;
	healthpub.cred_flag = false;
	healthpub.ttl = 10;
	healthpub.period = BT_MESH_PUB_PERIOD_10SEC(1);
	healthpub.transmit = BT_MESH_TRANSMIT(3, 100);

	ASSERT_OK(bt_mesh_cfg_app_key_add(0, current_dev_addr, 0, 0, test_app_key,
	&status));
	ASSERT_EQUAL(0, status);

	ASSERT_OK(bt_mesh_cfg_mod_app_bind(0, current_dev_addr, current_dev_addr, 0x0,
	BT_MESH_MODEL_ID_HEALTH_SRV, &status));
	ASSERT_EQUAL(0, status);

	ASSERT_OK(bt_mesh_cfg_mod_sub_add(0, current_dev_addr, current_dev_addr, 0xc000,
	BT_MESH_MODEL_ID_HEALTH_SRV, &status));
	ASSERT_EQUAL(0, status);

	ASSERT_OK(bt_mesh_cfg_mod_pub_set(0, current_dev_addr, current_dev_addr,
	BT_MESH_MODEL_ID_HEALTH_SRV, &healthpub,
	&status));
	ASSERT_EQUAL(0, status);

	ASSERT_OK(bt_mesh_cfg_node_reset(0, current_dev_addr, (bool *)&status));

	node = bt_mesh_cdb_node_get(current_dev_addr);
	bt_mesh_cdb_node_del(node, true);
	}

	PASS();
	}

	#define TEST_CASE(role, name, description) \
	{ \
	.test_id = "prov_" #role "_" #name, .test_descr = description, \
	.test_post_init_f = test_##role##_init, \
	.test_tick_f = bt_mesh_test_timeout, \
	.test_main_f = test_##role##_##name, \
	}

	static const struct bst_test_instance test_connect[] = {
	TEST_CASE(device, pb_adv_no_oob,
	"Device: pb-adv provisioning use no-oob method"),
	TEST_CASE(device, pb_adv_reprovision,
	"Device: pb-adv provisioning, reprovision"),
	TEST_CASE(provisioner, pb_adv_no_oob,
	"Provisioner: pb-adv provisioning use no-oob method"),
	TEST_CASE(provisioner, pb_adv_multi,
	"Provisioner: pb-adv provisioning multiple devices"),
	TEST_CASE(provisioner, iv_update_flag_zero,
	"Provisioner: effect on ivu_duration when IV Update flag is set to zero"),
	TEST_CASE(provisioner, iv_update_flag_one,
	"Provisioner: effect on ivu_duration when IV Update flag is set to one"),
	TEST_CASE(provisioner, pb_adv_reprovision,
	"Provisioner: pb-adv provisioning, resetting and reprovisioning multiple times."),

	BSTEST_END_MARKER
	};

	struct bst_test_list test_provision_install(struct bst_test_list tests)
	{
	tests = bst_add_tests(tests, test_connect);
	return tests;
	}