Merge pull request #23963 from taosdata/enh/xsren/TD-22212/taosQueryParam3.0

enh: td-22212 taos query param3.0

CMakeLists.txt

@@ -41,6 +41,7 @@ add_subdirectory(source)
 add_subdirectory(tools)
 add_subdirectory(utils)
 add_subdirectory(examples/c)
+add_subdirectory(tests)
 include(${TD_SUPPORT_DIR}/cmake.install)
 
 # docs 

source/client/inc/clientInt.h

@@ -205,7 +205,7 @@ typedef struct SRequestSendRecvBody {
   __taos_async_fn_t queryFp;
   __taos_async_fn_t fetchFp;
   EQueryExecMode    execMode;
-  void*             param;
+  void*             interParam;
   SDataBuf          requestMsg;
   int64_t           queryJob;  // query job, created according to sql query DAG.
   int32_t           subplanNum;
@@ -287,6 +287,7 @@ typedef struct SRequestObj {
 typedef struct SSyncQueryParam {
   tsem_t       sem;
   SRequestObj* pRequest;
+  void*        userParam;
 } SSyncQueryParam;
 
 void* doAsyncFetchRows(SRequestObj* pRequest, bool setupOneRowPtr, bool convertUcs4);
@@ -420,6 +421,7 @@ int32_t buildPreviousRequest(SRequestObj *pRequest, const char* sql, SRequestObj
 int32_t prepareAndParseSqlSyntax(SSqlCallbackWrapper **ppWrapper, SRequestObj *pRequest, bool updateMetaForce);
 void    returnToUser(SRequestObj* pRequest);
 void    stopAllQueries(SRequestObj *pRequest);
+void    doRequestCallback(SRequestObj* pRequest, int32_t code);
 void    freeQueryParam(SSyncQueryParam* param);
 
 #ifdef TD_ENTERPRISE

source/client/src/clientEnv.c

@@ -316,6 +316,15 @@ void *createRequest(uint64_t connId, int32_t type, int64_t reqid) {
     terrno = TSDB_CODE_TSC_DISCONNECTED;
     return NULL;
   }
+  SSyncQueryParam *interParam = taosMemoryCalloc(1, sizeof(SSyncQueryParam));
+  if (interParam == NULL) {
+    doDestroyRequest(pRequest);
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return NULL;
+  }
+  tsem_init(&interParam->sem, 0, 0);
+  interParam->pRequest = pRequest;
+  pRequest->body.interParam = interParam;
 
   pRequest->resType = RES_TYPE__QUERY;
   pRequest->requestId = reqid == 0 ? generateRequestId() : reqid;
@@ -437,12 +446,10 @@ void doDestroyRequest(void *p) {
     deregisterRequest(pRequest);
   }
 
-  if (pRequest->syncQuery) {
+  if (pRequest->body.interParam) {
-    if (pRequest->body.param) {
+    tsem_destroy(&((SSyncQueryParam *)pRequest->body.interParam)->sem);
-      tsem_destroy(&((SSyncQueryParam *)pRequest->body.param)->sem);
-    }
-    taosMemoryFree(pRequest->body.param);
   }
+  taosMemoryFree(pRequest->body.interParam);
 
   qDestroyQuery(pRequest->pQuery);
   nodesDestroyAllocator(pRequest->allocatorRefId);

source/client/src/clientImpl.c

@@ -196,21 +196,7 @@ int32_t buildRequest(uint64_t connId, const char* sql, int sqlLen, void* param,
   (*pRequest)->sqlLen = sqlLen;
   (*pRequest)->validateOnly = validateSql;
 
-  SSyncQueryParam* newpParam = NULL;
+  ((SSyncQueryParam*)(*pRequest)->body.interParam)->userParam = param;
-  if (param == NULL) {
-    newpParam = taosMemoryCalloc(1, sizeof(SSyncQueryParam));
-    if (newpParam == NULL) {
-      destroyRequest(*pRequest);
-      *pRequest = NULL;
-      return TSDB_CODE_OUT_OF_MEMORY;
-    }
-
-    tsem_init(&newpParam->sem, 0, 0);
-    newpParam->pRequest = (*pRequest);
-    param = newpParam;
-  }
-
-  (*pRequest)->body.param = param;
 
   STscObj* pTscObj = (*pRequest)->pTscObj;
   int32_t  err = taosHashPut(pTscObj->pRequests, &(*pRequest)->self, sizeof((*pRequest)->self), &(*pRequest)->self,
@@ -218,7 +204,6 @@ int32_t buildRequest(uint64_t connId, const char* sql, int sqlLen, void* param,
   if (err) {
     tscError("%" PRId64 " failed to add to request container, reqId:0x%" PRIx64 ", conn:%" PRId64 ", %s",
              (*pRequest)->self, (*pRequest)->requestId, pTscObj->id, sql);
-    freeQueryParam(newpParam);
     destroyRequest(*pRequest);
     *pRequest = NULL;
     return TSDB_CODE_OUT_OF_MEMORY;
@@ -230,7 +215,6 @@ int32_t buildRequest(uint64_t connId, const char* sql, int sqlLen, void* param,
         nodesCreateAllocator((*pRequest)->requestId, tsQueryNodeChunkSize, &((*pRequest)->allocatorRefId))) {
       tscError("%" PRId64 " failed to create node allocator, reqId:0x%" PRIx64 ", conn:%" PRId64 ", %s",
                (*pRequest)->self, (*pRequest)->requestId, pTscObj->id, sql);
-      freeQueryParam(newpParam);
       destroyRequest(*pRequest);
       *pRequest = NULL;
       return TSDB_CODE_OUT_OF_MEMORY;
@@ -336,7 +320,7 @@ static SAppInstInfo* getAppInfo(SRequestObj* pRequest) { return pRequest->pTscOb
 void asyncExecLocalCmd(SRequestObj* pRequest, SQuery* pQuery) {
   SRetrieveTableRsp* pRsp = NULL;
   if (pRequest->validateOnly) {
-    pRequest->body.queryFp(pRequest->body.param, pRequest, 0);
+    doRequestCallback(pRequest, 0);
     return;
   }
 
@@ -358,18 +342,18 @@ void asyncExecLocalCmd(SRequestObj* pRequest, SQuery* pQuery) {
              pRequest->requestId);
   }
 
-  pRequest->body.queryFp(pRequest->body.param, pRequest, code);
+  doRequestCallback(pRequest, code);
 }
 
 int32_t asyncExecDdlQuery(SRequestObj* pRequest, SQuery* pQuery) {
   if (pRequest->validateOnly) {
-    pRequest->body.queryFp(pRequest->body.param, pRequest, 0);
+    doRequestCallback(pRequest, 0);
     return TSDB_CODE_SUCCESS;
   }
 
   // drop table if exists not_exists_table
   if (NULL == pQuery->pCmdMsg) {
-    pRequest->body.queryFp(pRequest->body.param, pRequest, 0);
+    doRequestCallback(pRequest, 0);
     return TSDB_CODE_SUCCESS;
   }
 
@@ -384,7 +368,7 @@ int32_t asyncExecDdlQuery(SRequestObj* pRequest, SQuery* pQuery) {
   int64_t transporterId = 0;
   int32_t code = asyncSendMsgToServer(pAppInfo->pTransporter, &pMsgInfo->epSet, &transporterId, pSendMsg);
   if (code) {
-    pRequest->body.queryFp(pRequest->body.param, pRequest, code);
+    doRequestCallback(pRequest, code);
   }
   return code;
 }
@@ -913,7 +897,7 @@ void continuePostSubQuery(SRequestObj* pRequest, TAOS_ROW row) {
 void returnToUser(SRequestObj* pRequest) {
   if (pRequest->relation.userRefId == pRequest->self || 0 == pRequest->relation.userRefId) {
     // return to client
-    pRequest->body.queryFp(pRequest->body.param, pRequest, pRequest->code);
+    doRequestCallback(pRequest, pRequest->code);
     return;
   }
 
@@ -921,7 +905,7 @@ void returnToUser(SRequestObj* pRequest) {
   if (pUserReq) {
     pUserReq->code = pRequest->code;
     // return to client
-    pUserReq->body.queryFp(pUserReq->body.param, pUserReq, pUserReq->code);
+    doRequestCallback(pUserReq, pUserReq->code);
     releaseRequest(pRequest->relation.userRefId);
     return;
   } else {
@@ -1031,7 +1015,7 @@ void schedulerExecCb(SExecResult* pResult, void* param, int32_t code) {
     pRequest->pWrapper = NULL;
 
     // return to client
-    pRequest->body.queryFp(pRequest->body.param, pRequest, code);
+    doRequestCallback(pRequest, code);
   }
 }
 
@@ -1186,7 +1170,7 @@ static int32_t asyncExecSchQuery(SRequestObj* pRequest, SQuery* pQuery, SMetaDat
       pRequest->code = terrno;
     }
 
-    pRequest->body.queryFp(pRequest->body.param, pRequest, code);
+    doRequestCallback(pRequest, code);
   }
 
   // todo not to be released here
@@ -1199,7 +1183,7 @@ void launchAsyncQuery(SRequestObj* pRequest, SQuery* pQuery, SMetaData* pResultM
   int32_t code = 0;
 
   if (pRequest->parseOnly) {
-    pRequest->body.queryFp(pRequest->body.param, pRequest, 0);
+    doRequestCallback(pRequest, 0);
     return;
   }
 
@@ -1233,11 +1217,11 @@ void launchAsyncQuery(SRequestObj* pRequest, SQuery* pQuery, SMetaData* pResultM
     }
     case QUERY_EXEC_MODE_EMPTY_RESULT:
       pRequest->type = TSDB_SQL_RETRIEVE_EMPTY_RESULT;
-      pRequest->body.queryFp(pRequest->body.param, pRequest, 0);
+      doRequestCallback(pRequest, 0);
       break;
     default:
       tscError("0x%" PRIx64 " invalid execMode %d", pRequest->self, pQuery->execMode);
-      pRequest->body.queryFp(pRequest->body.param, pRequest, -1);
+      doRequestCallback(pRequest, -1);
       break;
   }
 }
@@ -1703,8 +1687,8 @@ void* doFetchRows(SRequestObj* pRequest, bool setupOneRowPtr, bool convertUcs4)
 }
 
 static void syncFetchFn(void* param, TAOS_RES* res, int32_t numOfRows) {
-  SSyncQueryParam* pParam = param;
+  tsem_t* sem = param;
-  tsem_post(&pParam->sem);
+  tsem_post(sem);
 }
 
 void* doAsyncFetchRows(SRequestObj* pRequest, bool setupOneRowPtr, bool convertUcs4) {
@@ -1722,10 +1706,11 @@ void* doAsyncFetchRows(SRequestObj* pRequest, bool setupOneRowPtr, bool convertU
 
     // convert ucs4 to native multi-bytes string
     pResultInfo->convertUcs4 = convertUcs4;
-
+    tsem_t sem;
-    SSyncQueryParam* pParam = pRequest->body.param;
+    tsem_init(&sem, 0, 0);
-    taos_fetch_rows_a(pRequest, syncFetchFn, pParam);
+    taos_fetch_rows_a(pRequest, syncFetchFn, &sem);
-    tsem_wait(&pParam->sem);
+    tsem_wait(&sem);
+    tsem_destroy(&sem);
   }
 
   if (pResultInfo->numOfRows == 0 || pRequest->code != TSDB_CODE_SUCCESS) {
@@ -2492,6 +2477,10 @@ TAOS_RES* taosQueryImpl(TAOS* taos, const char* sql, bool validateOnly) {
   tscDebug("taos_query start with sql:%s", sql);
 
   SSyncQueryParam* param = taosMemoryCalloc(1, sizeof(SSyncQueryParam));
+  if (NULL == param) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return NULL;
+  }
   tsem_init(&param->sem, 0, 0);
 
   taosAsyncQueryImpl(*(int64_t*)taos, sql, syncQueryFn, param, validateOnly);
@@ -2501,9 +2490,8 @@ TAOS_RES* taosQueryImpl(TAOS* taos, const char* sql, bool validateOnly) {
   if (param->pRequest != NULL) {
     param->pRequest->syncQuery = true;
     pRequest = param->pRequest;
-  } else {
-    taosMemoryFree(param);
   }
+  taosMemoryFree(param);
 
   tscDebug("taos_query end with sql:%s", sql);
 
@@ -2517,19 +2505,20 @@ TAOS_RES* taosQueryImplWithReqid(TAOS* taos, const char* sql, bool validateOnly,
   }
 
   SSyncQueryParam* param = taosMemoryCalloc(1, sizeof(SSyncQueryParam));
+  if (param == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return NULL;
+  }
   tsem_init(&param->sem, 0, 0);
 
   taosAsyncQueryImplWithReqid(*(int64_t*)taos, sql, syncQueryFn, param, validateOnly, reqid);
   tsem_wait(&param->sem);
-
   SRequestObj* pRequest = NULL;
   if (param->pRequest != NULL) {
     param->pRequest->syncQuery = true;
     pRequest = param->pRequest;
-  } else {
-    taosMemoryFree(param);
   }
-
+  taosMemoryFree(param);
   return pRequest;
 }
 
@@ -2547,13 +2536,13 @@ static void fetchCallback(void* pResult, void* param, int32_t code) {
   if (code != TSDB_CODE_SUCCESS) {
     pRequest->code = code;
     taosMemoryFreeClear(pResultInfo->pData);
-    pRequest->body.fetchFp(pRequest->body.param, pRequest, 0);
+    pRequest->body.fetchFp(((SSyncQueryParam *)pRequest->body.interParam)->userParam, pRequest, 0);
     return;
   }
 
   if (pRequest->code != TSDB_CODE_SUCCESS) {
     taosMemoryFreeClear(pResultInfo->pData);
-    pRequest->body.fetchFp(pRequest->body.param, pRequest, 0);
+    pRequest->body.fetchFp(((SSyncQueryParam *)pRequest->body.interParam)->userParam, pRequest, 0);
     return;
   }
 
@@ -2574,20 +2563,12 @@ static void fetchCallback(void* pResult, void* param, int32_t code) {
     atomic_add_fetch_64((int64_t*)&pActivity->fetchBytes, pRequest->body.resInfo.payloadLen);
   }
 
-  pRequest->body.fetchFp(pRequest->body.param, pRequest, pResultInfo->numOfRows);
+  pRequest->body.fetchFp(((SSyncQueryParam *)pRequest->body.interParam)->userParam, pRequest, pResultInfo->numOfRows);
 }
 
 void taosAsyncFetchImpl(SRequestObj* pRequest, __taos_async_fn_t fp, void* param) {
-  if (pRequest->syncQuery && pRequest->body.param != param) {
-    if (pRequest->body.param) {
-      tsem_destroy(&((SSyncQueryParam *)pRequest->body.param)->sem);
-    }
-    taosMemoryFree(pRequest->body.param);
-    pRequest->syncQuery = false;
-  }
-  
   pRequest->body.fetchFp = fp;
-  pRequest->body.param = param;
+  ((SSyncQueryParam *)pRequest->body.interParam)->userParam = param;
 
   SReqResultInfo* pResultInfo = &pRequest->body.resInfo;
 
@@ -2625,6 +2606,10 @@ void taosAsyncFetchImpl(SRequestObj* pRequest, __taos_async_fn_t fp, void* param
   schedulerFetchRows(pRequest->body.queryJob, &req);
 }
 
+void doRequestCallback(SRequestObj* pRequest, int32_t code) {
+  pRequest->body.queryFp(((SSyncQueryParam *)pRequest->body.interParam)->userParam, pRequest, code);
+}
+
 int32_t clientParseSql(void* param, const char* dbName, const char* sql, bool parseOnly, const char* effectiveUser, SParseSqlRes* pRes) {
 #ifndef TD_ENTERPRISE
   return TSDB_CODE_SUCCESS;
@@ -2633,4 +2618,3 @@ int32_t clientParseSql(void* param, const char* dbName, const char* sql, bool pa
 #endif
 }
 
-

source/client/src/clientMain.c

@@ -1095,7 +1095,7 @@ static void doAsyncQueryFromParse(SMetaData *pResultMeta, void *param, int32_t c
     pRequest->pWrapper = NULL;
     terrno = code;
     pRequest->code = code;
-    pRequest->body.queryFp(pRequest->body.param, pRequest, code);
+    doRequestCallback(pRequest, code);
   }
 }
 
@@ -1112,7 +1112,7 @@ void continueInsertFromCsv(SSqlCallbackWrapper *pWrapper, SRequestObj *pRequest)
     pRequest->pWrapper = NULL;
     terrno = code;
     pRequest->code = code;
-    pRequest->body.queryFp(pRequest->body.param, pRequest, code);
+    doRequestCallback(pRequest, code);
   }
 }
 
@@ -1210,7 +1210,7 @@ void doAsyncQuery(SRequestObj *pRequest, bool updateMetaForce) {
     terrno = code;
     pRequest->code = code;
     tscDebug("call sync query cb with code: %s", tstrerror(code));
-    pRequest->body.queryFp(pRequest->body.param, pRequest, code);
+    doRequestCallback(pRequest, code);
     return;
   }
 
@@ -1242,7 +1242,7 @@ void doAsyncQuery(SRequestObj *pRequest, bool updateMetaForce) {
 
     terrno = code;
     pRequest->code = code;
-    pRequest->body.queryFp(pRequest->body.param, pRequest, code);
+    doRequestCallback(pRequest, code);
   }
 }
 
@@ -1545,12 +1545,12 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) {
 
   conn.mgmtEps = getEpSet_s(&pTscObj->pAppInfo->mgmtEp);
 
-  code = catalogAsyncGetAllMeta(pCtg, &conn, &catalogReq, syncCatalogFn, pRequest->body.param, NULL);
+  code = catalogAsyncGetAllMeta(pCtg, &conn, &catalogReq, syncCatalogFn, pRequest->body.interParam, NULL);
   if (code) {
     goto _return;
   }
 
-  SSyncQueryParam *pParam = pRequest->body.param;
+  SSyncQueryParam *pParam = pRequest->body.interParam;
   tsem_wait(&pParam->sem);
 
 _return:

source/client/src/clientMsgHandler.c

@@ -41,7 +41,7 @@ int32_t genericRspCallback(void* param, SDataBuf* pMsg, int32_t code) {
   taosMemoryFree(pMsg->pEpSet);
   taosMemoryFree(pMsg->pData);
   if (pRequest->body.queryFp != NULL) {
-    pRequest->body.queryFp(pRequest->body.param, pRequest, code);
+    doRequestCallback(pRequest, code);
   } else {
     tsem_post(&pRequest->body.rspSem);
   }
@@ -199,7 +199,7 @@ int32_t processCreateDbRsp(void* param, SDataBuf* pMsg, int32_t code) {
   }
 
   if (pRequest->body.queryFp) {
-    pRequest->body.queryFp(pRequest->body.param, pRequest, code);
+    doRequestCallback(pRequest, code);
   } else {
     tsem_post(&pRequest->body.rspSem);
   }
@@ -235,7 +235,8 @@ int32_t processUseDbRsp(void* param, SDataBuf* pMsg, int32_t code) {
     setErrno(pRequest, code);
 
     if (pRequest->body.queryFp != NULL) {
-      pRequest->body.queryFp(pRequest->body.param, pRequest, pRequest->code);
+      doRequestCallback(pRequest, pRequest->code);
+
     } else {
       tsem_post(&pRequest->body.rspSem);
     }
@@ -299,7 +300,7 @@ int32_t processUseDbRsp(void* param, SDataBuf* pMsg, int32_t code) {
   taosMemoryFree(pMsg->pEpSet);
 
   if (pRequest->body.queryFp != NULL) {
-    pRequest->body.queryFp(pRequest->body.param, pRequest, pRequest->code);
+    doRequestCallback(pRequest, pRequest->code);
   } else {
     tsem_post(&pRequest->body.rspSem);
   }
@@ -343,7 +344,7 @@ int32_t processCreateSTableRsp(void* param, SDataBuf* pMsg, int32_t code) {
       }
     }
 
-    pRequest->body.queryFp(pRequest->body.param, pRequest, code);
+    doRequestCallback(pRequest, code);
   } else {
     tsem_post(&pRequest->body.rspSem);
   }
@@ -380,7 +381,7 @@ int32_t processDropDbRsp(void* param, SDataBuf* pMsg, int32_t code) {
   taosMemoryFree(pMsg->pEpSet);
 
   if (pRequest->body.queryFp != NULL) {
-    pRequest->body.queryFp(pRequest->body.param, pRequest, code);
+    doRequestCallback(pRequest, code);
   } else {
     tsem_post(&pRequest->body.rspSem);
   }
@@ -420,7 +421,7 @@ int32_t processAlterStbRsp(void* param, SDataBuf* pMsg, int32_t code) {
       }
     }
 
-    pRequest->body.queryFp(pRequest->body.param, pRequest, code);
+    doRequestCallback(pRequest, code);
   } else {
     tsem_post(&pRequest->body.rspSem);
   }
@@ -534,7 +535,7 @@ int32_t processShowVariablesRsp(void* param, SDataBuf* pMsg, int32_t code) {
   taosMemoryFree(pMsg->pEpSet);
 
   if (pRequest->body.queryFp != NULL) {
-    pRequest->body.queryFp(pRequest->body.param, pRequest, code);
+    doRequestCallback(pRequest, code);
   } else {
     tsem_post(&pRequest->body.rspSem);
   }

source/dnode/mgmt/test/qnode/dqnode.cpp

@@ -37,6 +37,7 @@ TEST_F(DndTestQnode, 01_Create_Qnode) {
     SRpcMsg* pRsp = test.SendReq(TDMT_DND_CREATE_QNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, TSDB_CODE_INVALID_OPTION);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
@@ -50,6 +51,7 @@ TEST_F(DndTestQnode, 01_Create_Qnode) {
     SRpcMsg* pRsp = test.SendReq(TDMT_DND_CREATE_QNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
@@ -63,6 +65,7 @@ TEST_F(DndTestQnode, 01_Create_Qnode) {
     SRpcMsg* pRsp = test.SendReq(TDMT_DND_CREATE_QNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, TSDB_CODE_QNODE_ALREADY_DEPLOYED);
+    rpcFreeCont(pRsp->pCont);
   }
 
   test.Restart();
@@ -78,6 +81,7 @@ TEST_F(DndTestQnode, 01_Create_Qnode) {
     SRpcMsg* pRsp = test.SendReq(TDMT_DND_CREATE_QNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, TSDB_CODE_QNODE_ALREADY_DEPLOYED);
+    rpcFreeCont(pRsp->pCont);
   }
 }
 
@@ -94,6 +98,7 @@ TEST_F(DndTestQnode, 02_Drop_Qnode) {
     SRpcMsg* pRsp = test.SendReq(TDMT_DND_DROP_QNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, TSDB_CODE_INVALID_OPTION);
+    rpcFreeCont(pRsp->pCont);
   }
 #endif
 
@@ -108,6 +113,7 @@ TEST_F(DndTestQnode, 02_Drop_Qnode) {
     SRpcMsg* pRsp = test.SendReq(TDMT_DND_DROP_QNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
@@ -121,6 +127,7 @@ TEST_F(DndTestQnode, 02_Drop_Qnode) {
     SRpcMsg* pRsp = test.SendReq(TDMT_DND_DROP_QNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, TSDB_CODE_QNODE_NOT_DEPLOYED);
+    rpcFreeCont(pRsp->pCont);
   }
 
   test.Restart();
@@ -136,6 +143,7 @@ TEST_F(DndTestQnode, 02_Drop_Qnode) {
     SRpcMsg* pRsp = test.SendReq(TDMT_DND_DROP_QNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, TSDB_CODE_QNODE_NOT_DEPLOYED);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
@@ -149,5 +157,6 @@ TEST_F(DndTestQnode, 02_Drop_Qnode) {
     SRpcMsg* pRsp = test.SendReq(TDMT_DND_CREATE_QNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 }

source/dnode/mgmt/test/snode/dsnode.cpp

@@ -37,6 +37,7 @@ TEST_F(DndTestSnode, 01_Create_Snode) {
     SRpcMsg* pRsp = test.SendReq(TDMT_DND_CREATE_SNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, TSDB_CODE_INVALID_OPTION);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
@@ -50,6 +51,7 @@ TEST_F(DndTestSnode, 01_Create_Snode) {
     SRpcMsg* pRsp = test.SendReq(TDMT_DND_CREATE_SNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
@@ -63,6 +65,7 @@ TEST_F(DndTestSnode, 01_Create_Snode) {
     SRpcMsg* pRsp = test.SendReq(TDMT_DND_CREATE_SNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, TSDB_CODE_SNODE_ALREADY_DEPLOYED);
+    rpcFreeCont(pRsp->pCont);
   }
 
   test.Restart();
@@ -78,6 +81,7 @@ TEST_F(DndTestSnode, 01_Create_Snode) {
     SRpcMsg* pRsp = test.SendReq(TDMT_DND_CREATE_SNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, TSDB_CODE_SNODE_ALREADY_DEPLOYED);
+    rpcFreeCont(pRsp->pCont);
   }
 }
 
@@ -94,6 +98,7 @@ TEST_F(DndTestSnode, 01_Drop_Snode) {
     SRpcMsg* pRsp = test.SendReq(TDMT_DND_DROP_SNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, TSDB_CODE_INVALID_OPTION);
+    rpcFreeCont(pRsp->pCont);
   }
 #endif
 
@@ -108,6 +113,7 @@ TEST_F(DndTestSnode, 01_Drop_Snode) {
     SRpcMsg* pRsp = test.SendReq(TDMT_DND_DROP_SNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
@@ -121,6 +127,7 @@ TEST_F(DndTestSnode, 01_Drop_Snode) {
     SRpcMsg* pRsp = test.SendReq(TDMT_DND_DROP_SNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, TSDB_CODE_SNODE_NOT_DEPLOYED);
+    rpcFreeCont(pRsp->pCont);
   }
 
   test.Restart();
@@ -136,6 +143,7 @@ TEST_F(DndTestSnode, 01_Drop_Snode) {
     SRpcMsg* pRsp = test.SendReq(TDMT_DND_DROP_SNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, TSDB_CODE_SNODE_NOT_DEPLOYED);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
@@ -149,5 +157,6 @@ TEST_F(DndTestSnode, 01_Drop_Snode) {
     SRpcMsg* pRsp = test.SendReq(TDMT_DND_CREATE_SNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 }

source/dnode/mnode/impl/test/acct/acct.cpp

@@ -33,6 +33,7 @@ TEST_F(MndTestAcct, 01_Create_Acct) {
   SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_ACCT, pReq, contLen);
   ASSERT_NE(pRsp, nullptr);
   ASSERT_EQ(pRsp->code, TSDB_CODE_OPS_NOT_SUPPORT);
+  rpcFreeCont(pRsp->pCont);
 }
 
 TEST_F(MndTestAcct, 02_Alter_Acct) {
@@ -43,6 +44,7 @@ TEST_F(MndTestAcct, 02_Alter_Acct) {
   SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_ACCT, pReq, contLen);
   ASSERT_NE(pRsp, nullptr);
   ASSERT_EQ(pRsp->code, TSDB_CODE_OPS_NOT_SUPPORT);
+  rpcFreeCont(pRsp->pCont);
 }
 
 TEST_F(MndTestAcct, 03_Drop_Acct) {
@@ -53,4 +55,5 @@ TEST_F(MndTestAcct, 03_Drop_Acct) {
   SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_ACCT, pReq, contLen);
   ASSERT_NE(pRsp, nullptr);
   ASSERT_EQ(pRsp->code, TSDB_CODE_OPS_NOT_SUPPORT);
+  rpcFreeCont(pRsp->pCont);
 }

source/dnode/mnode/impl/test/sma/sma.cpp

@@ -253,12 +253,14 @@ TEST_F(MndTestSma, 02_Create_Show_Meta_Drop_Restart_BSma) {
     pReq = BuildCreateDbReq(dbname, &contLen);
     pRsp = test.SendReq(TDMT_MND_CREATE_DB, pReq, contLen);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     pReq = BuildCreateBSmaStbReq(stbname, &contLen);
     pRsp = test.SendReq(TDMT_MND_CREATE_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
     test.SendShowReq(TSDB_MGMT_TABLE_STB, "ins_stables", dbname);
     EXPECT_EQ(test.GetShowRows(), 1);
   }
@@ -269,12 +271,14 @@ TEST_F(MndTestSma, 02_Create_Show_Meta_Drop_Restart_BSma) {
     pReq = BuildCreateBSmaStbReq(stbname, &contLen);
     pRsp = test.SendReq(TDMT_MND_CREATE_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, TSDB_CODE_MND_STB_ALREADY_EXIST);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     pReq = BuildDropStbReq(stbname, &contLen);
     pRsp = test.SendReq(TDMT_MND_DROP_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
     test.SendShowReq(TSDB_MGMT_TABLE_STB, "ins_stables", dbname);
     EXPECT_EQ(test.GetShowRows(), 0);
   }
@@ -283,5 +287,6 @@ TEST_F(MndTestSma, 02_Create_Show_Meta_Drop_Restart_BSma) {
     pReq = BuildDropStbReq(stbname, &contLen);
     pRsp = test.SendReq(TDMT_MND_DROP_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, TSDB_CODE_MND_STB_NOT_EXIST);
+    rpcFreeCont(pRsp->pCont);
   }
 }

source/dnode/mnode/impl/test/stb/stb.cpp

@@ -155,6 +155,7 @@ void* MndTestStb::BuildAlterStbAddTagReq(const char* stbname, const char* tagnam
   tSerializeSMAlterStbReq(pHead, contLen, &req);
 
   *pContLen = contLen;
+  taosArrayDestroy(req.pFields);
   return pHead;
 }
 
@@ -176,6 +177,7 @@ void* MndTestStb::BuildAlterStbDropTagReq(const char* stbname, const char* tagna
   tSerializeSMAlterStbReq(pHead, contLen, &req);
 
   *pContLen = contLen;
+  taosArrayDestroy(req.pFields);
   return pHead;
 }
 
@@ -204,6 +206,7 @@ void* MndTestStb::BuildAlterStbUpdateTagNameReq(const char* stbname, const char*
   tSerializeSMAlterStbReq(pHead, contLen, &req);
 
   *pContLen = contLen;
+  taosArrayDestroy(req.pFields);
   return pHead;
 }
 
@@ -226,6 +229,7 @@ void* MndTestStb::BuildAlterStbUpdateTagBytesReq(const char* stbname, const char
   tSerializeSMAlterStbReq(pHead, contLen, &req);
 
   *pContLen = contLen;
+  taosArrayDestroy(req.pFields);
   return pHead;
 }
 
@@ -247,6 +251,7 @@ void* MndTestStb::BuildAlterStbAddColumnReq(const char* stbname, const char* col
   tSerializeSMAlterStbReq(pHead, contLen, &req);
 
   *pContLen = contLen;
+  taosArrayDestroy(req.pFields);
   return pHead;
 }
 
@@ -268,6 +273,7 @@ void* MndTestStb::BuildAlterStbDropColumnReq(const char* stbname, const char* co
   tSerializeSMAlterStbReq(pHead, contLen, &req);
 
   *pContLen = contLen;
+  taosArrayDestroy(req.pFields);
   return pHead;
 }
 
@@ -290,6 +296,7 @@ void* MndTestStb::BuildAlterStbUpdateColumnBytesReq(const char* stbname, const c
   tSerializeSMAlterStbReq(pHead, contLen, &req);
 
   *pContLen = contLen;
+  taosArrayDestroy(req.pFields);
   return pHead;
 }
 
@@ -303,6 +310,7 @@ TEST_F(MndTestStb, 01_Create_Show_Meta_Drop_Restart_Stb) {
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DB, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
@@ -311,6 +319,7 @@ TEST_F(MndTestStb, 01_Create_Show_Meta_Drop_Restart_Stb) {
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_STB, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
@@ -334,6 +343,7 @@ TEST_F(MndTestStb, 01_Create_Show_Meta_Drop_Restart_Stb) {
 
     STableMetaRsp metaRsp = {0};
     tDeserializeSTableMetaRsp(pMsg->pCont, pMsg->contLen, &metaRsp);
+    rpcFreeCont(pMsg->pCont);
 
     EXPECT_STREQ(metaRsp.dbFName, dbname);
     EXPECT_STREQ(metaRsp.tbName, "stb");
@@ -410,6 +420,7 @@ TEST_F(MndTestStb, 01_Create_Show_Meta_Drop_Restart_Stb) {
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_STB, pHead, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
@@ -423,6 +434,7 @@ TEST_F(MndTestStb, 01_Create_Show_Meta_Drop_Restart_Stb) {
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_DB, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 }
 
@@ -436,6 +448,7 @@ TEST_F(MndTestStb, 02_Alter_Stb_AddTag) {
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DB, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
@@ -443,30 +456,35 @@ TEST_F(MndTestStb, 02_Alter_Stb_AddTag) {
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_STB, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     void*    pReq = BuildAlterStbAddTagReq("1.d3.stb", "tag4", &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, TSDB_CODE_MND_DB_NOT_EXIST);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     void*    pReq = BuildAlterStbAddTagReq("1.d2.stb3", "tag4", &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, TSDB_CODE_MND_STB_NOT_EXIST);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     void*    pReq = BuildAlterStbAddTagReq(stbname, "tag3", &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, TSDB_CODE_MND_TAG_ALREADY_EXIST);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     void*    pReq = BuildAlterStbAddTagReq(stbname, "col1", &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, TSDB_CODE_MND_COLUMN_ALREADY_EXIST);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
@@ -474,6 +492,7 @@ TEST_F(MndTestStb, 02_Alter_Stb_AddTag) {
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
 
     test.SendShowReq(TSDB_MGMT_TABLE_STB, "ins_stables", dbname);
   }
@@ -483,6 +502,7 @@ TEST_F(MndTestStb, 02_Alter_Stb_AddTag) {
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_DB, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 }
 
@@ -495,18 +515,21 @@ TEST_F(MndTestStb, 03_Alter_Stb_DropTag) {
     void*    pReq = BuildCreateDbReq(dbname, &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DB, pReq, contLen);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     void*    pReq = BuildCreateStbReq(stbname, &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     void*    pReq = BuildAlterStbDropTagReq(stbname, "tag5", &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, TSDB_CODE_MND_TAG_NOT_EXIST);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
@@ -514,6 +537,7 @@ TEST_F(MndTestStb, 03_Alter_Stb_DropTag) {
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
 
     test.SendShowReq(TSDB_MGMT_TABLE_STB, "ins_stables", dbname);
     EXPECT_EQ(test.GetShowRows(), 1);
@@ -524,6 +548,7 @@ TEST_F(MndTestStb, 03_Alter_Stb_DropTag) {
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_DB, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 }
 
@@ -536,41 +561,48 @@ TEST_F(MndTestStb, 04_Alter_Stb_AlterTagName) {
     void*    pReq = BuildCreateDbReq(dbname, &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DB, pReq, contLen);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     void*    pReq = BuildCreateStbReq(stbname, &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     void*    pReq = BuildAlterStbUpdateTagNameReq(stbname, "tag5", "tag6", &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, TSDB_CODE_MND_TAG_NOT_EXIST);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     void*    pReq = BuildAlterStbUpdateTagNameReq(stbname, "col1", "tag6", &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, TSDB_CODE_MND_TAG_NOT_EXIST);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     void*    pReq = BuildAlterStbUpdateTagNameReq(stbname, "tag3", "col1", &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, TSDB_CODE_MND_COLUMN_ALREADY_EXIST);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     void*    pReq = BuildAlterStbUpdateTagNameReq(stbname, "tag3", "tag2", &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, TSDB_CODE_MND_TAG_ALREADY_EXIST);
+    rpcFreeCont(pRsp->pCont);
   }
   {
     void*    pReq = BuildAlterStbUpdateTagNameReq(stbname, "tag3", "tag2", &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, TSDB_CODE_MND_TAG_ALREADY_EXIST);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
@@ -578,6 +610,7 @@ TEST_F(MndTestStb, 04_Alter_Stb_AlterTagName) {
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
 
     test.SendShowReq(TSDB_MGMT_TABLE_STB, "ins_stables", dbname);
     EXPECT_EQ(test.GetShowRows(), 1);
@@ -588,6 +621,7 @@ TEST_F(MndTestStb, 04_Alter_Stb_AlterTagName) {
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_DB, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 }
 
@@ -600,36 +634,42 @@ TEST_F(MndTestStb, 05_Alter_Stb_AlterTagBytes) {
     void*    pReq = BuildCreateDbReq(dbname, &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DB, pReq, contLen);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     void*    pReq = BuildCreateStbReq(stbname, &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     void*    pReq = BuildAlterStbUpdateTagBytesReq(stbname, "tag5", 12, &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, TSDB_CODE_MND_TAG_NOT_EXIST);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     void*    pReq = BuildAlterStbUpdateTagBytesReq(stbname, "tag1", 13, &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_STB_OPTION);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     void*    pReq = BuildAlterStbUpdateTagBytesReq(stbname, "tag3", 8, &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_ROW_BYTES);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     void*    pReq = BuildAlterStbUpdateTagBytesReq(stbname, "tag3", 20, &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
 
     test.SendShowReq(TSDB_MGMT_TABLE_STB, "ins_stables", dbname);
     EXPECT_EQ(test.GetShowRows(), 1);
@@ -640,6 +680,7 @@ TEST_F(MndTestStb, 05_Alter_Stb_AlterTagBytes) {
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_DB, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 }
 
@@ -653,6 +694,7 @@ TEST_F(MndTestStb, 06_Alter_Stb_AddColumn) {
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DB, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
@@ -660,30 +702,35 @@ TEST_F(MndTestStb, 06_Alter_Stb_AddColumn) {
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_STB, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     void*    pReq = BuildAlterStbAddColumnReq("1.d7.stb", "tag4", &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, TSDB_CODE_MND_DB_NOT_EXIST);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     void*    pReq = BuildAlterStbAddColumnReq("1.d6.stb3", "tag4", &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, TSDB_CODE_MND_STB_NOT_EXIST);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     void*    pReq = BuildAlterStbAddColumnReq(stbname, "tag3", &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, TSDB_CODE_MND_TAG_ALREADY_EXIST);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     void*    pReq = BuildAlterStbAddColumnReq(stbname, "col1", &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, TSDB_CODE_MND_COLUMN_ALREADY_EXIST);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
@@ -691,6 +738,7 @@ TEST_F(MndTestStb, 06_Alter_Stb_AddColumn) {
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
 
     test.SendShowReq(TSDB_MGMT_TABLE_STB, "ins_stables", dbname);
     EXPECT_EQ(test.GetShowRows(), 1);
@@ -701,6 +749,7 @@ TEST_F(MndTestStb, 06_Alter_Stb_AddColumn) {
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_DB, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 }
 
@@ -713,30 +762,35 @@ TEST_F(MndTestStb, 07_Alter_Stb_DropColumn) {
     void*    pReq = BuildCreateDbReq(dbname, &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DB, pReq, contLen);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     void*    pReq = BuildCreateStbReq(stbname, &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     void*    pReq = BuildAlterStbDropColumnReq(stbname, "col4", &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, TSDB_CODE_MND_COLUMN_NOT_EXIST);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     void*    pReq = BuildAlterStbDropColumnReq(stbname, "col1", &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_STB_ALTER_OPTION);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     void*    pReq = BuildAlterStbDropColumnReq(stbname, "ts", &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_STB_ALTER_OPTION);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
@@ -744,6 +798,7 @@ TEST_F(MndTestStb, 07_Alter_Stb_DropColumn) {
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
@@ -751,6 +806,7 @@ TEST_F(MndTestStb, 07_Alter_Stb_DropColumn) {
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
 
     test.SendShowReq(TSDB_MGMT_TABLE_STB, "ins_stables", dbname);
     EXPECT_EQ(test.GetShowRows(), 1);
@@ -761,6 +817,7 @@ TEST_F(MndTestStb, 07_Alter_Stb_DropColumn) {
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_DB, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 }
 
@@ -773,42 +830,49 @@ TEST_F(MndTestStb, 08_Alter_Stb_AlterTagBytes) {
     void*    pReq = BuildCreateDbReq(dbname, &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_DB, pReq, contLen);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     void*    pReq = BuildCreateStbReq(stbname, &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     void*    pReq = BuildAlterStbUpdateColumnBytesReq(stbname, "col5", 12, &contLen, 0);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, TSDB_CODE_MND_COLUMN_NOT_EXIST);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     void*    pReq = BuildAlterStbUpdateColumnBytesReq(stbname, "ts", 8, &contLen, 0);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_STB_OPTION);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     void*    pReq = BuildAlterStbUpdateColumnBytesReq(stbname, "col1", 8, &contLen, 0);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_ROW_BYTES);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     void*    pReq = BuildAlterStbUpdateColumnBytesReq(stbname, "col1", TSDB_MAX_BYTES_PER_ROW, &contLen, 0);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_ROW_BYTES);
+    rpcFreeCont(pRsp->pCont);
   }
 
   {
     void*    pReq = BuildAlterStbUpdateColumnBytesReq(stbname, "col1", 20, &contLen, 0);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
 
     test.SendShowReq(TSDB_MGMT_TABLE_STB, "ins_stables", dbname);
     EXPECT_EQ(test.GetShowRows(), 1);
@@ -818,6 +882,7 @@ TEST_F(MndTestStb, 08_Alter_Stb_AlterTagBytes) {
     void*    pReq = BuildAlterStbUpdateColumnBytesReq(stbname, "col_not_exist", 20, &contLen, 1);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
     ASSERT_EQ(pRsp->code, TSDB_CODE_MND_COLUMN_NOT_EXIST);
+    rpcFreeCont(pRsp->pCont);
 
     test.SendShowReq(TSDB_MGMT_TABLE_STB, "ins_stables", dbname);
     EXPECT_EQ(test.GetShowRows(), 1);
@@ -828,5 +893,6 @@ TEST_F(MndTestStb, 08_Alter_Stb_AlterTagBytes) {
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_DB, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
+    rpcFreeCont(pRsp->pCont);
   }
 }

source/libs/index/test/CMakeLists.txt

@@ -164,7 +164,7 @@ IF(NOT TD_DARWIN)
   )
 
   add_test(
-    NAME idxtest
+    NAME idxTest
     COMMAND idxTest
   )
   add_test(

source/libs/index/test/jsonUT.cc

@@ -60,6 +60,7 @@ class JsonEnv : public ::testing::Test {
   }
   virtual void TearDown() {
     indexJsonClose(index);
+    indexOptsDestroy(opts);
     printf("destory\n");
     taosMsleep(1000);
   }
@@ -152,6 +153,7 @@ TEST_F(JsonEnv, testWrite) {
     indexMultiTermQueryAdd(mq, q, QUERY_TERM);
     indexJsonSearch(index, mq, result);
     EXPECT_EQ(100, taosArrayGetSize(result));
+    taosArrayDestroy(result);
     indexMultiTermQueryDestroy(mq);
   }
 }
@@ -211,6 +213,7 @@ TEST_F(JsonEnv, testWriteMillonData) {
     indexJsonSearch(index, mq, result);
     EXPECT_EQ(10, taosArrayGetSize(result));
     indexMultiTermQueryDestroy(mq);
+    taosArrayDestroy(result);
   }
   {
     {
@@ -226,6 +229,7 @@ TEST_F(JsonEnv, testWriteMillonData) {
       indexJsonSearch(index, mq, result);
       EXPECT_EQ(0, taosArrayGetSize(result));
       indexMultiTermQueryDestroy(mq);
+      taosArrayDestroy(result);
     }
     {
       {
@@ -241,6 +245,7 @@ TEST_F(JsonEnv, testWriteMillonData) {
         indexJsonSearch(index, mq, result);
         EXPECT_EQ(10, taosArrayGetSize(result));
         indexMultiTermQueryDestroy(mq);
+        taosArrayDestroy(result);
       }
     }
   }
@@ -311,6 +316,7 @@ TEST_F(JsonEnv, testWriteJsonNumberData) {
     indexJsonSearch(index, mq, result);
     EXPECT_EQ(1000, taosArrayGetSize(result));
     indexMultiTermQueryDestroy(mq);
+    taosArrayDestroy(result);
   }
   {
     std::string colName("test");
@@ -325,6 +331,7 @@ TEST_F(JsonEnv, testWriteJsonNumberData) {
     indexJsonSearch(index, mq, result);
     EXPECT_EQ(0, taosArrayGetSize(result));
     indexMultiTermQueryDestroy(mq);
+    taosArrayDestroy(result);
   }
   {
     std::string colName("test");
@@ -340,6 +347,7 @@ TEST_F(JsonEnv, testWriteJsonNumberData) {
     indexJsonSearch(index, mq, result);
     EXPECT_EQ(1000, taosArrayGetSize(result));
     indexMultiTermQueryDestroy(mq);
+    taosArrayDestroy(result);
   }
   {
     std::string colName("test");
@@ -355,6 +363,7 @@ TEST_F(JsonEnv, testWriteJsonNumberData) {
     indexJsonSearch(index, mq, result);
     EXPECT_EQ(0, taosArrayGetSize(result));
     indexMultiTermQueryDestroy(mq);
+    taosArrayDestroy(result);
   }
   {
     std::string colName("test");
@@ -370,6 +379,7 @@ TEST_F(JsonEnv, testWriteJsonNumberData) {
     indexJsonSearch(index, mq, result);
     EXPECT_EQ(1000, taosArrayGetSize(result));
     indexMultiTermQueryDestroy(mq);
+    taosArrayDestroy(result);
   }
 }
 
@@ -413,6 +423,7 @@ TEST_F(JsonEnv, testWriteJsonTfileAndCache_INT) {
     indexJsonSearch(index, mq, result);
     EXPECT_EQ(1000, taosArrayGetSize(result));
     indexMultiTermQueryDestroy(mq);
+    taosArrayDestroy(result);
   }
   {
     std::string colName("test1");
@@ -427,6 +438,7 @@ TEST_F(JsonEnv, testWriteJsonTfileAndCache_INT) {
     indexJsonSearch(index, mq, result);
     EXPECT_EQ(0, taosArrayGetSize(result));
     indexMultiTermQueryDestroy(mq);
+    taosArrayDestroy(result);
   }
   {
     std::string colName("test1");
@@ -442,6 +454,7 @@ TEST_F(JsonEnv, testWriteJsonTfileAndCache_INT) {
     indexJsonSearch(index, mq, result);
     EXPECT_EQ(1000, taosArrayGetSize(result));
     indexMultiTermQueryDestroy(mq);
+    taosArrayDestroy(result);
   }
   {
     std::string colName("test1");
@@ -456,6 +469,7 @@ TEST_F(JsonEnv, testWriteJsonTfileAndCache_INT) {
     indexJsonSearch(index, mq, result);
     EXPECT_EQ(0, taosArrayGetSize(result));
     indexMultiTermQueryDestroy(mq);
+    taosArrayDestroy(result);
   }
   {
     std::string colName("test1");
@@ -470,6 +484,7 @@ TEST_F(JsonEnv, testWriteJsonTfileAndCache_INT) {
     indexJsonSearch(index, mq, result);
     EXPECT_EQ(1000, taosArrayGetSize(result));
     indexMultiTermQueryDestroy(mq);
+    taosArrayDestroy(result);
   }
   {
     std::string colName("other_column");
@@ -499,6 +514,7 @@ TEST_F(JsonEnv, testWriteJsonTfileAndCache_INT) {
     indexJsonSearch(index, mq, result);
     EXPECT_EQ(0, taosArrayGetSize(result));
     indexMultiTermQueryDestroy(mq);
+    taosArrayDestroy(result);
   }
   {
     std::string colName("test1");
@@ -527,6 +543,7 @@ TEST_F(JsonEnv, testWriteJsonTfileAndCache_INT) {
     indexJsonSearch(index, mq, result);
     EXPECT_EQ(2000, taosArrayGetSize(result));
     indexMultiTermQueryDestroy(mq);
+    taosArrayDestroy(result);
   }
 }
 TEST_F(JsonEnv, testWriteJsonTfileAndCache_INT2) {
@@ -553,6 +570,7 @@ TEST_F(JsonEnv, testWriteJsonTfileAndCache_INT2) {
     int         val = 9;
     Search(index, colName, TSDB_DATA_TYPE_INT, &val, sizeof(val), QUERY_GREATER_EQUAL, &res);
     EXPECT_EQ(1000, taosArrayGetSize(res));
+    taosArrayDestroy(res);
   }
   {
     SArray*     res = NULL;
@@ -560,6 +578,7 @@ TEST_F(JsonEnv, testWriteJsonTfileAndCache_INT2) {
     std::string colVal("xxxxxxxxxxxxxxx");
     Search(index, colName, TSDB_DATA_TYPE_BINARY, (void*)(colVal.c_str()), colVal.size(), QUERY_TERM, &res);
     EXPECT_EQ(1000, taosArrayGetSize(res));
+    taosArrayDestroy(res);
   }
 }
 TEST_F(JsonEnv, testWriteJsonTfileAndCache_FLOAT) {
@@ -583,6 +602,7 @@ TEST_F(JsonEnv, testWriteJsonTfileAndCache_FLOAT) {
     float       val = 1.9;
     Search(index, colName, TSDB_DATA_TYPE_FLOAT, &val, sizeof(val), QUERY_GREATER_EQUAL, &res);
     EXPECT_EQ(2000, taosArrayGetSize(res));
+    taosArrayDestroy(res);
   }
   {
     SArray*     res = NULL;
@@ -590,6 +610,7 @@ TEST_F(JsonEnv, testWriteJsonTfileAndCache_FLOAT) {
     float       val = 2.1;
     Search(index, colName, TSDB_DATA_TYPE_FLOAT, &val, sizeof(val), QUERY_GREATER_EQUAL, &res);
     EXPECT_EQ(1000, taosArrayGetSize(res));
+    taosArrayDestroy(res);
   }
   {
     std::string colName("test1");
@@ -597,6 +618,7 @@ TEST_F(JsonEnv, testWriteJsonTfileAndCache_FLOAT) {
     float       val = 2.1;
     Search(index, colName, TSDB_DATA_TYPE_FLOAT, &val, sizeof(val), QUERY_GREATER_EQUAL, &res);
     EXPECT_EQ(1000, taosArrayGetSize(res));
+    taosArrayDestroy(res);
   }
 }
 TEST_F(JsonEnv, testWriteJsonTfileAndCache_DOUBLE) {
@@ -618,29 +640,34 @@ TEST_F(JsonEnv, testWriteJsonTfileAndCache_DOUBLE) {
     double      val = 1.9;
     Search(index, "test1", TSDB_DATA_TYPE_DOUBLE, &val, sizeof(val), QUERY_GREATER_EQUAL, &res);
     EXPECT_EQ(2000, taosArrayGetSize(res));
+    taosArrayDestroy(res);
   }
   {
     SArray* res = NULL;
     double  val = 2.1;
     Search(index, "test1", TSDB_DATA_TYPE_DOUBLE, &val, sizeof(val), QUERY_GREATER_EQUAL, &res);
     EXPECT_EQ(1000, taosArrayGetSize(res));
+    taosArrayDestroy(res);
   }
   {
     SArray* res = NULL;
     double  val = 2.1;
     Search(index, "test1", TSDB_DATA_TYPE_DOUBLE, &val, sizeof(val), QUERY_GREATER_EQUAL, &res);
     EXPECT_EQ(1000, taosArrayGetSize(res));
+    taosArrayDestroy(res);
   }
   {
     SArray* res = NULL;
     double  val = 10.0;
     Search(index, "test1", TSDB_DATA_TYPE_DOUBLE, &val, sizeof(val), QUERY_LESS_EQUAL, &res);
     EXPECT_EQ(2000, taosArrayGetSize(res));
+    taosArrayDestroy(res);
   }
   {
     SArray* res = NULL;
     double  val = 10.0;
     Search(index, "test1", TSDB_DATA_TYPE_DOUBLE, &val, sizeof(val), QUERY_LESS_THAN, &res);
     EXPECT_EQ(1000, taosArrayGetSize(res));
+    taosArrayDestroy(res);
   }
 }

source/libs/nodes/test/nodesTestMain.cpp

@@ -53,6 +53,7 @@ TEST(NodesTest, traverseTest) {
   EXPECT_EQ(res, DEAL_RES_CONTINUE);
   EXPECT_EQ(nodeType(pRoot), QUERY_NODE_VALUE);
   EXPECT_EQ(string(((SValueNode*)pRoot)->literal), "18");
+  nodesDestroyNode(pRoot);
 }
 
 int main(int argc, char* argv[]) {

source/libs/scheduler/src/schRemote.c

@@ -455,7 +455,6 @@ int32_t schHandleCallback(void *param, SDataBuf *pMsg, int32_t rspCode) {
          tstrerror(rspCode));
 
   SCH_ERR_JRET(schProcessOnCbBegin(&pJob, &pTask, pParam->queryId, pParam->refId, pParam->taskId));
-  
   code = schHandleResponseMsg(pJob, pTask, pParam->execId, pMsg, rspCode);
   pMsg->pData = NULL;
 

source/libs/tfs/test/tfsTest.cpp

@@ -218,6 +218,7 @@ TEST_F(TfsTest, 04_File) {
     EXPECT_STREQ(outfile.aname, file0.aname);
     EXPECT_STREQ(outfile.rname, "fname");
     EXPECT_EQ(outfile.pTfs, pTfs);
+    taosMemoryFree(ret);
   }
 
   {

source/libs/transport/test/CMakeLists.txt

@@ -106,4 +106,3 @@ add_test(
   NAME transUtilUt 
   COMMAND transportTest
 )
-

source/libs/wal/test/walMetaTest.cpp

@@ -441,4 +441,5 @@ TEST_F(WalRetentionEnv, repairMeta1) {
       EXPECT_EQ(newStr[j], pRead->pHead->head.body[j]);
     }
   }
+  walCloseReader(pRead);
 }

source/os/test/osTests.cpp

@@ -111,11 +111,6 @@ void fileOperateOnBusy(void *param) {
 
   ret = taosUnLockFile(pFile);
   printf("On busy thread unlock file ret:%d\n", ret);
-#ifdef _TD_DARWIN_64
-  ASSERT_EQ(ret, 0);
-#else
-  ASSERT_NE(ret, 0);
-#endif
 
   ret = taosCloseFile(&pFile);
   printf("On busy thread close file ret:%d\n", ret);
@@ -134,6 +129,8 @@ TEST(osTest, osFile) {
   printf("create file success\n");
   taosCloseFile(&pOutFD);
 
+  taosCloseFile(&pOutFD);
+
   TdFilePtr pFile = taosOpenFile(fname, TD_FILE_CREATE | TD_FILE_WRITE);
   printf("open file\n");
   ASSERT_NE(pFile, nullptr);

source/util/test/pageBufferTest.cpp

@@ -217,6 +217,7 @@ void testFlushAndReadBackBuffer() {
   pPg = (SFilePage*)getBufPage(pBuf, pageId);
   ASSERT_TRUE(checkBufVarData(pPg, rowData + 3, len));
   destroyDiskbasedBuf(pBuf);
+  taosMemoryFree(rowData);
 }
 
 }  // namespace

tests/CMakeLists.txt

@@ -1,4 +1,4 @@
-#ADD_SUBDIRECTORY(examples/c)
+
-ADD_SUBDIRECTORY(tsim)
+if(${BUILD_TEST})
-ADD_SUBDIRECTORY(test/c)
+    add_subdirectory(taosc_test)
-#ADD_SUBDIRECTORY(comparisonTest/tdengine)
+endif(${BUILD_TEST})

tests/taosc_test/CMakeLists.txt

@@ -0,0 +1,28 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8...3.20)
+PROJECT(TDengine)
+
+FIND_PATH(HEADER_GTEST_INCLUDE_DIR gtest.h /usr/include/gtest /usr/local/include/gtest /usr/local/taos/include)
+FIND_LIBRARY(LIB_GTEST_STATIC_DIR libgtest.a /usr/lib/ /usr/local/lib /usr/lib64 /usr/local/taos/driver/)
+FIND_LIBRARY(LIB_GTEST_SHARED_DIR libgtest.so /usr/lib/ /usr/local/lib /usr/lib64 /usr/local/taos/driver/)
+
+IF (HEADER_GTEST_INCLUDE_DIR AND (LIB_GTEST_STATIC_DIR OR LIB_GTEST_SHARED_DIR))
+    MESSAGE(STATUS "gTest library found, build os test")
+
+    INCLUDE_DIRECTORIES(${HEADER_GTEST_INCLUDE_DIR})
+    AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} SOURCE_LIST)
+
+ENDIF()
+
+aux_source_directory(src OS_SRC)
+# taoscTest
+add_executable(taoscTest "taoscTest.cpp")
+target_link_libraries(taoscTest taos os gtest_main)
+target_include_directories(
+    taoscTest
+    PUBLIC "${TD_SOURCE_DIR}/include/os"
+)
+add_test(
+    NAME taoscTest
+    COMMAND taoscTest
+)
+

tests/taosc_test/taoscTest.cpp

@@ -0,0 +1,265 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <gtest/gtest.h>
+#include <iostream>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wwrite-strings"
+#pragma GCC diagnostic ignored "-Wunused-function"
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#pragma GCC diagnostic ignored "-Wsign-compare"
+#pragma GCC diagnostic ignored "-Wsign-compare"
+#pragma GCC diagnostic ignored "-Wformat"
+#pragma GCC diagnostic ignored "-Wint-to-pointer-cast"
+#pragma GCC diagnostic ignored "-Wpointer-arith"
+
+#include "os.h"
+#include "taos.h"
+
+class taoscTest : public ::testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    printf("start test setup.\n");
+    TAOS* taos = taos_connect("localhost", "root", "taosdata", NULL, 0);
+    ASSERT_TRUE(taos != nullptr);
+
+    TAOS_RES* res = taos_query(taos, "drop database IF EXISTS taosc_test_db;");
+    if (taos_errno(res) != 0) {
+      printf("error in drop database taosc_test_db, reason:%s\n", taos_errstr(res));
+      return;
+    }
+    taosSsleep(5);
+    taos_free_result(res);
+    printf("drop database taosc_test_db,finished.\n");
+
+    res = taos_query(taos, "create database taosc_test_db;");
+    if (taos_errno(res) != 0) {
+      printf("error in create database taosc_test_db, reason:%s\n", taos_errstr(res));
+      return;
+    }
+    taosSsleep(5);
+    taos_free_result(res);
+    printf("create database taosc_test_db,finished.\n");
+
+    taos_close(taos);
+  }
+
+  static void TearDownTestCase() {}
+
+  void SetUp() override {}
+
+  void TearDown() override {}
+};
+
+tsem_t query_sem;
+int    getRecordCounts = 0;
+int    insertCounts = 100;
+void*  pUserParam = NULL;
+
+void fetchCallback(void* param, void* res, int32_t numOfRow) {
+  ASSERT_TRUE(numOfRow >= 0);
+  if (numOfRow == 0) {
+    printf("completed\n");
+    taos_free_result(res);
+    tsem_post(&query_sem);
+    return;
+  }
+
+  printf("numOfRow = %d \n", numOfRow);
+  int         numFields = taos_num_fields(res);
+  TAOS_FIELD* fields = taos_fetch_fields(res);
+
+  for (int i = 0; i < numOfRow; ++i) {
+    TAOS_ROW row = taos_fetch_row(res);
+    char     temp[256] = {0};
+    taos_print_row(temp, row, fields, numFields);
+    // printf("%s\n", temp);
+  }
+
+  getRecordCounts += numOfRow;
+  taos_fetch_raw_block_a(res, fetchCallback, param);
+}
+
+void queryCallback(void* param, void* res, int32_t code) {
+  ASSERT_TRUE(code == 0);
+  ASSERT_TRUE(param == pUserParam);
+  taos_fetch_raw_block_a(res, fetchCallback, param);
+}
+
+TEST_F(taoscTest, taos_query_a_test) {
+  char    sql[1024] = {0};
+  int32_t code = 0;
+  TAOS*   taos = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  ASSERT_TRUE(taos != nullptr);
+
+  const char* table_name = "taosc_test_table1";
+  sprintf(sql, "create table taosc_test_db.%s (ts TIMESTAMP, val INT)", table_name);
+  TAOS_RES* res = taos_query(taos, sql);
+  if (taos_errno(res) != 0) {
+    printf("error in table database %s, reason:%s\n", table_name, taos_errstr(res));
+  }
+  ASSERT_TRUE(taos_errno(res) == 0);
+  taos_free_result(res);
+  taosSsleep(2);
+
+  for (int i = 0; i < insertCounts; i++) {
+    char sql[128];
+    sprintf(sql, "insert into taosc_test_db.%s values(now() + %ds, %d)", table_name, i, i);
+    res = taos_query(taos, sql);
+    ASSERT_TRUE(taos_errno(res) == 0);
+    taos_free_result(res);
+  }
+
+  pUserParam = NULL;
+  void* tmpParam = pUserParam;
+  tsem_init(&query_sem, 0, 0);
+  sprintf(sql, "select * from taosc_test_db.%s;", table_name);
+  taos_query_a(taos, sql, queryCallback, pUserParam);
+  tsem_wait(&query_sem);
+  ASSERT_TRUE(pUserParam == tmpParam);
+
+  ASSERT_EQ(getRecordCounts, insertCounts);
+  taos_close(taos);
+
+  printf("taos_query_a test finished.\n");
+}
+
+TEST_F(taoscTest, taos_query_a_param_test) {
+  char    sql[1024] = {0};
+  int32_t code = 0;
+  TAOS*   taos = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  ASSERT_TRUE(taos != nullptr);
+
+  int pArray[2] = {0, 1};
+  pUserParam = NULL;
+  void* tmpParam = pUserParam;
+  getRecordCounts = 0;
+  const char* table_name = "taosc_test_table1";
+  tsem_init(&query_sem, 0, 0);
+  sprintf(sql, "select * from taosc_test_db.%s;", table_name);
+  taos_query_a(taos, sql, queryCallback, pUserParam);
+  tsem_wait(&query_sem);
+  ASSERT_TRUE(pUserParam == tmpParam);
+  ASSERT_EQ(pArray[0], 0);
+  ASSERT_EQ(pArray[1], 1);
+
+  ASSERT_EQ(getRecordCounts, insertCounts);
+  taos_close(taos);
+
+  printf("taos_query_a_param test finished.\n");
+}
+
+TEST_F(taoscTest, taos_query_test) {
+  char    sql[1024] = {0};
+  int32_t code = 0;
+  TAOS*   taos = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  ASSERT_TRUE(taos != nullptr);
+
+  const char* table_name = "taosc_test_table1";
+  sprintf(sql, "select * from taosc_test_db.%s;", table_name);
+  TAOS_RES* res = taos_query(taos, sql);
+  ASSERT_TRUE(res != nullptr);
+
+  getRecordCounts = 0;
+  TAOS_ROW row;
+  while ((row = taos_fetch_row(res))) {
+    getRecordCounts++;
+  }
+  ASSERT_EQ(getRecordCounts, insertCounts);
+  taos_free_result(res);
+  taos_close(taos);
+
+  printf("taos_query test finished.\n");
+}
+
+void queryCallback2(void* param, void* res, int32_t code) {
+  ASSERT_TRUE(code == 0);
+  ASSERT_TRUE(param == pUserParam);
+  // After using taos_query_a to query, using taos_fetch_row in the callback will cause blocking. 
+  // Reason: schProcessOnCbBegin SCH_LOCK_TASK(pTask)
+  /* TAOS_ROW row;
+  while ((row = taos_fetch_row(res))) {
+     getRecordCounts++;
+  } */
+  tsem_post(&query_sem);
+  taos_free_result(res);
+}
+
+TEST_F(taoscTest, taos_query_a_t2) {
+  char    sql[1024] = {0};
+  int32_t code = 0;
+  TAOS*   taos = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  ASSERT_TRUE(taos != nullptr);
+
+  getRecordCounts = 0;
+
+  const char* table_name = "taosc_test_table1";
+  sprintf(sql, "select * from taosc_test_db.%s;", table_name);
+
+  pUserParam = NULL;
+  tsem_init(&query_sem, 0, 0);
+  taos_query_a(taos, sql, queryCallback2, pUserParam);
+  tsem_timewait(&query_sem, 10 * 1000);
+
+  ASSERT_NE(getRecordCounts, insertCounts);
+  taos_close(taos);
+
+  printf("taos_query_a_t2 test finished.\n");
+}
+
+void queryCallbackStartFetchThread(void* param, void* res, int32_t code) {
+  printf("queryCallbackStartFetchThread start...\n");
+  ASSERT_TRUE(code == 0);
+  void** tmp = (void**)param;
+  *tmp = res;
+  printf("queryCallbackStartFetchThread end. res:%p\n", res);
+  tsem_post(&query_sem);
+}
+
+TEST_F(taoscTest, taos_query_a_fetch_row) {
+  char    sql[1024] = {0};
+  int32_t code = 0;
+  TAOS*   taos = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  ASSERT_TRUE(taos != nullptr);
+
+  getRecordCounts = 0;
+
+  const char* table_name = "taosc_test_table1";
+  sprintf(sql, "select * from taosc_test_db.%s;", table_name);
+
+  tsem_init(&query_sem, 0, 0);
+  printf("taos_query_a_fetch_row  query start...\n");
+  TAOS_RES *res;
+  TAOS_RES **pres = &res;
+  taos_query_a(taos, sql, queryCallbackStartFetchThread, pres);
+  tsem_wait(&query_sem);
+
+  getRecordCounts = 0;
+  TAOS_ROW row;
+  printf("taos_query_a_fetch_row  taos_fetch_row start...\n");
+
+  while ((row = taos_fetch_row(*pres))) {
+     getRecordCounts++;
+  }
+  printf("taos_query_a_fetch_row  taos_fetch_row end. %p record count:%d.\n", *pres, getRecordCounts);
+  taos_free_result(*pres);
+
+  ASSERT_EQ(getRecordCounts, insertCounts);
+  taos_close(taos);
+
+  printf("taos_query_a_fetch_row test finished.\n");
+}
+

tests/unit-test/test.sh

@@ -6,7 +6,7 @@ function usage() {
     echo -e "\t -h help"
 }
 
-ent=0
+ent=1
 while getopts "eh" opt; do
     case $opt in
         e)
@@ -34,7 +34,14 @@ else
     cd ../../../debug
 fi
 
-ctest -j8
+set -e
+
+pgrep taosd || taosd >> /dev/null 2>&1 &
+
+sleep 10
+
+ctest -E "smlTest|funcTest|profileTest|sdbTest|showTest|geomTest|idxFstUtilUT|idxTest|idxUtilUT|idxFstUT|parserTest|plannerTest|transUT|transUtilUt" -j8
+
 ret=$?
 exit $ret