Merge pull request #29069 from taosdata/cover/simon/ut
enh: add test cases for osAtomic and osDir
This commit is contained in:
commit
d1f93abff4
|
@ -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
|
||||
|
|
|
@ -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()
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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(
|
||||
|
|
|
@ -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);
|
||||
}
|
|
@ -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/");
|
||||
}
|
|
@ -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);
|
||||
}
|
|
@ -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)
|
||||
|
|
|
@ -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));
|
||||
|
|
Loading…
Reference in New Issue