// 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