Elgato_dark/TDengine
1
0
Fork 0
mirror of https://github.com/taosdata/TDengine synced 2026-05-24 10:09:01 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 4
TDengine/source/util/test/utilTests.cpp
WANG Xu c52c68aa4f
sync: apply remaining build system changes from monorepo (main) 
The following commits could not be applied individually due to context
differences between the monorepo and the public repo's build files.
They have been applied as a cumulative diff to ensure the final state
matches the monorepo exactly:

- chore: sync CI files with 3.0 branch to eliminate merge conflicts (rd-public/tsdb!271)
- revert(refactor): dynamically link taosd taosudf taosmqtt against libtaosnative.so to reduce binary size (revert #183) (rd-public/tsdb!282)
- fix(docs): autofix formatting issues across all doc files (rd-public/tsdb!296)
- feat: support -DBUILD_SANITIZER=true on windows for debug build (rd-public/tsdb!291)
- feat(build): build cache, mirror, and sccache optimizations (rd-public/tsdb!326)
- docs: update image for three replica (rd-public/tsdb!324)
- enh: shared storage on windows (rd-public/tsdb!333)
- fix(cmake): convert ext_libs3 from git clone to URL tarball download (rd-public/tsdb!360)
- feat: dual-source deps and comprehensive docs/packaging (cherry-pick to main) (rd-public/tsdb!352)
- fix(cmake): guard DOWNLOAD_EXTRACT_TIMESTAMP for CMake < 3.24 and fix duplicate Cargo.lock entry (rd-public/tsdb!369)
- fix: test case execution failure in pytest.sh (rd-public/tsdb!338)
- enh: built-in compilation support for Python UDF plugins use abi3 (rd-public/tsdb!325)
2026-05-23 14:11:50 +08:00

592 lines
23 KiB
C++
Raw Permalink Blame History

#include <gtest/gtest.h>
#include <stdlib.h>
#include <tutil.h>
#include <random>
#include <functional>
#include "tglobal.h"
#include "ttime.h"
#include "tarray.h"
#include "tcompare.h"
#include "tdatablock.h"
#include "tworker.h"
namespace {
} // namespace
TEST(utilTest, wchar_pattern_match_test) {
const TdWchar* pattern = L"%1";
int32_t ret = 0;
SPatternCompareInfo pInfo = PATTERN_COMPARE_INFO_INITIALIZER;
const TdWchar* str0 = L"14";
ret = wcsPatternMatch(reinterpret_cast<const TdUcs4*>(pattern), 2, reinterpret_cast<const TdUcs4*>(str0), wcslen(str0), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_NOWILDCARDMATCH);
const TdWchar* str1 = L"11";
ret = wcsPatternMatch(reinterpret_cast<const TdUcs4*>(pattern), 2, reinterpret_cast<const TdUcs4*>(str1), wcslen(str1), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const TdWchar* str2 = L"41";
ret = wcsPatternMatch(reinterpret_cast<const TdUcs4*>(pattern), 2, reinterpret_cast<const TdUcs4*>(str2), wcslen(str2), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const TdWchar* pattern3 = L"%_";
const TdWchar* str3 = L"88";
ret = wcsPatternMatch(reinterpret_cast<const TdUcs4*>(pattern3), 2, reinterpret_cast<const TdUcs4*>(str3), wcslen(str3), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const TdWchar* pattern4 = L"%___";
const TdWchar* str4 = L"88";
ret = wcsPatternMatch(reinterpret_cast<const TdUcs4*>(pattern4), 4, reinterpret_cast<const TdUcs4*>(str4), wcslen(str4), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_NOWILDCARDMATCH);
const TdWchar* pattern5 = L"%___";
const TdWchar* str5 = L"883391";
ret = wcsPatternMatch(reinterpret_cast<const TdUcs4*>(pattern5), 4, reinterpret_cast<const TdUcs4*>(str5), wcslen(str5), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const TdWchar* pattern6 = L"%___66";
const TdWchar* str6 = L"88339166";
ret = wcsPatternMatch(reinterpret_cast<const TdUcs4*>(pattern6), 6, reinterpret_cast<const TdUcs4*>(str6), wcslen(str6), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const TdWchar* pattern7 = L"%____66";
const TdWchar* str7 = L"66166";
ret = wcsPatternMatch(reinterpret_cast<const TdUcs4*>(pattern7), 7, reinterpret_cast<const TdUcs4*>(str7), wcslen(str7), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_NOWILDCARDMATCH);
const TdWchar* pattern8 = L"6%____66";
const TdWchar* str8 = L"666166";
ret = wcsPatternMatch(reinterpret_cast<const TdUcs4*>(pattern8), 8, reinterpret_cast<const TdUcs4*>(str8), wcslen(str8), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_NOWILDCARDMATCH);
const TdWchar* pattern9 = L"6\\__6";
const TdWchar* str9 = L"6_66";
ret = wcsPatternMatch(reinterpret_cast<const TdUcs4*>(pattern9), 6, reinterpret_cast<const TdUcs4*>(str9), wcslen(str9), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const TdWchar* pattern10 = L"%";
const TdWchar* str10 = L"";
ret = wcsPatternMatch(reinterpret_cast<const TdUcs4*>(pattern10), 1, reinterpret_cast<const TdUcs4*>(str10), 0, &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const TdWchar* pattern11 = L"china%";
const TdWchar* str11 = L"CHI ";
ret = wcsPatternMatch(reinterpret_cast<const TdUcs4*>(pattern11), 6, reinterpret_cast<const TdUcs4*>(str11), 3, &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_NOMATCH);
const TdWchar* pattern12 = L"abc%";
const TdWchar* str12 = L"";
ret = wcsPatternMatch(reinterpret_cast<const TdUcs4*>(pattern12), 4, reinterpret_cast<const TdUcs4*>(str12), 0, &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_NOMATCH);
const TdWchar* pattern13 = L"%\\_6 ";
const TdWchar* str13 = L"6a6 ";
ret = wcsPatternMatch(reinterpret_cast<const TdUcs4*>(pattern13), 6, reinterpret_cast<const TdUcs4*>(str13), 4, &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_NOWILDCARDMATCH);
const TdWchar* pattern14 = L"%\\%6 ";
const TdWchar* str14 = L"6a6 ";
ret = wcsPatternMatch(reinterpret_cast<const TdUcs4*>(pattern14), 6, reinterpret_cast<const TdUcs4*>(str14), 4, &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_NOWILDCARDMATCH);
}
TEST(utilTest, wchar_pattern_match_no_terminated) {
const TdWchar* pattern = L"%1 ";
int32_t ret = 0;
SPatternCompareInfo pInfo = PATTERN_COMPARE_INFO_INITIALIZER;
const TdWchar* str0 = L"14 ";
ret = wcsPatternMatch(reinterpret_cast<const TdUcs4*>(pattern), 2, reinterpret_cast<const TdUcs4*>(str0), 2, &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_NOWILDCARDMATCH);
const TdWchar* str1 = L"11 ";
ret = wcsPatternMatch(reinterpret_cast<const TdUcs4*>(pattern), 2, reinterpret_cast<const TdUcs4*>(str1), 2, &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const TdWchar* str2 = L"41 ";
ret = wcsPatternMatch(reinterpret_cast<const TdUcs4*>(pattern), 2, reinterpret_cast<const TdUcs4*>(str2), 2, &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const TdWchar* pattern3 = L"%_ ";
const TdWchar* str3 = L"88 ";
ret = wcsPatternMatch(reinterpret_cast<const TdUcs4*>(pattern3), 2, reinterpret_cast<const TdUcs4*>(str3), 2, &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const TdWchar* pattern4 = L"%___ ";
const TdWchar* str4 = L"88 ";
ret = wcsPatternMatch(reinterpret_cast<const TdUcs4*>(pattern4), 4, reinterpret_cast<const TdUcs4*>(str4), 2, &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_NOWILDCARDMATCH);
const TdWchar* pattern5 = L"%___ ";
const TdWchar* str5 = L"883391 ";
ret = wcsPatternMatch(reinterpret_cast<const TdUcs4*>(pattern5), 4, reinterpret_cast<const TdUcs4*>(str5), 6, &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const TdWchar* pattern6 = L"%___66 ";
const TdWchar* str6 = L"88339166 ";
ret = wcsPatternMatch(reinterpret_cast<const TdUcs4*>(pattern6), 6, reinterpret_cast<const TdUcs4*>(str6), 8, &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const TdWchar* pattern7 = L"%____66 ";
const TdWchar* str7 = L"66166 ";
ret = wcsPatternMatch(reinterpret_cast<const TdUcs4*>(pattern7), 7, reinterpret_cast<const TdUcs4*>(str7), 5, &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_NOWILDCARDMATCH);
const TdWchar* pattern8 = L"6%____66 ";
const TdWchar* str8 = L"666166 ";
ret = wcsPatternMatch(reinterpret_cast<const TdUcs4*>(pattern8), 8, reinterpret_cast<const TdUcs4*>(str8), 6, &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_NOWILDCARDMATCH);
const TdWchar* pattern9 = L"6\\_6 ";
const TdWchar* str9 = L"6_6 ";
ret = wcsPatternMatch(reinterpret_cast<const TdUcs4*>(pattern9), 6, reinterpret_cast<const TdUcs4*>(str9), 4, &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const TdWchar* pattern10 = L"% ";
const TdWchar* str10 = L"6_6 ";
ret = wcsPatternMatch(reinterpret_cast<const TdUcs4*>(pattern10), 2, reinterpret_cast<const TdUcs4*>(str10), 4, &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const TdWchar* pattern11 = L"%\\_6 ";
const TdWchar* str11 = L"6_6 ";
ret = wcsPatternMatch(reinterpret_cast<const TdUcs4*>(pattern11), 6, reinterpret_cast<const TdUcs4*>(str11), 4, &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const TdWchar* pattern12 = L"%\\%6 ";
const TdWchar* str12 = L"6%6 ";
ret = wcsPatternMatch(reinterpret_cast<const TdUcs4*>(pattern12), 6, reinterpret_cast<const TdUcs4*>(str12), 4, &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
}
TEST(utilTest, char_pattern_match_test) {
const char* pattern = "%1";
int32_t ret = 0;
SPatternCompareInfo pInfo = PATTERN_COMPARE_INFO_INITIALIZER;
const char* str0 = "14";
ret = patternMatch(pattern, 2, str0, strlen(str0), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_NOWILDCARDMATCH);
const char* str1 = "11";
ret = patternMatch(pattern, 2, str1, strlen(str1), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const char* str2 = "41";
ret = patternMatch(pattern, 2, str2, strlen(str2), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const char* pattern3 = "%_";
const char* str3 = "88";
ret = patternMatch(pattern3, 2, str3, strlen(str3), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const char* pattern4 = "%___";
const char* str4 = "88";
ret = patternMatch(pattern4, 4, str4, strlen(str4), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_NOWILDCARDMATCH);
const char* pattern5 = "%___";
const char* str5 = "883391";
ret = patternMatch(pattern5, 4, str5, strlen(str5), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const char* pattern6 = "%___66";
const char* str6 = "88339166";
ret = patternMatch(pattern6, 6, str6, strlen(str6), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const char* pattern7 = "%____66";
const char* str7 = "66166";
ret = patternMatch(pattern7, 7, str7, strlen(str7), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_NOWILDCARDMATCH);
const char* pattern8 = "6%____66";
const char* str8 = "666166";
ret = patternMatch(pattern8, 8, str8, strlen(str8), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_NOWILDCARDMATCH);
const char* pattern9 = "6\\_6";
const char* str9 = "6_6";
ret = patternMatch(pattern9, 5, str9, strlen(str9), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const char* pattern10 = "%";
const char* str10 = " ";
ret = patternMatch(pattern10, 1, str10, 0, &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const char* pattern11 = "china%";
const char* str11 = "abc ";
ret = patternMatch(pattern11, 6, str11, 3, &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_NOMATCH);
const char* pattern12 = "abc%";
const char* str12 = NULL;
ret = patternMatch(pattern12, 4, str12, 0, &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_NOMATCH);
const char* pattern13 = "a\\%c";
const char* str13 = "a%c";
ret = patternMatch(pattern13, 5, str13, strlen(str13), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const char* pattern14 = "%a\\%c";
const char* str14 = "a%c";
ret = patternMatch(pattern14, strlen(pattern14), str14, strlen(str14), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const char* pattern15 = "_a\\%c";
const char* str15 = "ba%c";
ret = patternMatch(pattern15, strlen(pattern15), str15, strlen(str15), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const char* pattern16 = "_\\%c";
const char* str16 = "a%c";
ret = patternMatch(pattern16, strlen(pattern16), str16, strlen(str16), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const char* pattern17 = "_\\%c";
const char* str17 = "ba%c";
ret = patternMatch(pattern17, strlen(pattern17), str17, strlen(str17), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_NOMATCH);
const char* pattern18 = "%\\%c";
const char* str18 = "abc";
ret = patternMatch(pattern18, strlen(pattern18), str18, strlen(str18), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_NOWILDCARDMATCH);
const char* pattern19 = "%\\_c";
const char* str19 = "abc";
ret = patternMatch(pattern19, strlen(pattern19), str19, strlen(str19), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_NOWILDCARDMATCH);
}
TEST(utilTest, char_pattern_match_no_terminated) {
const char* pattern = "%1 ";
int32_t ret = 0;
SPatternCompareInfo pInfo = PATTERN_COMPARE_INFO_INITIALIZER;
const char* str0 = "14";
ret = patternMatch(pattern, 2, str0, strlen(str0), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_NOWILDCARDMATCH);
const char* str1 = "11";
ret = patternMatch(pattern, 2, str1, strlen(str1), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const char* str2 = "41";
ret = patternMatch(pattern, 2, str2, strlen(str2), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const char* pattern3 = "%_ ";
const char* str3 = "88";
ret = patternMatch(pattern3, 2, str3, strlen(str3), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const char* pattern4 = "%___ ";
const char* str4 = "88";
ret = patternMatch(pattern4, 4, str4, strlen(str4), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_NOWILDCARDMATCH);
const char* pattern5 = "%___ ";
const char* str5 = "883391";
ret = patternMatch(pattern5, 4, str5, strlen(str5), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const char* pattern6 = "%___66 ";
const char* str6 = "88339166";
ret = patternMatch(pattern6, 6, str6, strlen(str6), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const char* pattern7 = "%____66 ";
const char* str7 = "66166";
ret = patternMatch(pattern7, 7, str7, strlen(str7), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_NOWILDCARDMATCH);
const char* pattern8 = "6%____66 ";
const char* str8 = "666166";
ret = patternMatch(pattern8, 8, str8, strlen(str8), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_NOWILDCARDMATCH);
const char* pattern9 = "6\\_6 ";
const char* str9 = "6_6";
ret = patternMatch(pattern9, 4, str9, strlen(str9), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
const char* pattern10 = "% ";
const char* str10 = "6_6";
ret = patternMatch(pattern10, 1, str10, strlen(str10), &pInfo);
ASSERT_EQ(ret, TSDB_PATTERN_MATCH);
}
TEST(utilTest, tstrncspn) {
const char* p1 = "abc";
const char* reject = "d";
size_t v = tstrncspn(p1, strlen(p1), reject, 1);
ASSERT_EQ(v, 3);
const char* reject1 = "a";
v = tstrncspn(p1, strlen(p1), reject1, 1);
ASSERT_EQ(v, 0);
const char* reject2 = "de";
v = tstrncspn(p1, strlen(p1), reject2, 2);
ASSERT_EQ(v, 3);
const char* p2 = "abcdefghijklmn";
v = tstrncspn(p2, strlen(p2), reject2, 2);
ASSERT_EQ(v, 3);
const char* reject3 = "12345n";
v = tstrncspn(p2, strlen(p2), reject3, 6);
ASSERT_EQ(v, 13);
const char* reject4 = "";
v = tstrncspn(p2, strlen(p2), reject4, 0);
ASSERT_EQ(v, 14);
const char* reject5 = "911";
v = tstrncspn(p2, strlen(p2), reject5, 0);
ASSERT_EQ(v, 14);
const char* reject6 = "Kk";
v = tstrncspn(p2, strlen(p2), reject6, 2);
ASSERT_EQ(v, 10);
}
TEST(utilTest, intToHextStr) {
char buf[64] = {0};
int64_t v = 0;
tintToHex(0, buf);
ASSERT_STREQ(buf, "0");
v = 100000000;
tintToHex(v, buf);
char destBuf[128];
sprintf(destBuf, "%" PRIx64, v);
ASSERT_STREQ(buf, destBuf);
taosSeedRand(taosGetTimestampSec());
for(int32_t i = 0; i < 100000; ++i) {
memset(buf, 0, tListLen(buf));
memset(destBuf, 0, tListLen(destBuf));
v = taosRand();
tintToHex(v, buf);
sprintf(destBuf, "%" PRIx64, v);
ASSERT_STREQ(buf, destBuf);
}
}
static int64_t getIntervalValWithPrecision(int64_t interval, int8_t unit, int8_t precision) {
if (IS_CALENDAR_TIME_DURATION(unit)) {
return interval;
}
if(0 != getDuration(interval, unit, &interval, precision)) {
TD_ALWAYS_ASSERT(0);
}
return interval;
}
static bool tsmaIntervalCheck(int64_t baseInterval, int8_t baseUnit, int64_t interval, int8_t unit, int8_t precision) {
auto ret = checkRecursiveTsmaInterval(getIntervalValWithPrecision(baseInterval, baseUnit, precision), baseUnit,
getIntervalValWithPrecision(interval, unit, precision), unit, precision, true);
using namespace std;
cout << interval << unit << " on " << baseInterval << baseUnit << ": " << ret << endl;
return ret;
}
TEST(tsma, reverse_unit) {
ASSERT_TRUE(tsmaIntervalCheck(1, 'm', 120, 's', TSDB_TIME_PRECISION_MILLI));
ASSERT_TRUE(tsmaIntervalCheck(1, 'h', 120, 'm', TSDB_TIME_PRECISION_MILLI));
ASSERT_TRUE(tsmaIntervalCheck(20, 's', 2 * 20 * 1000, 'a', TSDB_TIME_PRECISION_MILLI));
ASSERT_TRUE(tsmaIntervalCheck(20, 's', 2 * 20 * 1000 * 1000, 'u', TSDB_TIME_PRECISION_MILLI));
ASSERT_TRUE(tsmaIntervalCheck(20, 's', 2UL * 20UL * 1000UL * 1000UL * 1000UL, 'b', TSDB_TIME_PRECISION_MILLI));
ASSERT_FALSE(tsmaIntervalCheck(1, 'h', 60, 'm', TSDB_TIME_PRECISION_MILLI));
ASSERT_FALSE(tsmaIntervalCheck(1, 'h', 6, 'm', TSDB_TIME_PRECISION_MILLI));
ASSERT_FALSE(tsmaIntervalCheck(2, 'h', 120, 'm', TSDB_TIME_PRECISION_MILLI));
ASSERT_TRUE(tsmaIntervalCheck(2, 'h', 240, 'm', TSDB_TIME_PRECISION_MILLI));
ASSERT_FALSE(tsmaIntervalCheck(1, 'd', 240, 'm', TSDB_TIME_PRECISION_MILLI));
ASSERT_FALSE(tsmaIntervalCheck(1, 'd', 1440, 'm', TSDB_TIME_PRECISION_MILLI));
ASSERT_TRUE(tsmaIntervalCheck(1, 'd', 2880, 'm', TSDB_TIME_PRECISION_MILLI));
ASSERT_FALSE(tsmaIntervalCheck(1, 'y', 365, 'd', TSDB_TIME_PRECISION_MILLI));
ASSERT_FALSE(tsmaIntervalCheck(1, 'n', 30, 'd', TSDB_TIME_PRECISION_MILLI));
ASSERT_TRUE(tsmaIntervalCheck(1, 'y', 24, 'n', TSDB_TIME_PRECISION_MILLI));
ASSERT_FALSE(tsmaIntervalCheck(55, 's', 55, 'm', TSDB_TIME_PRECISION_MILLI));
ASSERT_TRUE(tsmaIntervalCheck(10, 's', 1, 'm', TSDB_TIME_PRECISION_MICRO));
ASSERT_TRUE(tsmaIntervalCheck(10, 's', 2, 'm', TSDB_TIME_PRECISION_MICRO));
ASSERT_TRUE(tsmaIntervalCheck(10, 's', 20, 'm', TSDB_TIME_PRECISION_MICRO));
ASSERT_TRUE(tsmaIntervalCheck(10, 's', 50, 'm', TSDB_TIME_PRECISION_MICRO));
ASSERT_TRUE(tsmaIntervalCheck(120, 's', 30, 'm', TSDB_TIME_PRECISION_MICRO));
ASSERT_TRUE(tsmaIntervalCheck(360, 's', 30, 'm', TSDB_TIME_PRECISION_MICRO));
ASSERT_TRUE(tsmaIntervalCheck(600, 's', 30, 'm', TSDB_TIME_PRECISION_MICRO));
ASSERT_FALSE(tsmaIntervalCheck(600, 's', 15, 'm', TSDB_TIME_PRECISION_MICRO));
ASSERT_TRUE(tsmaIntervalCheck(10, 's', 1, 'h', TSDB_TIME_PRECISION_MICRO));
ASSERT_TRUE(tsmaIntervalCheck(15, 's', 1, 'h', TSDB_TIME_PRECISION_MICRO));
ASSERT_FALSE(tsmaIntervalCheck(7*60, 's', 1, 'h', TSDB_TIME_PRECISION_MICRO));
ASSERT_TRUE(tsmaIntervalCheck(10, 's', 1, 'd', TSDB_TIME_PRECISION_MICRO));
ASSERT_TRUE(tsmaIntervalCheck(10, 's', 1, 'w', TSDB_TIME_PRECISION_MICRO));
ASSERT_TRUE(tsmaIntervalCheck(1, 'd', 1, 'w', TSDB_TIME_PRECISION_MICRO));
ASSERT_TRUE(tsmaIntervalCheck(10, 's', 1, 'n', TSDB_TIME_PRECISION_MICRO));
ASSERT_TRUE(tsmaIntervalCheck(10, 's', 1, 'y', TSDB_TIME_PRECISION_MICRO));
ASSERT_TRUE(tsmaIntervalCheck(1, 'd', 1, 'w', TSDB_TIME_PRECISION_MICRO));
ASSERT_TRUE(tsmaIntervalCheck(1, 'd', 1, 'n', TSDB_TIME_PRECISION_MICRO));
ASSERT_TRUE(tsmaIntervalCheck(1, 'd', 2, 'n', TSDB_TIME_PRECISION_MICRO));
ASSERT_FALSE(tsmaIntervalCheck(2, 'd', 2, 'n', TSDB_TIME_PRECISION_MICRO));
ASSERT_FALSE(tsmaIntervalCheck(2, 'd', 2, 'y', TSDB_TIME_PRECISION_MICRO));
ASSERT_FALSE(tsmaIntervalCheck(2, 'd', 1, 'y', TSDB_TIME_PRECISION_MICRO));
ASSERT_FALSE(tsmaIntervalCheck(1, 'w', 1, 'n', TSDB_TIME_PRECISION_NANO));
ASSERT_FALSE(tsmaIntervalCheck(4, 'w', 1, 'n', TSDB_TIME_PRECISION_NANO));
ASSERT_FALSE(tsmaIntervalCheck(1, 'w', 1, 'y', TSDB_TIME_PRECISION_NANO));
ASSERT_TRUE(tsmaIntervalCheck(1, 'n', 1, 'y', TSDB_TIME_PRECISION_NANO));
ASSERT_TRUE(tsmaIntervalCheck(2, 'n', 1, 'y', TSDB_TIME_PRECISION_NANO));
ASSERT_TRUE(tsmaIntervalCheck(3, 'n', 1, 'y', TSDB_TIME_PRECISION_NANO));
ASSERT_TRUE(tsmaIntervalCheck(4, 'n', 1, 'y', TSDB_TIME_PRECISION_NANO));
ASSERT_FALSE(tsmaIntervalCheck(5, 'n', 1, 'y', TSDB_TIME_PRECISION_NANO));
ASSERT_TRUE(tsmaIntervalCheck(6, 'n', 1, 'y', TSDB_TIME_PRECISION_NANO));
ASSERT_FALSE(tsmaIntervalCheck(7, 'n', 1, 'y', TSDB_TIME_PRECISION_NANO));
ASSERT_FALSE(tsmaIntervalCheck(8, 'n', 1, 'y', TSDB_TIME_PRECISION_NANO));
ASSERT_FALSE(tsmaIntervalCheck(9, 'n', 1, 'y', TSDB_TIME_PRECISION_NANO));
ASSERT_FALSE(tsmaIntervalCheck(10, 'n', 1, 'y', TSDB_TIME_PRECISION_NANO));
ASSERT_FALSE(tsmaIntervalCheck(11, 'n', 1, 'y', TSDB_TIME_PRECISION_NANO));
ASSERT_FALSE(tsmaIntervalCheck(1, 'w', 1, 'w', TSDB_TIME_PRECISION_NANO));
ASSERT_FALSE(tsmaIntervalCheck(120, 's', 2, 'm', TSDB_TIME_PRECISION_NANO));
ASSERT_FALSE(tsmaIntervalCheck(2, 'n', 2, 'n', TSDB_TIME_PRECISION_NANO));
ASSERT_FALSE(tsmaIntervalCheck(2, 'y', 2, 'y', TSDB_TIME_PRECISION_NANO));
ASSERT_FALSE(tsmaIntervalCheck(12, 'n', 1, 'y', TSDB_TIME_PRECISION_NANO));
ASSERT_TRUE(tsmaIntervalCheck(3, 'n', 1, 'y', TSDB_TIME_PRECISION_NANO));
}
template <int16_t type, typename ValType, typename F>
void dataBlockNullTest(const F& setValFunc) {
int32_t totalRows = 16;
SColumnInfoData columnInfoData = createColumnInfoData(type, tDataTypes[type].bytes, 0);
SColumnDataAgg columnDataAgg = {}; // zero-init (numOfNull = 0)
std::function<void(uint32_t, bool)> checkNull = [totalRows, &columnInfoData, &columnDataAgg](uint32_t row, bool expected) {
EXPECT_EQ(colDataIsNull_s(&columnInfoData, row), expected);
EXPECT_EQ(colDataIsNull_t(&columnInfoData, row, IS_VAR_DATA_TYPE(columnInfoData.info.type)), expected);
EXPECT_EQ(colDataIsNull(&columnInfoData, totalRows, row, NULL), expected);
columnDataAgg.numOfNull = totalRows;
EXPECT_EQ(colDataIsNull(&columnInfoData, totalRows, row, &columnDataAgg), columnInfoData.hasNull);
columnDataAgg.numOfNull = 0;
EXPECT_EQ(colDataIsNull(&columnInfoData, totalRows, row, &columnDataAgg), false);
};
columnInfoData.hasNull = false;
checkNull(0, false);
checkNull(1, false);
checkNull(2, false);
checkNull(totalRows - 2, false);
checkNull(totalRows - 1, false);
if (IS_VAR_DATA_TYPE(type)) {
columnInfoData.varmeta.offset = (int32_t*)taosMemoryCalloc(totalRows, sizeof(int32_t));
} else {
columnInfoData.pData = (char*)taosMemoryCalloc(totalRows, tDataTypes[type].bytes);
columnInfoData.nullbitmap = (char*)taosMemoryCalloc(((totalRows - 1) >> NBIT) + 1, 1);
ValType val = 1;
setValFunc(&columnInfoData, 1, &val);
val = 2;
setValFunc(&columnInfoData, 2, &val);
}
colDataSetNULL(&columnInfoData, 0);
colDataSetNNULL(&columnInfoData, 3, totalRows - 3);
checkNull(0, true);
// Ethan liu changed the expected value of a varchar type from false to true due to the change of colDataIsNull_s
// function, which now returns true if the pData is null of the SColumnInfoData.
// Same to the fix of TS-6908, when columnInfoData created, the pData default value is null.
// When offset of varmeta created, the offset default value is 0. Without any data set to the columnInfoData, we should consider it null
// so that the colDataIsNull_s function should return true.
if( IS_VAR_DATA_TYPE(type)) {
checkNull(1, true);
checkNull(2, true);
} else {
checkNull(1, false);
checkNull(2, false);
}
checkNull(totalRows - 2, true);
checkNull(totalRows - 1, true);
if (IS_VAR_DATA_TYPE(type)) {
taosMemoryFreeClear(columnInfoData.varmeta.offset);
} else {
taosMemoryFreeClear(columnInfoData.pData);
taosMemoryFreeClear(columnInfoData.nullbitmap);
checkNull(0, false);
checkNull(1, false);
checkNull(2, false);
checkNull(totalRows - 2, false);
checkNull(totalRows - 1, false);
}
}
TEST(utilTest, tdatablockTestNull) {
dataBlockNullTest<TSDB_DATA_TYPE_TINYINT, int8_t>(colDataSetInt8);
dataBlockNullTest<TSDB_DATA_TYPE_SMALLINT, int16_t>(colDataSetInt16);
dataBlockNullTest<TSDB_DATA_TYPE_INT, int32_t>(colDataSetInt32);
dataBlockNullTest<TSDB_DATA_TYPE_BIGINT, int64_t>(colDataSetInt64);
dataBlockNullTest<TSDB_DATA_TYPE_FLOAT, float>(colDataSetFloat);
dataBlockNullTest<TSDB_DATA_TYPE_DOUBLE, double>(colDataSetDouble);
dataBlockNullTest<TSDB_DATA_TYPE_VARCHAR, int64_t>(colDataSetInt64);
}
void dispatchWorkerFp(SQueueInfo* pQInfo, void* pMsg) {
int32_t idx = *(int32_t*)pMsg;
SDispatchWorkerPool *pPool = (SDispatchWorkerPool*)pQInfo->ahandle;
ASSERT_EQ(pQInfo->workerId, idx % pPool->num);
std::cout << "idx: " << idx << " is dispatched to worker: " << pQInfo->workerId << " idx % pPool.num: " << idx % pPool->num << std::endl;
taosFreeQitem(pMsg);
}
int32_t dispatchFp(SDispatchWorkerPool* pPool, void* pParam, int32_t* pWorkerIdx) {
*pWorkerIdx = *(int32_t*)pParam % pPool->num;
return 0;
}
TEST(dispatchWorker, a) {
tsQueueMemoryAllowed = 102400;
SDispatchWorkerPool pool{};
pool.max = 4;
pool.name = "dispatchWorker-test";
ASSERT_EQ(0, tDispatchWorkerInit(&pool));
ASSERT_EQ(0, tDispatchWorkerAllocQueue(&pool, &pool, dispatchWorkerFp, dispatchFp));
int32_t idx = 0;
EQItype itype = RPC_QITEM;
void* qitem = NULL;
for (; idx < 100; ++idx) {
ASSERT_EQ(0, taosAllocateQitem(sizeof(int32_t), itype, 0, (void **)&qitem));
memcpy(qitem, &idx, sizeof(int32_t));
ASSERT_EQ(0, tAddTaskIntoDispatchWorkerPool(&pool, qitem));
}
tDispatchWorkerCleanup(&pool);
}
Reference in a new issue View git blame Copy permalink