TDengine/source/util/test/utilTests.cpp

#include <gtest/gtest.h>
#include <stdlib.h>
#include <tutil.h>
#include <random>
#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 = {.numOfNull = 0};

  auto 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);
}