Merge pull request #29069 from taosdata/cover/simon/ut

enh: add test cases for osAtomic and osDir
This commit is contained in:
Shengliang Guan 2024-12-10 09:08:43 +08:00 committed by GitHub
commit d1f93abff4
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
10 changed files with 1052 additions and 131 deletions

1
.gitignore vendored
View File

@ -162,3 +162,4 @@ geos_c.h
source/libs/parser/src/sql.c
include/common/ttokenauto.h
!packaging/smokeTest/pytest_require.txt
tdengine-test-dir

View File

@ -48,13 +48,13 @@ void atomic_store_8(int8_t volatile *ptr, int8_t val);
void atomic_store_16(int16_t volatile *ptr, int16_t val);
void atomic_store_32(int32_t volatile *ptr, int32_t val);
void atomic_store_64(int64_t volatile *ptr, int64_t val);
double atomic_store_double(double volatile *ptr, double val);
void atomic_store_double(double volatile *ptr, double val);
void atomic_store_ptr(void *ptr, void *val);
int8_t atomic_exchange_8(int8_t volatile *ptr, int8_t val);
int16_t atomic_exchange_16(int16_t volatile *ptr, int16_t val);
int32_t atomic_exchange_32(int32_t volatile *ptr, int32_t val);
int64_t atomic_exchange_64(int64_t volatile *ptr, int64_t val);
double atomic_exchange_double(double volatile *ptr, int64_t val);
double atomic_exchange_double(double volatile *ptr, double val);
void *atomic_exchange_ptr(void *ptr, void *val);
int8_t atomic_val_compare_exchange_8(int8_t volatile *ptr, int8_t oldval, int8_t newval);
int16_t atomic_val_compare_exchange_16(int16_t volatile *ptr, int16_t oldval, int16_t newval);
@ -71,7 +71,7 @@ int16_t atomic_fetch_add_16(int16_t volatile *ptr, int16_t val);
int32_t atomic_fetch_add_32(int32_t volatile *ptr, int32_t val);
int64_t atomic_fetch_add_64(int64_t volatile *ptr, int64_t val);
double atomic_fetch_add_double(double volatile *ptr, double val);
void *atomic_fetch_add_ptr(void *ptr, void *val);
void *atomic_fetch_add_ptr(void *ptr, int64_t val);
int8_t atomic_sub_fetch_8(int8_t volatile *ptr, int8_t val);
int16_t atomic_sub_fetch_16(int16_t volatile *ptr, int16_t val);
int32_t atomic_sub_fetch_32(int32_t volatile *ptr, int32_t val);
@ -82,37 +82,37 @@ int16_t atomic_fetch_sub_16(int16_t volatile *ptr, int16_t val);
int32_t atomic_fetch_sub_32(int32_t volatile *ptr, int32_t val);
int64_t atomic_fetch_sub_64(int64_t volatile *ptr, int64_t val);
double atomic_fetch_sub_double(double volatile *ptr, double val);
void *atomic_fetch_sub_ptr(void *ptr, void *val);
void *atomic_fetch_sub_ptr(void *ptr, int64_t val);
int8_t atomic_and_fetch_8(int8_t volatile *ptr, int8_t val);
int16_t atomic_and_fetch_16(int16_t volatile *ptr, int16_t val);
int32_t atomic_and_fetch_32(int32_t volatile *ptr, int32_t val);
int64_t atomic_and_fetch_64(int64_t volatile *ptr, int64_t val);
void *atomic_and_fetch_ptr(void *ptr, void *val);
void *atomic_and_fetch_ptr(void *ptr, int64_t val);
int8_t atomic_fetch_and_8(int8_t volatile *ptr, int8_t val);
int16_t atomic_fetch_and_16(int16_t volatile *ptr, int16_t val);
int32_t atomic_fetch_and_32(int32_t volatile *ptr, int32_t val);
int64_t atomic_fetch_and_64(int64_t volatile *ptr, int64_t val);
void *atomic_fetch_and_ptr(void *ptr, void *val);
void *atomic_fetch_and_ptr(void *ptr, int64_t val);
int8_t atomic_or_fetch_8(int8_t volatile *ptr, int8_t val);
int16_t atomic_or_fetch_16(int16_t volatile *ptr, int16_t val);
int32_t atomic_or_fetch_32(int32_t volatile *ptr, int32_t val);
int64_t atomic_or_fetch_64(int64_t volatile *ptr, int64_t val);
void *atomic_or_fetch_ptr(void *ptr, void *val);
void *atomic_or_fetch_ptr(void *ptr, int64_t val);
int8_t atomic_fetch_or_8(int8_t volatile *ptr, int8_t val);
int16_t atomic_fetch_or_16(int16_t volatile *ptr, int16_t val);
int32_t atomic_fetch_or_32(int32_t volatile *ptr, int32_t val);
int64_t atomic_fetch_or_64(int64_t volatile *ptr, int64_t val);
void *atomic_fetch_or_ptr(void *ptr, void *val);
void *atomic_fetch_or_ptr(void *ptr, int64_t val);
int8_t atomic_xor_fetch_8(int8_t volatile *ptr, int8_t val);
int16_t atomic_xor_fetch_16(int16_t volatile *ptr, int16_t val);
int32_t atomic_xor_fetch_32(int32_t volatile *ptr, int32_t val);
int64_t atomic_xor_fetch_64(int64_t volatile *ptr, int64_t val);
void *atomic_xor_fetch_ptr(void *ptr, void *val);
void *atomic_xor_fetch_ptr(void *ptr, int64_t val);
int8_t atomic_fetch_xor_8(int8_t volatile *ptr, int8_t val);
int16_t atomic_fetch_xor_16(int16_t volatile *ptr, int16_t val);
int32_t atomic_fetch_xor_32(int32_t volatile *ptr, int32_t val);
int64_t atomic_fetch_xor_64(int64_t volatile *ptr, int64_t val);
void *atomic_fetch_xor_ptr(void *ptr, void *val);
void *atomic_fetch_xor_ptr(void *ptr, int64_t val);
#ifdef _MSC_VER
#define tmemory_barrier(order) MemoryBarrier()

View File

@ -19,7 +19,6 @@
typedef union {
volatile int64_t i;
volatile double d;
//double d;
} double_number;
#ifdef WINDOWS
@ -345,7 +344,7 @@ void atomic_store_64(int64_t volatile* ptr, int64_t val) {
#endif
}
double atomic_store_double(double volatile *ptr, double val){
void atomic_store_double(double volatile* ptr, double val) {
for (;;) {
double_number old_num = {0};
old_num.d = *ptr; // current old value
@ -354,9 +353,9 @@ double atomic_store_double(double volatile *ptr, double val){
new_num.d = val;
double_number ret_num = {0};
ret_num.i = atomic_val_compare_exchange_64((volatile int64_t *)ptr, old_num.i, new_num.i);
ret_num.i = atomic_val_compare_exchange_64((volatile int64_t*)ptr, old_num.i, new_num.i);
if (ret_num.i == old_num.i) return ret_num.d;
if (ret_num.i == old_num.i) return;
}
}
@ -414,16 +413,16 @@ int64_t atomic_exchange_64(int64_t volatile* ptr, int64_t val) {
#endif
}
double atomic_exchange_double(double volatile *ptr, int64_t val){
double atomic_exchange_double(double volatile* ptr, double val) {
for (;;) {
double_number old_num = {0};
old_num.d = *ptr; // current old value
double_number new_num = {0};
int64_t iNew = val;
new_num.d = val;
double_number ret_num = {0};
ret_num.i = atomic_val_compare_exchange_64((volatile int64_t *)ptr, old_num.i, new_num.i);
ret_num.i = atomic_val_compare_exchange_64((volatile int64_t*)ptr, old_num.i, new_num.i);
if (ret_num.i == old_num.i) {
return ret_num.d;
@ -589,7 +588,7 @@ int64_t atomic_fetch_add_64(int64_t volatile* ptr, int64_t val) {
#endif
}
double atomic_fetch_add_double(double volatile *ptr, double val){
double atomic_fetch_add_double(double volatile* ptr, double val) {
for (;;) {
double_number old_num = {0};
old_num.d = *ptr; // current old value
@ -598,13 +597,13 @@ double atomic_fetch_add_double(double volatile *ptr, double val){
new_num.d = old_num.d + val;
double_number ret_num = {0};
ret_num.i = atomic_val_compare_exchange_64((volatile int64_t *)ptr, old_num.i, new_num.i);
ret_num.i = atomic_val_compare_exchange_64((volatile int64_t*)ptr, old_num.i, new_num.i);
if (ret_num.i == old_num.i) return ret_num.d;
}
}
void* atomic_fetch_add_ptr(void* ptr, void* val) {
void* atomic_fetch_add_ptr(void* ptr, int64_t val) {
#ifdef WINDOWS
return _InterlockedExchangePointer((void* volatile*)(ptr), (void*)(val));
#elif defined(_TD_NINGSI_60)
@ -710,7 +709,7 @@ int64_t atomic_fetch_sub_64(int64_t volatile* ptr, int64_t val) {
#endif
}
double atomic_fetch_sub_double(double volatile *ptr, double val){
double atomic_fetch_sub_double(double volatile* ptr, double val) {
for (;;) {
double_number old_num = {0};
old_num.d = *ptr; // current old value
@ -719,13 +718,13 @@ double atomic_fetch_sub_double(double volatile *ptr, double val){
new_num.d = old_num.d - val;
double_number ret_num = {0};
ret_num.i = atomic_val_compare_exchange_64((volatile int64_t *)ptr, old_num.i, new_num.i);
ret_num.i = atomic_val_compare_exchange_64((volatile int64_t*)ptr, old_num.i, new_num.i);
if (ret_num.i == old_num.i) return ret_num.d;
}
}
void* atomic_fetch_sub_ptr(void* ptr, void* val) {
void* atomic_fetch_sub_ptr(void* ptr, int64_t val) {
#ifdef WINDOWS
return interlocked_fetch_sub_ptr(ptr, val);
#elif defined(_TD_NINGSI_60)
@ -777,7 +776,7 @@ int64_t atomic_and_fetch_64(int64_t volatile* ptr, int64_t val) {
#endif
}
void* atomic_and_fetch_ptr(void* ptr, void* val) {
void* atomic_and_fetch_ptr(void* ptr, int64_t val) {
#ifdef WINDOWS
return interlocked_and_fetch_ptr((void* volatile*)(ptr), (void*)(val));
#elif defined(_TD_NINGSI_60)
@ -829,7 +828,7 @@ int64_t atomic_fetch_and_64(int64_t volatile* ptr, int64_t val) {
#endif
}
void* atomic_fetch_and_ptr(void* ptr, void* val) {
void* atomic_fetch_and_ptr(void* ptr, int64_t val) {
#ifdef WINDOWS
return interlocked_fetch_and_ptr((void* volatile*)(ptr), (void*)(val));
#elif defined(_TD_NINGSI_60)
@ -881,7 +880,7 @@ int64_t atomic_or_fetch_64(int64_t volatile* ptr, int64_t val) {
#endif
}
void* atomic_or_fetch_ptr(void* ptr, void* val) {
void* atomic_or_fetch_ptr(void* ptr, int64_t val) {
#ifdef WINDOWS
return interlocked_or_fetch_ptr((void* volatile*)(ptr), (void*)(val));
#elif defined(_TD_NINGSI_60)
@ -933,7 +932,7 @@ int64_t atomic_fetch_or_64(int64_t volatile* ptr, int64_t val) {
#endif
}
void* atomic_fetch_or_ptr(void* ptr, void* val) {
void* atomic_fetch_or_ptr(void* ptr, int64_t val) {
#ifdef WINDOWS
return interlocked_fetch_or_ptr((void* volatile*)(ptr), (void*)(val));
#elif defined(_TD_NINGSI_60)
@ -985,7 +984,7 @@ int64_t atomic_xor_fetch_64(int64_t volatile* ptr, int64_t val) {
#endif
}
void* atomic_xor_fetch_ptr(void* ptr, void* val) {
void* atomic_xor_fetch_ptr(void* ptr, int64_t val) {
#ifdef WINDOWS
return interlocked_xor_fetch_ptr((void* volatile*)(ptr), (void*)(val));
#elif defined(_TD_NINGSI_60)
@ -1037,7 +1036,7 @@ int64_t atomic_fetch_xor_64(int64_t volatile* ptr, int64_t val) {
#endif
}
void* atomic_fetch_xor_ptr(void* ptr, void* val) {
void* atomic_fetch_xor_ptr(void* ptr, int64_t val) {
#ifdef WINDOWS
return interlocked_fetch_xor_ptr((void* volatile*)(ptr), (void*)(val));
#elif defined(_TD_NINGSI_60)

View File

@ -39,7 +39,7 @@ enum {
WRDE_SYNTAX /* Shell syntax error. */
};
int wordexp(char *words, wordexp_t *pwordexp, int flags) {
int32_t wordexp(char *words, wordexp_t *pwordexp, int32_t flags) {
pwordexp->we_offs = 0;
pwordexp->we_wordc = 1;
pwordexp->we_wordv[0] = pwordexp->wordPos;
@ -197,14 +197,10 @@ int32_t taosMulMkDir(const char *dirname) {
}
}
if (code < 0 && errno == EEXIST) {
return 0;
}
return code;
return 0;
}
int32_t taosMulModeMkDir(const char *dirname, int mode, bool checkAccess) {
int32_t taosMulModeMkDir(const char *dirname, int32_t mode, bool checkAccess) {
if (dirname == NULL || strlen(dirname) >= TDDIRMAXLEN) {
terrno = TSDB_CODE_INVALID_PARA;
return terrno;
@ -326,7 +322,7 @@ void taosRemoveOldFiles(const char *dirname, int32_t keepDays) {
int32_t days = (int32_t)(TABS(sec - fileSec) / 86400 + 1);
if (days > keepDays) {
TAOS_UNUSED(taosRemoveFile(filename));
uInfo("file:%s is removed, days:%d keepDays:%d, sed:%" PRId64, filename, days, keepDays, fileSec);
// printf("file:%s is removed, days:%d keepDays:%d, sed:%" PRId64, filename, days, keepDays, fileSec);
} else {
// printf("file:%s won't be removed, days:%d keepDays:%d", filename, days, keepDays);
}
@ -340,7 +336,9 @@ void taosRemoveOldFiles(const char *dirname, int32_t keepDays) {
int32_t taosExpandDir(const char *dirname, char *outname, int32_t maxlen) {
OS_PARAM_CHECK(dirname);
OS_PARAM_CHECK(outname);
wordexp_t full_path;
if (dirname[0] == 0) return 0;
wordexp_t full_path = {0};
int32_t code = wordexp(dirname, &full_path, 0);
switch (code) {
case 0:
@ -357,13 +355,12 @@ int32_t taosExpandDir(const char *dirname, char *outname, int32_t maxlen) {
}
wordfree(&full_path);
return 0;
}
int32_t taosRealPath(char *dirname, char *realPath, int32_t maxlen) {
OS_PARAM_CHECK(dirname);
OS_PARAM_CHECK(realPath);
char tmp[PATH_MAX] = {0};
#ifdef WINDOWS
if (_fullpath(tmp, dirname, maxlen) != NULL) {
@ -377,12 +374,14 @@ int32_t taosRealPath(char *dirname, char *realPath, int32_t maxlen) {
tstrncpy(realPath, tmp, maxlen);
}
return 0;
} else {
terrno = TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
} else {
terrno = TAOS_SYSTEM_ERROR(errno);
return terrno;
}
terrno = TAOS_SYSTEM_ERROR(errno);
return terrno;
}
bool taosIsDir(const char *dirname) {
@ -454,7 +453,7 @@ TdDirPtr taosOpenDir(const char *dirname) {
}
#ifdef WINDOWS
char szFind[MAX_PATH]; //这是要找的
char szFind[MAX_PATH]; // 这是要找的
HANDLE hFind;
TdDirPtr pDir = taosMemoryMalloc(sizeof(TdDir));
@ -462,7 +461,7 @@ TdDirPtr taosOpenDir(const char *dirname) {
return NULL;
}
snprintf(szFind, sizeof(szFind), "%s%s", dirname, "\\*.*"); //利用通配符找这个目录下的所以文件,包括目录
snprintf(szFind, sizeof(szFind), "%s%s", dirname, "\\*.*"); // 利用通配符找这个目录下的所以文件,包括目录
pDir->hFind = FindFirstFile(szFind, &(pDir->dirEntry.findFileData));
if (INVALID_HANDLE_VALUE == pDir->hFind) {
@ -585,14 +584,14 @@ void taosGetCwd(char *buf, int32_t len) {
#endif
}
int taosGetDirSize(const char *path, int64_t *size) {
int32_t code;
int32_t taosGetDirSize(const char *path, int64_t *size) {
int32_t code = 0;
char fullPath[PATH_MAX + 100] = {0};
TdDirPtr pDir = taosOpenDir(path);
if (pDir == NULL) {
return code = terrno;
}
int32_t nBytes = 0;
char fullPath[1024] = {0};
int64_t totalSize = 0;
TdDirEntryPtr de = NULL;
@ -601,31 +600,23 @@ int taosGetDirSize(const char *path, int64_t *size) {
if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0) {
continue;
}
nBytes = snprintf(fullPath, sizeof(fullPath), "%s%s%s", path, TD_DIRSEP, name);
if (nBytes <= 0 || nBytes >= sizeof(fullPath)) {
TAOS_UNUSED(taosCloseDir(&pDir));
return TSDB_CODE_OUT_OF_RANGE;
}
(void)snprintf(fullPath, sizeof(fullPath), "%s%s%s", path, TD_DIRSEP, name);
int64_t subSize = 0;
if (taosIsDir(fullPath)) {
code = taosGetDirSize(fullPath, &subSize);
if (code != 0) {
TAOS_UNUSED(taosCloseDir(&pDir));
return code;
}
} else {
code = taosStatFile(fullPath, &subSize, NULL, NULL);
if (code != 0) {
TAOS_UNUSED(taosCloseDir(&pDir));
return code;
}
}
if (code != 0) goto _OVER;
totalSize += subSize;
fullPath[0] = 0;
}
_OVER:
*size = totalSize;
TAOS_UNUSED(taosCloseDir(&pDir));
return 0;
return code;
}

View File

@ -71,6 +71,9 @@ add_test(
COMMAND osTimeTests
)
if(TD_LINUX)
add_executable(osAtomicTests "osAtomicTests.cpp")
target_link_libraries(osAtomicTests os util gtest_main)
add_test(
@ -78,6 +81,22 @@ add_test(
COMMAND osAtomicTests
)
add_executable(osDirTests "osDirTests.cpp")
target_link_libraries(osDirTests os util gtest_main)
add_test(
NAME osDirTests
COMMAND osDirTests
)
add_executable(osEnvTests "osEnvTests.cpp")
target_link_libraries(osEnvTests os util gtest_main)
add_test(
NAME osEnvTests
COMMAND osEnvTests
)
endif()
add_executable(osSemaphoreTests "osSemaphoreTests.cpp")
target_link_libraries(osSemaphoreTests os util gtest_main)
add_test(

View File

@ -29,87 +29,434 @@
#include "os.h"
#include "tlog.h"
TEST(osAtomicTests, Exchange16) {
int16_t value = 123;
int16_t new_value = 456;
int16_t result = atomic_exchange_16(&value, new_value);
EXPECT_EQ(result, 123);
EXPECT_EQ(value, 456);
TEST(osAtomicTests, atomic_load) {
int8_t result8 = 0, value8 = 8;
int16_t result16 = 0, value16 = 16;
int32_t result32 = 0, value32 = 32;
int64_t result64 = 0, value64 = 64;
void* resultp = &result64;
void* valuep = &value64;
result8 = atomic_load_8(&value8);
result16 = atomic_load_16(&value16);
result32 = atomic_load_32(&value32);
result64 = atomic_load_64(&value64);
resultp = atomic_load_ptr(&valuep);
EXPECT_EQ(result8, 8);
EXPECT_EQ(result16, 16);
EXPECT_EQ(result32, 32);
EXPECT_EQ(result64, 64);
EXPECT_EQ(resultp, &value64);
EXPECT_EQ(value8, 8);
EXPECT_EQ(value16, 16);
EXPECT_EQ(value32, 32);
EXPECT_EQ(value64, 64);
EXPECT_EQ(valuep, &value64);
}
TEST(osAtomicTests, Exchange32) {
int32_t value = 123;
int32_t new_value = 456;
int32_t result = atomic_exchange_32(&value, new_value);
EXPECT_EQ(result, 123);
EXPECT_EQ(value, 456);
TEST(osAtomicTests, atomic_store) {
int8_t result8 = 0, value8 = 8;
int16_t result16 = 0, value16 = 16;
int32_t result32 = 0, value32 = 32;
int64_t result64 = 0, value64 = 64;
double resultd = 0, valued = 64;
void* resultp = &result64;
void* valuep = &value64;
atomic_store_8(&result8, value8);
atomic_store_16(&result16, value16);
atomic_store_32(&result32, value32);
atomic_store_64(&result64, value64);
atomic_store_double(&resultd, valued);
atomic_store_ptr(&resultp, valuep);
EXPECT_EQ(result8, 8);
EXPECT_EQ(result16, 16);
EXPECT_EQ(result32, 32);
EXPECT_EQ(result64, 64);
EXPECT_DOUBLE_EQ(resultd, 64);
EXPECT_EQ(resultp, &value64);
}
TEST(osAtomicTests, Exchange64) {
int64_t value = 123;
int64_t new_value = 456;
int64_t result = atomic_exchange_64(&value, new_value);
EXPECT_EQ(result, 123);
EXPECT_EQ(value, 456);
TEST(osAtomicTests, atomic_exchange) {
int8_t result8 = 0, value8 = 8, newval8 = 18;
int16_t result16 = 0, value16 = 16, newval16 = 116;
int32_t result32 = 0, value32 = 32, newval32 = 132;
int64_t result64 = 0, value64 = 64, newval64 = 164;
double resultd = 0, valued = 64, newvald = 164;
void* valuep = &value64;
void* newvalp = &newval64;
void* resultp = &result64;
result8 = atomic_exchange_8(&value8, newval8);
result16 = atomic_exchange_16(&value16, newval16);
result32 = atomic_exchange_32(&value32, newval32);
result64 = atomic_exchange_64(&value64, newval64);
resultd = atomic_exchange_double(&valued, newvald);
resultp = atomic_exchange_ptr(&valuep, newvalp);
EXPECT_EQ(value8, 18);
EXPECT_EQ(value16, 116);
EXPECT_EQ(value32, 132);
EXPECT_EQ(value64, 164);
EXPECT_DOUBLE_EQ(valued, 164);
EXPECT_EQ(valuep, &newval64);
EXPECT_EQ(result8, 8);
EXPECT_EQ(result16, 16);
EXPECT_EQ(result32, 32);
EXPECT_EQ(result64, 64);
EXPECT_DOUBLE_EQ(resultd, 64);
EXPECT_EQ(resultp, &value64);
}
TEST(osAtomicTests, ExchangePtr) {
int value1 = 123;
int value2 = 456;
int* ptr = &value1;
int* result = (int*)atomic_exchange_ptr(&ptr, &value2);
EXPECT_EQ(result, &value1);
EXPECT_EQ(*ptr, 456);
TEST(osAtomicTests, atomic_val_compare_exchange) {
int8_t result8 = 0, value8 = 8, oldval8 = 8, newval8 = 18;
int16_t result16 = 0, value16 = 16, oldval16 = 16, newval16 = 116;
int32_t result32 = 0, value32 = 32, oldval32 = 32, newval32 = 132;
int64_t result64 = 0, value64 = 64, oldval64 = 64, newval64 = 164;
void* resultp = NULL;
void* valuep = &value64;
void* oldvalp = &value64;
void* newvalp = &newval64;
result8 = atomic_val_compare_exchange_8(&value8, oldval8, newval8);
result16 = atomic_val_compare_exchange_16(&value16, oldval16, newval16);
result32 = atomic_val_compare_exchange_32(&value32, oldval32, newval32);
result64 = atomic_val_compare_exchange_64(&value64, oldval64, newval64);
resultp = atomic_val_compare_exchange_ptr(&valuep, oldvalp, newvalp);
EXPECT_EQ(result8, 8);
EXPECT_EQ(value8, 18);
EXPECT_EQ(result16, 16);
EXPECT_EQ(value16, 116);
EXPECT_EQ(result32, 32);
EXPECT_EQ(value32, 132);
EXPECT_EQ(result64, 64);
EXPECT_EQ(value64, 164);
EXPECT_EQ(resultp, &value64);
EXPECT_EQ(valuep, &newval64);
oldval8 = 9;
oldval16 = 99;
oldval32 = 999;
oldval64 = 9999;
oldvalp = NULL;
result8 = atomic_val_compare_exchange_8(&value8, oldval8, newval8);
result16 = atomic_val_compare_exchange_16(&value16, oldval16, newval16);
result32 = atomic_val_compare_exchange_32(&value32, oldval32, newval32);
result64 = atomic_val_compare_exchange_64(&value64, oldval64, newval64);
resultp = atomic_val_compare_exchange_ptr(&valuep, oldvalp, newvalp);
EXPECT_EQ(result8, 18);
EXPECT_EQ(value8, 18);
EXPECT_EQ(result16, 116);
EXPECT_EQ(value16, 116);
EXPECT_EQ(result32, 132);
EXPECT_EQ(value32, 132);
EXPECT_EQ(result64, 164);
EXPECT_EQ(value64, 164);
EXPECT_EQ(resultp, &newval64);
EXPECT_EQ(valuep, &newval64);
}
TEST(osAtomicTests, ValCompareExchange8) {
int8_t value = 12;
int8_t oldval = 12;
int8_t newval = 45;
int8_t result = atomic_val_compare_exchange_8(&value, oldval, newval);
EXPECT_EQ(result, 12);
EXPECT_EQ(value, 45);
TEST(osAtomicTests, atomic_add_fetch) {
int8_t result8 = 0, value8 = 8;
int16_t result16 = 0, value16 = 16;
int32_t result32 = 0, value32 = 32;
int64_t result64 = 0, value64 = 64;
oldval = 78;
result = atomic_val_compare_exchange_8(&value, oldval, newval);
EXPECT_EQ(result, 45);
EXPECT_EQ(value, 45);
int64_t valuex = 128;
int64_t* valuep = &valuex;
int64_t resultx = 0;
result8 = atomic_add_fetch_8(&value8, 10);
result16 = atomic_add_fetch_16(&value16, 10);
result32 = atomic_add_fetch_32(&value32, 10);
result64 = atomic_add_fetch_64(&value64, 10);
resultx = (int64_t)atomic_add_fetch_ptr(valuep, 10);
EXPECT_EQ(result8, 18);
EXPECT_EQ(value8, 18);
EXPECT_EQ(result16, 26);
EXPECT_EQ(value16, 26);
EXPECT_EQ(result32, 42);
EXPECT_EQ(value32, 42);
EXPECT_EQ(result64, 74);
EXPECT_EQ(value64, 74);
EXPECT_EQ(resultx, 138);
EXPECT_EQ(*valuep, 138);
EXPECT_EQ(valuex, 138);
}
TEST(osAtomicTests, ValCompareExchange16) {
int16_t value = 123;
int16_t oldval = 123;
int16_t newval = 456;
int16_t result = atomic_val_compare_exchange_16(&value, oldval, newval);
EXPECT_EQ(result, 123);
EXPECT_EQ(value, 456);
TEST(osAtomicTests, atomic_fetch_add) {
int8_t result8 = 0, value8 = 8;
int16_t result16 = 0, value16 = 16;
int32_t result32 = 0, value32 = 32;
int64_t result64 = 0, value64 = 64;
double resultd = 0, valued = 64;
oldval = 789;
result = atomic_val_compare_exchange_16(&value, oldval, newval);
EXPECT_EQ(result, 456);
EXPECT_EQ(value, 456);
int64_t valuex = 128;
int64_t* valuep = &valuex;
int64_t resultx = 0;
result8 = atomic_fetch_add_8(&value8, 10);
result16 = atomic_fetch_add_16(&value16, 10);
result32 = atomic_fetch_add_32(&value32, 10);
result64 = atomic_fetch_add_64(&value64, 10);
resultd = atomic_fetch_add_double(&valued, 10);
resultx = (int64_t)atomic_fetch_add_ptr(valuep, 10);
EXPECT_EQ(result8, 8);
EXPECT_EQ(value8, 18);
EXPECT_EQ(result16, 16);
EXPECT_EQ(value16, 26);
EXPECT_EQ(result32, 32);
EXPECT_EQ(value32, 42);
EXPECT_EQ(result64, 64);
EXPECT_EQ(value64, 74);
EXPECT_DOUBLE_EQ(resultd, 64);
EXPECT_DOUBLE_EQ(valued, 74);
EXPECT_EQ(resultx, 128);
EXPECT_EQ(*valuep, 138);
EXPECT_EQ(valuex, 138);
}
TEST(osAtomicTests, TestAtomicExchange8) {
volatile int8_t value = 42;
int8_t new_value = 100;
int8_t old_value = atomic_exchange_8(&value, new_value);
EXPECT_EQ(old_value, 42);
EXPECT_EQ(value, new_value);
TEST(osAtomicTests, atomic_sub_fetch) {
int8_t result8 = 0, value8 = 8;
int16_t result16 = 0, value16 = 16;
int32_t result32 = 0, value32 = 32;
int64_t result64 = 0, value64 = 64;
int64_t valuex = 128;
int64_t* valuep = &valuex;
int64_t resultx = 0;
result8 = atomic_sub_fetch_8(&value8, 10);
result16 = atomic_sub_fetch_16(&value16, 10);
result32 = atomic_sub_fetch_32(&value32, 10);
result64 = atomic_sub_fetch_64(&value64, 10);
resultx = (int64_t)atomic_sub_fetch_ptr(valuep, 10);
EXPECT_EQ(result8, -2);
EXPECT_EQ(value8, -2);
EXPECT_EQ(result16, 6);
EXPECT_EQ(value16, 6);
EXPECT_EQ(result32, 22);
EXPECT_EQ(value32, 22);
EXPECT_EQ(result64, 54);
EXPECT_EQ(value64, 54);
EXPECT_EQ(resultx, 118);
EXPECT_EQ(*valuep, 118);
EXPECT_EQ(valuex, 118);
}
TEST(osAtomicTests, TestAtomicAddFetch16) {
volatile int16_t value = 42;
int16_t increment = 10;
int16_t new_value = atomic_add_fetch_16(&value, increment);
EXPECT_EQ(new_value, 52);
EXPECT_EQ(value, 52);
TEST(osAtomicTests, atomic_fetch_sub) {
int8_t result8 = 0, value8 = 8;
int16_t result16 = 0, value16 = 16;
int32_t result32 = 0, value32 = 32;
int64_t result64 = 0, value64 = 64;
double resultd = 0, valued = 64;
int64_t valuex = 128;
int64_t* valuep = &valuex;
int64_t resultx = 0;
result8 = atomic_fetch_sub_8(&value8, 10);
result16 = atomic_fetch_sub_16(&value16, 10);
result32 = atomic_fetch_sub_32(&value32, 10);
result64 = atomic_fetch_sub_64(&value64, 10);
resultd = atomic_fetch_sub_double(&valued, 10);
resultx = (int64_t)atomic_fetch_sub_ptr(valuep, 10);
EXPECT_EQ(result8, 8);
EXPECT_EQ(value8, -2);
EXPECT_EQ(result16, 16);
EXPECT_EQ(value16, 6);
EXPECT_EQ(result32, 32);
EXPECT_EQ(value32, 22);
EXPECT_EQ(result64, 64);
EXPECT_EQ(value64, 54);
EXPECT_DOUBLE_EQ(resultd, 64);
EXPECT_DOUBLE_EQ(valued, 54);
EXPECT_EQ(resultx, 128);
EXPECT_EQ(*valuep, 118);
EXPECT_EQ(valuex, 118);
}
//TEST(osAtomicTests, AddFetchPtr) {
// uintptr_t val = 0;
// uintptr_t* ptr = &val;
// uintptr_t ret = atomic_add_fetch_ptr(ptr, 10);
// EXPECT_EQ(ret, 10);
// EXPECT_EQ(val, 10);
//}
TEST(osAtomicTests, atomic_and_fetch) {
int8_t result8 = 0, value8 = 3;
int16_t result16 = 0, value16 = 3;
int32_t result32 = 0, value32 = 3;
int64_t result64 = 0, value64 = 3;
int64_t valuex = 3;
int64_t* valuep = &valuex;
int64_t resultx = 0;
result8 = atomic_and_fetch_8(&value8, 5);
result16 = atomic_and_fetch_16(&value16, 5);
result32 = atomic_and_fetch_32(&value32, 5);
result64 = atomic_and_fetch_64(&value64, 5);
resultx = (int64_t)atomic_and_fetch_ptr(valuep, 5);
EXPECT_EQ(result8, 1);
EXPECT_EQ(value8, 1);
EXPECT_EQ(result16, 1);
EXPECT_EQ(value16, 1);
EXPECT_EQ(result32, 1);
EXPECT_EQ(value32, 1);
EXPECT_EQ(result64, 1);
EXPECT_EQ(value64, 1);
EXPECT_EQ(resultx, 1);
EXPECT_EQ(*valuep, 1);
EXPECT_EQ(valuex, 1);
}
TEST(osAtomicTests, atomic_fetch_and) {
int8_t result8 = 0, value8 = 3;
int16_t result16 = 0, value16 = 3;
int32_t result32 = 0, value32 = 3;
int64_t result64 = 0, value64 = 3;
int64_t valuex = 3;
int64_t* valuep = &valuex;
int64_t resultx = 0;
result8 = atomic_fetch_and_8(&value8, 5);
result16 = atomic_fetch_and_16(&value16, 5);
result32 = atomic_fetch_and_32(&value32, 5);
result64 = atomic_fetch_and_64(&value64, 5);
resultx = (int64_t)atomic_fetch_and_ptr(valuep, 5);
EXPECT_EQ(result8, 3);
EXPECT_EQ(value8, 1);
EXPECT_EQ(result16, 3);
EXPECT_EQ(value16, 1);
EXPECT_EQ(result32, 3);
EXPECT_EQ(value32, 1);
EXPECT_EQ(result64, 3);
EXPECT_EQ(value64, 1);
EXPECT_EQ(resultx, 3);
EXPECT_EQ(*valuep, 1);
EXPECT_EQ(valuex, 1);
}
TEST(osAtomicTests, atomic_or_fetch) {
int8_t result8 = 0, value8 = 3;
int16_t result16 = 0, value16 = 3;
int32_t result32 = 0, value32 = 3;
int64_t result64 = 0, value64 = 3;
int64_t valuex = 3;
int64_t* valuep = &valuex;
int64_t resultx = 0;
result8 = atomic_or_fetch_8(&value8, 5);
result16 = atomic_or_fetch_16(&value16, 5);
result32 = atomic_or_fetch_32(&value32, 5);
result64 = atomic_or_fetch_64(&value64, 5);
resultx = (int64_t)atomic_or_fetch_ptr(valuep, 5);
EXPECT_EQ(result8, 7);
EXPECT_EQ(value8, 7);
EXPECT_EQ(result16, 7);
EXPECT_EQ(value16, 7);
EXPECT_EQ(result32, 7);
EXPECT_EQ(value32, 7);
EXPECT_EQ(result64, 7);
EXPECT_EQ(value64, 7);
EXPECT_EQ(resultx, 7);
EXPECT_EQ(*valuep, 7);
EXPECT_EQ(valuex, 7);
}
TEST(osAtomicTests, atomic_fetch_or) {
int8_t result8 = 0, value8 = 3;
int16_t result16 = 0, value16 = 3;
int32_t result32 = 0, value32 = 3;
int64_t result64 = 0, value64 = 3;
int64_t valuex = 3;
int64_t* valuep = &valuex;
int64_t resultx = 0;
result8 = atomic_fetch_or_8(&value8, 5);
result16 = atomic_fetch_or_16(&value16, 5);
result32 = atomic_fetch_or_32(&value32, 5);
result64 = atomic_fetch_or_64(&value64, 5);
resultx = (int64_t)atomic_fetch_or_ptr(valuep, 5);
EXPECT_EQ(result8, 3);
EXPECT_EQ(value8, 7);
EXPECT_EQ(result16, 3);
EXPECT_EQ(value16, 7);
EXPECT_EQ(result32, 3);
EXPECT_EQ(value32, 7);
EXPECT_EQ(result64, 3);
EXPECT_EQ(value64, 7);
EXPECT_EQ(resultx, 3);
EXPECT_EQ(*valuep, 7);
EXPECT_EQ(valuex, 7);
}
TEST(osAtomicTests, atomic_xor_fetch) {
int8_t result8 = 0, value8 = 3;
int16_t result16 = 0, value16 = 3;
int32_t result32 = 0, value32 = 3;
int64_t result64 = 0, value64 = 3;
int64_t valuex = 3;
int64_t* valuep = &valuex;
int64_t resultx = 0;
result8 = atomic_xor_fetch_8(&value8, 5);
result16 = atomic_xor_fetch_16(&value16, 5);
result32 = atomic_xor_fetch_32(&value32, 5);
result64 = atomic_xor_fetch_64(&value64, 5);
resultx = (int64_t)atomic_xor_fetch_ptr(valuep, 5);
EXPECT_EQ(result8, 6);
EXPECT_EQ(value8, 6);
EXPECT_EQ(result16, 6);
EXPECT_EQ(value16, 6);
EXPECT_EQ(result32, 6);
EXPECT_EQ(value32, 6);
EXPECT_EQ(result64, 6);
EXPECT_EQ(value64, 6);
EXPECT_EQ(resultx, 6);
EXPECT_EQ(*valuep, 6);
EXPECT_EQ(valuex, 6);
}
TEST(osAtomicTests, atomic_fetch_xor) {
int8_t result8 = 0, value8 = 3;
int16_t result16 = 0, value16 = 3;
int32_t result32 = 0, value32 = 3;
int64_t result64 = 0, value64 = 3;
int64_t valuex = 3;
int64_t* valuep = &valuex;
int64_t resultx = 0;
result8 = atomic_fetch_xor_8(&value8, 5);
result16 = atomic_fetch_xor_16(&value16, 5);
result32 = atomic_fetch_xor_32(&value32, 5);
result64 = atomic_fetch_xor_64(&value64, 5);
resultx = (int64_t)atomic_fetch_xor_ptr(valuep, 5);
EXPECT_EQ(result8, 3);
EXPECT_EQ(value8, 6);
EXPECT_EQ(result16, 3);
EXPECT_EQ(value16, 6);
EXPECT_EQ(result32, 3);
EXPECT_EQ(value32, 6);
EXPECT_EQ(result64, 3);
EXPECT_EQ(value64, 6);
EXPECT_EQ(resultx, 3);
EXPECT_EQ(*valuep, 6);
EXPECT_EQ(valuex, 6);
}

View File

@ -0,0 +1,464 @@
/*
* 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 "tlog.h"
TEST(osDirTests, taosRemoveDir) {
int32_t ret = 0;
const char* testDir = "/tmp/tdengine-test-dir";
if (taosDirExist(testDir)) {
taosRemoveDir(testDir);
}
taosRemoveDir(testDir);
ret = taosMkDir(testDir);
EXPECT_EQ(ret, 0);
const char* testFile = "/tmp/tdengine-test-dir/test-file";
TdFilePtr testFilePtr = taosCreateFile(testFile, TD_FILE_CREATE);
EXPECT_NE(testFilePtr, nullptr);
ret = taosCloseFile(&testFilePtr);
EXPECT_EQ(ret, 0);
const char* testDir2 = "/tmp/tdengine-test-dir/test-dir2";
ret = taosMkDir(testDir2);
EXPECT_EQ(ret, 0);
const char* testFile2 = "/tmp/tdengine-test-dir/test-dir2/test-file2";
TdFilePtr testFilePtr2 = taosCreateFile(testFile2, TD_FILE_CREATE);
EXPECT_NE(testFilePtr2, nullptr);
ret = taosCloseFile(&testFilePtr2);
EXPECT_EQ(ret, 0);
taosRemoveDir(testDir);
bool exist = taosDirExist(testDir);
EXPECT_EQ(exist, false);
taosRemoveDir("/tmp/tdengine-test-dir");
}
TEST(osDirTests, taosDirExist) {
const char* dir1 = NULL;
bool exist = taosDirExist(dir1);
EXPECT_EQ(exist, false);
char dir2[2048] = {0};
for (int32_t i = 0; i < 2047; ++i) {
dir2[i] = 1;
}
exist = taosDirExist(dir2);
EXPECT_EQ(exist, false);
taosRemoveDir("/tmp/tdengine-test-dir");
}
TEST(osDirTests, taosMulMkDir) {
int32_t ret = 0;
const char* dir1 = NULL;
ret = taosMulMkDir(dir1);
EXPECT_EQ(ret, -1);
char dir2[2048] = {0};
for (int32_t i = 0; i < 2047; ++i) {
dir2[i] = '1';
}
ret = taosMulMkDir(dir2);
EXPECT_EQ(ret, -1);
const char* dir3 = "/tmp/tdengine-test-dir/1/2/3/4";
taosRemoveDir(dir3);
ret = taosMulMkDir(dir3);
EXPECT_EQ(ret, 0);
taosRemoveDir(dir3);
const char* dir4 = "./tdengine-test-dir/1/2/3/4";
taosRemoveDir(dir4);
ret = taosMulMkDir(dir4);
EXPECT_EQ(ret, 0);
taosRemoveDir(dir4);
const char* dir5 = "tdengine-test-dir/1/2/3/4";
taosRemoveDir(dir5);
ret = taosMulMkDir(dir5);
EXPECT_EQ(ret, 0);
ret = taosMulMkDir(dir5);
EXPECT_EQ(ret, 0);
taosRemoveDir(dir5);
const char* testFile = "/tmp/tdengine-test-dir/test-file";
TdFilePtr testFilePtr = taosCreateFile(testFile, TD_FILE_CREATE);
EXPECT_NE(testFilePtr, nullptr);
ret = taosCloseFile(&testFilePtr);
EXPECT_EQ(ret, 0);
char dir6[2048] = {0};
strcpy(dir6, "/tmp/tdengine-test-dir/test-file/1/2/3/4");
ret = taosMulMkDir(dir6);
EXPECT_NE(ret, 0);
taosRemoveDir("/tmp/tdengine-test-dir");
}
TEST(osDirTests, taosMulModeMkDir) {
int32_t ret = 0;
const char* dir1 = NULL;
ret = taosMulModeMkDir(dir1, 777, true);
EXPECT_NE(ret, 0);
char dir2[2048] = {0};
for (int32_t i = 0; i < 2047; ++i) {
dir2[i] = '1';
}
ret = taosMulModeMkDir(dir2, 777, true);
EXPECT_NE(ret, 0);
const char* dir3 = "/tmp/tdengine-test-dir/1/2/3/4";
taosRemoveDir(dir3);
ret = taosMulMkDir(dir3);
EXPECT_EQ(ret, 0);
ret = taosMulModeMkDir(dir3, 777, true);
EXPECT_EQ(ret, 0);
ret = taosMulModeMkDir(dir3, 777, false);
EXPECT_EQ(ret, 0);
ret = taosMulModeMkDir(dir3, 999, true);
EXPECT_EQ(ret, 0);
ret = taosMulModeMkDir(dir3, 999, false);
EXPECT_EQ(ret, 0);
taosRemoveDir(dir3);
const char* dir4 = "./tdengine-test-dir/1/2/3/4";
taosRemoveDir(dir4);
ret = taosMulModeMkDir(dir4, 777, true);
EXPECT_EQ(ret, 0);
ret = taosMulModeMkDir(dir4, 777, false);
EXPECT_EQ(ret, 0);
taosRemoveDir(dir4);
const char* dir5 = "tdengine-test-dir/1/2/3/4";
taosRemoveDir(dir5);
ret = taosMulModeMkDir(dir5, 777, true);
EXPECT_EQ(ret, 0);
ret = taosMulModeMkDir(dir5, 777, false);
EXPECT_EQ(ret, 0);
ret = taosMulModeMkDir(dir5, 777, true);
EXPECT_EQ(ret, 0);
ret = taosMulModeMkDir(dir5, 777, false);
EXPECT_EQ(ret, 0);
taosRemoveDir(dir5);
const char* testFile = "/tmp/tdengine-test-dir/test-file";
TdFilePtr testFilePtr = taosCreateFile(testFile, TD_FILE_CREATE);
EXPECT_NE(testFilePtr, nullptr);
ret = taosCloseFile(&testFilePtr);
EXPECT_EQ(ret, 0);
char dir6[2048] = {0};
strcpy(dir6, "/tmp/tdengine-test-dir/test-file/1/2/3/4");
ret = taosMulModeMkDir(dir6, 777, true);
EXPECT_NE(ret, 0);
const char* dir7 = "tdengine-test-dir/1/2/3/5";
taosRemoveDir(dir7);
ret = taosMulModeMkDir(dir7, 999, true);
EXPECT_EQ(ret, 0);
ret = taosMulModeMkDir(dir7, 999, false);
EXPECT_EQ(ret, 0);
taosRemoveDir("/tmp/tdengine-test-dir");
}
TEST(osDirTests, taosRemoveOldFiles) {
int32_t ret = 0;
const char* testDir = "/tmp/tdengine-test-dir";
if (taosDirExist(testDir)) {
taosRemoveDir(testDir);
}
taosRemoveDir(testDir);
ret = taosMkDir(testDir);
EXPECT_EQ(ret, 0);
const char* testFile = "/tmp/tdengine-test-dir/test-file";
TdFilePtr testFilePtr = taosCreateFile(testFile, TD_FILE_CREATE);
EXPECT_NE(testFilePtr, nullptr);
ret = taosCloseFile(&testFilePtr);
EXPECT_EQ(ret, 0);
taosRemoveOldFiles(testFile, 10);
const char* testDir2 = "/tmp/tdengine-test-dir/test-dir2";
ret = taosMkDir(testDir2);
EXPECT_EQ(ret, 0);
const char* testFile3 = "/tmp/tdengine-test-dir/log.1433726073.gz";
TdFilePtr testFilePtr3 = taosCreateFile(testFile3, TD_FILE_CREATE);
EXPECT_NE(testFilePtr3, nullptr);
ret = taosCloseFile(&testFilePtr3);
EXPECT_EQ(ret, 0);
const char* testFile4 = "/tmp/tdengine-test-dir/log.80.gz";
TdFilePtr testFilePtr4 = taosCreateFile(testFile4, TD_FILE_CREATE);
EXPECT_NE(testFilePtr4, nullptr);
ret = taosCloseFile(&testFilePtr4);
EXPECT_EQ(ret, 0);
char testFile5[1024];
snprintf(testFile5, 1024, "/tmp/tdengine-test-dir/log.%d.gz", taosGetTimestampSec());
TdFilePtr testFilePtr5 = taosCreateFile(testFile5, TD_FILE_CREATE);
EXPECT_NE(testFilePtr5, nullptr);
ret = taosCloseFile(&testFilePtr5);
EXPECT_EQ(ret, 0);
const char* testFile6 = "/tmp/tdengine-test-dir/log.1433726073.gz";
TdFilePtr testFilePtr6 = taosCreateFile(testFile6, TD_FILE_CREATE);
EXPECT_NE(testFilePtr6, nullptr);
ret = taosCloseFile(&testFilePtr6);
EXPECT_EQ(ret, 0);
taosRemoveOldFiles(testDir, 10);
bool exist = taosDirExist(testDir);
EXPECT_EQ(exist, true);
taosRemoveDir("/tmp/tdengine-test-dir");
}
TEST(osDirTests, taosExpandDir) {
int32_t ret = 0;
const char* testDir = "/tmp/tdengine-test-dir";
ret = taosMkDir(testDir);
EXPECT_EQ(ret, 0);
char fullpath[1024] = {0};
ret = taosExpandDir(testDir, NULL, 1024);
EXPECT_NE(ret, 0);
ret = taosExpandDir(NULL, fullpath, 1024);
EXPECT_NE(ret, 0);
ret = taosExpandDir(testDir, fullpath, 1024);
EXPECT_EQ(ret, 0);
ret = taosExpandDir("/x123", fullpath, 1024);
EXPECT_EQ(ret, 0);
ret = taosExpandDir("", fullpath, 1024);
EXPECT_EQ(ret, 0);
char dir2[2048] = {0};
for (int32_t i = 0; i < 2047; ++i) {
dir2[i] = '1';
}
ret = taosExpandDir(dir2, fullpath, 1024);
EXPECT_EQ(ret, 0);
taosRemoveDir("/tmp/tdengine-test-dir");
}
TEST(osDirTests, taosRealPath) {
int32_t ret = 0;
char testDir[PATH_MAX * 2] = "/tmp/tdengine-test-dir";
ret = taosMkDir(testDir);
EXPECT_EQ(ret, 0);
char fullpath[PATH_MAX * 2] = {0};
ret = taosRealPath(testDir, NULL, PATH_MAX * 2);
EXPECT_EQ(ret, 0);
ret = taosRealPath(NULL, fullpath, PATH_MAX * 2);
EXPECT_NE(ret, 0);
ret = taosRealPath(testDir, fullpath, PATH_MAX * 2);
EXPECT_EQ(ret, 0);
ret = taosRealPath(testDir, fullpath, 12);
EXPECT_NE(ret, 0);
ret = taosRealPath("/c/d", fullpath, 1024);
EXPECT_NE(ret, 0);
taosRemoveDir("/tmp/tdengine-test-dir");
}
TEST(osDirTests, taosIsDir) {
bool ret = taosIsDir("/c/d");
EXPECT_EQ(ret, false);
}
TEST(osDirTests, taosDirName) {
char* ret = taosDirName(NULL);
EXPECT_EQ(ret, nullptr);
char name1[24] = "xyz";
ret = taosDirName(name1);
EXPECT_NE(ret, nullptr);
EXPECT_EQ(name1[0], 0);
char name2[24] = "/root/xyz";
ret = taosDirName(name2);
EXPECT_NE(ret, nullptr);
EXPECT_STREQ(ret, "/root");
}
TEST(osDirTests, taosDirEntryBaseName) {
char* ret = taosDirEntryBaseName(NULL);
EXPECT_EQ(ret, nullptr);
char name1[12] = "/";
ret = taosDirEntryBaseName(name1);
EXPECT_STREQ(ret, "/");
char name2[12] = "/root/";
ret = taosDirEntryBaseName(name2);
EXPECT_STREQ(ret, "root");
char name3[12] = "/root";
ret = taosDirEntryBaseName(name3);
EXPECT_STREQ(ret, "root");
char name4[12] = "root";
ret = taosDirEntryBaseName(name4);
EXPECT_STREQ(ret, "root");
}
TEST(osDirTests, taosOpenDir) {
TdDirPtr ret = taosOpenDir(NULL);
EXPECT_EQ(ret, nullptr);
}
TEST(osDirTests, taosReadDir) {
TdDirEntryPtr rddir = taosReadDir(NULL);
EXPECT_EQ(rddir, nullptr);
int32_t ret = 0;
const char* testDir = "/tmp/tdengine-test-dir";
ret = taosMkDir(testDir);
EXPECT_EQ(ret, 0);
const char* testFile = "/tmp/tdengine-test-dir/test-file";
TdFilePtr testFilePtr = taosCreateFile(testFile, TD_FILE_CREATE);
EXPECT_NE(testFilePtr, nullptr);
ret = taosCloseFile(&testFilePtr);
EXPECT_EQ(ret, 0);
TdDirPtr dir = taosOpenDir(testFile);
EXPECT_EQ(dir, nullptr);
const char* testDir2 = "/tmp/tdengine-test-dir/test-dir2";
ret = taosMkDir(testDir2);
EXPECT_EQ(ret, 0);
const char* testFile2 = "/tmp/tdengine-test-dir/test-dir2/test-file2";
TdFilePtr testFilePtr2 = taosCreateFile(testFile2, TD_FILE_CREATE);
EXPECT_NE(testFilePtr2, nullptr);
ret = taosCloseFile(&testFilePtr2);
EXPECT_EQ(ret, 0);
dir = taosOpenDir(testFile);
EXPECT_EQ(dir, nullptr);
rddir = taosReadDir(dir);
EXPECT_EQ(rddir, nullptr);
dir = taosOpenDir(testDir);
EXPECT_NE(dir, nullptr);
rddir = taosReadDir(dir);
EXPECT_NE(rddir, nullptr);
bool entry = taosDirEntryIsDir(NULL);
EXPECT_EQ(entry, false);
char* entryname = taosGetDirEntryName(NULL);
EXPECT_EQ(entryname, nullptr);
entryname = taosGetDirEntryName(rddir);
EXPECT_NE(entryname, nullptr);
int32_t code = taosCloseDir(NULL);
EXPECT_NE(code, 0);
code = taosCloseDir(&dir);
EXPECT_EQ(code, 0);
taosRemoveDir("/tmp/tdengine-test-dir");
}
TEST(osDirTests, taosGetDirSize) {
TdDirEntryPtr rddir = taosReadDir(NULL);
EXPECT_EQ(rddir, nullptr);
int32_t ret = 0;
const char* testDir = "/tmp/tdengine-test-dir";
ret = taosMkDir(testDir);
EXPECT_EQ(ret, 0);
const char* testFile = "/tmp/tdengine-test-dir/test-file";
TdFilePtr testFilePtr = taosCreateFile(testFile, TD_FILE_CREATE);
EXPECT_NE(testFilePtr, nullptr);
ret = taosCloseFile(&testFilePtr);
EXPECT_EQ(ret, 0);
TdDirPtr dir = taosOpenDir(testFile);
EXPECT_EQ(dir, nullptr);
const char* testDir2 = "/tmp/tdengine-test-dir/test-dir2";
ret = taosMkDir(testDir2);
EXPECT_EQ(ret, 0);
const char* testFile2 = "/tmp/tdengine-test-dir/test-dir2/test-file2";
TdFilePtr testFilePtr2 = taosCreateFile(testFile2, TD_FILE_CREATE);
EXPECT_NE(testFilePtr2, nullptr);
ret = taosCloseFile(&testFilePtr2);
EXPECT_EQ(ret, 0);
int64_t size = -1;
ret = taosGetDirSize(testFile, &size);
EXPECT_NE(ret, 0);
ret = taosGetDirSize(testDir, &size);
EXPECT_EQ(ret, 0);
taosRemoveDir("/tmp/tdengine-test-dir");
taosRemoveDir("./tdengine-test-dir/1/2/3/5");
taosRemoveDir("./tdengine-test-dir/1/2/3/4");
taosRemoveDir("./tdengine-test-dir/1/2/3");
taosRemoveDir("./tdengine-test-dir/1/2");
taosRemoveDir("./tdengine-test-dir/1");
taosRemoveDir("./tdengine-test-dir/");
taosRemoveDir("tdengine-test-dir/1/2/3/5");
taosRemoveDir("tdengine-test-dir/1/2/3/4");
taosRemoveDir("tdengine-test-dir/1/2/3");
taosRemoveDir("tdengine-test-dir/1/2");
taosRemoveDir("tdengine-test-dir/1");
taosRemoveDir("tdengine-test-dir/");
taosRemoveDir("tdengine-test-dir/");
}

View File

@ -0,0 +1,93 @@
/*
* 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 "tlog.h"
TEST(osEnvTests, osDefaultInit) {
int32_t ret = 0;
strcpy(tsTimezoneStr, "");
strcpy(tsTempDir, "");
tsNumOfCores = 0;
ret = osDefaultInit();
EXPECT_EQ(ret, 0);
strcpy(tsTempDir, "/tmp");
ret = osDefaultInit();
EXPECT_EQ(ret, 0);
osCleanup();
}
TEST(osEnvTests, osUpdate) {
int32_t ret = 0;
strcpy(tsLogDir, "");
strcpy(tsDataDir, "");
strcpy(tsTempDir, "");
ret = osUpdate();
EXPECT_EQ(ret, 0);
}
TEST(osEnvTests, osSufficient) {
bool ret = 0;
tsLogSpace.size.avail = 10000;
tsDataSpace.size.avail = 10000;
tsTempSpace.size.avail = 10000;
tsLogSpace.reserved = 2000;
tsDataSpace.reserved = 2000;
tsDataSpace.reserved = 2000;
ret = osLogSpaceAvailable();
EXPECT_EQ(ret, true);
ret = osTempSpaceAvailable();
EXPECT_EQ(ret, true);
ret = osDataSpaceAvailable();
EXPECT_EQ(ret, true);
ret = osLogSpaceSufficient();
EXPECT_EQ(ret, true);
ret = osDataSpaceSufficient();
EXPECT_EQ(ret, true);
ret = osTempSpaceSufficient();
EXPECT_EQ(ret, true);
osSetSystemLocale(NULL, NULL);
osSetSystemLocale(NULL, NULL);
osSetSystemLocale("1", "2");
osSetProcPath(1, NULL);
osSetProcPath(0, (char **)&ret);
}

View File

@ -33,6 +33,13 @@ ENDIF()
INCLUDE_DIRECTORIES(${TD_SOURCE_DIR}/src/util/inc)
INCLUDE_DIRECTORIES(${TD_SOURCE_DIR}/include/common)
add_executable(heapTest "heapTest.cpp")
target_link_libraries(heapTest os util gtest_main)
add_test(
NAME heapTest
COMMAND heapTest
)
# arrayTest
add_executable(arrayTest "arrayTest.cpp")
target_link_libraries(arrayTest os util gtest_main)

View File

@ -20,7 +20,7 @@ int32_t heapCompare(const HeapNode* a, const HeapNode* b) {
return 1;
}
TEST(TD_UTIL_HEAP_TEST, heapTest) {
TEST(heapTest, heapTest) {
Heap* heap = heapCreate(heapCompare);
ASSERT_TRUE(heap != NULL);
ASSERT_EQ(0, heapSize(heap));