| /* |
| * Copyright (c) 2022 Nordic Semiconductor ASA |
| * |
| * SPDX-License-Identifier: Apache-2.0 |
| */ |
| |
| #include <zephyr/kernel.h> |
| #include <zephyr/ztest.h> |
| |
| #include "lwm2m_engine.h" |
| #include "lwm2m_rw_json.h" |
| |
| #define TEST_OBJ_ID 0xFFFF |
| #define TEST_OBJ_INST_ID 0 |
| |
| #define TEST_RES_S8 0 |
| #define TEST_RES_S16 1 |
| #define TEST_RES_S32 2 |
| #define TEST_RES_S64 3 |
| #define TEST_RES_STRING 4 |
| #define TEST_RES_FLOAT 5 |
| #define TEST_RES_BOOL 6 |
| #define TEST_RES_OBJLNK 7 |
| |
| #define TEST_OBJ_RES_MAX_ID 8 |
| |
| static struct lwm2m_engine_obj test_obj; |
| |
| static struct lwm2m_engine_obj_field test_fields[] = { |
| OBJ_FIELD_DATA(TEST_RES_S8, RW, S8), |
| OBJ_FIELD_DATA(TEST_RES_S16, RW, S16), |
| OBJ_FIELD_DATA(TEST_RES_S32, RW, S32), |
| OBJ_FIELD_DATA(TEST_RES_S64, RW, S64), |
| OBJ_FIELD_DATA(TEST_RES_STRING, RW, STRING), |
| OBJ_FIELD_DATA(TEST_RES_FLOAT, RW, FLOAT), |
| OBJ_FIELD_DATA(TEST_RES_BOOL, RW, BOOL), |
| OBJ_FIELD_DATA(TEST_RES_OBJLNK, RW, OBJLNK), |
| }; |
| |
| static struct lwm2m_engine_obj_inst test_inst; |
| static struct lwm2m_engine_res test_res[TEST_OBJ_RES_MAX_ID]; |
| static struct lwm2m_engine_res_inst test_res_inst[TEST_OBJ_RES_MAX_ID]; |
| |
| #define TEST_STRING_MAX_SIZE 16 |
| |
| static int8_t test_s8; |
| static int16_t test_s16; |
| static int32_t test_s32; |
| static int64_t test_s64; |
| static char test_string[TEST_STRING_MAX_SIZE]; |
| static double test_float; |
| static bool test_bool; |
| static struct lwm2m_objlnk test_objlnk; |
| |
| static struct lwm2m_engine_obj_inst *test_obj_create(uint16_t obj_inst_id) |
| { |
| int i = 0, j = 0; |
| |
| init_res_instance(test_res_inst, ARRAY_SIZE(test_res_inst)); |
| |
| INIT_OBJ_RES_DATA(TEST_RES_S8, test_res, i, test_res_inst, j, |
| &test_s8, sizeof(test_s8)); |
| INIT_OBJ_RES_DATA(TEST_RES_S16, test_res, i, test_res_inst, j, |
| &test_s16, sizeof(test_s16)); |
| INIT_OBJ_RES_DATA(TEST_RES_S32, test_res, i, test_res_inst, j, |
| &test_s32, sizeof(test_s32)); |
| INIT_OBJ_RES_DATA(TEST_RES_S64, test_res, i, test_res_inst, j, |
| &test_s64, sizeof(test_s64)); |
| INIT_OBJ_RES_DATA(TEST_RES_STRING, test_res, i, test_res_inst, j, |
| &test_string, sizeof(test_string)); |
| INIT_OBJ_RES_DATA(TEST_RES_FLOAT, test_res, i, test_res_inst, j, |
| &test_float, sizeof(test_float)); |
| INIT_OBJ_RES_DATA(TEST_RES_BOOL, test_res, i, test_res_inst, j, |
| &test_bool, sizeof(test_bool)); |
| INIT_OBJ_RES_DATA(TEST_RES_OBJLNK, test_res, i, test_res_inst, j, |
| &test_objlnk, sizeof(test_objlnk)); |
| |
| test_inst.resources = test_res; |
| test_inst.resource_count = i; |
| |
| return &test_inst; |
| } |
| |
| static void *test_obj_init(void) |
| { |
| struct lwm2m_engine_obj_inst *obj_inst = NULL; |
| |
| test_obj.obj_id = TEST_OBJ_ID; |
| test_obj.version_major = 1; |
| test_obj.version_minor = 0; |
| test_obj.is_core = false; |
| test_obj.fields = test_fields; |
| test_obj.field_count = ARRAY_SIZE(test_fields); |
| test_obj.max_instance_count = 1U; |
| test_obj.create_cb = test_obj_create; |
| |
| (void)lwm2m_register_obj(&test_obj); |
| (void)lwm2m_create_obj_inst(TEST_OBJ_ID, TEST_OBJ_INST_ID, &obj_inst); |
| return NULL; |
| } |
| |
| |
| /* 2 bytes for Content Format option + payload marker */ |
| #define TEST_PAYLOAD_OFFSET 3 |
| #define TEST_PAYLOAD(res_id, type, value) \ |
| "{\"bn\":\"/65535/0/\",\"e\":[{\"n\":\"" STRINGIFY(res_id) \ |
| "\",\"" type "\":" value "}]}" |
| |
| static struct lwm2m_message test_msg; |
| |
| static void context_reset(void) |
| { |
| memset(&test_msg, 0, sizeof(test_msg)); |
| |
| test_msg.out.writer = &json_writer; |
| test_msg.out.out_cpkt = &test_msg.cpkt; |
| |
| test_msg.in.reader = &json_reader; |
| test_msg.in.in_cpkt = &test_msg.cpkt; |
| |
| test_msg.path.level = LWM2M_PATH_LEVEL_RESOURCE; |
| test_msg.path.obj_id = TEST_OBJ_ID; |
| test_msg.path.obj_inst_id = TEST_OBJ_INST_ID; |
| |
| test_msg.cpkt.data = test_msg.msg_data; |
| test_msg.cpkt.max_len = sizeof(test_msg.msg_data); |
| } |
| |
| static void test_payload_set(const char *payload) |
| { |
| memcpy(test_msg.msg_data + 1, payload, strlen(payload)); |
| test_msg.cpkt.offset = strlen(payload) + 1; |
| test_msg.in.offset = 1; /* Payload marker */ |
| } |
| |
| static void test_prepare(void *dummy) |
| { |
| ARG_UNUSED(dummy); |
| context_reset(); |
| } |
| |
| static void test_prepare_nomem(void *dummy) |
| { |
| ARG_UNUSED(dummy); |
| context_reset(); |
| |
| /* Leave some space for Content-format option */ |
| test_msg.cpkt.offset = sizeof(test_msg.msg_data) - TEST_PAYLOAD_OFFSET; |
| } |
| |
| static void test_prepare_nodata(void *dummy) |
| { |
| ARG_UNUSED(dummy); |
| context_reset(); |
| } |
| |
| |
| ZTEST(net_content_json, test_put_s8) |
| { |
| int ret; |
| int i; |
| uint16_t offset = 0; |
| int8_t value[] = { 0, INT8_MAX, INT8_MIN }; |
| char * const expected_payload[] = { |
| TEST_PAYLOAD(TEST_RES_S8, "v", "0"), |
| TEST_PAYLOAD(TEST_RES_S8, "v", "127"), |
| TEST_PAYLOAD(TEST_RES_S8, "v", "-128"), |
| }; |
| |
| test_msg.path.res_id = TEST_RES_S8; |
| |
| for (i = 0; i < ARRAY_SIZE(expected_payload); i++) { |
| test_s8 = value[i]; |
| |
| ret = do_read_op_json(&test_msg, COAP_CONTENT_FORMAT_APP_JSON); |
| zassert_true(ret >= 0, "Error reported"); |
| |
| offset += TEST_PAYLOAD_OFFSET; |
| zassert_mem_equal(test_msg.msg_data + offset, |
| expected_payload[i], |
| strlen(expected_payload[i]), |
| "Invalid payload format"); |
| |
| offset += strlen(expected_payload[i]); |
| zassert_equal(test_msg.cpkt.offset, offset, |
| "Invalid packet offset"); |
| } |
| } |
| |
| ZTEST(net_content_json_nomem, test_put_s8_nomem) |
| { |
| int ret; |
| |
| test_msg.path.res_id = TEST_RES_S8; |
| |
| ret = do_read_op_json(&test_msg, COAP_CONTENT_FORMAT_APP_JSON); |
| zassert_equal(ret, -ENOMEM, "Invalid error code returned"); |
| } |
| |
| ZTEST(net_content_json, test_put_s16) |
| { |
| int ret; |
| int i; |
| uint16_t offset = 0; |
| int16_t value[] = { 0, INT16_MAX, INT16_MIN }; |
| char * const expected_payload[] = { |
| TEST_PAYLOAD(TEST_RES_S16, "v", "0"), |
| TEST_PAYLOAD(TEST_RES_S16, "v", "32767"), |
| TEST_PAYLOAD(TEST_RES_S16, "v", "-32768"), |
| }; |
| |
| test_msg.path.res_id = TEST_RES_S16; |
| |
| for (i = 0; i < ARRAY_SIZE(expected_payload); i++) { |
| test_s16 = value[i]; |
| |
| ret = do_read_op_json(&test_msg, COAP_CONTENT_FORMAT_APP_JSON); |
| zassert_true(ret >= 0, "Error reported"); |
| |
| offset += TEST_PAYLOAD_OFFSET; |
| zassert_mem_equal(test_msg.msg_data + offset, |
| expected_payload[i], |
| strlen(expected_payload[i]), |
| "Invalid payload format"); |
| |
| offset += strlen(expected_payload[i]); |
| zassert_equal(test_msg.cpkt.offset, offset, |
| "Invalid packet offset"); |
| } |
| } |
| |
| ZTEST(net_content_json_nomem, test_put_s16_nomem) |
| { |
| int ret; |
| |
| test_msg.path.res_id = TEST_RES_S16; |
| |
| ret = do_read_op_json(&test_msg, COAP_CONTENT_FORMAT_APP_JSON); |
| zassert_equal(ret, -ENOMEM, "Invalid error code returned"); |
| } |
| |
| ZTEST(net_content_json, test_put_s32) |
| { |
| int ret; |
| int i; |
| uint16_t offset = 0; |
| int32_t value[] = { 0, INT32_MAX, INT32_MIN }; |
| char * const expected_payload[] = { |
| TEST_PAYLOAD(TEST_RES_S32, "v", "0"), |
| TEST_PAYLOAD(TEST_RES_S32, "v", "2147483647"), |
| TEST_PAYLOAD(TEST_RES_S32, "v", "-2147483648"), |
| }; |
| |
| test_msg.path.res_id = TEST_RES_S32; |
| |
| for (i = 0; i < ARRAY_SIZE(expected_payload); i++) { |
| test_s32 = value[i]; |
| |
| ret = do_read_op_json(&test_msg, COAP_CONTENT_FORMAT_APP_JSON); |
| zassert_true(ret >= 0, "Error reported"); |
| |
| offset += TEST_PAYLOAD_OFFSET; |
| zassert_mem_equal(test_msg.msg_data + offset, |
| expected_payload[i], |
| strlen(expected_payload[i]), |
| "Invalid payload format"); |
| |
| offset += strlen(expected_payload[i]); |
| zassert_equal(test_msg.cpkt.offset, offset, |
| "Invalid packet offset"); |
| } |
| } |
| |
| ZTEST(net_content_json_nomem, test_put_s32_nomem) |
| { |
| int ret; |
| |
| test_msg.path.res_id = TEST_RES_S32; |
| |
| ret = do_read_op_json(&test_msg, COAP_CONTENT_FORMAT_APP_JSON); |
| zassert_equal(ret, -ENOMEM, "Invalid error code returned"); |
| } |
| |
| ZTEST(net_content_json, test_put_s64) |
| { |
| int ret; |
| int i; |
| uint16_t offset = 0; |
| int64_t value[] = { 0, INT64_MAX, INT64_MIN }; |
| char * const expected_payload[] = { |
| TEST_PAYLOAD(TEST_RES_S64, "v", "0"), |
| TEST_PAYLOAD(TEST_RES_S64, "v", "9223372036854775807"), |
| TEST_PAYLOAD(TEST_RES_S64, "v", "-9223372036854775808"), |
| }; |
| |
| test_msg.path.res_id = TEST_RES_S64; |
| |
| for (i = 0; i < ARRAY_SIZE(expected_payload); i++) { |
| test_s64 = value[i]; |
| |
| ret = do_read_op_json(&test_msg, COAP_CONTENT_FORMAT_APP_JSON); |
| zassert_true(ret >= 0, "Error reported"); |
| |
| offset += TEST_PAYLOAD_OFFSET; |
| zassert_mem_equal(test_msg.msg_data + offset, |
| expected_payload[i], |
| strlen(expected_payload[i]), |
| "Invalid payload format"); |
| |
| offset += strlen(expected_payload[i]); |
| zassert_equal(test_msg.cpkt.offset, offset, |
| "Invalid packet offset"); |
| } |
| } |
| |
| ZTEST(net_content_json_nomem, test_put_s64_nomem) |
| { |
| int ret; |
| |
| test_msg.path.res_id = TEST_RES_S64; |
| |
| ret = do_read_op_json(&test_msg, COAP_CONTENT_FORMAT_APP_JSON); |
| zassert_equal(ret, -ENOMEM, "Invalid error code returned"); |
| } |
| |
| ZTEST(net_content_json, test_put_string) |
| { |
| int ret; |
| const char *expected_payload = |
| TEST_PAYLOAD(TEST_RES_STRING, "sv", "\"test_string\""); |
| |
| strcpy(test_string, "test_string"); |
| test_msg.path.res_id = TEST_RES_STRING; |
| |
| ret = do_read_op_json(&test_msg, COAP_CONTENT_FORMAT_APP_JSON); |
| zassert_true(ret >= 0, "Error reported"); |
| |
| zassert_mem_equal(test_msg.msg_data + TEST_PAYLOAD_OFFSET, |
| expected_payload, strlen(expected_payload), |
| "Invalid payload format"); |
| zassert_equal(test_msg.cpkt.offset, |
| strlen(expected_payload) + TEST_PAYLOAD_OFFSET, |
| "Invalid packet offset"); |
| } |
| |
| ZTEST(net_content_json_nomem, test_put_string_nomem) |
| { |
| int ret; |
| |
| test_msg.path.res_id = TEST_RES_STRING; |
| |
| ret = do_read_op_json(&test_msg, COAP_CONTENT_FORMAT_APP_JSON); |
| zassert_equal(ret, -ENOMEM, "Invalid error code returned"); |
| } |
| |
| ZTEST(net_content_json, test_put_float) |
| { |
| int ret; |
| int i; |
| uint16_t offset = 0; |
| double value[] = { 0., 0.123, -0.987, 3., -10., 2.333, -123.125 }; |
| char * const expected_payload[] = { |
| TEST_PAYLOAD(TEST_RES_FLOAT, "v", "0.0"), |
| TEST_PAYLOAD(TEST_RES_FLOAT, "v", "0.123"), |
| TEST_PAYLOAD(TEST_RES_FLOAT, "v", "-0.987"), |
| TEST_PAYLOAD(TEST_RES_FLOAT, "v", "3.0"), |
| TEST_PAYLOAD(TEST_RES_FLOAT, "v", "-10.0"), |
| TEST_PAYLOAD(TEST_RES_FLOAT, "v", "2.333"), |
| TEST_PAYLOAD(TEST_RES_FLOAT, "v", "-123.125"), |
| }; |
| |
| test_msg.path.res_id = TEST_RES_FLOAT; |
| |
| for (i = 0; i < ARRAY_SIZE(expected_payload); i++) { |
| test_float = value[i]; |
| |
| ret = do_read_op_json(&test_msg, COAP_CONTENT_FORMAT_APP_JSON); |
| zassert_true(ret >= 0, "Error reported"); |
| |
| offset += TEST_PAYLOAD_OFFSET; |
| zassert_mem_equal(test_msg.msg_data + offset, |
| expected_payload[i], |
| strlen(expected_payload[i]), |
| "Invalid payload format"); |
| |
| offset += strlen(expected_payload[i]); |
| zassert_equal(test_msg.cpkt.offset, offset, |
| "Invalid packet offset"); |
| } |
| } |
| |
| ZTEST(net_content_json_nomem, test_put_float_nomem) |
| { |
| int ret; |
| |
| test_msg.path.res_id = TEST_RES_FLOAT; |
| |
| ret = do_read_op_json(&test_msg, COAP_CONTENT_FORMAT_APP_JSON); |
| zassert_equal(ret, -ENOMEM, "Invalid error code returned"); |
| } |
| |
| ZTEST(net_content_json, test_put_bool) |
| { |
| int ret; |
| int i; |
| uint16_t offset = 0; |
| bool value[] = { true, false }; |
| char * const expected_payload[] = { |
| TEST_PAYLOAD(TEST_RES_BOOL, "bv", "true"), |
| TEST_PAYLOAD(TEST_RES_BOOL, "bv", "false"), |
| }; |
| |
| test_msg.path.res_id = TEST_RES_BOOL; |
| |
| for (i = 0; i < ARRAY_SIZE(expected_payload); i++) { |
| test_bool = value[i]; |
| |
| ret = do_read_op_json(&test_msg, COAP_CONTENT_FORMAT_APP_JSON); |
| zassert_true(ret >= 0, "Error reported"); |
| |
| offset += TEST_PAYLOAD_OFFSET; |
| zassert_mem_equal(test_msg.msg_data + offset, |
| expected_payload[i], |
| strlen(expected_payload[i]), |
| "Invalid payload format"); |
| |
| offset += strlen(expected_payload[i]); |
| zassert_equal(test_msg.cpkt.offset, offset, |
| "Invalid packet offset"); |
| } |
| } |
| |
| ZTEST(net_content_json_nomem, test_put_bool_nomem) |
| { |
| int ret; |
| |
| test_msg.path.res_id = TEST_RES_BOOL; |
| |
| ret = do_read_op_json(&test_msg, COAP_CONTENT_FORMAT_APP_JSON); |
| zassert_equal(ret, -ENOMEM, "Invalid error code returned"); |
| } |
| |
| ZTEST(net_content_json, test_put_objlnk) |
| { |
| int ret; |
| int i; |
| uint16_t offset = 0; |
| struct lwm2m_objlnk value[] = { |
| { 0, 0 }, { 1, 1 }, { LWM2M_OBJLNK_MAX_ID, LWM2M_OBJLNK_MAX_ID } |
| }; |
| char * const expected_payload[] = { |
| TEST_PAYLOAD(TEST_RES_OBJLNK, "ov", "\"0:0\""), |
| TEST_PAYLOAD(TEST_RES_OBJLNK, "ov", "\"1:1\""), |
| TEST_PAYLOAD(TEST_RES_OBJLNK, "ov", "\"65535:65535\""), |
| }; |
| |
| test_msg.path.res_id = TEST_RES_OBJLNK; |
| |
| for (i = 0; i < ARRAY_SIZE(expected_payload); i++) { |
| test_objlnk = value[i]; |
| |
| ret = do_read_op_json(&test_msg, COAP_CONTENT_FORMAT_APP_JSON); |
| zassert_true(ret >= 0, "Error reported"); |
| |
| offset += TEST_PAYLOAD_OFFSET; |
| zassert_mem_equal(test_msg.msg_data + offset, |
| expected_payload[i], |
| strlen(expected_payload[i]), |
| "Invalid payload format"); |
| |
| offset += strlen(expected_payload[i]); |
| zassert_equal(test_msg.cpkt.offset, offset, |
| "Invalid packet offset"); |
| } |
| } |
| |
| ZTEST(net_content_json_nomem, test_put_objlnk_nomem) |
| { |
| int ret; |
| |
| test_msg.path.res_id = TEST_RES_OBJLNK; |
| |
| ret = do_read_op_json(&test_msg, COAP_CONTENT_FORMAT_APP_JSON); |
| zassert_equal(ret, -ENOMEM, "Invalid error code returned"); |
| } |
| |
| ZTEST(net_content_json, test_get_s32) |
| { |
| int ret; |
| int i; |
| char * const payload[] = { |
| TEST_PAYLOAD(TEST_RES_S32, "v", "0"), |
| TEST_PAYLOAD(TEST_RES_S32, "v", "2147483647"), |
| TEST_PAYLOAD(TEST_RES_S32, "v", "-2147483648"), |
| }; |
| int32_t expected_value[] = { 0, INT32_MAX, INT32_MIN }; |
| |
| test_msg.path.res_id = TEST_RES_S32; |
| |
| for (i = 0; i < ARRAY_SIZE(expected_value); i++) { |
| test_payload_set(payload[i]); |
| |
| ret = do_write_op_json(&test_msg); |
| zassert_true(ret >= 0, "Error reported"); |
| zassert_equal(test_s32, expected_value[i], "Invalid value parsed"); |
| } |
| } |
| |
| ZTEST(net_content_json_nomem, test_get_s32_nodata) |
| { |
| int ret; |
| |
| test_msg.path.res_id = TEST_RES_S32; |
| |
| ret = do_write_op_json(&test_msg); |
| zassert_equal(ret, -EINVAL, "Invalid error code returned"); |
| } |
| |
| ZTEST(net_content_json, test_get_s64) |
| { |
| int ret; |
| int i; |
| char * const payload[] = { |
| TEST_PAYLOAD(TEST_RES_S64, "v", "0"), |
| TEST_PAYLOAD(TEST_RES_S64, "v", "9223372036854775807"), |
| TEST_PAYLOAD(TEST_RES_S64, "v", "-9223372036854775808"), |
| }; |
| int64_t expected_value[] = { 0, INT64_MAX, INT64_MIN }; |
| |
| test_msg.path.res_id = TEST_RES_S64; |
| |
| for (i = 0; i < ARRAY_SIZE(expected_value); i++) { |
| test_payload_set(payload[i]); |
| |
| ret = do_write_op_json(&test_msg); |
| zassert_true(ret >= 0, "Error reported"); |
| zassert_equal(test_s64, expected_value[i], "Invalid value parsed"); |
| } |
| } |
| |
| ZTEST(net_content_json_nodata, test_get_s64_nodata) |
| { |
| int ret; |
| |
| test_msg.path.res_id = TEST_RES_S64; |
| |
| ret = do_write_op_json(&test_msg); |
| zassert_equal(ret, -EINVAL, "Invalid error code returned"); |
| } |
| |
| ZTEST(net_content_json, test_get_string) |
| { |
| int ret; |
| const char *payload = |
| TEST_PAYLOAD(TEST_RES_STRING, "sv", "\"test_string\""); |
| const char *expected_value = "test_string"; |
| |
| test_msg.path.res_id = TEST_RES_STRING; |
| |
| test_payload_set(payload); |
| |
| ret = do_write_op_json(&test_msg); |
| zassert_true(ret >= 0, "Error reported"); |
| zassert_mem_equal(test_string, expected_value, strlen(expected_value), |
| "Invalid value parsed"); |
| } |
| |
| ZTEST(net_content_json_nodata, test_get_string_nodata) |
| { |
| int ret; |
| |
| test_msg.path.res_id = TEST_RES_STRING; |
| |
| ret = do_write_op_json(&test_msg); |
| zassert_equal(ret, -EINVAL, "Invalid error code returned"); |
| } |
| |
| #define DOUBLE_CMP_EPSILON 0.000000001 |
| |
| ZTEST(net_content_json, test_get_float) |
| { |
| int ret; |
| int i; |
| char * const payload[] = { |
| TEST_PAYLOAD(TEST_RES_FLOAT, "v", "0.0"), |
| TEST_PAYLOAD(TEST_RES_FLOAT, "v", "0.123"), |
| TEST_PAYLOAD(TEST_RES_FLOAT, "v", "-0.987"), |
| TEST_PAYLOAD(TEST_RES_FLOAT, "v", "3.0"), |
| TEST_PAYLOAD(TEST_RES_FLOAT, "v", "-10.0"), |
| TEST_PAYLOAD(TEST_RES_FLOAT, "v", "2.333"), |
| TEST_PAYLOAD(TEST_RES_FLOAT, "v", "-123.125"), |
| }; |
| double expected_value[] = { |
| 0., 0.123, -0.987, 3., -10., 2.333, -123.125 |
| }; |
| |
| test_msg.path.res_id = TEST_RES_FLOAT; |
| |
| for (i = 0; i < ARRAY_SIZE(expected_value); i++) { |
| test_payload_set(payload[i]); |
| |
| ret = do_write_op_json(&test_msg); |
| zassert_true(ret >= 0, "Error reported"); |
| zassert_true((test_float > expected_value[i] - DOUBLE_CMP_EPSILON) && |
| (test_float < expected_value[i] + DOUBLE_CMP_EPSILON), |
| "Invalid value parsed"); |
| } |
| } |
| |
| ZTEST(net_content_json_nodata, test_get_float_nodata) |
| { |
| int ret; |
| |
| test_msg.path.res_id = TEST_RES_FLOAT; |
| |
| ret = do_write_op_json(&test_msg); |
| zassert_equal(ret, -EINVAL, "Invalid error code returned"); |
| } |
| |
| ZTEST(net_content_json, test_get_bool) |
| { |
| int ret; |
| int i; |
| char * const payload[] = { |
| TEST_PAYLOAD(TEST_RES_BOOL, "bv", "true"), |
| TEST_PAYLOAD(TEST_RES_BOOL, "bv", "false"), |
| }; |
| bool expected_value[] = { true, false }; |
| |
| test_msg.path.res_id = TEST_RES_BOOL; |
| |
| for (i = 0; i < ARRAY_SIZE(expected_value); i++) { |
| test_payload_set(payload[i]); |
| |
| ret = do_write_op_json(&test_msg); |
| zassert_true(ret >= 0, "Error reported"); |
| zassert_equal(test_bool, expected_value[i], "Invalid value parsed"); |
| } |
| } |
| |
| ZTEST(net_content_json_nodata, test_get_bool_nodata) |
| { |
| int ret; |
| |
| test_msg.path.res_id = TEST_RES_BOOL; |
| |
| ret = do_write_op_json(&test_msg); |
| zassert_equal(ret, -EINVAL, "Invalid error code returned"); |
| } |
| |
| ZTEST(net_content_json, test_get_objlnk) |
| { |
| int ret; |
| int i; |
| char * const payload[] = { |
| TEST_PAYLOAD(TEST_RES_OBJLNK, "ov", "\"0:0\""), |
| TEST_PAYLOAD(TEST_RES_OBJLNK, "ov", "\"1:1\""), |
| TEST_PAYLOAD(TEST_RES_OBJLNK, "ov", "\"65535:65535\""), |
| }; |
| struct lwm2m_objlnk expected_value[] = { |
| { 0, 0 }, { 1, 1 }, { LWM2M_OBJLNK_MAX_ID, LWM2M_OBJLNK_MAX_ID } |
| }; |
| |
| test_msg.path.res_id = TEST_RES_OBJLNK; |
| |
| for (i = 0; i < ARRAY_SIZE(expected_value); i++) { |
| test_payload_set(payload[i]); |
| |
| ret = do_write_op_json(&test_msg); |
| zassert_true(ret >= 0, "Error reported"); |
| zassert_mem_equal(&test_objlnk, &expected_value[i], |
| sizeof(test_objlnk), "Invalid value parsed"); |
| } |
| } |
| |
| ZTEST(net_content_json_nodata, test_get_objlnk_nodata) |
| { |
| int ret; |
| |
| test_msg.path.res_id = TEST_RES_OBJLNK; |
| |
| ret = do_write_op_json(&test_msg); |
| zassert_equal(ret, -EINVAL, "Invalid error code returned"); |
| } |
| |
| ZTEST_SUITE(net_content_json, NULL, test_obj_init, test_prepare, NULL, NULL); |
| ZTEST_SUITE(net_content_json_nomem, NULL, test_obj_init, test_prepare_nomem, NULL, NULL); |
| ZTEST_SUITE(net_content_json_nodata, NULL, test_obj_init, test_prepare_nodata, NULL, NULL); |