/* * Copyright (c) 2022 Nordic Semiconductor ASA * Copyright (c) 2023 Jamie M. * * SPDX-License-Identifier: Apache-2.0 */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include "smp_test_util.h" #define SMP_RESPONSE_WAIT_TIME 3 #define ZCBOR_BUFFER_SIZE 256 #define OUTPUT_BUFFER_SIZE 256 #define ZCBOR_HISTORY_ARRAY_SIZE 4 /* Test sets */ enum { OS_MGMT_DATETIME_TEST_SET_TIME_NOT_SET = 0, OS_MGMT_DATETIME_TEST_SET_TIME_SET, #ifdef CONFIG_MCUMGR_GRP_OS_DATETIME_HOOK OS_MGMT_DATETIME_TEST_SET_HOOKS, #endif OS_MGMT_DATETIME_TEST_SET_COUNT }; static struct net_buf *nb; struct state { uint8_t test_set; }; static struct state test_state = { .test_set = 0, }; static struct rtc_time valid_time = { .tm_sec = 13, .tm_min = 40, .tm_hour = 4, .tm_mday = 4, .tm_mon = 8, .tm_year = 2023, }; static struct rtc_time valid_time2 = { .tm_sec = 5, .tm_min = 4, .tm_hour = 3, .tm_mday = 2, .tm_mon = 1, .tm_year = 2001, }; static const char valid_time_string[] = "2023-08-04T04:40:13"; static const char valid_time2_string[] = "2001-01-02T03:04:05"; static const char invalid_time_string[] = "abcdefghij"; static const char invalid_time2_string[] = "20a1-b1-aTbb:dd:qq"; static const char invalid_time3_string[] = "1820-01-02T03:04:05"; struct group_error { uint16_t group; uint16_t rc; bool found; }; #ifdef CONFIG_MCUMGR_GRP_OS_DATETIME_HOOK static bool hook_get_ran; static bool hook_set_ran; static bool hook_other_ran; static uint8_t hook_set_data_size; static uint8_t hook_set_data[64]; #endif static void cleanup_test(void *p); static bool mcumgr_ret_decode(zcbor_state_t *state, struct group_error *result) { bool ok; size_t decoded; uint32_t tmp_group; uint32_t tmp_rc; struct zcbor_map_decode_key_val output_decode[] = { ZCBOR_MAP_DECODE_KEY_DECODER("group", zcbor_uint32_decode, &tmp_group), ZCBOR_MAP_DECODE_KEY_DECODER("rc", zcbor_uint32_decode, &tmp_rc), }; result->found = false; ok = zcbor_map_decode_bulk(state, output_decode, ARRAY_SIZE(output_decode), &decoded) == 0; if (ok && zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "group") && zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "rc")) { result->group = (uint16_t)tmp_group; result->rc = (uint16_t)tmp_rc; result->found = true; } return ok; } #ifdef CONFIG_MCUMGR_GRP_OS_DATETIME_HOOK static enum mgmt_cb_return os_mgmt_datetime_callback(uint32_t event, enum mgmt_cb_return prev_status, int32_t *rc, uint16_t *group, bool *abort_more, void *data, size_t data_size) { if (event == MGMT_EVT_OP_OS_MGMT_DATETIME_GET) { hook_get_ran = true; *rc = MGMT_ERR_EBUSY; return MGMT_CB_ERROR_RC; } else if (event == MGMT_EVT_OP_OS_MGMT_DATETIME_SET) { hook_set_ran = true; hook_set_data_size = data_size; memcpy(hook_set_data, data, data_size); *rc = MGMT_ERR_EACCESSDENIED; return MGMT_CB_ERROR_RC; } hook_other_ran = true; return MGMT_CB_OK; } static struct mgmt_callback os_datetime_callbacks = { .callback = os_mgmt_datetime_callback, .event_id = (MGMT_EVT_OP_OS_MGMT_DATETIME_GET | MGMT_EVT_OP_OS_MGMT_DATETIME_SET), }; #endif ZTEST(os_mgmt_datetime_not_set, test_datetime_get_not_set_v1) { uint8_t buffer[ZCBOR_BUFFER_SIZE]; uint8_t buffer_out[OUTPUT_BUFFER_SIZE]; bool ok; uint16_t buffer_size; zcbor_state_t zse[ZCBOR_HISTORY_ARRAY_SIZE] = { 0 }; zcbor_state_t zsd[ZCBOR_HISTORY_ARRAY_SIZE] = { 0 }; bool received; struct zcbor_string output = { 0 }; size_t decoded = 0; struct group_error group_error; int rc; struct zcbor_map_decode_key_val output_decode[] = { ZCBOR_MAP_DECODE_KEY_DECODER("datetime", zcbor_tstr_decode, &output), ZCBOR_MAP_DECODE_KEY_DECODER("rc", zcbor_int32_decode, &rc), ZCBOR_MAP_DECODE_KEY_DECODER("err", mcumgr_ret_decode, &group_error), }; memset(buffer, 0, sizeof(buffer)); memset(buffer_out, 0, sizeof(buffer_out)); buffer_size = 0; memset(zse, 0, sizeof(zse)); memset(zsd, 0, sizeof(zsd)); zcbor_new_encode_state(zse, 2, buffer, ARRAY_SIZE(buffer), 0); ok = create_mcumgr_datetime_get_packet(zse, false, buffer, buffer_out, &buffer_size); zassert_true(ok, "Expected packet creation to be successful"); /* Enable dummy SMP backend and ready for usage */ smp_dummy_enable(); smp_dummy_clear_state(); /* Send query command to dummy SMP backend */ (void)smp_dummy_tx_pkt(buffer_out, buffer_size); smp_dummy_add_data(); /* For a short duration to see if response has been received */ received = smp_dummy_wait_for_data(SMP_RESPONSE_WAIT_TIME); zassert_true(received, "Expected to receive data but timed out"); /* Retrieve response buffer and ensure validity */ nb = smp_dummy_get_outgoing(); smp_dummy_disable(); /* Process received data by removing header */ (void)net_buf_pull(nb, sizeof(struct smp_hdr)); zcbor_new_decode_state(zsd, 4, nb->data, nb->len, 1, NULL, 0); ok = zcbor_map_decode_bulk(zsd, output_decode, ARRAY_SIZE(output_decode), &decoded) == 0; zassert_true(ok, "Expected decode to be successful"); zassert_equal(decoded, 1, "Expected to receive 1 decoded zcbor element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "datetime"), "Did not expect to receive datetime element"); zassert_true(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "rc"), "Did not expect to receive rc element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "err"), "Expected to receive err element"); zassert_equal(rc, MGMT_ERR_ENOENT, "Expected 'rc' to be no entity"); } ZTEST(os_mgmt_datetime_not_set, test_datetime_get_not_set_v2) { uint8_t buffer[ZCBOR_BUFFER_SIZE]; uint8_t buffer_out[OUTPUT_BUFFER_SIZE]; bool ok; uint16_t buffer_size; zcbor_state_t zse[ZCBOR_HISTORY_ARRAY_SIZE] = { 0 }; zcbor_state_t zsd[ZCBOR_HISTORY_ARRAY_SIZE] = { 0 }; bool received; struct zcbor_string output = { 0 }; size_t decoded = 0; struct group_error group_error; int rc; struct zcbor_map_decode_key_val output_decode[] = { ZCBOR_MAP_DECODE_KEY_DECODER("datetime", zcbor_tstr_decode, &output), ZCBOR_MAP_DECODE_KEY_DECODER("rc", zcbor_int32_decode, &rc), ZCBOR_MAP_DECODE_KEY_DECODER("err", mcumgr_ret_decode, &group_error), }; memset(buffer, 0, sizeof(buffer)); memset(buffer_out, 0, sizeof(buffer_out)); buffer_size = 0; memset(zse, 0, sizeof(zse)); memset(zsd, 0, sizeof(zsd)); zcbor_new_encode_state(zse, 2, buffer, ARRAY_SIZE(buffer), 0); ok = create_mcumgr_datetime_get_packet(zse, true, buffer, buffer_out, &buffer_size); zassert_true(ok, "Expected packet creation to be successful"); /* Enable dummy SMP backend and ready for usage */ smp_dummy_enable(); smp_dummy_clear_state(); /* Send query command to dummy SMP backend */ (void)smp_dummy_tx_pkt(buffer_out, buffer_size); smp_dummy_add_data(); /* For a short duration to see if response has been received */ received = smp_dummy_wait_for_data(SMP_RESPONSE_WAIT_TIME); zassert_true(received, "Expected to receive data but timed out"); /* Retrieve response buffer and ensure validity */ nb = smp_dummy_get_outgoing(); smp_dummy_disable(); /* Process received data by removing header */ (void)net_buf_pull(nb, sizeof(struct smp_hdr)); zcbor_new_decode_state(zsd, 4, nb->data, nb->len, 1, NULL, 0); ok = zcbor_map_decode_bulk(zsd, output_decode, ARRAY_SIZE(output_decode), &decoded) == 0; zassert_true(ok, "Expected decode to be successful"); zassert_equal(decoded, 1, "Expected to receive 1 decoded zcbor element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "datetime"), "Did not expect to receive datetime element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "rc"), "Did not expect to receive rc element"); zassert_true(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "err"), "Expected to receive err element"); zassert_equal(group_error.group, MGMT_GROUP_ID_OS, "Expected 'err' -> 'group' to be OS"); zassert_equal(group_error.rc, OS_MGMT_ERR_RTC_NOT_SET, "Expected 'err' -> 'rc' to be RTC not set"); } ZTEST(os_mgmt_datetime_not_set, test_datetime_set_invalid_v1_1) { uint8_t buffer[ZCBOR_BUFFER_SIZE]; uint8_t buffer_out[OUTPUT_BUFFER_SIZE]; bool ok; uint16_t buffer_size; zcbor_state_t zse[ZCBOR_HISTORY_ARRAY_SIZE] = { 0 }; zcbor_state_t zsd[ZCBOR_HISTORY_ARRAY_SIZE] = { 0 }; bool received; struct zcbor_string output = { 0 }; size_t decoded = 0; struct group_error group_error; int rc; struct zcbor_map_decode_key_val output_decode[] = { ZCBOR_MAP_DECODE_KEY_DECODER("datetime", zcbor_tstr_decode, &output), ZCBOR_MAP_DECODE_KEY_DECODER("rc", zcbor_int32_decode, &rc), ZCBOR_MAP_DECODE_KEY_DECODER("err", mcumgr_ret_decode, &group_error), }; memset(buffer, 0, sizeof(buffer)); memset(buffer_out, 0, sizeof(buffer_out)); buffer_size = 0; memset(zse, 0, sizeof(zse)); memset(zsd, 0, sizeof(zsd)); zcbor_new_encode_state(zse, 4, buffer, ARRAY_SIZE(buffer), 0); ok = create_mcumgr_datetime_set_packet_str(zse, false, invalid_time_string, buffer, buffer_out, &buffer_size); zassert_true(ok, "Expected packet creation to be successful"); /* Enable dummy SMP backend and ready for usage */ smp_dummy_enable(); smp_dummy_clear_state(); /* Send query command to dummy SMP backend */ (void)smp_dummy_tx_pkt(buffer_out, buffer_size); smp_dummy_add_data(); /* For a short duration to see if response has been received */ received = smp_dummy_wait_for_data(SMP_RESPONSE_WAIT_TIME); zassert_true(received, "Expected to receive data but timed out"); /* Retrieve response buffer and ensure validity */ nb = smp_dummy_get_outgoing(); smp_dummy_disable(); /* Process received data by removing header */ (void)net_buf_pull(nb, sizeof(struct smp_hdr)); zcbor_new_decode_state(zsd, 4, nb->data, nb->len, 1, NULL, 0); ok = zcbor_map_decode_bulk(zsd, output_decode, ARRAY_SIZE(output_decode), &decoded) == 0; zassert_true(ok, "Expected decode to be successful"); zassert_equal(decoded, 1, "Expected to receive 1 decoded zcbor element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "datetime"), "Did not expect to receive datetime element"); zassert_true(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "rc"), "Expected to receive rc element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "err"), "Did not expect to receive err element"); zassert_equal(rc, MGMT_ERR_EINVAL, "Expected 'rc' to be invalid value"); /* Clean up test */ cleanup_test(NULL); memset(buffer, 0, sizeof(buffer)); memset(buffer_out, 0, sizeof(buffer_out)); buffer_size = 0; memset(zse, 0, sizeof(zse)); memset(zsd, 0, sizeof(zsd)); output_decode[0].found = false; output_decode[1].found = false; output_decode[2].found = false; /* Query time and ensure it is not set */ zcbor_new_encode_state(zse, 2, buffer, ARRAY_SIZE(buffer), 0); ok = create_mcumgr_datetime_get_packet(zse, false, buffer, buffer_out, &buffer_size); zassert_true(ok, "Expected packet creation to be successful"); /* Enable dummy SMP backend and ready for usage */ smp_dummy_enable(); smp_dummy_clear_state(); /* Send query command to dummy SMP backend */ (void)smp_dummy_tx_pkt(buffer_out, buffer_size); smp_dummy_add_data(); /* For a short duration to see if response has been received */ received = smp_dummy_wait_for_data(SMP_RESPONSE_WAIT_TIME); zassert_true(received, "Expected to receive data but timed out"); /* Retrieve response buffer and ensure validity */ nb = smp_dummy_get_outgoing(); smp_dummy_disable(); /* Process received data by removing header */ (void)net_buf_pull(nb, sizeof(struct smp_hdr)); zcbor_new_decode_state(zsd, 4, nb->data, nb->len, 1, NULL, 0); ok = zcbor_map_decode_bulk(zsd, output_decode, ARRAY_SIZE(output_decode), &decoded) == 0; zassert_true(ok, "Expected decode to be successful"); zassert_equal(decoded, 1, "Expected to receive 1 decoded zcbor element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "datetime"), "Did not expect to receive datetime element"); zassert_true(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "rc"), "Did not expect to receive rc element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "err"), "Expected to receive err element"); zassert_equal(rc, MGMT_ERR_ENOENT, "Expected 'rc' to be no entity"); } ZTEST(os_mgmt_datetime_not_set, test_datetime_set_invalid_v1_2) { uint8_t buffer[ZCBOR_BUFFER_SIZE]; uint8_t buffer_out[OUTPUT_BUFFER_SIZE]; bool ok; uint16_t buffer_size; zcbor_state_t zse[ZCBOR_HISTORY_ARRAY_SIZE] = { 0 }; zcbor_state_t zsd[ZCBOR_HISTORY_ARRAY_SIZE] = { 0 }; bool received; struct zcbor_string output = { 0 }; size_t decoded = 0; struct group_error group_error; int rc; struct zcbor_map_decode_key_val output_decode[] = { ZCBOR_MAP_DECODE_KEY_DECODER("datetime", zcbor_tstr_decode, &output), ZCBOR_MAP_DECODE_KEY_DECODER("rc", zcbor_int32_decode, &rc), ZCBOR_MAP_DECODE_KEY_DECODER("err", mcumgr_ret_decode, &group_error), }; memset(buffer, 0, sizeof(buffer)); memset(buffer_out, 0, sizeof(buffer_out)); buffer_size = 0; memset(zse, 0, sizeof(zse)); memset(zsd, 0, sizeof(zsd)); zcbor_new_encode_state(zse, 4, buffer, ARRAY_SIZE(buffer), 0); ok = create_mcumgr_datetime_set_packet_str(zse, false, invalid_time2_string, buffer, buffer_out, &buffer_size); zassert_true(ok, "Expected packet creation to be successful"); /* Enable dummy SMP backend and ready for usage */ smp_dummy_enable(); smp_dummy_clear_state(); /* Send query command to dummy SMP backend */ (void)smp_dummy_tx_pkt(buffer_out, buffer_size); smp_dummy_add_data(); /* For a short duration to see if response has been received */ received = smp_dummy_wait_for_data(SMP_RESPONSE_WAIT_TIME); zassert_true(received, "Expected to receive data but timed out"); /* Retrieve response buffer and ensure validity */ nb = smp_dummy_get_outgoing(); smp_dummy_disable(); /* Process received data by removing header */ (void)net_buf_pull(nb, sizeof(struct smp_hdr)); zcbor_new_decode_state(zsd, 4, nb->data, nb->len, 1, NULL, 0); ok = zcbor_map_decode_bulk(zsd, output_decode, ARRAY_SIZE(output_decode), &decoded) == 0; zassert_true(ok, "Expected decode to be successful"); zassert_equal(decoded, 1, "Expected to receive 1 decoded zcbor element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "datetime"), "Did not expect to receive datetime element"); zassert_true(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "rc"), "Expected to receive rc element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "err"), "Did not expect to receive err element"); zassert_equal(rc, MGMT_ERR_EINVAL, "Expected 'rc' to be invalid value"); /* Clean up test */ cleanup_test(NULL); memset(buffer, 0, sizeof(buffer)); memset(buffer_out, 0, sizeof(buffer_out)); buffer_size = 0; memset(zse, 0, sizeof(zse)); memset(zsd, 0, sizeof(zsd)); output_decode[0].found = false; output_decode[1].found = false; output_decode[2].found = false; /* Query time and ensure it is not set */ zcbor_new_encode_state(zse, 2, buffer, ARRAY_SIZE(buffer), 0); ok = create_mcumgr_datetime_get_packet(zse, false, buffer, buffer_out, &buffer_size); zassert_true(ok, "Expected packet creation to be successful"); /* Enable dummy SMP backend and ready for usage */ smp_dummy_enable(); smp_dummy_clear_state(); /* Send query command to dummy SMP backend */ (void)smp_dummy_tx_pkt(buffer_out, buffer_size); smp_dummy_add_data(); /* For a short duration to see if response has been received */ received = smp_dummy_wait_for_data(SMP_RESPONSE_WAIT_TIME); zassert_true(received, "Expected to receive data but timed out"); /* Retrieve response buffer and ensure validity */ nb = smp_dummy_get_outgoing(); smp_dummy_disable(); /* Process received data by removing header */ (void)net_buf_pull(nb, sizeof(struct smp_hdr)); zcbor_new_decode_state(zsd, 4, nb->data, nb->len, 1, NULL, 0); ok = zcbor_map_decode_bulk(zsd, output_decode, ARRAY_SIZE(output_decode), &decoded) == 0; zassert_true(ok, "Expected decode to be successful"); zassert_equal(decoded, 1, "Expected to receive 1 decoded zcbor element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "datetime"), "Did not expect to receive datetime element"); zassert_true(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "rc"), "Did not expect to receive rc element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "err"), "Expected to receive err element"); zassert_equal(rc, MGMT_ERR_ENOENT, "Expected 'rc' to be no entity"); } ZTEST(os_mgmt_datetime_not_set, test_datetime_set_invalid_v1_3) { uint8_t buffer[ZCBOR_BUFFER_SIZE]; uint8_t buffer_out[OUTPUT_BUFFER_SIZE]; bool ok; uint16_t buffer_size; zcbor_state_t zse[ZCBOR_HISTORY_ARRAY_SIZE] = { 0 }; zcbor_state_t zsd[ZCBOR_HISTORY_ARRAY_SIZE] = { 0 }; bool received; struct zcbor_string output = { 0 }; size_t decoded = 0; struct group_error group_error; int rc; struct zcbor_map_decode_key_val output_decode[] = { ZCBOR_MAP_DECODE_KEY_DECODER("datetime", zcbor_tstr_decode, &output), ZCBOR_MAP_DECODE_KEY_DECODER("rc", zcbor_int32_decode, &rc), ZCBOR_MAP_DECODE_KEY_DECODER("err", mcumgr_ret_decode, &group_error), }; memset(buffer, 0, sizeof(buffer)); memset(buffer_out, 0, sizeof(buffer_out)); buffer_size = 0; memset(zse, 0, sizeof(zse)); memset(zsd, 0, sizeof(zsd)); zcbor_new_encode_state(zse, 4, buffer, ARRAY_SIZE(buffer), 0); ok = create_mcumgr_datetime_set_packet_str(zse, false, invalid_time3_string, buffer, buffer_out, &buffer_size); zassert_true(ok, "Expected packet creation to be successful"); /* Enable dummy SMP backend and ready for usage */ smp_dummy_enable(); smp_dummy_clear_state(); /* Send query command to dummy SMP backend */ (void)smp_dummy_tx_pkt(buffer_out, buffer_size); smp_dummy_add_data(); /* For a short duration to see if response has been received */ received = smp_dummy_wait_for_data(SMP_RESPONSE_WAIT_TIME); zassert_true(received, "Expected to receive data but timed out"); /* Retrieve response buffer and ensure validity */ nb = smp_dummy_get_outgoing(); smp_dummy_disable(); /* Process received data by removing header */ (void)net_buf_pull(nb, sizeof(struct smp_hdr)); zcbor_new_decode_state(zsd, 4, nb->data, nb->len, 1, NULL, 0); ok = zcbor_map_decode_bulk(zsd, output_decode, ARRAY_SIZE(output_decode), &decoded) == 0; zassert_true(ok, "Expected decode to be successful"); zassert_equal(decoded, 1, "Expected to receive 1 decoded zcbor element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "datetime"), "Did not expect to receive datetime element"); zassert_true(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "rc"), "Expected to receive rc element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "err"), "Did not expect to receive err element"); zassert_equal(rc, MGMT_ERR_EINVAL, "Expected 'rc' to be invalid value"); /* Clean up test */ cleanup_test(NULL); memset(buffer, 0, sizeof(buffer)); memset(buffer_out, 0, sizeof(buffer_out)); buffer_size = 0; memset(zse, 0, sizeof(zse)); memset(zsd, 0, sizeof(zsd)); output_decode[0].found = false; output_decode[1].found = false; output_decode[2].found = false; /* Query time and ensure it is not set */ zcbor_new_encode_state(zse, 2, buffer, ARRAY_SIZE(buffer), 0); ok = create_mcumgr_datetime_get_packet(zse, false, buffer, buffer_out, &buffer_size); zassert_true(ok, "Expected packet creation to be successful"); /* Enable dummy SMP backend and ready for usage */ smp_dummy_enable(); smp_dummy_clear_state(); /* Send query command to dummy SMP backend */ (void)smp_dummy_tx_pkt(buffer_out, buffer_size); smp_dummy_add_data(); /* For a short duration to see if response has been received */ received = smp_dummy_wait_for_data(SMP_RESPONSE_WAIT_TIME); zassert_true(received, "Expected to receive data but timed out"); /* Retrieve response buffer and ensure validity */ nb = smp_dummy_get_outgoing(); smp_dummy_disable(); /* Process received data by removing header */ (void)net_buf_pull(nb, sizeof(struct smp_hdr)); zcbor_new_decode_state(zsd, 4, nb->data, nb->len, 1, NULL, 0); ok = zcbor_map_decode_bulk(zsd, output_decode, ARRAY_SIZE(output_decode), &decoded) == 0; zassert_true(ok, "Expected decode to be successful"); zassert_equal(decoded, 1, "Expected to receive 1 decoded zcbor element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "datetime"), "Did not expect to receive datetime element"); zassert_true(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "rc"), "Did not expect to receive rc element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "err"), "Expected to receive err element"); zassert_equal(rc, MGMT_ERR_ENOENT, "Expected 'rc' to be no entity"); } ZTEST(os_mgmt_datetime_not_set, test_datetime_set_invalid_v2_1) { uint8_t buffer[ZCBOR_BUFFER_SIZE]; uint8_t buffer_out[OUTPUT_BUFFER_SIZE]; bool ok; uint16_t buffer_size; zcbor_state_t zse[ZCBOR_HISTORY_ARRAY_SIZE] = { 0 }; zcbor_state_t zsd[ZCBOR_HISTORY_ARRAY_SIZE] = { 0 }; bool received; struct zcbor_string output = { 0 }; size_t decoded = 0; struct group_error group_error; int rc; struct zcbor_map_decode_key_val output_decode[] = { ZCBOR_MAP_DECODE_KEY_DECODER("datetime", zcbor_tstr_decode, &output), ZCBOR_MAP_DECODE_KEY_DECODER("rc", zcbor_int32_decode, &rc), ZCBOR_MAP_DECODE_KEY_DECODER("err", mcumgr_ret_decode, &group_error), }; memset(buffer, 0, sizeof(buffer)); memset(buffer_out, 0, sizeof(buffer_out)); buffer_size = 0; memset(zse, 0, sizeof(zse)); memset(zsd, 0, sizeof(zsd)); zcbor_new_encode_state(zse, 4, buffer, ARRAY_SIZE(buffer), 0); ok = create_mcumgr_datetime_set_packet_str(zse, true, invalid_time2_string, buffer, buffer_out, &buffer_size); zassert_true(ok, "Expected packet creation to be successful"); /* Enable dummy SMP backend and ready for usage */ smp_dummy_enable(); smp_dummy_clear_state(); /* Send query command to dummy SMP backend */ (void)smp_dummy_tx_pkt(buffer_out, buffer_size); smp_dummy_add_data(); /* For a short duration to see if response has been received */ received = smp_dummy_wait_for_data(SMP_RESPONSE_WAIT_TIME); zassert_true(received, "Expected to receive data but timed out"); /* Retrieve response buffer and ensure validity */ nb = smp_dummy_get_outgoing(); smp_dummy_disable(); /* Process received data by removing header */ (void)net_buf_pull(nb, sizeof(struct smp_hdr)); zcbor_new_decode_state(zsd, 4, nb->data, nb->len, 1, NULL, 0); ok = zcbor_map_decode_bulk(zsd, output_decode, ARRAY_SIZE(output_decode), &decoded) == 0; zassert_true(ok, "Expected decode to be successful"); zassert_equal(decoded, 1, "Expected to receive 1 decoded zcbor element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "datetime"), "Did not expect to receive datetime element"); zassert_true(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "rc"), "Expected to receive rc element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "err"), "Did not expect to receive err element"); zassert_equal(rc, MGMT_ERR_EINVAL, "Expected 'rc' to be invalid value"); /* Clean up test */ cleanup_test(NULL); memset(buffer, 0, sizeof(buffer)); memset(buffer_out, 0, sizeof(buffer_out)); buffer_size = 0; memset(zse, 0, sizeof(zse)); memset(zsd, 0, sizeof(zsd)); output_decode[0].found = false; output_decode[1].found = false; output_decode[2].found = false; /* Query time and ensure it is not set */ zcbor_new_encode_state(zse, 2, buffer, ARRAY_SIZE(buffer), 0); ok = create_mcumgr_datetime_get_packet(zse, true, buffer, buffer_out, &buffer_size); zassert_true(ok, "Expected packet creation to be successful"); /* Enable dummy SMP backend and ready for usage */ smp_dummy_enable(); smp_dummy_clear_state(); /* Send query command to dummy SMP backend */ (void)smp_dummy_tx_pkt(buffer_out, buffer_size); smp_dummy_add_data(); /* For a short duration to see if response has been received */ received = smp_dummy_wait_for_data(SMP_RESPONSE_WAIT_TIME); zassert_true(received, "Expected to receive data but timed out"); /* Retrieve response buffer and ensure validity */ nb = smp_dummy_get_outgoing(); smp_dummy_disable(); /* Process received data by removing header */ (void)net_buf_pull(nb, sizeof(struct smp_hdr)); zcbor_new_decode_state(zsd, 4, nb->data, nb->len, 1, NULL, 0); ok = zcbor_map_decode_bulk(zsd, output_decode, ARRAY_SIZE(output_decode), &decoded) == 0; zassert_true(ok, "Expected decode to be successful"); zassert_equal(decoded, 1, "Expected to receive 1 decoded zcbor element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "datetime"), "Did not expect to receive datetime element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "rc"), "Did not expect to receive rc element"); zassert_true(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "err"), "Expected to receive err element"); zassert_equal(group_error.group, MGMT_GROUP_ID_OS, "Expected 'err' -> 'group' to be OS"); zassert_equal(group_error.rc, OS_MGMT_ERR_RTC_NOT_SET, "Expected 'err' -> 'rc' to be RTC not set"); } ZTEST(os_mgmt_datetime_not_set, test_datetime_set_invalid_v2_2) { uint8_t buffer[ZCBOR_BUFFER_SIZE]; uint8_t buffer_out[OUTPUT_BUFFER_SIZE]; bool ok; uint16_t buffer_size; zcbor_state_t zse[ZCBOR_HISTORY_ARRAY_SIZE] = { 0 }; zcbor_state_t zsd[ZCBOR_HISTORY_ARRAY_SIZE] = { 0 }; bool received; struct zcbor_string output = { 0 }; size_t decoded = 0; struct group_error group_error; int rc; struct zcbor_map_decode_key_val output_decode[] = { ZCBOR_MAP_DECODE_KEY_DECODER("datetime", zcbor_tstr_decode, &output), ZCBOR_MAP_DECODE_KEY_DECODER("rc", zcbor_int32_decode, &rc), ZCBOR_MAP_DECODE_KEY_DECODER("err", mcumgr_ret_decode, &group_error), }; memset(buffer, 0, sizeof(buffer)); memset(buffer_out, 0, sizeof(buffer_out)); buffer_size = 0; memset(zse, 0, sizeof(zse)); memset(zsd, 0, sizeof(zsd)); zcbor_new_encode_state(zse, 4, buffer, ARRAY_SIZE(buffer), 0); ok = create_mcumgr_datetime_set_packet_str(zse, true, invalid_time2_string, buffer, buffer_out, &buffer_size); zassert_true(ok, "Expected packet creation to be successful"); /* Enable dummy SMP backend and ready for usage */ smp_dummy_enable(); smp_dummy_clear_state(); /* Send query command to dummy SMP backend */ (void)smp_dummy_tx_pkt(buffer_out, buffer_size); smp_dummy_add_data(); /* For a short duration to see if response has been received */ received = smp_dummy_wait_for_data(SMP_RESPONSE_WAIT_TIME); zassert_true(received, "Expected to receive data but timed out"); /* Retrieve response buffer and ensure validity */ nb = smp_dummy_get_outgoing(); smp_dummy_disable(); /* Process received data by removing header */ (void)net_buf_pull(nb, sizeof(struct smp_hdr)); zcbor_new_decode_state(zsd, 4, nb->data, nb->len, 1, NULL, 0); ok = zcbor_map_decode_bulk(zsd, output_decode, ARRAY_SIZE(output_decode), &decoded) == 0; zassert_true(ok, "Expected decode to be successful"); zassert_equal(decoded, 1, "Expected to receive 1 decoded zcbor element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "datetime"), "Did not expect to receive datetime element"); zassert_true(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "rc"), "Expected to receive rc element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "err"), "Did not expect to receive err element"); zassert_equal(rc, MGMT_ERR_EINVAL, "Expected 'rc' to be invalid value"); /* Clean up test */ cleanup_test(NULL); memset(buffer, 0, sizeof(buffer)); memset(buffer_out, 0, sizeof(buffer_out)); buffer_size = 0; memset(zse, 0, sizeof(zse)); memset(zsd, 0, sizeof(zsd)); output_decode[0].found = false; output_decode[1].found = false; output_decode[2].found = false; /* Query time and ensure it is not set */ zcbor_new_encode_state(zse, 2, buffer, ARRAY_SIZE(buffer), 0); ok = create_mcumgr_datetime_get_packet(zse, true, buffer, buffer_out, &buffer_size); zassert_true(ok, "Expected packet creation to be successful"); /* Enable dummy SMP backend and ready for usage */ smp_dummy_enable(); smp_dummy_clear_state(); /* Send query command to dummy SMP backend */ (void)smp_dummy_tx_pkt(buffer_out, buffer_size); smp_dummy_add_data(); /* For a short duration to see if response has been received */ received = smp_dummy_wait_for_data(SMP_RESPONSE_WAIT_TIME); zassert_true(received, "Expected to receive data but timed out"); /* Retrieve response buffer and ensure validity */ nb = smp_dummy_get_outgoing(); smp_dummy_disable(); /* Process received data by removing header */ (void)net_buf_pull(nb, sizeof(struct smp_hdr)); zcbor_new_decode_state(zsd, 4, nb->data, nb->len, 1, NULL, 0); ok = zcbor_map_decode_bulk(zsd, output_decode, ARRAY_SIZE(output_decode), &decoded) == 0; zassert_true(ok, "Expected decode to be successful"); zassert_equal(decoded, 1, "Expected to receive 1 decoded zcbor element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "datetime"), "Did not expect to receive datetime element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "rc"), "Did not expect to receive rc element"); zassert_true(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "err"), "Expected to receive err element"); zassert_equal(group_error.group, MGMT_GROUP_ID_OS, "Expected 'err' -> 'group' to be OS"); zassert_equal(group_error.rc, OS_MGMT_ERR_RTC_NOT_SET, "Expected 'err' -> 'rc' to be RTC not set"); } ZTEST(os_mgmt_datetime_not_set, test_datetime_set_invalid_v2_3) { uint8_t buffer[ZCBOR_BUFFER_SIZE]; uint8_t buffer_out[OUTPUT_BUFFER_SIZE]; bool ok; uint16_t buffer_size; zcbor_state_t zse[ZCBOR_HISTORY_ARRAY_SIZE] = { 0 }; zcbor_state_t zsd[ZCBOR_HISTORY_ARRAY_SIZE] = { 0 }; bool received; struct zcbor_string output = { 0 }; size_t decoded = 0; struct group_error group_error; int rc; struct zcbor_map_decode_key_val output_decode[] = { ZCBOR_MAP_DECODE_KEY_DECODER("datetime", zcbor_tstr_decode, &output), ZCBOR_MAP_DECODE_KEY_DECODER("rc", zcbor_int32_decode, &rc), ZCBOR_MAP_DECODE_KEY_DECODER("err", mcumgr_ret_decode, &group_error), }; memset(buffer, 0, sizeof(buffer)); memset(buffer_out, 0, sizeof(buffer_out)); buffer_size = 0; memset(zse, 0, sizeof(zse)); memset(zsd, 0, sizeof(zsd)); zcbor_new_encode_state(zse, 4, buffer, ARRAY_SIZE(buffer), 0); ok = create_mcumgr_datetime_set_packet_str(zse, true, invalid_time3_string, buffer, buffer_out, &buffer_size); zassert_true(ok, "Expected packet creation to be successful"); /* Enable dummy SMP backend and ready for usage */ smp_dummy_enable(); smp_dummy_clear_state(); /* Send query command to dummy SMP backend */ (void)smp_dummy_tx_pkt(buffer_out, buffer_size); smp_dummy_add_data(); /* For a short duration to see if response has been received */ received = smp_dummy_wait_for_data(SMP_RESPONSE_WAIT_TIME); zassert_true(received, "Expected to receive data but timed out"); /* Retrieve response buffer and ensure validity */ nb = smp_dummy_get_outgoing(); smp_dummy_disable(); /* Process received data by removing header */ (void)net_buf_pull(nb, sizeof(struct smp_hdr)); zcbor_new_decode_state(zsd, 4, nb->data, nb->len, 1, NULL, 0); ok = zcbor_map_decode_bulk(zsd, output_decode, ARRAY_SIZE(output_decode), &decoded) == 0; zassert_true(ok, "Expected decode to be successful"); zassert_equal(decoded, 1, "Expected to receive 1 decoded zcbor element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "datetime"), "Did not expect to receive datetime element"); zassert_true(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "rc"), "Expected to receive rc element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "err"), "Did not expect to receive err element"); zassert_equal(rc, MGMT_ERR_EINVAL, "Expected 'rc' to be invalid value"); /* Clean up test */ cleanup_test(NULL); memset(buffer, 0, sizeof(buffer)); memset(buffer_out, 0, sizeof(buffer_out)); buffer_size = 0; memset(zse, 0, sizeof(zse)); memset(zsd, 0, sizeof(zsd)); output_decode[0].found = false; output_decode[1].found = false; output_decode[2].found = false; /* Query time and ensure it is not set */ zcbor_new_encode_state(zse, 2, buffer, ARRAY_SIZE(buffer), 0); ok = create_mcumgr_datetime_get_packet(zse, true, buffer, buffer_out, &buffer_size); zassert_true(ok, "Expected packet creation to be successful"); /* Enable dummy SMP backend and ready for usage */ smp_dummy_enable(); smp_dummy_clear_state(); /* Send query command to dummy SMP backend */ (void)smp_dummy_tx_pkt(buffer_out, buffer_size); smp_dummy_add_data(); /* For a short duration to see if response has been received */ received = smp_dummy_wait_for_data(SMP_RESPONSE_WAIT_TIME); zassert_true(received, "Expected to receive data but timed out"); /* Retrieve response buffer and ensure validity */ nb = smp_dummy_get_outgoing(); smp_dummy_disable(); /* Process received data by removing header */ (void)net_buf_pull(nb, sizeof(struct smp_hdr)); zcbor_new_decode_state(zsd, 4, nb->data, nb->len, 1, NULL, 0); ok = zcbor_map_decode_bulk(zsd, output_decode, ARRAY_SIZE(output_decode), &decoded) == 0; zassert_true(ok, "Expected decode to be successful"); zassert_equal(decoded, 1, "Expected to receive 1 decoded zcbor element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "datetime"), "Did not expect to receive datetime element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "rc"), "Did not expect to receive rc element"); zassert_true(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "err"), "Expected to receive err element"); zassert_equal(group_error.group, MGMT_GROUP_ID_OS, "Expected 'err' -> 'group' to be OS"); zassert_equal(group_error.rc, OS_MGMT_ERR_RTC_NOT_SET, "Expected 'err' -> 'rc' to be RTC not set"); } ZTEST(os_mgmt_datetime_set, test_datetime_set_v1) { uint8_t buffer[ZCBOR_BUFFER_SIZE]; uint8_t buffer_out[OUTPUT_BUFFER_SIZE]; bool ok; uint16_t buffer_size; zcbor_state_t zse[ZCBOR_HISTORY_ARRAY_SIZE] = { 0 }; zcbor_state_t zsd[ZCBOR_HISTORY_ARRAY_SIZE] = { 0 }; bool received; struct zcbor_string output = { 0 }; size_t decoded = 0; struct group_error group_error; int rc; struct zcbor_map_decode_key_val output_decode[] = { ZCBOR_MAP_DECODE_KEY_DECODER("datetime", zcbor_tstr_decode, &output), ZCBOR_MAP_DECODE_KEY_DECODER("rc", zcbor_int32_decode, &rc), ZCBOR_MAP_DECODE_KEY_DECODER("err", mcumgr_ret_decode, &group_error), }; memset(buffer, 0, sizeof(buffer)); memset(buffer_out, 0, sizeof(buffer_out)); buffer_size = 0; memset(zse, 0, sizeof(zse)); memset(zsd, 0, sizeof(zsd)); zcbor_new_encode_state(zse, 4, buffer, ARRAY_SIZE(buffer), 0); ok = create_mcumgr_datetime_set_packet(zse, false, &valid_time, buffer, buffer_out, &buffer_size); zassert_true(ok, "Expected packet creation to be successful"); /* Enable dummy SMP backend and ready for usage */ smp_dummy_enable(); smp_dummy_clear_state(); /* Send query command to dummy SMP backend */ (void)smp_dummy_tx_pkt(buffer_out, buffer_size); smp_dummy_add_data(); /* For a short duration to see if response has been received */ received = smp_dummy_wait_for_data(SMP_RESPONSE_WAIT_TIME); zassert_true(received, "Expected to receive data but timed out"); /* Retrieve response buffer and ensure validity */ nb = smp_dummy_get_outgoing(); smp_dummy_disable(); /* Process received data by removing header */ (void)net_buf_pull(nb, sizeof(struct smp_hdr)); zcbor_new_decode_state(zsd, 4, nb->data, nb->len, 1, NULL, 0); ok = zcbor_map_decode_bulk(zsd, output_decode, ARRAY_SIZE(output_decode), &decoded) == 0; zassert_true(ok, "Expected decode to be successful"); zassert_equal(decoded, 0, "Did not expect to receive any decoded zcbor element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "datetime"), "Did not expect to receive datetime element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "rc"), "Did not expect to receive rc element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "err"), "Did not expect to receive err element"); /* Clean up test */ cleanup_test(NULL); memset(buffer, 0, sizeof(buffer)); memset(buffer_out, 0, sizeof(buffer_out)); buffer_size = 0; memset(zse, 0, sizeof(zse)); memset(zsd, 0, sizeof(zsd)); output_decode[0].found = false; output_decode[1].found = false; output_decode[2].found = false; /* Query time and ensure it is set */ zcbor_new_encode_state(zse, 2, buffer, ARRAY_SIZE(buffer), 0); ok = create_mcumgr_datetime_get_packet(zse, false, buffer, buffer_out, &buffer_size); zassert_true(ok, "Expected packet creation to be successful"); /* Enable dummy SMP backend and ready for usage */ smp_dummy_enable(); smp_dummy_clear_state(); /* Send query command to dummy SMP backend */ (void)smp_dummy_tx_pkt(buffer_out, buffer_size); smp_dummy_add_data(); /* For a short duration to see if response has been received */ received = smp_dummy_wait_for_data(SMP_RESPONSE_WAIT_TIME); zassert_true(received, "Expected to receive data but timed out"); /* Retrieve response buffer and ensure validity */ nb = smp_dummy_get_outgoing(); smp_dummy_disable(); /* Process received data by removing header */ (void)net_buf_pull(nb, sizeof(struct smp_hdr)); zcbor_new_decode_state(zsd, 4, nb->data, nb->len, 1, NULL, 0); ok = zcbor_map_decode_bulk(zsd, output_decode, ARRAY_SIZE(output_decode), &decoded) == 0; zassert_true(ok, "Expected decode to be successful"); zassert_equal(decoded, 1, "Expected to receive 1 decoded zcbor element"); zassert_true(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "datetime"), "Expected to receive datetime element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "rc"), "Did not expect to receive rc element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "err"), "Did not expected to receive err element"); /* Check that the date/time is as expected */ zassert_equal(output.len, strlen(valid_time_string), "Expected received datetime length mismatch"); zassert_mem_equal(output.value, valid_time_string, strlen(valid_time_string), "Expected received datetime value mismatch"); } ZTEST(os_mgmt_datetime_set, test_datetime_set_v2) { uint8_t buffer[ZCBOR_BUFFER_SIZE]; uint8_t buffer_out[OUTPUT_BUFFER_SIZE]; bool ok; uint16_t buffer_size; zcbor_state_t zse[ZCBOR_HISTORY_ARRAY_SIZE] = { 0 }; zcbor_state_t zsd[ZCBOR_HISTORY_ARRAY_SIZE] = { 0 }; bool received; struct zcbor_string output = { 0 }; size_t decoded = 0; struct group_error group_error; int rc; struct zcbor_map_decode_key_val output_decode[] = { ZCBOR_MAP_DECODE_KEY_DECODER("datetime", zcbor_tstr_decode, &output), ZCBOR_MAP_DECODE_KEY_DECODER("rc", zcbor_int32_decode, &rc), ZCBOR_MAP_DECODE_KEY_DECODER("err", mcumgr_ret_decode, &group_error), }; memset(buffer, 0, sizeof(buffer)); memset(buffer_out, 0, sizeof(buffer_out)); buffer_size = 0; memset(zse, 0, sizeof(zse)); memset(zsd, 0, sizeof(zsd)); zcbor_new_encode_state(zse, 4, buffer, ARRAY_SIZE(buffer), 0); ok = create_mcumgr_datetime_set_packet(zse, true, &valid_time2, buffer, buffer_out, &buffer_size); zassert_true(ok, "Expected packet creation to be successful"); /* Enable dummy SMP backend and ready for usage */ smp_dummy_enable(); smp_dummy_clear_state(); /* Send query command to dummy SMP backend */ (void)smp_dummy_tx_pkt(buffer_out, buffer_size); smp_dummy_add_data(); /* For a short duration to see if response has been received */ received = smp_dummy_wait_for_data(SMP_RESPONSE_WAIT_TIME); zassert_true(received, "Expected to receive data but timed out"); /* Retrieve response buffer and ensure validity */ nb = smp_dummy_get_outgoing(); smp_dummy_disable(); /* Process received data by removing header */ (void)net_buf_pull(nb, sizeof(struct smp_hdr)); zcbor_new_decode_state(zsd, 4, nb->data, nb->len, 1, NULL, 0); ok = zcbor_map_decode_bulk(zsd, output_decode, ARRAY_SIZE(output_decode), &decoded) == 0; zassert_true(ok, "Expected decode to be successful"); zassert_equal(decoded, 0, "Did not expect to receive any decoded zcbor element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "datetime"), "Did not expect to receive datetime element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "rc"), "Did not expect to receive rc element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "err"), "Did not expect to receive err element"); /* Clean up test */ cleanup_test(NULL); memset(buffer, 0, sizeof(buffer)); memset(buffer_out, 0, sizeof(buffer_out)); buffer_size = 0; memset(zse, 0, sizeof(zse)); memset(zsd, 0, sizeof(zsd)); output_decode[0].found = false; output_decode[1].found = false; output_decode[2].found = false; /* Query time and ensure it is set */ zcbor_new_encode_state(zse, 2, buffer, ARRAY_SIZE(buffer), 0); ok = create_mcumgr_datetime_get_packet(zse, false, buffer, buffer_out, &buffer_size); zassert_true(ok, "Expected packet creation to be successful"); /* Enable dummy SMP backend and ready for usage */ smp_dummy_enable(); smp_dummy_clear_state(); /* Send query command to dummy SMP backend */ (void)smp_dummy_tx_pkt(buffer_out, buffer_size); smp_dummy_add_data(); /* For a short duration to see if response has been received */ received = smp_dummy_wait_for_data(SMP_RESPONSE_WAIT_TIME); zassert_true(received, "Expected to receive data but timed out"); /* Retrieve response buffer and ensure validity */ nb = smp_dummy_get_outgoing(); smp_dummy_disable(); /* Process received data by removing header */ (void)net_buf_pull(nb, sizeof(struct smp_hdr)); zcbor_new_decode_state(zsd, 4, nb->data, nb->len, 1, NULL, 0); ok = zcbor_map_decode_bulk(zsd, output_decode, ARRAY_SIZE(output_decode), &decoded) == 0; zassert_true(ok, "Expected decode to be successful"); zassert_equal(decoded, 1, "Expected to receive 1 decoded zcbor element"); zassert_true(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "datetime"), "Expected to receive datetime element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "rc"), "Did not expect to receive rc element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "err"), "Did not expected to receive err element"); /* Check that the date/time is as expected */ zassert_equal(output.len, strlen(valid_time2_string), "Expected received datetime length mismatch"); zassert_mem_equal(output.value, valid_time2_string, strlen(valid_time2_string), "Expected received datetime value mismatch"); } #ifdef CONFIG_MCUMGR_GRP_OS_DATETIME_HOOK static void *setup_os_datetime_callbacks(void) { mgmt_callback_register(&os_datetime_callbacks); return NULL; } static void destroy_os_datetime_callbacks(void *p) { mgmt_callback_unregister(&os_datetime_callbacks); } ZTEST(os_mgmt_datetime_hook, test_datetime_set_valid_hook_v1) { uint8_t buffer[ZCBOR_BUFFER_SIZE]; uint8_t buffer_out[OUTPUT_BUFFER_SIZE]; bool ok; uint16_t buffer_size; zcbor_state_t zse[ZCBOR_HISTORY_ARRAY_SIZE] = { 0 }; zcbor_state_t zsd[ZCBOR_HISTORY_ARRAY_SIZE] = { 0 }; bool received; struct zcbor_string output = { 0 }; size_t decoded = 0; struct group_error group_error; int rc; struct rtc_time *hook_data; struct zcbor_map_decode_key_val output_decode[] = { ZCBOR_MAP_DECODE_KEY_DECODER("datetime", zcbor_tstr_decode, &output), ZCBOR_MAP_DECODE_KEY_DECODER("rc", zcbor_int32_decode, &rc), ZCBOR_MAP_DECODE_KEY_DECODER("err", mcumgr_ret_decode, &group_error), }; memset(buffer, 0, sizeof(buffer)); memset(buffer_out, 0, sizeof(buffer_out)); buffer_size = 0; memset(zse, 0, sizeof(zse)); memset(zsd, 0, sizeof(zsd)); zcbor_new_encode_state(zse, 4, buffer, ARRAY_SIZE(buffer), 0); ok = create_mcumgr_datetime_set_packet(zse, false, &valid_time2, buffer, buffer_out, &buffer_size); zassert_true(ok, "Expected packet creation to be successful"); /* Enable dummy SMP backend and ready for usage */ smp_dummy_enable(); smp_dummy_clear_state(); /* Send query command to dummy SMP backend */ (void)smp_dummy_tx_pkt(buffer_out, buffer_size); smp_dummy_add_data(); /* For a short duration to see if response has been received */ received = smp_dummy_wait_for_data(SMP_RESPONSE_WAIT_TIME); zassert_true(received, "Expected to receive data but timed out"); /* Retrieve response buffer and ensure validity */ nb = smp_dummy_get_outgoing(); smp_dummy_disable(); /* Process received data by removing header */ (void)net_buf_pull(nb, sizeof(struct smp_hdr)); zcbor_new_decode_state(zsd, 4, nb->data, nb->len, 1, NULL, 0); ok = zcbor_map_decode_bulk(zsd, output_decode, ARRAY_SIZE(output_decode), &decoded) == 0; zassert_true(ok, "Expected decode to be successful"); zassert_equal(decoded, 1, "Expected to receive 1 decoded zcbor element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "datetime"), "Did not expect to receive datetime element"); zassert_true(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "rc"), "Expected to receive rc element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "err"), "Did not expect to receive err element"); zassert_equal(rc, MGMT_ERR_EACCESSDENIED, "Expected 'rc' to be access denied"); /* Check hook actions are as expected */ hook_data = (struct rtc_time *)hook_set_data; zassert_false(hook_get_ran, "Did not expect get hook to run"); zassert_true(hook_set_ran, "Expected set hook to run"); zassert_false(hook_other_ran, "Did not expect other hooks to run"); zassert_equal(hook_set_data_size, sizeof(valid_time2), "Expected data size to match time struct size"); zassert_equal(valid_time2.tm_sec, hook_data->tm_sec, "Expected value mismatch"); zassert_equal(valid_time2.tm_min, hook_data->tm_min, "Expected value mismatch"); zassert_equal(valid_time2.tm_hour, hook_data->tm_hour, "Expected value mismatch"); zassert_equal(valid_time2.tm_mday, hook_data->tm_mday, "Expected value mismatch"); zassert_equal(valid_time2.tm_mon, (hook_data->tm_mon + 1), "Expected value mismatch"); zassert_equal(valid_time2.tm_year, (hook_data->tm_year + 1900), "Expected value mismatch"); /* Clean up test */ cleanup_test(NULL); memset(buffer, 0, sizeof(buffer)); memset(buffer_out, 0, sizeof(buffer_out)); buffer_size = 0; memset(zse, 0, sizeof(zse)); memset(zsd, 0, sizeof(zsd)); output_decode[0].found = false; output_decode[1].found = false; output_decode[2].found = false; /* Query time and ensure it is not set */ zcbor_new_encode_state(zse, 2, buffer, ARRAY_SIZE(buffer), 0); ok = create_mcumgr_datetime_get_packet(zse, false, buffer, buffer_out, &buffer_size); zassert_true(ok, "Expected packet creation to be successful"); /* Enable dummy SMP backend and ready for usage */ smp_dummy_enable(); smp_dummy_clear_state(); /* Send query command to dummy SMP backend */ (void)smp_dummy_tx_pkt(buffer_out, buffer_size); smp_dummy_add_data(); /* For a short duration to see if response has been received */ received = smp_dummy_wait_for_data(SMP_RESPONSE_WAIT_TIME); zassert_true(received, "Expected to receive data but timed out"); /* Retrieve response buffer and ensure validity */ nb = smp_dummy_get_outgoing(); smp_dummy_disable(); /* Process received data by removing header */ (void)net_buf_pull(nb, sizeof(struct smp_hdr)); zcbor_new_decode_state(zsd, 4, nb->data, nb->len, 1, NULL, 0); ok = zcbor_map_decode_bulk(zsd, output_decode, ARRAY_SIZE(output_decode), &decoded) == 0; zassert_true(ok, "Expected decode to be successful"); zassert_equal(decoded, 1, "Expected to receive 1 decoded zcbor element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "datetime"), "Did not expect to receive datetime element"); zassert_true(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "rc"), "Expected to receive rc element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "err"), "Did not expect to receive err element"); zassert_equal(rc, MGMT_ERR_EBUSY, "Expected 'rc' to be busy"); /* Check hook actions are as expected */ zassert_true(hook_get_ran, "Expected get hook to run"); zassert_false(hook_set_ran, "Did not expect set hook to run"); zassert_false(hook_other_ran, "Did not expect other hooks to run"); zassert_equal(hook_set_data_size, 0, "Expected data size to be 0"); } ZTEST(os_mgmt_datetime_hook, test_datetime_set_valid_hook_v2) { uint8_t buffer[ZCBOR_BUFFER_SIZE]; uint8_t buffer_out[OUTPUT_BUFFER_SIZE]; bool ok; uint16_t buffer_size; zcbor_state_t zse[ZCBOR_HISTORY_ARRAY_SIZE] = { 0 }; zcbor_state_t zsd[ZCBOR_HISTORY_ARRAY_SIZE] = { 0 }; bool received; struct zcbor_string output = { 0 }; size_t decoded = 0; struct group_error group_error; int rc; struct rtc_time *hook_data; struct zcbor_map_decode_key_val output_decode[] = { ZCBOR_MAP_DECODE_KEY_DECODER("datetime", zcbor_tstr_decode, &output), ZCBOR_MAP_DECODE_KEY_DECODER("rc", zcbor_int32_decode, &rc), ZCBOR_MAP_DECODE_KEY_DECODER("err", mcumgr_ret_decode, &group_error), }; memset(buffer, 0, sizeof(buffer)); memset(buffer_out, 0, sizeof(buffer_out)); buffer_size = 0; memset(zse, 0, sizeof(zse)); memset(zsd, 0, sizeof(zsd)); zcbor_new_encode_state(zse, 4, buffer, ARRAY_SIZE(buffer), 0); ok = create_mcumgr_datetime_set_packet(zse, true, &valid_time2, buffer, buffer_out, &buffer_size); zassert_true(ok, "Expected packet creation to be successful"); /* Enable dummy SMP backend and ready for usage */ smp_dummy_enable(); smp_dummy_clear_state(); /* Send query command to dummy SMP backend */ (void)smp_dummy_tx_pkt(buffer_out, buffer_size); smp_dummy_add_data(); /* For a short duration to see if response has been received */ received = smp_dummy_wait_for_data(SMP_RESPONSE_WAIT_TIME); zassert_true(received, "Expected to receive data but timed out"); /* Retrieve response buffer and ensure validity */ nb = smp_dummy_get_outgoing(); smp_dummy_disable(); /* Process received data by removing header */ (void)net_buf_pull(nb, sizeof(struct smp_hdr)); zcbor_new_decode_state(zsd, 4, nb->data, nb->len, 1, NULL, 0); ok = zcbor_map_decode_bulk(zsd, output_decode, ARRAY_SIZE(output_decode), &decoded) == 0; zassert_true(ok, "Expected decode to be successful"); zassert_equal(decoded, 1, "Expected to receive 1 decoded zcbor element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "datetime"), "Did not expect to receive datetime element"); zassert_true(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "rc"), "Expected to receive rc element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "err"), "Did not expect to receive err element"); zassert_equal(rc, MGMT_ERR_EACCESSDENIED, "Expected 'rc' to be access denied"); /* Check hook actions are as expected */ hook_data = (struct rtc_time *)hook_set_data; zassert_false(hook_get_ran, "Did not expect get hook to run"); zassert_true(hook_set_ran, "Expected set hook to run"); zassert_false(hook_other_ran, "Did not expect other hooks to run"); zassert_equal(hook_set_data_size, sizeof(valid_time2), "Expected data size to match time struct size"); zassert_equal(valid_time2.tm_sec, hook_data->tm_sec, "Expected value mismatch"); zassert_equal(valid_time2.tm_min, hook_data->tm_min, "Expected value mismatch"); zassert_equal(valid_time2.tm_hour, hook_data->tm_hour, "Expected value mismatch"); zassert_equal(valid_time2.tm_mday, hook_data->tm_mday, "Expected value mismatch"); zassert_equal(valid_time2.tm_mon, (hook_data->tm_mon + 1), "Expected value mismatch"); zassert_equal(valid_time2.tm_year, (hook_data->tm_year + 1900), "Expected value mismatch"); /* Clean up test */ cleanup_test(NULL); memset(buffer, 0, sizeof(buffer)); memset(buffer_out, 0, sizeof(buffer_out)); buffer_size = 0; memset(zse, 0, sizeof(zse)); memset(zsd, 0, sizeof(zsd)); output_decode[0].found = false; output_decode[1].found = false; output_decode[2].found = false; /* Query time and ensure it is not set */ zcbor_new_encode_state(zse, 2, buffer, ARRAY_SIZE(buffer), 0); ok = create_mcumgr_datetime_get_packet(zse, true, buffer, buffer_out, &buffer_size); zassert_true(ok, "Expected packet creation to be successful"); /* Enable dummy SMP backend and ready for usage */ smp_dummy_enable(); smp_dummy_clear_state(); /* Send query command to dummy SMP backend */ (void)smp_dummy_tx_pkt(buffer_out, buffer_size); smp_dummy_add_data(); /* For a short duration to see if response has been received */ received = smp_dummy_wait_for_data(SMP_RESPONSE_WAIT_TIME); zassert_true(received, "Expected to receive data but timed out"); /* Retrieve response buffer and ensure validity */ nb = smp_dummy_get_outgoing(); smp_dummy_disable(); /* Process received data by removing header */ (void)net_buf_pull(nb, sizeof(struct smp_hdr)); zcbor_new_decode_state(zsd, 4, nb->data, nb->len, 1, NULL, 0); ok = zcbor_map_decode_bulk(zsd, output_decode, ARRAY_SIZE(output_decode), &decoded) == 0; zassert_true(ok, "Expected decode to be successful"); zassert_equal(decoded, 1, "Expected to receive 1 decoded zcbor element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "datetime"), "Did not expect to receive datetime element"); zassert_true(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "rc"), "Expected to receive rc element"); zassert_false(zcbor_map_decode_bulk_key_found(output_decode, ARRAY_SIZE(output_decode), "err"), "Did not expect to receive err element"); zassert_equal(rc, MGMT_ERR_EBUSY, "Expected 'rc' to be busy"); /* Check hook actions are as expected */ zassert_true(hook_get_ran, "Expected get hook to run"); zassert_false(hook_set_ran, "Did not expect set hook to run"); zassert_false(hook_other_ran, "Did not expect other hooks to run"); zassert_equal(hook_set_data_size, 0, "Expected data size to be 0"); } #endif static void cleanup_test(void *p) { if (nb != NULL) { net_buf_unref(nb); nb = NULL; } #ifdef CONFIG_MCUMGR_GRP_OS_DATETIME_HOOK hook_get_ran = false; hook_set_ran = false; hook_other_ran = false; hook_set_data_size = 0; hook_set_data[0] = 0; #endif } void test_main(void) { while (test_state.test_set < OS_MGMT_DATETIME_TEST_SET_COUNT) { ztest_run_all(&test_state, false, 1, 1); ++test_state.test_set; } ztest_verify_all_test_suites_ran(); } static bool time_not_set_predicate(const void *state) { return ((struct state *)state)->test_set == OS_MGMT_DATETIME_TEST_SET_TIME_NOT_SET; } static bool time_set_predicate(const void *state) { return ((struct state *)state)->test_set == OS_MGMT_DATETIME_TEST_SET_TIME_SET; } #ifdef CONFIG_MCUMGR_GRP_OS_DATETIME_HOOK static bool hooks_predicate(const void *state) { return ((struct state *)state)->test_set == OS_MGMT_DATETIME_TEST_SET_HOOKS; } #endif /* Time not set test set */ ZTEST_SUITE(os_mgmt_datetime_not_set, time_not_set_predicate, NULL, NULL, cleanup_test, NULL); #ifdef CONFIG_MCUMGR_GRP_OS_DATETIME_HOOK /* Hook test set */ ZTEST_SUITE(os_mgmt_datetime_hook, hooks_predicate, setup_os_datetime_callbacks, NULL, cleanup_test, destroy_os_datetime_callbacks); #endif /* Time set test set */ ZTEST_SUITE(os_mgmt_datetime_set, time_set_predicate, NULL, NULL, cleanup_test, NULL);