tests: Bluetooth: Mesh: time status timing of time model

Commit adds unit test to check the Time Status timig of
the Time model (including time restrictions).

Signed-off-by: Aleksandr Khromykh <aleksandr.khromykh@nordicsemi.no>

tests/subsys/bluetooth/mesh/time_model/CMakeLists.txt

@@ -0,0 +1,39 @@
+#
+# Copyright (c) 2023 Nordic Semiconductor ASA
+#
+# SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
+#
+cmake_minimum_required(VERSION 3.20.0)
+
+find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
+project(bt_mesh_time_model_test)
+
+target_include_directories(app PUBLIC
+ ${ZEPHYR_NRF_MODULE_DIR}/subsys/bluetooth/mesh
+ ${ZEPHYR_BASE}/subsys/bluetooth
+ ../common
+ )
+
+FILE(GLOB app_sources src/*.c)
+
+target_sources(app PRIVATE
+ ${app_sources}
+ ${ZEPHYR_NRF_MODULE_DIR}/subsys/bluetooth/mesh/time_srv.c
+ ${ZEPHYR_NRF_MODULE_DIR}/subsys/bluetooth/mesh/time.c
+ ${ZEPHYR_NRF_MODULE_DIR}/subsys/bluetooth/mesh/time_util.c
+ )
+
+target_compile_options(app
+ PRIVATE
+ -DCONFIG_BT_MESH_MODEL_KEY_COUNT=5
+ -DCONFIG_BT_MESH_MODEL_GROUP_COUNT=5
+ -DCONFIG_BT_LOG_LEVEL=0
+ -DCONFIG_BT_MESH_TIME_SRV=1
+ -DCONFIG_BT_MESH_TIME_SRV_CLOCK_ACCURACY=500
+ -DCONFIG_BT_MESH_TIME_MESH_HOP_UNCERTAINTY=30
+ -DCONFIG_BT_MESH_USES_TINYCRYPT
+ )
+
+zephyr_ld_options(
+ ${LINKERFLAGPREFIX},--allow-multiple-definition
+ )

tests/subsys/bluetooth/mesh/time_model/prj.conf

@@ -0,0 +1,12 @@
+#
+# Copyright (c) 2023 Nordic Semiconductor ASA
+#
+# SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
+#
+
+# Ztest configuration
+CONFIG_ZTEST=y
+CONFIG_ZTEST_NEW_API=y
+CONFIG_TEST_RANDOM_GENERATOR=y
+
+CONFIG_NET_BUF=y

tests/subsys/bluetooth/mesh/time_model/src/main.c

@@ -0,0 +1,249 @@
+/*
+ * Copyright (c) 2023 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
+ */
+
+#include <zephyr/ztest.h>
+#include <zephyr/kernel.h>
+#include <zephyr/random/rand32.h>
+#include <bluetooth/mesh/time_srv.h>
+#include <bluetooth/mesh/models.h>
+#include "time_internal.h"
+#include "time_util.h"
+
+#define UNCERTAINTY_STEP_MS 10
+#define SUBSEC_STEPS 256U
+#define STATUS_INTERVAL_MIN 30000ul
+#define TEST_TIME 100000ul
+
+static struct bt_mesh_time_srv time_srv = BT_MESH_TIME_SRV_INIT(NULL);
+
+static struct bt_mesh_elem mock_elem[] = {
+ BT_MESH_ELEM(1, BT_MESH_MODEL_LIST(BT_MESH_MODEL_TIME_SRV(&time_srv)), BT_MESH_MODEL_NONE)};
+
+struct mock_comp_data {
+ size_t elem_count;
+ struct bt_mesh_elem *elem;
+} mock_comp = {.elem_count = 1, .elem = mock_elem};
+
+static struct bt_mesh_msg_ctx test_ctx = {
+ .addr = 0x0001,
+ .send_ttl = 0,
+};
+
+static const struct bt_mesh_time_zone_change zone_change = {.new_offset = 3, .timestamp = 30};
+
+static const struct bt_mesh_time_tai_utc_change tai_utc_change = {.delta_new = 4, .timestamp = 40};
+
+static struct bt_mesh_time_status expected_status;
+static uint32_t time_status_rx_number;
+static bool is_randomized;
+static bool is_unsolicited;
+
+static void tc_setup(void *f)
+{
+ struct bt_mesh_time_tai tai;
+ struct tm start_tm = {
+ /* 1st of Jan 2010 */
+ .tm_year = 110, .tm_mon = 0, .tm_mday = 1, .tm_wday = 5,
+ .tm_hour = 0, .tm_min = 0, .tm_sec = 0,
+ };
+
+ time_status_rx_number = 0;
+ zassert_not_null(_bt_mesh_time_srv_cb.init, "Init cb is null");
+ _bt_mesh_time_srv_cb.init(mock_elem[0].models);
+
+ bt_mesh_time_srv_time_zone_change_set(&time_srv, &zone_change);
+ bt_mesh_time_srv_tai_utc_change_set(&time_srv, &tai_utc_change);
+ bt_mesh_time_srv_role_set(&time_srv, BT_MESH_TIME_RELAY);
+
+ zassert_ok(ts_to_tai(&tai, &start_tm), "cannot convert tai time");
+ time_srv.data.sync.uptime = k_uptime_get();
+ time_srv.data.sync.status.tai = tai;
+}
+
+static void tc_teardown(void *f)
+{
+ zassert_not_null(_bt_mesh_time_srv_cb.reset, "Reset cb is null");
+ _bt_mesh_time_srv_cb.reset(mock_elem[0].models);
+}
+
+int bt_mesh_model_extend(struct bt_mesh_model *extending_mod, struct bt_mesh_model *base_mod)
+{
+ return 0;
+}
+
+void bt_mesh_model_msg_init(struct net_buf_simple *msg, uint32_t opcode)
+{
+}
+
+int bt_mesh_msg_send(struct bt_mesh_model *model, struct bt_mesh_msg_ctx *ctx,
+ struct net_buf_simple *buf)
+{
+ struct bt_mesh_time_status status;
+ uint64_t expected_uncertity =
+ (expected_status.uncertainty + CONFIG_BT_MESH_TIME_MESH_HOP_UNCERTAINTY) /
+ UNCERTAINTY_STEP_MS;
+ int64_t steps =
+ (SUBSEC_STEPS * (k_uptime_get() - time_srv.data.sync.uptime)) / MSEC_PER_SEC;
+
+ zassert_equal_ptr(time_srv.model, model);
+
+ if (is_randomized) {
+ zassert_is_null(ctx);
+ } else {
+ if (is_unsolicited) {
+ zassert_is_null(ctx);
+ } else {
+ zassert_not_null(ctx);
+ }
+ is_unsolicited = !is_unsolicited;
+ }
+
+ bt_mesh_time_decode_time_params(buf, &status);
+
+ zassert_equal(status.tai.sec, expected_status.tai.sec);
+ zassert_equal(status.tai.subsec, expected_status.tai.subsec + steps);
+ zassert_equal(status.tai_utc_delta, expected_status.tai_utc_delta);
+ zassert_equal(status.is_authority, expected_status.is_authority);
+ zassert_equal(status.time_zone_offset, expected_status.time_zone_offset);
+
+ if (is_randomized) {
+ zassert_between_inclusive(status.uncertainty,
+ expected_uncertity * UNCERTAINTY_STEP_MS + 20,
+ expected_uncertity * UNCERTAINTY_STEP_MS + 50);
+ } else {
+ zassert_equal(status.uncertainty, expected_uncertity * UNCERTAINTY_STEP_MS);
+ }
+
+ time_status_rx_number++;
+
+ return 0;
+}
+
+int bt_mesh_model_send(struct bt_mesh_model *model, struct bt_mesh_msg_ctx *ctx,
+ struct net_buf_simple *msg, const struct bt_mesh_send_cb *cb, void *cb_data)
+{
+ return 0;
+}
+
+int bt_rand(void *buf, size_t len)
+{
+ sys_rand_get(buf, len);
+ return 0;
+}
+
+static void rx_time_status(void)
+{
+ /* Create a time status */
+ BT_MESH_MODEL_BUF_DEFINE(msg, BT_MESH_TIME_OP_TIME_STATUS,
+ BT_MESH_TIME_MSG_MAXLEN_TIME_STATUS);
+ bt_mesh_time_srv_status(&time_srv, k_uptime_get(), &expected_status);
+ bt_mesh_time_encode_time_params(&msg, &expected_status);
+
+ _bt_mesh_time_srv_op[1].func(time_srv.model, &test_ctx, &msg);
+
+ k_sleep(K_SECONDS(1));
+}
+
+static void rx_time_set(void)
+{
+ /* Create a time set */
+ BT_MESH_MODEL_BUF_DEFINE(msg, BT_MESH_TIME_OP_TIME_SET, BT_MESH_TIME_MSG_LEN_TIME_SET);
+ bt_mesh_time_srv_status(&time_srv, k_uptime_get(), &expected_status);
+ bt_mesh_time_encode_time_params(&msg, &expected_status);
+
+ _bt_mesh_time_setup_srv_op[0].func(time_srv.model, &test_ctx, &msg);
+
+ k_sleep(K_SECONDS(1));
+}
+
+/** Test scenario: Time Relay receives Time Status every second
+ * during 100 seconds. Expectation: device will relay only 4 Time Statuses
+ * with randomization.
+ */
+ZTEST(time_model, test_time_status_timing)
+{
+ int64_t start_time = k_uptime_get();
+
+ is_randomized = true;
+
+ while (k_uptime_get() - start_time < TEST_TIME) {
+ rx_time_status();
+ }
+
+ zassert_equal(TEST_TIME / STATUS_INTERVAL_MIN + 1, time_status_rx_number);
+}
+
+/** Test scenario: Time Relay receives Time Set every second
+ * during 100 seconds. Expectation: device will publish Time Status with publication settings
+ * and response Time Status to sender every received Time Set message without randomization.
+ */
+ZTEST(time_model, test_time_set_timing)
+{
+ int64_t start_time = k_uptime_get();
+
+ is_randomized = false;
+ is_unsolicited = true;
+
+ while (k_uptime_get() - start_time < TEST_TIME) {
+ rx_time_set();
+ }
+
+ zassert_equal(2 * TEST_TIME / 1000, time_status_rx_number);
+}
+
+/** Test scenario: Time Relay receives Time Status once. Then it receives Time Set and then
+ * it receives Time Status very second during 100 seconds.
+ * Expectation: previously received Time Status doesn't impact on Time Set replies both
+ * publishing and response. However, Time Set published reply triggers 30 seconds delay
+ * for next Time Status handler (Time Relay relays only 3 Time Statuses instead of 4).
+ */
+ZTEST(time_model, test_time_set_status_mix)
+{
+ is_randomized = true;
+
+ rx_time_status();
+ zassert_equal(1, time_status_rx_number);
+
+ is_randomized = false;
+ is_unsolicited = true;
+ time_status_rx_number = 0;
+
+ rx_time_set();
+ zassert_equal(2, time_status_rx_number);
+
+ int64_t start_time = k_uptime_get();
+
+ is_randomized = true;
+ time_status_rx_number = 0;
+
+ while (k_uptime_get() - start_time < TEST_TIME) {
+ rx_time_status();
+ }
+
+ zassert_equal(TEST_TIME / STATUS_INTERVAL_MIN, time_status_rx_number);
+}
+
+/** Test scenario: Time Relay publishes Time Status over periodic publishing handler.
+ * Then it receives Time Status every second during 100 seconds.
+ * Expectation: preiodic publishing triggers 30 seconds delay and device relays
+ * 3 statuses instead of 4.
+ */
+ZTEST(time_model, test_time_periodic_pub_status_mix)
+{
+ zassert_ok(_bt_mesh_time_srv_update_handler(mock_elem[0].models));
+
+ int64_t start_time = k_uptime_get();
+
+ is_randomized = true;
+
+ while (k_uptime_get() - start_time < TEST_TIME) {
+ rx_time_status();
+ }
+
+ zassert_equal(TEST_TIME / STATUS_INTERVAL_MIN, time_status_rx_number);
+}
+
+ZTEST_SUITE(time_model, NULL, NULL, tc_setup, tc_teardown, NULL);

tests/subsys/bluetooth/mesh/time_model/testcase.yaml

@@ -0,0 +1,6 @@
+tests:
+ bluetooth.mesh.time_model:
+ platform_allow: native_posix
+ tags: bluetooth ci_build
+ integration_platforms:
+ - native_posix