465 lines
17 KiB
C++
465 lines
17 KiB
C++
// Copyright 2025 Google LLC. All Rights Reserved. This file and proprietary
|
|
// source code may only be used and distributed under the Widevine License
|
|
// Agreement.
|
|
#include "wv_date_time.h"
|
|
|
|
#include <stdint.h>
|
|
|
|
// #include <gmock/gmock.h>
|
|
#include <gtest/gtest.h>
|
|
|
|
#include "wv_duration.h"
|
|
#include "wv_timestamp.h"
|
|
|
|
namespace wvutil {
|
|
namespace test {
|
|
namespace {
|
|
// This is a Unix time chosen for testing.
|
|
// Friday, April 19th, 2024 13:36:18.507
|
|
// April 19th is the 110th day of the year when a leap year.
|
|
constexpr uint64_t kTestUnixTimeS = 1713533778;
|
|
constexpr uint64_t kTestUnixTimeMs = 1713533778507;
|
|
|
|
constexpr Seconds kTestTimeS = Seconds(kTestUnixTimeS);
|
|
constexpr Milliseconds kTestTimeMs = Milliseconds(kTestUnixTimeMs);
|
|
|
|
constexpr uint32_t kTestYear = 2024;
|
|
constexpr uint32_t kTestMonth = 4; // April
|
|
constexpr uint32_t kTestDay = 19;
|
|
constexpr uint32_t kTestHour = 13;
|
|
constexpr uint32_t kTestMinute = 36;
|
|
constexpr uint32_t kTestSecond = 18;
|
|
constexpr uint32_t kTestMs = 507;
|
|
constexpr uint32_t kTestDayOfWeek = 6; // Friday
|
|
constexpr uint32_t kTestDayOfYear = 110;
|
|
|
|
constexpr int64_t kOneMinuteS = 60;
|
|
constexpr int64_t kOneHourS = kOneMinuteS * 60;
|
|
constexpr int64_t kOneDayS = kOneHourS * 24;
|
|
constexpr int64_t kOneCommonYearS = kOneDayS * 365;
|
|
constexpr int64_t kOneLeapYearS = kOneDayS * 366;
|
|
|
|
constexpr int64_t kOneSecondMs = 1000;
|
|
constexpr int64_t kOneMinuteMs = kOneSecondMs * 60;
|
|
constexpr int64_t kOneHourMs = kOneMinuteMs * 60;
|
|
constexpr int64_t kOneDayMs = kOneHourMs * 24;
|
|
|
|
uint32_t DayOfWeekAddition(uint32_t day_of_week, uint32_t inc) {
|
|
return ((day_of_week - 1 + inc) % 7) + 1;
|
|
}
|
|
|
|
uint32_t DayOfWeekSubtraction(uint32_t day_of_week, uint32_t dec) {
|
|
const uint32_t reverse_day_of_week = (8 - day_of_week);
|
|
const uint32_t reverse_new_day_of_week =
|
|
DayOfWeekAddition(reverse_day_of_week, dec);
|
|
return (8 - reverse_new_day_of_week);
|
|
}
|
|
} // namespace
|
|
|
|
TEST(WvDateTimeUtilTest, FromUnixSeconds) {
|
|
const DateTime datetime = DateTime::FromUnixSeconds(kTestUnixTimeS, kTestMs);
|
|
ASSERT_TRUE(datetime.IsSet());
|
|
EXPECT_EQ(datetime.epoch_seconds(), kTestTimeS);
|
|
EXPECT_EQ(datetime.epoch_milliseconds(), kTestTimeMs);
|
|
|
|
EXPECT_EQ(datetime.year(), kTestYear);
|
|
EXPECT_EQ(datetime.month(), kTestMonth);
|
|
EXPECT_EQ(datetime.day(), kTestDay);
|
|
EXPECT_EQ(datetime.day_of_year(), kTestDayOfYear);
|
|
EXPECT_EQ(datetime.day_of_week(), kTestDayOfWeek);
|
|
|
|
EXPECT_EQ(datetime.hour(), kTestHour);
|
|
EXPECT_EQ(datetime.minute(), kTestMinute);
|
|
EXPECT_EQ(datetime.second(), kTestSecond);
|
|
EXPECT_EQ(datetime.millisecond(), kTestMs);
|
|
}
|
|
|
|
TEST(WvDateTimeUtilTest, FromUnixMilliseconds) {
|
|
const DateTime datetime = DateTime::FromUnixMilliseconds(kTestUnixTimeMs);
|
|
ASSERT_TRUE(datetime.IsSet());
|
|
EXPECT_EQ(datetime.epoch_seconds(), kTestTimeS);
|
|
EXPECT_EQ(datetime.epoch_milliseconds(), kTestTimeMs);
|
|
|
|
EXPECT_EQ(datetime.year(), kTestYear);
|
|
EXPECT_EQ(datetime.month(), kTestMonth);
|
|
EXPECT_EQ(datetime.day(), kTestDay);
|
|
EXPECT_EQ(datetime.day_of_year(), kTestDayOfYear);
|
|
EXPECT_EQ(datetime.day_of_week(), kTestDayOfWeek);
|
|
|
|
EXPECT_EQ(datetime.hour(), kTestHour);
|
|
EXPECT_EQ(datetime.minute(), kTestMinute);
|
|
EXPECT_EQ(datetime.second(), kTestSecond);
|
|
EXPECT_EQ(datetime.millisecond(), kTestMs);
|
|
}
|
|
|
|
TEST(WvDateTimeUtilTest, Min) {
|
|
// Thursday, January 1st, 1970 00:00:00.001
|
|
const DateTime datetime = DateTime::Min();
|
|
ASSERT_TRUE(datetime.IsSet());
|
|
EXPECT_EQ(datetime.epoch_seconds(), Seconds(0));
|
|
EXPECT_EQ(datetime.epoch_milliseconds(), Milliseconds(1));
|
|
|
|
EXPECT_EQ(datetime.year(), 1970u);
|
|
EXPECT_EQ(datetime.month(), 1u);
|
|
EXPECT_EQ(datetime.day(), 1u);
|
|
EXPECT_EQ(datetime.day_of_year(), 1u);
|
|
EXPECT_EQ(datetime.day_of_week(), 5u);
|
|
|
|
EXPECT_EQ(datetime.hour(), 0u);
|
|
EXPECT_EQ(datetime.minute(), 0u);
|
|
EXPECT_EQ(datetime.second(), 0u);
|
|
EXPECT_EQ(datetime.millisecond(), 1u);
|
|
}
|
|
|
|
TEST(WvDateTimeUtilTest, Max) {
|
|
constexpr int64_t kMaxEpochTimeS = 253402300799;
|
|
constexpr int64_t kMaxEpochTimeMs = (kMaxEpochTimeS * 1000) + 999;
|
|
// Friday, December 31st, 9999 23:59:59.999
|
|
const DateTime datetime = DateTime::Max();
|
|
ASSERT_TRUE(datetime.IsSet());
|
|
EXPECT_EQ(datetime.epoch_seconds(), Seconds(kMaxEpochTimeS));
|
|
EXPECT_EQ(datetime.epoch_milliseconds(), Milliseconds(kMaxEpochTimeMs));
|
|
|
|
EXPECT_EQ(datetime.year(), 9999u);
|
|
EXPECT_EQ(datetime.month(), 12u);
|
|
EXPECT_EQ(datetime.day(), 31u);
|
|
EXPECT_EQ(datetime.day_of_year(), 365u);
|
|
EXPECT_EQ(datetime.day_of_week(), 6u);
|
|
|
|
EXPECT_EQ(datetime.hour(), 23u);
|
|
EXPECT_EQ(datetime.minute(), 59u);
|
|
EXPECT_EQ(datetime.second(), 59u);
|
|
EXPECT_EQ(datetime.millisecond(), 999u);
|
|
}
|
|
|
|
TEST(WvDateTimeUtilTest, Clear) {
|
|
DateTime datetime = DateTime::FromUnixMilliseconds(kTestUnixTimeMs);
|
|
ASSERT_TRUE(datetime.IsSet());
|
|
datetime.Clear();
|
|
|
|
EXPECT_FALSE(datetime.IsSet());
|
|
EXPECT_EQ(datetime.year(), 0u);
|
|
EXPECT_EQ(datetime.month(), 0u);
|
|
EXPECT_EQ(datetime.day(), 0u);
|
|
EXPECT_EQ(datetime.day_of_year(), 0u);
|
|
EXPECT_EQ(datetime.day_of_week(), 0u);
|
|
|
|
EXPECT_EQ(datetime.hour(), 0u);
|
|
EXPECT_EQ(datetime.minute(), 0u);
|
|
EXPECT_EQ(datetime.second(), 0u);
|
|
EXPECT_EQ(datetime.millisecond(), 0u);
|
|
}
|
|
|
|
TEST(WvDateTimeUtilTest, Comparison) {
|
|
const DateTime datetime_a = DateTime::Min();
|
|
const DateTime datetime_b =
|
|
DateTime::FromUnixMilliseconds(kTestUnixTimeMs - kOneDayMs);
|
|
const DateTime datetime_c = DateTime::FromUnixMilliseconds(kTestUnixTimeMs);
|
|
const DateTime datetime_d =
|
|
DateTime::FromUnixMilliseconds(kTestUnixTimeMs + 1);
|
|
const DateTime datetime_e = DateTime::Max();
|
|
|
|
// Equality
|
|
EXPECT_EQ(datetime_a, datetime_a);
|
|
EXPECT_EQ(datetime_b, datetime_b);
|
|
EXPECT_EQ(datetime_c, datetime_c);
|
|
EXPECT_EQ(datetime_d, datetime_d);
|
|
EXPECT_EQ(datetime_e, datetime_e);
|
|
|
|
// Inequality.
|
|
EXPECT_NE(datetime_a, datetime_b);
|
|
EXPECT_NE(datetime_a, datetime_c);
|
|
EXPECT_NE(datetime_a, datetime_d);
|
|
EXPECT_NE(datetime_a, datetime_e);
|
|
EXPECT_NE(datetime_b, datetime_c);
|
|
EXPECT_NE(datetime_b, datetime_d);
|
|
EXPECT_NE(datetime_b, datetime_e);
|
|
EXPECT_NE(datetime_c, datetime_d);
|
|
EXPECT_NE(datetime_c, datetime_e);
|
|
EXPECT_NE(datetime_d, datetime_e);
|
|
|
|
// Less than
|
|
EXPECT_LT(datetime_a, datetime_b);
|
|
EXPECT_LT(datetime_a, datetime_c);
|
|
EXPECT_LT(datetime_a, datetime_d);
|
|
EXPECT_LT(datetime_a, datetime_e);
|
|
EXPECT_LT(datetime_b, datetime_c);
|
|
EXPECT_LT(datetime_b, datetime_d);
|
|
EXPECT_LT(datetime_b, datetime_e);
|
|
EXPECT_LT(datetime_c, datetime_d);
|
|
EXPECT_LT(datetime_c, datetime_e);
|
|
EXPECT_LT(datetime_d, datetime_e);
|
|
|
|
// Less than or equal.
|
|
EXPECT_LE(datetime_a, datetime_a);
|
|
EXPECT_LE(datetime_a, datetime_b);
|
|
EXPECT_LE(datetime_a, datetime_c);
|
|
EXPECT_LE(datetime_a, datetime_d);
|
|
EXPECT_LE(datetime_a, datetime_e);
|
|
EXPECT_LE(datetime_b, datetime_b);
|
|
EXPECT_LE(datetime_b, datetime_c);
|
|
EXPECT_LE(datetime_b, datetime_d);
|
|
EXPECT_LE(datetime_b, datetime_e);
|
|
EXPECT_LE(datetime_c, datetime_c);
|
|
EXPECT_LE(datetime_c, datetime_d);
|
|
EXPECT_LE(datetime_c, datetime_e);
|
|
EXPECT_LE(datetime_d, datetime_d);
|
|
EXPECT_LE(datetime_d, datetime_e);
|
|
EXPECT_LE(datetime_e, datetime_e);
|
|
|
|
// Greater than
|
|
EXPECT_GT(datetime_b, datetime_a);
|
|
EXPECT_GT(datetime_c, datetime_a);
|
|
EXPECT_GT(datetime_d, datetime_a);
|
|
EXPECT_GT(datetime_e, datetime_a);
|
|
EXPECT_GT(datetime_c, datetime_b);
|
|
EXPECT_GT(datetime_d, datetime_b);
|
|
EXPECT_GT(datetime_e, datetime_b);
|
|
EXPECT_GT(datetime_d, datetime_c);
|
|
EXPECT_GT(datetime_e, datetime_c);
|
|
EXPECT_GT(datetime_e, datetime_d);
|
|
|
|
// Greater than or equal.
|
|
EXPECT_GE(datetime_a, datetime_a);
|
|
EXPECT_GE(datetime_b, datetime_a);
|
|
EXPECT_GE(datetime_c, datetime_a);
|
|
EXPECT_GE(datetime_d, datetime_a);
|
|
EXPECT_GE(datetime_e, datetime_a);
|
|
EXPECT_GE(datetime_b, datetime_b);
|
|
EXPECT_GE(datetime_c, datetime_b);
|
|
EXPECT_GE(datetime_d, datetime_b);
|
|
EXPECT_GE(datetime_e, datetime_b);
|
|
EXPECT_GE(datetime_c, datetime_c);
|
|
EXPECT_GE(datetime_d, datetime_c);
|
|
EXPECT_GE(datetime_e, datetime_c);
|
|
EXPECT_GE(datetime_d, datetime_d);
|
|
EXPECT_GE(datetime_e, datetime_d);
|
|
EXPECT_GE(datetime_e, datetime_e);
|
|
}
|
|
|
|
TEST(WvDateTimeUtilTest, Addition_WithDuration) {
|
|
const DateTime start = DateTime::FromUnixMilliseconds(kTestUnixTimeMs);
|
|
ASSERT_TRUE(start.IsSet());
|
|
|
|
const Duration one_day = Duration::FromMilliseconds(kOneDayMs);
|
|
const DateTime tomorrow = start + one_day;
|
|
ASSERT_TRUE(tomorrow.IsSet());
|
|
|
|
EXPECT_EQ(tomorrow.epoch_seconds(), kTestTimeS + Seconds(kOneDayS));
|
|
EXPECT_EQ(tomorrow.epoch_milliseconds(),
|
|
kTestTimeMs + Milliseconds(kOneDayMs));
|
|
|
|
EXPECT_EQ(tomorrow.year(), kTestYear);
|
|
EXPECT_EQ(tomorrow.month(), kTestMonth);
|
|
EXPECT_EQ(tomorrow.day(), kTestDay + 1);
|
|
EXPECT_EQ(tomorrow.day_of_year(), kTestDayOfYear + 1);
|
|
EXPECT_EQ(tomorrow.day_of_week(), DayOfWeekAddition(kTestDayOfWeek, 1));
|
|
|
|
EXPECT_EQ(tomorrow.hour(), kTestHour);
|
|
EXPECT_EQ(tomorrow.minute(), kTestMinute);
|
|
EXPECT_EQ(tomorrow.second(), kTestSecond);
|
|
EXPECT_EQ(tomorrow.millisecond(), kTestMs);
|
|
|
|
// Note: This is 30 days for April to May.
|
|
const Duration one_month = Duration::FromSeconds(kOneDayS * 30);
|
|
const DateTime next_month = start + one_month;
|
|
EXPECT_EQ(next_month.year(), kTestYear);
|
|
EXPECT_EQ(next_month.month(), kTestMonth + 1);
|
|
EXPECT_EQ(next_month.day(), kTestDay);
|
|
EXPECT_EQ(next_month.day_of_year(), kTestDayOfYear + 30);
|
|
EXPECT_EQ(next_month.day_of_week(), DayOfWeekAddition(kTestDayOfWeek, 30));
|
|
|
|
EXPECT_EQ(next_month.hour(), kTestHour);
|
|
EXPECT_EQ(next_month.minute(), kTestMinute);
|
|
EXPECT_EQ(next_month.second(), kTestSecond);
|
|
EXPECT_EQ(next_month.millisecond(), kTestMs);
|
|
|
|
// Note: This should roll over a day.
|
|
const uint32_t day_inc_11h = (kTestHour + 11) / 24;
|
|
const Duration eleven_hours = Duration::FromSeconds(kOneHourS * 11);
|
|
const DateTime hours_later = start + eleven_hours;
|
|
EXPECT_EQ(hours_later.year(), kTestYear);
|
|
EXPECT_EQ(hours_later.month(), kTestMonth);
|
|
EXPECT_EQ(hours_later.day(), kTestDay + day_inc_11h);
|
|
EXPECT_EQ(hours_later.day_of_year(), kTestDayOfYear + day_inc_11h);
|
|
EXPECT_EQ(hours_later.day_of_week(),
|
|
DayOfWeekAddition(kTestDayOfWeek, day_inc_11h));
|
|
|
|
const uint32_t new_hour_11h = (kTestHour + 11) % 24;
|
|
EXPECT_EQ(hours_later.hour(), new_hour_11h);
|
|
EXPECT_EQ(hours_later.minute(), kTestMinute);
|
|
EXPECT_EQ(hours_later.second(), kTestSecond);
|
|
EXPECT_EQ(hours_later.millisecond(), kTestMs);
|
|
|
|
const Duration five_years =
|
|
Duration::FromSeconds(kOneCommonYearS * 4 + kOneLeapYearS);
|
|
const DateTime fewer_years_later = start + five_years;
|
|
EXPECT_EQ(fewer_years_later.year(), kTestYear + 5);
|
|
EXPECT_EQ(fewer_years_later.month(), kTestMonth);
|
|
EXPECT_EQ(fewer_years_later.day(), kTestDay);
|
|
|
|
EXPECT_EQ(fewer_years_later.hour(), kTestHour);
|
|
EXPECT_EQ(fewer_years_later.minute(), kTestMinute);
|
|
EXPECT_EQ(fewer_years_later.second(), kTestSecond);
|
|
EXPECT_EQ(fewer_years_later.millisecond(), kTestMs);
|
|
|
|
const DateTime same_time = start + Duration::Zero();
|
|
EXPECT_EQ(start, same_time);
|
|
}
|
|
|
|
TEST(WvDateTimeUtilTest, Addition_WithDuration_Invalid) {
|
|
// Addition with an unset date time is not allowed.
|
|
const DateTime unset;
|
|
ASSERT_FALSE(unset.IsSet());
|
|
const Duration one_month = Duration::FromSeconds(kOneDayS * 30);
|
|
DateTime result = unset + one_month;
|
|
EXPECT_FALSE(result.IsSet());
|
|
|
|
// Addition that causes overflow is not allowed.
|
|
result = DateTime::Max() + Duration::FromMilliseconds(1);
|
|
EXPECT_FALSE(result.IsSet());
|
|
|
|
result = DateTime::Min() + Duration::FromSeconds(kOneCommonYearS * 10000);
|
|
EXPECT_FALSE(result.IsSet());
|
|
}
|
|
|
|
TEST(WvDateTimeUtilTest, Subtraction_WithDuration) {
|
|
const DateTime start = DateTime::FromUnixMilliseconds(kTestUnixTimeMs);
|
|
ASSERT_TRUE(start.IsSet());
|
|
|
|
const Duration one_day = Duration::FromMilliseconds(kOneDayMs);
|
|
const DateTime yesterday = start - one_day;
|
|
ASSERT_TRUE(yesterday.IsSet());
|
|
|
|
EXPECT_EQ(yesterday.epoch_seconds(), Seconds(kTestUnixTimeS - kOneDayS));
|
|
EXPECT_EQ(yesterday.epoch_milliseconds(),
|
|
Milliseconds(kTestUnixTimeMs - kOneDayMs));
|
|
|
|
EXPECT_EQ(yesterday.year(), kTestYear);
|
|
EXPECT_EQ(yesterday.month(), kTestMonth);
|
|
EXPECT_EQ(yesterday.day(), kTestDay - 1);
|
|
EXPECT_EQ(yesterday.day_of_year(), kTestDayOfYear - 1);
|
|
EXPECT_EQ(yesterday.day_of_week(), DayOfWeekSubtraction(kTestDayOfWeek, 1));
|
|
|
|
EXPECT_EQ(yesterday.hour(), kTestHour);
|
|
EXPECT_EQ(yesterday.minute(), kTestMinute);
|
|
EXPECT_EQ(yesterday.second(), kTestSecond);
|
|
EXPECT_EQ(yesterday.millisecond(), kTestMs);
|
|
|
|
// Note: This is a 31 days for March.
|
|
const Duration one_month = Duration::FromSeconds(kOneDayS * 31);
|
|
const DateTime previous_month = start - one_month;
|
|
EXPECT_EQ(previous_month.year(), kTestYear);
|
|
EXPECT_EQ(previous_month.month(), kTestMonth - 1);
|
|
EXPECT_EQ(previous_month.day(), kTestDay);
|
|
EXPECT_EQ(previous_month.day_of_year(), kTestDayOfYear - 31);
|
|
EXPECT_EQ(previous_month.day_of_week(),
|
|
DayOfWeekSubtraction(kTestDayOfWeek, 31));
|
|
|
|
EXPECT_EQ(previous_month.hour(), kTestHour);
|
|
EXPECT_EQ(previous_month.minute(), kTestMinute);
|
|
EXPECT_EQ(previous_month.second(), kTestSecond);
|
|
EXPECT_EQ(previous_month.millisecond(), kTestMs);
|
|
|
|
const uint32_t day_dec_14h = (kTestHour < 14) ? 1 : 0;
|
|
const Duration fourteen_hours = Duration::FromSeconds(kOneHourS * 14);
|
|
const DateTime hours_earlier = start - fourteen_hours;
|
|
EXPECT_EQ(yesterday.year(), kTestYear);
|
|
EXPECT_EQ(yesterday.month(), kTestMonth);
|
|
EXPECT_EQ(yesterday.day(), kTestDay - day_dec_14h);
|
|
EXPECT_EQ(yesterday.day_of_year(), kTestDayOfYear - day_dec_14h);
|
|
EXPECT_EQ(yesterday.day_of_week(),
|
|
DayOfWeekSubtraction(kTestDayOfWeek, day_dec_14h));
|
|
|
|
const uint32_t new_hour_14h =
|
|
(kTestHour < 14) ? (kTestHour + 10) : kTestHour - 14;
|
|
EXPECT_EQ(hours_earlier.hour(), new_hour_14h);
|
|
EXPECT_EQ(hours_earlier.minute(), kTestMinute);
|
|
EXPECT_EQ(hours_earlier.second(), kTestSecond);
|
|
EXPECT_EQ(hours_earlier.millisecond(), kTestMs);
|
|
|
|
const Duration five_years =
|
|
Duration::FromSeconds(kOneCommonYearS * 3 + kOneLeapYearS * 2);
|
|
const DateTime few_years_earlier = start - five_years;
|
|
EXPECT_EQ(few_years_earlier.year(), kTestYear - 5);
|
|
EXPECT_EQ(few_years_earlier.month(), kTestMonth);
|
|
EXPECT_EQ(few_years_earlier.day(), kTestDay);
|
|
|
|
EXPECT_EQ(few_years_earlier.hour(), kTestHour);
|
|
EXPECT_EQ(few_years_earlier.minute(), kTestMinute);
|
|
EXPECT_EQ(few_years_earlier.second(), kTestSecond);
|
|
EXPECT_EQ(few_years_earlier.millisecond(), kTestMs);
|
|
|
|
const DateTime same_time = start - Duration::Zero();
|
|
EXPECT_EQ(start, same_time);
|
|
}
|
|
|
|
TEST(WvDateTimeUtilTest, Subtraction_WithDuration_Invalid) {
|
|
// Subtract with an unset date time is not allowed.
|
|
const DateTime unset;
|
|
ASSERT_FALSE(unset.IsSet());
|
|
const Duration one_month = Duration::FromSeconds(kOneDayS * 30);
|
|
DateTime result = unset - one_month;
|
|
EXPECT_FALSE(result.IsSet());
|
|
|
|
// Subtract that causes overflow is not allowed.
|
|
result = DateTime::Min() - Duration::FromMilliseconds(1);
|
|
EXPECT_FALSE(result.IsSet());
|
|
|
|
result = DateTime::Max() - Duration::FromSeconds(kOneCommonYearS * 10000);
|
|
EXPECT_FALSE(result.IsSet());
|
|
}
|
|
|
|
TEST(WvDateTimeUtilTest, Difference) {
|
|
const Duration expected_diff =
|
|
Duration(Hours(15) + Minutes(6) + Seconds(30) + Milliseconds(123));
|
|
const DateTime datetime_a =
|
|
DateTime::FromUnixSeconds(kTestUnixTimeS, kTestMs);
|
|
const DateTime datetime_b = DateTime::FromUnixMilliseconds(
|
|
datetime_a.epoch_milliseconds() + expected_diff.total_milliseconds());
|
|
|
|
const Duration diff_ab = datetime_b - datetime_a;
|
|
EXPECT_EQ(diff_ab, expected_diff);
|
|
|
|
const Duration diff_ba = datetime_a - datetime_b;
|
|
EXPECT_EQ(diff_ba, -expected_diff);
|
|
|
|
// Very big diff
|
|
const Duration diff_min_max = DateTime::Max() - DateTime::Min();
|
|
EXPECT_TRUE(diff_min_max.IsPositive());
|
|
const Duration diff_max_min = DateTime::Min() - DateTime::Max();
|
|
EXPECT_TRUE(diff_max_min.IsNegative());
|
|
EXPECT_EQ(diff_min_max, -diff_max_min);
|
|
|
|
// No difference.
|
|
const Duration diff_aa = datetime_a - datetime_a;
|
|
EXPECT_TRUE(diff_aa.IsZero());
|
|
}
|
|
|
|
TEST(WvDateTimeUtilTest, Difference_Invalid) {
|
|
const DateTime datetime = DateTime::FromUnixSeconds(kTestUnixTimeS, kTestMs);
|
|
const DateTime unset;
|
|
|
|
Duration diff = datetime - unset;
|
|
EXPECT_TRUE(diff.IsZero());
|
|
|
|
diff = unset - datetime;
|
|
EXPECT_TRUE(diff.IsZero());
|
|
}
|
|
|
|
TEST(WvDateTimeUtilTest, ToString) {
|
|
// Default should ISO date times with short timezones, and milliseconds
|
|
// only printed if non-zero.
|
|
DateTime datetime = DateTime::FromUnixSeconds(kTestUnixTimeS, kTestMs);
|
|
EXPECT_EQ(datetime.ToString(), "2024-04-19T13:36:18.507Z");
|
|
datetime = DateTime::FromUnixSeconds(kTestUnixTimeS);
|
|
EXPECT_EQ(datetime.ToString(), "2024-04-19T13:36:18Z");
|
|
|
|
EXPECT_EQ(DateTime::Min().ToString(), "1970-01-01T00:00:00.001Z");
|
|
EXPECT_EQ(DateTime::Max().ToString(), "9999-12-31T23:59:59.999Z");
|
|
|
|
EXPECT_EQ(DateTime().ToString(), "<unset>");
|
|
}
|
|
} // namespace test
|
|
} // namespace wvutil
|