refactor: init后没有start销毁客户端bug修复、增加某些字段0长度支持、优化config内存占用、增加对应的test

mqttclient/RyanMqttClient.c

@@ -111,6 +111,7 @@ __exit:
  *  !mqtt删除自己的延时最大不会超过config里面 recvTimeout + 1秒
  *  !mqtt删除自己前会调用 RyanMqttEventDestroyBefore 事件回调
  *  !调用此函数后就不应该再对该客户端进行任何操作
+ *  ?这里用信号量通知mqtt线程是最好的，但是为了简化platform层，这里用标志位代替信号量
  * @param client
  * @return RyanMqttError_e
  */
@@ -118,9 +119,17 @@ RyanMqttError_e RyanMqttDestroy(RyanMqttClient_t *client)
 {
 	RyanMqttCheck(NULL != client, RyanMqttParamInvalidError, RyanMqttLog_d);
 
-	platformCriticalEnter(client->config.userData, &client->criticalLock);
-	client->destroyFlag = RyanMqttTrue;
-	platformCriticalExit(client->config.userData, &client->criticalLock);
+	if (RyanMqttInitState == RyanMqttGetClientState(client))
+	{
+		RyanMqttPurgeClient(client);
+		platformMemoryFree(client);
+	}
+	else
+	{
+		platformCriticalEnter(client->config.userData, &client->criticalLock);
+		client->destroyFlag = RyanMqttTrue;
+		platformCriticalExit(client->config.userData, &client->criticalLock);
+	}
 
 	return RyanMqttSuccessError;
 }
@@ -830,42 +839,56 @@ static RyanMqttError_e RyanMqttClientConfigDeepCopy(RyanMqttClientConfig_t *dest
 	RyanMqttError_e result = RyanMqttSuccessError;
 	RyanMqttAssert(NULL != destConfig && NULL != srcConfig);
 
-	RyanMqttMemcpy(destConfig, srcConfig, sizeof(RyanMqttClientConfig_t));
-
-	destConfig->clientId = NULL;
-	destConfig->userName = NULL;
-	destConfig->password = NULL;
-	destConfig->host = NULL;
-	destConfig->taskName = NULL;
-
-	result = RyanMqttDupString(&destConfig->clientId, srcConfig->clientId, RyanMqttStrlen(srcConfig->clientId));
-	RyanMqttCheckCodeNoReturn(RyanMqttSuccessError == result, result, RyanMqttLog_d, { goto __exit; });
-
+	// 清除需要申请内存的字段
+	uint16_t clientIdLen = RyanMqttStrlen(srcConfig->clientId) + 1;
+	uint16_t userNameLen = 0;
+	uint16_t passwordLen = 0;
+	uint16_t hostLen = RyanMqttStrlen(srcConfig->host) + 1;
+	uint16_t taskNameLen = RyanMqttStrlen(srcConfig->taskName) + 1;
 	if (NULL != srcConfig->userName)
 	{
-		result = RyanMqttDupString(&destConfig->userName, srcConfig->userName,
-					   RyanMqttStrlen(srcConfig->userName));
-		RyanMqttCheckCodeNoReturn(RyanMqttSuccessError == result, result, RyanMqttLog_d, { goto __exit; });
+		userNameLen += RyanMqttStrlen(srcConfig->userName) + 1;
 	}
-
 	if (NULL != srcConfig->password)
 	{
-		result = RyanMqttDupString(&destConfig->password, srcConfig->password,
-					   RyanMqttStrlen(srcConfig->password));
-		RyanMqttCheckCodeNoReturn(RyanMqttSuccessError == result, result, RyanMqttLog_d, { goto __exit; });
+		passwordLen += RyanMqttStrlen(srcConfig->password) + 1;
 	}
 
-	result = RyanMqttDupString(&destConfig->host, srcConfig->host, RyanMqttStrlen(srcConfig->host));
-	RyanMqttCheckCodeNoReturn(RyanMqttSuccessError == result, result, RyanMqttLog_d, { goto __exit; });
+	// 获取申请内存大小
+	uint32_t mallocSize = clientIdLen + userNameLen + passwordLen + hostLen + taskNameLen;
+	char *buf = (char *)platformMemoryMalloc(mallocSize);
+	RyanMqttCheck(NULL != buf, RyanMqttNotEnoughMemError, RyanMqttLog_d);
+	RyanMqttMemset(buf, 0, mallocSize);
 
-	result = RyanMqttDupString(&destConfig->taskName, srcConfig->taskName, RyanMqttStrlen(srcConfig->taskName));
-	RyanMqttCheckCodeNoReturn(RyanMqttSuccessError == result, result, RyanMqttLog_d, { goto __exit; });
+	// 拷贝数据
+	RyanMqttMemcpy(destConfig, srcConfig, sizeof(RyanMqttClientConfig_t));
+	uint32_t offset = 0;
 
-__exit:
-	if (RyanMqttSuccessError != result)
+	// 共同使用一块内存
+#define copyConfigFieldWithOffset(key, valueLen)                                                                       \
+	destConfig->key = buf + offset;                                                                                \
+	if ((valueLen) != 1) RyanMqttMemcpy(destConfig->key, srcConfig->key, valueLen);                                \
+	offset += (valueLen);
+
+	copyConfigFieldWithOffset(clientId, clientIdLen); // 必须第一个字段
+	if (NULL != srcConfig->userName)
+	{
+		copyConfigFieldWithOffset(userName, userNameLen);
+	}
+	else
+	{
+		destConfig->userName = NULL;
+	}
+	if (NULL != srcConfig->password)
+	{
+		copyConfigFieldWithOffset(password, passwordLen);
+	}
+	else
 	{
-		RyanMqttPurgeConfig(destConfig);
+		destConfig->password = NULL;
 	}
+	copyConfigFieldWithOffset(host, hostLen);
+	copyConfigFieldWithOffset(taskName, taskNameLen);
 
 	return result;
 }
@@ -987,7 +1010,7 @@ RyanMqttError_e RyanMqttSetLwt(RyanMqttClient_t *client, char *topicName, char *
 	RyanMqttError_e result = RyanMqttSuccessError;
 
 	RyanMqttCheck(NULL != client, RyanMqttParamInvalidError, RyanMqttLog_d);
-	RyanMqttCheck(NULL != topicName, RyanMqttParamInvalidError, RyanMqttLog_d);
+	RyanMqttCheck(NULL != topicName && RyanMqttStrlen(topicName) > 0, RyanMqttParamInvalidError, RyanMqttLog_d);
 	RyanMqttCheck(RyanMqttConnectState != RyanMqttGetClientState(client), RyanMqttFailedError, RyanMqttLog_d);
 	RyanMqttCheck(RyanMqttMaxPayloadLen >= payloadLen, RyanMqttParamInvalidError, RyanMqttLog_d);
 	RyanMqttCheck(RyanMqttQos0 <= qos && RyanMqttQos2 >= qos, RyanMqttParamInvalidError, RyanMqttLog_d);

mqttclient/RyanMqttThread.c

@@ -470,42 +470,7 @@ void RyanMqttThread(void *argument)
 		{
 			RyanMqttEventMachine(client, RyanMqttEventDestroyBefore, (void *)NULL);
 
-			// 关闭网络组件
-			platformNetworkClose(client->config.userData, &client->network);
-
-			// 销毁网络组件
-			platformNetworkDestroy(client->config.userData, &client->network);
-
-			// 清除config信息
-			RyanMqttPurgeConfig(&client->config);
-
-			// 清除遗嘱相关配置
-			if (NULL != client->lwtOptions)
-			{
-				if (NULL != client->lwtOptions->payload)
-				{
-					platformMemoryFree(client->lwtOptions->payload);
-				}
-
-				if (NULL != client->lwtOptions->topic)
-				{
-					platformMemoryFree(client->lwtOptions->topic);
-				}
-
-				platformMemoryFree(client->lwtOptions);
-			}
-
-			// 清除session  ack链表和msg链表
-			RyanMqttPurgeSession(client);
-
-			// 清除互斥锁
-			platformMutexDestroy(client->config.userData, &client->sendLock);
-			platformMutexDestroy(client->config.userData, &client->msgHandleLock);
-			platformMutexDestroy(client->config.userData, &client->ackHandleLock);
-			platformMutexDestroy(client->config.userData, &client->userSessionLock);
-
-			// 清除临界区
-			platformCriticalDestroy(client->config.userData, &client->criticalLock);
+			RyanMqttPurgeClient(client);
 
 			// 清除掉线程动态资源
 			platformThread_t mqttThread;
@@ -541,7 +506,7 @@ void RyanMqttThread(void *argument)
 
 		case RyanMqttConnectState: // 连接状态
 			RyanMqttLog_d("连接状态");
-            // 不对返回值进行处理
+			// 不对返回值进行处理
 			RyanMqttProcessPacketHandler(client);
 			RyanMqttAckListScan(client, RyanMqttTrue);
 			RyanMqttKeepalive(client);

mqttclient/RyanMqttUtil.c

@@ -268,6 +268,11 @@ void RyanMqttPurgeSession(RyanMqttClient_t *client)
 	platformMutexUnLock(client->config.userData, &client->userSessionLock);
 }
 
+/**
+ * @brief 销毁mqtt客户端Config信息
+ *
+ * @param clientConfig
+ */
 void RyanMqttPurgeConfig(RyanMqttClientConfig_t *clientConfig)
 {
 	RyanMqttAssert(NULL != clientConfig);
@@ -276,26 +281,51 @@ void RyanMqttPurgeConfig(RyanMqttClientConfig_t *clientConfig)
 	{
 		platformMemoryFree(clientConfig->clientId);
 	}
+}
 
-	if (clientConfig->userName)
-	{
-		platformMemoryFree(clientConfig->userName);
-	}
+/**
+ * @brief 销毁mqtt客户端资源
+ *
+ * @param client
+ */
+void RyanMqttPurgeClient(RyanMqttClient_t *client)
+{
+	RyanMqttAssert(NULL != client);
 
-	if (clientConfig->password)
-	{
-		platformMemoryFree(clientConfig->password);
-	}
+	// 关闭销毁网络组件
+	platformNetworkClose(client->config.userData, &client->network);
+	platformNetworkDestroy(client->config.userData, &client->network);
 
-	if (clientConfig->host)
-	{
-		platformMemoryFree(clientConfig->host);
-	}
+	// 清除config信息
+	RyanMqttPurgeConfig(&client->config);
 
-	if (clientConfig->taskName)
+	// 清除遗嘱相关配置
+	if (NULL != client->lwtOptions)
 	{
-		platformMemoryFree(clientConfig->taskName);
+		if (NULL != client->lwtOptions->payload)
+		{
+			platformMemoryFree(client->lwtOptions->payload);
+		}
+
+		if (NULL != client->lwtOptions->topic)
+		{
+			platformMemoryFree(client->lwtOptions->topic);
+		}
+
+		platformMemoryFree(client->lwtOptions);
 	}
+
+	// 清除session  ack链表和msg链表
+	RyanMqttPurgeSession(client);
+
+	// 清除互斥锁
+	platformMutexDestroy(client->config.userData, &client->sendLock);
+	platformMutexDestroy(client->config.userData, &client->msgHandleLock);
+	platformMutexDestroy(client->config.userData, &client->ackHandleLock);
+	platformMutexDestroy(client->config.userData, &client->userSessionLock);
+
+	// 清除临界区
+	platformCriticalDestroy(client->config.userData, &client->criticalLock);
 }
 
 /**

mqttclient/include/RyanMqttPublic.h

@@ -75,6 +75,7 @@ typedef enum
 	RyanMqttBit0 = 0x00000001,
 } RyanMqttBit_e;
 
+// 仅作兼容使用
 #define RyanMqttFalse (false)
 #define RyanMqttTrue  (true)
 typedef bool RyanMqttBool_e;

mqttclient/include/RyanMqttUtil.h

@@ -25,6 +25,7 @@ extern RyanMqttState_e RyanMqttGetClientState(RyanMqttClient_t *client);
 extern RyanMqttError_e RyanMqttDupString(char **dest, const char *src, uint32_t strLen);
 extern void RyanMqttPurgeSession(RyanMqttClient_t *client);
 extern void RyanMqttPurgeConfig(RyanMqttClientConfig_t *clientConfig);
+extern void RyanMqttPurgeClient(RyanMqttClient_t *client);
 
 extern RyanMqttError_e RyanMqttSendPacket(RyanMqttClient_t *client, uint8_t *buf, uint32_t length);
 extern RyanMqttError_e RyanMqttRecvPacket(RyanMqttClient_t *client, uint8_t *buf, uint32_t length);
@@ -38,7 +39,7 @@ extern RyanMqttError_e RyanMqttMsgHandlerFind(RyanMqttClient_t *client, RyanMqtt
 					      RyanMqttBool_e isTopicMatchedFlag, RyanMqttMsgHandler_t **pMsgHandler,
 					      RyanMqttBool_e removeOnMatch);
 extern void RyanMqttMsgHandlerFindAndDestroyByPacketId(RyanMqttClient_t *client, RyanMqttMsgHandler_t *msgMatchCriteria,
-						     RyanMqttBool_e skipSamePacketId);
+						       RyanMqttBool_e skipSamePacketId);
 extern RyanMqttError_e RyanMqttMsgHandlerAddToMsgList(RyanMqttClient_t *client, RyanMqttMsgHandler_t *msgHandler);
 extern RyanMqttError_e RyanMqttMsgHandlerRemoveToMsgList(RyanMqttClient_t *client, RyanMqttMsgHandler_t *msgHandler);
 

test/RyanMqttDestroyTest.c

@@ -2,6 +2,27 @@
 
 static RyanMqttError_e RyanMqttConnectDestroy(uint32_t count)
 {
+	RyanMqttClientConfig_t baseMqttConfig = {.clientId = RyanMqttClientId,
+						 .userName = RyanMqttUserName,
+						 .password = RyanMqttPassword,
+						 .host = RyanMqttHost,
+						 .port = RyanMqttPort,
+						 .taskName = "mqttThread",
+						 .taskPrio = 16,
+						 .taskStack = 4096,
+						 .mqttVersion = 4,
+						 .ackHandlerRepeatCountWarning = 6,
+						 .ackHandlerCountWarning = 60000,
+						 .autoReconnectFlag = RyanMqttTrue,
+						 .cleanSessionFlag = RyanMqttTrue,
+						 .reconnectTimeout = 3000,
+						 .recvTimeout = 2000,
+						 .sendTimeout = 1800,
+						 .ackTimeout = 10000,
+						 .keepaliveTimeoutS = 120,
+						 .mqttEventHandle = NULL,
+						 .userData = NULL};
+
 	for (uint32_t i = 0; i < count; i++)
 	{
 		RyanMqttClient_t *client = NULL;
@@ -20,13 +41,21 @@ static RyanMqttError_e RyanMqttConnectDestroy(uint32_t count)
 		RyanMqttPublish(client, "testlinux/pub1", "helloworld", RyanMqttStrlen("helloworld"), RyanMqttQos0,
 				RyanMqttFalse);
 
-		// 偶尔让订阅主题全部订阅成功
+		// 偶尔等待订阅主题全部订阅成功
 		if (i % 7 == 0)
 		{
 			delay(2);
 		}
 
 		RyanMqttTestDestroyClient(client);
+
+		// 测试只初始化不启动的销毁
+		RyanMqttInit(&client);
+		if (i % 2)
+		{
+			RyanMqttSetConfig(client, &baseMqttConfig);
+		}
+		RyanMqttDestroy(client);
 	}
 
 	return RyanMqttSuccessError;

test/RyanMqttPublicApiParamCheckTest.c

@@ -122,6 +122,10 @@ static RyanMqttError_e RyanMqttLwtApiParamCheckTest(void)
 	result = RyanMqttSetLwt(validClient, NULL, "offline", 7, RyanMqttQos1, RyanMqttTrue);
 	RyanMqttCheckCodeNoReturn(RyanMqttParamInvalidError == result, result, RyanMqttLog_e, { goto __exit; });
 
+	// 非法主题
+	result = RyanMqttSetLwt(validClient, "", "offline", 7, RyanMqttQos1, RyanMqttTrue);
+	RyanMqttCheckCodeNoReturn(RyanMqttParamInvalidError == result, result, RyanMqttLog_e, { goto __exit; });
+
 	// NULL负载但长度不为0
 	result = RyanMqttSetLwt(validClient, "test/lwt", NULL, 7, RyanMqttQos1, RyanMqttTrue);
 	RyanMqttCheckCodeNoReturn(RyanMqttParamInvalidError == result, result, RyanMqttLog_e, { goto __exit; });
@@ -158,32 +162,6 @@ static RyanMqttError_e RyanMqttConfigApiParamCheckTest(void)
 	RyanMqttError_e result = RyanMqttSuccessError;
 
 	RyanMqttClient_t *validClient = NULL;
-	// 准备一个有效的客户端用于某些测试
-	result = RyanMqttTestInit(&validClient, RyanMqttTrue, RyanMqttFalse, 120, NULL, NULL);
-	RyanMqttCheckCodeNoReturn(RyanMqttSuccessError == result, result, RyanMqttLog_e, { goto __exit; });
-	RyanMqttDisconnect(validClient, RyanMqttTrue);
-
-	// NULL客户端指针
-	result = RyanMqttGetConfig(NULL, NULL);
-	RyanMqttCheckCodeNoReturn(RyanMqttParamInvalidError == result, result, RyanMqttLog_e, { goto __exit; });
-
-	RyanMqttClientConfig_t *getConfig = NULL;
-
-	/**
-	 * @brief RyanMqttGetConfig
-	 *
-	 */
-	// NULL客户端指针
-	result = RyanMqttGetConfig(NULL, &getConfig);
-	RyanMqttCheckCodeNoReturn(RyanMqttParamInvalidError == result, result, RyanMqttLog_e, { goto __exit; });
-
-	// NULL配置指针
-	result = RyanMqttGetConfig(validClient, NULL);
-	RyanMqttCheckCodeNoReturn(RyanMqttParamInvalidError == result, result, RyanMqttLog_e, { goto __exit; });
-
-	// NULL配置指针
-	result = RyanMqttFreeConfigFromGet(NULL);
-	RyanMqttCheckCodeNoReturn(RyanMqttParamInvalidError == result, result, RyanMqttLog_e, { goto __exit; });
 
 	/**
 	 * @brief RyanMqttSetConfig
@@ -210,6 +188,9 @@ static RyanMqttError_e RyanMqttConfigApiParamCheckTest(void)
 						 .mqttEventHandle = NULL,
 						 .userData = NULL};
 
+	result = RyanMqttInit(&validClient);
+	RyanMqttCheck(RyanMqttSuccessError == result, result, RyanMqttLog_e);
+
 	RyanMqttClientConfig_t mqttConfig = {0};
 
 	// NULL客户端指针
@@ -220,27 +201,77 @@ static RyanMqttError_e RyanMqttConfigApiParamCheckTest(void)
 	result = RyanMqttSetConfig(validClient, NULL);
 	RyanMqttCheckCodeNoReturn(RyanMqttParamInvalidError == result, result, RyanMqttLog_e, { goto __exit; });
 
-#define checkSetConfigParam(code)                                                                                      \
+#define checkSetConfigParam(code, errType)                                                                             \
 	do                                                                                                             \
 	{                                                                                                              \
 		RyanMqttMemcpy(&mqttConfig, &baseMqttConfig, sizeof(RyanMqttClientConfig_t));                          \
 		{code};                                                                                                \
 		result = RyanMqttSetConfig(validClient, &mqttConfig);                                                  \
-		RyanMqttCheckCodeNoReturn(RyanMqttParamInvalidError == result, result, RyanMqttLog_e,                  \
-					  { goto __exit; });                                                           \
+		RyanMqttCheckCodeNoReturn((errType) == result, result, RyanMqttLog_e, { goto __exit; });               \
 	} while (0)
 
-	checkSetConfigParam({ mqttConfig.clientId = NULL; });
-	checkSetConfigParam({ mqttConfig.host = NULL; });
-	checkSetConfigParam({ mqttConfig.taskName = NULL; });
-	checkSetConfigParam({
-		mqttConfig.recvTimeout = 10;
-		mqttConfig.keepaliveTimeoutS = 20 - 1;
-	});
-	checkSetConfigParam({
-		mqttConfig.recvTimeout = 10;
-		mqttConfig.sendTimeout = 11;
-	});
+	checkSetConfigParam({ mqttConfig.host = NULL; }, RyanMqttParamInvalidError);
+	checkSetConfigParam({ mqttConfig.taskName = NULL; }, RyanMqttParamInvalidError);
+	checkSetConfigParam({ mqttConfig.clientId = NULL; }, RyanMqttParamInvalidError);
+
+	// NULL用户名密码
+	checkSetConfigParam({ mqttConfig.userName = NULL; }, RyanMqttSuccessError);
+	checkSetConfigParam({ mqttConfig.password = NULL; }, RyanMqttSuccessError);
+
+	// 0长度
+	checkSetConfigParam({ mqttConfig.clientId = ""; }, RyanMqttSuccessError);
+	checkSetConfigParam({ mqttConfig.userName = ""; }, RyanMqttSuccessError);
+	checkSetConfigParam({ mqttConfig.password = ""; }, RyanMqttSuccessError);
+
+	// 配置错误
+	checkSetConfigParam(
+		{
+			mqttConfig.recvTimeout = 10;
+			mqttConfig.keepaliveTimeoutS = 20 - 1;
+		},
+		RyanMqttParamInvalidError);
+	checkSetConfigParam(
+		{
+			mqttConfig.recvTimeout = 10;
+			mqttConfig.sendTimeout = 11;
+		},
+		RyanMqttParamInvalidError);
+
+	RyanMqttSetConfig(validClient, &baseMqttConfig);
+
+	RyanMqttDestroy(validClient);
+	validClient = NULL;
+
+	/**
+	 * @brief RyanMqttGetConfig
+	 *
+	 */
+	// 准备一个有效的客户端用于某些测试
+	result = RyanMqttTestInit(&validClient, RyanMqttTrue, RyanMqttFalse, 120, NULL, NULL);
+	RyanMqttCheckCodeNoReturn(RyanMqttSuccessError == result, result, RyanMqttLog_e, { goto __exit; });
+	RyanMqttDisconnect(validClient, RyanMqttTrue);
+
+	// NULL客户端指针
+	result = RyanMqttGetConfig(NULL, NULL);
+	RyanMqttCheckCodeNoReturn(RyanMqttParamInvalidError == result, result, RyanMqttLog_e, { goto __exit; });
+
+	RyanMqttClientConfig_t *getConfig = NULL;
+
+	/**
+	 * @brief RyanMqttGetConfig
+	 *
+	 */
+	// NULL客户端指针
+	result = RyanMqttGetConfig(NULL, &getConfig);
+	RyanMqttCheckCodeNoReturn(RyanMqttParamInvalidError == result, result, RyanMqttLog_e, { goto __exit; });
+
+	// NULL配置指针
+	result = RyanMqttGetConfig(validClient, NULL);
+	RyanMqttCheckCodeNoReturn(RyanMqttParamInvalidError == result, result, RyanMqttLog_e, { goto __exit; });
+
+	// NULL配置指针
+	result = RyanMqttFreeConfigFromGet(NULL);
+	RyanMqttCheckCodeNoReturn(RyanMqttParamInvalidError == result, result, RyanMqttLog_e, { goto __exit; });
 
 	// 清理资源
 	if (validClient)

test/RyanMqttTest.c

@@ -166,7 +166,7 @@ RyanMqttError_e RyanMqttTestInit(RyanMqttClient_t **client, RyanMqttBool_e syncF
 	}
 
 	RyanMqttError_e result = RyanMqttSuccessError;
-	RyanMqttClientConfig_t mqttConfig = {.clientId = aaa,
+	RyanMqttClientConfig_t mqttConfig = {.clientId = count % 2 ? aaa : "", // 测试0长度字符串客户端ID
 					     .userName = RyanMqttUserName,
 					     .password = RyanMqttPassword,
 					     .host = RyanMqttHost,
@@ -199,7 +199,7 @@ RyanMqttError_e RyanMqttTestInit(RyanMqttClient_t **client, RyanMqttBool_e syncF
 	// 设置mqtt客户端config
 	result = RyanMqttSetConfig(*client, &mqttConfig);
 	RyanMqttCheck(RyanMqttSuccessError == result, result, RyanMqttLog_e);
-	// 重复设定一次测试
+	// 重复设定一次config测试
 	result = RyanMqttSetConfig(*client, &mqttConfig);
 	RyanMqttCheck(RyanMqttSuccessError == result, result, RyanMqttLog_e);
 
@@ -237,6 +237,15 @@ RyanMqttError_e RyanMqttTestInit(RyanMqttClient_t **client, RyanMqttBool_e syncF
 		return RyanMqttFailedError;
 	}
 
+	// 重复设定一次config测试
+	result = RyanMqttSetConfig(*client, &mqttConfig);
+	RyanMqttCheck(RyanMqttSuccessError == result, result, RyanMqttLog_e);
+
+	// 获取config测试
+	result = RyanMqttGetConfig(*client, &mqttConfig22);
+	RyanMqttCheck(RyanMqttSuccessError == result, result, RyanMqttLog_e);
+	RyanMqttFreeConfigFromGet(mqttConfig22);
+
 	return RyanMqttSuccessError;
 }