242 lines
8.1 KiB
C++
242 lines
8.1 KiB
C++
/**
|
|
* Copyright (c) 2021 OceanBase
|
|
* OceanBase CE is licensed under Mulan PubL v2.
|
|
* You can use this software according to the terms and conditions of the Mulan PubL v2.
|
|
* You may obtain a copy of Mulan PubL v2 at:
|
|
* http://license.coscl.org.cn/MulanPubL-2.0
|
|
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
|
|
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
|
|
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
|
|
* See the Mulan PubL v2 for more details.
|
|
*/
|
|
|
|
#include <gtest/gtest.h>
|
|
#include <stdint.h>
|
|
#include "lib/ob_define.h"
|
|
#include "lib/time/ob_time_utility.h"
|
|
|
|
using namespace oceanbase;
|
|
using namespace oceanbase::common;
|
|
|
|
class ObTimeUtilityTest: public ::testing::Test
|
|
{
|
|
public:
|
|
ObTimeUtilityTest();
|
|
virtual ~ObTimeUtilityTest();
|
|
virtual void SetUp();
|
|
virtual void TearDown();
|
|
private:
|
|
// disallow copy
|
|
ObTimeUtilityTest(const ObTimeUtilityTest &other);
|
|
ObTimeUtilityTest& operator=(const ObTimeUtilityTest &other);
|
|
protected:
|
|
// data members
|
|
};
|
|
|
|
ObTimeUtilityTest::ObTimeUtilityTest()
|
|
{
|
|
}
|
|
|
|
ObTimeUtilityTest::~ObTimeUtilityTest()
|
|
{
|
|
}
|
|
|
|
void ObTimeUtilityTest::SetUp()
|
|
{
|
|
}
|
|
|
|
void ObTimeUtilityTest::TearDown()
|
|
{
|
|
}
|
|
|
|
TEST(ObTimeUtilityTest, str_to_date_test)
|
|
{
|
|
struct tm t;
|
|
int64_t usec = 0;
|
|
const char *date_ptr = "1970-02-03 07:08:09.12";
|
|
const char *format_ptr = "%Y-%m-%d %k:%i:%S.%f";
|
|
ASSERT_EQ(OB_SUCCESS, ObTimeUtility::str_format_to_timestamp(ObString::make_string(date_ptr),
|
|
ObString::make_string(format_ptr), t, usec));
|
|
printf("date: %04d-%02d-%02d %02d:%02d:%02d.%06ld\n",
|
|
t.tm_year + 1900, t.tm_mon + 1, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec, usec);
|
|
date_ptr = "13/02/17";
|
|
format_ptr = "%y/%m/%d";
|
|
ASSERT_EQ(OB_NOT_SUPPORTED, ObTimeUtility::str_format_to_timestamp(ObString::make_string(date_ptr),
|
|
ObString::make_string(format_ptr), t, usec));
|
|
// ASSERT_EQ(2013, t.tm_year + 1900);
|
|
// ASSERT_EQ(2, t.tm_mon + 1);
|
|
// ASSERT_EQ(17, t.tm_mday);
|
|
|
|
date_ptr = "1970-01-01 08:00:01";
|
|
format_ptr = "%Y-%m-%d %k:%i:%S";
|
|
ASSERT_EQ(OB_SUCCESS, ObTimeUtility::str_format_to_usec(ObString::make_string(date_ptr),
|
|
ObString::make_string(format_ptr), usec));
|
|
ASSERT_EQ(1000L * 1000L, usec);
|
|
}
|
|
|
|
TEST(ObTimeUtilityTest, str_to_timestamp_test)
|
|
{
|
|
struct tm t;
|
|
int64_t usec = 0;
|
|
const char *date_ptr = "1970-02-03 07:08:09.12";
|
|
ASSERT_EQ(OB_SUCCESS, ObTimeUtility::str_to_timestamp(ObString::make_string(date_ptr), t, usec));
|
|
printf("date: %04d-%02d-%02d %02d:%02d:%02d.%06ld\n",
|
|
t.tm_year + 1900, t.tm_mon + 1, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec, usec);
|
|
date_ptr = "1970^^02***03&&&07:08:09->12";
|
|
ASSERT_EQ(OB_SUCCESS, ObTimeUtility::str_to_timestamp(ObString::make_string(date_ptr), t, usec));
|
|
printf("date: %04d-%02d-%02d %02d:%02d:%02d.%06ld\n",
|
|
t.tm_year + 1900, t.tm_mon + 1, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec, usec);
|
|
}
|
|
|
|
TEST(ObTimeUtilityTest, str_dateunit_to_timestamp_test)
|
|
{
|
|
int64_t usec = 0;
|
|
const char *str = "12";
|
|
struct tm t;
|
|
|
|
ASSERT_EQ(OB_SUCCESS, ObTimeUtility::str_dateunit_to_timestamp(ObString::make_string(str),
|
|
DATE_UNIT_MICROSECOND, t, usec));
|
|
ASSERT_EQ(12, usec);
|
|
|
|
str = "1";
|
|
ASSERT_EQ(OB_SUCCESS, ObTimeUtility::str_dateunit_to_timestamp(ObString::make_string(str),
|
|
DATE_UNIT_DAY, t, usec));
|
|
ASSERT_EQ(1 * 1000L * 1000L * 60L * 60L * 24L, usec);
|
|
|
|
str = "21-25";
|
|
ASSERT_EQ(OB_SUCCESS, ObTimeUtility::str_dateunit_to_timestamp(ObString::make_string(str),
|
|
DATE_UNIT_YEAR_MONTH, t, usec));
|
|
ASSERT_EQ(21, t.tm_year);
|
|
ASSERT_EQ(25, t.tm_mon);
|
|
}
|
|
|
|
TEST(ObTimeUtilityTest, date_format_test)
|
|
{
|
|
const char *date = "2013-01-01 22:23:00";
|
|
const char *format = "%U %V %X";
|
|
char buf[1024] = {'\0'};
|
|
int64_t pos = 0;
|
|
int64_t usec = 0;
|
|
|
|
ASSERT_EQ(OB_SUCCESS, ObTimeUtility::str_to_usec(ObString::make_string(date), usec));
|
|
ASSERT_EQ(OB_SUCCESS, ObTimeUtility::usec_format_to_str(usec, ObString::make_string(format), buf, 1024, pos));
|
|
printf("buf: %s\n", buf);
|
|
ASSERT_STREQ("00 53 2012", buf);
|
|
format = "%c %d %e %f %H %h %I %i %j %k %l %m %p %r %S %s %T %U %u %V %v %w %X %x %Y %y %%";
|
|
pos = 0;
|
|
ASSERT_EQ(OB_SUCCESS, ObTimeUtility::usec_format_to_str(usec, ObString::make_string(format), buf, 1024, pos));
|
|
buf[pos] = '\0';
|
|
printf("date: %s, buf: %s\n", date, buf);
|
|
ASSERT_STREQ("1 01 1 000000 22 10 10 23 001 22 10 01 PM 10:23:00 PM 00 00 22:23:00 00 01 53 01 2 2012 2013 2013 13 %", buf);
|
|
}
|
|
|
|
#define T_WEEK(today, wday, flag_mask, result) \
|
|
{ \
|
|
struct tm t; \
|
|
t.tm_yday = today - 1; \
|
|
t.tm_wday = wday; \
|
|
ASSERT_EQ(result, ObTimeUtility::get_weeks_of_year(t, flag_mask)); \
|
|
}
|
|
|
|
#define T_WEEK_CHECK_YEAR(today, wday, year, flag_mask, week_count, r_year) \
|
|
{ \
|
|
struct tm t; \
|
|
t.tm_year = year - 1900; \
|
|
t.tm_yday = today - 1; \
|
|
t.tm_wday = wday; \
|
|
ASSERT_EQ(week_count, ObTimeUtility::get_weeks_of_year(t, flag_mask)); \
|
|
ASSERT_EQ(r_year, t.tm_year + 1900); \
|
|
}
|
|
|
|
TEST(ObTimeUtilityTest, get_weeks_of_year_test)
|
|
{
|
|
//'%U'
|
|
T_WEEK(1, 0, START_WITH_SUNDAY | WEEK_FIRST_WEEKDAY, 1);
|
|
T_WEEK(1, 3, START_WITH_SUNDAY | WEEK_FIRST_WEEKDAY, 0);
|
|
T_WEEK(8, 4, START_WITH_SUNDAY | WEEK_FIRST_WEEKDAY, 1);
|
|
T_WEEK(32, 6, START_WITH_SUNDAY | WEEK_FIRST_WEEKDAY, 4);
|
|
//'%u'
|
|
T_WEEK(1, 0, 0, 0);
|
|
T_WEEK(1, 1, 0, 1);
|
|
T_WEEK(8, 4, 0, 2);
|
|
T_WEEK(32, 6, 0, 5);
|
|
T_WEEK(1, 3, 0, 1);
|
|
//'%V'
|
|
T_WEEK_CHECK_YEAR(1, 0, 2014, START_WITH_SUNDAY | WEEK_FIRST_WEEKDAY | INCLUDE_CRITICAL_WEEK, 1, 2014);
|
|
T_WEEK_CHECK_YEAR(1, 3, 2014, START_WITH_SUNDAY | WEEK_FIRST_WEEKDAY | INCLUDE_CRITICAL_WEEK, 52, 2013);
|
|
T_WEEK_CHECK_YEAR(32, 6, 2014, START_WITH_SUNDAY | WEEK_FIRST_WEEKDAY | INCLUDE_CRITICAL_WEEK, 4, 2014);
|
|
T_WEEK_CHECK_YEAR(365, 2, 2013, START_WITH_SUNDAY | WEEK_FIRST_WEEKDAY | INCLUDE_CRITICAL_WEEK, 52, 2013);
|
|
//'%v'
|
|
T_WEEK_CHECK_YEAR(1, 3, 2014, INCLUDE_CRITICAL_WEEK, 1, 2014);
|
|
T_WEEK_CHECK_YEAR(365, 2, 2013, INCLUDE_CRITICAL_WEEK, 1, 2014);
|
|
T_WEEK_CHECK_YEAR(1, 0, 2012, INCLUDE_CRITICAL_WEEK, 52, 2011);
|
|
T_WEEK_CHECK_YEAR(32, 6, 2014, INCLUDE_CRITICAL_WEEK, 5, 2014);
|
|
T_WEEK_CHECK_YEAR(365, 0, 2023, INCLUDE_CRITICAL_WEEK, 52, 2023);
|
|
}
|
|
|
|
TEST(ObTimeUtilityTest, extract_usec_test1)
|
|
{
|
|
int64_t usec = 0;
|
|
const char *str = "12";
|
|
|
|
ASSERT_EQ(OB_SUCCESS, ObTimeUtility::extract_usec(ObString::make_string(str), usec));
|
|
ASSERT_EQ(120000, usec);
|
|
}
|
|
|
|
TEST(ObTimeUtilityTest, extract_usec_test2)
|
|
{
|
|
int64_t pos = 0;
|
|
int64_t usec = 0;
|
|
ASSERT_EQ(OB_SUCCESS, ObTimeUtility::extract_usec(ObString::make_string("123"), pos, usec, ObTimeUtility::DIGTS_INSENSITIVE));
|
|
ASSERT_EQ(123000, usec);
|
|
}
|
|
|
|
TEST(ObTimeUtilityTest, extract_usec_reverse_test)
|
|
{
|
|
int64_t pos = strlen("123") - 1;
|
|
int64_t usec = 0;
|
|
ASSERT_EQ(OB_SUCCESS, ObTimeUtility::extract_usec_reverse(ObString::make_string("123"), pos, usec));
|
|
ASSERT_EQ(123000, usec);
|
|
}
|
|
|
|
TEST(ObTimeUtilityTest, extract_date_test)
|
|
{
|
|
int64_t pos = 0;
|
|
int64_t date = 0;
|
|
ASSERT_EQ(OB_SUCCESS, ObTimeUtility::extract_date(ObString::make_string("123"), 0, pos, date));
|
|
ASSERT_EQ(123, date);
|
|
}
|
|
|
|
TEST(ObTimeUtilityTest, extract_date_reverse_test)
|
|
{
|
|
int64_t pos = strlen("123") - 1;
|
|
int64_t date = 0;
|
|
ASSERT_EQ(OB_SUCCESS, ObTimeUtility::extract_date_reverse(ObString::make_string("123"), 0, pos, date));
|
|
ASSERT_EQ(123, date);
|
|
}
|
|
|
|
TEST(ObTimeUtilityTest, is_valid_date_test)
|
|
{
|
|
ASSERT_TRUE(ObTimeUtility::is_valid_date(2013, 12, 23));
|
|
ASSERT_FALSE(ObTimeUtility::is_valid_date(2013, 2, 29));
|
|
ASSERT_TRUE(ObTimeUtility::is_valid_date(2012, 2, 29));
|
|
ASSERT_FALSE(ObTimeUtility::is_valid_date(1900, 2, 29));
|
|
ASSERT_FALSE(ObTimeUtility::is_valid_date(2013, 1, 32));
|
|
ASSERT_TRUE(ObTimeUtility::is_valid_date(2013, 3, 31));
|
|
ASSERT_TRUE(ObTimeUtility::is_valid_date(2013, 5, 31));
|
|
ASSERT_TRUE(ObTimeUtility::is_valid_date(2013, 7, 31));
|
|
ASSERT_TRUE(ObTimeUtility::is_valid_date(2013, 8, 31));
|
|
ASSERT_TRUE(ObTimeUtility::is_valid_date(2013, 10, 31));
|
|
ASSERT_TRUE(ObTimeUtility::is_valid_date(2013, 12, 31));
|
|
ASSERT_FALSE(ObTimeUtility::is_valid_date(2013, 4, 31));
|
|
ASSERT_FALSE(ObTimeUtility::is_valid_date(2013, 6, 31));
|
|
ASSERT_FALSE(ObTimeUtility::is_valid_date(2013, 9, 31));
|
|
ASSERT_FALSE(ObTimeUtility::is_valid_date(2013, 11, 31));
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
::testing::InitGoogleTest(&argc,argv);
|
|
return RUN_ALL_TESTS();
|
|
}
|