test: 增加内存故障测试

platform/linux/platformSystem.c

@@ -2,6 +2,10 @@
 #include "platformSystem.h"
 #include "RyanMqttPlatform.h"
 
+#ifdef RyanMqttLinuxTestEnable
+#include "RyanMqttTest.h"
+#endif
+
 /**
  * @brief 申请内存
  *
@@ -10,6 +14,22 @@
  */
 inline void *platformMemoryMalloc(size_t size)
 {
+#ifdef RyanMqttLinuxTestEnable
+	RyanMqttTestEnableCritical();
+	if (RyanMqttTrue == isEnableRandomMemoryFault)
+	{
+		memoryRandomCount++;
+		if (memoryRandomCount >= RyanRand(10, 100))
+		{
+			memoryRandomCount = 0;
+			RyanMqttTestExitCritical();
+			// printf("模拟没有空闲内存\r\n");
+			return NULL;
+		}
+	}
+	RyanMqttTestExitCritical();
+#endif
+
 	return malloc(size);
 }
 

test/RyanMqttMemoryFaultToleranceTest.c

@@ -0,0 +1,259 @@
+#include "RyanMqttTest.h"
+
+/**
+ * @brief 混乱随机的qos消息测试
+ *
+ * @param count
+ * @param delayms
+ * @return RyanMqttError_e
+ */
+static RyanMqttError_e RyanMqttNetworkFaultPublishHybridTest(int32_t count, uint32_t delayms)
+{
+
+#define RyanMqttPubHybridTestPubTopic "testlinux/aa/pub/adfa/kkk"
+#define RyanMqttPubHybridTestSubTopic "testlinux/aa/+/#"
+
+	RyanMqttError_e result = RyanMqttSuccessError;
+	RyanMqttClient_t *client;
+	char *pubStr = "hello, this is a mqtt publish test string.";
+	uint32_t pubStrLen = strlen(pubStr);
+
+	result = RyanMqttTestInit(&client, RyanMqttTrue, RyanMqttTrue, 120, NULL, NULL);
+	RyanMqttCheckCodeNoReturn(RyanMqttSuccessError == result, RyanMqttFailedError, RyanMqttLog_e, { goto __exit; });
+
+	// 等待订阅主题成功
+	RyanMqttSubscribe(client, RyanMqttPubHybridTestSubTopic, RyanMqttQos2);
+	RyanMqttSubscribe(client, RyanMqttPubHybridTestPubTopic, RyanMqttQos2);
+	delay(2);
+
+	enableRandomMemoryFault();
+	for (int32_t i = 0; i < count; i++)
+	{
+		if (RyanMqttConnectState != RyanMqttGetState(client))
+		{
+			RyanMqttLog_e("mqtt 发布测试，销毁mqtt客户端aaaaaaaaaaaaa %d", i);
+			goto __exit;
+		}
+
+		char *pubTopic = RyanMqttPubHybridTestPubTopic;
+		RyanMqttPublishWithUserData(client, pubTopic, RyanMqttStrlen(pubTopic), pubStr, pubStrLen, i % 3,
+					    RyanMqttFalse, NULL);
+
+		if (delayms)
+		{
+			delay(delayms);
+		}
+	}
+	delay(RyanMqttAckTimeout * 2 + 200);
+	RyanMqttUnSubscribe(client, RyanMqttPubHybridTestSubTopic);
+
+__exit:
+	disableRandomMemoryFault();
+	RyanMqttLog_i("mqtt 发布测试，销毁mqtt客户端");
+	RyanMqttTestDestroyClient(client);
+
+	return result;
+}
+
+static RyanMqttError_e RyanMqttNetworkFaultSubscribeHybridTest(int32_t count, int32_t testCount)
+{
+	RyanMqttError_e result = RyanMqttSuccessError;
+	RyanMqttClient_t *client;
+	RyanMqttUnSubscribeData_t *unSubscribeManyData = NULL;
+	RyanMqttSubscribeData_t *subscribeManyData = NULL;
+
+	result = RyanMqttTestInit(&client, RyanMqttTrue, RyanMqttTrue, 120, NULL, NULL);
+	RyanMqttCheckCodeNoReturn(RyanMqttSuccessError == result, RyanMqttFailedError, RyanMqttLog_e, { goto __exit; });
+
+	// 生成需要订阅的主题数据
+	{
+		subscribeManyData = (RyanMqttSubscribeData_t *)malloc(sizeof(RyanMqttSubscribeData_t) * count);
+		if (NULL == subscribeManyData)
+		{
+			RyanMqttLog_e("内存不足");
+			result = RyanMqttNotEnoughMemError;
+			goto __exit;
+		}
+
+		for (int32_t i = 0; i < count; i++)
+		{
+			subscribeManyData[i].qos = i % 3;
+			char *topic = (char *)malloc(64);
+			if (NULL == topic)
+			{
+				RyanMqttLog_e("内存不足");
+				result = RyanMqttNotEnoughMemError;
+				goto __exit;
+			}
+			RyanMqttSnprintf(topic, 64, "test/subscribe/%d", i);
+			subscribeManyData[i].topic = topic;
+			subscribeManyData[i].topicLen = RyanMqttStrlen(topic);
+		}
+	}
+
+	// 生成取消所有订阅消息
+	unSubscribeManyData = malloc(sizeof(RyanMqttUnSubscribeData_t) * count);
+	if (NULL == unSubscribeManyData)
+	{
+		RyanMqttLog_e("内存不足");
+		result = RyanMqttNotEnoughMemError;
+		goto __exit;
+	}
+	for (int32_t i = 0; i < count; i++)
+	{
+		char *topic = (char *)malloc(64);
+		if (NULL == topic)
+		{
+			RyanMqttLog_e("内存不足");
+			result = RyanMqttNotEnoughMemError;
+			goto __exit;
+		}
+		RyanMqttSnprintf(topic, 64, "test/subscribe/%d", i);
+		unSubscribeManyData[i].topic = topic;
+		unSubscribeManyData[i].topicLen = RyanMqttStrlen(topic);
+	}
+
+	enableRandomMemoryFault();
+	for (int32_t testCount2 = 0; testCount2 < testCount; testCount2++)
+	{
+		// 订阅全部主题
+		RyanMqttSubscribeMany(client, count - 1, subscribeManyData);
+
+		RyanMqttSubscribe(client, subscribeManyData[count - 1].topic, subscribeManyData[count - 1].qos);
+		// 测试重复订阅，不修改qos等级
+		RyanMqttSubscribeMany(client, count / 2, subscribeManyData);
+
+		// 测试重复订阅并且修改qos等级
+		for (int32_t i = count; i > 0; i--)
+		{
+			subscribeManyData[count - i].qos = i % 3;
+		}
+		RyanMqttSubscribeMany(client, count, subscribeManyData);
+		RyanMqttUnSubscribeMany(client, count - 1, unSubscribeManyData);
+		RyanMqttUnSubscribe(client, unSubscribeManyData[count - 1].topic);
+
+		// 重复取消订阅主题
+		RyanMqttUnSubscribeMany(client, count / 2, unSubscribeManyData);
+	}
+
+	delay(RyanMqttAckTimeout * 2 + 200);
+
+__exit:
+	disableRandomMemoryFault();
+	// 删除
+	for (int32_t i = 0; i < count; i++)
+	{
+		if (NULL != subscribeManyData && NULL != subscribeManyData[i].topic)
+		{
+			free(subscribeManyData[i].topic);
+		}
+
+		if (NULL != unSubscribeManyData && NULL != unSubscribeManyData[i].topic)
+		{
+			free(unSubscribeManyData[i].topic);
+		}
+	}
+
+	if (NULL != subscribeManyData)
+	{
+		free(subscribeManyData);
+	}
+
+	if (NULL != unSubscribeManyData)
+	{
+		free(unSubscribeManyData);
+	}
+
+	RyanMqttLog_i("mqtt 订阅测试，销毁mqtt客户端");
+	RyanMqttTestDestroyClient(client);
+
+	return result;
+}
+
+static RyanMqttError_e RyanMqttNetworkFaultHybridTest(int32_t count)
+{
+	RyanMqttError_e result = RyanMqttSuccessError;
+	RyanMqttClient_t *client;
+
+	result = RyanMqttTestInit(&client, RyanMqttTrue, RyanMqttTrue, 120, NULL, NULL);
+	RyanMqttCheckCodeNoReturn(RyanMqttSuccessError == result, RyanMqttFailedError, RyanMqttLog_e, { goto __exit; });
+
+	// 等待订阅主题成功
+	RyanMqttSubscribe(client, RyanMqttPubHybridTestSubTopic, RyanMqttQos2);
+	RyanMqttSubscribe(client, RyanMqttPubHybridTestPubTopic, RyanMqttQos2);
+	delay(2);
+
+	enableRandomMemoryFault();
+	for (int32_t i = 0; i < count; i++)
+	{
+		RyanMqttMsgHandler_t *msgHandles = NULL;
+		int32_t subscribeNum = 0;
+		RyanMqttGetSubscribeSafe(client, &msgHandles, &subscribeNum);
+		RyanMqttSafeFreeSubscribeResources(msgHandles, subscribeNum);
+
+		RyanMqttMsgHandler_t msgHandlesStatic[3] = {0};
+		RyanMqttGetSubscribe(client, msgHandlesStatic, getArraySize(msgHandlesStatic), &subscribeNum);
+
+		int32_t subscribeTotalCount = 0;
+		RyanMqttGetSubscribeTotalCount(client, &subscribeTotalCount);
+
+		RyanMqttGetState(client);
+
+		uint32_t keepAliveRemain = 0;
+		RyanMqttGetKeepAliveRemain(client, &keepAliveRemain);
+
+		RyanMqttClientConfig_t *pclientConfig = NULL;
+		RyanMqttGetConfig(client, &pclientConfig);
+
+		// 不管 pclientConfig 是否有效
+		RyanMqttSetConfig(client, pclientConfig);
+
+		RyanMqttFreeConfigFromGet(pclientConfig);
+
+		RyanMqttSetLwt(client, "pub/lwt/test", "this is will", RyanMqttStrlen("this is will"), RyanMqttQos2, 0);
+
+		RyanMqttDiscardAckHandler(client, MQTT_PACKET_TYPE_PUBACK, 1);
+
+		RyanMqttEventId_e eventId = RyanMqttEventAnyId;
+
+		RyanMqttGetEventId(client, &eventId);
+
+		RyanMqttCancelEventId(client, eventId);
+
+		RyanMqttRegisterEventId(client, eventId);
+	}
+
+	RyanMqttUnSubscribe(client, RyanMqttPubHybridTestSubTopic);
+
+__exit:
+	disableRandomMemoryFault();
+	RyanMqttTestDestroyClient(client);
+	return result;
+}
+
+/**
+ * @brief 内存故障测试
+ *
+ * @return RyanMqttError_e
+ */
+RyanMqttError_e RyanMqttMemoryFaultToleranceTest(void)
+{
+	RyanMqttError_e result = RyanMqttSuccessError;
+
+	result = RyanMqttNetworkFaultPublishHybridTest(2000, 1);
+	RyanMqttCheckCodeNoReturn(RyanMqttSuccessError == result, RyanMqttFailedError, RyanMqttLog_e, { goto __exit; });
+	checkMemory;
+
+	result = RyanMqttNetworkFaultSubscribeHybridTest(2000, 5);
+	RyanMqttCheckCodeNoReturn(RyanMqttSuccessError == result, RyanMqttFailedError, RyanMqttLog_e, { goto __exit; });
+	checkMemory;
+
+	result = RyanMqttNetworkFaultHybridTest(5000);
+	RyanMqttCheckCodeNoReturn(RyanMqttSuccessError == result, RyanMqttFailedError, RyanMqttLog_e, { goto __exit; });
+	checkMemory;
+
+	return RyanMqttSuccessError;
+
+__exit:
+	return RyanMqttFailedError;
+}

test/RyanMqttNetworkFaultQosResilienceTest.c

@@ -114,11 +114,11 @@ static RyanMqttError_e RyanMqttNetworkFaultQosResiliencePublishTest(int32_t coun
 		delay(1);
 	}
 
-	exportQos = RyanMqttSubFail;
+	exportQos = qos;
 
 	// 生成随机的数据包大小
 	{
-		pubStr = (char *)platformMemoryMalloc(2048);
+		pubStr = (char *)malloc(2048);
 		RyanMqttCheck(NULL != pubStr, RyanMqttNotEnoughMemError, RyanMqttLog_e);
 		RyanMqttMemset(pubStr, 0, 2048);
 
@@ -191,8 +191,7 @@ static RyanMqttError_e RyanMqttNetworkFaultQosResiliencePublishTest(int32_t coun
 		{
 			if (pubTestPublishedEventCount >= sendNeedAckCount
 			    // 不要求接收数据也全部到达，跟emqx服务器关系太大了
-			    //   &&  pubTestDataEventCount >= sendNeedAckCount
-			)
+			    && pubTestDataEventCount >= sendNeedAckCount)
 			{
 				break;
 			}
@@ -234,7 +233,7 @@ static RyanMqttError_e RyanMqttNetworkFaultQosResiliencePublishTest(int32_t coun
 
 __exit:
 	disableRandomNetworkFault();
-	platformMemoryFree(pubStr);
+	free(pubStr);
 	pubStr = NULL;
 	RyanMqttLog_i("mqtt 测试，销毁mqtt客户端");
 	RyanMqttTestDestroyClient(client);
@@ -250,15 +249,15 @@ RyanMqttError_e RyanMqttNetworkFaultQosResilienceTest(void)
 {
 	RyanMqttError_e result = RyanMqttSuccessError;
 
-	result = RyanMqttNetworkFaultQosResiliencePublishTest(500, 1, RyanMqttQos0);
+	result = RyanMqttNetworkFaultQosResiliencePublishTest(700, 0, RyanMqttQos0);
 	RyanMqttCheckCodeNoReturn(RyanMqttSuccessError == result, result, RyanMqttLog_e, { goto __exit; });
 	checkMemory;
 
-	result = RyanMqttNetworkFaultQosResiliencePublishTest(500, 2, RyanMqttQos1);
+	result = RyanMqttNetworkFaultQosResiliencePublishTest(1300, 2, RyanMqttQos1);
 	RyanMqttCheckCodeNoReturn(RyanMqttSuccessError == result, result, RyanMqttLog_e, { goto __exit; });
 	checkMemory;
 
-	result = RyanMqttNetworkFaultQosResiliencePublishTest(500, 4, RyanMqttQos2);
+	result = RyanMqttNetworkFaultQosResiliencePublishTest(1700, 4, RyanMqttQos2);
 	RyanMqttCheckCodeNoReturn(RyanMqttSuccessError == result, result, RyanMqttLog_e, { goto __exit; });
 	checkMemory;
 

test/RyanMqttNetworkFaultToleranceMemoryTest.c → test/RyanMqttNetworkFaultToleranceMemoryTest copy.c

@@ -23,8 +23,10 @@ static RyanMqttError_e RyanMqttNetworkFaultPublishHybridTest(int32_t count, uint
 
 	// 等待订阅主题成功
 	RyanMqttSubscribe(client, RyanMqttPubHybridTestSubTopic, RyanMqttQos2);
+	RyanMqttSubscribe(client, RyanMqttPubHybridTestPubTopic, RyanMqttQos2);
 	delay(2);
 
+	enableRandomNetworkFault();
 	for (int32_t i = 0; i < count; i++)
 	{
 		if (RyanMqttConnectState != RyanMqttGetState(client))
@@ -46,7 +48,7 @@ static RyanMqttError_e RyanMqttNetworkFaultPublishHybridTest(int32_t count, uint
 	RyanMqttUnSubscribe(client, RyanMqttPubHybridTestSubTopic);
 
 __exit:
-
+	disableRandomNetworkFault();
 	RyanMqttLog_i("mqtt 发布测试，销毁mqtt客户端");
 	RyanMqttTestDestroyClient(client);
 	return result;
@@ -64,8 +66,7 @@ static RyanMqttError_e RyanMqttNetworkFaultSubscribeHybridTest(int32_t count, in
 
 	// 生成需要订阅的主题数据
 	{
-		subscribeManyData =
-			(RyanMqttSubscribeData_t *)platformMemoryMalloc(sizeof(RyanMqttSubscribeData_t) * count);
+		subscribeManyData = (RyanMqttSubscribeData_t *)malloc(sizeof(RyanMqttSubscribeData_t) * count);
 		if (NULL == subscribeManyData)
 		{
 			RyanMqttLog_e("内存不足");
@@ -76,7 +77,7 @@ static RyanMqttError_e RyanMqttNetworkFaultSubscribeHybridTest(int32_t count, in
 		for (int32_t i = 0; i < count; i++)
 		{
 			subscribeManyData[i].qos = i % 3;
-			char *topic = (char *)platformMemoryMalloc(64);
+			char *topic = (char *)malloc(64);
 			if (NULL == topic)
 			{
 				RyanMqttLog_e("内存不足");
@@ -90,7 +91,7 @@ static RyanMqttError_e RyanMqttNetworkFaultSubscribeHybridTest(int32_t count, in
 	}
 
 	// 生成取消所有订阅消息
-	unSubscribeManyData = platformMemoryMalloc(sizeof(RyanMqttUnSubscribeData_t) * count);
+	unSubscribeManyData = malloc(sizeof(RyanMqttUnSubscribeData_t) * count);
 	if (NULL == unSubscribeManyData)
 	{
 		RyanMqttLog_e("内存不足");
@@ -99,7 +100,7 @@ static RyanMqttError_e RyanMqttNetworkFaultSubscribeHybridTest(int32_t count, in
 	}
 	for (int32_t i = 0; i < count; i++)
 	{
-		char *topic = (char *)platformMemoryMalloc(64);
+		char *topic = (char *)malloc(64);
 		if (NULL == topic)
 		{
 			RyanMqttLog_e("内存不足");
@@ -111,6 +112,7 @@ static RyanMqttError_e RyanMqttNetworkFaultSubscribeHybridTest(int32_t count, in
 		unSubscribeManyData[i].topicLen = RyanMqttStrlen(topic);
 	}
 
+	enableRandomNetworkFault();
 	for (int32_t testCount2 = 0; testCount2 < testCount; testCount2++)
 	{
 		// 订阅全部主题
@@ -134,28 +136,29 @@ static RyanMqttError_e RyanMqttNetworkFaultSubscribeHybridTest(int32_t count, in
 	}
 
 __exit:
+	disableRandomNetworkFault();
 	// 删除
 	for (int32_t i = 0; i < count; i++)
 	{
 		if (NULL != subscribeManyData && NULL != subscribeManyData[i].topic)
 		{
-			platformMemoryFree(subscribeManyData[i].topic);
+			free(subscribeManyData[i].topic);
 		}
 
 		if (NULL != unSubscribeManyData && NULL != unSubscribeManyData[i].topic)
 		{
-			platformMemoryFree(unSubscribeManyData[i].topic);
+			free(unSubscribeManyData[i].topic);
 		}
 	}
 
 	if (NULL != subscribeManyData)
 	{
-		platformMemoryFree(subscribeManyData);
+		free(subscribeManyData);
 	}
 
 	if (NULL != unSubscribeManyData)
 	{
-		platformMemoryFree(unSubscribeManyData);
+		free(unSubscribeManyData);
 	}
 
 	RyanMqttLog_i("mqtt 订阅测试，销毁mqtt客户端");
@@ -171,7 +174,6 @@ __exit:
 RyanMqttError_e RyanMqttNetworkFaultToleranceMemoryTest(void)
 {
 	RyanMqttError_e result = RyanMqttSuccessError;
-	enableRandomNetworkFault();
 
 	result = RyanMqttNetworkFaultPublishHybridTest(2000, 1);
 	RyanMqttCheckCodeNoReturn(RyanMqttSuccessError == result, RyanMqttFailedError, RyanMqttLog_e, { goto __exit; });
@@ -181,10 +183,8 @@ RyanMqttError_e RyanMqttNetworkFaultToleranceMemoryTest(void)
 	RyanMqttCheckCodeNoReturn(RyanMqttSuccessError == result, RyanMqttFailedError, RyanMqttLog_e, { goto __exit; });
 	checkMemory;
 
-	disableRandomNetworkFault();
 	return RyanMqttSuccessError;
 
 __exit:
-	disableRandomNetworkFault();
 	return RyanMqttFailedError;
 }

test/RyanMqttPubTest.c

@@ -116,7 +116,7 @@ static RyanMqttError_e RyanMqttPublishTest(RyanMqttQos_e qos, int32_t count, uin
 
 	// 生成随机的数据包大小
 	{
-		pubStr = (char *)platformMemoryMalloc(2048);
+		pubStr = (char *)malloc(2048);
 		RyanMqttCheck(NULL != pubStr, RyanMqttNotEnoughMemError, RyanMqttLog_e);
 		RyanMqttMemset(pubStr, 0, 2048);
 
@@ -183,7 +183,7 @@ static RyanMqttError_e RyanMqttPublishTest(RyanMqttQos_e qos, int32_t count, uin
 	RyanMqttCheckCodeNoReturn(RyanMqttSuccessError == result, RyanMqttFailedError, RyanMqttLog_e, { goto __exit; });
 
 __exit:
-	platformMemoryFree(pubStr);
+	free(pubStr);
 	pubStr = NULL;
 	RyanMqttLog_i("mqtt 发布测试，销毁mqtt客户端");
 	RyanMqttTestDestroyClient(client);
@@ -239,7 +239,7 @@ static RyanMqttError_e RyanMqttPublishHybridTest(int32_t count, uint32_t delayms
 
 	// 生成随机的数据包大小
 	{
-		pubStr = (char *)platformMemoryMalloc(2048);
+		pubStr = (char *)malloc(2048);
 		RyanMqttCheck(NULL != pubStr, RyanMqttNotEnoughMemError, RyanMqttLog_e);
 		RyanMqttMemset(pubStr, 0, 2048);
 
@@ -305,7 +305,7 @@ static RyanMqttError_e RyanMqttPublishHybridTest(int32_t count, uint32_t delayms
 	RyanMqttCheckCodeNoReturn(RyanMqttSuccessError == result, RyanMqttFailedError, RyanMqttLog_e, { goto __exit; });
 
 __exit:
-	platformMemoryFree(pubStr);
+	free(pubStr);
 	pubStr = NULL;
 	RyanMqttLog_i("mqtt 发布测试，销毁mqtt客户端");
 	RyanMqttTestDestroyClient(client);

test/RyanMqttPublicApiParamCheckTest.c

@@ -70,6 +70,15 @@ static RyanMqttError_e RyanMqttBaseApiParamCheckTest(void)
 	result = RyanMqttDiscardAckHandler(validClient, MQTT_PACKET_TYPE_PUBACK, RyanMqttMaxPacketId + 1);
 	RyanMqttCheckCodeNoReturn(RyanMqttParamInvalidError == result, result, RyanMqttLog_e, { goto __exit; });
 
+	RyanMqttEventId_e eventId = RyanMqttEventConnected;
+	// NULL客户端指针
+	result = RyanMqttGetEventId(NULL, &eventId);
+	RyanMqttCheckCodeNoReturn(RyanMqttParamInvalidError == result, result, RyanMqttLog_e, { goto __exit; });
+
+	// NULL eventId指针
+	result = RyanMqttGetEventId(validClient, NULL);
+	RyanMqttCheckCodeNoReturn(RyanMqttParamInvalidError == result, result, RyanMqttLog_e, { goto __exit; });
+
 	// NULL客户端指针
 	result = RyanMqttRegisterEventId(NULL, RyanMqttEventConnected);
 	RyanMqttCheckCodeNoReturn(RyanMqttParamInvalidError == result, result, RyanMqttLog_e, { goto __exit; });
@@ -374,6 +383,10 @@ static RyanMqttError_e RyanMqttSubApiParamCheckTest(void)
 		unsubscribeData[i].topicLen = strlen("test/topic2");
 	}
 
+	/**
+	 * @brief
+	 *
+	 */
 	RyanMqttMsgHandler_t *msgHandles = NULL;
 	int32_t subscribeNum = 0;
 	int32_t totalCount = 0;
@@ -393,10 +406,6 @@ static RyanMqttError_e RyanMqttSubApiParamCheckTest(void)
 	result = RyanMqttSafeFreeSubscribeResources(NULL, 5);
 	RyanMqttCheckCodeNoReturn(RyanMqttParamInvalidError == result, result, RyanMqttLog_e, { goto __exit; });
 
-	// !一定失败否则要报错
-	result = RyanMqttSafeFreeSubscribeResources((void *)&msgHandles, 0);
-	RyanMqttCheckCodeNoReturn(RyanMqttParamInvalidError == result, result, RyanMqttLog_e, { goto __exit; });
-
 	// NULL客户端指针
 	result = RyanMqttGetSubscribeTotalCount(NULL, &totalCount);
 	RyanMqttCheckCodeNoReturn(RyanMqttParamInvalidError == result, result, RyanMqttLog_e, { goto __exit; });
@@ -405,6 +414,24 @@ static RyanMqttError_e RyanMqttSubApiParamCheckTest(void)
 	result = RyanMqttGetSubscribeTotalCount(validClient, NULL);
 	RyanMqttCheckCodeNoReturn(RyanMqttParamInvalidError == result, result, RyanMqttLog_e,
 				  { goto __exit; }); // 清理资源
+
+	/**
+	 * @brief
+	 *
+	 */
+	RyanMqttMsgHandler_t msgHandlesStatic[3] = {0};
+	RyanMqttGetSubscribe(NULL, msgHandlesStatic, getArraySize(msgHandlesStatic), &subscribeNum);
+	RyanMqttCheckCodeNoReturn(RyanMqttParamInvalidError == result, result, RyanMqttLog_e, { goto __exit; });
+
+	RyanMqttGetSubscribe(validClient, NULL, getArraySize(msgHandlesStatic), &subscribeNum);
+	RyanMqttCheckCodeNoReturn(RyanMqttParamInvalidError == result, result, RyanMqttLog_e, { goto __exit; });
+
+	RyanMqttGetSubscribe(validClient, msgHandlesStatic, 0, &subscribeNum);
+	RyanMqttCheckCodeNoReturn(RyanMqttParamInvalidError == result, result, RyanMqttLog_e, { goto __exit; });
+
+	RyanMqttGetSubscribe(validClient, msgHandlesStatic, getArraySize(msgHandlesStatic), NULL);
+	RyanMqttCheckCodeNoReturn(RyanMqttParamInvalidError == result, result, RyanMqttLog_e, { goto __exit; });
+
 	if (validClient)
 	{
 		RyanMqttTestDestroyClient(validClient);

test/RyanMqttSubTest.c

@@ -177,7 +177,7 @@ static RyanMqttError_e RyanMqttSubscribeHybridTest(int32_t count, int32_t testCo
 	// 生成需要订阅的主题数据
 	{
 		subscribeManyData =
-			(RyanMqttSubscribeData_t *)platformMemoryMalloc(sizeof(RyanMqttSubscribeData_t) * count);
+			(RyanMqttSubscribeData_t *)malloc(sizeof(RyanMqttSubscribeData_t) * count);
 		if (NULL == subscribeManyData)
 		{
 			RyanMqttLog_e("内存不足");
@@ -188,7 +188,7 @@ static RyanMqttError_e RyanMqttSubscribeHybridTest(int32_t count, int32_t testCo
 		for (int32_t i = 0; i < count; i++)
 		{
 			subscribeManyData[i].qos = i % 3;
-			char *topic = (char *)platformMemoryMalloc(32);
+			char *topic = (char *)malloc(32);
 			if (NULL == topic)
 			{
 				RyanMqttLog_e("内存不足");
@@ -202,7 +202,7 @@ static RyanMqttError_e RyanMqttSubscribeHybridTest(int32_t count, int32_t testCo
 	}
 
 	// 生成取消所有订阅消息
-	unSubscribeManyData = platformMemoryMalloc(sizeof(RyanMqttUnSubscribeData_t) * count);
+	unSubscribeManyData = malloc(sizeof(RyanMqttUnSubscribeData_t) * count);
 	if (NULL == unSubscribeManyData)
 	{
 		RyanMqttLog_e("内存不足");
@@ -211,7 +211,7 @@ static RyanMqttError_e RyanMqttSubscribeHybridTest(int32_t count, int32_t testCo
 	}
 	for (int32_t i = 0; i < count; i++)
 	{
-		char *topic = (char *)platformMemoryMalloc(32);
+		char *topic = (char *)malloc(32);
 		if (NULL == topic)
 		{
 			RyanMqttLog_e("内存不足");
@@ -267,6 +267,12 @@ static RyanMqttError_e RyanMqttSubscribeHybridTest(int32_t count, int32_t testCo
 		RyanMqttCheckCodeNoReturn(RyanMqttSuccessError == result, RyanMqttFailedError, RyanMqttLog_e,
 					  { goto __exit; });
 
+		// !emqx服务器有时候会误判新的订阅请求为重复订阅主题，导致订阅失败
+		// 重复取消订阅主题
+		result = RyanMqttUnSubscribeMany(client, count / 2, unSubscribeManyData);
+		RyanMqttCheckCodeNoReturn(RyanMqttSuccessError == result, RyanMqttFailedError, RyanMqttLog_e,
+					  { goto __exit; });
+
 		for (int32_t i = 0; i < 600; i++)
 		{
 			delay(100);
@@ -285,14 +291,8 @@ static RyanMqttError_e RyanMqttSubscribeHybridTest(int32_t count, int32_t testCo
 			}
 		}
 
-		// !emqx服务器有时候会误判新的订阅请求为重复订阅主题，导致订阅失败
-		// // 重复取消订阅主题
-		// result = RyanMqttUnSubscribeMany(client, count / 2, unSubscribeManyData);
-		// RyanMqttCheckCodeNoReturn(RyanMqttSuccessError == result, RyanMqttFailedError, RyanMqttLog_e,
-		// 			  { goto __exit; });
-
-		// // 有重复取消订阅主题，增加延时，防止emqx服务器误判新的订阅请求
-		// delay(300);
+		// 有重复取消订阅主题，增加延时，防止emqx服务器误判新的订阅请求
+		delay(100);
 	}
 
 	result = checkAckList(client);
@@ -305,23 +305,23 @@ __exit:
 	{
 		if (NULL != subscribeManyData && NULL != subscribeManyData[i].topic)
 		{
-			platformMemoryFree(subscribeManyData[i].topic);
+			free(subscribeManyData[i].topic);
 		}
 
 		if (NULL != unSubscribeManyData && NULL != unSubscribeManyData[i].topic)
 		{
-			platformMemoryFree(unSubscribeManyData[i].topic);
+			free(unSubscribeManyData[i].topic);
 		}
 	}
 
 	if (NULL != subscribeManyData)
 	{
-		platformMemoryFree(subscribeManyData);
+		free(subscribeManyData);
 	}
 
 	if (NULL != unSubscribeManyData)
 	{
-		platformMemoryFree(unSubscribeManyData);
+		free(unSubscribeManyData);
 	}
 
 	RyanMqttLog_i("mqtt 订阅测试，销毁mqtt客户端");

test/RyanMqttTest.c

@@ -1,50 +1,5 @@
 #include "RyanMqttTest.h"
 
-static pthread_spinlock_t spin;
-uint32_t destroyCount = 0;
-
-uint32_t randomCount = 0;
-uint32_t sendRandomCount = 0;
-RyanMqttBool_e isEnableRandomNetworkFault = RyanMqttFalse;
-void enableRandomNetworkFault(void)
-{
-	RyanMqttTestEnableCritical();
-	isEnableRandomNetworkFault = RyanMqttTrue;
-	RyanMqttTestExitCritical();
-}
-
-void disableRandomNetworkFault(void)
-{
-	RyanMqttTestEnableCritical();
-	isEnableRandomNetworkFault = RyanMqttFalse;
-	RyanMqttTestExitCritical();
-}
-
-void toggleRandomNetworkFault(void)
-{
-	RyanMqttTestEnableCritical();
-	isEnableRandomNetworkFault = !isEnableRandomNetworkFault;
-	RyanMqttTestExitCritical();
-}
-
-uint32_t RyanRand(int32_t min, int32_t max)
-{
-	static uint32_t isSeed = 0;
-	static uint32_t seedp = 0;
-	if (isSeed > 1024 || 0 == seedp)
-	{
-		seedp = platformUptimeMs();
-		isSeed = 0;
-	}
-
-	if (min >= max)
-	{
-		return min;
-	}
-	isSeed++;
-	return (rand_r(&seedp) % (max - min + 1)) + min;
-}
-
 /**
  * @brief mqtt事件回调处理函数
  * 事件的详细定义可以查看枚举定义
@@ -193,7 +148,7 @@ RyanMqttError_e RyanMqttTestInit(RyanMqttClient_t **client, RyanMqttBool_e syncF
 	RyanMqttSnprintf(aaa, sizeof(aaa), "%s%d", RyanMqttClientId, count);
 
 	struct RyanMqttTestEventUserData *eventUserData =
-		(struct RyanMqttTestEventUserData *)platformMemoryMalloc(sizeof(struct RyanMqttTestEventUserData));
+		(struct RyanMqttTestEventUserData *)malloc(sizeof(struct RyanMqttTestEventUserData));
 	if (NULL == eventUserData)
 	{
 		RyanMqttLog_e("内存不足");
@@ -285,14 +240,28 @@ RyanMqttError_e RyanMqttTestInit(RyanMqttClient_t **client, RyanMqttBool_e syncF
 	return RyanMqttSuccessError;
 }
 
+typedef struct
+{
+	void *ptr;
+	timer_t timerid;
+} FreeTimerArg;
+
 static void RyanMqttTestFreeTimerCallback(union sigval arg)
 {
-	void *ptr = arg.sival_ptr;
-	platformMemoryFree(ptr);
+	FreeTimerArg *fta = arg.sival_ptr;
+	free(fta->ptr);
 
 	RyanMqttTestEnableCritical();
 	destroyCount--;
 	RyanMqttTestExitCritical();
+
+	timer_t timerid = fta->timerid;
+	free(fta); // 释放参数结构
+
+	if (0 != timer_delete(timerid))
+	{
+		RyanMqttLog_e("timer_delete failed");
+	}
 }
 
 static void RyanMqttTestScheduleFreeAfterMs(void *ptr, uint32_t delayMs)
@@ -305,16 +274,22 @@ static void RyanMqttTestScheduleFreeAfterMs(void *ptr, uint32_t delayMs)
 	struct sigevent sev = {0};
 	struct itimerspec its = {0};
 
+	FreeTimerArg *fta = malloc(sizeof(FreeTimerArg));
+	fta->ptr = ptr;
+
 	sev.sigev_notify = SIGEV_THREAD;
-	sev.sigev_value.sival_ptr = ptr;                           // 传递给回调的参数
+	sev.sigev_value.sival_ptr = fta;                           // 传递给回调的参数
 	sev.sigev_notify_function = RyanMqttTestFreeTimerCallback; // 定时到期时调用的函数
 
 	if (0 != timer_create(CLOCK_REALTIME, &sev, &timerid))
 	{
 		RyanMqttLog_e("timer_create failed");
+		free(fta);
 		return;
 	}
 
+	fta->timerid = timerid;
+
 	// 毫秒转秒和纳秒
 	its.it_value.tv_sec = delayMs / 1000;
 	its.it_value.tv_nsec = (uint32_t)((delayMs % 1000) * 1000000);
@@ -322,6 +297,13 @@ static void RyanMqttTestScheduleFreeAfterMs(void *ptr, uint32_t delayMs)
 	if (0 != timer_settime(timerid, 0, &its, NULL))
 	{
 		RyanMqttLog_e("timer_settime failed");
+
+		if (0 != timer_delete(timerid))
+		{
+			RyanMqttLog_e("timer_delete failed");
+		}
+
+		free(fta);
 		return;
 	}
 }
@@ -346,7 +328,7 @@ RyanMqttError_e RyanMqttTestDestroyClient(RyanMqttClient_t *client)
 		sem_destroy(&eventUserData->sem);
 
 		delay(20); // 等待mqtt线程回收资源
-		platformMemoryFree(eventUserData);
+		free(eventUserData);
 	}
 	else
 	{
@@ -391,49 +373,15 @@ RyanMqttError_e checkAckList(RyanMqttClient_t *client)
 	return RyanMqttSuccessError;
 }
 
-void printfArrStr(uint8_t *buf, uint32_t len, char *userData)
-{
-	RyanMqttLog_raw("%s len: %d ", userData, len);
-	for (uint32_t i = 0; i < len; i++)
-	{
-		RyanMqttLog_raw("%c", buf[i]);
-	}
-
-	RyanMqttLog_raw("\r\n");
-}
-
-void RyanMqttTestEnableCritical(void)
-{
-	pthread_spin_lock(&spin);
-}
-
-void RyanMqttTestExitCritical(void)
-{
-	pthread_spin_unlock(&spin);
-}
-
 // 注意测试代码只有特定emqx服务器才可以通过，用户的emqx服务器大概率通过不了，
 // 因为有些依赖emqx的配置，比如消息重试间隔，最大飞行窗口，最大消息队列等
 // todo 增加session测试
 // !当测试程序出错时，并不会回收内存。交由父进程进行回收
 int main(void)
 {
-	// 多线程测试必须设置这个，否则会导致 heap-use-after-free, 原因如下
-	// 虽然也有办法解决，不过RyanMqtt目标为嵌入式场景，不想引入需要更多资源的逻辑，嵌入式场景目前想不到有这么频繁而且还是本机emqx的场景。
-
-	// 用户线程send -> emqx回复报文 -> mqtt线程recv。
-	// recv线程收到数据后，会释放用户线程send的sendbuf缓冲区。
-	// 但是在本机部署的emqx并且多核心同时运行，发送的数据量非常大的情况下会出现mqtt线程recv已经收到数据，但是用户线程send函数还没有返回。
-	cpu_set_t cpuset;
-	CPU_ZERO(&cpuset);
-	CPU_SET(0, &cpuset);
-	pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
-	sched_setaffinity(0, sizeof(cpu_set_t), &cpuset);
+	RyanMqttTestUtileInit();
 
 	RyanMqttError_e result = RyanMqttSuccessError;
-	vallocInit();
-
-	pthread_spin_init(&spin, PTHREAD_PROCESS_PRIVATE);
 
 	uint32_t testRunCount = 0;
 	uint32_t funcStartMs;
@@ -444,27 +392,34 @@ int main(void)
 		RyanMqttLog_raw("┌── [TEST %d] 开始执行: " #fun "()\r\n", testRunCount);                               \
 		funcStartMs = platformUptimeMs();                                                                      \
 		result = fun();                                                                                        \
-		RyanMqttLog_raw("└── [TEST %d] 结束执行: 返回值 = %d %s | 耗时: %d ms\x1b[0m\r\n\r\n\r\n",             \
-				testRunCount, result, (result == RyanMqttSuccessError) ? "✅" : "❌",                  \
+		RyanMqttLog_raw("└── [TEST %d] 结束执行: 返回值 = %d %s | 耗时: %d ms\x1b[0m\r\n\r\n", testRunCount,   \
+				result, (result == RyanMqttSuccessError) ? "✅" : "❌",                                \
 				platformUptimeMs() - funcStartMs);                                                     \
 		RyanMqttCheckCodeNoReturn(RyanMqttSuccessError == result, result, RyanMqttLog_e, { goto __exit; });    \
 	} while (0)
 
 	uint32_t totalElapsedStartMs = platformUptimeMs();
 	runTestWithLogAndTimer(RyanMqttPublicApiParamCheckTest);
+	runTestWithLogAndTimer(RyanMqttMemoryFaultToleranceTest);
+
 	runTestWithLogAndTimer(RyanMqttSubTest);
 	runTestWithLogAndTimer(RyanMqttPubTest);
+
 	runTestWithLogAndTimer(RyanMqttDestroyTest);
+
 	runTestWithLogAndTimer(RyanMqttNetworkFaultToleranceMemoryTest);
 	runTestWithLogAndTimer(RyanMqttNetworkFaultQosResilienceTest);
+
 	runTestWithLogAndTimer(RyanMqttMultiThreadMultiClientTest);
 	runTestWithLogAndTimer(RyanMqttMultiThreadSafetyTest);
+
 	runTestWithLogAndTimer(RyanMqttReconnectTest);
 	runTestWithLogAndTimer(RyanMqttKeepAliveTest);
+
+	// 暂时不开放出来
 	// runTestWithLogAndTimer(RyanMqttWildcardTest);
 
 __exit:
-	pthread_spin_destroy(&spin);
 
 	RyanMqttLog_raw("测试总耗时: %.3f S\r\n", (platformUptimeMs() - totalElapsedStartMs) / 1000.0);
 
@@ -482,5 +437,7 @@ __exit:
 		displayMem();
 		delay(300);
 	}
+
+	RyanMqttTestUtileDeInit();
 	return 0;
 }

test/RyanMqttTest.h

@@ -17,10 +17,6 @@ extern "C" {
 #include <pthread.h>
 #include <sched.h>
 #include "valloc.h"
-#define malloc  v_malloc
-#define calloc  v_calloc
-#define free    v_free
-#define realloc v_realloc
 
 #ifndef RyanMqttLogLevel
 #define RyanMqttLogLevel (RyanMqttLogLevelError) // 日志打印等级
@@ -31,6 +27,8 @@ extern "C" {
 #include "RyanMqttClient.h"
 #include "RyanMqttUtil.h"
 
+#include "RyanMqttTestUtile.h"
+
 #define RyanMqttClientId ("RyanMqttTest888") // 填写mqtt客户端id，要求唯一
 // #define RyanMqttHost ("127.0.0.1")           // 填写你的mqtt服务器ip
 #define RyanMqttHost     ("localhost") // 填写你的mqtt服务器ip
@@ -45,53 +43,9 @@ extern "C" {
 #define RyanMqttSendTimeout      (1800) // 发送数据超时时间，单位ms
 #define RyanMqttAckTimeout       (3000) // 等待ack超时时间，单位ms
 
-#define delay(ms)         usleep((ms) * 1000)
-#define delay_us(us)      usleep((us))
-#define getArraySize(arr) ((int32_t)(sizeof(arr) / sizeof((arr)[0])))
-extern uint32_t destroyCount;
-
-#define checkMemory                                                                                                    \
-	do                                                                                                             \
-	{                                                                                                              \
-		for (uint32_t aaa = 0;; aaa++)                                                                         \
-		{                                                                                                      \
-			RyanMqttTestEnableCritical();                                                                  \
-			uint32_t destoryCount2 = destroyCount;                                                         \
-			RyanMqttTestExitCritical();                                                                    \
-			if (0 == destoryCount2) break;                                                                 \
-			if (aaa > 10 * 1000)                                                                           \
-			{                                                                                              \
-				printf("aaaaaaaa %d\r\n", destoryCount2);                                              \
-				break;                                                                                 \
-			}                                                                                              \
-			delay(1);                                                                                      \
-		}                                                                                                      \
-		int area = 0, use = 0;                                                                                 \
-		v_mcheck(&area, &use);                                                                                 \
-		if (area != 0 || use != 0)                                                                             \
-		{                                                                                                      \
-			RyanMqttLog_e("内存泄漏");                                                                     \
-			while (1)                                                                                      \
-			{                                                                                              \
-				v_mcheck(&area, &use);                                                                 \
-				RyanMqttLog_e("|||----------->>> area = %d, size = %d", area, use);                    \
-				delay(3000);                                                                           \
-			}                                                                                              \
-		}                                                                                                      \
-	} while (0)
-
-extern uint32_t randomCount;
-extern uint32_t sendRandomCount;
-extern RyanMqttBool_e isEnableRandomNetworkFault;
-extern void enableRandomNetworkFault(void);
-extern void disableRandomNetworkFault(void);
-extern void toggleRandomNetworkFault(void);
-extern uint32_t RyanRand(int32_t min, int32_t max);
-
 // 定义枚举类型
 
 // 定义结构体类型
-#define RyanMqttTestEventUserDataMagic (123456789)
 struct RyanMqttTestEventUserData
 {
 	uint32_t magic; // 防止野指针
@@ -100,16 +54,12 @@ struct RyanMqttTestEventUserData
 	void *userData;
 };
 /* extern variables-----------------------------------------------------------*/
-
-extern void RyanMqttTestEnableCritical(void);
-extern void RyanMqttTestExitCritical(void);
 extern RyanMqttError_e RyanMqttTestInit(RyanMqttClient_t **client, RyanMqttBool_e syncFlag,
 					RyanMqttBool_e autoReconnectFlag, uint16_t keepaliveTimeoutS,
 					RyanMqttEventHandle mqttEventCallback, void *userData);
 extern RyanMqttError_e RyanMqttTestDestroyClient(RyanMqttClient_t *client);
 extern void mqttEventBaseHandle(void *pclient, RyanMqttEventId_e event, const void *eventData);
 extern RyanMqttError_e checkAckList(RyanMqttClient_t *client);
-extern void printfArrStr(uint8_t *buf, uint32_t len, char *userData);
 
 extern RyanMqttError_e RyanMqttDestroyTest(void);
 extern RyanMqttError_e RyanMqttKeepAliveTest(void);
@@ -122,6 +72,7 @@ extern RyanMqttError_e RyanMqttMultiThreadSafetyTest(void);
 extern RyanMqttError_e RyanMqttPublicApiParamCheckTest(void);
 extern RyanMqttError_e RyanMqttNetworkFaultToleranceMemoryTest(void);
 extern RyanMqttError_e RyanMqttNetworkFaultQosResilienceTest(void);
+extern RyanMqttError_e RyanMqttMemoryFaultToleranceTest(void);
 
 #ifdef __cplusplus
 }

test/RyanMqttTestUtile.c

@@ -0,0 +1,113 @@
+#include "RyanMqttTest.h"
+
+static pthread_spinlock_t spin;
+uint32_t destroyCount = 0;
+
+uint32_t randomCount = 0;
+uint32_t sendRandomCount = 0;
+uint32_t memoryRandomCount = 0;
+RyanMqttBool_e isEnableRandomNetworkFault = RyanMqttFalse;
+RyanMqttBool_e isEnableRandomMemoryFault = RyanMqttFalse;
+void enableRandomNetworkFault(void)
+{
+	RyanMqttTestEnableCritical();
+	isEnableRandomNetworkFault = RyanMqttTrue;
+	RyanMqttTestExitCritical();
+}
+
+void disableRandomNetworkFault(void)
+{
+	RyanMqttTestEnableCritical();
+	isEnableRandomNetworkFault = RyanMqttFalse;
+	RyanMqttTestExitCritical();
+}
+
+void toggleRandomNetworkFault(void)
+{
+	RyanMqttTestEnableCritical();
+	isEnableRandomNetworkFault = !isEnableRandomNetworkFault;
+	RyanMqttTestExitCritical();
+}
+
+void enableRandomMemoryFault(void)
+{
+	RyanMqttTestEnableCritical();
+	isEnableRandomMemoryFault = RyanMqttTrue;
+	RyanMqttTestExitCritical();
+}
+
+void disableRandomMemoryFault(void)
+{
+	RyanMqttTestEnableCritical();
+	isEnableRandomMemoryFault = RyanMqttFalse;
+	RyanMqttTestExitCritical();
+}
+
+void toggleRandomMemoryFault(void)
+{
+	RyanMqttTestEnableCritical();
+	isEnableRandomMemoryFault = !isEnableRandomMemoryFault;
+	RyanMqttTestExitCritical();
+}
+
+uint32_t RyanRand(int32_t min, int32_t max)
+{
+	static uint32_t isSeed = 0;
+	static uint32_t seedp = 0;
+	if (isSeed > 1024 || 0 == seedp)
+	{
+		seedp = platformUptimeMs();
+		isSeed = 0;
+	}
+
+	if (min >= max)
+	{
+		return min;
+	}
+	isSeed++;
+	return (rand_r(&seedp) % (max - min + 1)) + min;
+}
+
+void RyanMqttTestEnableCritical(void)
+{
+	pthread_spin_lock(&spin);
+}
+
+void RyanMqttTestExitCritical(void)
+{
+	pthread_spin_unlock(&spin);
+}
+
+void printfArrStr(uint8_t *buf, uint32_t len, char *userData)
+{
+	RyanMqttLog_raw("%s len: %d ", userData, len);
+	for (uint32_t i = 0; i < len; i++)
+	{
+		RyanMqttLog_raw("%c", buf[i]);
+	}
+
+	RyanMqttLog_raw("\r\n");
+}
+
+void RyanMqttTestUtileInit(void)
+{
+	pthread_spin_init(&spin, PTHREAD_PROCESS_PRIVATE);
+
+	// 多线程测试必须设置这个，否则会导致 heap-use-after-free, 原因如下
+	// 虽然也有办法解决，不过RyanMqtt目标为嵌入式场景，不想引入需要更多资源的逻辑，嵌入式场景目前想不到有这么频繁而且还是本机emqx的场景。
+	// 用户线程send -> emqx回复报文 -> mqtt线程recv。
+	// recv线程收到数据后，会释放用户线程send的sendbuf缓冲区。
+	// 但是在本机部署的emqx并且多核心同时运行，发送的数据量非常大的情况下会出现mqtt线程recv已经收到数据，但是用户线程send函数还没有返回。
+	cpu_set_t cpuset;
+	CPU_ZERO(&cpuset);
+	CPU_SET(0, &cpuset);
+	pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
+	sched_setaffinity(0, sizeof(cpu_set_t), &cpuset);
+
+	vallocInit();
+}
+
+void RyanMqttTestUtileDeInit(void)
+{
+	pthread_spin_destroy(&spin);
+}

test/RyanMqttTestUtile.h

@@ -0,0 +1,94 @@
+#ifndef __RyanMqttTestUtile__
+#define __RyanMqttTestUtile__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <time.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <unistd.h>
+#include <semaphore.h>
+#include <pthread.h>
+#include <sched.h>
+#include "valloc.h"
+#define malloc  v_malloc
+#define calloc  v_calloc
+#define free    v_free
+#define realloc v_realloc
+
+#include "RyanMqttLog.h"
+#include "RyanMqttClient.h"
+#include "RyanMqttUtil.h"
+
+#define delay(ms)         usleep((ms) * 1000)
+#define delay_us(us)      usleep((us))
+#define getArraySize(arr) ((int32_t)(sizeof(arr) / sizeof((arr)[0])))
+extern uint32_t destroyCount;
+
+#define checkMemory                                                                                                    \
+	do                                                                                                             \
+	{                                                                                                              \
+		for (uint32_t aaa = 0;; aaa++)                                                                         \
+		{                                                                                                      \
+			RyanMqttTestEnableCritical();                                                                  \
+			uint32_t destoryCount2 = destroyCount;                                                         \
+			RyanMqttTestExitCritical();                                                                    \
+			if (0 == destoryCount2) break;                                                                 \
+			if (aaa > 10 * 1000)                                                                           \
+			{                                                                                              \
+				printf("aaaaaaaa %d\r\n", destoryCount2);                                              \
+				break;                                                                                 \
+			}                                                                                              \
+			delay(1);                                                                                      \
+		}                                                                                                      \
+		int area = 0, use = 0;                                                                                 \
+		v_mcheck(&area, &use);                                                                                 \
+		if (area != 0 || use != 0)                                                                             \
+		{                                                                                                      \
+			RyanMqttLog_e("内存泄漏");                                                                     \
+			while (1)                                                                                      \
+			{                                                                                              \
+				v_mcheck(&area, &use);                                                                 \
+				RyanMqttLog_e("|||----------->>> area = %d, size = %d", area, use);                    \
+				delay(3000);                                                                           \
+			}                                                                                              \
+		}                                                                                                      \
+	} while (0)
+
+extern uint32_t randomCount;
+extern uint32_t sendRandomCount;
+extern uint32_t memoryRandomCount;
+extern RyanMqttBool_e isEnableRandomNetworkFault;
+extern RyanMqttBool_e isEnableRandomMemoryFault;
+extern void enableRandomNetworkFault(void);
+extern void disableRandomNetworkFault(void);
+extern void toggleRandomNetworkFault(void);
+extern void enableRandomMemoryFault(void);
+extern void disableRandomMemoryFault(void);
+extern void toggleRandomMemoryFault(void);
+extern uint32_t RyanRand(int32_t min, int32_t max);
+
+// 定义枚举类型
+
+// 定义结构体类型
+#define RyanMqttTestEventUserDataMagic (123456789)
+
+/* extern variables-----------------------------------------------------------*/
+
+extern void RyanMqttTestEnableCritical(void);
+extern void RyanMqttTestExitCritical(void);
+extern void printfArrStr(uint8_t *buf, uint32_t len, char *userData);
+
+extern void RyanMqttTestUtileInit(void);
+extern void RyanMqttTestUtileDeInit(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif