// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

#include "runtime/datetime_value.h"

#include <string>

#include <gtest/gtest.h>

#include "common/logging.h"
#include "util/logging.h"

namespace doris {

class DateTimeValueTest : public testing::Test {
public:
    DateTimeValueTest() {
        TimezoneDatabase::init();
    }

protected:
    virtual void SetUp() {
    }
    virtual void TearDown() {
    }
};

// Assert size
TEST_F(DateTimeValueTest, struct_size) {
    ASSERT_EQ(16, sizeof(DateTimeValue));
}

TEST_F(DateTimeValueTest, equal) {
    DateTimeValue value1;
    value1.from_date_int64(19880201);
    DateTimeValue value2;

    value2.from_date_int64(19880201);
    ASSERT_TRUE(value1 == value2);
    ASSERT_TRUE(value1 <= value2);
    ASSERT_TRUE(value1 >= value2);
    ASSERT_FALSE(value1 < value2);
    ASSERT_FALSE(value1 > value2);

    value2.from_date_int64(19880201000000);
    ASSERT_TRUE(value1 == value2);
    ASSERT_TRUE(value1 <= value2);
    ASSERT_TRUE(value1 >= value2);
    ASSERT_FALSE(value1 < value2);
    ASSERT_FALSE(value1 > value2);

    value2.from_date_int64(19880202);
    ASSERT_TRUE(value1 != value2);
    ASSERT_TRUE(value1 <= value2);
    ASSERT_TRUE(value1 < value2);
    ASSERT_FALSE(value1 >= value2);
    ASSERT_FALSE(value1 > value2);

    value2.from_date_int64(19880131);
    ASSERT_TRUE(value1 != value2);
    ASSERT_TRUE(value1 > value2);
    ASSERT_TRUE(value1 >= value2);
    ASSERT_FALSE(value1 < value2);
    ASSERT_FALSE(value1 <= value2);

    std::string test_str = "1988-02-01 00:00:00.12345";
    value2.from_date_str(test_str.c_str(), test_str.size());
    ASSERT_TRUE(value1 != value2);
    ASSERT_TRUE(value1 < value2);
    ASSERT_TRUE(value1 <= value2);
    ASSERT_FALSE(value1 > value2);
    ASSERT_FALSE(value1 >= value2);
}

// Test check range
TEST_F(DateTimeValueTest, day_of_year) {
    DateTimeValue value;
    value.from_date_int64(20070101);
    ASSERT_EQ(1, value.day_of_year());
    value.from_date_int64(20070203);
    ASSERT_EQ(34, value.day_of_year());
}

// Test check range
TEST_F(DateTimeValueTest, random_convert) {
    char buf[64];

    for (int i = 0; i < 64; ++i) {
        buf[i] = '0' + i % 10;
    }

    DateTimeValue value_check;

    DateTimeValue *value = (DateTimeValue*)buf;
    value->from_date_daynr(366);
    value_check.from_date_daynr(366);
    ASSERT_STREQ("0001-01-01", value->debug_string().c_str());
    ASSERT_FALSE(memcmp(value, &value_check, sizeof(value_check)));

    value = (DateTimeValue*)&buf[5];
    value->from_date_str("19880201", 8);
    value_check.from_date_str("19880201", 8);
    ASSERT_STREQ("1988-02-01", value->debug_string().c_str());
    ASSERT_FALSE(memcmp(value, &value_check, sizeof(value_check)));

    value = (DateTimeValue*)&buf[10];
    value->from_date_format_str("%Y%m%d", 6, "19880201", 8);
    value_check.from_date_format_str("%Y%m%d", 6, "19880201", 8);
    ASSERT_STREQ("1988-02-01", value->debug_string().c_str());
    ASSERT_FALSE(memcmp(value, &value_check, sizeof(value_check)));

    value = (DateTimeValue*)&buf[15];
    value->from_date_int64(19880201);
    value_check.from_date_int64(19880201);
    ASSERT_STREQ("1988-02-01", value->debug_string().c_str());
    ASSERT_FALSE(memcmp(value, &value_check, sizeof(value_check)));

    value = (DateTimeValue*)&buf[20];
    value->from_olap_datetime(19880201235959);
    value_check.from_date_int64(19880201235959);
    ASSERT_STREQ("1988-02-01 23:59:59", value->debug_string().c_str());
    ASSERT_FALSE(memcmp(value, &value_check, sizeof(value_check)));

    value = (DateTimeValue*)&buf[30];
    uint64_t date = 0;
    date = 1988;
    date <<= 4;
    date |= 2;
    date <<= 5;
    date |= 1;
    value->from_olap_date(date);
    value_check.from_date_int64(19880201);
    ASSERT_STREQ("1988-02-01", value->debug_string().c_str());
    ASSERT_FALSE(memcmp(value, &value_check, sizeof(value_check)));
}

// Test check range
TEST_F(DateTimeValueTest, construct_int64) {
    char buf[64];

    DateTimeValue value;
    value.from_date_int64(19880201);

    DateTimeValue value1(19880201);
    value1.to_string(buf);
    ASSERT_STREQ("1988-02-01", buf);
    ASSERT_TRUE(value == value1);

    value.from_date_int64(19880201123456);
    DateTimeValue value2(19880201123456);
    value2.to_string(buf);
    ASSERT_STREQ("1988-02-01 12:34:56", buf);
    ASSERT_TRUE(value == value2);
}

// Test check range
TEST_F(DateTimeValueTest, acc) {
    DateTimeValue value;
    char buf[64];

    value.from_date_int64(19880201);
    ++value;
    value.to_string(buf);
    ASSERT_STREQ("1988-02-02", buf);

    value.from_date_int64(19880131235959);
    value.to_string(buf);
    ASSERT_STREQ("1988-01-31 23:59:59", buf);
    ++value;
    value.to_string(buf);
    ASSERT_STREQ("1988-02-01 00:00:00", buf);
}

// Test check range
TEST_F(DateTimeValueTest, local_time) {
    DateTimeValue value = DateTimeValue::local_time();
    LOG(INFO) << value.debug_string();
}

// Test check range
TEST_F(DateTimeValueTest, check_range) {
    DateTimeValue value;
    value.from_date_int64(19880201123456);
    ASSERT_FALSE(value.check_range());
    
    value._year = 10000;
    ASSERT_TRUE(value.check_range());
    value._year = 1988;

    value._month = 13;
    ASSERT_TRUE(value.check_range());
    value._month = 2;

    value._day = 32;
    ASSERT_TRUE(value.check_range());
    value._day = 1;

    value._hour = TIME_MAX_HOUR;
    ASSERT_TRUE(value.check_range());
    value._type = TIME_TIME;
    ASSERT_FALSE(value.check_range());
    value._hour = TIME_MAX_HOUR + 1;
    ASSERT_TRUE(value.check_range());
    value._type = TIME_DATETIME;
    value._hour = 12;

    value._minute = 60;
    ASSERT_TRUE(value.check_range());
    value._minute = 34;

    value._second = 60;
    ASSERT_TRUE(value.check_range());
    value._second = 56;

    value._microsecond = 1000000;
    ASSERT_TRUE(value.check_range());
    value._month = 0;
}

TEST_F(DateTimeValueTest, check_date) {
    DateTimeValue value;
    ASSERT_TRUE(value.from_date_int64(19880201));

    value._month = 0;
    ASSERT_TRUE(value.check_date());
    value._month = 2;

    value._day = 0;
    ASSERT_TRUE(value.check_date());
    value._year = 1987;
    value._day = 29;
    ASSERT_TRUE(value.check_date());
    value._year = 2000;
    ASSERT_FALSE(value.check_date());
}

// Calculate format
TEST_F(DateTimeValueTest, week) {
    std::string date_str;
    DateTimeValue value;

    // 0000-01-01
    date_str = "0000-01-01";
    value.from_date_str(date_str.c_str(), date_str.size());
    ASSERT_EQ(1, value.week(mysql_week_mode(0)));
    ASSERT_EQ(0, value.week(mysql_week_mode(1)));
    ASSERT_EQ(1, value.week(mysql_week_mode(2)));
    ASSERT_EQ(52, value.week(mysql_week_mode(3)));
    ASSERT_EQ(1, value.week(mysql_week_mode(4)));
    ASSERT_EQ(0, value.week(mysql_week_mode(5)));
    ASSERT_EQ(1, value.week(mysql_week_mode(6)));
    ASSERT_EQ(52, value.week(mysql_week_mode(7)));

    // 2013-12-31
    date_str = "2013-12-31";
    value.from_date_str(date_str.c_str(), date_str.size());
    ASSERT_EQ(52, value.week(mysql_week_mode(0)));
    ASSERT_EQ(53, value.week(mysql_week_mode(1)));
    ASSERT_EQ(52, value.week(mysql_week_mode(2)));
    ASSERT_EQ(1, value.week(mysql_week_mode(3)));
    ASSERT_EQ(53, value.week(mysql_week_mode(4)));
    ASSERT_EQ(52, value.week(mysql_week_mode(5)));
    ASSERT_EQ(1, value.week(mysql_week_mode(6)));
    ASSERT_EQ(52, value.week(mysql_week_mode(7)));

    // 1988-02-01
    date_str = "1988-02-01";
    value.from_date_str(date_str.c_str(), date_str.size());
    ASSERT_EQ(5, value.week(mysql_week_mode(0)));
    ASSERT_EQ(5, value.week(mysql_week_mode(1)));
    ASSERT_EQ(5, value.week(mysql_week_mode(2)));
    ASSERT_EQ(5, value.week(mysql_week_mode(3)));
    ASSERT_EQ(5, value.week(mysql_week_mode(4)));
    ASSERT_EQ(5, value.week(mysql_week_mode(5)));
    ASSERT_EQ(5, value.week(mysql_week_mode(6)));
    ASSERT_EQ(5, value.week(mysql_week_mode(7)));
}

// Calculate format
TEST_F(DateTimeValueTest, from_unixtime) {
    char str[MAX_DTVALUE_STR_LEN];
    DateTimeValue value;

    value.from_unixtime(570672000, TimezoneDatabase::default_time_zone);
    value.to_string(str);
    ASSERT_STREQ("1988-02-01 08:00:00", str);
    
    value.from_unixtime(253402271999, TimezoneDatabase::default_time_zone);
    value.to_string(str);
    ASSERT_STREQ("9999-12-31 23:59:59", str);
    
    value.from_unixtime(0, TimezoneDatabase::default_time_zone);
    value.to_string(str);
    ASSERT_STREQ("1970-01-01 08:00:00", str);

    ASSERT_FALSE(value.from_unixtime(1586098092, "+20:00"));
    ASSERT_FALSE(value.from_unixtime(1586098092, "foo"));
}

// Calculate format
TEST_F(DateTimeValueTest, unix_timestamp) {
    DateTimeValue value;
    int64_t timestamp;
    value.from_date_int64(19691231);
    value.unix_timestamp(&timestamp, TimezoneDatabase::default_time_zone);
    ASSERT_EQ(-115200, timestamp);
    value.from_date_int64(19700101);
    value.unix_timestamp(&timestamp, TimezoneDatabase::default_time_zone);
    ASSERT_EQ(0 - 28800, timestamp);
    value.from_date_int64(19700102);
    value.unix_timestamp(&timestamp, TimezoneDatabase::default_time_zone);
    ASSERT_EQ(86400 - 28800, timestamp);
    value.from_date_int64(19880201000000);
    value.unix_timestamp(&timestamp, TimezoneDatabase::default_time_zone);
    ASSERT_EQ(570672000 - 28800, timestamp);
    value.from_date_int64(20380119);
    value.unix_timestamp(&timestamp, TimezoneDatabase::default_time_zone);
    ASSERT_EQ(2147472000 - 28800, timestamp);
    value.from_date_int64(20380120);
    value.unix_timestamp(&timestamp, TimezoneDatabase::default_time_zone);
    ASSERT_EQ(2147529600, timestamp);
	
    value.from_date_int64(10000101);
    value.unix_timestamp(&timestamp, TimezoneDatabase::default_time_zone);
    ASSERT_EQ(-30610252800, timestamp);
}

// Calculate format
TEST_F(DateTimeValueTest, add_interval) {
    // Used to check
    char str[MAX_DTVALUE_STR_LEN];

    TimeInterval interval;

    DateTimeValue value;

    value.from_date_int64(19880201);
    interval.microsecond = 1;
    ASSERT_TRUE(value.date_add_interval(interval, MICROSECOND));
    interval.microsecond = 0;
    value.to_string(str);
    ASSERT_STREQ("1988-02-01 00:00:00.000001", str);

    value.from_date_int64(19880201);
    interval.second = 1;
    ASSERT_TRUE(value.date_add_interval(interval, SECOND));
    interval.second = 0;
    value.to_string(str);
    ASSERT_STREQ("1988-02-01 00:00:01", str);

    value.from_date_int64(19880201);
    interval.minute = 1;
    ASSERT_TRUE(value.date_add_interval(interval, MINUTE));
    interval.minute = 0;
    value.to_string(str);
    ASSERT_STREQ("1988-02-01 00:01:00", str);

    value.from_date_int64(19880201);
    interval.hour = 1;
    ASSERT_TRUE(value.date_add_interval(interval, HOUR));
    interval.hour = 0;
    value.to_string(str);
    ASSERT_STREQ("1988-02-01 01:00:00", str);

    value.from_date_int64(19880201);
    interval.microsecond = 1;
    interval.second = 1;
    ASSERT_TRUE(value.date_add_interval(interval, SECOND_MICROSECOND));
    interval.microsecond = 0;
    interval.second = 0;
    value.to_string(str);
    ASSERT_STREQ("1988-02-01 00:00:01.000001", str);

    value.from_date_int64(19880201);
    interval.day = 100;
    ASSERT_TRUE(value.date_add_interval(interval, DAY));
    interval.day = 0;
    value.to_string(str);
    ASSERT_STREQ("1988-05-11", str);

    value.from_date_int64(19880131);
    interval.month = 97;
    ASSERT_TRUE(value.date_add_interval(interval, MONTH));
    interval.month = 0;
    value.to_string(str);
    ASSERT_STREQ("1996-02-29", str);

    value.from_date_int64(19880229);
    interval.year = 1;
    ASSERT_TRUE(value.date_add_interval(interval, YEAR));
    interval.year = 0;
    value.to_string(str);
    ASSERT_STREQ("1989-02-28", str);
}

// Calculate format
TEST_F(DateTimeValueTest, from_date_format_str) {
    // Used to check
    char str[MAX_DTVALUE_STR_LEN];
    std::string format_str;
    std::string value_str;
    DateTimeValue value;

    // %Y-%m-%d
    format_str = "%Y-%m-%d";
    value_str = "1988-02-01";
    ASSERT_TRUE(value.from_date_format_str(
            format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size()));
    value.to_string(str);
    ASSERT_STREQ("1988-02-01", str);

    format_str = "%Y-%M-%d";
    value_str = "1988-feb-01";
    ASSERT_TRUE(value.from_date_format_str(
            format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size()));
    value.to_string(str);
    ASSERT_STREQ("1988-02-01", str);

    format_str = "%Y-%b-%d";
    value_str = "1988-feb-01";
    ASSERT_TRUE(value.from_date_format_str(
            format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size()));
    value.to_string(str);
    ASSERT_STREQ("1988-02-01", str);

    format_str = "%Y%b%d";
    value_str = "1988f01";
    ASSERT_TRUE(value.from_date_format_str(
            format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size()));
    value.to_string(str);
    ASSERT_STREQ("1988-02-01", str);

    format_str = "%y%m%d";
    value_str = "880201";
    ASSERT_TRUE(value.from_date_format_str(
            format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size()));
    value.to_string(str);
    ASSERT_STREQ("1988-02-01", str);

    format_str = "%y%c%d";
    value_str = "880201";
    ASSERT_TRUE(value.from_date_format_str(
            format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size()));
    value.to_string(str);
    ASSERT_STREQ("1988-02-01", str);

    format_str = "%y%c-%e";
    value_str = "882-1";
    ASSERT_TRUE(value.from_date_format_str(
            format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size()));
    value.to_string(str);
    ASSERT_STREQ("1988-02-01", str);

    // %j
    format_str = "%Y%j %H";
    value_str = "198832 03";
    ASSERT_TRUE(value.from_date_format_str(
            format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size()));
    value.to_string(str);
    ASSERT_STREQ("1988-02-01 03:00:00", str);

    // %x
    format_str = "%X %V %w";
    value_str = "2015 1 1";
    ASSERT_TRUE(value.from_date_format_str(
            format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size()));
    value.to_string(str);
    ASSERT_STREQ("2015-01-05", str);

    // %x
    format_str = "%x %v %w";
    value_str = "2015 1 1";
    ASSERT_TRUE(value.from_date_format_str(
            format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size()));
    value.to_string(str);
    ASSERT_STREQ("2014-12-29", str);

    // %x
    format_str = "%x %v %W";
    value_str = "2015 1 Monday";
    ASSERT_TRUE(value.from_date_format_str(
            format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size()));
    value.to_string(str);
    ASSERT_STREQ("2014-12-29", str);

    // %x
    format_str = "%X %V %a";
    value_str = "2015 1 Mon";
    ASSERT_TRUE(value.from_date_format_str(
            format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size()));
    value.to_string(str);
    ASSERT_STREQ("2015-01-05", str);

    // %T
    format_str = "%X %V %a %r";
    value_str = "2015 1 Mon 2:34:56 AM";
    ASSERT_TRUE(value.from_date_format_str(
            format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size()));
    value.to_string(str);
    ASSERT_STREQ("2015-01-05 02:34:56", str);

    // %T
    format_str = "%X %V %a %T";
    value_str = "2015 1 Mon 12:34:56";
    ASSERT_TRUE(value.from_date_format_str(
            format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size()));
    value.to_string(str);
    ASSERT_STREQ("2015-01-05 12:34:56", str);

    //  hour
    format_str = "%Y-%m-%d %H %i %s";
    value_str = "88-2-1 03 4 5";
    ASSERT_TRUE(value.from_date_format_str(
            format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size()));
    value.to_string(str);
    ASSERT_STREQ("1988-02-01 03:04:05", str);

    // escape %
    format_str = "%Y-%m-%d %H%%3A%i%%3A%s";
    value_str = "2020-02-26 00%3A00%3A00";
    ASSERT_TRUE(value.from_date_format_str(
            format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size()));
    value.to_string(str);
    ASSERT_STREQ("2020-02-26 00:00:00", str);

    // escape %
    format_str = "%Y-%m-%d%%%% %H%%3A%i%%3A%s";
    value_str = "2020-02-26%% 00%3A00%3A00";
    ASSERT_TRUE(value.from_date_format_str(
            format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size()));
    value.to_string(str);
    ASSERT_STREQ("2020-02-26 00:00:00", str);
}

// Calculate format
TEST_F(DateTimeValueTest, from_date_format_str_invalid) {
    // Used to check
    std::string format_str;
    std::string value_str;
    DateTimeValue value;

    format_str = "%y%c%e";
    value_str = "8821";
    ASSERT_FALSE(value.from_date_format_str(
            format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size()));
    format_str = "%y-%c-%e";
    value_str = "8821";
    ASSERT_FALSE(value.from_date_format_str(
            format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size()));
    format_str = "%y%c-%e";
    value_str = "882-30";
    ASSERT_FALSE(value.from_date_format_str(
            format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size()));
    // %x
    format_str = "%X %v %w";
    value_str = "2015 1 1";
    ASSERT_FALSE(value.from_date_format_str(
            format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size()));

    format_str = "%x %V %w";
    value_str = "2015 1 1";
    ASSERT_FALSE(value.from_date_format_str(
            format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size()));

    format_str = "%Y-%m-%d %H%3A%i%3A%s";
    value_str = "2020-02-26 00%3A00%3A00";
    ASSERT_FALSE(value.from_date_format_str(
            format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size()));
}
// Calculate format
TEST_F(DateTimeValueTest, format_str) {
    // Used to check
    char str[MAX_DTVALUE_STR_LEN];

    std::string format_str;
    DateTimeValue value;

    // %a
    format_str = "%a";
    value.from_date_int64(20150215);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("Sun", str);

    // %b
    format_str = "%b";
    value.from_date_int64(20150215);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("Feb", str);

    // %c
    format_str = "%c";
    value.from_date_int64(20150215);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("2", str);
    value.from_date_int64(20151215);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("12", str);

    // %d
    format_str = "%d";
    value.from_date_int64(20150215);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("15", str);
    value.from_date_int64(20150205);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("05", str);
    
    // %D
    format_str = "%D";
    value.from_date_int64(20150201);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("1st", str);
    value.from_date_int64(20150202);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("2nd", str);
    value.from_date_int64(20150203);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("3rd", str);
    value.from_date_int64(20150204);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("4th", str);

    // %e
    format_str = "%e";
    value.from_date_int64(20150201);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("1", str);
    value.from_date_int64(20150211);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("11", str);

    // %f
    format_str = "%f";
    value.from_date_str("20150201000000.1", 16);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("100000", str);
    value.from_date_str("20150211000000.123456", 21);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("123456", str);

    // %h %I
    format_str = "%h";
    value.from_date_int64(20150201010000L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("01", str);
    value.from_date_int64(20150201230000L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("11", str);
    format_str = "%I";
    value.from_date_int64(20150201010000L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("01", str);
    value.from_date_int64(20150201230000L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("11", str);

    // %H
    format_str = "%H";
    value.from_date_int64(20150201010000L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("01", str);
    value.from_date_int64(20150201230000L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("23", str);

    // %i
    format_str = "%i";
    value.from_date_int64(20150201010000L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("00", str);
    value.from_date_int64(20150201235900L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("59", str);

    // %j
    format_str = "%j";
    value.from_date_int64(20150201L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("032", str);
    value.from_date_int64(20151231L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("365", str);

    // %k
    format_str = "%k";
    value.from_date_int64(20150201000000L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("0", str);
    value.from_date_int64(20150201230000L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("23", str);

    // %l
    format_str = "%l";
    value.from_date_int64(20150201010000L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("1", str);
    value.from_date_int64(20150201230000L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("11", str);

    // %m
    format_str = "%m";
    value.from_date_int64(20150201);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("02", str);

    // %M
    format_str = "%M";
    value.from_date_int64(20150201);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("February", str);

    // %p
    format_str = "%p";
    value.from_date_int64(20150201000000L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("AM", str);
    value.from_date_int64(20150201120000L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("PM", str);

    // %r
    format_str = "%r";
    value.from_date_int64(20150201023456L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("02:34:56 AM", str);
    value.from_date_int64(20150201003456L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("12:34:56 AM", str);
    value.from_date_int64(20150201123456L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("12:34:56 PM", str);

    // %s & %S
    format_str = "%s";
    value.from_date_int64(20150201023456L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("56", str);
    value.from_date_int64(20150201023406L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("06", str);
    format_str = "%S";
    value.from_date_int64(20150201023456L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("56", str);
    value.from_date_int64(20150201023406L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("06", str);

    // %T
    format_str = "%T";
    value.from_date_int64(20150201023456L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("02:34:56", str);
    value.from_date_int64(20150201003456L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("00:34:56", str);
    value.from_date_int64(20150201123456L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("12:34:56", str);

    // %u
    format_str = "%u";
    value.from_date_int64(20131231L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("53", str);
    value.from_date_int64(20150101);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("01", str);

    // %U
    format_str = "%U";
    value.from_date_int64(20131231L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("52", str);
    value.from_date_int64(20150101);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("00", str);

    // %v
    format_str = "%v";
    value.from_date_int64(20131231L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("01", str);
    value.from_date_int64(20150101);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("01", str);

    // %V
    format_str = "%V";
    value.from_date_int64(20131231L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("52", str);
    value.from_date_int64(20150101);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("52", str);

    // %w
    format_str = "%w";
    value.from_date_int64(20131231L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("2", str);
    value.from_date_int64(20150101);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("4", str);

    // %W
    format_str = "%W";
    value.from_date_int64(20131231L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("Tuesday", str);
    value.from_date_int64(20150101);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("Thursday", str);

    // %x
    format_str = "%x";
    value.from_date_str("0000-01-01", 10);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("4294967295", str);
    value.from_date_int64(20131231L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("2014", str);
    value.from_date_int64(20150101);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("2015", str);

    // %X
    format_str = "%X";
    value.from_date_str("0000-01-01", 10);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("0000", str);
    value.from_date_int64(20131231L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("2013", str);
    value.from_date_int64(20150101);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("2014", str);

    // %y
    format_str = "%y";
    value.from_date_int64(20150201000000L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("15", str);
    value.from_date_str("0005.0201120000", 17);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("05", str);

    // %Y
    format_str = "%Y";
    value.from_date_int64(20150201000000L);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("2015", str);
    value.from_date_str("0015.0201120000", 17);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("0015", str);

    // %Y%m%a
    format_str = "this is %Y-%m-%d";
    value.from_date_int64(19880201);
    ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str));
    ASSERT_STREQ("this is 1988-02-01", str);
}

// Calculate weekday
TEST_F(DateTimeValueTest, weekday) {
    DateTimeValue value;
    // NORMAL CASE
    ASSERT_TRUE(value.from_date_int64(101));
    ASSERT_TRUE(value.from_date_daynr(6));
    // NORMAL CASE
    ASSERT_TRUE(value.from_date_int64(20150215));
    ASSERT_TRUE(value.from_date_daynr(6));
}

// Calculate from daynr
TEST_F(DateTimeValueTest, calc_form_daynr) {
    // Used to check
    char str[MAX_DTVALUE_STR_LEN];

    DateTimeValue value;
    // NORMAL CASE
    ASSERT_TRUE(value.from_date_daynr(1));
    value.to_string(str);
    ASSERT_STREQ("0000-01-01", str);
    ASSERT_TRUE(value.from_date_daynr(59));
    value.to_string(str);
    ASSERT_STREQ("0000-02-28", str);
    ASSERT_TRUE(value.from_date_daynr(60));
    value.to_string(str);
    ASSERT_STREQ("0000-03-01", str);
    ASSERT_TRUE(value.from_date_daynr(365));
    value.to_string(str);
    ASSERT_STREQ("0000-12-31", str);
    ASSERT_TRUE(value.from_date_daynr(366));
    value.to_string(str);
    ASSERT_STREQ("0001-01-01", str);
    ASSERT_TRUE(value.from_date_daynr(1520));
    value.to_string(str);
    ASSERT_STREQ("0004-02-29", str);
    ASSERT_TRUE(value.from_date_daynr(1519));
    value.to_string(str);
    ASSERT_STREQ("0004-02-28", str);
    ASSERT_TRUE(value.from_date_daynr(1521));
    value.to_string(str);
    ASSERT_STREQ("0004-03-01", str);
    ASSERT_TRUE(value.from_date_daynr(726133));
    value.to_string(str);
    ASSERT_STREQ("1988-02-01", str);
    ASSERT_TRUE(value.from_date_daynr(3652424));
    value.to_string(str);
    ASSERT_STREQ("9999-12-31", str);

    // BAD CASE
    ASSERT_FALSE(value.from_date_daynr(0));
    ASSERT_FALSE(value.from_date_daynr(3652425));
    ASSERT_FALSE(value.from_date_daynr(36524251));
}

// Calculate daynr
TEST_F(DateTimeValueTest, calc_daynr) {
    ASSERT_EQ(0, DateTimeValue::calc_daynr(0, 0, 1));
    ASSERT_EQ(1, DateTimeValue::calc_daynr(0, 1, 1));
    ASSERT_EQ(365, DateTimeValue::calc_daynr(0, 12, 31));
    ASSERT_EQ(366, DateTimeValue::calc_daynr(1, 1, 1));
    ASSERT_EQ(726133, DateTimeValue::calc_daynr(1988, 2, 1));
    DateTimeValue value;
    value.from_date_int64(880201);
    ASSERT_EQ(726133, value.daynr());
    ASSERT_EQ(726161, DateTimeValue::calc_daynr(1988, 2, 29));
}

// Construct from int value
TEST_F(DateTimeValueTest, from_time_str) {
    // Used to check
    char str[MAX_DTVALUE_STR_LEN];
    std::string test_str;

    DateTimeValue value;
    // INTERNAL MODE WITH OUT
    test_str = " 880201";
    ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size()));
    value.to_string(str);
    ASSERT_STREQ("1988-02-01", str);

    test_str = "88020112";
    ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size()));
    value.to_string(str);
    ASSERT_STREQ("8802-01-12", str);

    test_str = "8802011223";
    ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size()));
    value.to_string(str);
    ASSERT_STREQ("1988-02-01 12:23:00", str);
    
    test_str = "880201122334";
    ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size()));
    value.to_string(str);
    ASSERT_STREQ("1988-02-01 12:23:34", str);

    test_str = "19880201";
    ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size()));
    value.to_string(str);
    ASSERT_STREQ("1988-02-01", str);

    test_str = "1988.020112";
    ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size()));
    value.to_string(str);
    ASSERT_STREQ("1988-02-01 12:00:00", str);

    test_str = "1988.0201123";
    ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size()));
    value.to_string(str);
    ASSERT_STREQ("1988-02-01 12:03:00", str);

    test_str = "1988.020112345";
    ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size()));
    value.to_string(str);
    ASSERT_STREQ("1988-02-01 12:34:05", str);

    test_str = "19880201000000.1234567";
    ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size()));
    value.to_string(str);
    ASSERT_STREQ("1988-02-01 00:00:00.123456", str);

    test_str = "19880201T000000.1234567";
    ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size()));
    value.to_string(str);
    ASSERT_STREQ("1988-02-01 00:00:00.123456", str);

    // normal-2

    // Delim MODE
    test_str = "88-02-01";
    ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size()));
    value.to_string(str);
    ASSERT_STREQ("1988-02-01", str);

    test_str = "1988-02-01";
    ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size()));
    value.to_string(str);
    ASSERT_STREQ("1988-02-01", str);

    test_str = "1988-02-01 12";
    ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size()));
    value.to_string(str);
    ASSERT_STREQ("1988-02-01 12:00:00", str);

    test_str = "1988-02-01 12:34";
    ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size()));
    value.to_string(str);
    ASSERT_STREQ("1988-02-01 12:34:00", str);

    test_str = "1988-02-01 12:34:56";
    ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size()));
    value.to_string(str);
    ASSERT_STREQ("1988-02-01 12:34:56", str);

    test_str = "1988-02-01 12:34:56.123";
    ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size()));
    value.to_string(str);
    ASSERT_STREQ("1988-02-01 12:34:56.123000", str);
}

TEST_F(DateTimeValueTest, from_time_str_invalid) {
    std::string test_str;

    DateTimeValue value;
    test_str = "  ";
    ASSERT_FALSE(value.from_date_str(test_str.c_str(), test_str.size()));
    test_str = " a";
    ASSERT_FALSE(value.from_date_str(test_str.c_str(), test_str.size()));
    // normal-1
    test_str = "1988-02-31 00:00:00";
    ASSERT_FALSE(value.from_date_str(test_str.c_str(), test_str.size()));

    test_str = "1988-02 01 12:34:56";
    ASSERT_FALSE(value.from_date_str(test_str.c_str(), test_str.size()));
    // excede 9999999
    test_str = "1988999-02-31 00:00:00";
    ASSERT_FALSE(value.from_date_str(test_str.c_str(), test_str.size()));

    test_str = "1988-02-31 100";
    ASSERT_FALSE(value.from_date_str(test_str.c_str(), test_str.size()));

    test_str = "1988.02-31 10";
    ASSERT_FALSE(value.from_date_str(test_str.c_str(), test_str.size()));
}

// Construct from int value
TEST_F(DateTimeValueTest, from_time_int) {
    // Used to check
    char str[MAX_DTVALUE_STR_LEN];

    DateTimeValue value;
    // 59 -> 00:00:59
    ASSERT_TRUE(value.from_time_int64(59));
    value.to_string(str);
    ASSERT_STREQ("00:00:59", str);
    // 5959 -> 00:59:59
    ASSERT_TRUE(value.from_time_int64(5959));
    value.to_string(str);
    ASSERT_STREQ("00:59:59", str);
    // 8385959 -> 838:59:59
    ASSERT_TRUE(value.from_time_int64(8385959));
    value.to_string(str);
    ASSERT_STREQ("838:59:59", str);
    // 880201000000
    ASSERT_TRUE(value.from_time_int64(880201000000));
    value.to_string(str);
    ASSERT_STREQ("1988-02-01 00:00:00", str);
}

// Construct from int value
TEST_F(DateTimeValueTest, from_time_int_invalid) {
    DateTimeValue value;
    // 69
    ASSERT_FALSE(value.from_time_int64(69));
    // 6959
    ASSERT_FALSE(value.from_time_int64(6959));
    // 9006969
    ASSERT_FALSE(value.from_time_int64(8396969));
    // 1000132000000
    ASSERT_FALSE(value.from_time_int64(1000132000000));
}

// Construct from int value
TEST_F(DateTimeValueTest, from_int_value) {
    // Used to check
    char str[MAX_DTVALUE_STR_LEN];

    DateTimeValue value;
    // 101 -> 2000-01-01
    ASSERT_TRUE(value.from_date_int64(101));
    value.to_string(str);
    ASSERT_STREQ("2000-01-01", str);
    // 150201 -> 2015-02-01
    ASSERT_TRUE(value.from_date_int64(150201));
    value.to_string(str);
    ASSERT_STREQ("2015-02-01", str);
    // 691231 -> 2069-12-31
    ASSERT_TRUE(value.from_date_int64(691231));
    value.to_string(str);
    ASSERT_STREQ("2069-12-31", str);
    // 700101 -> 1970-01-01
    ASSERT_TRUE(value.from_date_int64(700101));
    value.to_string(str);
    ASSERT_STREQ("1970-01-01", str);
    // 880201 -> 1988-02-01
    ASSERT_TRUE(value.from_date_int64(880201));
    value.to_string(str);
    ASSERT_STREQ("1988-02-01", str);
    // 991231 -> 1999-12-31
    ASSERT_TRUE(value.from_date_int64(991231));
    value.to_string(str);
    ASSERT_STREQ("1999-12-31", str);
    // 10000101 -> 1000-01-01
    ASSERT_TRUE(value.from_date_int64(10000101));
    value.to_string(str);
    ASSERT_STREQ("1000-01-01", str);
    // 12340531 -> 1234-05-31
    ASSERT_TRUE(value.from_date_int64(12340531));
    value.to_string(str);
    ASSERT_STREQ("1234-05-31", str);
    // 99991231 -> 9999-12-31
    ASSERT_TRUE(value.from_date_int64(99991231));
    value.to_string(str);
    ASSERT_STREQ("9999-12-31", str);

    // BELOW IS DATETIME VALUE CHECK

    // 101000000 -> 2000-01-01 00:00:00
    ASSERT_TRUE(value.from_date_int64(101000000));
    value.to_string(str);
    ASSERT_STREQ("2000-01-01 00:00:00", str);
    // 150201123456 -> 2015-02-01 12:34:56
    ASSERT_TRUE(value.from_date_int64(150201123456));
    value.to_string(str);
    ASSERT_STREQ("2015-02-01 12:34:56", str);
    // 691231235959 -> 2069-12-31 23:59:59
    ASSERT_TRUE(value.from_date_int64(691231235959));
    value.to_string(str);
    ASSERT_STREQ("2069-12-31 23:59:59", str);

    // 700101000000 -> 1970-01-01 00:00:00
    ASSERT_TRUE(value.from_date_int64(700101000000));
    value.to_string(str);
    ASSERT_STREQ("1970-01-01 00:00:00", str);
    // 880201123456 -> 1988-02-01 12:34:56
    ASSERT_TRUE(value.from_date_int64(880201123456));
    value.to_string(str);
    ASSERT_STREQ("1988-02-01 12:34:56", str);
    // 991231235959 -> 1999-12-31 23:59:59
    ASSERT_TRUE(value.from_date_int64(991231235959));
    value.to_string(str);
    ASSERT_STREQ("1999-12-31 23:59:59", str);

    // four digits year
    // 1231231235959 -> 0123-12-31 23:59:59
    ASSERT_TRUE(value.from_date_int64(1231231235959));
    value.to_string(str);
    ASSERT_STREQ("0123-12-31 23:59:59", str);

    // 99991231235959 -> 9999-12-31 23:59:59
    ASSERT_TRUE(value.from_date_int64(99991231235959));
    value.to_string(str);
    ASSERT_STREQ("9999-12-31 23:59:59", str);
}

// Construct from int value invalid
TEST_F(DateTimeValueTest, from_int_value_invalid) {
    DateTimeValue value;
    // minus value
    ASSERT_FALSE(value.from_date_int64(-1231));
    // [0, 101)
    ASSERT_FALSE(value.from_date_int64(100));
    // 691323
    ASSERT_FALSE(value.from_date_int64(691323));
    // three digits year 8980101
    ASSERT_FALSE(value.from_date_int64(8980101));
    // 100-12-31
    ASSERT_FALSE(value.from_date_int64(1000101L));
    // 100-12-31
    ASSERT_FALSE(value.from_date_int64(1232));
    // 99 00:00:00
    ASSERT_FALSE(value.from_date_int64(99000000));
    // 9999-99-99 99:99:99 + 1
    ASSERT_FALSE(value.from_date_int64(99999999999999L + 1));
}

// Convert to datetime string
TEST_F(DateTimeValueTest, to_string) {
    char str[MAX_DTVALUE_STR_LEN];

    // 0000-00-00 00:00:00
    {
        DateTimeValue value;
        // datetime
        value.to_string(str);
        ASSERT_STREQ("0000-00-00 00:00:00", str);

        // date
        value._type = TIME_DATE;
        value.to_string(str);
        ASSERT_STREQ("0000-00-00", str);

        // time
        value._type = TIME_TIME;
        value.to_string(str);
        ASSERT_STREQ("00:00:00", str);
    }

    // 8765-12-23 12:34:56.987654
    {
        DateTimeValue value;
        value._year = 8765;
        value._month = 12;
        value._day = 23;
        value._hour = 12;
        value._minute = 34;
        value._second = 56;
        value._microsecond = 987654;
        // datetime
        value.to_string(str);
        ASSERT_STREQ("8765-12-23 12:34:56.987654", str);

        // time
        value._type = TIME_TIME;
        value.to_string(str);
        ASSERT_STREQ("12:34:56.987654", str);

        // date
        value._type = TIME_DATE;
        value.to_string(str);
        ASSERT_STREQ("8765-12-23", str);
    }

    // 0001-02-03 04:05:06.000007
    {
        DateTimeValue value;
        value._year = 1;
        value._month = 2;
        value._day = 3;
        value._hour = 4;
        value._minute = 5;
        value._second = 6;
        value._microsecond = 7;
        value.to_string(str);
        ASSERT_STREQ("0001-02-03 04:05:06.000007", str);

        // date
        value._type = TIME_DATE;
        value.to_string(str);
        ASSERT_STREQ("0001-02-03", str);

        // time
        value._type = TIME_TIME;
        value.to_string(str);
        ASSERT_STREQ("04:05:06.000007", str);
    }

    // time minus -100:05:06
    {
        DateTimeValue value;
        value._hour = 100;
        value._minute = 5;
        value._second = 6;
        value._microsecond = 7;
        value._type = TIME_TIME;
        value._neg = 1;
        value.to_string(str);
        ASSERT_STREQ("-100:05:06.000007", str);
    }
}

TEST_F(DateTimeValueTest, to_int64) {
    // 0000-00-00 00:00:00
    {
        DateTimeValue value;
        // datetime
        ASSERT_EQ(0L, value.to_int64());

        // date
        value._type = TIME_DATE;
        ASSERT_EQ(0L, value.to_int64());

        // time
        value._type = TIME_TIME;
        ASSERT_EQ(0L, value.to_int64());
    }

    // 8765-12-23 12:34:56.987654
    {
        DateTimeValue value;
        value._year = 8765;
        value._month = 12;
        value._day = 23;
        value._hour = 12;
        value._minute = 34;
        value._second = 56;
        value._microsecond = 987654;
        // datetime
        ASSERT_EQ(87651223123456L, value.to_int64());

        // time
        value._type = TIME_TIME;
        ASSERT_EQ(123456L, value.to_int64());

        // date
        value._type = TIME_DATE;
        ASSERT_EQ(87651223L, value.to_int64());
    }

    // 0001-02-03 04:05:06.000007
    {
        DateTimeValue value;
        value._year = 1;
        value._month = 2;
        value._day = 3;
        value._hour = 4;
        value._minute = 5;
        value._second = 6;
        value._microsecond = 7;
        ASSERT_EQ(10203040506L, value.to_int64());

        // date
        value._type = TIME_DATE;
        ASSERT_EQ(10203L, value.to_int64());

        // time
        value._type = TIME_TIME;
        ASSERT_EQ(40506L, value.to_int64());
    }

    // time minus -100:05:06
    {
        DateTimeValue value;
        value._hour = 100;
        value._minute = 5;
        value._second = 6;
        value._microsecond = 7;
        value._type = TIME_TIME;
        value._neg = 1;
        ASSERT_EQ(-1000506L, value.to_int64());
    }
}

TEST_F(DateTimeValueTest, operatro_minus) {
    {
        DateTimeValue v1;
        ASSERT_TRUE(v1.from_date_int64(19880201));
        DateTimeValue v2;
        ASSERT_TRUE(v2.from_date_int64(19870201));
        int value = v1 - v2;
        ASSERT_EQ(365, value);
        value = v2 - v1;
        ASSERT_EQ(-365, value);
        value = v1 - v1;
        ASSERT_EQ(0, value);
    }

    {
        DateTimeValue v1;
        ASSERT_TRUE(v1.from_date_int64(19880201));
        DateTimeValue v2;
        ASSERT_TRUE(v2.from_date_int64(19870201123456));
        int value = v1 - v2;
        ASSERT_EQ(365, value);
        value = v2 - v1;
        ASSERT_EQ(-365, value);
        value = v1 - v1;
        ASSERT_EQ(0, value);
    }
}

TEST_F(DateTimeValueTest, min_max) {
    char buf[64];
    {
        DateTimeValue v1 = DateTimeValue::datetime_min_value();
        v1.to_string(buf);
        ASSERT_STREQ("0000-01-01 00:00:00", buf);
    }

    {
        DateTimeValue v1 = DateTimeValue::datetime_max_value();
        v1.to_string(buf);
        ASSERT_STREQ("9999-12-31 23:59:59", buf);
    }
}

TEST_F(DateTimeValueTest, packed_time) {
    char buf[64];
    {
        DateTimeValue v1;
        v1.from_date_int64(20010203123456L);
        v1.to_string(buf);
        ASSERT_STREQ("2001-02-03 12:34:56", buf);

        int64_t packed_time = v1.to_int64_date_packed();
        ASSERT_EQ(1830649476851695616L, packed_time);
        packed_time = v1.to_int64_datetime_packed();
        ASSERT_EQ(1830650338932162560L, packed_time);
    }

    {
        doris_udf::DateTimeVal tv;
        tv.packed_time = 1830650338932162560L;
        tv.type = TIME_DATETIME;
        DateTimeValue v1 = DateTimeValue::from_datetime_val(tv);
        v1.to_string(buf);
        ASSERT_STREQ("2001-02-03 12:34:56", buf);

        doris_udf::DateTimeVal tv2;
        v1.to_datetime_val(&tv2);

        ASSERT_TRUE(tv == tv2);
    }

}

}

int main(int argc, char** argv) {
    // std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf";
    // if (!doris::config::init(conffile.c_str(), false)) {
    //     fprintf(stderr, "error read config file. \n");
    //     return -1;
    // }
    // doris::init_glog("be-test");
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}