| /* |
| * Copyright (c) 2022 Nordic Semiconductor ASA |
| * |
| * SPDX-License-Identifier: Apache-2.0 |
| */ |
| |
| #include <zephyr.h> |
| #include <ztest.h> |
| |
| #include "lwm2m_util.h" |
| #include "lwm2m_rw_cbor.h" |
| |
| #define TEST_MAX_PAYLOAD_BUFFER_LENGTH 40 |
| |
| struct test_payload_buffer { |
| uint8_t data[TEST_MAX_PAYLOAD_BUFFER_LENGTH]; |
| size_t len; |
| }; |
| |
| static struct lwm2m_output_context test_out; |
| static struct lwm2m_input_context test_in; |
| static struct lwm2m_obj_path test_path; |
| static struct coap_packet test_packet; |
| static uint8_t test_payload[128]; |
| |
| static void context_reset(void) |
| { |
| memset(&test_out, 0, sizeof(test_out)); |
| test_out.writer = &cbor_writer; |
| test_out.out_cpkt = &test_packet; |
| |
| memset(&test_in, 0, sizeof(test_in)); |
| test_in.reader = &cbor_reader; |
| test_in.in_cpkt = &test_packet; |
| |
| memset(&test_payload, 0, sizeof(test_payload)); |
| memset(&test_packet, 0, sizeof(test_packet)); |
| test_packet.data = test_payload; |
| test_packet.max_len = sizeof(test_payload); |
| } |
| |
| static void test_prepare(void) |
| { |
| context_reset(); |
| } |
| |
| static void test_prepare_nomem(void) |
| { |
| context_reset(); |
| |
| test_packet.offset = sizeof(test_payload); |
| } |
| |
| static void test_prepare_nodata(void) |
| { |
| context_reset(); |
| |
| test_packet.offset = sizeof(test_payload); |
| test_in.offset = sizeof(test_payload); |
| } |
| |
| static void test_payload_set(const uint8_t *payload, size_t len) |
| { |
| memcpy(test_payload + 1, payload, len); |
| test_packet.offset = len + 1; |
| test_in.offset = 1; /* Payload marker */ |
| } |
| |
| static void test_put_s8(void) |
| { |
| int ret; |
| int i; |
| uint16_t offset = 0; |
| int8_t value[] = { 1, -1, INT8_MAX, INT8_MIN }; |
| struct test_payload_buffer expected_payload[] = { |
| { |
| .data = { |
| (0x00 << 5) | 0x01 |
| }, |
| .len = 1 |
| }, |
| { |
| .data = { |
| (0x01 << 5) | 0x00 |
| }, |
| .len = 1 |
| }, |
| { |
| .data = { |
| (0x00 << 5) | 0x18, |
| 0x7f |
| }, |
| .len = 2 |
| }, |
| { |
| .data = { |
| (0x01 << 5) | 0x18, |
| 0x7f |
| }, |
| .len = 2 |
| } |
| }; |
| |
| for (i = 0; i < ARRAY_SIZE(expected_payload); i++) { |
| ret = cbor_writer.put_s8(&test_out, &test_path, value[i]); |
| zassert_equal(ret, expected_payload[i].len, |
| "Invalid length returned"); |
| zassert_mem_equal(test_out.out_cpkt->data + offset, |
| expected_payload[i].data, |
| expected_payload[i].len, |
| "Invalid payload format"); |
| |
| offset += expected_payload[i].len; |
| zassert_equal(test_out.out_cpkt->offset, offset, |
| "Invalid packet offset"); |
| } |
| } |
| |
| static void test_put_s8_nomem(void) |
| { |
| int ret; |
| |
| ret = cbor_writer.put_s8(&test_out, &test_path, INT8_MAX); |
| zassert_equal(ret, -ENOMEM, "Invalid error code returned"); |
| } |
| |
| static void test_put_s16(void) |
| { |
| int ret; |
| int i; |
| uint16_t offset = 0; |
| int16_t value[] = { 1, -1, INT16_MAX, INT16_MIN }; |
| struct test_payload_buffer expected_payload[] = { |
| { |
| .data = { |
| (0x00 << 5) | 0x01 |
| }, |
| .len = 1 |
| }, |
| { |
| .data = { |
| (0x01 << 5) | 0x00 |
| }, |
| .len = 1 |
| }, |
| { |
| .data = { |
| (0x00 << 5) | 0x19, |
| 0x7f, 0xff |
| }, |
| .len = 3 |
| }, |
| { |
| .data = { |
| (0x01 << 5) | 0x19, |
| 0x7f, 0xff |
| }, |
| .len = 3 |
| } |
| }; |
| |
| for (i = 0; i < ARRAY_SIZE(expected_payload); i++) { |
| ret = cbor_writer.put_s16(&test_out, &test_path, value[i]); |
| zassert_equal(ret, expected_payload[i].len, |
| "Invalid length returned"); |
| zassert_mem_equal(test_out.out_cpkt->data + offset, |
| expected_payload[i].data, |
| expected_payload[i].len, |
| "Invalid payload format"); |
| |
| offset += expected_payload[i].len; |
| zassert_equal(test_out.out_cpkt->offset, offset, |
| "Invalid packet offset"); |
| } |
| } |
| |
| static void test_put_s16_nomem(void) |
| { |
| int ret; |
| |
| ret = cbor_writer.put_s16(&test_out, &test_path, INT16_MAX); |
| zassert_equal(ret, -ENOMEM, "Invalid error code returned"); |
| } |
| |
| static void test_put_s32(void) |
| { |
| int ret; |
| int i; |
| uint16_t offset = 0; |
| int32_t value[] = { 1, -1, INT32_MAX, INT32_MIN }; |
| struct test_payload_buffer expected_payload[] = { |
| { |
| .data = { |
| (0x00 << 5) | 0x01 |
| }, |
| .len = 1 |
| }, |
| { |
| .data = { |
| (0x01 << 5) | 0x00 |
| }, |
| .len = 1 |
| }, |
| { |
| .data = { |
| (0x00 << 5) | 0x1a, |
| 0x7f, 0xff, 0xff, 0xff |
| }, |
| .len = 5 |
| }, |
| { |
| .data = { |
| (0x01 << 5) | 0x1a, |
| 0x7f, 0xff, 0xff, 0xff |
| }, |
| .len = 5 |
| } |
| }; |
| |
| for (i = 0; i < ARRAY_SIZE(expected_payload); i++) { |
| ret = cbor_writer.put_s32(&test_out, &test_path, value[i]); |
| zassert_equal(ret, expected_payload[i].len, |
| "Invalid length returned"); |
| zassert_mem_equal(test_out.out_cpkt->data + offset, |
| expected_payload[i].data, |
| expected_payload[i].len, |
| "Invalid payload format"); |
| |
| offset += expected_payload[i].len; |
| zassert_equal(test_out.out_cpkt->offset, offset, |
| "Invalid packet offset"); |
| } |
| } |
| |
| static void test_put_s32_nomem(void) |
| { |
| int ret; |
| |
| ret = cbor_writer.put_s32(&test_out, &test_path, INT32_MAX); |
| zassert_equal(ret, -ENOMEM, "Invalid error code returned"); |
| } |
| |
| static void test_put_s64(void) |
| { |
| int ret; |
| int i; |
| uint16_t offset = 0; |
| int64_t value[] = { 1, -1, INT64_MAX, INT64_MIN }; |
| struct test_payload_buffer expected_payload[] = { |
| { |
| .data = { |
| (0x00 << 5) | 0x01 |
| }, |
| .len = 1 |
| }, |
| { |
| .data = { |
| (0x01 << 5) | 0x00 |
| }, |
| .len = 1 |
| }, |
| { |
| .data = { |
| (0x00 << 5) | 0x1b, |
| 0x7f, 0xff, 0xff, 0xff, |
| 0xff, 0xff, 0xff, 0xff |
| }, |
| .len = 9 |
| }, |
| { |
| .data = { |
| (0x01 << 5) | 0x1b, |
| 0x7f, 0xff, 0xff, 0xff, |
| 0xff, 0xff, 0xff, 0xff |
| }, |
| .len = 9 |
| } |
| }; |
| |
| for (i = 0; i < ARRAY_SIZE(expected_payload); i++) { |
| ret = cbor_writer.put_s64(&test_out, &test_path, value[i]); |
| zassert_equal(ret, expected_payload[i].len, |
| "Invalid length returned"); |
| zassert_mem_equal(test_out.out_cpkt->data + offset, |
| expected_payload[i].data, |
| expected_payload[i].len, |
| "Invalid payload format"); |
| |
| offset += expected_payload[i].len; |
| zassert_equal(test_out.out_cpkt->offset, offset, |
| "Invalid packet offset"); |
| } |
| } |
| |
| static void test_put_s64_nomem(void) |
| { |
| int ret; |
| |
| ret = cbor_writer.put_s64(&test_out, &test_path, INT64_MAX); |
| zassert_equal(ret, -ENOMEM, "Invalid error code returned"); |
| } |
| |
| #define DOUBLE_CMP_EPSILON 0.000000001 |
| |
| static void test_put_float(void) |
| { |
| int ret; |
| int i; |
| uint16_t offset = 0; |
| |
| double readback_value; |
| double value[] = { 0.123, -0.987, 3., -10., 2.333, -123.125 }; |
| struct test_payload_buffer expected_payload[] = { |
| { |
| .data = { |
| (0x07 << 5) | 0x1b, |
| 0x3F, 0xBF, 0x7C, 0xED, 0x91, 0x68, 0x72, 0xB0 |
| }, |
| .len = 9 |
| }, |
| { |
| .data = { |
| (0x07 << 5) | 0x1b, |
| 0xBF, 0xEF, 0x95, 0x81, 0x06, 0x24, 0xDD, 0x2F |
| }, |
| .len = 9 |
| }, |
| { |
| .data = { |
| (0x07 << 5) | 0x1b, |
| 0x40, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 |
| }, |
| .len = 9 |
| }, |
| { |
| .data = { |
| (0x07 << 5) | 0x1b, |
| 0xC0, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 |
| }, |
| .len = 9 |
| }, |
| { |
| .data = { |
| (0x07 << 5) | 0x1b, |
| 0x40, 0x02, 0xA9, 0xFB, 0xE7, 0x6C, 0x8B, 0x44 |
| }, |
| .len = 9 |
| }, |
| { |
| .data = { |
| (0x07 << 5) | 0x1b, |
| 0xC0, 0x5E, 0xC8, 0x00, 0x00, 0x00, 0x00, 0x00 |
| }, |
| .len = 9 |
| } |
| }; |
| |
| for (i = 0; i < ARRAY_SIZE(expected_payload); i++) { |
| |
| ret = cbor_writer.put_float(&test_out, &test_path, &value[i]); |
| zassert_equal(ret, expected_payload[i].len, |
| "Invalid length returned"); |
| /* Ignore encoded least significant byte - it may differ slightly |
| * on various platform due to float rounding. |
| */ |
| zassert_mem_equal(test_out.out_cpkt->data + offset, |
| expected_payload[i].data, |
| expected_payload[i].len - 1, |
| "Invalid payload format"); |
| offset += expected_payload[i].len; |
| |
| /* Parse double back and compare it with the original one with |
| * a little error margin |
| */ |
| (void)lwm2m_b64_to_float(test_out.out_cpkt->data + offset - 8, 8, |
| &readback_value); |
| zassert_true((readback_value > value[i] - DOUBLE_CMP_EPSILON) && |
| (readback_value < value[i] + DOUBLE_CMP_EPSILON), |
| "Invalid value encoded"); |
| |
| zassert_equal(test_out.out_cpkt->offset, offset, |
| "Invalid packet offset"); |
| } |
| } |
| |
| static void test_put_float_nomem(void) |
| { |
| int ret; |
| double value = 1.2; |
| |
| ret = cbor_writer.put_float(&test_out, &test_path, &value); |
| zassert_equal(ret, -ENOMEM, "Invalid error code returned"); |
| } |
| |
| static void test_put_string(void) |
| { |
| int ret; |
| const char *test_string = "test_string"; |
| const char *long_string = "test_string_that_is_a_bit_longer"; |
| struct test_payload_buffer expected_payload = { |
| .data = { |
| (0x03 << 5) | (sizeof("test_string") - 1), |
| 't', 'e', 's', 't', '_', 's', |
| 't', 'r', 'i', 'n', 'g' |
| }, |
| .len = sizeof("test_string") - 1 + 1 |
| }; |
| struct test_payload_buffer long_payload = { |
| .data = { |
| (0x03 << 5) | 0x18, |
| (sizeof("test_string_that_is_a_bit_longer") - 1), |
| 't', 'e', 's', 't', '_', 's', |
| 't', 'r', 'i', 'n', 'g', '_', |
| 't', 'h', 'a', 't', '_', 'i', |
| 's', '_', 'a', '_', 'b', 'i', |
| 't', '_', 'l', 'o', 'n', 'g', |
| 'e', 'r' |
| }, |
| .len = sizeof("test_string_that_is_a_bit_longer") - 1 + 2 |
| }; |
| ret = cbor_writer.put_string(&test_out, &test_path, |
| (char *)test_string, strlen(test_string)); |
| zassert_equal(ret, expected_payload.len, "Invalid length returned"); |
| zassert_mem_equal(test_out.out_cpkt->data, expected_payload.data, |
| expected_payload.len, "Invalid payload format"); |
| zassert_equal(test_out.out_cpkt->offset, expected_payload.len, |
| "Invalid packet offset"); |
| |
| uint16_t offset = expected_payload.len; |
| |
| ret = cbor_writer.put_string(&test_out, &test_path, |
| (char *)long_string, strlen(long_string)); |
| zassert_equal(ret, long_payload.len, "Invalid length returned"); |
| zassert_mem_equal(test_out.out_cpkt->data + offset, long_payload.data, |
| long_payload.len, "Invalid payload format"); |
| zassert_equal(test_out.out_cpkt->offset, long_payload.len + offset, |
| "Invalid packet offset"); |
| } |
| |
| static void test_put_string_nomem(void) |
| { |
| int ret; |
| const char *test_string = "test_string"; |
| |
| ret = cbor_writer.put_string(&test_out, &test_path, |
| (char *)test_string, |
| strlen(test_string)); |
| zassert_equal(ret, -ENOMEM, "Invalid error code returned"); |
| } |
| |
| static void test_put_time(void) |
| { |
| int ret; |
| int64_t timestamp = 1; |
| struct test_payload_buffer expected_payload = { |
| .data = { |
| (0x06 << 5) | 0x00, |
| (0x03 << 5) | 0x18, |
| sizeof("1970-01-01T00:00:01-00:00") - 1, |
| '1', '9', '7', '0', '-', '0', '1', '-', |
| '0', '1', 'T', '0', '0', ':', '0', '0', |
| ':', '0', '1', '-', '0', '0', ':', '0', '0', '\0' |
| }, |
| .len = sizeof("1970-01-01T00:00:01-00:00") + 2 |
| }; |
| |
| ret = cbor_writer.put_time(&test_out, &test_path, timestamp); |
| zassert_equal(ret, expected_payload.len, "Invalid length returned"); |
| zassert_mem_equal(test_out.out_cpkt->data, expected_payload.data, |
| expected_payload.len, "Invalid payload format"); |
| zassert_equal(test_out.out_cpkt->offset, expected_payload.len, |
| "Invalid packet offset"); |
| } |
| |
| static void test_put_time_nomem(void) |
| { |
| int ret; |
| |
| ret = cbor_writer.put_time(&test_out, &test_path, UINT64_MAX); |
| zassert_equal(ret, -ENOMEM, "Invalid error code returned"); |
| } |
| |
| static void test_put_bool(void) |
| { |
| int ret; |
| int i; |
| uint16_t offset = 0; |
| bool value[] = { true, false }; |
| struct test_payload_buffer expected_payload[] = { |
| { |
| .data = { |
| (0x07 << 5) | 0x15 |
| }, |
| .len = 1 |
| }, |
| { |
| .data = { |
| (0x07 << 5) | 0x14 |
| }, |
| .len = 1 |
| } |
| }; |
| |
| for (i = 0; i < ARRAY_SIZE(expected_payload); i++) { |
| ret = cbor_writer.put_bool(&test_out, &test_path, value[i]); |
| zassert_equal(ret, expected_payload[i].len, |
| "Invalid length returned"); |
| zassert_mem_equal(test_out.out_cpkt->data + offset, |
| expected_payload[i].data, |
| expected_payload[i].len, |
| "Invalid payload format"); |
| |
| offset += expected_payload[i].len; |
| zassert_equal(test_out.out_cpkt->offset, offset, |
| "Invalid packet offset"); |
| } |
| } |
| |
| static void test_put_bool_nomem(void) |
| { |
| int ret; |
| |
| ret = cbor_writer.put_bool(&test_out, &test_path, true); |
| zassert_equal(ret, -ENOMEM, "Invalid error code returned"); |
| } |
| |
| static void test_put_opaque(void) |
| { |
| int ret; |
| const char *test_opaque = "test_opaque"; |
| const char *long_opaque = "test_opaque_that_is_a_bit_longer"; |
| struct test_payload_buffer expected_payload = { |
| .data = { |
| (0x02 << 5) | (sizeof("test_opaque") - 1), |
| 't', 'e', 's', 't', '_', 'o', |
| 'p', 'a', 'q', 'u', 'e' |
| }, |
| .len = sizeof("test_opaque") - 1 + 1 |
| }; |
| struct test_payload_buffer long_payload = { |
| .data = { |
| (0x02 << 5) | 0x18, |
| (sizeof("test_opaque_that_is_a_bit_longer") - 1), |
| 't', 'e', 's', 't', '_', 'o', |
| 'p', 'a', 'q', 'u', 'e', '_', |
| 't', 'h', 'a', 't', '_', 'i', |
| 's', '_', 'a', '_', 'b', 'i', |
| 't', '_', 'l', 'o', 'n', 'g', |
| 'e', 'r' |
| }, |
| .len = sizeof("test_opaque_that_is_a_bit_longer") - 1 + 2 |
| }; |
| ret = cbor_writer.put_opaque(&test_out, &test_path, |
| (char *)test_opaque, strlen(test_opaque)); |
| zassert_equal(ret, expected_payload.len, "Invalid length returned"); |
| zassert_mem_equal(test_out.out_cpkt->data, expected_payload.data, |
| expected_payload.len, "Invalid payload format"); |
| zassert_equal(test_out.out_cpkt->offset, expected_payload.len, |
| "Invalid packet offset"); |
| |
| uint16_t offset = expected_payload.len; |
| |
| ret = cbor_writer.put_opaque(&test_out, &test_path, |
| (char *)long_opaque, strlen(long_opaque)); |
| zassert_equal(ret, long_payload.len, "Invalid length returned"); |
| zassert_mem_equal(test_out.out_cpkt->data + offset, long_payload.data, |
| long_payload.len, "Invalid payload format"); |
| zassert_equal(test_out.out_cpkt->offset, long_payload.len + offset, |
| "Invalid packet offset"); |
| } |
| |
| static void test_put_opaque_nomem(void) |
| { |
| int ret; |
| const char *test_opaque = "test_opaque"; |
| |
| ret = cbor_writer.put_opaque(&test_out, &test_path, |
| (char *)test_opaque, |
| strlen(test_opaque)); |
| zassert_equal(ret, -ENOMEM, "Invalid error code returned"); |
| } |
| |
| static void test_put_objlnk(void) |
| { |
| int ret; |
| int i; |
| uint16_t offset = 0; |
| struct lwm2m_objlnk values[] = { |
| { 0, 0 }, { 1, 2 }, { LWM2M_OBJLNK_MAX_ID, LWM2M_OBJLNK_MAX_ID} |
| }; |
| struct test_payload_buffer expected_payload[] = { |
| { |
| .data = { |
| (0x03 << 5) | (sizeof("0:0")), |
| '0', ':', '0', '\0' |
| }, |
| .len = sizeof("0:0") + 1 |
| }, |
| { |
| .data = { |
| (0x03 << 5) | (sizeof("1:2")), |
| '1', ':', '2', '\0' |
| }, |
| .len = sizeof("1:2") + 1 |
| }, |
| { |
| .data = { |
| (0x03 << 5) | (sizeof("65535:65535")), |
| '6', '5', '5', '3', '5', ':', |
| '6', '5', '5', '3', '5', '\0' |
| }, |
| .len = sizeof("65535:65535") + 1 |
| } |
| }; |
| |
| for (i = 0; i < ARRAY_SIZE(expected_payload); i++) { |
| ret = cbor_writer.put_objlnk(&test_out, &test_path, &values[i]); |
| zassert_equal(ret, expected_payload[i].len, |
| "Invalid length returned"); |
| zassert_mem_equal(test_out.out_cpkt->data + offset, |
| expected_payload[i].data, |
| expected_payload[i].len, |
| "Invalid payload format"); |
| |
| offset += expected_payload[i].len; |
| zassert_equal(test_out.out_cpkt->offset, offset, |
| "Invalid packet offset"); |
| } |
| } |
| |
| static void test_put_objlnk_nomem(void) |
| { |
| int ret; |
| struct lwm2m_objlnk value = { 0, 0 }; |
| |
| ret = cbor_writer.put_objlnk(&test_out, &test_path, &value); |
| zassert_equal(ret, -ENOMEM, "Invalid error code returned"); |
| } |
| |
| static void test_get_s32(void) |
| { |
| int ret; |
| int i; |
| struct test_payload_buffer payload[] = { |
| { |
| .data = { |
| (0x00 << 5) | 0x01 |
| }, |
| .len = 1 |
| }, |
| { |
| .data = { |
| (0x01 << 5) | 0x00 |
| }, |
| .len = 1 |
| }, |
| { |
| .data = { |
| (0x00 << 5) | 0x1a, |
| 0x7f, 0xff, 0xff, 0xff |
| }, |
| .len = 5 |
| }, |
| { |
| .data = { |
| (0x01 << 5) | 0x1a, |
| 0x7f, 0xff, 0xff, 0xff |
| }, |
| .len = 5 |
| } |
| }; |
| int32_t expected_value[] = { 1, -1, INT32_MAX, INT32_MIN }; |
| int32_t value; |
| |
| for (i = 0; i < ARRAY_SIZE(expected_value); i++) { |
| test_payload_set(payload[i].data, payload[i].len); |
| |
| ret = cbor_reader.get_s32(&test_in, &value); |
| zassert_equal(ret, payload[i].len, "Invalid length returned"); |
| zassert_equal(value, expected_value[i], "Invalid value parsed"); |
| zassert_equal(test_in.offset, payload[i].len + 1, |
| "Invalid packet offset"); |
| } |
| } |
| |
| static void test_get_s32_nodata(void) |
| { |
| int ret; |
| int32_t value; |
| |
| ret = cbor_reader.get_s32(&test_in, &value); |
| zassert_equal(ret, -EBADMSG, "Invalid error code returned"); |
| } |
| |
| static void test_get_s64(void) |
| { |
| int ret; |
| int i; |
| struct test_payload_buffer payload[] = { |
| { |
| .data = { |
| (0x00 << 5) | 0x01 |
| }, |
| .len = 1 |
| }, |
| { |
| .data = { |
| (0x01 << 5) | 0x00 |
| }, |
| .len = 1 |
| }, |
| { |
| .data = { |
| (0x00 << 5) | 0x1b, |
| 0x7f, 0xff, 0xff, 0xff, |
| 0xff, 0xff, 0xff, 0xff |
| }, |
| .len = 9 |
| }, |
| { |
| .data = { |
| (0x01 << 5) | 0x1b, |
| 0x7f, 0xff, 0xff, 0xff, |
| 0xff, 0xff, 0xff, 0xff |
| }, |
| .len = 9 |
| } |
| }; |
| int64_t expected_value[] = { 1, -1, INT64_MAX, INT64_MIN }; |
| int64_t value; |
| |
| for (i = 0; i < ARRAY_SIZE(expected_value); i++) { |
| test_payload_set(payload[i].data, payload[i].len); |
| |
| ret = cbor_reader.get_s64(&test_in, &value); |
| zassert_equal(ret, payload[i].len, "Invalid length returned"); |
| zassert_equal(value, expected_value[i], "Invalid value parsed"); |
| zassert_equal(test_in.offset, payload[i].len + 1, |
| "Invalid packet offset"); |
| } |
| } |
| |
| static void test_get_s64_nodata(void) |
| { |
| int ret; |
| int64_t value; |
| |
| ret = cbor_reader.get_s64(&test_in, &value); |
| zassert_equal(ret, -EBADMSG, "Invalid error code returned"); |
| } |
| |
| #define DOUBLE_CMP_EPSILON 0.000000001 |
| |
| static void test_get_float(void) |
| { |
| int ret; |
| int i; |
| struct test_payload_buffer payload[] = { |
| { |
| .data = { |
| (0x07 << 5) | 0x1b, |
| 0, 0, 0, 0, 0, 0, 0, 0 |
| }, |
| .len = 9 |
| }, |
| { |
| .data = { |
| (0x07 << 5) | 0x1b, |
| 0x3F, 0xBF, 0x7C, 0xED, 0x91, 0x68, 0x72, 0xB0 |
| }, |
| .len = 9 |
| }, |
| { |
| .data = { |
| (0x07 << 5) | 0x1b, |
| 0xBF, 0xEF, 0x95, 0x81, 0x06, 0x24, 0xDD, 0x2F |
| }, |
| .len = 9 |
| }, |
| { |
| .data = { |
| (0x07 << 5) | 0x1b, |
| 0x40, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 |
| }, |
| .len = 9 |
| }, |
| { |
| .data = { |
| (0x07 << 5) | 0x1b, |
| 0xC0, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 |
| }, |
| .len = 9 |
| }, |
| { |
| .data = { |
| (0x07 << 5) | 0x1b, |
| 0x40, 0x02, 0xA9, 0xFB, 0xE7, 0x6C, 0x8B, 0x44 |
| }, |
| .len = 9 |
| }, |
| { |
| .data = { |
| (0x07 << 5) | 0x1b, |
| 0xC0, 0x5E, 0xC8, 0x00, 0x00, 0x00, 0x00, 0x00 |
| }, |
| .len = 9 |
| } |
| }; |
| double expected_value[] = { |
| 0., 0.123, -0.987, 3., -10., 2.333, -123.125 |
| }; |
| double value; |
| |
| for (i = 0; i < ARRAY_SIZE(expected_value); i++) { |
| test_payload_set(payload[i].data, payload[i].len); |
| |
| ret = cbor_reader.get_float(&test_in, &value); |
| zassert_equal(ret, payload[i].len, |
| "Invalid length returned"); |
| zassert_true((value > expected_value[i] - DOUBLE_CMP_EPSILON) && |
| (value < expected_value[i] + DOUBLE_CMP_EPSILON), |
| "Invalid value parsed"); |
| zassert_equal(test_in.offset, payload[i].len + 1, |
| "Invalid packet offset"); |
| } |
| } |
| |
| static void test_get_float_nodata(void) |
| { |
| int ret; |
| double value; |
| |
| ret = cbor_reader.get_float(&test_in, &value); |
| zassert_equal(ret, -EBADMSG, "Invalid error code returned"); |
| } |
| |
| static void test_get_string(void) |
| { |
| int ret; |
| const char *short_string = "test_string"; |
| const char *long_string = "test_string_that_is_a_bit_longer"; |
| uint8_t buf[40]; |
| struct test_payload_buffer short_payload = { |
| .data = { |
| (0x03 << 5) | (sizeof("test_string") - 1), |
| 't', 'e', 's', 't', '_', 's', |
| 't', 'r', 'i', 'n', 'g' |
| }, |
| .len = sizeof("test_string") - 1 + 1 |
| }; |
| struct test_payload_buffer long_payload = { |
| .data = { |
| (0x03 << 5) | 0x18, |
| (sizeof("test_string_that_is_a_bit_longer") - 1), |
| 't', 'e', 's', 't', '_', 's', |
| 't', 'r', 'i', 'n', 'g', '_', |
| 't', 'h', 'a', 't', '_', 'i', |
| 's', '_', 'a', '_', 'b', 'i', |
| 't', '_', 'l', 'o', 'n', 'g', |
| 'e', 'r' |
| }, |
| .len = sizeof("test_string_that_is_a_bit_longer") - 1 + 2 |
| }; |
| |
| test_payload_set(short_payload.data, short_payload.len); |
| |
| ret = cbor_reader.get_string(&test_in, buf, sizeof(buf)); |
| zassert_equal(ret, short_payload.len, "Invalid length returned"); |
| zassert_mem_equal(buf, short_string, strlen(short_string), |
| "Invalid value parsed"); |
| zassert_equal(test_in.offset, short_payload.len + 1, |
| "Invalid packet offset"); |
| |
| test_payload_set(long_payload.data, long_payload.len); |
| |
| ret = cbor_reader.get_string(&test_in, buf, sizeof(buf)); |
| zassert_equal(ret, long_payload.len, "Invalid length returned"); |
| zassert_mem_equal(buf, long_string, strlen(long_string), |
| "Invalid value parsed"); |
| zassert_equal(test_in.offset, long_payload.len + 1, |
| "Invalid packet offset"); |
| } |
| |
| static void test_get_string_nodata(void) |
| { |
| int ret; |
| uint8_t buf[16]; |
| |
| ret = cbor_reader.get_string(&test_in, buf, sizeof(buf)); |
| zassert_equal(ret, -EBADMSG, "Invalid error code returned"); |
| } |
| |
| static void test_get_bool(void) |
| { |
| int ret; |
| int i; |
| bool expected_value[] = { true, false }; |
| struct test_payload_buffer payload[] = { |
| { |
| .data = { |
| (0x07 << 5) | 0x15 |
| }, |
| .len = 1 |
| }, |
| { |
| .data = { |
| (0x07 << 5) | 0x14 |
| }, |
| .len = 1 |
| } |
| }; |
| bool value; |
| |
| for (i = 0; i < ARRAY_SIZE(expected_value); i++) { |
| test_payload_set(payload[i].data, payload[i].len); |
| |
| ret = cbor_reader.get_bool(&test_in, &value); |
| zassert_equal(ret, payload[i].len, |
| "Invalid length returned"); |
| zassert_equal(value, expected_value[i], "Invalid value parsed"); |
| zassert_equal(test_in.offset, payload[i].len + 1, |
| "Invalid packet offset"); |
| } |
| } |
| |
| static void test_get_bool_nodata(void) |
| { |
| int ret; |
| bool value; |
| |
| ret = cbor_reader.get_bool(&test_in, &value); |
| zassert_equal(ret, -EBADMSG, "Invalid error code returned"); |
| } |
| |
| static void test_get_opaque(void) |
| { |
| int ret; |
| const char *short_opaque = "test_opaque"; |
| const char *long_opaque = "test_opaque_that_is_a_bit_longer"; |
| struct test_payload_buffer short_payload = { |
| .data = { |
| (0x02 << 5) | (sizeof("test_opaque") - 1), |
| 't', 'e', 's', 't', '_', 'o', |
| 'p', 'a', 'q', 'u', 'e' |
| }, |
| .len = sizeof("test_opaque") - 1 + 1 |
| }; |
| struct test_payload_buffer long_payload = { |
| .data = { |
| (0x02 << 5) | 0x18, |
| (sizeof("test_opaque_that_is_a_bit_longer") - 1), |
| 't', 'e', 's', 't', '_', 'o', |
| 'p', 'a', 'q', 'u', 'e', '_', |
| 't', 'h', 'a', 't', '_', 'i', |
| 's', '_', 'a', '_', 'b', 'i', |
| 't', '_', 'l', 'o', 'n', 'g', |
| 'e', 'r' |
| }, |
| .len = sizeof("test_opaque_that_is_a_bit_longer") - 1 + 2 |
| }; |
| uint8_t buf[40]; |
| bool last_block; |
| struct lwm2m_opaque_context ctx = { 0 }; |
| |
| test_payload_set(short_payload.data, short_payload.len); |
| ret = cbor_reader.get_opaque(&test_in, buf, sizeof(buf), |
| &ctx, &last_block); |
| zassert_equal(ret, strlen(short_opaque), "Invalid length returned"); |
| zassert_mem_equal(buf, short_opaque, strlen(short_opaque), |
| "Invalid value parsed"); |
| zassert_equal(test_in.offset, short_payload.len + 1, |
| "Invalid packet offset"); |
| |
| test_payload_set(long_payload.data, long_payload.len); |
| ret = cbor_reader.get_opaque(&test_in, buf, sizeof(buf), &ctx, &last_block); |
| zassert_equal(ret, strlen(long_opaque), "Invalid length returned"); |
| zassert_mem_equal(buf, long_opaque, strlen(long_opaque), |
| "Invalid value parsed"); |
| zassert_equal(test_in.offset, long_payload.len + 1, |
| "Invalid packet offset"); |
| } |
| |
| static void test_get_opaque_nodata(void) |
| { |
| int ret; |
| uint8_t value[4]; |
| bool last_block; |
| struct lwm2m_opaque_context ctx = { 0 }; |
| |
| ret = cbor_reader.get_opaque(&test_in, value, sizeof(value), &ctx, &last_block); |
| zassert_equal(ret, -EBADMSG, "Invalid error code returned %d"); |
| } |
| |
| static void test_get_objlnk(void) |
| { |
| int ret; |
| int i; |
| struct test_payload_buffer payload[] = { |
| { |
| .data = { |
| (0x03 << 5) | (sizeof("0:0")), |
| '0', ':', '0', '\0' |
| }, |
| .len = sizeof("0:0") + 1 |
| }, |
| { |
| .data = { |
| (0x03 << 5) | (sizeof("1:2")), |
| '1', ':', '2', '\0' |
| }, |
| .len = sizeof("1:2") + 1 |
| }, |
| { |
| .data = { |
| (0x03 << 5) | (sizeof("65535:65535")), |
| '6', '5', '5', '3', '5', ':', |
| '6', '5', '5', '3', '5', '\0' |
| }, |
| .len = sizeof("65535:65535") + 1 |
| } |
| }; |
| struct lwm2m_objlnk expected_value[] = { |
| { 0, 0 }, { 1, 2 }, { LWM2M_OBJLNK_MAX_ID, LWM2M_OBJLNK_MAX_ID } |
| }; |
| struct lwm2m_objlnk value; |
| |
| for (i = 0; i < ARRAY_SIZE(expected_value); i++) { |
| test_payload_set(payload[i].data, payload[i].len); |
| |
| ret = cbor_reader.get_objlnk(&test_in, &value); |
| zassert_equal(ret, payload[i].len, "Invalid length returned"); |
| zassert_mem_equal(&value, &expected_value[i], |
| sizeof(struct lwm2m_objlnk), |
| "Invalid value parsed"); |
| zassert_equal(test_in.offset, payload[i].len + 1, |
| "Invalid packet offset"); |
| } |
| } |
| |
| static void test_get_objlnk_nodata(void) |
| { |
| int ret; |
| struct lwm2m_objlnk value; |
| |
| ret = cbor_reader.get_objlnk(&test_in, &value); |
| zassert_equal(ret, -EBADMSG, "Invalid error code returned"); |
| } |
| |
| void test_main(void) |
| { |
| ztest_test_suite( |
| lwm2m_content_raw_cbor, |
| ztest_unit_test_setup_teardown(test_put_s8, test_prepare, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_put_s8_nomem, |
| test_prepare_nomem, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_put_s16, test_prepare, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_put_s16_nomem, |
| test_prepare_nomem, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_put_s32, test_prepare, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_put_s32_nomem, |
| test_prepare_nomem, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_put_s64, test_prepare, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_put_s64_nomem, |
| test_prepare_nomem, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_put_float, test_prepare, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_put_float_nomem, |
| test_prepare_nomem, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_put_string, test_prepare, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_put_string_nomem, |
| test_prepare_nomem, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_put_time, test_prepare, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_put_time_nomem, |
| test_prepare_nomem, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_put_bool, test_prepare, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_put_bool_nomem, |
| test_prepare_nomem, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_put_opaque, test_prepare, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_put_opaque_nomem, |
| test_prepare_nomem, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_put_objlnk, test_prepare, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_put_objlnk_nomem, |
| test_prepare_nomem, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_get_s32, test_prepare, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_get_s32_nodata, |
| test_prepare_nodata, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_get_s64, test_prepare, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_get_s64_nodata, |
| test_prepare_nodata, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_get_float, test_prepare, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_get_float_nodata, |
| test_prepare_nodata, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_get_string, test_prepare, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_get_string_nodata, |
| test_prepare_nodata, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_get_bool, test_prepare, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_get_bool_nodata, |
| test_prepare_nodata, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_get_opaque, test_prepare, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_get_opaque_nodata, |
| test_prepare_nodata, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_get_objlnk, test_prepare, unit_test_noop), |
| ztest_unit_test_setup_teardown(test_get_objlnk_nodata, |
| test_prepare_nodata, unit_test_noop) |
| ); |
| |
| ztest_run_test_suite(lwm2m_content_raw_cbor); |
| } |