rename test cases

source/dnode/mgmt/impl/test/CMakeLists.txt

@@ -1,3 +1,4 @@
+enable_testing()
 
 add_subdirectory(acct)
 # add_subdirectory(auth)
@@ -9,7 +10,7 @@ add_subdirectory(dnode)
 # add_subdirectory(mnode)
 # add_subdirectory(profile)
 # add_subdirectory(show)
-# add_subdirectory(stb)
+add_subdirectory(stb)
 # add_subdirectory(sync)
 # add_subdirectory(telem)
 # add_subdirectory(trans)

source/dnode/mgmt/impl/test/acct/CMakeLists.txt

@@ -21,8 +21,6 @@ target_include_directories(dnode_test_acct
     "${CMAKE_CURRENT_SOURCE_DIR}/../sut"
 )
 
-enable_testing()
-
 add_test(
     NAME dnode_test_acct
     COMMAND dnode_test_acct

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

@@ -1,5 +1,5 @@
 /**
- * @file vnodeApiTests.cpp
+ * @file acct.cpp
  * @author slguan (slguan@taosdata.com)
  * @brief DNODE module acct-msg tests
  * @version 0.1

source/dnode/mgmt/impl/test/cluster/CMakeLists.txt

@@ -21,8 +21,6 @@ target_include_directories(dnode_test_cluster
     "${CMAKE_CURRENT_SOURCE_DIR}/../sut"
 )
 
-enable_testing()
-
 add_test(
     NAME dnode_test_cluster
     COMMAND dnode_test_cluster

source/dnode/mgmt/impl/test/cluster/cluster.cpp

@@ -1,5 +1,5 @@
 /**
- * @file vnodeApiTests.cpp
+ * @file cluster.cpp
  * @author slguan (slguan@taosdata.com)
  * @brief DNODE module cluster-msg tests
  * @version 0.1

source/dnode/mgmt/impl/test/db/CMakeLists.txt

@@ -21,8 +21,6 @@ target_include_directories(dnode_test_db
     "${CMAKE_CURRENT_SOURCE_DIR}/../sut"
 )
 
-enable_testing()
-
 add_test(
     NAME dnode_test_db
     COMMAND dnode_test_db

source/dnode/mgmt/impl/test/db/db.cpp

@@ -1,5 +1,5 @@
 /**
- * @file vnodeApiTests.cpp
+ * @file db.cpp
  * @author slguan (slguan@taosdata.com)
  * @brief DNODE module db-msg tests
  * @version 0.1

source/dnode/mgmt/impl/test/dnode/CMakeLists.txt

@@ -21,8 +21,6 @@ target_include_directories(dnode_test_dnode
     "${CMAKE_CURRENT_SOURCE_DIR}/../sut"
 )
 
-enable_testing()
-
 add_test(
     NAME dnode_test_dnode
     COMMAND dnode_test_dnode

source/dnode/mgmt/impl/test/dnode/dnode.cpp

@@ -1,5 +1,5 @@
 /**
- * @file vnodeApiTests.cpp
+ * @file dnode.cpp
  * @author slguan (slguan@taosdata.com)
  * @brief DNODE module dnode-msg tests
  * @version 0.1

source/dnode/mgmt/impl/test/profile/CMakeLists.txt

@@ -21,8 +21,6 @@ target_include_directories(dndTestProfile
     "${CMAKE_CURRENT_SOURCE_DIR}/../sut"
 )
 
-enable_testing()
-
 add_test(
     NAME dndTestProfile
     COMMAND dndTestProfile

source/dnode/mgmt/impl/test/profile/profile.cpp

@@ -1,5 +1,5 @@
 /**
- * @file vnodeApiTests.cpp
+ * @file profile.cpp
  * @author slguan (slguan@taosdata.com)
  * @brief DNODE module profile-msg tests
  * @version 0.1

source/dnode/mgmt/impl/test/show/CMakeLists.txt

@@ -21,8 +21,6 @@ target_include_directories(dnode_test_show
     "${CMAKE_CURRENT_SOURCE_DIR}/../sut"
 )
 
-enable_testing()
-
 add_test(
     NAME dnode_test_show
     COMMAND dnode_test_show

source/dnode/mgmt/impl/test/show/show.cpp

@@ -1,5 +1,5 @@
 /**
- * @file vnodeApiTests.cpp
+ * @file show.cpp
  * @author slguan (slguan@taosdata.com)
  * @brief DNODE module show-msg tests
  * @version 0.1

source/dnode/mgmt/impl/test/stb/CMakeLists.txt

@@ -0,0 +1,27 @@
+add_executable(dnode_test_stb "")
+
+target_sources(dnode_test_stb
+    PRIVATE
+    "stb.cpp"
+    "../sut/deploy.cpp"
+)
+
+target_link_libraries(
+    dnode_test_stb
+    PUBLIC dnode
+    PUBLIC util
+    PUBLIC os
+    PUBLIC gtest_main
+)
+
+target_include_directories(dnode_test_stb
+    PUBLIC
+    "${CMAKE_SOURCE_DIR}/include/server/dnode/mgmt"
+    "${CMAKE_CURRENT_SOURCE_DIR}/../../inc"
+    "${CMAKE_CURRENT_SOURCE_DIR}/../sut"
+)
+
+add_test(
+    NAME dnode_test_stb
+    COMMAND dnode_test_stb
+)

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

@@ -0,0 +1,479 @@
+/**
+ * @file stb.cpp
+ * @author slguan (slguan@taosdata.com)
+ * @brief DNODE module db-msg tests
+ * @version 0.1
+ * @date 2021-12-17
+ *
+ * @copyright Copyright (c) 2021
+ *
+ */
+
+#include "deploy.h"
+
+class DndTestStb : public ::testing::Test {
+ protected:
+  static SServer* CreateServer(const char* path, const char* fqdn, uint16_t port, const char* firstEp) {
+    SServer* pServer = createServer(path, fqdn, port, firstEp);
+    ASSERT(pServer);
+    return pServer;
+  }
+
+  static void SetUpTestSuite() {
+    initLog("/tmp/tdlog");
+
+    const char* fqdn = "localhost";
+    const char* firstEp = "localhost:9101";
+    pServer = CreateServer("/tmp/dnode_test_stb", fqdn, 9101, firstEp);
+    pClient = createClient("root", "taosdata", fqdn, 9101);
+    taosMsleep(1100);
+  }
+
+  static void TearDownTestSuite() {
+    stopServer(pServer);
+    dropClient(pClient);
+    pServer = NULL;
+    pClient = NULL;
+  }
+
+  static SServer* pServer;
+  static SClient* pClient;
+  static int32_t  connId;
+
+ public:
+  void SetUp() override {}
+  void TearDown() override {}
+
+  void SendTheCheckShowMetaMsg(int8_t showType, const char* showName, int32_t columns, const char* db) {
+    SShowMsg* pShow = (SShowMsg*)rpcMallocCont(sizeof(SShowMsg));
+    pShow->type = showType;
+    if (db != NULL) {
+      strcpy(pShow->db, db);
+    }
+    SRpcMsg showRpcMsg = {0};
+    showRpcMsg.pCont = pShow;
+    showRpcMsg.contLen = sizeof(SShowMsg);
+    showRpcMsg.msgType = TSDB_MSG_TYPE_SHOW;
+
+    sendMsg(pClient, &showRpcMsg);
+    ASSERT_NE(pClient->pRsp, nullptr);
+    ASSERT_EQ(pClient->pRsp->code, 0);
+    ASSERT_NE(pClient->pRsp->pCont, nullptr);
+
+    SShowRsp* pShowRsp = (SShowRsp*)pClient->pRsp->pCont;
+    ASSERT_NE(pShowRsp, nullptr);
+    pShowRsp->showId = htonl(pShowRsp->showId);
+    pMeta = &pShowRsp->tableMeta;
+    pMeta->numOfTags = htonl(pMeta->numOfTags);
+    pMeta->numOfColumns = htonl(pMeta->numOfColumns);
+    pMeta->sversion = htonl(pMeta->sversion);
+    pMeta->tversion = htonl(pMeta->tversion);
+    pMeta->tuid = htobe64(pMeta->tuid);
+    pMeta->suid = htobe64(pMeta->suid);
+
+    showId = pShowRsp->showId;
+
+    EXPECT_NE(pShowRsp->showId, 0);
+    EXPECT_STREQ(pMeta->tbFname, showName);
+    EXPECT_EQ(pMeta->numOfTags, 0);
+    EXPECT_EQ(pMeta->numOfColumns, columns);
+    EXPECT_EQ(pMeta->precision, 0);
+    EXPECT_EQ(pMeta->tableType, 0);
+    EXPECT_EQ(pMeta->update, 0);
+    EXPECT_EQ(pMeta->sversion, 0);
+    EXPECT_EQ(pMeta->tversion, 0);
+    EXPECT_EQ(pMeta->tuid, 0);
+    EXPECT_EQ(pMeta->suid, 0);
+  }
+
+  void CheckSchema(int32_t index, int8_t type, int32_t bytes, const char* name) {
+    SSchema* pSchema = &pMeta->pSchema[index];
+    pSchema->bytes = htons(pSchema->bytes);
+    EXPECT_EQ(pSchema->colId, 0);
+    EXPECT_EQ(pSchema->type, type);
+    EXPECT_EQ(pSchema->bytes, bytes);
+    EXPECT_STREQ(pSchema->name, name);
+  }
+
+  void SendThenCheckShowRetrieveMsg(int32_t rows) {
+    SRetrieveTableMsg* pRetrieve = (SRetrieveTableMsg*)rpcMallocCont(sizeof(SRetrieveTableMsg));
+    pRetrieve->showId = htonl(showId);
+    pRetrieve->free = 0;
+
+    SRpcMsg retrieveRpcMsg = {0};
+    retrieveRpcMsg.pCont = pRetrieve;
+    retrieveRpcMsg.contLen = sizeof(SRetrieveTableMsg);
+    retrieveRpcMsg.msgType = TSDB_MSG_TYPE_SHOW_RETRIEVE;
+
+    sendMsg(pClient, &retrieveRpcMsg);
+
+    ASSERT_NE(pClient->pRsp, nullptr);
+    ASSERT_EQ(pClient->pRsp->code, 0);
+    ASSERT_NE(pClient->pRsp->pCont, nullptr);
+
+    pRetrieveRsp = (SRetrieveTableRsp*)pClient->pRsp->pCont;
+    ASSERT_NE(pRetrieveRsp, nullptr);
+    pRetrieveRsp->numOfRows = htonl(pRetrieveRsp->numOfRows);
+    pRetrieveRsp->offset = htobe64(pRetrieveRsp->offset);
+    pRetrieveRsp->useconds = htobe64(pRetrieveRsp->useconds);
+    pRetrieveRsp->compLen = htonl(pRetrieveRsp->compLen);
+
+    EXPECT_EQ(pRetrieveRsp->numOfRows, rows);
+    EXPECT_EQ(pRetrieveRsp->offset, 0);
+    EXPECT_EQ(pRetrieveRsp->useconds, 0);
+    // EXPECT_EQ(pRetrieveRsp->completed, completed);
+    EXPECT_EQ(pRetrieveRsp->precision, TSDB_TIME_PRECISION_MILLI);
+    EXPECT_EQ(pRetrieveRsp->compressed, 0);
+    EXPECT_EQ(pRetrieveRsp->reserved, 0);
+    EXPECT_EQ(pRetrieveRsp->compLen, 0);
+
+    pData = pRetrieveRsp->data;
+    pos = 0;
+  }
+
+  void CheckInt8(int8_t val) {
+    int8_t data = *((int8_t*)(pData + pos));
+    pos += sizeof(int8_t);
+    EXPECT_EQ(data, val);
+  }
+
+  void CheckInt16(int16_t val) {
+    int16_t data = *((int16_t*)(pData + pos));
+    pos += sizeof(int16_t);
+    EXPECT_EQ(data, val);
+  }
+
+  void CheckInt32(int32_t val) {
+    int32_t data = *((int32_t*)(pData + pos));
+    pos += sizeof(int32_t);
+    EXPECT_EQ(data, val);
+  }
+
+  void CheckInt64(int64_t val) {
+    int64_t data = *((int64_t*)(pData + pos));
+    pos += sizeof(int64_t);
+    EXPECT_EQ(data, val);
+  }
+
+  void CheckTimestamp() {
+    int64_t data = *((int64_t*)(pData + pos));
+    pos += sizeof(int64_t);
+    EXPECT_GT(data, 0);
+  }
+
+  void CheckBinary(const char* val, int32_t len) {
+    pos += sizeof(VarDataLenT);
+    char* data = (char*)(pData + pos);
+    pos += len;
+    EXPECT_STREQ(data, val);
+  }
+
+  int32_t            showId;
+  STableMetaMsg*     pMeta;
+  SRetrieveTableRsp* pRetrieveRsp;
+  char*              pData;
+  int32_t            pos;
+};
+
+SServer* DndTestStb::pServer;
+SClient* DndTestStb::pClient;
+int32_t  DndTestStb::connId;
+
+TEST_F(DndTestStb, 01_Create_Alter_Drop_Stb) {
+  {
+    SCreateDbMsg* pReq = (SCreateDbMsg*)rpcMallocCont(sizeof(SCreateDbMsg));
+    strcpy(pReq->db, "1.d1");
+    pReq->numOfVgroups = htonl(2);
+    pReq->cacheBlockSize = htonl(16);
+    pReq->totalBlocks = htonl(10);
+    pReq->daysPerFile = htonl(10);
+    pReq->daysToKeep0 = htonl(3650);
+    pReq->daysToKeep1 = htonl(3650);
+    pReq->daysToKeep2 = htonl(3650);
+    pReq->minRowsPerFileBlock = htonl(100);
+    pReq->maxRowsPerFileBlock = htonl(4096);
+    pReq->commitTime = htonl(3600);
+    pReq->fsyncPeriod = htonl(3000);
+    pReq->walLevel = 1;
+    pReq->precision = 0;
+    pReq->compression = 2;
+    pReq->replications = 1;
+    pReq->quorum = 1;
+    pReq->update = 0;
+    pReq->cacheLastRow = 0;
+    pReq->ignoreExist = 1;
+
+    SRpcMsg rpcMsg = {0};
+    rpcMsg.pCont = pReq;
+    rpcMsg.contLen = sizeof(SCreateDbMsg);
+    rpcMsg.msgType = TSDB_MSG_TYPE_CREATE_DB;
+
+    sendMsg(pClient, &rpcMsg);
+    SRpcMsg* pMsg = pClient->pRsp;
+    ASSERT_NE(pMsg, nullptr);
+    ASSERT_EQ(pMsg->code, 0);
+  }
+
+  {
+    int32_t tags = 2;
+    int32_t cols = 3;
+    int32_t size = (tags + cols) * sizeof(SSchema) + sizeof(SCreateStbMsg);
+
+    SCreateStbMsg* pReq = (SCreateStbMsg*)rpcMallocCont(size);
+    strcpy(pReq->name, "1.d1.stb");
+    pReq->numOfTags = htonl(tags);
+    pReq->numOfColumns = htonl(cols);
+
+    {
+      SSchema* pSchema = &pReq->pSchema[0];
+      pSchema->colId = htonl(0);
+      pSchema->bytes = htonl(8);
+      pSchema->type = TSDB_DATA_TYPE_TIMESTAMP;
+      strcpy(pSchema->name, "ts");
+    }
+
+    {
+      SSchema* pSchema = &pReq->pSchema[1];
+      pSchema->colId = htonl(1);
+      pSchema->bytes = htonl(4);
+      pSchema->type = TSDB_DATA_TYPE_INT;
+      strcpy(pSchema->name, "col1");
+    }
+
+    {
+      SSchema* pSchema = &pReq->pSchema[2];
+      pSchema->colId = htonl(2);
+      pSchema->bytes = htonl(2);
+      pSchema->type = TSDB_DATA_TYPE_TINYINT;
+      strcpy(pSchema->name, "tag1");
+    }
+
+    {
+      SSchema* pSchema = &pReq->pSchema[3];
+      pSchema->colId = htonl(3);
+      pSchema->bytes = htonl(8);
+      pSchema->type = TSDB_DATA_TYPE_BIGINT;
+      strcpy(pSchema->name, "tag2");
+    }
+
+    {
+      SSchema* pSchema = &pReq->pSchema[4];
+      pSchema->colId = htonl(4);
+      pSchema->bytes = htonl(16);
+      pSchema->type = TSDB_DATA_TYPE_BINARY;
+      strcpy(pSchema->name, "tag3");
+    }
+
+    SRpcMsg rpcMsg = {0};
+    rpcMsg.pCont = pReq;
+    rpcMsg.contLen = sizeof(SCreateStbMsg);
+    rpcMsg.msgType = TSDB_MSG_TYPE_CREATE_STB;
+
+    sendMsg(pClient, &rpcMsg);
+    SRpcMsg* pMsg = pClient->pRsp;
+    ASSERT_NE(pMsg, nullptr);
+    ASSERT_EQ(pMsg->code, 0);
+  }
+  taosMsleep(10000);
+
+  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DB, "show stables", 4, NULL);
+  CheckSchema(0, TSDB_DATA_TYPE_BINARY, TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE, "name");
+  CheckSchema(1, TSDB_DATA_TYPE_TIMESTAMP, 8, "create time");
+  CheckSchema(2, TSDB_DATA_TYPE_INT, 2, "columns");
+  CheckSchema(3, TSDB_DATA_TYPE_INT, 2, "tags");
+
+  SendThenCheckShowRetrieveMsg(1);
+  CheckBinary("stb", TSDB_DB_NAME_LEN - 1);
+  CheckTimestamp();
+  CheckInt16(2);
+  CheckInt16(3);
+
+#if 0
+  {
+    SAlterDbMsg* pReq = (SAlterDbMsg*)rpcMallocCont(sizeof(SAlterDbMsg));
+    strcpy(pReq->db, "1.d1");
+    pReq->totalBlocks = htonl(12);
+    pReq->daysToKeep0 = htonl(300);
+    pReq->daysToKeep1 = htonl(400);
+    pReq->daysToKeep2 = htonl(500);
+    pReq->fsyncPeriod = htonl(4000);
+    pReq->walLevel = 2;
+    pReq->quorum = 2;
+    pReq->cacheLastRow = 1;
+
+    SRpcMsg rpcMsg = {0};
+    rpcMsg.pCont = pReq;
+    rpcMsg.contLen = sizeof(SAlterDbMsg);
+    rpcMsg.msgType = TSDB_MSG_TYPE_ALTER_DB;
+
+    sendMsg(pClient, &rpcMsg);
+    SRpcMsg* pMsg = pClient->pRsp;
+    ASSERT_NE(pMsg, nullptr);
+    ASSERT_EQ(pMsg->code, 0);
+  }
+
+  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DB, "show databases", 17, NULL);
+  SendThenCheckShowRetrieveMsg(1);
+  CheckBinary("d1", TSDB_DB_NAME_LEN - 1);
+  CheckTimestamp();
+  CheckInt16(2);                   // vgroups
+  CheckInt16(1);                   // replica
+  CheckInt16(2);                   // quorum
+  CheckInt16(10);                  // days
+  CheckBinary("300,400,500", 24);  // days
+  CheckInt32(16);                  // cache
+  CheckInt32(12);                  // blocks
+  CheckInt32(100);                 // minrows
+  CheckInt32(4096);                // maxrows
+  CheckInt8(2);                    // wallevel
+  CheckInt32(4000);                // fsync
+  CheckInt8(2);                    // comp
+  CheckInt8(1);                    // cachelast
+  CheckBinary("ms", 3);            // precision
+  CheckInt8(0);                    // update
+
+#endif
+
+  // restart
+  stopServer(pServer);
+  pServer = NULL;
+
+  uInfo("start all server");
+
+  const char* fqdn = "localhost";
+  const char* firstEp = "localhost:9101";
+  pServer = startServer("/tmp/dnode_test_stb", fqdn, 9101, firstEp);
+
+  uInfo("all server is running");
+
+  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DB, "show stables", 4, NULL);
+  CheckSchema(0, TSDB_DATA_TYPE_BINARY, TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE, "name");
+  CheckSchema(1, TSDB_DATA_TYPE_TIMESTAMP, 8, "create time");
+  CheckSchema(2, TSDB_DATA_TYPE_INT, 2, "columns");
+  CheckSchema(3, TSDB_DATA_TYPE_INT, 2, "tags");
+
+  SendThenCheckShowRetrieveMsg(1);
+  CheckBinary("stb", TSDB_DB_NAME_LEN - 1);
+  CheckTimestamp();
+  CheckInt16(2);
+  CheckInt16(3);
+
+#if 0
+  {
+    SDropStbMsg* pReq = (SDropStbMsg*)rpcMallocCont(sizeof(SDropStbMsg));
+    strcpy(pReq->name, "1.d1.stb");
+
+    SRpcMsg rpcMsg = {0};
+    rpcMsg.pCont = pReq;
+    rpcMsg.contLen = sizeof(SDropStbMsg);
+    rpcMsg.msgType = TSDB_MSG_TYPE_DROP_STB;
+
+    sendMsg(pClient, &rpcMsg);
+    SRpcMsg* pMsg = pClient->pRsp;
+    ASSERT_NE(pMsg, nullptr);
+    ASSERT_EQ(pMsg->code, 0);
+  }
+
+  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DB, "show stables", 4, NULL);
+  SendThenCheckShowRetrieveMsg(0);
+#endif  
+}
+
+#if 0
+TEST_F(DndTestStb, 03_Create_Use_Restart_Use_Db) {
+  {
+    SCreateDbMsg* pReq = (SCreateDbMsg*)rpcMallocCont(sizeof(SCreateDbMsg));
+    strcpy(pReq->db, "1.d2");
+    pReq->numOfVgroups = htonl(2);
+    pReq->cacheBlockSize = htonl(16);
+    pReq->totalBlocks = htonl(10);
+    pReq->daysPerFile = htonl(10);
+    pReq->daysToKeep0 = htonl(3650);
+    pReq->daysToKeep1 = htonl(3650);
+    pReq->daysToKeep2 = htonl(3650);
+    pReq->minRowsPerFileBlock = htonl(100);
+    pReq->maxRowsPerFileBlock = htonl(4096);
+    pReq->commitTime = htonl(3600);
+    pReq->fsyncPeriod = htonl(3000);
+    pReq->walLevel = 1;
+    pReq->precision = 0;
+    pReq->compression = 2;
+    pReq->replications = 1;
+    pReq->quorum = 1;
+    pReq->update = 0;
+    pReq->cacheLastRow = 0;
+    pReq->ignoreExist = 1;
+
+    SRpcMsg rpcMsg = {0};
+    rpcMsg.pCont = pReq;
+    rpcMsg.contLen = sizeof(SCreateDbMsg);
+    rpcMsg.msgType = TSDB_MSG_TYPE_CREATE_DB;
+
+    sendMsg(pClient, &rpcMsg);
+    SRpcMsg* pMsg = pClient->pRsp;
+    ASSERT_NE(pMsg, nullptr);
+    ASSERT_EQ(pMsg->code, 0);
+  }
+
+  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DB, "show databases", 17, NULL);
+  SendThenCheckShowRetrieveMsg(1);
+  CheckBinary("d2", TSDB_DB_NAME_LEN - 1);
+
+  {
+    SUseDbMsg* pReq = (SUseDbMsg*)rpcMallocCont(sizeof(SUseDbMsg));
+    strcpy(pReq->db, "1.d2");
+    pReq->vgVersion = htonl(-1);
+
+    SRpcMsg rpcMsg = {0};
+    rpcMsg.pCont = pReq;
+    rpcMsg.contLen = sizeof(SUseDbMsg);
+    rpcMsg.msgType = TSDB_MSG_TYPE_USE_DB;
+
+    sendMsg(pClient, &rpcMsg);
+    SRpcMsg* pMsg = pClient->pRsp;
+    ASSERT_NE(pMsg, nullptr);
+    ASSERT_EQ(pMsg->code, 0);
+
+    SUseDbRsp* pRsp = (SUseDbRsp*)pMsg->pCont;
+    EXPECT_STREQ(pRsp->db, "1.d2");
+    pRsp->vgVersion = htonl(pRsp->vgVersion);
+    pRsp->vgNum = htonl(pRsp->vgNum);
+    pRsp->hashMethod = pRsp->hashMethod;
+    EXPECT_EQ(pRsp->vgVersion, 1);
+    EXPECT_EQ(pRsp->vgNum, 2);
+    EXPECT_EQ(pRsp->hashMethod, 1);
+
+    {
+      SVgroupInfo* pInfo = &pRsp->vgroupInfo[0];
+      pInfo->vgId = htonl(pInfo->vgId);
+      pInfo->hashBegin = htonl(pInfo->hashBegin);
+      pInfo->hashEnd = htonl(pInfo->hashEnd);
+      EXPECT_GT(pInfo->vgId, 0);
+      EXPECT_EQ(pInfo->hashBegin, 0);
+      EXPECT_EQ(pInfo->hashEnd, UINT32_MAX / 2 - 1);
+      EXPECT_EQ(pInfo->inUse, 0);
+      EXPECT_EQ(pInfo->numOfEps, 1);
+      SEpAddrMsg* pAddr = &pInfo->epAddr[0];
+      pAddr->port = htons(pAddr->port);
+      EXPECT_EQ(pAddr->port, 9101);
+      EXPECT_STREQ(pAddr->fqdn, "localhost");
+    }
+
+    {
+      SVgroupInfo* pInfo = &pRsp->vgroupInfo[1];
+      pInfo->vgId = htonl(pInfo->vgId);
+      pInfo->hashBegin = htonl(pInfo->hashBegin);
+      pInfo->hashEnd = htonl(pInfo->hashEnd);
+      EXPECT_GT(pInfo->vgId, 0);
+      EXPECT_EQ(pInfo->hashBegin, UINT32_MAX / 2);
+      EXPECT_EQ(pInfo->hashEnd, UINT32_MAX);
+      EXPECT_EQ(pInfo->inUse, 0);
+      EXPECT_EQ(pInfo->numOfEps, 1);
+      SEpAddrMsg* pAddr = &pInfo->epAddr[0];
+      pAddr->port = htons(pAddr->port);
+      EXPECT_EQ(pAddr->port, 9101);
+      EXPECT_STREQ(pAddr->fqdn, "localhost");
+    }
+  }
+}
+#endif

source/dnode/mgmt/impl/test/user/CMakeLists.txt

@@ -21,8 +21,6 @@ target_include_directories(dnode_test_user
     "${CMAKE_CURRENT_SOURCE_DIR}/../sut"
 )
 
-enable_testing()
-
 add_test(
     NAME dnode_test_user
     COMMAND dnode_test_user

source/dnode/mgmt/impl/test/user/user.cpp

@@ -1,5 +1,5 @@
 /**
- * @file vnodeApiTests.cpp
+ * @file user.cpp
  * @author slguan (slguan@taosdata.com)
  * @brief DNODE module user-msg tests
  * @version 0.1