Mesh: Implement Mesh Node Role API'ssubmit/tizen/20210330.044039accepted/tizen/unified/20210331.054026

This patch implements the Mesh node role for device.
Join API create a fresh node and set callbacks for join complete
and message execution callbacks.
Cancel API destroy the outgoing request initiated by Join API
and destroy the node from the application

Change-Id: Ic7127b90849223626c94351c63a2e86e092065f6
Signed-off-by: anuj.bhumiya <anuj.bhumiya@samsung.com>

7 files changed, 361 insertions, 9 deletions

diff --git a/include/bluetooth_internal.h b/include/bluetooth_internal.h
index 93fdbb4..69681e1 100644
--- a/include/bluetooth_internal.h
+++ b/include/bluetooth_internal.h
@@ -4614,8 +4614,8 @@ int bt_mesh_network_destroy(bt_mesh_network_h network);
  * @since_tizen 6.5
  * @privlevel platform
  */
-int bt_mesh_network_join(bt_mesh_node_h node_handle,
-		bt_mesh_join_complete_cb cb, void *user_data);
+int bt_mesh_node_network_join(bt_mesh_node_h node_handle,
+		bt_mesh_join_complete_cb callback, void *user_data);
 
 /**
  * @internal
@@ -4624,11 +4624,31 @@ int bt_mesh_network_join(bt_mesh_node_h node_handle,
  *
  * @param: in: node_handle, Local Mesh node
  *
- * @see bt_mesh_network_join
+ * @see bt_mesh_node_network_join
  * @since_tizen 6.5
  * @privlevel platform
  */
-int bt_mesh_cancel_join(bt_mesh_node_h node_handle);
+int bt_mesh_node_cancel_join(bt_mesh_node_h node_handle);
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_MESH_MODULE
+ * @brief Registers a callback that will be invoked when message is
+ * received from any node either remote node or from provisioner node
+ *
+ * @pre Either bt_mesh_network_provision_device() in case of Provisioner role
+ * or bt_mesh_node_network_join() in case of Node role must be called
+ *
+ * @param[in] callback, callback function which is set, for receiving any message.
+ *
+ * @see bt_network_provision_device()
+ * @see bt_mesh_node_network_join()
+ * @since_tizen 6.5
+ * @privlevel platform
+ */
+int bt_mesh_node_model_set_msg_cb(bt_mesh_node_h node_handle,
+		bt_mesh_model_msg_cb callback,
+			void *user_data);
 
 /**
  * @internal
diff --git a/include/bluetooth_private.h b/include/bluetooth_private.h
index f71fb0d..00ee146 100644
--- a/include/bluetooth_private.h
+++ b/include/bluetooth_private.h
@@ -188,6 +188,7 @@ typedef enum {
 	BT_EVENT_MESH_NODE_MODEL_GROUP_SUB, /**< Mesh -   Model Virtual Subscription - Add/Delete/overwrite/DeleteAll  */
 	BT_EVENT_MESH_NODE_MODEL_GROUP_VIR_SUB, /**< Mesh -  Model Virtual Subscription - Add/Delete/overwrite/DeleteAll  */
 	BT_EVENT_MESH_NODE_MODEL_PUBLICATION, /**< Mesh -  Model Publication Status event index */
+	BT_EVENT_MESH_JOIN_NETWORK, /**< Mesh -  Join Complete callback */
 	BT_EVENT_MAX
 } bt_event_e;
 
diff --git a/include/bluetooth_type_internal.h b/include/bluetooth_type_internal.h
index 22feb8c..e34596c 100644
--- a/include/bluetooth_type_internal.h
+++ b/include/bluetooth_type_internal.h
@@ -1741,8 +1741,8 @@ typedef void (*bt_mesh_network_device_provision_cb)
 			const char *dev_uuid, void *user_data);
 
 typedef void (*bt_mesh_join_complete_cb)
-		(int result, bt_mesh_node_h node_handle,
-		 char *token, void *user_data);
+		(int result, bt_mesh_node_h node,
+			void *user_data);
 
 typedef void (*bt_mesh_authentication_request_cb)
 		(int result, bt_mesh_authentication_type_e auth_type,
diff --git a/src/bluetooth-common.c b/src/bluetooth-common.c
index 48e0588..c43e721 100644
--- a/src/bluetooth-common.c
+++ b/src/bluetooth-common.c
@@ -299,6 +299,7 @@ static bt_event2index_table_t event2index[] = {
 	{ BLUETOOTH_EVENT_MESH_MODEL_SUBSCRIPTION_CONFGURED, BT_EVENT_MESH_NODE_MODEL_GROUP_SUB },
 	{ BLUETOOTH_EVENT_MESH_MODEL_VIRTUAL_SUBSCRIPTION_CONFGURED, BT_EVENT_MESH_NODE_MODEL_GROUP_VIR_SUB },
 	{ BLUETOOTH_EVENT_MESH_MODEL_PUBLICATION_STATUS, BT_EVENT_MESH_NODE_MODEL_PUBLICATION },
+	{ BLUETOOTH_EVENT_MESH_JOIN_COMPLETED, BT_EVENT_MESH_JOIN_NETWORK },
 	{ 0, -1 }
 };
 
@@ -1467,6 +1468,7 @@ static bool __bt_need_to_handle(int event)
 	case BLUETOOTH_EVENT_MESH_MODEL_VIRTUAL_SUBSCRIPTION_CONFGURED:
 	case BLUETOOTH_EVENT_MESH_MODEL_PUBLICATION_STATUS:
 	case BLUETOOTH_EVENT_MESH_MODEL_MSG_EXECUTED:
+	case BLUETOOTH_EVENT_MESH_JOIN_COMPLETED:
 		return true;
 	default:
 		break;
@@ -4157,6 +4159,22 @@ static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *us
 			(bt_mesh_appkey_h) appkey_s, msg,
 			bt_event_slot_container[event_index].user_data);
 		break;
+	} case BLUETOOTH_EVENT_MESH_JOIN_COMPLETED: {
+		BT_INFO("BLUETOOTH_EVENT_MESH_JOIN_FINISHED");
+		bluetooth_mesh_node_t *node = NULL;
+		bt_mesh_node_s *info = NULL;
+		node = (bluetooth_mesh_node_t *)(param->param_data);
+
+		info = (bt_mesh_node_s*)node;
+		if (!info) {
+			BT_INFO("Node Handel not received");
+			break;
+		}
+		((bt_mesh_join_complete_cb)
+			bt_event_slot_container[event_index].callback)
+				(_bt_get_error_code(param->result), (bt_mesh_node_h) info,
+					bt_event_slot_container[event_index].user_data);
+		break;
 	}
 	default:
 		BT_INFO("Unknown function");
diff --git a/src/bluetooth-mesh.c b/src/bluetooth-mesh.c
index 195e4c0..f86bb2e 100644
--- a/src/bluetooth-mesh.c
+++ b/src/bluetooth-mesh.c
@@ -1467,6 +1467,183 @@ int bt_mesh_network_load(const char *token, bt_mesh_network_h *network)
 	return error_code;
 }
 
+int bt_mesh_node_network_join(bt_mesh_node_h node_handle,
+		bt_mesh_join_complete_cb callback,
+			void *user_data)
+{
+	FUNC_ENTRY;
+	int error_code = BT_ERROR_NONE;
+	GSList *l1, *l2;
+	int i, j;
+	int offset = 0;
+	int num_models = 0;
+
+	bluetooth_mesh_node_t param_node;
+	bluetooth_mesh_model_t **param_model = NULL;
+
+	BT_CHECK_MESH_SUPPORT();
+	BT_CHECK_MESH_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(node_handle);
+	BT_CHECK_INPUT_PARAMETER(callback);
+
+	bt_mesh_node_s *node = (bt_mesh_node_s*)node_handle;
+	BT_MESH_VALIDATE_HANDLE(node, node_list);
+
+	BT_CHECK_MESH_IS_ATTACHED(node);
+
+	/* Node should contain at-least one element */
+	if (!g_slist_length(node->elements)) {
+		BT_INFO("Mesh: No element present in Node: NOT ALLOWED!!");
+		return BT_ERROR_INVALID_PARAMETER;
+	}
+
+	/* Element in Node should contain at-least one Model */
+	for (l1 = node->elements; l1 != NULL; l1 = l1->next) {
+		bt_mesh_element_s *el = l1->data;
+		int models = 0;
+		models = g_slist_length(el->models);
+		BT_INFO("Mesh: Num models element [%u] has is [%d]", el->index, models);
+		if (!models) {
+			BT_INFO("Mesh: No Model present in element: NOT ALLOWED!!");
+			return BT_ERROR_INVALID_PARAMETER;
+		}
+		/* If Primary element does not contain CFG SRV model, create and append */
+		if (el->index == 0x0000) {
+			uint32_t mod_id = 0xFFFF0000; /* CFG SRV */
+
+			if (!g_slist_find_custom(el->models, GUINT_TO_POINTER(mod_id),
+					(GCompareFunc)__compare_model_id)) {
+				bt_mesh_model_s *model_s;
+				BT_ERR("Mesh: Primary element does not contain CFG SRV Model:Add it!");
+				model_s = g_malloc0(sizeof(bt_mesh_model_s));
+
+				model_s->is_local = true;
+				model_s->parent = el;
+				model_s->id = mod_id;
+				model_list = g_slist_append(model_list, model_s);
+				el->models = g_slist_append(el->models, model_s);
+				num_models++;
+			} else
+				BT_INFO("Mesh: CFG SRV model is already added in primary element");
+		}
+		num_models += models;
+	}
+
+	memset(&param_node, 0x00, sizeof(bluetooth_mesh_node_t));
+	param_node.vendor_info.companyid = node->features.cid;
+	param_node.vendor_info.vendorid = node->features.pid;
+	param_node.vendor_info.versionid = node->features.vid;
+	param_node.vendor_info.crpl = node->features.crpl;
+
+	if (node->features.features & BT_MESH_FEATURE_RELAY)
+		param_node.vendor_info.relay = 1;
+	if (node->features.features & BT_MESH_FEATURE_PROXY)
+		param_node.vendor_info.proxy = 1;
+	if (node->features.features & BT_MESH_FEATURE_FRIEND)
+		param_node.vendor_info.frnd = 1;
+	if (node->features.features & BT_MESH_FEATURE_LOWPOWER)
+		param_node.vendor_info.lpn = 1;
+
+	param_node.num_elements =  g_slist_length(node->elements);
+	param_node.primary_unicast = 0x0001;
+	_bt_get_random_bytes(param_node.uuid, 16);
+
+	BT_INFO("Mesh: Total Models [%d]", num_models);
+	param_model = (bluetooth_mesh_model_t**)g_malloc0(num_models * sizeof(bluetooth_mesh_model_t*));
+
+	for (l1 = node->elements, i = 0; l1 != NULL; l1 = l1->next, i++) {
+		bt_mesh_element_s *e = l1->data;
+		for (l2 = e->models, j = 0; l2 != NULL; l2 = l2->next, j++) {
+			bt_mesh_model_s *m = l2->data;
+			param_model[j+offset] = g_malloc0(sizeof(bluetooth_mesh_model_t));
+			param_model[j+offset]->elem_index = i;
+			param_model[j+offset]->model_id = m->id;
+		}
+		offset += g_slist_length(e->models);
+	}
+
+	BT_INFO("Mesh: Send Join Network Request to FRWK");
+	error_code = _bt_get_error_code(bluetooth_mesh_network_join(&param_node,
+				num_models, param_model));
+	if (error_code != BT_ERROR_NONE) {
+		BT_INFO("Mesh: Remote Node could not be created!!");
+		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
+
+		/* Cleanup */
+		for (int i = 0; i < num_models; i++)
+			g_free(param_model[i]);
+
+		g_free(param_model);
+		return error_code;
+	}
+
+	BT_INFO("Mesh: Remote Node created successfully");
+
+	/* Fill Node Data */
+	node->is_attached = false;
+	node->is_provisioner = false;
+	__bt_mesh_util_convert_hex_to_string((uint8_t *)param_node.uuid,
+		16, node->uuid, sizeof(node->uuid));
+
+	BT_INFO("Mesh: Node UUID [%s]", node->uuid);
+	/* Clean up memory */
+	for (int i = 0; i < num_models; i++)
+		g_free(param_model[i]);
+	g_free(param_model);
+	_bt_set_cb(BT_EVENT_MESH_JOIN_NETWORK, callback, user_data);
+	FUNC_EXIT;
+	return BT_ERROR_NONE;
+}
+
+int bt_mesh_node_cancel_join(bt_mesh_node_h node_handle)
+{
+	FUNC_ENTRY;
+	int error_code = BT_ERROR_NONE;
+	bluetooth_mesh_node_info_t node;
+
+	BT_CHECK_MESH_SUPPORT();
+	BT_CHECK_MESH_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(node_handle);
+
+	bt_mesh_node_s *node_s = (bt_mesh_node_s*)node_handle;
+	BT_MESH_VALIDATE_HANDLE(node_s, node_list);
+	BT_CHECK_MESH_IS_ATTACHED(node_s);
+	memset(&node, 0x00, sizeof(bluetooth_mesh_node_info_t));
+
+	BT_INFO("Mesh: Node UUID [%s]", node_s->uuid);
+	BT_INFO("Mesh: Send Cancel ongoing Request to FRWK");
+	g_strlcpy(node.net_uuid, node_s->uuid, 33);
+	error_code = _bt_get_error_code(bluetooth_mesh_cancel_join(&node));
+	if (error_code != BT_ERROR_NONE) {
+		BT_INFO("Mesh: Failed to cancel Join!!");
+		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
+		FUNC_EXIT;
+		return error_code;
+	}
+
+	BT_INFO("Mesh: Ongoing Join request cancelled successfully");
+	node_list = g_slist_remove(node_list, node_s);
+	g_slist_free_full(node_s->elements, __bt_mesh_free_elements);
+	g_free(node_s);
+
+	FUNC_EXIT;
+	return error_code;
+}
+
+int bt_mesh_node_model_set_msg_cb(bt_mesh_node_h node_handle,
+		bt_mesh_model_msg_cb callback, void *user_data)
+{
+	FUNC_ENTRY;
+	BT_CHECK_MESH_SUPPORT();
+	BT_CHECK_MESH_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(callback);
+	BT_CHECK_INPUT_PARAMETER(node_handle);
+
+	_bt_set_cb(BT_EVENT_MESH_NODE_MODEL_EXECUTE_MSG_COMPLETED, callback, user_data);
+	FUNC_EXIT;
+	return BT_ERROR_NONE;
+}
+
 int bt_mesh_network_get_name(bt_mesh_network_h network, char **network_name)
 {
 	bt_mesh_network_s *network_s;
diff --git a/tests/test/bt_mesh_unit_test.c b/tests/test/bt_mesh_unit_test.c
index 96a87ed..6122b14 100644
--- a/tests/test/bt_mesh_unit_test.c
+++ b/tests/test/bt_mesh_unit_test.c
@@ -256,6 +256,20 @@ tc_table_t tc_scenario[] = {
 	{NULL						, 0X0000},
 };
 
+tc_table_t tc_join_scenario[] = {
+	{"Back"
+		, BT_MESH_UNIT_TEST_FUNCTION_BACK},
+	{"bt_mesh_scenario_network_join"
+		, BT_MESH_UNIT_TEST_SCENARIO_NETWORK_JOIN},
+	{"Cancel"
+		, BT_MESH_UNIT_TEST_SCENARIO_JOIN_CANCEL},
+	{"Set Message execuation callback"
+		, BT_MESH_UNIT_TEST_SCENARIO_SET_MSG_CB},
+	{"select this menu to set parameters and then select the function again"
+		, BT_MESH_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS},
+	{NULL						, 0X0000},
+};
+
 tc_table_t tc_main[] = {
 	{"bt_mesh_initialize"
 		, BT_MESH_UNIT_TEST_FUNCTION_INITIALIZE},
@@ -269,6 +283,8 @@ tc_table_t tc_main[] = {
 		, BT_MESH_UNIT_TEST_TABLE_CONTROL},
 	{"Scenerio"
 		, BT_MESH_UNIT_TEST_TABLE_SCENARIO},
+	{"Join_Scenerio"
+		, BT_MESH_UNIT_TEST_TABLE_JOIN_SCENARIO},
 	{"Finish"
 		, BT_MESH_UNIT_TEST_TABLE_FINISH},
 	{NULL						, 0x0000},
@@ -301,6 +317,9 @@ void tc_usage_print(void){
 	case BT_MESH_UNIT_TEST_TABLE_SCENARIO:
 		tc_table = tc_scenario;
 		break;
+	case BT_MESH_UNIT_TEST_TABLE_JOIN_SCENARIO:
+		tc_table = tc_join_scenario;
+		break;
 	default:
 		tc_table = tc_main;
 		break;
@@ -759,6 +778,13 @@ void __bt_mesh_network_create_cb(int result, bt_mesh_network_h network, const ch
 	print_network_handle(network);
 }
 
+void __bt_mesh_join_complete_cb(int result, bt_mesh_node_h node,
+		void *user_data)
+{
+	TC_PRT("result: %s", __bt_get_error_message(result));
+	TC_PRT("network_handle = [%p]", (void*)node);
+}
+
 bool __bt_mesh_appkey_info_cb(int result, bt_mesh_network_h network, int total,
 		bt_mesh_netkey_h netkey, bt_mesh_appkey_h appkey, uint16_t appkey_index, void *user_data)
 {
@@ -1124,6 +1150,23 @@ int test_set_params(int test_id, char *param)
 		}
 		break;
 	}
+	case BT_MESH_UNIT_TEST_TABLE_JOIN_SCENARIO:
+	{
+		switch (test_id) {
+		case BT_MESH_UNIT_TEST_SCENARIO_JOIN_CANCEL:
+			param_count = 1;
+			TC_PRT("Input param(%d) (node_handle)\n", param_index + 1);
+			break;
+		case BT_MESH_UNIT_TEST_SCENARIO_SET_MSG_CB:
+			param_count = 1;
+			TC_PRT("Input param(%d) (node_handle)\n", param_index + 1);
+			break;
+		default:
+			TC_PRT("There is no parameter to set\n");
+			break;
+		}
+	break;
+	}
 	case BT_MESH_UNIT_TEST_TABLE_CONFIGURATION: {
 		switch (test_id) {
 		case BT_MESH_UNIT_TEST_FUNCTION_MESH_NETWORK_DISCOVER_NODE:
@@ -2603,7 +2646,7 @@ int test_input_callback(void *data)
 			if (ret != BT_ERROR_NONE)
 				TC_PRT("return %s\n", __bt_get_error_message(ret));
 
-				break;
+			break;
 		}
 		case BT_MESH_UNIT_TEST_SCENARIO_UNPROVISIONED_SCAN: {
 			unprov_dev_list = NULL;
@@ -2824,13 +2867,102 @@ int test_input_callback(void *data)
 			__bt_free_test_param(&g_test_param);
 		break;
 	}
+	case BT_MESH_UNIT_TEST_TABLE_JOIN_SCENARIO:
+	{
+		switch (test_id) {
+		case BT_MESH_UNIT_TEST_SCENARIO_NETWORK_JOIN: {
+			bt_mesh_element_h element_sh;
+			bt_mesh_model_h model_sh1, model_sh3, model_sh4;
+			bt_mesh_model_id_s mod_id1, mod_id3, mod_id4;
+			bt_mesh_node_features_s features;
+			features.features = BT_MESH_FEATURE_RELAY;
+			features.features |= BT_MESH_FEATURE_LOWPOWER;
+
+			// create node
+			ret = bt_mesh_node_create(&features, &local_node);
+			if (ret != BT_ERROR_NONE)
+				TC_PRT("bt_mesh_node_create return %s\n", __bt_get_error_message(ret));
+
+			// create element
+			ret = bt_mesh_node_create_element(local_node, &element_sh);
+			if (ret != BT_ERROR_NONE)
+				TC_PRT("bt_mesh_node_create_element return %s\n", __bt_get_error_message(ret));
+
+			// create models
+			// Add configuration server
+			memset(&mod_id1, 0x00, sizeof(bt_mesh_model_id_s));
+			mod_id1.model_id = BT_MESH_MODEL_ID_CFG_SRV;
+			mod_id1.company_id = 0xFFFF;
+			if (ret != BT_ERROR_NONE)
+				TC_PRT("The model_id is [0x%2.2X]\n", mod_id1.model_id);
+			ret = bt_mesh_element_create_model(element_sh, &mod_id1, &model_sh1);
+			if (ret != BT_ERROR_NONE)
+				TC_PRT("bt_mesh_element_create_model return %s\n", __bt_get_error_message(ret));
+
+			// Add Generic on-off client and server
+			memset(&mod_id3, 0x00, sizeof(bt_mesh_model_id_s));
+			mod_id3.model_id = BT_MESH_MODEL_ID_GEN_ONOFF_SRV;
+			mod_id3.company_id = 0xFFFF;
+			ret = bt_mesh_element_create_model(element_sh, &mod_id3, &model_sh3);
+			if (ret != BT_ERROR_NONE)
+				TC_PRT("bt_mesh_element_create_model return %s\n", __bt_get_error_message(ret));
+
+			memset(&mod_id4, 0x00, sizeof(bt_mesh_model_id_s));
+			mod_id4.model_id = BT_MESH_MODEL_ID_GEN_ONOFF_CLIENT;
+			mod_id4.company_id = 0xFFFF;
+			ret = bt_mesh_element_create_model(element_sh, &mod_id4, &model_sh4);
+			if (ret != BT_ERROR_NONE)
+				TC_PRT("bt_mesh_element_create_model return %s\n", __bt_get_error_message(ret));
+
+			// join network call
+			ret = bt_mesh_node_network_join(local_node, __bt_mesh_join_complete_cb, NULL);
+			if (ret != BT_ERROR_NONE)
+				TC_PRT("bt_mesh_node_network_join return %s", __bt_get_error_message(ret));
+			else {
+				TC_PRT("Mesh Node created!!");
+				print_node_handle(local_node);
+			}
+			break;
+		}
+		case BT_MESH_UNIT_TEST_SCENARIO_JOIN_CANCEL:{
+			bt_mesh_node_h node_h;
+			if (g_test_param.param_count != 1) {
+				TC_PRT("Enter parameters first!");
+				break;
+			}
+			node_h = GUINT_TO_POINTER(strtoul(g_test_param.params[0], NULL, 16));
+			ret = bt_mesh_node_cancel_join(node_h);
+			TC_PRT("return %s\n", __bt_get_error_message(ret));
+			break;
+		}
+		case BT_MESH_UNIT_TEST_SCENARIO_SET_MSG_CB: {
+			bt_mesh_node_h node_h;
+			if (g_test_param.param_count != 1) {
+				TC_PRT("Enter parameters first!");
+				break;
+			}
+			node_h = GUINT_TO_POINTER(strtoul(g_test_param.params[0], NULL, 16));
+			ret = bt_mesh_node_model_set_msg_cb(node_h, __bt_mesh_model_msg_cb, NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+		case BT_MESH_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS: {
+			need_to_set_params = true;
+			TC_PRT("Select the function again");
+			break;
+		}
+		default:
+			break;
+		}
+		__bt_free_test_param(&g_test_param);
+		break;
+	}
 	default:
 		break;
 	}
 	return 0;
 }
 
-
 static gboolean key_event_cb(GIOChannel *chan,
 		GIOCondition cond,
 		gpointer data)
@@ -2872,7 +3004,7 @@ static gboolean key_event_cb(GIOChannel *chan,
 		if (test_id == 0)
 			current_tc_table = BT_MESH_UNIT_TEST_TABLE_MAIN;
 		else if (test_id >= BT_MESH_UNIT_TEST_TABLE_NETWORK
-			&& test_id <= BT_MESH_UNIT_TEST_TABLE_SCENARIO) {
+			&& test_id <= BT_MESH_UNIT_TEST_TABLE_JOIN_SCENARIO) {
 			current_tc_table = test_id;
 		} else if (test_id > BT_MESH_UNIT_TEST_TABLE_CONTROL
 			&& test_id < BT_MESH_UNIT_TEST_TABLE_FINISH) {
diff --git a/tests/test/bt_mesh_unit_test.h b/tests/test/bt_mesh_unit_test.h
index 1843ba7..6bd8ba6 100644
--- a/tests/test/bt_mesh_unit_test.h
+++ b/tests/test/bt_mesh_unit_test.h
@@ -38,6 +38,7 @@ typedef enum {
 	BT_MESH_UNIT_TEST_TABLE_CONFIGURATION,
 	BT_MESH_UNIT_TEST_TABLE_CONTROL,
 	BT_MESH_UNIT_TEST_TABLE_SCENARIO,
+	BT_MESH_UNIT_TEST_TABLE_JOIN_SCENARIO,
 	BT_MESH_UNIT_TEST_TABLE_FINISH = 0XFF,
 } bt_mesh_unit_test_table_e;
 
@@ -124,6 +125,9 @@ typedef enum {
 	BT_MESH_UNIT_TEST_SCENARIO_MODEL_GENERIC_ONOFF_SET_OFF,
 	BT_MESH_UNIT_TEST_SCENARIO_GROUP_GENERIC_ONOFF_SET_ON,
 	BT_MESH_UNIT_TEST_SCENARIO_GROUP_GENERIC_ONOFF_SET_OFF,
+	BT_MESH_UNIT_TEST_SCENARIO_NETWORK_JOIN =1,
+	BT_MESH_UNIT_TEST_SCENARIO_JOIN_CANCEL,
+	BT_MESH_UNIT_TEST_SCENARIO_SET_MSG_CB,
 	BT_MESH_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS = 0XFF,
 } bt_mesh_unit_test_function_e;