1159 lines
40 KiB
C++
1159 lines
40 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_duration.h"
|
|
|
|
#include <inttypes.h>
|
|
|
|
#include <chrono>
|
|
|
|
#include <gtest/gtest.h>
|
|
|
|
namespace wvutil {
|
|
namespace test {
|
|
namespace {
|
|
// Milliseconds per second.
|
|
constexpr int64_t kMsPerS = 1000;
|
|
// Seconds per minute.
|
|
constexpr int64_t kSPerM = 60;
|
|
// Minutes per hour.
|
|
constexpr int64_t kMPerH = 60;
|
|
// Hours per day.
|
|
constexpr int64_t kHPerD = 24;
|
|
|
|
// Milliseconds per minute.
|
|
constexpr int64_t kMsPerM = kMsPerS * kSPerM;
|
|
// Milliseconds per hour.
|
|
constexpr int64_t kMsPerH = kMsPerM * kMPerH;
|
|
// Milliseconds per day.
|
|
constexpr int64_t kMsPerD = kMsPerH * kHPerD;
|
|
|
|
// Seconds per hour.
|
|
constexpr int64_t kSPerH = kSPerM * kMPerH;
|
|
// Seconds per day.
|
|
constexpr int64_t kSPerD = kSPerH * kHPerD;
|
|
|
|
// Minutes per day.
|
|
constexpr int64_t kMPerD = kMPerH * kHPerD;
|
|
} // namespace
|
|
|
|
// Note: Using "WvDurationUtilTest" instead of "DurationTest" as
|
|
// it be confused with policy duration tests.
|
|
|
|
TEST(WvDurationUtilTest, SpecialInitializers) {
|
|
const Duration zero = Duration::Zero();
|
|
EXPECT_TRUE(zero.IsZero());
|
|
EXPECT_FALSE(zero.IsNegative());
|
|
EXPECT_FALSE(zero.IsPositive());
|
|
EXPECT_TRUE(zero.IsNonNegative());
|
|
EXPECT_EQ(zero.total_milliseconds().count(), 0);
|
|
EXPECT_EQ(zero.total_seconds().count(), 0);
|
|
EXPECT_EQ(zero.total_minutes().count(), 0);
|
|
EXPECT_EQ(zero.total_hours().count(), 0);
|
|
EXPECT_EQ(zero.total_days().count(), 0);
|
|
|
|
const Duration positive_seconds = Duration::FromSeconds(104000);
|
|
EXPECT_FALSE(positive_seconds.IsZero());
|
|
EXPECT_FALSE(positive_seconds.IsNegative());
|
|
EXPECT_TRUE(positive_seconds.IsPositive());
|
|
EXPECT_TRUE(positive_seconds.IsNonNegative());
|
|
// Totals
|
|
EXPECT_EQ(positive_seconds.total_milliseconds().count(), 104000000);
|
|
EXPECT_EQ(positive_seconds.total_seconds().count(), 104000);
|
|
EXPECT_EQ(positive_seconds.total_minutes().count(), 1733);
|
|
EXPECT_EQ(positive_seconds.total_hours().count(), 28);
|
|
EXPECT_EQ(positive_seconds.total_days().count(), 1);
|
|
// Components
|
|
EXPECT_EQ(positive_seconds.milliseconds(), 0u);
|
|
EXPECT_EQ(positive_seconds.seconds(), 20u);
|
|
EXPECT_EQ(positive_seconds.minutes(), 53u);
|
|
EXPECT_EQ(positive_seconds.hours(), 4u);
|
|
EXPECT_EQ(positive_seconds.days(), 1u);
|
|
|
|
const Duration positive_milliseconds = Duration::FromMilliseconds(104000123);
|
|
EXPECT_FALSE(positive_milliseconds.IsZero());
|
|
EXPECT_FALSE(positive_milliseconds.IsNegative());
|
|
EXPECT_TRUE(positive_milliseconds.IsPositive());
|
|
EXPECT_TRUE(positive_milliseconds.IsNonNegative());
|
|
// Totals
|
|
EXPECT_EQ(positive_milliseconds.total_milliseconds().count(), 104000123);
|
|
EXPECT_EQ(positive_milliseconds.total_seconds().count(), 104000);
|
|
EXPECT_EQ(positive_milliseconds.total_minutes().count(), 1733);
|
|
EXPECT_EQ(positive_milliseconds.total_hours().count(), 28);
|
|
EXPECT_EQ(positive_milliseconds.total_days().count(), 1);
|
|
// Components
|
|
EXPECT_EQ(positive_milliseconds.milliseconds(), 123u);
|
|
EXPECT_EQ(positive_milliseconds.seconds(), 20u);
|
|
EXPECT_EQ(positive_milliseconds.minutes(), 53u);
|
|
EXPECT_EQ(positive_milliseconds.hours(), 4u);
|
|
EXPECT_EQ(positive_milliseconds.days(), 1u);
|
|
|
|
const Duration negative_seconds = Duration::FromSeconds(-104000);
|
|
EXPECT_FALSE(negative_seconds.IsZero());
|
|
EXPECT_TRUE(negative_seconds.IsNegative());
|
|
EXPECT_FALSE(negative_seconds.IsPositive());
|
|
EXPECT_FALSE(negative_seconds.IsNonNegative());
|
|
// Totals
|
|
EXPECT_EQ(negative_seconds.total_milliseconds().count(), -104000000);
|
|
EXPECT_EQ(negative_seconds.total_seconds().count(), -104000);
|
|
EXPECT_EQ(negative_seconds.total_minutes().count(), -1733);
|
|
EXPECT_EQ(negative_seconds.total_hours().count(), -28);
|
|
EXPECT_EQ(negative_seconds.total_days().count(), -1);
|
|
// Components (presented as positives)
|
|
EXPECT_EQ(negative_seconds.milliseconds(), 0u);
|
|
EXPECT_EQ(negative_seconds.seconds(), 20u);
|
|
EXPECT_EQ(negative_seconds.minutes(), 53u);
|
|
EXPECT_EQ(negative_seconds.hours(), 4u);
|
|
EXPECT_EQ(negative_seconds.days(), 1u);
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, GetAbsolute) {
|
|
const Duration positive = Duration::FromMilliseconds(4000123);
|
|
const Duration negative = Duration::FromMilliseconds(-4000123);
|
|
const Duration zero = Duration::Zero();
|
|
EXPECT_EQ(negative.GetAbsolute(), positive);
|
|
EXPECT_EQ(positive.GetAbsolute(), positive);
|
|
EXPECT_EQ(zero.GetAbsolute(), zero);
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, GetTruncate) {
|
|
// Truncate a positive value.
|
|
const Duration positive_milliseconds = Duration::FromMilliseconds(104000123);
|
|
// Expected values of |positive_milliseconds|
|
|
const Duration positive_seconds = Duration::FromSeconds(104000);
|
|
const Duration positive_minutes = Duration::FromSeconds(1733 * 60);
|
|
const Duration positive_hours = Duration::FromSeconds(28 * 60 * 60);
|
|
const Duration positive_days = Duration::FromSeconds(1 * 24 * 60 * 60);
|
|
EXPECT_EQ(positive_milliseconds.GetTruncateBySeconds(), positive_seconds);
|
|
EXPECT_EQ(positive_milliseconds.GetTruncateByMinutes(), positive_minutes);
|
|
EXPECT_EQ(positive_milliseconds.GetTruncateByHours(), positive_hours);
|
|
EXPECT_EQ(positive_milliseconds.GetTruncateByDays(), positive_days);
|
|
|
|
// Truncate a negative value.
|
|
const Duration negative_milliseconds = Duration::FromMilliseconds(-104000123);
|
|
// Expected values of |negative_milliseconds|
|
|
const Duration negative_seconds = Duration::FromSeconds(-104000);
|
|
const Duration negative_minutes = Duration::FromSeconds(-(1733 * 60));
|
|
const Duration negative_hours = Duration::FromSeconds(-(28 * 60 * 60));
|
|
const Duration negative_days = Duration::FromSeconds(-(1 * 24 * 60 * 60));
|
|
EXPECT_EQ(negative_milliseconds.GetTruncateBySeconds(), negative_seconds);
|
|
EXPECT_EQ(negative_milliseconds.GetTruncateByMinutes(), negative_minutes);
|
|
EXPECT_EQ(negative_milliseconds.GetTruncateByHours(), negative_hours);
|
|
EXPECT_EQ(negative_milliseconds.GetTruncateByDays(), negative_days);
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, Comparison) {
|
|
const Duration duration_a = Duration::FromMilliseconds(-4000123);
|
|
const Duration duration_b = Duration::FromSeconds(-4000);
|
|
const Duration duration_c = Duration::Zero();
|
|
const Duration duration_d = Duration::FromSeconds(4000);
|
|
const Duration duration_e = Duration::FromMilliseconds(4000123);
|
|
|
|
// Equality
|
|
EXPECT_EQ(duration_a, duration_a);
|
|
EXPECT_EQ(duration_b, duration_b);
|
|
EXPECT_EQ(duration_c, duration_c);
|
|
EXPECT_EQ(duration_d, duration_d);
|
|
EXPECT_EQ(duration_e, duration_e);
|
|
|
|
// Inequality.
|
|
EXPECT_NE(duration_a, duration_b);
|
|
EXPECT_NE(duration_a, duration_c);
|
|
EXPECT_NE(duration_a, duration_d);
|
|
EXPECT_NE(duration_a, duration_e);
|
|
EXPECT_NE(duration_b, duration_c);
|
|
EXPECT_NE(duration_b, duration_d);
|
|
EXPECT_NE(duration_b, duration_e);
|
|
EXPECT_NE(duration_c, duration_d);
|
|
EXPECT_NE(duration_c, duration_e);
|
|
EXPECT_NE(duration_d, duration_e);
|
|
|
|
// Less than
|
|
EXPECT_LT(duration_a, duration_b);
|
|
EXPECT_LT(duration_a, duration_c);
|
|
EXPECT_LT(duration_a, duration_d);
|
|
EXPECT_LT(duration_a, duration_e);
|
|
EXPECT_LT(duration_b, duration_c);
|
|
EXPECT_LT(duration_b, duration_d);
|
|
EXPECT_LT(duration_b, duration_e);
|
|
EXPECT_LT(duration_c, duration_d);
|
|
EXPECT_LT(duration_c, duration_e);
|
|
EXPECT_LT(duration_d, duration_e);
|
|
|
|
// Less than or equal.
|
|
EXPECT_LE(duration_a, duration_a);
|
|
EXPECT_LE(duration_a, duration_b);
|
|
EXPECT_LE(duration_a, duration_c);
|
|
EXPECT_LE(duration_a, duration_d);
|
|
EXPECT_LE(duration_a, duration_e);
|
|
EXPECT_LE(duration_b, duration_b);
|
|
EXPECT_LE(duration_b, duration_c);
|
|
EXPECT_LE(duration_b, duration_d);
|
|
EXPECT_LE(duration_b, duration_e);
|
|
EXPECT_LE(duration_c, duration_c);
|
|
EXPECT_LE(duration_c, duration_d);
|
|
EXPECT_LE(duration_c, duration_e);
|
|
EXPECT_LE(duration_d, duration_d);
|
|
EXPECT_LE(duration_d, duration_e);
|
|
EXPECT_LE(duration_e, duration_e);
|
|
|
|
// Greater than
|
|
EXPECT_GT(duration_b, duration_a);
|
|
EXPECT_GT(duration_c, duration_a);
|
|
EXPECT_GT(duration_d, duration_a);
|
|
EXPECT_GT(duration_e, duration_a);
|
|
EXPECT_GT(duration_c, duration_b);
|
|
EXPECT_GT(duration_d, duration_b);
|
|
EXPECT_GT(duration_e, duration_b);
|
|
EXPECT_GT(duration_d, duration_c);
|
|
EXPECT_GT(duration_e, duration_c);
|
|
EXPECT_GT(duration_e, duration_d);
|
|
|
|
// Greater than or equal.
|
|
EXPECT_GE(duration_a, duration_a);
|
|
EXPECT_GE(duration_b, duration_a);
|
|
EXPECT_GE(duration_c, duration_a);
|
|
EXPECT_GE(duration_d, duration_a);
|
|
EXPECT_GE(duration_e, duration_a);
|
|
EXPECT_GE(duration_b, duration_b);
|
|
EXPECT_GE(duration_c, duration_b);
|
|
EXPECT_GE(duration_d, duration_b);
|
|
EXPECT_GE(duration_e, duration_b);
|
|
EXPECT_GE(duration_c, duration_c);
|
|
EXPECT_GE(duration_d, duration_c);
|
|
EXPECT_GE(duration_e, duration_c);
|
|
EXPECT_GE(duration_d, duration_d);
|
|
EXPECT_GE(duration_e, duration_d);
|
|
EXPECT_GE(duration_e, duration_e);
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, Comparison_WithChronoDuration) {
|
|
// 1h6m40s123ms
|
|
const Duration duration = Duration::FromMilliseconds(104000123);
|
|
|
|
// Equality
|
|
EXPECT_EQ(duration, Milliseconds(104000123));
|
|
EXPECT_EQ(duration, Microseconds(104000123000));
|
|
EXPECT_EQ(duration, Nanoseconds(104000123000000));
|
|
// Equality (after truncation)
|
|
EXPECT_EQ(duration.GetTruncateByDays(), Days(1));
|
|
EXPECT_EQ(duration.GetTruncateByHours(), Hours(28));
|
|
EXPECT_EQ(duration.GetTruncateByMinutes(), Minutes(1733));
|
|
EXPECT_EQ(duration.GetTruncateBySeconds(), Seconds(104000));
|
|
|
|
// Inequality (slight differences).
|
|
EXPECT_NE(duration, Milliseconds(104000124));
|
|
EXPECT_NE(duration, Microseconds(104000122999));
|
|
EXPECT_NE(duration, Nanoseconds(104000123000001));
|
|
// Inequality (equal if truncated)
|
|
EXPECT_NE(duration, Days(1));
|
|
EXPECT_NE(duration, Hours(28));
|
|
EXPECT_NE(duration, Minutes(1733));
|
|
EXPECT_NE(duration, Seconds(104000));
|
|
|
|
// Less than (slight differences).
|
|
EXPECT_LT(duration, Milliseconds(104000124));
|
|
EXPECT_LT(duration, Microseconds(104000123001));
|
|
EXPECT_LT(duration, Nanoseconds(104000123000001));
|
|
// Less than (larger difference).
|
|
EXPECT_LT(duration, Days(2));
|
|
EXPECT_LT(duration, Hours(29));
|
|
EXPECT_LT(duration, Minutes(1734));
|
|
EXPECT_LT(duration, Seconds(104001));
|
|
|
|
// Less than or equal (check equal)
|
|
EXPECT_LE(duration, Milliseconds(104000123));
|
|
EXPECT_LE(duration, Microseconds(104000123000));
|
|
EXPECT_LE(duration, Nanoseconds(104000123000000));
|
|
// Less than or equal (slight difference)
|
|
EXPECT_LE(duration, Milliseconds(104000124));
|
|
EXPECT_LE(duration, Microseconds(104000123001));
|
|
EXPECT_LE(duration, Nanoseconds(104000123000001));
|
|
// Less than or equal (larger differences).
|
|
EXPECT_LE(duration, Days(2));
|
|
EXPECT_LE(duration, Hours(29));
|
|
EXPECT_LE(duration, Minutes(1734));
|
|
EXPECT_LE(duration, Seconds(104001));
|
|
|
|
// Greater than (slight differences).
|
|
EXPECT_GT(duration, Milliseconds(104000122));
|
|
EXPECT_GT(duration, Microseconds(104000122999));
|
|
EXPECT_GT(duration, Nanoseconds(104000122999999));
|
|
// Less than (larger difference)
|
|
EXPECT_GT(duration, Days(1));
|
|
EXPECT_GT(duration, Hours(28));
|
|
EXPECT_GT(duration, Minutes(1733));
|
|
EXPECT_GT(duration, Seconds(104000));
|
|
|
|
// Greater than or equal (check equal)
|
|
EXPECT_GE(duration, Milliseconds(104000123));
|
|
EXPECT_GE(duration, Microseconds(104000123000));
|
|
EXPECT_GE(duration, Nanoseconds(104000123000000));
|
|
// Greater than or equal (slight difference)
|
|
EXPECT_GE(duration, Milliseconds(104000122));
|
|
EXPECT_GE(duration, Microseconds(104000122999));
|
|
EXPECT_GE(duration, Nanoseconds(104000122999999));
|
|
// Greater than or equal (larger differences).
|
|
EXPECT_GE(duration, Days(1));
|
|
EXPECT_GE(duration, Hours(28));
|
|
EXPECT_GE(duration, Minutes(1733));
|
|
EXPECT_GE(duration, Seconds(104000));
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, UnaryPlusMinus) {
|
|
const Duration negative_milliseconds = Duration::FromMilliseconds(-4000123);
|
|
const Duration negative_seconds = Duration::FromSeconds(-4000);
|
|
const Duration zero = Duration::Zero();
|
|
const Duration positive_seconds = Duration::FromSeconds(4000);
|
|
const Duration positive_milliseconds = Duration::FromMilliseconds(4000123);
|
|
|
|
// + operator
|
|
EXPECT_EQ(+negative_milliseconds, negative_milliseconds);
|
|
EXPECT_EQ(+negative_seconds, negative_seconds);
|
|
EXPECT_EQ(+zero, zero);
|
|
EXPECT_EQ(+positive_seconds, positive_seconds);
|
|
EXPECT_EQ(+positive_milliseconds, positive_milliseconds);
|
|
|
|
// - operator
|
|
EXPECT_EQ(-negative_milliseconds, positive_milliseconds);
|
|
EXPECT_EQ(-negative_seconds, positive_seconds);
|
|
EXPECT_EQ(-zero, zero);
|
|
EXPECT_EQ(-positive_seconds, negative_seconds);
|
|
EXPECT_EQ(-positive_milliseconds, negative_milliseconds);
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, Addition) {
|
|
const Duration ps = Duration::FromSeconds(4000);
|
|
const Duration pms = Duration::FromMilliseconds(123);
|
|
const Duration pt = Duration::FromMilliseconds(4000123);
|
|
const Duration ns = Duration::FromSeconds(-4000);
|
|
const Duration nms = Duration::FromMilliseconds(-123);
|
|
const Duration nt = Duration::FromMilliseconds(-4000123);
|
|
const Duration zero = Duration::Zero();
|
|
|
|
// Positive + positive
|
|
EXPECT_EQ(ps + pms, pt);
|
|
// Positive + negative
|
|
EXPECT_EQ(pt + nms, ps);
|
|
EXPECT_EQ(pt + ns, pms);
|
|
EXPECT_EQ(pt + nt, zero);
|
|
EXPECT_EQ(ps + ns, zero);
|
|
EXPECT_EQ(pms + nms, zero);
|
|
// Positive + zero
|
|
EXPECT_EQ(pt + zero, pt);
|
|
EXPECT_EQ(ps + zero, ps);
|
|
EXPECT_EQ(pms + zero, pms);
|
|
// Negative + negative
|
|
EXPECT_EQ(ns + nms, nt);
|
|
// Negative + positive
|
|
EXPECT_EQ(nt + pms, ns);
|
|
EXPECT_EQ(nt + ps, nms);
|
|
EXPECT_EQ(nt + pt, zero);
|
|
EXPECT_EQ(ns + ps, zero);
|
|
EXPECT_EQ(nms + pms, zero);
|
|
// Negative + zero
|
|
EXPECT_EQ(nt + zero, nt);
|
|
EXPECT_EQ(ns + zero, ns);
|
|
EXPECT_EQ(nms + zero, nms);
|
|
// Zero + zero
|
|
EXPECT_EQ(zero + zero, zero);
|
|
// Zero + positive
|
|
EXPECT_EQ(zero + pt, pt);
|
|
EXPECT_EQ(zero + ps, ps);
|
|
EXPECT_EQ(zero + pms, pms);
|
|
// Zero + negative
|
|
EXPECT_EQ(zero + nt, nt);
|
|
EXPECT_EQ(zero + ns, ns);
|
|
EXPECT_EQ(zero + nms, nms);
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, Subtraction) {
|
|
const Duration ps = Duration::FromSeconds(4000);
|
|
const Duration pms = Duration::FromMilliseconds(123);
|
|
const Duration pt = Duration::FromMilliseconds(4000123);
|
|
const Duration ns = Duration::FromSeconds(-4000);
|
|
const Duration nms = Duration::FromMilliseconds(-123);
|
|
const Duration nt = Duration::FromMilliseconds(-4000123);
|
|
const Duration zero = Duration::Zero();
|
|
// Positive - positive
|
|
EXPECT_EQ(pt - pms, ps);
|
|
EXPECT_EQ(pt - ps, pms);
|
|
EXPECT_EQ(pt - pt, zero);
|
|
EXPECT_EQ(ps - ps, zero);
|
|
EXPECT_EQ(pms - pms, zero);
|
|
// Positive - negative
|
|
EXPECT_EQ(ps - nms, pt);
|
|
EXPECT_EQ(pms - ns, pt);
|
|
// Positive - zero
|
|
EXPECT_EQ(pt - zero, pt);
|
|
EXPECT_EQ(ps - zero, ps);
|
|
EXPECT_EQ(pms - zero, pms);
|
|
// Negative - negative
|
|
EXPECT_EQ(nt - ns, nms);
|
|
EXPECT_EQ(nt - nms, ns);
|
|
EXPECT_EQ(nt - nt, zero);
|
|
EXPECT_EQ(ns - ns, zero);
|
|
EXPECT_EQ(nms - nms, zero);
|
|
// Negative - positive
|
|
EXPECT_EQ(ns - pms, nt);
|
|
EXPECT_EQ(nms - ps, nt);
|
|
// Negative - zero
|
|
EXPECT_EQ(nt - zero, nt);
|
|
EXPECT_EQ(ns - zero, ns);
|
|
EXPECT_EQ(nms - zero, nms);
|
|
// Zero - zero
|
|
EXPECT_EQ(zero - zero, zero);
|
|
// Zero - positive
|
|
EXPECT_EQ(zero - pt, nt);
|
|
EXPECT_EQ(zero - ps, ns);
|
|
EXPECT_EQ(zero - pms, nms);
|
|
// Zero - negative
|
|
EXPECT_EQ(zero - nt, pt);
|
|
EXPECT_EQ(zero - ns, ps);
|
|
EXPECT_EQ(zero - nms, pms);
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, Addition_WithChronoDuration) {
|
|
const Duration ps = Duration::FromSeconds(104000);
|
|
const Duration pms = Duration::FromMilliseconds(123);
|
|
const Duration pt = Duration::FromMilliseconds(104000123);
|
|
const Duration ns = Duration::FromSeconds(-104000);
|
|
const Duration nms = Duration::FromMilliseconds(-123);
|
|
const Duration nt = Duration::FromMilliseconds(-104000123);
|
|
const Duration zero = Duration::Zero();
|
|
// Positive + positive (small units).
|
|
EXPECT_EQ(ps + Milliseconds(123), pt);
|
|
// Positive + positive (large units).
|
|
EXPECT_EQ(pms + Seconds(104000), pt);
|
|
EXPECT_EQ(pms + Minutes(1733) + Seconds(20), pt);
|
|
EXPECT_EQ(pms + Hours(28) + Minutes(53) + Seconds(20), pt);
|
|
EXPECT_EQ(pms + Days(1) + Hours(4) + Minutes(53) + Seconds(20), pt);
|
|
// Positive + negative (small units)
|
|
EXPECT_EQ(pt + Milliseconds(-123), ps);
|
|
// Positive + negative (large units)
|
|
EXPECT_EQ(pt + Seconds(-104000), pms);
|
|
EXPECT_EQ(pt + Minutes(-1733) + Seconds(-20), pms);
|
|
EXPECT_EQ(pt + Hours(-28) + Minutes(-53) + Seconds(-20), pms);
|
|
EXPECT_EQ(pt + Days(-1) + Hours(-4) + Minutes(-53) + Seconds(-20), pms);
|
|
// Positive + zero (all units)
|
|
EXPECT_EQ(pt + Milliseconds::zero(), pt);
|
|
EXPECT_EQ(pt + Seconds::zero(), pt);
|
|
EXPECT_EQ(pt + Minutes::zero(), pt);
|
|
EXPECT_EQ(pt + Hours::zero(), pt);
|
|
|
|
// Negative + positive (small units).
|
|
EXPECT_EQ(nt + Milliseconds(123), ns);
|
|
// Negative + positive (large units).
|
|
EXPECT_EQ(nt + Seconds(104000), nms);
|
|
EXPECT_EQ(nt + Minutes(1733) + Seconds(20), nms);
|
|
EXPECT_EQ(nt + Hours(28) + Minutes(53) + Seconds(20), nms);
|
|
EXPECT_EQ(nt + Days(1) + Hours(4) + Minutes(53) + Seconds(20), nms);
|
|
// Negative + negative (small units)
|
|
EXPECT_EQ(ns + Milliseconds(-123), nt);
|
|
// Negative + negative (large units)
|
|
EXPECT_EQ(nms + Seconds(-104000), nt);
|
|
EXPECT_EQ(nms + Minutes(-1733) + Seconds(-20), nt);
|
|
EXPECT_EQ(nms + Hours(-28) + Minutes(-53) + Seconds(-20), nt);
|
|
EXPECT_EQ(nms + Days(-1) + Hours(-4) + Minutes(-53) + Seconds(-20), nt);
|
|
// Negative + zero (all units)
|
|
EXPECT_EQ(nt + Milliseconds::zero(), nt);
|
|
EXPECT_EQ(nt + Seconds::zero(), nt);
|
|
EXPECT_EQ(nt + Minutes::zero(), nt);
|
|
EXPECT_EQ(nt + Hours::zero(), nt);
|
|
|
|
// Zero + zero (all units)
|
|
EXPECT_EQ(zero + Milliseconds::zero(), zero);
|
|
EXPECT_EQ(zero + Seconds::zero(), zero);
|
|
EXPECT_EQ(zero + Minutes::zero(), zero);
|
|
EXPECT_EQ(zero + Hours::zero(), zero);
|
|
// Zero + positive (small units)
|
|
EXPECT_EQ(zero + Milliseconds(123), pms);
|
|
// Zero + positive (large units)
|
|
EXPECT_EQ(zero + Seconds(104000), ps);
|
|
EXPECT_EQ(zero + Minutes(1733) + Seconds(20), ps);
|
|
EXPECT_EQ(zero + Hours(28) + Minutes(53) + Seconds(20), ps);
|
|
EXPECT_EQ(zero + Days(1) + Hours(4) + Minutes(53) + Seconds(20), ps);
|
|
// Zero + negative (small units)
|
|
EXPECT_EQ(zero + Milliseconds(-123), nms);
|
|
// Zero + negative (large units)
|
|
EXPECT_EQ(zero + Seconds(-104000), ns);
|
|
EXPECT_EQ(zero + Minutes(-1733) + Seconds(-20), ns);
|
|
EXPECT_EQ(zero + Hours(-28) + Minutes(-53) + Seconds(-20), ns);
|
|
EXPECT_EQ(zero + Days(-1) + Hours(-4) + Minutes(-53) + Seconds(-20), ns);
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, Subtraction_WithChronoDuration) {
|
|
const Duration ps = Duration::FromSeconds(4000);
|
|
const Duration pms = Duration::FromMilliseconds(123);
|
|
const Duration pt = Duration::FromMilliseconds(4000123);
|
|
const Duration ns = Duration::FromSeconds(-4000);
|
|
const Duration nms = Duration::FromMilliseconds(-123);
|
|
const Duration nt = Duration::FromMilliseconds(-4000123);
|
|
const Duration zero = Duration::Zero();
|
|
|
|
// Positive - positive (small units).
|
|
EXPECT_EQ(pt - Milliseconds(123), ps);
|
|
// Positive - positive (large units).
|
|
EXPECT_EQ(pt - Seconds(4000), pms);
|
|
EXPECT_EQ(pt - Minutes(66) - Seconds(40), pms);
|
|
EXPECT_EQ(pt - Hours(1) - Minutes(6) - Seconds(40), pms);
|
|
// Positive - negative (small units)
|
|
EXPECT_EQ(ps - Milliseconds(-123), pt);
|
|
// Positive - negative (large units)
|
|
EXPECT_EQ(pms - Seconds(-4000), pt);
|
|
EXPECT_EQ(pms - Minutes(-66) - Seconds(-40), pt);
|
|
EXPECT_EQ(pms - Hours(-1) - Minutes(-6) - Seconds(-40), pt);
|
|
// Positive - zero (all units)
|
|
EXPECT_EQ(pt - Milliseconds::zero(), pt);
|
|
EXPECT_EQ(pt - Seconds::zero(), pt);
|
|
EXPECT_EQ(pt - Minutes::zero(), pt);
|
|
EXPECT_EQ(pt - Hours::zero(), pt);
|
|
|
|
// Negative - positive (small units).
|
|
EXPECT_EQ(ns - Milliseconds(123), nt);
|
|
// Negative - positive (large units).
|
|
EXPECT_EQ(nms - Seconds(4000), nt);
|
|
EXPECT_EQ(nms - Minutes(66) - Seconds(40), nt);
|
|
EXPECT_EQ(nms - Hours(1) - Minutes(6) - Seconds(40), nt);
|
|
// Negative - negative (small units)
|
|
EXPECT_EQ(nt - Milliseconds(-123), ns);
|
|
// Negative - negative (large units)
|
|
EXPECT_EQ(nt - Seconds(-4000), nms);
|
|
EXPECT_EQ(nt - Minutes(-66) - Seconds(-40), nms);
|
|
EXPECT_EQ(nt - Hours(-1) - Minutes(-6) - Seconds(-40), nms);
|
|
// Negative - zero (all units)
|
|
EXPECT_EQ(nt - Milliseconds::zero(), nt);
|
|
EXPECT_EQ(nt - Seconds::zero(), nt);
|
|
EXPECT_EQ(nt - Minutes::zero(), nt);
|
|
EXPECT_EQ(nt - Hours::zero(), nt);
|
|
|
|
// Zero - zero (all units)
|
|
EXPECT_EQ(zero - Milliseconds::zero(), zero);
|
|
EXPECT_EQ(zero - Seconds::zero(), zero);
|
|
EXPECT_EQ(zero - Minutes::zero(), zero);
|
|
EXPECT_EQ(zero - Hours::zero(), zero);
|
|
// Zero - positive (small units)
|
|
EXPECT_EQ(zero - Milliseconds(123), nms);
|
|
// Zero - positive (large units)
|
|
EXPECT_EQ(zero - Seconds(4000), ns);
|
|
EXPECT_EQ(zero - Minutes(66) - Seconds(40), ns);
|
|
EXPECT_EQ(zero - Hours(1) - Minutes(6) - Seconds(40), ns);
|
|
// Zero - negative (small units)
|
|
EXPECT_EQ(zero - Milliseconds(-123), pms);
|
|
// Zero - negative (large units)
|
|
EXPECT_EQ(zero - Seconds(-4000), ps);
|
|
EXPECT_EQ(zero - Minutes(-66) - Seconds(-40), ps);
|
|
EXPECT_EQ(zero - Hours(-1) - Minutes(-6) - Seconds(-40), ps);
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, Increment) {
|
|
const Duration ps = Duration::FromSeconds(4000);
|
|
const Duration pms = Duration::FromMilliseconds(123);
|
|
const Duration pt = Duration::FromMilliseconds(4000123);
|
|
const Duration ns = Duration::FromSeconds(-4000);
|
|
const Duration nms = Duration::FromMilliseconds(-123);
|
|
const Duration nt = Duration::FromMilliseconds(-4000123);
|
|
const Duration zero = Duration::Zero();
|
|
|
|
Duration acc = zero;
|
|
// zero += positive -> positive
|
|
acc += ps;
|
|
EXPECT_EQ(acc, ps);
|
|
// positive += positive -> positive
|
|
acc += pms;
|
|
EXPECT_EQ(acc, pt);
|
|
// positive += zero -> positive
|
|
acc += zero;
|
|
EXPECT_EQ(acc, pt);
|
|
// positive += negative -> positive
|
|
acc += ns;
|
|
EXPECT_EQ(acc, pms);
|
|
// positive += negative -> zero
|
|
acc += nms;
|
|
EXPECT_EQ(acc, zero);
|
|
// zero += zero -> zero
|
|
acc += zero;
|
|
EXPECT_EQ(acc, zero);
|
|
// zero += negative -> negative
|
|
acc += nms;
|
|
EXPECT_EQ(acc, nms);
|
|
// negative += negative -> negative
|
|
acc += ns;
|
|
EXPECT_EQ(acc, nt);
|
|
// negative += zero -> zero
|
|
acc += zero;
|
|
EXPECT_EQ(acc, nt);
|
|
// negative += positive -> negative
|
|
acc += pms;
|
|
EXPECT_EQ(acc, ns);
|
|
// negative += positive -> zero
|
|
acc += ps;
|
|
EXPECT_EQ(acc, zero);
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, Decrement) {
|
|
const Duration ps = Duration::FromSeconds(4000);
|
|
const Duration pms = Duration::FromMilliseconds(123);
|
|
const Duration pt = Duration::FromMilliseconds(4000123);
|
|
const Duration ns = Duration::FromSeconds(-4000);
|
|
const Duration nms = Duration::FromMilliseconds(-123);
|
|
const Duration nt = Duration::FromMilliseconds(-4000123);
|
|
const Duration zero = Duration::Zero();
|
|
|
|
Duration acc = zero;
|
|
// zero -= positive -> negative
|
|
acc -= ps;
|
|
EXPECT_EQ(acc, ns);
|
|
// negative -= positive -> negative
|
|
acc -= pms;
|
|
EXPECT_EQ(acc, nt);
|
|
// negative -= zero -> negative
|
|
acc -= zero;
|
|
EXPECT_EQ(acc, nt);
|
|
// negative -= negative -> negative
|
|
acc -= ns;
|
|
EXPECT_EQ(acc, nms);
|
|
// negative -= negative -> zero
|
|
acc -= nms;
|
|
EXPECT_EQ(acc, zero);
|
|
// zero -= zero -> zero
|
|
acc -= zero;
|
|
EXPECT_EQ(acc, zero);
|
|
// zero -= negative -> positive
|
|
acc -= nms;
|
|
EXPECT_EQ(acc, pms);
|
|
// positive -= negative -> positive
|
|
acc -= ns;
|
|
EXPECT_EQ(acc, pt);
|
|
// positive -= zero -> positive
|
|
acc -= zero;
|
|
EXPECT_EQ(acc, pt);
|
|
// positive -= positive -> positive
|
|
acc -= pms;
|
|
EXPECT_EQ(acc, ps);
|
|
// positive -= positive -> zero
|
|
acc -= ps;
|
|
EXPECT_EQ(acc, zero);
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, Increment_WithChronoDuration) {
|
|
const Duration ps = Duration::FromSeconds(104000);
|
|
const Duration pms = Duration::FromMilliseconds(123);
|
|
const Duration pt = Duration::FromMilliseconds(104000123);
|
|
const Duration ns = Duration::FromSeconds(-104000);
|
|
const Duration nms = Duration::FromMilliseconds(-123);
|
|
const Duration nt = Duration::FromMilliseconds(-104000123);
|
|
const Duration zero = Duration::Zero();
|
|
|
|
Duration acc = zero;
|
|
// zero += positive (small units) -> positive
|
|
acc += Milliseconds(123);
|
|
EXPECT_EQ(acc, pms);
|
|
// positive += positive (larger units) -> positive
|
|
acc += Days(1);
|
|
acc += Hours(4);
|
|
acc += Minutes(53);
|
|
acc += Seconds(20);
|
|
EXPECT_EQ(acc, pt);
|
|
// positive += zero (all units) -> positive
|
|
acc += Milliseconds::zero();
|
|
EXPECT_EQ(acc, pt);
|
|
acc += Seconds::zero();
|
|
EXPECT_EQ(acc, pt);
|
|
acc += Minutes::zero();
|
|
EXPECT_EQ(acc, pt);
|
|
acc += Hours::zero();
|
|
EXPECT_EQ(acc, pt);
|
|
acc += Days::zero();
|
|
EXPECT_EQ(acc, pt);
|
|
// positive += negative (small units) -> positive
|
|
acc += Milliseconds(-123);
|
|
EXPECT_EQ(acc, ps);
|
|
// positive += negative (large units) -> zero
|
|
acc += Days(-1);
|
|
acc += Hours(-4);
|
|
acc += Minutes(-53);
|
|
acc += Seconds(-20);
|
|
EXPECT_EQ(acc, zero);
|
|
// zero += zero (all units) -> zero
|
|
acc += Milliseconds::zero();
|
|
EXPECT_EQ(acc, zero);
|
|
acc += Seconds::zero();
|
|
EXPECT_EQ(acc, zero);
|
|
acc += Minutes::zero();
|
|
EXPECT_EQ(acc, zero);
|
|
acc += Hours::zero();
|
|
EXPECT_EQ(acc, zero);
|
|
acc += Days::zero();
|
|
EXPECT_EQ(acc, zero);
|
|
// zero += negative (large units) -> negative
|
|
acc += Days(-1);
|
|
acc += Hours(-4);
|
|
acc += Minutes(-53);
|
|
acc += Seconds(-20);
|
|
EXPECT_EQ(acc, ns);
|
|
// negative += negative (small unit) -> negative
|
|
acc += Milliseconds(-123);
|
|
EXPECT_EQ(acc, nt);
|
|
// negative += zero (all units) -> negative
|
|
acc += Milliseconds::zero();
|
|
EXPECT_EQ(acc, nt);
|
|
acc += Seconds::zero();
|
|
EXPECT_EQ(acc, nt);
|
|
acc += Minutes::zero();
|
|
EXPECT_EQ(acc, nt);
|
|
acc += Hours::zero();
|
|
EXPECT_EQ(acc, nt);
|
|
acc += Days::zero();
|
|
EXPECT_EQ(acc, nt);
|
|
// negative += positive (large units) -> negative
|
|
acc += Days(1);
|
|
acc += Hours(4);
|
|
acc += Minutes(53);
|
|
acc += Seconds(20);
|
|
EXPECT_EQ(acc, nms);
|
|
// negative += positive (small units) -> zero
|
|
acc += Milliseconds(123);
|
|
EXPECT_EQ(acc, zero);
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, Decrement_WithChronoDuration) {
|
|
const Duration ps = Duration::FromSeconds(104000);
|
|
const Duration pms = Duration::FromMilliseconds(123);
|
|
const Duration pt = Duration::FromMilliseconds(104000123);
|
|
const Duration ns = Duration::FromSeconds(-104000);
|
|
const Duration nms = Duration::FromMilliseconds(-123);
|
|
const Duration nt = Duration::FromMilliseconds(-104000123);
|
|
const Duration zero = Duration::Zero();
|
|
|
|
Duration acc = zero;
|
|
// zero -= positive (small units) -> negative
|
|
acc -= Milliseconds(123);
|
|
EXPECT_EQ(acc, nms);
|
|
// negative -= positive (larger units) -> negative
|
|
acc -= Days(1);
|
|
acc -= Hours(4);
|
|
acc -= Minutes(53);
|
|
acc -= Seconds(20);
|
|
EXPECT_EQ(acc, nt);
|
|
// negative -= zero (all units) -> negative
|
|
acc -= Milliseconds::zero();
|
|
EXPECT_EQ(acc, nt);
|
|
acc -= Seconds::zero();
|
|
EXPECT_EQ(acc, nt);
|
|
acc -= Minutes::zero();
|
|
EXPECT_EQ(acc, nt);
|
|
acc -= Hours::zero();
|
|
EXPECT_EQ(acc, nt);
|
|
acc -= Days::zero();
|
|
EXPECT_EQ(acc, nt);
|
|
// negative -= negative (small units) -> negative
|
|
acc -= Milliseconds(-123);
|
|
EXPECT_EQ(acc, ns);
|
|
// negative -= negative (large units) -> zero
|
|
acc -= Days(-1);
|
|
acc -= Hours(-4);
|
|
acc -= Minutes(-53);
|
|
acc -= Seconds(-20);
|
|
EXPECT_EQ(acc, zero);
|
|
// zero -= zero (all units) -> zero
|
|
acc -= Milliseconds::zero();
|
|
EXPECT_EQ(acc, zero);
|
|
acc -= Seconds::zero();
|
|
EXPECT_EQ(acc, zero);
|
|
acc -= Minutes::zero();
|
|
EXPECT_EQ(acc, zero);
|
|
acc -= Hours::zero();
|
|
EXPECT_EQ(acc, zero);
|
|
acc -= Days::zero();
|
|
EXPECT_EQ(acc, zero);
|
|
// zero -= negative (large units) -> positive
|
|
acc -= Days(-1);
|
|
acc -= Hours(-4);
|
|
acc -= Minutes(-53);
|
|
acc -= Seconds(-20);
|
|
EXPECT_EQ(acc, ps);
|
|
// positive -= negative (small unit) -> positive
|
|
acc -= Milliseconds(-123);
|
|
EXPECT_EQ(acc, pt);
|
|
// positive -= zero (all units) -> positive
|
|
acc -= Milliseconds::zero();
|
|
EXPECT_EQ(acc, pt);
|
|
acc -= Seconds::zero();
|
|
EXPECT_EQ(acc, pt);
|
|
acc -= Minutes::zero();
|
|
EXPECT_EQ(acc, pt);
|
|
acc -= Hours::zero();
|
|
EXPECT_EQ(acc, pt);
|
|
acc -= Days::zero();
|
|
EXPECT_EQ(acc, pt);
|
|
// positive -= positive (large units) -> positive
|
|
acc -= Days(1);
|
|
acc -= Hours(4);
|
|
acc -= Minutes(53);
|
|
acc -= Seconds(20);
|
|
EXPECT_EQ(acc, pms);
|
|
// positive -= positive (small units) -> zero
|
|
acc -= Milliseconds(123);
|
|
EXPECT_EQ(acc, zero);
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_Zero) {
|
|
EXPECT_EQ(Duration::Zero().ToString(), "0s");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_Ms) {
|
|
// Millis only
|
|
EXPECT_EQ(Duration::FromMilliseconds(1).ToString(), "1ms");
|
|
EXPECT_EQ(Duration::FromMilliseconds(12).ToString(), "12ms");
|
|
EXPECT_EQ(Duration::FromMilliseconds(123).ToString(), "123ms");
|
|
EXPECT_EQ(Duration::FromMilliseconds(999).ToString(), "999ms");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_S) {
|
|
// Seconds only
|
|
EXPECT_EQ(Duration::FromSeconds(1).ToString(), "1s");
|
|
EXPECT_EQ(Duration::FromSeconds(9).ToString(), "9s");
|
|
EXPECT_EQ(Duration::FromSeconds(30).ToString(), "30s");
|
|
EXPECT_EQ(Duration::FromSeconds(59).ToString(), "59s");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_M) {
|
|
// Minutes only
|
|
EXPECT_EQ(Duration::FromSeconds(1 * kSPerM).ToString(), "1m");
|
|
EXPECT_EQ(Duration::FromSeconds(9 * kSPerM).ToString(), "9m");
|
|
EXPECT_EQ(Duration::FromSeconds(30 * kSPerM).ToString(), "30m");
|
|
EXPECT_EQ(Duration::FromSeconds(59 * kSPerM).ToString(), "59m");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_H) {
|
|
// Hours only
|
|
EXPECT_EQ(Duration::FromSeconds(1 * kSPerH).ToString(), "1h");
|
|
EXPECT_EQ(Duration::FromSeconds(9 * kSPerH).ToString(), "9h");
|
|
EXPECT_EQ(Duration::FromSeconds(12 * kSPerH).ToString(), "12h");
|
|
EXPECT_EQ(Duration::FromSeconds(23 * kSPerH).ToString(), "23h");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_D) {
|
|
// Days only
|
|
EXPECT_EQ(Duration::FromSeconds(1 * kSPerD).ToString(), "1d");
|
|
EXPECT_EQ(Duration::FromSeconds(7 * kSPerD).ToString(), "7d");
|
|
EXPECT_EQ(Duration::FromSeconds(99 * kSPerD).ToString(), "99d");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_S_Ms) {
|
|
// Seconds and millis
|
|
EXPECT_EQ(Duration::FromMilliseconds(1001).ToString(), "1s1ms");
|
|
EXPECT_EQ(Duration::FromMilliseconds(1123).ToString(), "1s123ms");
|
|
EXPECT_EQ(Duration::FromMilliseconds(30507).ToString(), "30s507ms");
|
|
EXPECT_EQ(Duration::FromMilliseconds(59999).ToString(), "59s999ms");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_M_Ms) {
|
|
// Minutes and millis
|
|
EXPECT_EQ(Duration::FromMilliseconds(kMsPerM + 1).ToString(), "1m1ms");
|
|
EXPECT_EQ(Duration::FromMilliseconds(kMsPerM + 123).ToString(), "1m123ms");
|
|
EXPECT_EQ(Duration::FromMilliseconds(30l * kMsPerM + 507).ToString(),
|
|
"30m507ms");
|
|
EXPECT_EQ(Duration::FromMilliseconds(59l * kMsPerM + 999).ToString(),
|
|
"59m999ms");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_H_Ms) {
|
|
// Hours and millis
|
|
EXPECT_EQ(Duration::FromMilliseconds(kMsPerH + 1).ToString(), "1h1ms");
|
|
EXPECT_EQ(Duration::FromMilliseconds(kMsPerH + 123).ToString(), "1h123ms");
|
|
EXPECT_EQ(Duration::FromMilliseconds(12l * kMsPerH + 507).ToString(),
|
|
"12h507ms");
|
|
EXPECT_EQ(Duration::FromMilliseconds(23l * kMsPerH + 999).ToString(),
|
|
"23h999ms");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_D_Ms) {
|
|
// Days and millis
|
|
EXPECT_EQ(Duration::FromMilliseconds(1l * kMsPerD + 1).ToString(), "1d1ms");
|
|
EXPECT_EQ(Duration::FromMilliseconds(7l * kMsPerD + 123).ToString(),
|
|
"7d123ms");
|
|
EXPECT_EQ(Duration::FromMilliseconds(10l * kMsPerD + 507).ToString(),
|
|
"10d507ms");
|
|
EXPECT_EQ(Duration::FromMilliseconds(99l * kMsPerD + 507).ToString(),
|
|
"99d507ms");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_M_S) {
|
|
// Minutes and seconds
|
|
EXPECT_EQ(Duration::FromSeconds(kSPerM + 1).ToString(), "1m1s");
|
|
EXPECT_EQ(Duration::FromSeconds(30 * kSPerM + 30).ToString(), "30m30s");
|
|
EXPECT_EQ(Duration::FromSeconds(59 * kSPerM + 59).ToString(), "59m59s");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_H_S) {
|
|
// Hours and seconds
|
|
EXPECT_EQ(Duration::FromSeconds(kSPerH + 1).ToString(), "1h1s");
|
|
EXPECT_EQ(Duration::FromSeconds(12 * kSPerH + 30).ToString(), "12h30s");
|
|
EXPECT_EQ(Duration::FromSeconds(23 * kSPerH + 59).ToString(), "23h59s");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_D_S) {
|
|
// Days and seconds
|
|
EXPECT_EQ(Duration::FromSeconds(kSPerD + 1).ToString(), "1d1s");
|
|
EXPECT_EQ(Duration::FromSeconds(7 * kSPerD + 30).ToString(), "7d30s");
|
|
EXPECT_EQ(Duration::FromSeconds(30 * kSPerD + 59).ToString(), "30d59s");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_H_M) {
|
|
// Hours and minutes
|
|
EXPECT_EQ(Duration::FromSeconds((kMPerH + 1) * kSPerM).ToString(), "1h1m");
|
|
EXPECT_EQ(Duration::FromSeconds((12 * kMPerH + 30) * kSPerM).ToString(),
|
|
"12h30m");
|
|
EXPECT_EQ(Duration::FromSeconds((23 * kMPerH + 59) * kSPerM).ToString(),
|
|
"23h59m");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_D_M) {
|
|
// Days and minutes
|
|
EXPECT_EQ(Duration::FromSeconds((kMPerD + 1) * kSPerM).ToString(), "1d1m");
|
|
EXPECT_EQ(Duration::FromSeconds((7 * kMPerD + 30) * kSPerM).ToString(),
|
|
"7d30m");
|
|
EXPECT_EQ(Duration::FromSeconds((30 * kMPerD + 59) * kSPerM).ToString(),
|
|
"30d59m");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_D_H) {
|
|
// Days and hours
|
|
EXPECT_EQ(Duration::FromSeconds((kHPerD + 1) * kSPerH).ToString(), "1d1h");
|
|
EXPECT_EQ(Duration::FromSeconds((7 * kHPerD + 12) * kSPerH).ToString(),
|
|
"7d12h");
|
|
EXPECT_EQ(Duration::FromSeconds((30 * kHPerD + 23) * kSPerH).ToString(),
|
|
"30d23h");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_M_S_Ms) {
|
|
// Minutes, seconds, and millis
|
|
EXPECT_EQ(Duration::FromMilliseconds((kSPerM + 1) * kMsPerS + 1).ToString(),
|
|
"1m1s1ms");
|
|
EXPECT_EQ(
|
|
Duration::FromMilliseconds((6l * kSPerM + 30) * kMsPerS + 123).ToString(),
|
|
"6m30s123ms");
|
|
EXPECT_EQ(
|
|
Duration::FromMilliseconds((30l * kSPerM + 3) * kMsPerS + 507).ToString(),
|
|
"30m3s507ms");
|
|
EXPECT_EQ(Duration::FromMilliseconds((59l * kSPerM + 59) * kMsPerS + 999)
|
|
.ToString(),
|
|
"59m59s999ms");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_H_S_Ms) {
|
|
// Hours, seconds, and millis
|
|
EXPECT_EQ(Duration::FromMilliseconds((kSPerH + 1) * kMsPerS + 1).ToString(),
|
|
"1h1s1ms");
|
|
EXPECT_EQ(
|
|
Duration::FromMilliseconds((6l * kSPerH + 30) * kMsPerS + 123).ToString(),
|
|
"6h30s123ms");
|
|
EXPECT_EQ(
|
|
Duration::FromMilliseconds((12l * kSPerH + 3) * kMsPerS + 507).ToString(),
|
|
"12h3s507ms");
|
|
EXPECT_EQ(Duration::FromMilliseconds((23l * kSPerH + 59) * kMsPerS + 999)
|
|
.ToString(),
|
|
"23h59s999ms");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_D_S_Ms) {
|
|
// Days, seconds, and millis
|
|
EXPECT_EQ(Duration::FromMilliseconds((kSPerD + 1) * kMsPerS + 1).ToString(),
|
|
"1d1s1ms");
|
|
EXPECT_EQ(
|
|
Duration::FromMilliseconds((7 * kSPerD + 30) * kMsPerS + 123).ToString(),
|
|
"7d30s123ms");
|
|
EXPECT_EQ(
|
|
Duration::FromMilliseconds((30 * kSPerD + 59) * kMsPerS + 999).ToString(),
|
|
"30d59s999ms");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_H_M_Ms) {
|
|
// Hours, minutes, and millis
|
|
EXPECT_EQ(Duration::FromMilliseconds((kMPerH + 1) * kMsPerM + 1).ToString(),
|
|
"1h1m1ms");
|
|
EXPECT_EQ(
|
|
Duration::FromMilliseconds((6l * kMPerH + 30) * kMsPerM + 123).ToString(),
|
|
"6h30m123ms");
|
|
EXPECT_EQ(
|
|
Duration::FromMilliseconds((12l * kMPerH + 3) * kMsPerM + 507).ToString(),
|
|
"12h3m507ms");
|
|
EXPECT_EQ(Duration::FromMilliseconds((23l * kMPerH + 59) * kMsPerM + 999)
|
|
.ToString(),
|
|
"23h59m999ms");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_D_M_Ms) {
|
|
// Days, minutes and millis
|
|
EXPECT_EQ(Duration::FromMilliseconds((kMPerD + 1) * kMsPerM + 1).ToString(),
|
|
"1d1m1ms");
|
|
EXPECT_EQ(
|
|
Duration::FromMilliseconds((7l * kMPerD + 30) * kMsPerM + 123).ToString(),
|
|
"7d30m123ms");
|
|
EXPECT_EQ(Duration::FromMilliseconds((30l * kMPerD + 59) * kMsPerM + 999)
|
|
.ToString(),
|
|
"30d59m999ms");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_D_H_Ms) {
|
|
// Days, hours and millis
|
|
EXPECT_EQ(Duration::FromMilliseconds((kHPerD + 1) * kMsPerH + 1).ToString(),
|
|
"1d1h1ms");
|
|
EXPECT_EQ(
|
|
Duration::FromMilliseconds((7 * kHPerD + 12) * kMsPerH + 123).ToString(),
|
|
"7d12h123ms");
|
|
EXPECT_EQ(
|
|
Duration::FromMilliseconds((30 * kHPerD + 23) * kMsPerH + 999).ToString(),
|
|
"30d23h999ms");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_H_M_S) {
|
|
// Hours, minutes and seconds.
|
|
EXPECT_EQ(Duration::FromSeconds((kMPerH + 1) * kSPerM + 1).ToString(),
|
|
"1h1m1s");
|
|
EXPECT_EQ(Duration::FromSeconds((6 * kMPerH + 30) * kSPerM + 9).ToString(),
|
|
"6h30m9s");
|
|
EXPECT_EQ(Duration::FromSeconds((12 * kMPerH + 3) * kSPerM + 30).ToString(),
|
|
"12h3m30s");
|
|
EXPECT_EQ(Duration::FromSeconds((23 * kMPerH + 59) * kSPerM + 59).ToString(),
|
|
"23h59m59s");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_D_M_S) {
|
|
// Days, minutes and seconds.
|
|
EXPECT_EQ(Duration::FromSeconds((kMPerD + 1) * kSPerM + 1).ToString(),
|
|
"1d1m1s");
|
|
EXPECT_EQ(Duration::FromSeconds((7 * kMPerD + 3) * kSPerM + 30).ToString(),
|
|
"7d3m30s");
|
|
EXPECT_EQ(Duration::FromSeconds((30 * kMPerD + 59) * kSPerM + 59).ToString(),
|
|
"30d59m59s");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_D_H_S) {
|
|
// Days, hours and seconds.
|
|
EXPECT_EQ(Duration::FromSeconds((kHPerD + 1) * kSPerH + 1).ToString(),
|
|
"1d1h1s");
|
|
EXPECT_EQ(Duration::FromSeconds((7 * kHPerD + 12) * kSPerH + 30).ToString(),
|
|
"7d12h30s");
|
|
EXPECT_EQ(Duration::FromSeconds((30 * kHPerD + 23) * kSPerH + 59).ToString(),
|
|
"30d23h59s");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_D_H_M) {
|
|
// Days, hours and minutes.
|
|
EXPECT_EQ(
|
|
Duration::FromSeconds(((kHPerD + 1) * kMPerH + 1) * kSPerM).ToString(),
|
|
"1d1h1m");
|
|
EXPECT_EQ(Duration::FromSeconds(((7 * kHPerD + 12) * kMPerH + 30) * kSPerM)
|
|
.ToString(),
|
|
"7d12h30m");
|
|
EXPECT_EQ(Duration::FromSeconds(((30 * kHPerD + 23) * kMPerH + 59) * kSPerM)
|
|
.ToString(),
|
|
"30d23h59m");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_H_M_S_Ms) {
|
|
// Hours, minutes, seconds, and millis
|
|
EXPECT_EQ(
|
|
Duration::FromMilliseconds(((1l * kMPerH + 1) * kSPerM + 1) * kMsPerS + 1)
|
|
.ToString(),
|
|
"1h1m1s1ms");
|
|
EXPECT_EQ(Duration::FromMilliseconds(
|
|
((12l * kMPerH + 7) * kSPerM + 21) * kMsPerS + 60)
|
|
.ToString(),
|
|
"12h7m21s60ms");
|
|
EXPECT_EQ(Duration::FromMilliseconds(
|
|
((3l * kMPerH + 18) * kSPerM + 6) * kMsPerS + 507)
|
|
.ToString(),
|
|
"3h18m6s507ms");
|
|
EXPECT_EQ(Duration::FromMilliseconds(
|
|
((23l * kMPerH + 59) * kSPerM + 59) * kMsPerS + 999)
|
|
.ToString(),
|
|
"23h59m59s999ms");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_D_M_S_Ms) {
|
|
// Days, minutes, seconds, and millis
|
|
EXPECT_EQ(
|
|
Duration::FromMilliseconds(((1l * kMPerD + 1) * kSPerM + 1) * kMsPerS + 1)
|
|
.ToString(),
|
|
"1d1m1s1ms");
|
|
EXPECT_EQ(Duration::FromMilliseconds(
|
|
((7l * kMPerD + 18) * kSPerM + 6) * kMsPerS + 507)
|
|
.ToString(),
|
|
"7d18m6s507ms");
|
|
EXPECT_EQ(Duration::FromMilliseconds(
|
|
((30l * kMPerD + 59) * kSPerM + 59) * kMsPerS + 999)
|
|
.ToString(),
|
|
"30d59m59s999ms");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_D_H_S_Ms) {
|
|
// Days, hours, seconds, and millis
|
|
EXPECT_EQ(
|
|
Duration::FromMilliseconds(((1l * kHPerD + 1) * kSPerH + 1) * kMsPerS + 1)
|
|
.ToString(),
|
|
"1d1h1s1ms");
|
|
EXPECT_EQ(Duration::FromMilliseconds(
|
|
((7l * kHPerD + 12) * kSPerH + 30) * kMsPerS + 507)
|
|
.ToString(),
|
|
"7d12h30s507ms");
|
|
EXPECT_EQ(Duration::FromMilliseconds(
|
|
((30l * kHPerD + 23) * kSPerH + 59) * kMsPerS + 999)
|
|
.ToString(),
|
|
"30d23h59s999ms");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_D_H_M_Ms) {
|
|
// Days, hours, minutes, and millis
|
|
EXPECT_EQ(
|
|
Duration::FromMilliseconds(((1l * kHPerD + 1) * kMPerH + 1) * kMsPerM + 1)
|
|
.ToString(),
|
|
"1d1h1m1ms");
|
|
EXPECT_EQ(Duration::FromMilliseconds(
|
|
((7l * kHPerD + 12) * kMPerH + 30) * kMsPerM + 507)
|
|
.ToString(),
|
|
"7d12h30m507ms");
|
|
EXPECT_EQ(Duration::FromMilliseconds(
|
|
((30l * kHPerD + 23) * kMPerH + 59) * kMsPerM + 999)
|
|
.ToString(),
|
|
"30d23h59m999ms");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_D_H_M_S) {
|
|
// Days, hours, minutes, and seconds
|
|
EXPECT_EQ(Duration::FromSeconds(((1l * kHPerD + 1) * kMPerH + 1) * kSPerM + 1)
|
|
.ToString(),
|
|
"1d1h1m1s");
|
|
EXPECT_EQ(
|
|
Duration::FromSeconds(((7l * kHPerD + 12) * kMPerH + 30) * kSPerM + 22)
|
|
.ToString(),
|
|
"7d12h30m22s");
|
|
EXPECT_EQ(
|
|
Duration::FromSeconds(((30l * kHPerD + 23) * kMPerH + 59) * kSPerM + 59)
|
|
.ToString(),
|
|
"30d23h59m59s");
|
|
}
|
|
|
|
TEST(WvDurationUtilTest, ToString_D_H_M_S_Ms) {
|
|
// Days, hours, minutes, seconds and millis
|
|
EXPECT_EQ(Duration::FromMilliseconds(
|
|
(((1l * kHPerD + 1) * kMPerH + 1) * kSPerM + 1) * kMsPerS + 1)
|
|
.ToString(),
|
|
"1d1h1m1s1ms");
|
|
EXPECT_EQ(
|
|
Duration::FromMilliseconds(
|
|
(((7l * kHPerD + 12) * kMPerH + 10) * kSPerM + 20) * kMsPerS + 507)
|
|
.ToString(),
|
|
"7d12h10m20s507ms");
|
|
EXPECT_EQ(
|
|
Duration::FromMilliseconds(
|
|
(((30l * kHPerD + 23) * kMPerH + 59) * kSPerM + 59) * kMsPerS + 999)
|
|
.ToString(),
|
|
"30d23h59m59s999ms");
|
|
}
|
|
} // namespace test
|
|
} // namespace wvutil
|