637 lines
17 KiB
C++
637 lines
17 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(tasoUcs4Compare(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(tasoUcs4Compare(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(tasoUcs4Compare(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);
|
|
}
|
|
|