788 lines
21 KiB
C++
788 lines
21 KiB
C++
/*
|
|
* 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 <cstring>
|
|
#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"
|
|
|
|
#ifdef WINDOWS
|
|
TEST(osStringTests, strsepNormalInput) {
|
|
char str[] = "This is a test string.";
|
|
char* ptr = str;
|
|
char* tok = NULL;
|
|
const char delim[] = " ";
|
|
|
|
while ((tok = strsep(&ptr, delim)) != NULL) {
|
|
printf("%s\n", tok);
|
|
}
|
|
EXPECT_STREQ(tok, nullptr);
|
|
EXPECT_EQ(ptr, nullptr);
|
|
}
|
|
|
|
TEST(osStringTests, strsepEmptyInput) {
|
|
char* str = "";
|
|
char* ptr = str;
|
|
char* tok = NULL;
|
|
const char delim[] = " ";
|
|
|
|
while ((tok = strsep(&ptr, delim)) != NULL) {
|
|
printf("%s\n", tok);
|
|
}
|
|
|
|
EXPECT_STREQ(tok, nullptr);
|
|
EXPECT_EQ(ptr, nullptr);
|
|
}
|
|
|
|
TEST(osStringTests, strsepNullInput) {
|
|
char* str = NULL;
|
|
char* ptr = str;
|
|
char* tok = NULL;
|
|
const char delim[] = " ";
|
|
|
|
while ((tok = strsep(&ptr, delim)) != NULL) {
|
|
printf("%s\n", tok);
|
|
}
|
|
|
|
EXPECT_STREQ(tok, nullptr);
|
|
EXPECT_EQ(ptr, nullptr);
|
|
}
|
|
|
|
TEST(osStringTests, strndupNormalInput) {
|
|
const char s[] = "This is a test string.";
|
|
int size = strlen(s) + 1;
|
|
char* s2 = taosStrndup(s, size);
|
|
|
|
EXPECT_STREQ(s, s2);
|
|
|
|
free(s2);
|
|
}
|
|
#endif
|
|
|
|
TEST(osStringTests, osUcs4Tests1) {
|
|
TdUcs4 f1_ucs4[] = {0x0048, 0x0065, 0x006C, 0x006C, 0x006F, 0x0000};
|
|
TdUcs4 f2_ucs4[] = {0x0048, 0x0065, 0x006C, 0x006C, 0x006F, 0x0000};
|
|
|
|
EXPECT_EQ(taosUcs4Compare(f1_ucs4, f2_ucs4, sizeof(f1_ucs4)), 0);
|
|
|
|
TdUcs4 f3_ucs4[] = {0x0048, 0x0065, 0x006C, 0x006C, 0x006F, 0x0020, 0x0077,
|
|
0x006F, 0x0072, 0x006C, 0x0064, 0x0021, 0x0000};
|
|
TdUcs4 f4_ucs4[] = {0x0048, 0x0065, 0x006C, 0x006C, 0x006F, 0x0000};
|
|
|
|
EXPECT_GT(taosUcs4Compare(f3_ucs4, f4_ucs4, sizeof(f3_ucs4)), 0);
|
|
|
|
TdUcs4 f5_ucs4[] = {0x0048, 0x0065, 0x006C, 0x006C, 0x006F, 0x0000};
|
|
TdUcs4 f6_ucs4[] = {0x0048, 0x0065, 0x006C, 0x006C, 0x006F, 0x0020, 0x0077,
|
|
0x006F, 0x0072, 0x006C, 0x0064, 0x0021, 0x0000};
|
|
|
|
EXPECT_LT(taosUcs4Compare(f5_ucs4, f6_ucs4, sizeof(f5_ucs4)), 0);
|
|
}
|
|
|
|
TEST(osStringTests, osUcs4lenTests2) {
|
|
TdUcs4 ucs4_1[] = {'H', 'e', 'l', 'l', 'o', '\0'};
|
|
EXPECT_EQ(taosUcs4len(ucs4_1), 5);
|
|
|
|
TdUcs4 ucs4_2[] = {'\0'};
|
|
EXPECT_EQ(taosUcs4len(ucs4_2), 0);
|
|
|
|
TdUcs4 ucs4_3[] = {'C', 'h', 'i', 'n', 'a', 0x4E2D, 0x6587, '\0'};
|
|
EXPECT_EQ(taosUcs4len(ucs4_3), 7);
|
|
}
|
|
|
|
TEST(osStringTests, ostsnprintfTests) {
|
|
char buffer[50] = {0};
|
|
int64_t ret;
|
|
|
|
ret = tsnprintf(buffer, sizeof(buffer), "Hello, %s!", "World");
|
|
EXPECT_EQ(ret, 13);
|
|
EXPECT_STREQ(buffer, "Hello, World!");
|
|
|
|
memset(buffer, 0, sizeof(buffer));
|
|
ret = tsnprintf(buffer, 10, "Hello, %s!", "World");
|
|
EXPECT_EQ(ret, 9);
|
|
EXPECT_EQ(strncmp(buffer, "Hello, Wo", 9), 0);
|
|
|
|
memset(buffer, 0, sizeof(buffer));
|
|
ret = tsnprintf(buffer, 10, "Hello%s", "World");
|
|
EXPECT_EQ(ret, 9);
|
|
EXPECT_EQ(strncmp(buffer, "HelloWorl", 9), 0);
|
|
|
|
memset(buffer, 0, sizeof(buffer));
|
|
ret = tsnprintf(buffer, 0, "Hello, %s!", "World");
|
|
EXPECT_EQ(ret, 0);
|
|
|
|
memset(buffer, 0, sizeof(buffer));
|
|
ret = tsnprintf(buffer, SIZE_MAX + 1, "Hello, %s!", "World");
|
|
EXPECT_EQ(ret, 0);
|
|
|
|
memset(buffer, 0, sizeof(buffer));
|
|
ret = tsnprintf(buffer, sizeof(buffer), "");
|
|
EXPECT_EQ(ret, 0);
|
|
EXPECT_STREQ(buffer, "");
|
|
|
|
memset(buffer, 0, sizeof(buffer));
|
|
ret = tsnprintf(buffer, sizeof(buffer), "Number: %d", 42);
|
|
EXPECT_EQ(ret, 10);
|
|
EXPECT_STREQ(buffer, "Number: 42");
|
|
|
|
memset(buffer, 0, sizeof(buffer));
|
|
ret = tsnprintf(buffer, sizeof(buffer), "Float: %.2f", 3.14);
|
|
EXPECT_EQ(ret, 11);
|
|
EXPECT_STREQ(buffer, "Float: 3.14");
|
|
}
|
|
TEST(osStringTests, osStr2Int64) {
|
|
int64_t val;
|
|
int32_t result;
|
|
|
|
// 测试空指针输入
|
|
result = taosStr2int64(NULL, &val);
|
|
assert(result == TSDB_CODE_INVALID_PARA);
|
|
|
|
result = taosStr2int64("123", NULL);
|
|
ASSERT_NE(result, 0);
|
|
|
|
// 测试无效输入
|
|
result = taosStr2int64("abc", &val);
|
|
ASSERT_NE(result, 0);
|
|
|
|
result = taosStr2int64("", &val);
|
|
ASSERT_NE(result, 0);
|
|
|
|
char large_num[50];
|
|
snprintf(large_num, sizeof(large_num), "%lld", LLONG_MAX);
|
|
result = taosStr2int64(large_num, &val);
|
|
assert(result == 0);
|
|
assert(val == LLONG_MAX);
|
|
|
|
snprintf(large_num, sizeof(large_num), "%lld", LLONG_MIN);
|
|
result = taosStr2int64(large_num, &val);
|
|
assert(result == 0);
|
|
assert(val == LLONG_MIN);
|
|
|
|
result = taosStr2int64("123abc", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 123);
|
|
|
|
result = taosStr2int64("abc123", &val);
|
|
ASSERT_NE(result, 0);
|
|
// 测试有效的整数字符串
|
|
result = taosStr2int64("12345", &val);
|
|
assert(result == 0);
|
|
assert(val == 12345);
|
|
|
|
result = taosStr2int64("-12345", &val);
|
|
assert(result == 0);
|
|
assert(val == -12345);
|
|
|
|
result = taosStr2int64("0", &val);
|
|
assert(result == 0);
|
|
assert(val == 0);
|
|
|
|
// 测试带空格的字符串
|
|
result = taosStr2int64(" 12345", &val);
|
|
assert(result == 0);
|
|
assert(val == 12345);
|
|
|
|
result = taosStr2int64("12345 ", &val);
|
|
assert(result == 0);
|
|
assert(val == 12345);
|
|
}
|
|
TEST(osStringTests, osStr2int32) {
|
|
int32_t val;
|
|
int32_t result;
|
|
|
|
// 测试空指针输入
|
|
result = taosStr2int32(NULL, &val);
|
|
ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
|
|
|
|
result = taosStr2int32("123", NULL);
|
|
ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
|
|
|
|
// 测试无效输入
|
|
result = taosStr2int32("abc", &val);
|
|
ASSERT_NE(result, 0);
|
|
|
|
result = taosStr2int32("", &val);
|
|
ASSERT_NE(result, 0);
|
|
|
|
// 测试超出范围的值
|
|
char large_num[50];
|
|
snprintf(large_num, sizeof(large_num), "%d", INT_MAX);
|
|
result = taosStr2int32(large_num, &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, INT_MAX);
|
|
|
|
snprintf(large_num, sizeof(large_num), "%d", INT_MIN);
|
|
result = taosStr2int32(large_num, &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, INT_MIN);
|
|
|
|
// 测试大于 INT32 范围的值
|
|
snprintf(large_num, sizeof(large_num), "%lld", (long long)INT_MAX + 1);
|
|
result = taosStr2int32(large_num, &val);
|
|
ASSERT_EQ(result, TAOS_SYSTEM_ERROR(ERANGE));
|
|
|
|
snprintf(large_num, sizeof(large_num), "%lld", (long long)INT_MIN - 1);
|
|
result = taosStr2int32(large_num, &val);
|
|
ASSERT_EQ(result, TAOS_SYSTEM_ERROR(ERANGE));
|
|
|
|
result = taosStr2int32("123abc", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 123);
|
|
|
|
result = taosStr2int32("abc123", &val);
|
|
ASSERT_NE(result, 0);
|
|
|
|
// 测试有效的整数字符串
|
|
result = taosStr2int32("12345", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 12345);
|
|
|
|
result = taosStr2int32("-12345", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, -12345);
|
|
|
|
result = taosStr2int32("0", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 0);
|
|
|
|
// 测试带空格的字符串
|
|
result = taosStr2int32(" 12345", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 12345);
|
|
|
|
result = taosStr2int32("12345 ", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 12345);
|
|
}
|
|
|
|
TEST(osStringTests, taosStr2int16) {
|
|
int16_t val;
|
|
int32_t result;
|
|
|
|
// 测试空指针输入
|
|
result = taosStr2int16(NULL, &val);
|
|
ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
|
|
|
|
result = taosStr2int16("123", NULL);
|
|
ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
|
|
|
|
// 测试无效输入
|
|
result = taosStr2int16("abc", &val);
|
|
ASSERT_NE(result, 0);
|
|
|
|
result = taosStr2int16("", &val);
|
|
ASSERT_NE(result, 0);
|
|
|
|
// 测试超出范围的值
|
|
char large_num[50];
|
|
snprintf(large_num, sizeof(large_num), "%d", INT16_MAX);
|
|
result = taosStr2int16(large_num, &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, INT16_MAX);
|
|
|
|
snprintf(large_num, sizeof(large_num), "%d", INT16_MIN);
|
|
result = taosStr2int16(large_num, &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, INT16_MIN);
|
|
|
|
// 测试大于 INT16 范围的值
|
|
snprintf(large_num, sizeof(large_num), "%lld", (long long)INT16_MAX + 1);
|
|
result = taosStr2int16(large_num, &val);
|
|
ASSERT_EQ(result, TAOS_SYSTEM_ERROR(ERANGE));
|
|
|
|
snprintf(large_num, sizeof(large_num), "%lld", (long long)INT16_MIN - 1);
|
|
result = taosStr2int16(large_num, &val);
|
|
ASSERT_EQ(result, TAOS_SYSTEM_ERROR(ERANGE));
|
|
|
|
result = taosStr2int16("123abc", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 123);
|
|
|
|
result = taosStr2int16("abc123", &val);
|
|
ASSERT_NE(result, 0);
|
|
// 测试有效的整数字符串
|
|
result = taosStr2int16("12345", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 12345);
|
|
|
|
result = taosStr2int16("-12345", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, -12345);
|
|
|
|
result = taosStr2int16("0", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 0);
|
|
|
|
// 测试带空格的字符串
|
|
result = taosStr2int16(" 12345", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 12345);
|
|
|
|
result = taosStr2int16("12345 ", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 12345);
|
|
}
|
|
|
|
TEST(osStringTests, taosStr2int8) {
|
|
int8_t val;
|
|
int32_t result;
|
|
|
|
// 测试空指针输入
|
|
result = taosStr2int8(NULL, &val);
|
|
ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
|
|
|
|
result = taosStr2int8("123", NULL);
|
|
ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
|
|
|
|
// 测试无效输入
|
|
result = taosStr2int8("abc", &val);
|
|
ASSERT_NE(result, 0);
|
|
|
|
result = taosStr2int8("", &val);
|
|
ASSERT_NE(result, 0);
|
|
|
|
// 测试超出范围的值
|
|
char large_num[50];
|
|
snprintf(large_num, sizeof(large_num), "%d", INT8_MAX);
|
|
result = taosStr2int8(large_num, &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, INT8_MAX);
|
|
|
|
snprintf(large_num, sizeof(large_num), "%d", INT8_MIN);
|
|
result = taosStr2int8(large_num, &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, INT8_MIN);
|
|
|
|
// 测试大于 INT8 范围的值
|
|
snprintf(large_num, sizeof(large_num), "%lld", (long long)INT8_MAX + 1);
|
|
result = taosStr2int8(large_num, &val);
|
|
ASSERT_EQ(result, TAOS_SYSTEM_ERROR(ERANGE));
|
|
|
|
snprintf(large_num, sizeof(large_num), "%lld", (long long)INT8_MIN - 1);
|
|
result = taosStr2int8(large_num, &val);
|
|
ASSERT_EQ(result, TAOS_SYSTEM_ERROR(ERANGE));
|
|
|
|
result = taosStr2int8("123abc", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 123);
|
|
|
|
result = taosStr2int8("abc123", &val);
|
|
ASSERT_NE(result, 0);
|
|
|
|
// 测试有效的整数字符串
|
|
result = taosStr2int8("123", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 123);
|
|
|
|
result = taosStr2int8("-123", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, -123);
|
|
|
|
result = taosStr2int8("0", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 0);
|
|
|
|
// 测试带空格的字符串
|
|
result = taosStr2int8(" 123", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 123);
|
|
|
|
result = taosStr2int8("123 ", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 123);
|
|
}
|
|
|
|
TEST(osStringTests, osStr2Uint64) {
|
|
uint64_t val;
|
|
int32_t result;
|
|
|
|
// 测试空指针输入
|
|
result = taosStr2Uint64(NULL, &val);
|
|
ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
|
|
|
|
result = taosStr2Uint64("123", NULL);
|
|
ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
|
|
|
|
// 测试无效输入
|
|
result = taosStr2Uint64("abc", &val);
|
|
ASSERT_NE(result, 0);
|
|
|
|
result = taosStr2Uint64("", &val);
|
|
ASSERT_NE(result, 0);
|
|
|
|
char large_num[50];
|
|
snprintf(large_num, sizeof(large_num), "%llu", ULLONG_MAX);
|
|
result = taosStr2Uint64(large_num, &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, ULLONG_MAX);
|
|
|
|
result = taosStr2Uint64("123abc", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 123);
|
|
|
|
result = taosStr2Uint64("abc123", &val);
|
|
ASSERT_NE(result, 0);
|
|
// 测试有效的整数字符串
|
|
result = taosStr2Uint64("12345", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 12345);
|
|
|
|
result = taosStr2Uint64("0", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 0);
|
|
|
|
// 测试带空格的字符串
|
|
result = taosStr2Uint64(" 12345", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 12345);
|
|
|
|
result = taosStr2Uint64("12345 ", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 12345);
|
|
}
|
|
|
|
TEST(osStringTests, taosStr2Uint32) {
|
|
uint32_t val;
|
|
int32_t result;
|
|
|
|
// 测试空指针输入
|
|
result = taosStr2Uint32(NULL, &val);
|
|
ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
|
|
|
|
result = taosStr2Uint32("123", NULL);
|
|
ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
|
|
|
|
// 测试无效输入
|
|
result = taosStr2Uint32("abc", &val);
|
|
ASSERT_NE(result, 0);
|
|
|
|
result = taosStr2Uint32("", &val);
|
|
ASSERT_NE(result, 0);
|
|
|
|
// 测试超出范围的值
|
|
char large_num[50];
|
|
snprintf(large_num, sizeof(large_num), "%u", UINT32_MAX);
|
|
result = taosStr2Uint32(large_num, &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, UINT32_MAX);
|
|
|
|
// 测试大于 UINT32 范围的值
|
|
snprintf(large_num, sizeof(large_num), "%llu", (unsigned long long)UINT32_MAX + 1);
|
|
result = taosStr2Uint32(large_num, &val);
|
|
ASSERT_EQ(result, TAOS_SYSTEM_ERROR(ERANGE));
|
|
|
|
result = taosStr2Uint32("123abc", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 123);
|
|
|
|
result = taosStr2Uint32("abc123", &val);
|
|
ASSERT_NE(result, 0);
|
|
// 测试有效的整数字符串
|
|
result = taosStr2Uint32("12345", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 12345);
|
|
|
|
result = taosStr2Uint32("0", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 0);
|
|
|
|
// 测试带空格的字符串
|
|
result = taosStr2Uint32(" 12345", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 12345);
|
|
|
|
result = taosStr2Uint32("12345 ", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 12345);
|
|
}
|
|
|
|
TEST(osStringTests, taosStr2Uint16) {
|
|
uint16_t val;
|
|
int32_t result;
|
|
|
|
// 测试空指针输入
|
|
result = taosStr2Uint16(NULL, &val);
|
|
ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
|
|
|
|
result = taosStr2Uint16("123", NULL);
|
|
ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
|
|
|
|
// 测试无效输入
|
|
result = taosStr2Uint16("abc", &val);
|
|
ASSERT_NE(result, 0);
|
|
|
|
result = taosStr2Uint16("", &val);
|
|
ASSERT_NE(result, 0);
|
|
|
|
// 测试超出范围的值
|
|
char large_num[50];
|
|
snprintf(large_num, sizeof(large_num), "%u", UINT16_MAX);
|
|
result = taosStr2Uint16(large_num, &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, UINT16_MAX);
|
|
|
|
// 测试大于 UINT16 范围的值
|
|
snprintf(large_num, sizeof(large_num), "%llu", (unsigned long long)UINT16_MAX + 1);
|
|
result = taosStr2Uint16(large_num, &val);
|
|
ASSERT_EQ(result, TAOS_SYSTEM_ERROR(ERANGE));
|
|
|
|
result = taosStr2Uint16("123abc", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 123);
|
|
|
|
result = taosStr2Uint16("abc123", &val);
|
|
ASSERT_NE(result, 0);
|
|
// 测试有效的整数字符串
|
|
result = taosStr2Uint16("12345", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 12345);
|
|
|
|
result = taosStr2Uint16("0", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 0);
|
|
|
|
// 测试带空格的字符串
|
|
result = taosStr2Uint16(" 12345", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 12345);
|
|
|
|
result = taosStr2Uint16("12345 ", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 12345);
|
|
}
|
|
|
|
TEST(osStringTests, taosStr2Uint8) {
|
|
uint8_t val;
|
|
int32_t result;
|
|
|
|
// 测试空指针输入
|
|
result = taosStr2Uint8(NULL, &val);
|
|
ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
|
|
|
|
result = taosStr2Uint8("123", NULL);
|
|
ASSERT_EQ(result, TSDB_CODE_INVALID_PARA);
|
|
|
|
// 测试无效输入
|
|
result = taosStr2Uint8("abc", &val);
|
|
ASSERT_NE(result, 0);
|
|
|
|
result = taosStr2Uint8("", &val);
|
|
ASSERT_NE(result, 0);
|
|
|
|
// 测试超出范围的值
|
|
char large_num[50];
|
|
snprintf(large_num, sizeof(large_num), "%u", UINT8_MAX);
|
|
result = taosStr2Uint8(large_num, &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, UINT8_MAX);
|
|
|
|
// 测试大于 UINT8 范围的值
|
|
snprintf(large_num, sizeof(large_num), "%llu", (unsigned long long)UINT8_MAX + 1);
|
|
result = taosStr2Uint8(large_num, &val);
|
|
ASSERT_EQ(result, TAOS_SYSTEM_ERROR(ERANGE));
|
|
|
|
result = taosStr2Uint8("123abc", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 123);
|
|
|
|
result = taosStr2Uint8("abc123", &val);
|
|
ASSERT_NE(result, 0);
|
|
// 测试有效的整数字符串
|
|
result = taosStr2Uint8("123", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 123);
|
|
|
|
result = taosStr2Uint8("0", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 0);
|
|
|
|
// 测试带空格的字符串
|
|
result = taosStr2Uint8(" 123", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 123);
|
|
|
|
result = taosStr2Uint8("123 ", &val);
|
|
ASSERT_EQ(result, 0);
|
|
ASSERT_EQ(val, 123);
|
|
}
|
|
|
|
TEST(osStringTests, strint2) {
|
|
const char* ret = tstrdup(NULL);
|
|
EXPECT_EQ(ret, nullptr);
|
|
|
|
ret = taosStrndupi(NULL, 0);
|
|
EXPECT_EQ(ret, nullptr);
|
|
|
|
char buf[12] = "12345";
|
|
ret = tstrndup(buf, 4);
|
|
EXPECT_NE(ret, nullptr);
|
|
|
|
int64_t val = 0;
|
|
int32_t ret32 = taosStr2int64(NULL, &val);
|
|
EXPECT_NE(ret32, 0);
|
|
ret32 = taosStr2int64(buf, NULL);
|
|
EXPECT_NE(ret32, 0);
|
|
|
|
TdUcs4 p1, p2;
|
|
int32_t val32 = 0;
|
|
ret32 = taosUcs4Compare(&p1, NULL, val32);
|
|
EXPECT_NE(ret32, 0);
|
|
ret32 = taosUcs4Compare(NULL, &p2, val32);
|
|
EXPECT_NE(ret32, 0);
|
|
|
|
void* retptr = taosAcquireConv(NULL, M2C, NULL);
|
|
EXPECT_EQ(retptr, nullptr);
|
|
|
|
ret32 = taosUcs4ToMbs(NULL, 0, NULL, NULL);
|
|
EXPECT_EQ(ret32, 0);
|
|
ret32 = taosUcs4ToMbs(NULL, -1, NULL, NULL);
|
|
EXPECT_NE(ret32, 0);
|
|
ret32 = taosUcs4ToMbs(NULL, 1, NULL, NULL);
|
|
EXPECT_NE(ret32, 0);
|
|
ret32 = taosUcs4ToMbs(&p1, 1, NULL, NULL);
|
|
EXPECT_NE(ret32, 0);
|
|
|
|
bool retb = taosValidateEncodec(NULL);
|
|
EXPECT_FALSE(retb);
|
|
|
|
ret32 = taosUcs4len(NULL);
|
|
EXPECT_EQ(ret32, 0);
|
|
|
|
unsigned char src[24] = "1234";
|
|
char dst[24] = {0};
|
|
int32_t len = 5;
|
|
int32_t bufSize = 24;
|
|
ret32 = taosHexEncode(NULL, NULL, len, -1);
|
|
EXPECT_NE(ret32, 0);
|
|
ret32 = taosHexEncode(src, NULL, len, -1);
|
|
EXPECT_NE(ret32, 0);
|
|
ret32 = taosHexEncode(src, dst, len, -1);
|
|
EXPECT_NE(ret32, 0);
|
|
ret32 = taosHexEncode(src, dst, len, bufSize);
|
|
EXPECT_EQ(ret32, 0);
|
|
|
|
char dst2[24] = {0};
|
|
ret32 = taosHexDecode(NULL, NULL, 0);
|
|
EXPECT_NE(ret32, 0);
|
|
ret32 = taosHexDecode(NULL, dst2, 0);
|
|
EXPECT_NE(ret32, 0);
|
|
ret32 = taosHexDecode(dst, NULL, 0);
|
|
EXPECT_NE(ret32, 0);
|
|
ret32 = taosHexDecode(dst, dst2, 24);
|
|
EXPECT_EQ(ret32, 0);
|
|
EXPECT_STREQ((char*)src, dst2);
|
|
}
|
|
|
|
TEST(osStringTests, wchartest) {
|
|
char src[24] = "1234";
|
|
TdWchar dst[24] = {0};
|
|
|
|
int32_t ret32 = taosWcharsWidth(NULL, 0);
|
|
EXPECT_LT(ret32, 0);
|
|
ret32 = taosWcharsWidth(dst, 0);
|
|
EXPECT_LT(ret32, 0);
|
|
|
|
ret32 = taosMbToWchar(NULL, NULL, 0);
|
|
EXPECT_LT(ret32, 0);
|
|
ret32 = taosMbToWchar(dst, NULL, 0);
|
|
EXPECT_LT(ret32, 0);
|
|
ret32 = taosMbToWchar(dst, src, 0);
|
|
EXPECT_LT(ret32, 0);
|
|
ret32 = taosMbToWchar(dst, src, 4);
|
|
EXPECT_GT(ret32, 0);
|
|
ret32 = taosWcharsWidth(dst, ret32);
|
|
EXPECT_GT(ret32, 0);
|
|
|
|
ret32 = taosMbsToWchars(NULL, NULL, 0);
|
|
EXPECT_LT(ret32, 0);
|
|
ret32 = taosMbsToWchars(dst, NULL, 0);
|
|
EXPECT_LT(ret32, 0);
|
|
ret32 = taosMbsToWchars(dst, src, 0);
|
|
EXPECT_LT(ret32, 0);
|
|
ret32 = taosMbsToWchars(dst, src, 4);
|
|
EXPECT_GT(ret32, 0);
|
|
ret32 = taosWcharsWidth(dst, ret32);
|
|
EXPECT_GT(ret32, 0);
|
|
|
|
ret32 = taosWcharsWidth(NULL, dst[0]);
|
|
EXPECT_NE(ret32, 0);
|
|
ret32 = taosWcharToMb(src, dst[0]);
|
|
EXPECT_NE(ret32, 0);
|
|
}
|
|
|
|
TEST(osStringTests, strtransform) {
|
|
char src[12] = "12";
|
|
|
|
void* retptr = taosStrCaseStr(NULL, NULL);
|
|
EXPECT_EQ(retptr, nullptr);
|
|
retptr = taosStrCaseStr(src, NULL);
|
|
EXPECT_NE(retptr, nullptr);
|
|
|
|
int64_t ret64 = taosStr2Int64(NULL, NULL, 0);
|
|
EXPECT_EQ(ret64, 0);
|
|
uint64_t retu64 = taosStr2UInt64(NULL, NULL, 0);
|
|
EXPECT_EQ(retu64, 0);
|
|
int32_t ret32 = taosStr2Int32(NULL, NULL, 0);
|
|
EXPECT_EQ(ret32, 0);
|
|
uint32_t retu32 = taosStr2UInt32(NULL, NULL, 0);
|
|
EXPECT_EQ(retu32, 0);
|
|
ret32 = taosStr2Int16(NULL, NULL, 0);
|
|
EXPECT_EQ(ret32, 0);
|
|
ret32 = taosStr2UInt16(NULL, NULL, 0);
|
|
EXPECT_EQ(ret32, 0);
|
|
ret32 = taosStr2Int8(NULL, NULL, 0);
|
|
EXPECT_EQ(ret32, 0);
|
|
ret32 = taosStr2UInt8(NULL, NULL, 0);
|
|
EXPECT_EQ(ret32, 0);
|
|
|
|
double retd = taosStr2Double(NULL, NULL);
|
|
EXPECT_EQ((int32_t)retd, 0);
|
|
float retf = taosStr2Float(NULL, NULL);
|
|
EXPECT_EQ((int32_t)retf, 0);
|
|
|
|
bool retb = isValidateHex(NULL, 0);
|
|
EXPECT_FALSE(retb);
|
|
|
|
char z[12] = {0};
|
|
ret32 = taosHex2Ascii(NULL, 0, NULL, NULL);
|
|
EXPECT_NE(ret32, 0);
|
|
ret32 = taosHex2Ascii(z, 0, NULL, NULL);
|
|
EXPECT_NE(ret32, 0);
|
|
ret32 = taosHex2Ascii(z, 0, (void**)&z, NULL);
|
|
EXPECT_NE(ret32, 0);
|
|
|
|
ret64 = tsnprintf(NULL, 0, NULL);
|
|
EXPECT_EQ(ret64, 0);
|
|
ret64 = tsnprintf(z, 4, NULL);
|
|
EXPECT_EQ(ret64, 0);
|
|
ret64 = tsnprintf(z, 0, "ab");
|
|
EXPECT_EQ(ret64, 0);
|
|
ret64 = tsnprintf(z, 1, "ab");
|
|
EXPECT_EQ(ret64, 0);
|
|
}
|