Merge branch 'feature/support_mqtt5_protocol' into 'master'

Make MQTT client to comply with mqtt v5.0 spec

See merge request espressif/esp-idf!17345

components/mqtt/CMakeLists.txt

@@ -1,7 +1,10 @@
-idf_component_register(SRCS "esp-mqtt/mqtt_client.c"
-                            "esp-mqtt/lib/mqtt_msg.c"
-                            "esp-mqtt/lib/mqtt_outbox.c"
-                            "esp-mqtt/lib/platform_esp32_idf.c"
+set(srcs esp-mqtt/mqtt_client.c esp-mqtt/lib/mqtt_msg.c esp-mqtt/lib/mqtt_outbox.c esp-mqtt/lib/platform_esp32_idf.c)
+
+if(CONFIG_MQTT_PROTOCOL_5)
+    list(APPEND srcs esp-mqtt/lib/mqtt5_msg.c esp-mqtt/mqtt5_client.c)
+endif()
+
+idf_component_register(SRCS "${srcs}"
                     INCLUDE_DIRS esp-mqtt/include
                     PRIV_INCLUDE_DIRS "esp-mqtt/lib/include"
                     PRIV_REQUIRES esp_timer

components/mqtt/Kconfig

@@ -6,6 +6,12 @@ menu "ESP-MQTT Configurations"
         help
             If not, this library will use MQTT protocol 3.1
 
+    config MQTT_PROTOCOL_5
+        bool "Enable MQTT protocol 5.0"
+        default n
+        help
+            If not, this library will not support MQTT 5.0
+
     config MQTT_TRANSPORT_SSL
         bool "Enable MQTT over SSL"
         default y

components/mqtt/test/CMakeLists.txt

@@ -1,2 +1,8 @@
-idf_component_register(SRC_DIRS "."
+set(srcs test_mqtt_client_broker.c test_mqtt_connection.c test_mqtt.c)
+
+if(CONFIG_MQTT_PROTOCOL_5)
+    list(APPEND srcs test_mqtt5_client_broker.c test_mqtt5.c)
+endif()
+
+idf_component_register(SRCS "${srcs}"
                     PRIV_REQUIRES cmock test_utils mqtt nvs_flash app_update esp_eth esp_netif)

components/mqtt/test/Kconfig

@@ -6,4 +6,9 @@ menu "ESP-MQTT Unit Test Config"
         help
             URL of an mqtt broker which this test connects to.
 
+    config MQTT5_TEST_BROKER_URI
+        string "URI of the test broker"
+        default "mqtt://mqtt.eclipseprojects.io"
+        help
+            URL of an mqtt broker which this test connects to.
 endmenu

components/mqtt/test/test_mqtt5.c

@@ -0,0 +1,151 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <sys/time.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/event_groups.h"
+#include "unity.h"
+#include "test_utils.h"
+#include "memory_checks.h"
+#include "mqtt_client.h"
+#include "nvs_flash.h"
+#include "esp_ota_ops.h"
+#include "sdkconfig.h"
+#include "test_mqtt5_client_broker.h"
+#include "test_mqtt_connection.h"
+#include "esp_mac.h"
+
+static esp_mqtt5_user_property_item_t user_property_arr[3] = {
+    {"board", "esp32"},
+    {"u", "user"},
+    {"p", "password"}
+};
+
+static void test_leak_setup(const char * file, long line)
+{
+    uint8_t mac[6];
+    struct timeval te;
+    gettimeofday(&te, NULL); // get current time
+    esp_read_mac(mac, ESP_MAC_WIFI_STA);
+    printf("%s:%ld: time=%ld.%lds, mac:" MACSTR "\n", file, line, te.tv_sec, te.tv_usec, MAC2STR(mac));
+    test_utils_record_free_mem();
+}
+
+TEST_CASE("mqtt5 init with invalid url", "[mqtt5][leaks=0]")
+{
+    test_leak_setup(__FILE__, __LINE__);
+    const esp_mqtt_client_config_t mqtt5_cfg = {
+            .broker.address.uri = "INVALID",
+            .session.protocol_ver = MQTT_PROTOCOL_V_5,
+    };
+    esp_mqtt_client_handle_t client = esp_mqtt_client_init(&mqtt5_cfg);
+    TEST_ASSERT_EQUAL(NULL, client );
+}
+
+TEST_CASE("mqtt5 init and deinit", "[mqtt5][leaks=0]")
+{
+    test_leak_setup(__FILE__, __LINE__);
+    const esp_mqtt_client_config_t mqtt5_cfg = {
+            // no connection takes place, but the uri has to be valid for init() to succeed
+            .broker.address.uri = "mqtts://localhost:8883",
+            .session.protocol_ver = MQTT_PROTOCOL_V_5,
+            .credentials.username = "123",
+            .credentials.authentication.password = "456",
+            .session.last_will.topic = "/topic/will",
+            .session.last_will.msg = "i will leave",
+            .session.last_will.msg_len = 12,
+            .session.last_will.qos = 1,
+            .session.last_will.retain = true,
+    };
+    esp_mqtt5_connection_property_config_t connect_property = {
+        .session_expiry_interval = 10,
+        .maximum_packet_size = 1024,
+        .receive_maximum = 65535,
+        .topic_alias_maximum = 2,
+        .request_resp_info = true,
+        .request_problem_info = true,
+        .will_delay_interval = 10,
+        .payload_format_indicator = true,
+        .message_expiry_interval = 10,
+        .content_type = "json",
+        .response_topic = "/test/response",
+        .correlation_data = "123456",
+        .correlation_data_len = 6,
+    };
+
+    esp_mqtt_client_handle_t client = esp_mqtt_client_init(&mqtt5_cfg);
+    esp_mqtt5_client_set_user_property(&connect_property.user_property, user_property_arr, 3);
+    esp_mqtt5_client_set_user_property(&connect_property.will_user_property, user_property_arr, 3);
+    esp_mqtt5_client_set_connect_property(client, &connect_property);
+    esp_mqtt5_client_delete_user_property(connect_property.user_property);
+    esp_mqtt5_client_delete_user_property(connect_property.will_user_property);
+    TEST_ASSERT_NOT_EQUAL(NULL, client );
+    esp_mqtt_client_destroy(client);
+}
+
+static const char* this_bin_addr(void)
+{
+    spi_flash_mmap_handle_t out_handle;
+    const void *binary_address;
+    const esp_partition_t* partition = esp_ota_get_running_partition();
+    esp_partition_mmap(partition, 0, partition->size, SPI_FLASH_MMAP_DATA, &binary_address, &out_handle);
+    return binary_address;
+}
+
+TEST_CASE("mqtt5 enqueue and destroy outbox", "[mqtt5][leaks=0]")
+{
+    const char * bin_addr = this_bin_addr();
+    test_leak_setup(__FILE__, __LINE__);
+    const int messages = 20;
+    const int size = 2000;
+    const esp_mqtt_client_config_t mqtt5_cfg = {
+            // no connection takes place, but the uri has to be valid for init() to succeed
+            .broker.address.uri = "mqtts://localhost:8883",
+            .session.protocol_ver = MQTT_PROTOCOL_V_5,
+    };
+    esp_mqtt5_publish_property_config_t publish_property = {
+        .payload_format_indicator = 1,
+        .message_expiry_interval = 1000,
+        .topic_alias = 0,
+        .response_topic = "/topic/test/response",
+        .correlation_data = "123456",
+        .correlation_data_len = 6,
+        .content_type = "json",
+    };
+    esp_mqtt_client_handle_t client = esp_mqtt_client_init(&mqtt5_cfg);
+    TEST_ASSERT_NOT_EQUAL(NULL, client );
+    int bytes_before = esp_get_free_heap_size();
+    for (int i = 0; i < messages; i ++) {
+        esp_mqtt5_client_set_user_property(&publish_property.user_property, user_property_arr, 3);
+        esp_mqtt5_client_set_publish_property(client, &publish_property);
+        esp_mqtt_client_publish(client, "test", bin_addr, size, 1, 0);
+        esp_mqtt5_client_delete_user_property(publish_property.user_property);
+        publish_property.user_property = NULL;
+    }
+    int bytes_after = esp_get_free_heap_size();
+    // check that outbox allocated all messages on heap
+    TEST_ASSERT_GREATER_OR_EQUAL(messages*size, bytes_before - bytes_after);
+
+    esp_mqtt_client_destroy(client);
+}
+
+#if SOC_EMAC_SUPPORTED
+/**
+ * This test cases uses ethernet kit, so build and use it only if EMAC supported
+ */
+TEST_CASE("mqtt5 broker tests", "[mqtt5][test_env=UT_T2_Ethernet]")
+{
+    test_case_uses_tcpip();
+    connect_test_fixture_setup();
+
+    RUN_MQTT5_BROKER_TEST(mqtt5_connect_disconnect);
+    RUN_MQTT5_BROKER_TEST(mqtt5_subscribe_publish);
+    RUN_MQTT5_BROKER_TEST(mqtt5_lwt_clean_disconnect);
+    RUN_MQTT5_BROKER_TEST(mqtt5_subscribe_payload);
+
+    connect_test_fixture_teardown();
+}
+#endif // SOC_EMAC_SUPPORTED

components/mqtt/test/test_mqtt5_client_broker.c

@@ -0,0 +1,285 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "freertos/FreeRTOS.h"
+#include "freertos/event_groups.h"
+#include "mqtt_client.h"
+#include "esp_log.h"
+#include "esp_mac.h"
+
+#define WAIT_FOR_EVENT(event) \
+    TEST_ASSERT_TRUE(xEventGroupWaitBits(s_event_group, event, pdTRUE, pdTRUE, pdMS_TO_TICKS(COMMON_OPERATION_TIMEOUT)) & event);
+
+#define TEST_ASSERT_TRUE(condition) TEST_ASSERT_TRUE_LINE(condition, __LINE__)
+#define TEST_ASSERT_TRUE_LINE(condition, line) \
+    do {                                       \
+        if (!(condition)) {                    \
+                ESP_LOGE("test_mqtt5_client_broker.c", \
+                "Assertion failed in line %d", line); \
+                return false;                         \
+            } \
+    } while(0)
+
+
+static const int COMMON_OPERATION_TIMEOUT = 10000;
+static const int CONNECT_BIT = BIT0;
+static const int DISCONNECT_BIT = BIT1;
+static const int DATA_BIT = BIT2;
+
+static EventGroupHandle_t s_event_group;
+
+static esp_mqtt5_user_property_item_t user_property_arr[3] = {
+    {"board", "esp32"},
+    {"u", "user"},
+    {"p", "password"}
+};
+
+static char* append_mac(const char* string)
+{
+    uint8_t mac[6];
+    char *id_string = NULL;
+    esp_read_mac(mac, ESP_MAC_WIFI_STA);
+    asprintf(&id_string, "%s_%02x%02X%02X", string, mac[3], mac[4], mac[5]);
+    return id_string;
+}
+
+static void mqtt5_data_handler_qos(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data)
+{
+    if (event_id == MQTT_EVENT_DATA) {
+        esp_mqtt_event_handle_t event = event_data;
+        int * qos  = handler_args;
+        *qos = event->qos;
+        xEventGroupSetBits(s_event_group, DATA_BIT);
+    }
+}
+
+static void mqtt5_data_handler_lwt(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data)
+{
+    if (event_id == MQTT_EVENT_DATA) {
+        esp_mqtt_event_handle_t event = event_data;
+        ESP_LOGI("mqtt-lwt", "MQTT_EVENT_DATA");
+        ESP_LOGI("mqtt-lwt", "TOPIC=%.*s", event->topic_len, event->topic);
+        ESP_LOGI("mqtt-lwt", "DATA=%.*s", event->data_len, event->data);
+        if (strncmp(event->data, "no-lwt", event->data_len) == 0) {
+            // no lwt, just to indicate the test has finished
+            xEventGroupSetBits(s_event_group, DATA_BIT);
+        } else {
+            // count up any potential lwt message
+            int * count  = handler_args;
+            *count = *count + 1;
+            ESP_LOGE("mqtt5-lwt", "count=%d", *count);
+        }
+    }
+}
+
+static void mqtt5_data_handler_subscribe(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data)
+{
+    if (event_id == MQTT_EVENT_SUBSCRIBED) {
+        esp_mqtt_event_handle_t event = event_data;
+        ESP_LOGI("mqtt5-subscribe", "MQTT_EVENT_SUBSCRIBED, data size=%d", event->data_len);
+        int * sub_payload  = handler_args;
+        if (event->data_len == 1) {
+            ESP_LOGI("mqtt5-subscribe", "DATA=%d", *(uint8_t*)event->data);
+            *sub_payload = *(uint8_t*)event->data;
+        }
+        xEventGroupSetBits(s_event_group, DATA_BIT);
+    }
+}
+
+
+static void mqtt5_event_handler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data)
+{
+    switch ((esp_mqtt_event_id_t)event_id) {
+        case MQTT_EVENT_CONNECTED:
+            xEventGroupSetBits(s_event_group, CONNECT_BIT);
+            break;
+
+        case MQTT_EVENT_DISCONNECTED:
+            xEventGroupSetBits(s_event_group, DISCONNECT_BIT);
+            break;
+        default:
+            break;
+    }
+}
+
+bool mqtt5_connect_disconnect(void)
+{
+    const esp_mqtt_client_config_t mqtt5_cfg = {
+            .broker.address.uri = CONFIG_MQTT5_TEST_BROKER_URI,
+            .network.disable_auto_reconnect = true,
+            .session.protocol_ver = MQTT_PROTOCOL_V_5,
+    };
+    esp_mqtt5_connection_property_config_t connect_property = {
+        .session_expiry_interval = 10,
+        .maximum_packet_size = 1024,
+        .receive_maximum = 65535,
+        .topic_alias_maximum = 2,
+        .request_resp_info = true,
+        .request_problem_info = true,
+    };
+    esp_mqtt5_disconnect_property_config_t disconnect_property = {
+        .session_expiry_interval = 10,
+        .disconnect_reason = 0,
+    };
+    s_event_group = xEventGroupCreate();
+    esp_mqtt_client_handle_t client = esp_mqtt_client_init(&mqtt5_cfg);
+    TEST_ASSERT_TRUE(NULL != client );
+    esp_mqtt_client_register_event(client, ESP_EVENT_ANY_ID, mqtt5_event_handler, NULL);
+    TEST_ASSERT_TRUE(ESP_OK == esp_mqtt5_client_set_user_property(&connect_property.user_property, user_property_arr, 3));
+    TEST_ASSERT_TRUE(ESP_OK == esp_mqtt5_client_set_connect_property(client, &connect_property));
+    esp_mqtt5_client_delete_user_property(connect_property.user_property);
+    TEST_ASSERT_TRUE(ESP_OK == esp_mqtt_client_start(client));
+    WAIT_FOR_EVENT(CONNECT_BIT);
+    TEST_ASSERT_TRUE(ESP_OK == esp_mqtt5_client_set_user_property(&disconnect_property.user_property, user_property_arr, 3));
+    TEST_ASSERT_TRUE(ESP_OK == esp_mqtt5_client_set_disconnect_property(client, &disconnect_property));
+    esp_mqtt5_client_delete_user_property(disconnect_property.user_property);
+    esp_mqtt_client_disconnect(client);
+    WAIT_FOR_EVENT(DISCONNECT_BIT);
+    esp_mqtt_client_reconnect(client);
+    WAIT_FOR_EVENT(CONNECT_BIT);
+    esp_mqtt_client_destroy(client);
+    vEventGroupDelete(s_event_group);
+    return true;
+}
+
+bool mqtt5_subscribe_publish(void)
+{
+    const esp_mqtt_client_config_t mqtt5_cfg = {
+            .broker.address.uri = CONFIG_MQTT5_TEST_BROKER_URI,
+            .session.protocol_ver = MQTT_PROTOCOL_V_5,
+    };
+    esp_mqtt5_publish_property_config_t publish_property = {
+        .payload_format_indicator = 1,
+        .message_expiry_interval = 1000,
+        .topic_alias = 1,
+        .response_topic = "/topic/test/response",
+        .correlation_data = "123456",
+        .correlation_data_len = 6,
+        .content_type = "json",
+    };
+    esp_mqtt5_subscribe_property_config_t subscribe_property = {
+        .subscribe_id = 25555,
+        .no_local_flag = false,
+        .retain_as_published_flag = true,
+        .retain_handle = 0,
+    };
+    char* topic = append_mac("topic");
+    TEST_ASSERT_TRUE(NULL != topic);
+    s_event_group = xEventGroupCreate();
+    esp_mqtt_client_handle_t client = esp_mqtt_client_init(&mqtt5_cfg);
+    TEST_ASSERT_TRUE(NULL != client );
+    esp_mqtt_client_register_event(client, ESP_EVENT_ANY_ID, mqtt5_event_handler, NULL);
+    TEST_ASSERT_TRUE(ESP_OK == esp_mqtt_client_start(client));
+    WAIT_FOR_EVENT(CONNECT_BIT);
+    int qos = -1;
+    esp_mqtt_client_register_event(client, MQTT_EVENT_DATA, mqtt5_data_handler_qos, &qos);
+    TEST_ASSERT_TRUE(ESP_OK == esp_mqtt5_client_set_subscribe_property(client, &subscribe_property));
+    TEST_ASSERT_TRUE(esp_mqtt_client_subscribe(client, topic, 2) != -1);
+    TEST_ASSERT_TRUE(ESP_OK == esp_mqtt5_client_set_publish_property(client, &publish_property));
+    TEST_ASSERT_TRUE(esp_mqtt_client_publish(client, topic, "message", 0, 2, 0) != -1);
+    WAIT_FOR_EVENT(DATA_BIT);
+    TEST_ASSERT_TRUE(qos == 2);
+    TEST_ASSERT_TRUE(esp_mqtt_client_publish(client, topic, "message", 0, 1, 0) != -1);
+    WAIT_FOR_EVENT(DATA_BIT);
+    TEST_ASSERT_TRUE(qos == 1);
+    esp_mqtt_client_destroy(client);
+    vEventGroupDelete(s_event_group);
+    free(topic);
+    return true;
+}
+
+bool mqtt5_lwt_clean_disconnect(void)
+{
+    char* lwt = append_mac("lwt");
+    TEST_ASSERT_TRUE(lwt);
+    const esp_mqtt_client_config_t mqtt5_cfg1 = {
+            .broker.address.uri = CONFIG_MQTT5_TEST_BROKER_URI,
+            .credentials.set_null_client_id = true,
+            .session.last_will.topic = lwt,
+            .session.last_will.msg = "lwt_msg",
+            .session.protocol_ver = MQTT_PROTOCOL_V_5,
+    };
+    const esp_mqtt_client_config_t mqtt5_cfg2 = {
+            .broker.address.uri = CONFIG_MQTT5_TEST_BROKER_URI,
+            .credentials.set_null_client_id = true,
+            .session.last_will.topic = lwt,
+            .session.last_will.msg = "lwt_msg",
+            .session.protocol_ver = MQTT_PROTOCOL_V_5,
+    };
+    esp_mqtt5_connection_property_config_t connect_property = {
+        .will_delay_interval = 10,
+        .payload_format_indicator = true,
+        .message_expiry_interval = 10,
+        .content_type = "json",
+        .response_topic = "/test/response",
+        .correlation_data = "123456",
+        .correlation_data_len = 6,
+    };
+    s_event_group = xEventGroupCreate();
+
+    esp_mqtt_client_handle_t client1 = esp_mqtt_client_init(&mqtt5_cfg1);
+    esp_mqtt_client_handle_t client2 = esp_mqtt_client_init(&mqtt5_cfg2);
+    TEST_ASSERT_TRUE(NULL != client1 && NULL != client2 );
+    esp_mqtt_client_register_event(client1, ESP_EVENT_ANY_ID, mqtt5_event_handler, NULL);
+    esp_mqtt_client_register_event(client2, ESP_EVENT_ANY_ID, mqtt5_event_handler, NULL);
+    TEST_ASSERT_TRUE(ESP_OK == esp_mqtt5_client_set_connect_property(client1, &connect_property));
+    TEST_ASSERT_TRUE(ESP_OK == esp_mqtt5_client_set_connect_property(client2, &connect_property));
+    TEST_ASSERT_TRUE(esp_mqtt_client_start(client1) == ESP_OK);
+    WAIT_FOR_EVENT(CONNECT_BIT);
+    TEST_ASSERT_TRUE(esp_mqtt_client_start(client2) == ESP_OK);
+    WAIT_FOR_EVENT(CONNECT_BIT);
+    int counter = 0;
+    esp_mqtt_client_register_event(client1, MQTT_EVENT_DATA, mqtt5_data_handler_lwt, &counter);
+    esp_mqtt_client_register_event(client2, MQTT_EVENT_DATA, mqtt5_data_handler_lwt, &counter);
+    TEST_ASSERT_TRUE(esp_mqtt_client_subscribe(client1, lwt, 0) != -1);
+    TEST_ASSERT_TRUE(esp_mqtt_client_subscribe(client2, lwt, 0) != -1);
+    esp_mqtt_client_disconnect(client1);
+    WAIT_FOR_EVENT(DISCONNECT_BIT);
+    esp_mqtt_client_reconnect(client1);
+    WAIT_FOR_EVENT(CONNECT_BIT);
+    TEST_ASSERT_TRUE(esp_mqtt_client_subscribe(client1, lwt, 0) != -1);
+    esp_mqtt_client_stop(client2);
+    esp_mqtt_client_start(client2);
+    WAIT_FOR_EVENT(CONNECT_BIT);
+    TEST_ASSERT_TRUE(esp_mqtt_client_subscribe(client2, lwt, 0) != -1);
+    TEST_ASSERT_TRUE(esp_mqtt_client_publish(client1, lwt, "no-lwt", 0, 0, 0) != -1);
+    WAIT_FOR_EVENT(DATA_BIT);
+    TEST_ASSERT_TRUE(counter == 0);
+    esp_mqtt_client_destroy(client1);
+    esp_mqtt_client_destroy(client2);
+    vEventGroupDelete(s_event_group);
+    free(lwt);
+    return true;
+}
+
+bool mqtt5_subscribe_payload(void)
+{
+    const esp_mqtt_client_config_t mqtt5_cfg = {
+            .broker.address.uri = CONFIG_MQTT5_TEST_BROKER_URI,
+            .network.disable_auto_reconnect = true,
+            .session.protocol_ver = MQTT_PROTOCOL_V_5,
+    };
+    char* topic = append_mac("topic");
+    TEST_ASSERT_TRUE(NULL != topic);
+    s_event_group = xEventGroupCreate();
+    esp_mqtt_client_handle_t client = esp_mqtt_client_init(&mqtt5_cfg);
+    TEST_ASSERT_TRUE(NULL != client );
+    esp_mqtt_client_register_event(client, ESP_EVENT_ANY_ID, mqtt5_event_handler, NULL);
+    TEST_ASSERT_TRUE(ESP_OK == esp_mqtt_client_start(client));
+    WAIT_FOR_EVENT(CONNECT_BIT);
+    int qos_payload = -1;
+    esp_mqtt_client_register_event(client, MQTT_EVENT_SUBSCRIBED, mqtt5_data_handler_subscribe, &qos_payload);
+    TEST_ASSERT_TRUE(esp_mqtt_client_subscribe(client, topic, 2) != -1);
+    WAIT_FOR_EVENT(DATA_BIT);
+    TEST_ASSERT_TRUE(qos_payload == 2);
+    TEST_ASSERT_TRUE(esp_mqtt_client_subscribe(client, topic, 0) != -1);
+    WAIT_FOR_EVENT(DATA_BIT);
+    TEST_ASSERT_TRUE(qos_payload == 0);
+    esp_mqtt_client_destroy(client);
+    vEventGroupDelete(s_event_group);
+    free(topic);
+    return true;
+}

components/mqtt/test/test_mqtt5_client_broker.h

@@ -0,0 +1,51 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+#include "esp_log.h"
+
+/**
+ * @brief MQTT5 client-broker tests are not implemented as separate test cases
+ * due to time consuming connection setup/teardown.
+ * This utility macro is used to run functional cases as MQTT tests
+ * and evaluate as separate assertions in one "mqtt5 broker tests" test case.
+ */
+#define RUN_MQTT5_BROKER_TEST(test_name) \
+    do {                                \
+        ESP_LOGI("mqtt5_test", "Running test:" #test_name "()");                       \
+        TEST_ASSERT_TRUE_MESSAGE(test_name(), "Mqtt5 test failed: " #test_name "() "); \
+        ESP_LOGI("mqtt5_test", "Test:" #test_name "() passed ");                       \
+    } while(0)
+
+
+/**
+ * @brief This module contains mqtt5 test cases interacting the client with a (real) broker
+ */
+
+/**
+ * @brief The client subscribes and publishes on the same topic
+ * and verifies the received published qos in the event
+ */
+bool mqtt5_subscribe_publish(void);
+
+/**
+ * @brief The client connects, disconnects and reconnects.
+ * Tests basic client state transitions
+ */
+bool mqtt5_connect_disconnect(void);
+
+/**
+ * @brief Two clients with defined lwt connect and subscribe to lwt topic.
+ * This test verifies that no lwt is send when each of the client disconnects.
+ * (we expect a clean disconnection, so no last-will being sent)
+ */
+bool mqtt5_lwt_clean_disconnect(void);
+
+/**
+ * @brief The client subscribes to a topic with certain qos
+ * and verifies the qos in SUBACK message from the broker.
+ */
+bool mqtt5_subscribe_payload(void);

examples/protocols/.build-test-rules.yml

@@ -194,6 +194,16 @@ examples/protocols/mqtt/wss:
       temporary: true
       reason: lack of runners
 
+examples/protocols/mqtt5:
+  disable:
+    - if: IDF_TARGET == "esp32c2"
+      temporary: true
+      reason: target esp32c2 is not supported yet
+  disable_test:
+    - if: IDF_TARGET in ["esp32c3", "esp32s2", "esp32s3"]
+      temporary: true
+      reason: lack of runners
+
 examples/protocols/slip/slip_udp:
   disable:
     - if: IDF_TARGET == "esp32c2"

examples/protocols/mqtt5/CMakeLists.txt

@@ -0,0 +1,10 @@
+# The following four lines of boilerplate have to be in your project's CMakeLists
+# in this exact order for cmake to work correctly
+cmake_minimum_required(VERSION 3.16)
+
+# (Not part of the boilerplate)
+# This example uses an extra component for common functions such as Wi-Fi and Ethernet connection.
+set(EXTRA_COMPONENT_DIRS $ENV{IDF_PATH}/examples/common_components/protocol_examples_common)
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+project(mqtt5)

examples/protocols/mqtt5/README.md

@@ -0,0 +1,78 @@
+| Supported Targets | ESP32 | ESP32-C3 | ESP32-S2 | ESP32-S3 |
+| ----------------- | ----- | -------- | -------- | -------- |
+
+# ESP-MQTT sample application
+(See the README.md file in the upper level 'examples' directory for more information about examples.)
+
+This example connects to the broker URI selected using `idf.py menuconfig` (using mqtt tcp transport) and as a demonstration subscribes/unsubscribes and send a message on certain topic.
+(Please note that the public broker is maintained by the community so may not be always available, for details please see this [disclaimer](https://iot.eclipse.org/getting-started/#sandboxes))
+
+Note: If the URI equals `FROM_STDIN` then the broker address is read from stdin upon application startup (used for testing)
+
+It uses ESP-MQTT library which implements mqtt client to connect to mqtt broker with MQTT version 5.
+
+The more details about MQTT v5, please refer to [official website](https://docs.oasis-open.org/mqtt/mqtt/v5.0/os/mqtt-v5.0-os.html)
+
+## How to use example
+
+### Hardware Required
+
+This example can be executed on any ESP32 board, the only required interface is WiFi and connection to internet.
+
+### Configure the project
+
+* Open the project configuration menu (`idf.py menuconfig`)
+* Configure Wi-Fi or Ethernet under "Example Connection Configuration" menu. See "Establishing Wi-Fi or Ethernet Connection" section in [examples/protocols/README.md](../../README.md) for more details.
+* MQTT v5 protocol (`CONFIG_MQTT_PROTOCOL_5`) under "ESP-MQTT Configurations" menu is enabled by `sdkconfig.defaults`.
+
+### Build and Flash
+
+Build the project and flash it to the board, then run monitor tool to view serial output:
+
+```
+idf.py -p PORT flash monitor
+```
+
+(To exit the serial monitor, type ``Ctrl-]``.)
+
+See the Getting Started Guide for full steps to configure and use ESP-IDF to build projects.
+
+## Example Output
+
+```
+I (5119) esp_netif_handlers: example_connect: sta ip: 192.168.3.143, mask: 255.255.255.0, gw: 192.168.3.1
+I (5119) example_connect: Got IPv4 event: Interface "example_connect: sta" address: 192.168.3.143
+I (5619) example_connect: Got IPv6 event: Interface "example_connect: sta" address: fe80:0000:0000:0000:c64f:33ff:fe24:6645, type: ESP_IP6_ADDR_IS_LINK_LOCAL
+I (5619) example_connect: Connected to example_connect: sta
+I (5629) example_connect: - IPv4 address: 192.168.3.143
+I (5629) example_connect: - IPv6 address: fe80:0000:0000:0000:c64f:33ff:fe24:6645, type: ESP_IP6_ADDR_IS_LINK_LOCAL
+I (5649) MQTT5_EXAMPLE: Other event id:7
+W (6299) wifi:<ba-add>idx:0 (ifx:0, 34:29:12:43:c5:40), tid:7, ssn:0, winSize:64
+I (7439) MQTT5_EXAMPLE: MQTT_EVENT_CONNECTED
+I (7439) MQTT5_EXAMPLE: sent publish successful, msg_id=53118
+I (7439) MQTT5_EXAMPLE: sent subscribe successful, msg_id=41391
+I (7439) MQTT5_EXAMPLE: sent subscribe successful, msg_id=13695
+I (7449) MQTT5_EXAMPLE: sent unsubscribe successful, msg_id=55594
+I (7649) mqtt5_client: MQTT_MSG_TYPE_PUBACK return code is -1
+I (7649) MQTT5_EXAMPLE: MQTT_EVENT_PUBLISHED, msg_id=53118
+I (8039) mqtt5_client: MQTT_MSG_TYPE_SUBACK return code is 0
+I (8049) MQTT5_EXAMPLE: MQTT_EVENT_SUBSCRIBED, msg_id=41391
+I (8049) MQTT5_EXAMPLE: sent publish successful, msg_id=0
+I (8059) mqtt5_client: MQTT_MSG_TYPE_SUBACK return code is 2
+I (8059) MQTT5_EXAMPLE: MQTT_EVENT_SUBSCRIBED, msg_id=13695
+I (8069) MQTT5_EXAMPLE: sent publish successful, msg_id=0
+I (8079) MQTT5_EXAMPLE: MQTT_EVENT_DATA
+I (8079) MQTT5_EXAMPLE: key is board, value is esp32
+I (8079) MQTT5_EXAMPLE: key is u, value is user
+I (8089) MQTT5_EXAMPLE: key is p, value is password
+I (8089) MQTT5_EXAMPLE: payload_format_indicator is 1
+I (8099) MQTT5_EXAMPLE: response_topic is /topic/test/response
+I (8109) MQTT5_EXAMPLE: correlation_data is 123456
+I (8109) MQTT5_EXAMPLE: content_type is 
+I (8119) MQTT5_EXAMPLE: TOPIC=/topic/qos1
+I (8119) MQTT5_EXAMPLE: DATA=data_3
+I (8129) mqtt5_client: MQTT_MSG_TYPE_UNSUBACK return code is 0
+I (8129) MQTT5_EXAMPLE: MQTT_EVENT_UNSUBSCRIBED, msg_id=55594
+I (8139) mqtt_client: Client asked to disconnect
+I (9159) MQTT5_EXAMPLE: MQTT_EVENT_DISCONNECTED
+```

examples/protocols/mqtt5/main/CMakeLists.txt

@@ -0,0 +1,2 @@
+idf_component_register(SRCS "app_main.c"
+                    INCLUDE_DIRS ".")

examples/protocols/mqtt5/main/Kconfig.projbuild

@@ -0,0 +1,13 @@
+menu "Example Configuration"
+
+    config BROKER_URL
+        string "Broker URL"
+        default "mqtt://mqtt.eclipseprojects.io"
+        help
+            URL of the broker to connect to
+
+    config BROKER_URL_FROM_STDIN
+        bool
+        default y if BROKER_URL = "FROM_STDIN"
+
+endmenu

examples/protocols/mqtt5/main/app_main.c

@@ -0,0 +1,289 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stddef.h>
+#include <string.h>
+#include "esp_system.h"
+#include "nvs_flash.h"
+#include "esp_event.h"
+#include "esp_netif.h"
+#include "protocol_examples_common.h"
+#include "esp_log.h"
+#include "mqtt_client.h"
+
+static const char *TAG = "MQTT5_EXAMPLE";
+
+static void log_error_if_nonzero(const char *message, int error_code)
+{
+    if (error_code != 0) {
+        ESP_LOGE(TAG, "Last error %s: 0x%x", message, error_code);
+    }
+}
+
+static esp_mqtt5_user_property_item_t user_property_arr[] = {
+        {"board", "esp32"},
+        {"u", "user"},
+        {"p", "password"}
+    };
+
+#define USE_PROPERTY_ARR_SIZE   sizeof(user_property_arr)/sizeof(esp_mqtt5_user_property_item_t)
+
+static esp_mqtt5_publish_property_config_t publish_property = {
+    .payload_format_indicator = 1,
+    .message_expiry_interval = 1000,
+    .topic_alias = 0,
+    .response_topic = "/topic/test/response",
+    .correlation_data = "123456",
+    .correlation_data_len = 6,
+};
+
+static esp_mqtt5_subscribe_property_config_t subscribe_property = {
+    .subscribe_id = 25555,
+    .no_local_flag = false,
+    .retain_as_published_flag = false,
+    .retain_handle = 0,
+    .is_share_subscribe = true,
+    .share_name = "group1",
+};
+
+static esp_mqtt5_subscribe_property_config_t subscribe1_property = {
+    .subscribe_id = 25555,
+    .no_local_flag = true,
+    .retain_as_published_flag = false,
+    .retain_handle = 0,
+};
+
+static esp_mqtt5_unsubscribe_property_config_t unsubscribe_property = {
+    .is_share_subscribe = true,
+    .share_name = "group1",
+};
+
+static esp_mqtt5_disconnect_property_config_t disconnect_property = {
+    .session_expiry_interval = 60,
+    .disconnect_reason = 0,
+};
+
+static void print_user_property(mqtt5_user_property_handle_t user_property)
+{
+    if (user_property) {
+        uint8_t count = esp_mqtt5_client_get_user_property_count(user_property);
+        if (count) {
+            esp_mqtt5_user_property_item_t *item = malloc(count * sizeof(esp_mqtt5_user_property_item_t));
+            if (esp_mqtt5_client_get_user_property(user_property, item, &count) == ESP_OK) {
+                for (int i = 0; i < count; i ++) {
+                    esp_mqtt5_user_property_item_t *t = &item[i];
+                    ESP_LOGI(TAG, "key is %s, value is %s", t->key, t->value);
+                    free((char *)t->key);
+                    free((char *)t->value);
+                }
+            }
+            free(item);
+        }
+    }
+}
+
+/*
+ * @brief Event handler registered to receive MQTT events
+ *
+ *  This function is called by the MQTT client event loop.
+ *
+ * @param handler_args user data registered to the event.
+ * @param base Event base for the handler(always MQTT Base in this example).
+ * @param event_id The id for the received event.
+ * @param event_data The data for the event, esp_mqtt_event_handle_t.
+ */
+static void mqtt5_event_handler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data)
+{
+    ESP_LOGD(TAG, "Event dispatched from event loop base=%s, event_id=%d", base, event_id);
+    esp_mqtt_event_handle_t event = event_data;
+    esp_mqtt_client_handle_t client = event->client;
+    int msg_id;
+
+    ESP_LOGD(TAG, "free heap size is %d, maxminu %d", esp_get_free_heap_size(), esp_get_minimum_free_heap_size());
+    switch ((esp_mqtt_event_id_t)event_id) {
+    case MQTT_EVENT_CONNECTED:
+        ESP_LOGI(TAG, "MQTT_EVENT_CONNECTED");
+        print_user_property(event->property->user_property);
+        esp_mqtt5_client_set_user_property(&publish_property.user_property, user_property_arr, USE_PROPERTY_ARR_SIZE);
+        esp_mqtt5_client_set_publish_property(client, &publish_property);
+        msg_id = esp_mqtt_client_publish(client, "/topic/qos1", "data_3", 0, 1, 1);
+        esp_mqtt5_client_delete_user_property(publish_property.user_property);
+        publish_property.user_property = NULL;
+        ESP_LOGI(TAG, "sent publish successful, msg_id=%d", msg_id);
+
+        esp_mqtt5_client_set_user_property(&subscribe_property.user_property, user_property_arr, USE_PROPERTY_ARR_SIZE);
+        esp_mqtt5_client_set_subscribe_property(client, &subscribe_property);
+        msg_id = esp_mqtt_client_subscribe(client, "/topic/qos0", 0);
+        esp_mqtt5_client_delete_user_property(subscribe_property.user_property);
+        subscribe_property.user_property = NULL;
+        ESP_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id);
+
+        esp_mqtt5_client_set_user_property(&subscribe1_property.user_property, user_property_arr, USE_PROPERTY_ARR_SIZE);
+        esp_mqtt5_client_set_subscribe_property(client, &subscribe1_property);
+        msg_id = esp_mqtt_client_subscribe(client, "/topic/qos1", 2);
+        esp_mqtt5_client_delete_user_property(subscribe1_property.user_property);
+        subscribe1_property.user_property = NULL;
+        ESP_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id);
+
+        esp_mqtt5_client_set_user_property(&unsubscribe_property.user_property, user_property_arr, USE_PROPERTY_ARR_SIZE);
+        esp_mqtt5_client_set_unsubscribe_property(client, &unsubscribe_property);
+        msg_id = esp_mqtt_client_unsubscribe(client, "/topic/qos0");
+        ESP_LOGI(TAG, "sent unsubscribe successful, msg_id=%d", msg_id);
+        esp_mqtt5_client_delete_user_property(unsubscribe_property.user_property);
+        unsubscribe_property.user_property = NULL;
+        break;
+    case MQTT_EVENT_DISCONNECTED:
+        ESP_LOGI(TAG, "MQTT_EVENT_DISCONNECTED");
+        print_user_property(event->property->user_property);
+        break;
+    case MQTT_EVENT_SUBSCRIBED:
+        ESP_LOGI(TAG, "MQTT_EVENT_SUBSCRIBED, msg_id=%d", event->msg_id);
+        print_user_property(event->property->user_property);
+        esp_mqtt5_client_set_publish_property(client, &publish_property);
+        msg_id = esp_mqtt_client_publish(client, "/topic/qos0", "data", 0, 0, 0);
+        ESP_LOGI(TAG, "sent publish successful, msg_id=%d", msg_id);
+        break;
+    case MQTT_EVENT_UNSUBSCRIBED:
+        ESP_LOGI(TAG, "MQTT_EVENT_UNSUBSCRIBED, msg_id=%d", event->msg_id);
+        print_user_property(event->property->user_property);
+        esp_mqtt5_client_set_user_property(&disconnect_property.user_property, user_property_arr, USE_PROPERTY_ARR_SIZE);
+        esp_mqtt5_client_set_disconnect_property(client, &disconnect_property);
+        esp_mqtt5_client_delete_user_property(disconnect_property.user_property);
+        disconnect_property.user_property = NULL;
+        esp_mqtt_client_disconnect(client);
+        break;
+    case MQTT_EVENT_PUBLISHED:
+        ESP_LOGI(TAG, "MQTT_EVENT_PUBLISHED, msg_id=%d", event->msg_id);
+        print_user_property(event->property->user_property);
+        break;
+    case MQTT_EVENT_DATA:
+        ESP_LOGI(TAG, "MQTT_EVENT_DATA");
+        print_user_property(event->property->user_property);
+        ESP_LOGI(TAG, "payload_format_indicator is %d", event->property->payload_format_indicator);
+        ESP_LOGI(TAG, "response_topic is %.*s", event->property->response_topic_len, event->property->response_topic);
+        ESP_LOGI(TAG, "correlation_data is %.*s", event->property->correlation_data_len, event->property->correlation_data);
+        ESP_LOGI(TAG, "content_type is %.*s", event->property->content_type_len, event->property->content_type);
+        ESP_LOGI(TAG, "TOPIC=%.*s", event->topic_len, event->topic);
+        ESP_LOGI(TAG, "DATA=%.*s", event->data_len, event->data);
+        break;
+    case MQTT_EVENT_ERROR:
+        ESP_LOGI(TAG, "MQTT_EVENT_ERROR");
+        print_user_property(event->property->user_property);
+        ESP_LOGI(TAG, "MQTT5 return code is %d", event->error_handle->connect_return_code);
+        if (event->error_handle->error_type == MQTT_ERROR_TYPE_TCP_TRANSPORT) {
+            log_error_if_nonzero("reported from esp-tls", event->error_handle->esp_tls_last_esp_err);
+            log_error_if_nonzero("reported from tls stack", event->error_handle->esp_tls_stack_err);
+            log_error_if_nonzero("captured as transport's socket errno",  event->error_handle->esp_transport_sock_errno);
+            ESP_LOGI(TAG, "Last errno string (%s)", strerror(event->error_handle->esp_transport_sock_errno));
+        }
+        break;
+    default:
+        ESP_LOGI(TAG, "Other event id:%d", event->event_id);
+        break;
+    }
+}
+
+static void mqtt5_app_start(void)
+{
+    esp_mqtt5_connection_property_config_t connect_property = {
+        .session_expiry_interval = 10,
+        .maximum_packet_size = 1024,
+        .receive_maximum = 65535,
+        .topic_alias_maximum = 2,
+        .request_resp_info = true,
+        .request_problem_info = true,
+        .will_delay_interval = 10,
+        .payload_format_indicator = true,
+        .message_expiry_interval = 10,
+        .response_topic = "/test/response",
+        .correlation_data = "123456",
+        .correlation_data_len = 6,
+    };
+
+    esp_mqtt_client_config_t mqtt5_cfg = {
+        .broker.address.uri = CONFIG_BROKER_URL,
+        .session.protocol_ver = MQTT_PROTOCOL_V_5,
+        .network.disable_auto_reconnect = true,
+        .credentials.username = "123",
+        .credentials.authentication.password = "456",
+        .session.last_will.topic = "/topic/will",
+        .session.last_will.msg = "i will leave",
+        .session.last_will.msg_len = 12,
+        .session.last_will.qos = 1,
+        .session.last_will.retain = true,
+    };
+
+#if CONFIG_BROKER_URL_FROM_STDIN
+    char line[128];
+
+    if (strcmp(mqtt5_cfg.uri, "FROM_STDIN") == 0) {
+        int count = 0;
+        printf("Please enter url of mqtt broker\n");
+        while (count < 128) {
+            int c = fgetc(stdin);
+            if (c == '\n') {
+                line[count] = '\0';
+                break;
+            } else if (c > 0 && c < 127) {
+                line[count] = c;
+                ++count;
+            }
+            vTaskDelay(10 / portTICK_PERIOD_MS);
+        }
+        mqtt5_cfg.broker.address.uri = line;
+        printf("Broker url: %s\n", line);
+    } else {
+        ESP_LOGE(TAG, "Configuration mismatch: wrong broker url");
+        abort();
+    }
+#endif /* CONFIG_BROKER_URL_FROM_STDIN */
+
+    esp_mqtt_client_handle_t client = esp_mqtt_client_init(&mqtt5_cfg);
+
+    /* Set connection properties and user properties */
+    esp_mqtt5_client_set_user_property(&connect_property.user_property, user_property_arr, USE_PROPERTY_ARR_SIZE);
+    esp_mqtt5_client_set_user_property(&connect_property.will_user_property, user_property_arr, USE_PROPERTY_ARR_SIZE);
+    esp_mqtt5_client_set_connect_property(client, &connect_property);
+
+    /* If you call esp_mqtt5_client_set_user_property to set user properties, DO NOT forget to delete them.
+     * esp_mqtt5_client_set_connect_property will malloc buffer to store the user_property and you can delete it after
+     */
+    esp_mqtt5_client_delete_user_property(connect_property.user_property);
+    esp_mqtt5_client_delete_user_property(connect_property.will_user_property);
+
+    /* The last argument may be used to pass data to the event handler, in this example mqtt_event_handler */
+    esp_mqtt_client_register_event(client, ESP_EVENT_ANY_ID, mqtt5_event_handler, NULL);
+    esp_mqtt_client_start(client);
+}
+
+void app_main(void)
+{
+    ESP_LOGI(TAG, "[APP] Startup..");
+    ESP_LOGI(TAG, "[APP] Free memory: %d bytes", esp_get_free_heap_size());
+    ESP_LOGI(TAG, "[APP] IDF version: %s", esp_get_idf_version());
+
+    esp_log_level_set("*", ESP_LOG_INFO);
+    esp_log_level_set("MQTT_CLIENT", ESP_LOG_VERBOSE);
+    esp_log_level_set("MQTT_EXAMPLE", ESP_LOG_VERBOSE);
+    esp_log_level_set("TRANSPORT_BASE", ESP_LOG_VERBOSE);
+    esp_log_level_set("esp-tls", ESP_LOG_VERBOSE);
+    esp_log_level_set("TRANSPORT", ESP_LOG_VERBOSE);
+    esp_log_level_set("OUTBOX", ESP_LOG_VERBOSE);
+
+    ESP_ERROR_CHECK(nvs_flash_init());
+    ESP_ERROR_CHECK(esp_netif_init());
+    ESP_ERROR_CHECK(esp_event_loop_create_default());
+
+    /* This helper function configures Wi-Fi or Ethernet, as selected in menuconfig.
+     * Read "Establishing Wi-Fi or Ethernet Connection" section in
+     * examples/protocols/README.md for more information about this function.
+     */
+    ESP_ERROR_CHECK(example_connect());
+
+    mqtt5_app_start();
+}

examples/protocols/mqtt5/pytest_mqtt5.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python
+#
+# SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+import os
+
+import pytest
+from pytest_embedded import Dut
+
+
+@pytest.mark.esp32
+@pytest.mark.ethernet
+def test_examples_protocol_mqtt5(dut: Dut) -> None:
+    """
+    steps: |
+      1. join AP
+      2. connect to mqtt://mqtt.eclipseprojects.io
+      3. check conneciton success
+    """
+    # check and log bin size
+    binary_file = os.path.join(dut.app.binary_path, 'mqtt5.bin')
+    bin_size = os.path.getsize(binary_file)
+    logging.info('mqtt5_bin_size : {}KB'.format(bin_size // 1024))
+    # check if connected or not
+    dut.expect_exact('MQTT_EVENT_CONNECTED', timeout=30)
+    # check log
+    res = dut.expect(r'sent publish successful, msg_id=(\d+)')
+    msgid_pub1 = res.group(1).decode('utf8')
+    res = dut.expect(r'sent subscribe successful, msg_id=(\d+)')
+    msgid_sub1 = res.group(1).decode('utf8')
+    res = dut.expect(r'sent subscribe successful, msg_id=(\d+)')
+    msgid_sub2 = res.group(1).decode('utf8')
+    res = dut.expect(r'sent unsubscribe successful, msg_id=(\d+)')
+    msgid_unsub = res.group(1).decode('utf8')
+    res = dut.expect(r'MQTT_EVENT_PUBLISHED, msg_id=(\d+)')
+    msgid_pubd = res.group(1).decode('utf8')
+    assert msgid_pubd == msgid_pub1
+
+    res = dut.expect(r'MQTT_EVENT_SUBSCRIBED, msg_id=(\d+)')
+    msgid_subd = res.group(1).decode('utf8')
+    assert msgid_subd == msgid_sub1
+
+    dut.expect_exact('sent publish successful, msg_id=0')
+    res = dut.expect(r'MQTT_EVENT_SUBSCRIBED, msg_id=(\d+)')
+    msgid_subd = res.group(1).decode('utf8')
+    assert msgid_subd == msgid_sub2
+
+    dut.expect_exact('sent publish successful, msg_id=0')
+    dut.expect_exact('MQTT_EVENT_DATA')
+    dut.expect_exact('key is board, value is esp32')
+    dut.expect_exact('key is u, value is user')
+    dut.expect_exact('key is p, value is password')
+    dut.expect_exact('payload_format_indicator is 1')
+    dut.expect_exact('response_topic is /topic/test/response')
+    dut.expect_exact('correlation_data is 123456')
+    dut.expect_exact('TOPIC=/topic/qos1')
+    dut.expect_exact('DATA=data_3')
+    res = dut.expect(r'MQTT_EVENT_UNSUBSCRIBED, msg_id=(\d+)')
+    msgid_unsubd = res.group(1).decode('utf8')
+    assert msgid_unsubd == msgid_unsub
+
+    dut.expect_exact('MQTT_EVENT_DISCONNECTED')
+    logging.info('MQTT5 pytest pass')

examples/protocols/mqtt5/sdkconfig.ci

@@ -0,0 +1,9 @@
+CONFIG_EXAMPLE_CONNECT_ETHERNET=y
+CONFIG_EXAMPLE_CONNECT_WIFI=n
+CONFIG_EXAMPLE_USE_INTERNAL_ETHERNET=y
+CONFIG_EXAMPLE_ETH_PHY_IP101=y
+CONFIG_EXAMPLE_ETH_MDC_GPIO=23
+CONFIG_EXAMPLE_ETH_MDIO_GPIO=18
+CONFIG_EXAMPLE_ETH_PHY_RST_GPIO=5
+CONFIG_EXAMPLE_ETH_PHY_ADDR=1
+CONFIG_MQTT_PROTOCOL_5=y

examples/protocols/mqtt5/sdkconfig.defaults

@@ -0,0 +1 @@
+CONFIG_MQTT_PROTOCOL_5=y

tools/unit-test-app/configs/mqtt

@@ -0,0 +1,3 @@
+TEST_COMPONENTS=mqtt
+CONFIG_MQTT_PROTOCOL_5=y
+CONFIG_MQTT5_TEST_BROKER_URI="mqtt://mqtt.eclipseprojects.io"