unitest for config

include/libs/config/config.h

@@ -25,12 +25,12 @@ extern "C" {
 
 typedef enum {
   CFG_TYPE_DEFAULT,
-  CFG_TYPE_TAOS_CFG,
+  CFG_TYPE_CFG_FILE,
   CFG_TYPE_DOT_ENV,
   CFG_TYPE_ENV_VAR,
   CFG_TYPE_APOLLO_URL,
   CFG_TYPE_CONSOLE_PARA
-} ECfgType;
+} ECfgSrcType;
 
 typedef enum {
   CFG_DTYPE_NONE,
@@ -63,7 +63,7 @@ typedef enum {
 } ECfgUnitType;
 
 typedef struct SConfigItem {
-  ECfgType     stype;
+  ECfgSrcType   stype;
   ECfgUnitType utype;
   ECfgDataType dtype;
   char        *name;
@@ -90,7 +90,7 @@ typedef struct SConfigItem {
 typedef struct SConfig SConfig;
 
 SConfig *cfgInit();
-int32_t  cfgLoad(SConfig *pConfig, ECfgType cfgType, const char *sourceStr);
+int32_t  cfgLoad(SConfig *pConfig, ECfgSrcType cfgType, const char *sourceStr);
 void     cfgCleanup(SConfig *pConfig);
 
 int32_t      cfgGetSize(SConfig *pConfig);
@@ -115,6 +115,10 @@ int32_t cfgAddIpStr(SConfig *pConfig, const char *name, const char *defaultVal,
 int32_t cfgAddDir(SConfig *pConfig, const char *name, const char *defaultVal, ECfgUnitType utype);
 int32_t cfgAddFile(SConfig *pConfig, const char *name, const char *defaultVal, ECfgUnitType utype);
 
+const char *cfgStypeStr(ECfgSrcType type);
+const char *cfgDtypeStr(ECfgDataType type);
+const char *cfgUtypeStr(ECfgUnitType type);
+
 #ifdef __cplusplus
 }
 #endif

source/libs/config/inc/cfgInt.h

@@ -27,7 +27,7 @@ extern "C" {
 #endif
 
 typedef struct SConfig {
-  ECfgType  stype;
+  ECfgSrcType  stype;
   SHashObj *hash;
 } SConfig;
 

source/libs/config/src/config.c

@@ -33,9 +33,9 @@ SConfig *cfgInit() {
   return pConfig;
 }
 
-int32_t cfgLoad(SConfig *pConfig, ECfgType cfgType, const char *sourceStr) {
+int32_t cfgLoad(SConfig *pConfig, ECfgSrcType cfgType, const char *sourceStr) {
   switch (cfgType) {
-    case CFG_TYPE_TAOS_CFG:
+    case CFG_TYPE_CFG_FILE:
       return cfgLoadFromTaosFile(pConfig, sourceStr);
     case CFG_TYPE_DOT_ENV:
       return cfgLoadFromDotEnvFile(pConfig, sourceStr);
@@ -49,10 +49,12 @@ int32_t cfgLoad(SConfig *pConfig, ECfgType cfgType, const char *sourceStr) {
 }
 
 void cfgCleanup(SConfig *pConfig) {
-  if (pConfig == NULL) return;
+  if (pConfig != NULL) {
-  if (pConfig->hash != NULL) {
+    if (pConfig->hash != NULL) {
-    taosHashCleanup(pConfig->hash);
+      taosHashCleanup(pConfig->hash);
-    pConfig->hash == NULL;
+      pConfig->hash == NULL;
+    }
+    free(pConfig);
   }
 }
 
@@ -68,7 +70,7 @@ static int32_t cfgAddItem(SConfig *pConfig, SConfigItem *pItem, const char *name
   pItem->stype = CFG_TYPE_DEFAULT;
   pItem->utype = utype;
   pItem->name = strdup(name);
-  if (pItem->name != NULL) {
+  if (pItem->name == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
   }
@@ -152,7 +154,7 @@ int32_t cfgAddDouble(SConfig *pConfig, const char *name, double defaultVal, ECfg
 int32_t cfgAddString(SConfig *pConfig, const char *name, const char *defaultVal, ECfgUnitType utype) {
   SConfigItem item = {.dtype = CFG_DTYPE_STRING};
   item.strVal = strdup(defaultVal);
-  if (item.strVal != NULL) {
+  if (item.strVal == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
   }
@@ -162,7 +164,7 @@ int32_t cfgAddString(SConfig *pConfig, const char *name, const char *defaultVal,
 int32_t cfgAddFqdn(SConfig *pConfig, const char *name, const char *defaultVal, ECfgUnitType utype) {
   SConfigItem item = {.dtype = CFG_DTYPE_FQDN};
   item.fqdnVal = strdup(defaultVal);
-  if (item.fqdnVal != NULL) {
+  if (item.fqdnVal == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
   }
@@ -172,7 +174,7 @@ int32_t cfgAddFqdn(SConfig *pConfig, const char *name, const char *defaultVal, E
 int32_t cfgAddIpStr(SConfig *pConfig, const char *name, const char *defaultVal, ECfgUnitType utype) {
   SConfigItem item = {.dtype = CFG_DTYPE_IPSTR};
   item.ipstrVal = strdup(defaultVal);
-  if (item.ipstrVal != NULL) {
+  if (item.ipstrVal == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
   }
@@ -182,7 +184,7 @@ int32_t cfgAddIpStr(SConfig *pConfig, const char *name, const char *defaultVal,
 int32_t cfgAddDir(SConfig *pConfig, const char *name, const char *defaultVal, ECfgUnitType utype) {
   SConfigItem item = {.dtype = CFG_DTYPE_DIR};
   item.dirVal = strdup(defaultVal);
-  if (item.dirVal != NULL) {
+  if (item.dirVal == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
   }
@@ -192,9 +194,88 @@ int32_t cfgAddDir(SConfig *pConfig, const char *name, const char *defaultVal, EC
 int32_t cfgAddFile(SConfig *pConfig, const char *name, const char *defaultVal, ECfgUnitType utype) {
   SConfigItem item = {.dtype = CFG_DTYPE_FILE};
   item.fileVal = strdup(defaultVal);
-  if (item.fileVal != NULL) {
+  if (item.fileVal == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
   }
   return cfgAddItem(pConfig, &item, name, utype);
 }
+
+const char *cfgStypeStr(ECfgSrcType type) {
+  switch (type) {
+    case CFG_TYPE_DEFAULT:
+      return "default";
+    case CFG_TYPE_CFG_FILE:
+      return "cfg";
+    case CFG_TYPE_DOT_ENV:
+      return ".env";
+    case CFG_TYPE_ENV_VAR:
+      return "env";
+    case CFG_TYPE_APOLLO_URL:
+      return "apollo";
+    default:
+      return "invalid";
+  }
+}
+
+const char *cfgDtypeStr(ECfgDataType type) {
+  switch (type) {
+    case CFG_DTYPE_NONE:
+      return "none";
+    case CFG_DTYPE_BOOL:
+      return "bool";
+    case CFG_DTYPE_INT8:
+      return "int8";
+    case CFG_DTYPE_UINT8:
+      return "uint8";
+    case CFG_DTYPE_INT16:
+      return "int16";
+    case CFG_DTYPE_UINT16:
+      return "uint16";
+    case CFG_DTYPE_INT32:
+      return "int32";
+    case CFG_DTYPE_UINT32:
+      return "uint32";
+    case CFG_DTYPE_INT64:
+      return "int64";
+    case CFG_DTYPE_UINT64:
+      return "uint64";
+    case CFG_DTYPE_FLOAT:
+      return "float";
+    case CFG_DTYPE_DOUBLE:
+      return "double";
+    case CFG_DTYPE_STRING:
+      return "string";
+    case CFG_DTYPE_FQDN:
+      return "fqdn";
+    case CFG_DTYPE_IPSTR:
+      return "ipstr";
+    case CFG_DTYPE_DIR:
+      return "dir";
+    case CFG_DTYPE_FILE:
+      return "file";
+    default:
+      return "invalid";
+  }
+}
+
+const char *cfgUtypeStr(ECfgUnitType type) {
+  switch (type) {
+    case CFG_UTYPE_NONE:
+      return "";
+    case CFG_UTYPE_PERCENT:
+      return "(%)";
+    case CFG_UTYPE_GB:
+      return "(GB)";
+    case CFG_UTYPE_MB:
+      return "(Mb)";
+    case CFG_UTYPE_BYTE:
+      return "(byte)";
+    case CFG_UTYPE_SECOND:
+      return "(s)";
+    case CFG_UTYPE_MS:
+      return "(ms)";
+    default:
+      return "invalid";
+  }
+}

source/libs/config/test/cfgTest.cpp

@@ -28,84 +28,124 @@ class CfgTest : public ::testing::Test {
 
 const char *CfgTest::pConfig;
 
-TEST_F(CfgTest, 01_Basic) {
+TEST_F(CfgTest, 02_Str) {
+  EXPECT_STREQ(cfgStypeStr(CFG_TYPE_DEFAULT), "default");
+  EXPECT_STREQ(cfgStypeStr(CFG_TYPE_CFG_FILE), "cfg");
+  EXPECT_STREQ(cfgStypeStr(CFG_TYPE_DOT_ENV), ".env");
+  EXPECT_STREQ(cfgStypeStr(CFG_TYPE_ENV_VAR), "env");
+  EXPECT_STREQ(cfgStypeStr(CFG_TYPE_APOLLO_URL), "apollo");
+  EXPECT_STREQ(cfgStypeStr(ECfgSrcType(1024)), "invalid");
+
+  EXPECT_STREQ(cfgDtypeStr(CFG_DTYPE_NONE), "none");
+  EXPECT_STREQ(cfgDtypeStr(CFG_DTYPE_BOOL), "bool");
+  EXPECT_STREQ(cfgDtypeStr(CFG_DTYPE_INT8), "int8");
+  EXPECT_STREQ(cfgDtypeStr(CFG_DTYPE_UINT8), "uint8");
+  EXPECT_STREQ(cfgDtypeStr(CFG_DTYPE_INT16), "int16");
+  EXPECT_STREQ(cfgDtypeStr(CFG_DTYPE_UINT16), "uint16");
+  EXPECT_STREQ(cfgDtypeStr(CFG_DTYPE_INT32), "int32");
+  EXPECT_STREQ(cfgDtypeStr(CFG_DTYPE_UINT32), "uint32");
+  EXPECT_STREQ(cfgDtypeStr(CFG_DTYPE_INT64), "int64");
+  EXPECT_STREQ(cfgDtypeStr(CFG_DTYPE_UINT64), "uint64");
+  EXPECT_STREQ(cfgDtypeStr(CFG_DTYPE_FLOAT), "float");
+  EXPECT_STREQ(cfgDtypeStr(CFG_DTYPE_DOUBLE), "double");
+  EXPECT_STREQ(cfgDtypeStr(CFG_DTYPE_STRING), "string");
+  EXPECT_STREQ(cfgDtypeStr(CFG_DTYPE_FQDN), "fqdn");
+  EXPECT_STREQ(cfgDtypeStr(CFG_DTYPE_IPSTR), "ipstr");
+  EXPECT_STREQ(cfgDtypeStr(CFG_DTYPE_DIR), "dir");
+  EXPECT_STREQ(cfgDtypeStr(CFG_DTYPE_FILE), "file");
+  EXPECT_STREQ(cfgDtypeStr(ECfgDataType(1024)), "invalid");
+
+  EXPECT_STREQ(cfgUtypeStr(CFG_UTYPE_NONE), "");
+  EXPECT_STREQ(cfgUtypeStr(CFG_UTYPE_PERCENT), "(%)");
+  EXPECT_STREQ(cfgUtypeStr(CFG_UTYPE_GB), "(GB)");
+  EXPECT_STREQ(cfgUtypeStr(CFG_UTYPE_MB), "(Mb)");
+  EXPECT_STREQ(cfgUtypeStr(CFG_UTYPE_BYTE), "(byte)");
+  EXPECT_STREQ(cfgUtypeStr(CFG_UTYPE_SECOND), "(s)");
+  EXPECT_STREQ(cfgUtypeStr(CFG_UTYPE_MS), "(ms)");
+  EXPECT_STREQ(cfgUtypeStr(ECfgUnitType(1024)), "invalid");
+}
+
+TEST_F(CfgTest, 02_Basic) {
   SConfig *pConfig = cfgInit();
-  cfgAddBool(pConfig, "test_bool", 0, CFG_UTYPE_NONE);
+  ASSERT_NE(pConfig, nullptr);
-  cfgAddInt8(pConfig, "test_int8", 1, CFG_UTYPE_GB);
+
-  cfgAddUInt8(pConfig, "test_uint8", 2, CFG_UTYPE_MB);
+  EXPECT_EQ(cfgAddBool(pConfig, "test_bool", 0, CFG_UTYPE_NONE), 0);
-  cfgAddInt16(pConfig, "test_int16", 3, CFG_UTYPE_BYTE);
+  EXPECT_EQ(cfgAddInt8(pConfig, "test_int8", 1, CFG_UTYPE_GB), 0);
-  cfgAddUInt16(pConfig, "test_uint16", 4, CFG_UTYPE_SECOND);
+  EXPECT_EQ(cfgAddUInt8(pConfig, "test_uint8", 2, CFG_UTYPE_MB), 0);
-  cfgAddInt32(pConfig, "test_int32", 5, CFG_UTYPE_MS);
+  EXPECT_EQ(cfgAddInt16(pConfig, "test_int16", 3, CFG_UTYPE_BYTE), 0);
-  cfgAddUInt32(pConfig, "test_uint32", 6, CFG_UTYPE_PERCENT);
+  EXPECT_EQ(cfgAddUInt16(pConfig, "test_uint16", 4, CFG_UTYPE_SECOND), 0);
-  cfgAddInt64(pConfig, "test_int64", 7, CFG_UTYPE_NONE);
+  EXPECT_EQ(cfgAddInt32(pConfig, "test_int32", 5, CFG_UTYPE_MS), 0);
-  cfgAddUInt64(pConfig, "test_uint64", 8, CFG_UTYPE_NONE);
+  EXPECT_EQ(cfgAddUInt32(pConfig, "test_uint32", 6, CFG_UTYPE_PERCENT), 0);
-  cfgAddFloat(pConfig, "test_float", 9, CFG_UTYPE_NONE);
+  EXPECT_EQ(cfgAddInt64(pConfig, "test_int64", 7, CFG_UTYPE_NONE), 0);
-  cfgAddDouble(pConfig, "test_double", 10, CFG_UTYPE_NONE);
+  EXPECT_EQ(cfgAddUInt64(pConfig, "test_uint64", 8, CFG_UTYPE_NONE), 0);
-  cfgAddString(pConfig, "test_string", "11", CFG_UTYPE_NONE);
+  EXPECT_EQ(cfgAddFloat(pConfig, "test_float", 9, CFG_UTYPE_NONE), 0);
-  cfgAddFqdn(pConfig, "test_fqdn", "localhost", CFG_UTYPE_NONE);
+  EXPECT_EQ(cfgAddDouble(pConfig, "test_double", 10, CFG_UTYPE_NONE), 0);
-  cfgAddIpStr(pConfig, "test_ipstr", "192.168.0.1", CFG_UTYPE_NONE);
+  EXPECT_EQ(cfgAddString(pConfig, "test_string", "11", CFG_UTYPE_NONE), 0);
-  cfgAddDir(pConfig, "test_dir", "/tmp", CFG_UTYPE_NONE);
+  EXPECT_EQ(cfgAddFqdn(pConfig, "test_fqdn", "localhost", CFG_UTYPE_NONE), 0);
-  cfgAddFile(pConfig, "test_file", "/tmp/file1", CFG_UTYPE_NONE);
+  EXPECT_EQ(cfgAddIpStr(pConfig, "test_ipstr", "192.168.0.1", CFG_UTYPE_NONE), 0);
+  EXPECT_EQ(cfgAddDir(pConfig, "test_dir", "/tmp", CFG_UTYPE_NONE), 0);
+  EXPECT_EQ(cfgAddFile(pConfig, "test_file", "/tmp/file1", CFG_UTYPE_NONE), 0);
 
   EXPECT_EQ(cfgGetSize(pConfig), 16);
 
   int32_t      size = 0;
   SConfigItem *pItem = cfgIterate(pConfig, NULL);
   while (pItem != NULL) {
-    pItem = cfgIterate(pConfig, pItem);
     switch (pItem->dtype) {
       case CFG_DTYPE_BOOL:
-        printf("cfg:%s, value:%d\n", pItem->name, pItem->boolVal);
+        printf("index:%d, cfg:%s value:%d\n", size, pItem->name, pItem->boolVal);
         break;
-      CFG_DTYPE_INT8:
+      case CFG_DTYPE_INT8:
-        printf("cfg:%s, value:%d\n", pItem->name, pItem->uint8Val);
+        printf("index:%d, cfg:%s value:%d\n", size, pItem->name, pItem->uint8Val);
         break;
-      CFG_DTYPE_UINT8:
+      case CFG_DTYPE_UINT8:
-        printf("cfg:%s, value:%d\n", pItem->name, pItem->int8Val);
+        printf("index:%d, cfg:%s value:%d\n", size, pItem->name, pItem->int8Val);
         break;
-      CFG_DTYPE_INT16:
+      case CFG_DTYPE_INT16:
-        printf("cfg:%s, value:%d\n", pItem->name, pItem->uint16Val);
+        printf("index:%d, cfg:%s value:%d\n", size, pItem->name, pItem->uint16Val);
         break;
-      CFG_DTYPE_UINT16:
+      case CFG_DTYPE_UINT16:
-        printf("cfg:%s, value:%d\n", pItem->name, pItem->int16Val);
+        printf("index:%d, cfg:%s value:%d\n", size, pItem->name, pItem->int16Val);
         break;
-      CFG_DTYPE_INT32:
+      case CFG_DTYPE_INT32:
-        printf("cfg:%s, value:%d\n", pItem->name, pItem->uint32Val);
+        printf("index:%d, cfg:%s value:%d\n", size, pItem->name, pItem->uint32Val);
         break;
-      CFG_DTYPE_UINT32:
+      case CFG_DTYPE_UINT32:
-        printf("cfg:%s, value:%d\n", pItem->name, pItem->int32Val);
+        printf("index:%d, cfg:%s value:%d\n", size, pItem->name, pItem->int32Val);
         break;
-      CFG_DTYPE_INT64:
+      case CFG_DTYPE_INT64:
-        printf("cfg:%s, value:%" PRIu64, pItem->name, pItem->uint64Val);
+        printf("index:%d, cfg:%s value:%" PRIu64 "\n", size, pItem->name, pItem->uint64Val);
         break;
-      CFG_DTYPE_UINT64:
+      case CFG_DTYPE_UINT64:
-        printf("cfg:%s, value:%" PRId64, pItem->name, pItem->int64Val);
+        printf("index:%d, cfg:%s value:%" PRId64 "\n", size, pItem->name, pItem->int64Val);
         break;
-      CFG_DTYPE_FLOAT:
+      case CFG_DTYPE_FLOAT:
-        printf("cfg:%s, value:%f\n", pItem->name, pItem->floatVal);
+        printf("index:%d, cfg:%s value:%f\n", size, pItem->name, pItem->floatVal);
         break;
-      CFG_DTYPE_DOUBLE:
+      case CFG_DTYPE_DOUBLE:
-        printf("cfg:%s, value:%f\n", pItem->name, pItem->doubleVal);
+        printf("index:%d, cfg:%s value:%f\n", size, pItem->name, pItem->doubleVal);
         break;
-      CFG_DTYPE_STRING:
+      case CFG_DTYPE_STRING:
-        printf("cfg:%s, value:%s\n", pItem->name, pItem->strVal);
+        printf("index:%d, cfg:%s value:%s\n", size, pItem->name, pItem->strVal);
         break;
-      CFG_DTYPE_FQDN:
+      case CFG_DTYPE_FQDN:
-        printf("cfg:%s, value:%s\n", pItem->name, pItem->fqdnVal);
+        printf("index:%d, cfg:%s value:%s\n", size, pItem->name, pItem->fqdnVal);
         break;
-      CFG_DTYPE_IPSTR:
+      case CFG_DTYPE_IPSTR:
-        printf("cfg:%s, value:%s\n", pItem->name, pItem->ipstrVal);
+        printf("index:%d, cfg:%s value:%s\n", size, pItem->name, pItem->ipstrVal);
         break;
-      CFG_DTYPE_DIR:
+      case CFG_DTYPE_DIR:
-        printf("cfg:%s, value:%s\n", pItem->name, pItem->dirVal);
+        printf("index:%d, cfg:%s value:%s\n", size, pItem->name, pItem->dirVal);
         break;
-      CFG_DTYPE_FILE:
+      case CFG_DTYPE_FILE:
-        printf("cfg:%s, value:%s\n", pItem->name, pItem->fileVal);
+        printf("index:%d, cfg:%s value:%s\n", size, pItem->name, pItem->fileVal);
         break;
       default:
+        printf("index:%d, cfg:%s invalid cfg dtype:%d\n", size, pItem->name, pItem->dtype);
         break;
     }
     size++;
+    pItem = cfgIterate(pConfig, pItem);
   }
   cfgCancelIterate(pConfig, pItem);
 
@@ -162,8 +202,8 @@ TEST_F(CfgTest, 01_Basic) {
 
   pItem = cfgGetItem(pConfig, "test_int64");
   EXPECT_EQ(pItem->stype, CFG_TYPE_DEFAULT);
-  EXPECT_EQ(pItem->utype, CFG_UTYPE_SECOND);
+  EXPECT_EQ(pItem->utype, CFG_UTYPE_NONE);
-  EXPECT_EQ(pItem->dtype, CFG_UTYPE_NONE);
+  EXPECT_EQ(pItem->dtype, CFG_DTYPE_INT64);
   EXPECT_STREQ(pItem->name, "test_int64");
   EXPECT_EQ(pItem->int64Val, 7);