| /* |
| * Copyright (c) 2016 Intel Corporation. |
| * |
| * SPDX-License-Identifier: Apache-2.0 |
| */ |
| |
| #include <tc_util.h> |
| #include <mqtt_internal.h> |
| #include <sys/util.h> /* for ARRAY_SIZE */ |
| #include <ztest.h> |
| |
| #define CLIENTID MQTT_UTF8_LITERAL("zephyr") |
| #define TOPIC MQTT_UTF8_LITERAL("sensors") |
| #define WILL_TOPIC MQTT_UTF8_LITERAL("quitting") |
| #define WILL_MSG MQTT_UTF8_LITERAL("bye") |
| #define USERNAME MQTT_UTF8_LITERAL("zephyr1") |
| #define PASSWORD MQTT_UTF8_LITERAL("password") |
| |
| #define BUFFER_SIZE 128 |
| |
| static ZTEST_DMEM uint8_t rx_buffer[BUFFER_SIZE]; |
| static ZTEST_DMEM uint8_t tx_buffer[BUFFER_SIZE]; |
| static ZTEST_DMEM struct mqtt_client client; |
| |
| static ZTEST_DMEM struct mqtt_topic topic_qos_0 = { |
| .qos = 0, |
| .topic = TOPIC, |
| }; |
| static ZTEST_DMEM struct mqtt_topic topic_qos_1 = { |
| .qos = 1, |
| .topic = TOPIC, |
| }; |
| static ZTEST_DMEM struct mqtt_topic topic_qos_2 = { |
| .qos = 2, |
| .topic = TOPIC, |
| }; |
| static ZTEST_DMEM struct mqtt_topic will_topic_qos_0 = { |
| .qos = 0, |
| .topic = WILL_TOPIC, |
| }; |
| static ZTEST_DMEM struct mqtt_topic will_topic_qos_1 = { |
| .qos = 1, |
| .topic = WILL_TOPIC, |
| }; |
| static ZTEST_DMEM struct mqtt_utf8 will_msg = WILL_MSG; |
| static ZTEST_DMEM struct mqtt_utf8 username = USERNAME; |
| static ZTEST_DMEM struct mqtt_utf8 password = PASSWORD; |
| |
| /** |
| * @brief MQTT test structure |
| */ |
| struct mqtt_test { |
| /* test name, for example: "test connect 1" */ |
| const char *test_name; |
| |
| /* cast to something like: |
| * struct mqtt_publish_param *msg_publish = |
| * (struct mqtt_publish_param *)ctx |
| */ |
| void *ctx; |
| |
| /* pointer to the eval routine, for example: |
| * eval_fcn = eval_msg_connect |
| */ |
| int (*eval_fcn)(struct mqtt_test *); |
| |
| /* expected result */ |
| uint8_t *expected; |
| |
| /* length of 'expected' */ |
| uint16_t expected_len; |
| }; |
| |
| /** |
| * @brief eval_msg_connect Evaluate the given mqtt_test against the |
| * connect packing/unpacking routines. |
| * @param [in] mqtt_test MQTT test structure |
| * @return TC_PASS on success |
| * @return TC_FAIL on error |
| */ |
| static int eval_msg_connect(struct mqtt_test *mqtt_test); |
| |
| /** |
| * @brief eval_msg_publish Evaluate the given mqtt_test against the |
| * publish packing/unpacking routines. |
| * @param [in] mqtt_test MQTT test structure |
| * @return TC_PASS on success |
| * @return TC_FAIL on error |
| */ |
| static int eval_msg_publish(struct mqtt_test *mqtt_test); |
| |
| /** |
| * @brief eval_msg_corrupted_publish Evaluate the given mqtt_test against the |
| * corrupted publish message. |
| * @param [in] mqtt_test MQTT test structure |
| * @return TC_PASS on success |
| * @return TC_FAIL on error |
| */ |
| static int eval_msg_corrupted_publish(struct mqtt_test *mqtt_test); |
| |
| /** |
| * @brief eval_msg_subscribe Evaluate the given mqtt_test against the |
| * subscribe packing/unpacking routines. |
| * @param [in] mqtt_test MQTT test structure |
| * @return TC_PASS on success |
| * @return TC_FAIL on error |
| */ |
| static int eval_msg_subscribe(struct mqtt_test *mqtt_test); |
| |
| /** |
| * @brief eval_msg_suback Evaluate the given mqtt_test against the |
| * suback packing/unpacking routines. |
| * @param [in] mqtt_test MQTT test structure |
| * @return TC_PASS on success |
| * @return TC_FAIL on error |
| */ |
| static int eval_msg_suback(struct mqtt_test *mqtt_test); |
| |
| /** |
| * @brief eval_msg_pingreq Evaluate the given mqtt_test against the |
| * pingreq packing/unpacking routines. |
| * @param [in] mqtt_test MQTT test structure |
| * @return TC_PASS on success |
| * @return TC_FAIL on error |
| */ |
| static int eval_msg_pingreq(struct mqtt_test *mqtt_test); |
| |
| /** |
| * @brief eval_msg_puback Evaluate the given mqtt_test against the |
| * puback routines. |
| * @param [in] mqtt_test MQTT test structure |
| * @return TC_PASS on success |
| * @return TC_FAIL on error |
| */ |
| static int eval_msg_puback(struct mqtt_test *mqtt_test); |
| |
| /** |
| * @brief eval_msg_puback Evaluate the given mqtt_test against the |
| * pubcomp routines. |
| * @param [in] mqtt_test MQTT test structure |
| * @return TC_PASS on success |
| * @return TC_FAIL on error |
| */ |
| static int eval_msg_pubcomp(struct mqtt_test *mqtt_test); |
| |
| /** |
| * @brief eval_msg_pubrec Evaluate the given mqtt_test against the |
| * pubrec routines. |
| * @param [in] mqtt_test MQTT test structure |
| * @return TC_PASS on success |
| * @return TC_FAIL on error |
| */ |
| static int eval_msg_pubrec(struct mqtt_test *mqtt_test); |
| |
| /** |
| * @brief eval_msg_pubrel Evaluate the given mqtt_test against the |
| * pubrel routines. |
| * @param [in] mqtt_test MQTT test structure |
| * @return TC_PASS on success |
| * @return TC_FAIL on error |
| */ |
| static int eval_msg_pubrel(struct mqtt_test *mqtt_test); |
| |
| /** |
| * @brief eval_msg_unsuback Evaluate the given mqtt_test against the |
| * unsuback routines. |
| * @param [in] mqtt_test MQTT test structure |
| * @return TC_PASS on success |
| * @return TC_FAIL on error |
| */ |
| static int eval_msg_unsuback(struct mqtt_test *mqtt_test); |
| |
| /** |
| * @brief eval_msg_disconnect Evaluate the given mqtt_test against the |
| * disconnect routines. |
| * @param [in] mqtt_test MQTT test structure |
| * @return TC_PASS on success |
| * @return TC_FAIL on error |
| */ |
| static int eval_msg_disconnect(struct mqtt_test *mqtt_test); |
| |
| /** |
| * @brief eval_max_pkt_len Evaluate header with maximum allowed packet |
| * length. |
| * @param [in] mqtt_test MQTT test structure |
| * @return TC_PASS on success |
| * @return TC_FAIL on error |
| */ |
| static int eval_max_pkt_len(struct mqtt_test *mqtt_test); |
| |
| /** |
| * @brief eval_corrupted_pkt_len Evaluate header exceeding maximum |
| * allowed packet length. |
| * @param [in] mqtt_test MQTT test structure |
| * @return TC_PASS on success |
| * @return TC_FAIL on error |
| */ |
| static int eval_corrupted_pkt_len(struct mqtt_test *mqtt_test); |
| |
| /** |
| * @brief eval_buffers Evaluate if two given buffers are equal |
| * @param [in] buf Input buffer 1, mostly used as the 'computed' |
| * buffer |
| * @param [in] expected Expected buffer |
| * @param [in] len 'expected' len |
| * @return TC_PASS on success |
| * @return TC_FAIL on error and prints both buffers |
| */ |
| static int eval_buffers(const struct buf_ctx *buf, |
| const uint8_t *expected, uint16_t len); |
| |
| |
| /** |
| * @brief print_array Prints the array 'a' of 'size' elements |
| * @param a The array |
| * @param size Array's size |
| */ |
| static void print_array(const uint8_t *a, uint16_t size); |
| |
| /* |
| * MQTT CONNECT msg: |
| * Clean session: 1 Client id: [6] 'zephyr' Will flag: 0 |
| * Will QoS: 0 Will retain: 0 Will topic: [0] |
| * Will msg: [0] Keep alive: 60 User name: [0] |
| * Password: [0] |
| * |
| * Message can be generated by the following command: |
| * mosquitto_sub -V mqttv311 -i zephyr -k 60 -t sensors |
| */ |
| static ZTEST_DMEM |
| uint8_t connect1[] = {0x10, 0x12, 0x00, 0x04, 0x4d, 0x51, 0x54, 0x54, |
| 0x04, 0x02, 0x00, 0x3c, 0x00, 0x06, 0x7a, 0x65, |
| 0x70, 0x68, 0x79, 0x72}; |
| |
| static ZTEST_DMEM struct mqtt_client client_connect1 = { |
| .clean_session = 1, .client_id = CLIENTID, |
| .will_retain = 0, .will_topic = NULL, |
| .will_message = NULL, .user_name = NULL, |
| .password = NULL |
| }; |
| |
| /* |
| * MQTT CONNECT msg: |
| * Clean session: 1 Client id: [6] 'zephyr' Will flag: 1 |
| * Will QoS: 0 Will retain: 0 Will topic: [8] quitting |
| * Will msg: [3] bye Keep alive: 0 |
| * |
| * Message can be generated by the following command: |
| * mosquitto_sub -V mqttv311 -i zephyr -k 60 -t sensors --will-topic quitting \ |
| * --will-qos 0 --will-payload bye |
| */ |
| static ZTEST_DMEM |
| uint8_t connect2[] = {0x10, 0x21, 0x00, 0x04, 0x4d, 0x51, 0x54, 0x54, |
| 0x04, 0x06, 0x00, 0x3c, 0x00, 0x06, 0x7a, 0x65, |
| 0x70, 0x68, 0x79, 0x72, 0x00, 0x08, 0x71, 0x75, |
| 0x69, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x00, 0x03, |
| 0x62, 0x79, 0x65}; |
| |
| static ZTEST_DMEM struct mqtt_client client_connect2 = { |
| .clean_session = 1, .client_id = CLIENTID, |
| .will_retain = 0, .will_topic = &will_topic_qos_0, |
| .will_message = &will_msg, .user_name = NULL, |
| .password = NULL |
| }; |
| |
| /* |
| * MQTT CONNECT msg: |
| * Same message as connect3, but set Will retain: 1 |
| * |
| * Message can be generated by the following command: |
| * mosquitto_sub -V mqttv311 -i zephyr -k 60 -t sensors --will-topic quitting \ |
| * --will-qos 0 --will-payload bye --will-retain |
| */ |
| static ZTEST_DMEM |
| uint8_t connect3[] = {0x10, 0x21, 0x00, 0x04, 0x4d, 0x51, 0x54, 0x54, |
| 0x04, 0x26, 0x00, 0x3c, 0x00, 0x06, 0x7a, 0x65, |
| 0x70, 0x68, 0x79, 0x72, 0x00, 0x08, 0x71, 0x75, |
| 0x69, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x00, 0x03, |
| 0x62, 0x79, 0x65}; |
| |
| static ZTEST_DMEM struct mqtt_client client_connect3 = { |
| .clean_session = 1, .client_id = CLIENTID, |
| .will_retain = 1, .will_topic = &will_topic_qos_0, |
| .will_message = &will_msg, .user_name = NULL, |
| .password = NULL |
| }; |
| |
| /* |
| * MQTT CONNECT msg: |
| * Same message as connect3, but set Will QoS: 1 |
| * |
| * Message can be generated by the following command: |
| * mosquitto_sub -V mqttv311 -i zephyr -k 60 -t sensors --will-topic quitting \ |
| * --will-qos 1 --will-payload bye |
| */ |
| static ZTEST_DMEM |
| uint8_t connect4[] = {0x10, 0x21, 0x00, 0x04, 0x4d, 0x51, 0x54, 0x54, |
| 0x04, 0x0e, 0x00, 0x3c, 0x00, 0x06, 0x7a, 0x65, |
| 0x70, 0x68, 0x79, 0x72, 0x00, 0x08, 0x71, 0x75, |
| 0x69, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x00, 0x03, |
| 0x62, 0x79, 0x65}; |
| |
| static ZTEST_DMEM struct mqtt_client client_connect4 = { |
| .clean_session = 1, .client_id = CLIENTID, |
| .will_retain = 0, .will_topic = &will_topic_qos_1, |
| .will_message = &will_msg, .user_name = NULL, |
| .password = NULL |
| }; |
| |
| /* |
| * MQTT CONNECT msg: |
| * Same message as connect5, but set Will retain: 1 |
| * |
| * Message can be generated by the following command: |
| * mosquitto_sub -V mqttv311 -i zephyr -k 60 -t sensors --will-topic quitting \ |
| * --will-qos 1 --will-payload bye --will-retain |
| */ |
| static ZTEST_DMEM |
| uint8_t connect5[] = {0x10, 0x21, 0x00, 0x04, 0x4d, 0x51, 0x54, 0x54, |
| 0x04, 0x2e, 0x00, 0x3c, 0x00, 0x06, 0x7a, 0x65, |
| 0x70, 0x68, 0x79, 0x72, 0x00, 0x08, 0x71, 0x75, |
| 0x69, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x00, 0x03, |
| 0x62, 0x79, 0x65}; |
| |
| static ZTEST_DMEM struct mqtt_client client_connect5 = { |
| .clean_session = 1, .client_id = CLIENTID, |
| .will_retain = 1, .will_topic = &will_topic_qos_1, |
| .will_message = &will_msg, .user_name = NULL, |
| .password = NULL |
| }; |
| |
| /* |
| * MQTT CONNECT msg: |
| * Same message as connect6, but set username: zephyr1 and password: password |
| * |
| * Message can be generated by the following command: |
| * mosquitto_sub -V mqttv311 -i zephyr -k 60 -t sensors --will-topic quitting \ |
| * --will-qos 1 --will-payload bye --will-retain -u zephyr1 -P password |
| */ |
| static ZTEST_DMEM |
| uint8_t connect6[] = {0x10, 0x34, 0x00, 0x04, 0x4d, 0x51, 0x54, 0x54, |
| 0x04, 0xee, 0x00, 0x3c, 0x00, 0x06, 0x7a, 0x65, |
| 0x70, 0x68, 0x79, 0x72, 0x00, 0x08, 0x71, 0x75, |
| 0x69, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x00, 0x03, |
| 0x62, 0x79, 0x65, 0x00, 0x07, 0x7a, 0x65, 0x70, |
| 0x68, 0x79, 0x72, 0x31, 0x00, 0x08, 0x70, 0x61, |
| 0x73, 0x73, 0x77, 0x6f, 0x72, 0x64}; |
| |
| static ZTEST_DMEM struct mqtt_client client_connect6 = { |
| .clean_session = 1, .client_id = CLIENTID, |
| .will_retain = 1, .will_topic = &will_topic_qos_1, |
| .will_message = &will_msg, .user_name = &username, |
| .password = &password |
| }; |
| |
| static ZTEST_DMEM |
| uint8_t disconnect1[] = {0xe0, 0x00}; |
| |
| /* |
| * MQTT PUBLISH msg: |
| * DUP: 0, QoS: 0, Retain: 0, topic: sensors, message: OK |
| * |
| * Message can be generated by the following command: |
| * mosquitto_pub -V mqttv311 -i zephyr -t sensors -q 0 -m "OK" |
| */ |
| static ZTEST_DMEM |
| uint8_t publish1[] = {0x30, 0x0b, 0x00, 0x07, 0x73, 0x65, 0x6e, 0x73, |
| 0x6f, 0x72, 0x73, 0x4f, 0x4b}; |
| |
| static ZTEST_DMEM struct mqtt_publish_param msg_publish1 = { |
| .dup_flag = 0, .retain_flag = 0, .message_id = 0, |
| .message.topic.qos = 0, |
| .message.topic.topic = TOPIC, |
| .message.payload.data = (uint8_t *)"OK", |
| .message.payload.len = 2, |
| }; |
| |
| /* |
| * MQTT PUBLISH msg: |
| * DUP: 0, QoS: 0, Retain: 1, topic: sensors, message: OK |
| * |
| * Message can be generated by the following command: |
| * mosquitto_pub -V mqttv311 -i zephyr -t sensors -q 0 -m "OK" -r |
| */ |
| static ZTEST_DMEM |
| uint8_t publish2[] = {0x31, 0x0b, 0x00, 0x07, 0x73, 0x65, 0x6e, 0x73, |
| 0x6f, 0x72, 0x73, 0x4f, 0x4b}; |
| |
| static ZTEST_DMEM struct mqtt_publish_param msg_publish2 = { |
| .dup_flag = 0, .retain_flag = 1, .message_id = 0, |
| .message.topic.qos = 0, |
| .message.topic.topic = TOPIC, |
| .message.payload.data = (uint8_t *)"OK", |
| .message.payload.len = 2, |
| }; |
| |
| /* |
| * MQTT PUBLISH msg: |
| * DUP: 0, QoS: 1, Retain: 1, topic: sensors, message: OK, pkt_id: 1 |
| * |
| * Message can be generated by the following command: |
| * mosquitto_pub -V mqttv311 -i zephyr -t sensors -q 1 -m "OK" -r |
| */ |
| static ZTEST_DMEM |
| uint8_t publish3[] = {0x33, 0x0d, 0x00, 0x07, 0x73, 0x65, 0x6e, 0x73, |
| 0x6f, 0x72, 0x73, 0x00, 0x01, 0x4f, 0x4b}; |
| |
| static ZTEST_DMEM struct mqtt_publish_param msg_publish3 = { |
| .dup_flag = 0, .retain_flag = 1, .message_id = 1, |
| .message.topic.qos = 1, |
| .message.topic.topic = TOPIC, |
| .message.payload.data = (uint8_t *)"OK", |
| .message.payload.len = 2, |
| }; |
| |
| /* |
| * MQTT PUBLISH msg: |
| * DUP: 0, QoS: 2, Retain: 0, topic: sensors, message: OK, pkt_id: 1 |
| * |
| * Message can be generated by the following command: |
| * mosquitto_pub -V mqttv311 -i zephyr -t sensors -q 2 -m "OK" |
| */ |
| static ZTEST_DMEM |
| uint8_t publish4[] = {0x34, 0x0d, 0x00, 0x07, 0x73, 0x65, 0x6e, 0x73, |
| 0x6f, 0x72, 0x73, 0x00, 0x01, 0x4f, 0x4b}; |
| static ZTEST_DMEM struct mqtt_publish_param msg_publish4 = { |
| .dup_flag = 0, .retain_flag = 0, .message_id = 1, |
| .message.topic.qos = 2, |
| .message.topic.topic = TOPIC, |
| .message.payload.data = (uint8_t *)"OK", |
| .message.payload.len = 2, |
| }; |
| |
| static ZTEST_DMEM |
| uint8_t publish_corrupted[] = {0x30, 0x07, 0x00, 0x07, 0x73, 0x65, 0x6e, 0x73, |
| 0x6f, 0x72, 0x73, 0x00, 0x01, 0x4f, 0x4b}; |
| static ZTEST_DMEM struct buf_ctx publish_corrupted_buf = { |
| .cur = publish_corrupted, |
| .end = publish_corrupted + sizeof(publish_corrupted) |
| }; |
| |
| /* |
| * MQTT SUBSCRIBE msg: |
| * pkt_id: 1, topic: sensors, qos: 0 |
| * |
| * Message can be generated by the following command: |
| * mosquitto_sub -V mqttv311 -i zephyr -t sensors -q 0 |
| */ |
| static ZTEST_DMEM |
| uint8_t subscribe1[] = {0x82, 0x0c, 0x00, 0x01, 0x00, 0x07, 0x73, 0x65, |
| 0x6e, 0x73, 0x6f, 0x72, 0x73, 0x00}; |
| static ZTEST_DMEM struct mqtt_subscription_list msg_subscribe1 = { |
| .message_id = 1, .list_count = 1, .list = &topic_qos_0 |
| }; |
| |
| /* |
| * MQTT SUBSCRIBE msg: |
| * pkt_id: 1, topic: sensors, qos: 1 |
| * |
| * Message can be generated by the following command: |
| * mosquitto_sub -V mqttv311 -i zephyr -t sensors -q 1 |
| */ |
| static ZTEST_DMEM |
| uint8_t subscribe2[] = {0x82, 0x0c, 0x00, 0x01, 0x00, 0x07, 0x73, 0x65, |
| 0x6e, 0x73, 0x6f, 0x72, 0x73, 0x01}; |
| static ZTEST_DMEM struct mqtt_subscription_list msg_subscribe2 = { |
| .message_id = 1, .list_count = 1, .list = &topic_qos_1 |
| }; |
| |
| /* |
| * MQTT SUBSCRIBE msg: |
| * pkt_id: 1, topic: sensors, qos: 2 |
| * |
| * Message can be generated by the following command: |
| * mosquitto_sub -V mqttv311 -i zephyr -t sensors -q 2 |
| */ |
| static ZTEST_DMEM |
| uint8_t subscribe3[] = {0x82, 0x0c, 0x00, 0x01, 0x00, 0x07, 0x73, 0x65, |
| 0x6e, 0x73, 0x6f, 0x72, 0x73, 0x02}; |
| static ZTEST_DMEM struct mqtt_subscription_list msg_subscribe3 = { |
| .message_id = 1, .list_count = 1, .list = &topic_qos_2 |
| }; |
| |
| /* |
| * MQTT SUBACK msg |
| * pkt_id: 1, qos: 0 |
| * |
| * Message can be generated by the following command: |
| * mosquitto_sub -V mqttv311 -i zephyr -t sensors -q 0 |
| */ |
| static ZTEST_DMEM |
| uint8_t suback1[] = {0x90, 0x03, 0x00, 0x01, 0x00}; |
| static ZTEST_DMEM uint8_t data_suback1[] = { MQTT_SUBACK_SUCCESS_QoS_0 }; |
| static ZTEST_DMEM struct mqtt_suback_param msg_suback1 = { |
| .message_id = 1, .return_codes.len = 1, |
| .return_codes.data = data_suback1 |
| }; |
| |
| /* |
| * MQTT SUBACK message |
| * pkt_id: 1, qos: 1 |
| * |
| * Message can be generated by the following command: |
| * mosquitto_sub -V mqttv311 -i zephyr -t sensors -q 1 |
| */ |
| static ZTEST_DMEM |
| uint8_t suback2[] = {0x90, 0x03, 0x00, 0x01, 0x01}; |
| static ZTEST_DMEM uint8_t data_suback2[] = { MQTT_SUBACK_SUCCESS_QoS_1 }; |
| static ZTEST_DMEM struct mqtt_suback_param msg_suback2 = { |
| .message_id = 1, .return_codes.len = 1, |
| .return_codes.data = data_suback2 |
| }; |
| |
| /* |
| * MQTT SUBACK message |
| * pkt_id: 1, qos: 2 |
| * |
| * Message can be generated by the following command: |
| * mosquitto_sub -V mqttv311 -i zephyr -t sensors -q 2 |
| */ |
| static ZTEST_DMEM |
| uint8_t suback3[] = {0x90, 0x03, 0x00, 0x01, 0x02}; |
| static ZTEST_DMEM uint8_t data_suback3[] = { MQTT_SUBACK_SUCCESS_QoS_2 }; |
| static ZTEST_DMEM struct mqtt_suback_param msg_suback3 = { |
| .message_id = 1, .return_codes.len = 1, |
| .return_codes.data = data_suback3 |
| }; |
| |
| static ZTEST_DMEM |
| uint8_t pingreq1[] = {0xc0, 0x00}; |
| |
| static ZTEST_DMEM |
| uint8_t puback1[] = {0x40, 0x02, 0x00, 0x01}; |
| static ZTEST_DMEM struct mqtt_puback_param msg_puback1 = {.message_id = 1}; |
| |
| static ZTEST_DMEM |
| uint8_t pubrec1[] = {0x50, 0x02, 0x00, 0x01}; |
| static ZTEST_DMEM struct mqtt_pubrec_param msg_pubrec1 = {.message_id = 1}; |
| |
| static ZTEST_DMEM |
| uint8_t pubrel1[] = {0x62, 0x02, 0x00, 0x01}; |
| static ZTEST_DMEM struct mqtt_pubrel_param msg_pubrel1 = {.message_id = 1}; |
| |
| static ZTEST_DMEM |
| uint8_t pubcomp1[] = {0x70, 0x02, 0x00, 0x01}; |
| static ZTEST_DMEM struct mqtt_pubcomp_param msg_pubcomp1 = {.message_id = 1}; |
| |
| static ZTEST_DMEM |
| uint8_t unsuback1[] = {0xb0, 0x02, 0x00, 0x01}; |
| static ZTEST_DMEM struct mqtt_unsuback_param msg_unsuback1 = {.message_id = 1}; |
| |
| static ZTEST_DMEM |
| uint8_t max_pkt_len[] = {0x30, 0xff, 0xff, 0xff, 0x7f}; |
| static ZTEST_DMEM struct buf_ctx max_pkt_len_buf = { |
| .cur = max_pkt_len, .end = max_pkt_len + sizeof(max_pkt_len) |
| }; |
| |
| static ZTEST_DMEM |
| uint8_t corrupted_pkt_len[] = {0x30, 0xff, 0xff, 0xff, 0xff, 0x01}; |
| static ZTEST_DMEM struct buf_ctx corrupted_pkt_len_buf = { |
| .cur = corrupted_pkt_len, |
| .end = corrupted_pkt_len + sizeof(corrupted_pkt_len) |
| }; |
| |
| static ZTEST_DMEM |
| struct mqtt_test mqtt_tests[] = { |
| |
| {.test_name = "CONNECT, new session, zeros", |
| .ctx = &client_connect1, .eval_fcn = eval_msg_connect, |
| .expected = connect1, .expected_len = sizeof(connect1)}, |
| |
| {.test_name = "CONNECT, new session, will", |
| .ctx = &client_connect2, .eval_fcn = eval_msg_connect, |
| .expected = connect2, .expected_len = sizeof(connect2)}, |
| |
| {.test_name = "CONNECT, new session, will retain", |
| .ctx = &client_connect3, .eval_fcn = eval_msg_connect, |
| .expected = connect3, .expected_len = sizeof(connect3)}, |
| |
| {.test_name = "CONNECT, new session, will qos = 1", |
| .ctx = &client_connect4, .eval_fcn = eval_msg_connect, |
| .expected = connect4, .expected_len = sizeof(connect4)}, |
| |
| {.test_name = "CONNECT, new session, will qos = 1, will retain", |
| .ctx = &client_connect5, .eval_fcn = eval_msg_connect, |
| .expected = connect5, .expected_len = sizeof(connect5)}, |
| |
| {.test_name = "CONNECT, new session, username and password", |
| .ctx = &client_connect6, .eval_fcn = eval_msg_connect, |
| .expected = connect6, .expected_len = sizeof(connect6)}, |
| |
| {.test_name = "DISCONNECT", |
| .ctx = NULL, .eval_fcn = eval_msg_disconnect, |
| .expected = disconnect1, .expected_len = sizeof(disconnect1)}, |
| |
| {.test_name = "PUBLISH, qos = 0", |
| .ctx = &msg_publish1, .eval_fcn = eval_msg_publish, |
| .expected = publish1, .expected_len = sizeof(publish1)}, |
| |
| {.test_name = "PUBLISH, retain = 1", |
| .ctx = &msg_publish2, .eval_fcn = eval_msg_publish, |
| .expected = publish2, .expected_len = sizeof(publish2)}, |
| |
| {.test_name = "PUBLISH, retain = 1, qos = 1", |
| .ctx = &msg_publish3, .eval_fcn = eval_msg_publish, |
| .expected = publish3, .expected_len = sizeof(publish3)}, |
| |
| {.test_name = "PUBLISH, qos = 2", |
| .ctx = &msg_publish4, .eval_fcn = eval_msg_publish, |
| .expected = publish4, .expected_len = sizeof(publish4)}, |
| |
| {.test_name = "PUBLISH, corrupted message length (smaller than topic)", |
| .ctx = &publish_corrupted_buf, .eval_fcn = eval_msg_corrupted_publish}, |
| |
| {.test_name = "SUBSCRIBE, one topic, qos = 0", |
| .ctx = &msg_subscribe1, .eval_fcn = eval_msg_subscribe, |
| .expected = subscribe1, .expected_len = sizeof(subscribe1)}, |
| |
| {.test_name = "SUBSCRIBE, one topic, qos = 1", |
| .ctx = &msg_subscribe2, .eval_fcn = eval_msg_subscribe, |
| .expected = subscribe2, .expected_len = sizeof(subscribe2)}, |
| |
| {.test_name = "SUBSCRIBE, one topic, qos = 2", |
| .ctx = &msg_subscribe3, .eval_fcn = eval_msg_subscribe, |
| .expected = subscribe3, .expected_len = sizeof(subscribe3)}, |
| |
| {.test_name = "SUBACK, one topic, qos = 0", |
| .ctx = &msg_suback1, .eval_fcn = eval_msg_suback, |
| .expected = suback1, .expected_len = sizeof(suback1)}, |
| |
| {.test_name = "SUBACK, one topic, qos = 1", |
| .ctx = &msg_suback2, .eval_fcn = eval_msg_suback, |
| .expected = suback2, .expected_len = sizeof(suback2)}, |
| |
| {.test_name = "SUBACK, one topic, qos = 2", |
| .ctx = &msg_suback3, .eval_fcn = eval_msg_suback, |
| .expected = suback3, .expected_len = sizeof(suback3)}, |
| |
| {.test_name = "PINGREQ", |
| .ctx = NULL, .eval_fcn = eval_msg_pingreq, |
| .expected = pingreq1, .expected_len = sizeof(pingreq1)}, |
| |
| {.test_name = "PUBACK", |
| .ctx = &msg_puback1, .eval_fcn = eval_msg_puback, |
| .expected = puback1, .expected_len = sizeof(puback1)}, |
| |
| {.test_name = "PUBREC", |
| .ctx = &msg_pubrec1, .eval_fcn = eval_msg_pubrec, |
| .expected = pubrec1, .expected_len = sizeof(pubrec1)}, |
| |
| {.test_name = "PUBREL", |
| .ctx = &msg_pubrel1, .eval_fcn = eval_msg_pubrel, |
| .expected = pubrel1, .expected_len = sizeof(pubrel1)}, |
| |
| {.test_name = "PUBCOMP", |
| .ctx = &msg_pubcomp1, .eval_fcn = eval_msg_pubcomp, |
| .expected = pubcomp1, .expected_len = sizeof(pubcomp1)}, |
| |
| {.test_name = "UNSUBACK", |
| .ctx = &msg_unsuback1, .eval_fcn = eval_msg_unsuback, |
| .expected = unsuback1, .expected_len = sizeof(unsuback1)}, |
| |
| {.test_name = "Maximum packet length", |
| .ctx = &max_pkt_len_buf, .eval_fcn = eval_max_pkt_len}, |
| |
| {.test_name = "Corrupted packet length", |
| .ctx = &corrupted_pkt_len_buf, .eval_fcn = eval_corrupted_pkt_len}, |
| |
| /* last test case, do not remove it */ |
| {.test_name = NULL} |
| }; |
| |
| static void print_array(const uint8_t *a, uint16_t size) |
| { |
| uint16_t i; |
| |
| TC_PRINT("\n"); |
| for (i = 0U; i < size; i++) { |
| TC_PRINT("%x ", a[i]); |
| if ((i+1) % 8 == 0U) { |
| TC_PRINT("\n"); |
| } |
| } |
| TC_PRINT("\n"); |
| } |
| |
| static |
| int eval_buffers(const struct buf_ctx *buf, const uint8_t *expected, uint16_t len) |
| { |
| if (buf->end - buf->cur != len) { |
| goto exit_eval; |
| } |
| |
| if (memcmp(expected, buf->cur, buf->end - buf->cur) != 0) { |
| goto exit_eval; |
| } |
| |
| return TC_PASS; |
| |
| exit_eval: |
| TC_PRINT("FAIL\n"); |
| TC_PRINT("Computed:"); |
| print_array(buf->cur, buf->end - buf->cur); |
| TC_PRINT("Expected:"); |
| print_array(expected, len); |
| |
| return TC_FAIL; |
| } |
| |
| static int eval_msg_connect(struct mqtt_test *mqtt_test) |
| { |
| struct mqtt_client *test_client; |
| int rc; |
| struct buf_ctx buf; |
| |
| test_client = (struct mqtt_client *)mqtt_test->ctx; |
| |
| client.clean_session = test_client->clean_session; |
| client.client_id = test_client->client_id; |
| client.will_topic = test_client->will_topic; |
| client.will_retain = test_client->will_retain; |
| client.will_message = test_client->will_message; |
| client.user_name = test_client->user_name; |
| client.password = test_client->password; |
| |
| buf.cur = client.tx_buf; |
| buf.end = client.tx_buf + client.tx_buf_size; |
| |
| rc = connect_request_encode(&client, &buf); |
| |
| /**TESTPOINTS: Check connect_request_encode functions*/ |
| zassert_false(rc, "connect_request_encode failed"); |
| |
| rc = eval_buffers(&buf, mqtt_test->expected, mqtt_test->expected_len); |
| |
| zassert_false(rc, "eval_buffers failed"); |
| |
| return TC_PASS; |
| } |
| |
| static int eval_msg_disconnect(struct mqtt_test *mqtt_test) |
| { |
| int rc; |
| struct buf_ctx buf; |
| |
| buf.cur = client.tx_buf; |
| buf.end = client.tx_buf + client.tx_buf_size; |
| |
| rc = disconnect_encode(&buf); |
| |
| /**TESTPOINTS: Check disconnect_encode functions*/ |
| zassert_false(rc, "disconnect_encode failed"); |
| |
| rc = eval_buffers(&buf, mqtt_test->expected, mqtt_test->expected_len); |
| |
| zassert_false(rc, "eval_buffers failed"); |
| |
| return TC_PASS; |
| } |
| |
| static int eval_msg_publish(struct mqtt_test *mqtt_test) |
| { |
| struct mqtt_publish_param *param = |
| (struct mqtt_publish_param *)mqtt_test->ctx; |
| struct mqtt_publish_param dec_param; |
| int rc; |
| uint8_t type_and_flags; |
| uint32_t length; |
| struct buf_ctx buf; |
| |
| memset(&dec_param, 0, sizeof(dec_param)); |
| |
| buf.cur = client.tx_buf; |
| buf.end = client.tx_buf + client.tx_buf_size; |
| |
| rc = publish_encode(param, &buf); |
| |
| /* Payload is not copied, copy it manually just after the header.*/ |
| memcpy(buf.end, param->message.payload.data, |
| param->message.payload.len); |
| buf.end += param->message.payload.len; |
| |
| /**TESTPOINT: Check publish_encode function*/ |
| zassert_false(rc, "publish_encode failed"); |
| |
| rc = eval_buffers(&buf, mqtt_test->expected, mqtt_test->expected_len); |
| |
| zassert_false(rc, "eval_buffers failed"); |
| |
| rc = fixed_header_decode(&buf, &type_and_flags, &length); |
| |
| zassert_false(rc, "fixed_header_decode failed"); |
| |
| rc = publish_decode(type_and_flags, length, &buf, &dec_param); |
| |
| /**TESTPOINT: Check publish_decode function*/ |
| zassert_false(rc, "publish_decode failed"); |
| |
| zassert_equal(dec_param.message_id, param->message_id, |
| "message_id error"); |
| zassert_equal(dec_param.dup_flag, param->dup_flag, |
| "dup flag error"); |
| zassert_equal(dec_param.retain_flag, param->retain_flag, |
| "retain flag error"); |
| zassert_equal(dec_param.message.topic.qos, param->message.topic.qos, |
| "topic qos error"); |
| zassert_equal(dec_param.message.topic.topic.size, |
| param->message.topic.topic.size, |
| "topic len error"); |
| if (memcmp(dec_param.message.topic.topic.utf8, |
| param->message.topic.topic.utf8, |
| dec_param.message.topic.topic.size) != 0) { |
| zassert_unreachable("topic content error"); |
| } |
| zassert_equal(dec_param.message.payload.len, |
| param->message.payload.len, |
| "payload len error"); |
| |
| return TC_PASS; |
| } |
| |
| static int eval_msg_corrupted_publish(struct mqtt_test *mqtt_test) |
| { |
| struct buf_ctx *buf = (struct buf_ctx *)mqtt_test->ctx; |
| int rc; |
| uint8_t type_and_flags; |
| uint32_t length; |
| struct mqtt_publish_param dec_param; |
| |
| rc = fixed_header_decode(buf, &type_and_flags, &length); |
| zassert_equal(rc, 0, "fixed_header_decode failed"); |
| |
| rc = publish_decode(type_and_flags, length, buf, &dec_param); |
| zassert_equal(rc, -EINVAL, "publish_decode should fail"); |
| |
| return TC_PASS; |
| } |
| |
| static int eval_msg_subscribe(struct mqtt_test *mqtt_test) |
| { |
| struct mqtt_subscription_list *param = |
| (struct mqtt_subscription_list *)mqtt_test->ctx; |
| int rc; |
| struct buf_ctx buf; |
| |
| buf.cur = client.tx_buf; |
| buf.end = client.tx_buf + client.tx_buf_size; |
| |
| rc = subscribe_encode(param, &buf); |
| |
| /**TESTPOINT: Check subscribe_encode function*/ |
| zassert_false(rc, "subscribe_encode failed"); |
| |
| return eval_buffers(&buf, mqtt_test->expected, mqtt_test->expected_len); |
| } |
| |
| static int eval_msg_suback(struct mqtt_test *mqtt_test) |
| { |
| struct mqtt_suback_param *param = |
| (struct mqtt_suback_param *)mqtt_test->ctx; |
| struct mqtt_suback_param dec_param; |
| |
| int rc; |
| uint8_t type_and_flags; |
| uint32_t length; |
| struct buf_ctx buf; |
| |
| buf.cur = mqtt_test->expected; |
| buf.end = mqtt_test->expected + mqtt_test->expected_len; |
| |
| memset(&dec_param, 0, sizeof(dec_param)); |
| |
| rc = fixed_header_decode(&buf, &type_and_flags, &length); |
| |
| zassert_false(rc, "fixed_header_decode failed"); |
| |
| rc = subscribe_ack_decode(&buf, &dec_param); |
| |
| /**TESTPOINT: Check subscribe_ack_decode function*/ |
| zassert_false(rc, "subscribe_ack_decode failed"); |
| |
| zassert_equal(dec_param.message_id, param->message_id, |
| "packet identifier error"); |
| zassert_equal(dec_param.return_codes.len, |
| param->return_codes.len, |
| "topic count error"); |
| if (memcmp(dec_param.return_codes.data, param->return_codes.data, |
| dec_param.return_codes.len) != 0) { |
| zassert_unreachable("subscribe result error"); |
| } |
| |
| return TC_PASS; |
| } |
| |
| static int eval_msg_pingreq(struct mqtt_test *mqtt_test) |
| { |
| int rc; |
| struct buf_ctx buf; |
| |
| buf.cur = client.tx_buf; |
| buf.end = client.tx_buf + client.tx_buf_size; |
| |
| rc = ping_request_encode(&buf); |
| |
| /**TESTPOINTS: Check eval_msg_pingreq functions*/ |
| zassert_false(rc, "ping_request_encode failed"); |
| |
| rc = eval_buffers(&buf, mqtt_test->expected, mqtt_test->expected_len); |
| |
| zassert_false(rc, "eval_buffers failed"); |
| |
| return TC_PASS; |
| } |
| |
| static int eval_msg_puback(struct mqtt_test *mqtt_test) |
| { |
| struct mqtt_puback_param *param = |
| (struct mqtt_puback_param *)mqtt_test->ctx; |
| struct mqtt_puback_param dec_param; |
| int rc; |
| uint8_t type_and_flags; |
| uint32_t length; |
| struct buf_ctx buf; |
| |
| memset(&dec_param, 0, sizeof(dec_param)); |
| |
| buf.cur = client.tx_buf; |
| buf.end = client.tx_buf + client.tx_buf_size; |
| |
| rc = publish_ack_encode(param, &buf); |
| |
| /**TESTPOINTS: Check publish_ack_encode functions*/ |
| zassert_false(rc, "publish_ack_encode failed"); |
| |
| rc = eval_buffers(&buf, mqtt_test->expected, mqtt_test->expected_len); |
| |
| zassert_false(rc, "eval_buffers failed"); |
| |
| rc = fixed_header_decode(&buf, &type_and_flags, &length); |
| |
| zassert_false(rc, "fixed_header_decode failed"); |
| |
| rc = publish_ack_decode(&buf, &dec_param); |
| |
| zassert_false(rc, "publish_ack_decode failed"); |
| |
| zassert_equal(dec_param.message_id, param->message_id, |
| "packet identifier error"); |
| |
| return TC_PASS; |
| } |
| |
| static int eval_msg_pubcomp(struct mqtt_test *mqtt_test) |
| { |
| struct mqtt_pubcomp_param *param = |
| (struct mqtt_pubcomp_param *)mqtt_test->ctx; |
| struct mqtt_pubcomp_param dec_param; |
| int rc; |
| uint32_t length; |
| uint8_t type_and_flags; |
| struct buf_ctx buf; |
| |
| memset(&dec_param, 0, sizeof(dec_param)); |
| |
| buf.cur = client.tx_buf; |
| buf.end = client.tx_buf + client.tx_buf_size; |
| |
| rc = publish_complete_encode(param, &buf); |
| |
| /**TESTPOINTS: Check publish_complete_encode functions*/ |
| zassert_false(rc, "publish_complete_encode failed"); |
| |
| rc = eval_buffers(&buf, mqtt_test->expected, mqtt_test->expected_len); |
| |
| zassert_false(rc, "eval_buffers failed"); |
| |
| rc = fixed_header_decode(&buf, &type_and_flags, &length); |
| |
| zassert_false(rc, "fixed_header_decode failed"); |
| |
| rc = publish_complete_decode(&buf, &dec_param); |
| |
| zassert_false(rc, "publish_complete_decode failed"); |
| |
| zassert_equal(dec_param.message_id, param->message_id, |
| "packet identifier error"); |
| |
| return TC_PASS; |
| } |
| |
| static int eval_msg_pubrec(struct mqtt_test *mqtt_test) |
| { |
| struct mqtt_pubrec_param *param = |
| (struct mqtt_pubrec_param *)mqtt_test->ctx; |
| struct mqtt_pubrec_param dec_param; |
| int rc; |
| uint32_t length; |
| uint8_t type_and_flags; |
| struct buf_ctx buf; |
| |
| memset(&dec_param, 0, sizeof(dec_param)); |
| |
| buf.cur = client.tx_buf; |
| buf.end = client.tx_buf + client.tx_buf_size; |
| |
| rc = publish_receive_encode(param, &buf); |
| |
| /**TESTPOINTS: Check publish_receive_encode functions*/ |
| zassert_false(rc, "publish_receive_encode failed"); |
| |
| rc = eval_buffers(&buf, mqtt_test->expected, mqtt_test->expected_len); |
| |
| zassert_false(rc, "eval_buffers failed"); |
| |
| rc = fixed_header_decode(&buf, &type_and_flags, &length); |
| |
| zassert_false(rc, "fixed_header_decode failed"); |
| |
| rc = publish_receive_decode(&buf, &dec_param); |
| |
| zassert_false(rc, "publish_receive_decode failed"); |
| |
| zassert_equal(dec_param.message_id, param->message_id, |
| "packet identifier error"); |
| |
| return TC_PASS; |
| } |
| |
| static int eval_msg_pubrel(struct mqtt_test *mqtt_test) |
| { |
| struct mqtt_pubrel_param *param = |
| (struct mqtt_pubrel_param *)mqtt_test->ctx; |
| struct mqtt_pubrel_param dec_param; |
| int rc; |
| uint32_t length; |
| uint8_t type_and_flags; |
| struct buf_ctx buf; |
| |
| memset(&dec_param, 0, sizeof(dec_param)); |
| |
| buf.cur = client.tx_buf; |
| buf.end = client.tx_buf + client.tx_buf_size; |
| |
| rc = publish_release_encode(param, &buf); |
| |
| /**TESTPOINTS: Check publish_release_encode functions*/ |
| zassert_false(rc, "publish_release_encode failed"); |
| |
| rc = eval_buffers(&buf, mqtt_test->expected, mqtt_test->expected_len); |
| |
| zassert_false(rc, "eval_buffers failed"); |
| |
| rc = fixed_header_decode(&buf, &type_and_flags, &length); |
| |
| zassert_false(rc, "fixed_header_decode failed"); |
| |
| rc = publish_release_decode(&buf, &dec_param); |
| |
| zassert_false(rc, "publish_release_decode failed"); |
| |
| zassert_equal(dec_param.message_id, param->message_id, |
| "packet identifier error"); |
| |
| return TC_PASS; |
| } |
| |
| static int eval_msg_unsuback(struct mqtt_test *mqtt_test) |
| { |
| struct mqtt_unsuback_param *param = |
| (struct mqtt_unsuback_param *)mqtt_test->ctx; |
| struct mqtt_unsuback_param dec_param; |
| int rc; |
| uint32_t length; |
| uint8_t type_and_flags; |
| struct buf_ctx buf; |
| |
| memset(&dec_param, 0, sizeof(dec_param)); |
| |
| buf.cur = mqtt_test->expected; |
| buf.end = mqtt_test->expected + mqtt_test->expected_len; |
| |
| rc = fixed_header_decode(&buf, &type_and_flags, &length); |
| |
| zassert_false(rc, "fixed_header_decode failed"); |
| |
| rc = unsubscribe_ack_decode(&buf, &dec_param); |
| |
| zassert_false(rc, "unsubscribe_ack_decode failed"); |
| |
| zassert_equal(dec_param.message_id, param->message_id, |
| "packet identifier error"); |
| |
| return TC_PASS; |
| } |
| |
| static int eval_max_pkt_len(struct mqtt_test *mqtt_test) |
| { |
| struct buf_ctx *buf = (struct buf_ctx *)mqtt_test->ctx; |
| int rc; |
| uint8_t flags; |
| uint32_t length; |
| |
| rc = fixed_header_decode(buf, &flags, &length); |
| |
| zassert_equal(rc, 0, "fixed_header_decode failed"); |
| zassert_equal(length, MQTT_MAX_PAYLOAD_SIZE, |
| "Invalid packet length decoded"); |
| |
| return TC_PASS; |
| } |
| |
| static int eval_corrupted_pkt_len(struct mqtt_test *mqtt_test) |
| { |
| struct buf_ctx *buf = (struct buf_ctx *)mqtt_test->ctx; |
| int rc; |
| uint8_t flags; |
| uint32_t length; |
| |
| rc = fixed_header_decode(buf, &flags, &length); |
| |
| zassert_equal(rc, -EINVAL, "fixed_header_decode should fail"); |
| |
| return TC_PASS; |
| } |
| |
| void test_mqtt_packet(void) |
| { |
| TC_START("MQTT Library test"); |
| |
| int rc; |
| int i; |
| |
| mqtt_client_init(&client); |
| client.protocol_version = MQTT_VERSION_3_1_1; |
| client.rx_buf = rx_buffer; |
| client.rx_buf_size = sizeof(rx_buffer); |
| client.tx_buf = tx_buffer; |
| client.tx_buf_size = sizeof(tx_buffer); |
| |
| i = 0; |
| do { |
| struct mqtt_test *test = &mqtt_tests[i]; |
| |
| if (test->test_name == NULL) { |
| break; |
| } |
| |
| rc = test->eval_fcn(test); |
| TC_PRINT("[%s] %d - %s\n", TC_RESULT_TO_STR(rc), i + 1, |
| test->test_name); |
| |
| /**TESTPOINT: Check eval_fcn*/ |
| zassert_false(rc, "mqtt_packet test error"); |
| |
| i++; |
| } while (1); |
| |
| mqtt_abort(&client); |
| } |
| |
| void test_main(void) |
| { |
| ztest_test_suite(test_mqtt_packet_fn, |
| ztest_user_unit_test(test_mqtt_packet)); |
| ztest_run_test_suite(test_mqtt_packet_fn); |
| } |