// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.  All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd

#include "google/protobuf/util/time_util.h"

#include <cstdint>
#include <ctime>

#include "google/protobuf/duration.pb.h"
#include "google/protobuf/timestamp.pb.h"
#include "google/protobuf/testing/googletest.h"
#include <gtest/gtest.h>
#include "google/protobuf/util/internal_timeval.h"  // IWYU pragma: keep for timeval

namespace google {
namespace protobuf {
namespace util {

using google::protobuf::Duration;
using google::protobuf::Timestamp;

namespace {

TEST(TimeUtilTest, TimestampStringFormat) {
  // These these are out of bounds for 32-bit architectures.
  if(sizeof(time_t) >= sizeof(uint64_t)) {
    Timestamp begin, end;
    EXPECT_TRUE(TimeUtil::FromString("0001-01-01T00:00:00Z", &begin));
    EXPECT_EQ(TimeUtil::kTimestampMinSeconds, begin.seconds());
    EXPECT_EQ(0, begin.nanos());
    EXPECT_TRUE(TimeUtil::FromString("9999-12-31T23:59:59.999999999Z", &end));
    EXPECT_EQ(TimeUtil::kTimestampMaxSeconds, end.seconds());
    EXPECT_EQ(999999999, end.nanos());
    EXPECT_EQ("0001-01-01T00:00:00Z", TimeUtil::ToString(begin));
    EXPECT_EQ("9999-12-31T23:59:59.999999999Z", TimeUtil::ToString(end));
  }

  // Test negative timestamps.
  Timestamp time = TimeUtil::NanosecondsToTimestamp(-1);
  EXPECT_EQ(-1, time.seconds());
  // Timestamp's nano part is always non-negative.
  EXPECT_EQ(999999999, time.nanos());
  EXPECT_EQ("1969-12-31T23:59:59.999999999Z", TimeUtil::ToString(time));

  // Generated output should contain 3, 6, or 9 fractional digits.
  EXPECT_EQ("1970-01-01T00:00:00Z",
            TimeUtil::ToString(TimeUtil::NanosecondsToTimestamp(0)));
  EXPECT_EQ("1970-01-01T00:00:00.010Z",
            TimeUtil::ToString(TimeUtil::NanosecondsToTimestamp(10000000)));
  EXPECT_EQ("1970-01-01T00:00:00.000010Z",
            TimeUtil::ToString(TimeUtil::NanosecondsToTimestamp(10000)));
  EXPECT_EQ("1970-01-01T00:00:00.000000010Z",
            TimeUtil::ToString(TimeUtil::NanosecondsToTimestamp(10)));

  // Parsing accepts an fractional digits as long as they fit into nano
  // precision.
  EXPECT_TRUE(TimeUtil::FromString("1970-01-01T00:00:00.1Z", &time));
  EXPECT_EQ(100000000, TimeUtil::TimestampToNanoseconds(time));
  EXPECT_TRUE(TimeUtil::FromString("1970-01-01T00:00:00.0001Z", &time));
  EXPECT_EQ(100000, TimeUtil::TimestampToNanoseconds(time));
  EXPECT_TRUE(TimeUtil::FromString("1970-01-01T00:00:00.0000001Z", &time));
  EXPECT_EQ(100, TimeUtil::TimestampToNanoseconds(time));

  // Also accepts offsets.
  EXPECT_TRUE(TimeUtil::FromString("1970-01-01T00:00:00-08:00", &time));
  EXPECT_EQ(8 * 3600, TimeUtil::TimestampToSeconds(time));
}

TEST(TimeUtilTest, DurationStringFormat) {
  Timestamp begin, end;
  EXPECT_TRUE(TimeUtil::FromString("0001-01-01T00:00:00Z", &begin));
  EXPECT_TRUE(TimeUtil::FromString("9999-12-31T23:59:59.999999999Z", &end));

  // These these are out of bounds for 32-bit architectures.
  if(sizeof(time_t) >= sizeof(uint64_t)) {
    EXPECT_EQ("315537897599.999999999s", TimeUtil::ToString(end - begin));
    EXPECT_EQ("-315537897599.999999999s", TimeUtil::ToString(begin - end));
  }
  EXPECT_EQ(999999999, (end - begin).nanos());
  EXPECT_EQ(-999999999, (begin - end).nanos());

  // Generated output should contain 3, 6, or 9 fractional digits.
  EXPECT_EQ("1s", TimeUtil::ToString(TimeUtil::SecondsToDuration(1)));
  EXPECT_EQ("0.010s", TimeUtil::ToString(TimeUtil::MillisecondsToDuration(10)));
  EXPECT_EQ("0.000010s",
            TimeUtil::ToString(TimeUtil::MicrosecondsToDuration(10)));
  EXPECT_EQ("0.000000010s",
            TimeUtil::ToString(TimeUtil::NanosecondsToDuration(10)));

  // Parsing accepts an fractional digits as long as they fit into nano
  // precision.
  Duration d;
  EXPECT_TRUE(TimeUtil::FromString("0.1s", &d));
  EXPECT_EQ(100, TimeUtil::DurationToMilliseconds(d));
  EXPECT_TRUE(TimeUtil::FromString("0.0001s", &d));
  EXPECT_EQ(100, TimeUtil::DurationToMicroseconds(d));
  EXPECT_TRUE(TimeUtil::FromString("0.0000001s", &d));
  EXPECT_EQ(100, TimeUtil::DurationToNanoseconds(d));

  // Duration must support range from -315,576,000,000s to +315576000000s
  // which includes negative values.
  EXPECT_TRUE(TimeUtil::FromString("315576000000.999999999s", &d));
  EXPECT_EQ(int64_t{315576000000}, d.seconds());
  EXPECT_EQ(999999999, d.nanos());
  EXPECT_TRUE(TimeUtil::FromString("-315576000000.999999999s", &d));
  EXPECT_EQ(int64_t{-315576000000}, d.seconds());
  EXPECT_EQ(-999999999, d.nanos());
}

TEST(TimeUtilTest, GetEpoch) {
  EXPECT_EQ(0, TimeUtil::TimestampToNanoseconds(TimeUtil::GetEpoch()));
}

TEST(TimeUtilTest, DurationIntegerConversion) {
  EXPECT_EQ("0.000000001s",
            TimeUtil::ToString(TimeUtil::NanosecondsToDuration(1)));
  EXPECT_EQ("-0.000000001s",
            TimeUtil::ToString(TimeUtil::NanosecondsToDuration(-1)));
  EXPECT_EQ("0.000001s",
            TimeUtil::ToString(TimeUtil::MicrosecondsToDuration(1)));
  EXPECT_EQ("-0.000001s",
            TimeUtil::ToString(TimeUtil::MicrosecondsToDuration(-1)));
  EXPECT_EQ("0.001s", TimeUtil::ToString(TimeUtil::MillisecondsToDuration(1)));
  EXPECT_EQ("-0.001s",
            TimeUtil::ToString(TimeUtil::MillisecondsToDuration(-1)));
  EXPECT_EQ("1s", TimeUtil::ToString(TimeUtil::SecondsToDuration(1)));
  EXPECT_EQ("-1s", TimeUtil::ToString(TimeUtil::SecondsToDuration(-1)));
  EXPECT_EQ("60s", TimeUtil::ToString(TimeUtil::MinutesToDuration(1)));
  EXPECT_EQ("-60s", TimeUtil::ToString(TimeUtil::MinutesToDuration(-1)));
  EXPECT_EQ("3600s", TimeUtil::ToString(TimeUtil::HoursToDuration(1)));
  EXPECT_EQ("-3600s", TimeUtil::ToString(TimeUtil::HoursToDuration(-1)));

  EXPECT_EQ(
      1, TimeUtil::DurationToNanoseconds(TimeUtil::NanosecondsToDuration(1)));
  EXPECT_EQ(
      -1, TimeUtil::DurationToNanoseconds(TimeUtil::NanosecondsToDuration(-1)));
  EXPECT_EQ(
      1, TimeUtil::DurationToMicroseconds(TimeUtil::MicrosecondsToDuration(1)));
  EXPECT_EQ(-1, TimeUtil::DurationToMicroseconds(
                    TimeUtil::MicrosecondsToDuration(-1)));
  EXPECT_EQ(
      1, TimeUtil::DurationToMilliseconds(TimeUtil::MillisecondsToDuration(1)));
  EXPECT_EQ(-1, TimeUtil::DurationToMilliseconds(
                    TimeUtil::MillisecondsToDuration(-1)));
  // Test overflow issue
  EXPECT_EQ(315576000000000, TimeUtil::DurationToMilliseconds(
                                 TimeUtil::SecondsToDuration(315576000000)));
  // Test overflow issue
  EXPECT_EQ(315576000000000000, TimeUtil::DurationToMicroseconds(
                                    TimeUtil::SecondsToDuration(315576000000)));
  EXPECT_EQ(1, TimeUtil::DurationToSeconds(TimeUtil::SecondsToDuration(1)));
  EXPECT_EQ(-1, TimeUtil::DurationToSeconds(TimeUtil::SecondsToDuration(-1)));
  EXPECT_EQ(1, TimeUtil::DurationToMinutes(TimeUtil::MinutesToDuration(1)));
  EXPECT_EQ(-1, TimeUtil::DurationToMinutes(TimeUtil::MinutesToDuration(-1)));
  EXPECT_EQ(1, TimeUtil::DurationToHours(TimeUtil::HoursToDuration(1)));
  EXPECT_EQ(-1, TimeUtil::DurationToHours(TimeUtil::HoursToDuration(-1)));

  // Test truncation behavior.
  EXPECT_EQ(1, TimeUtil::DurationToMicroseconds(
                   TimeUtil::NanosecondsToDuration(1999)));
  // For negative values, Duration will be rounded towards 0.
  EXPECT_EQ(-1, TimeUtil::DurationToMicroseconds(
                    TimeUtil::NanosecondsToDuration(-1999)));
}

TEST(TestUtilTest, TimestampIntegerConversion) {
  EXPECT_EQ("1970-01-01T00:00:00.000000001Z",
            TimeUtil::ToString(TimeUtil::NanosecondsToTimestamp(1)));
  EXPECT_EQ("1969-12-31T23:59:59.999999999Z",
            TimeUtil::ToString(TimeUtil::NanosecondsToTimestamp(-1)));
  EXPECT_EQ("1970-01-01T00:00:00.000001Z",
            TimeUtil::ToString(TimeUtil::MicrosecondsToTimestamp(1)));
  EXPECT_EQ("1969-12-31T23:59:59.999999Z",
            TimeUtil::ToString(TimeUtil::MicrosecondsToTimestamp(-1)));
  EXPECT_EQ("1970-01-01T00:00:00.001Z",
            TimeUtil::ToString(TimeUtil::MillisecondsToTimestamp(1)));
  EXPECT_EQ("1969-12-31T23:59:59.999Z",
            TimeUtil::ToString(TimeUtil::MillisecondsToTimestamp(-1)));
  EXPECT_EQ("1970-01-01T00:00:01Z",
            TimeUtil::ToString(TimeUtil::SecondsToTimestamp(1)));
  EXPECT_EQ("1969-12-31T23:59:59Z",
            TimeUtil::ToString(TimeUtil::SecondsToTimestamp(-1)));

  EXPECT_EQ(
      1, TimeUtil::TimestampToNanoseconds(TimeUtil::NanosecondsToTimestamp(1)));
  EXPECT_EQ(-1, TimeUtil::TimestampToNanoseconds(
                    TimeUtil::NanosecondsToTimestamp(-1)));
  EXPECT_EQ(1, TimeUtil::TimestampToMicroseconds(
                   TimeUtil::MicrosecondsToTimestamp(1)));
  EXPECT_EQ(-1, TimeUtil::TimestampToMicroseconds(
                    TimeUtil::MicrosecondsToTimestamp(-1)));
  EXPECT_EQ(1, TimeUtil::TimestampToMilliseconds(
                   TimeUtil::MillisecondsToTimestamp(1)));
  EXPECT_EQ(-1, TimeUtil::TimestampToMilliseconds(
                    TimeUtil::MillisecondsToTimestamp(-1)));
  EXPECT_EQ(1, TimeUtil::TimestampToSeconds(TimeUtil::SecondsToTimestamp(1)));
  EXPECT_EQ(-1, TimeUtil::TimestampToSeconds(TimeUtil::SecondsToTimestamp(-1)));

  // Test truncation behavior.
  EXPECT_EQ(1, TimeUtil::TimestampToMicroseconds(
                   TimeUtil::NanosecondsToTimestamp(1999)));
  // For negative values, Timestamp will be rounded down.
  // For example, "1969-12-31T23:59:59.5Z" (i.e., -0.5s) rounded to seconds
  // will be "1969-12-31T23:59:59Z" (i.e., -1s) rather than
  // "1970-01-01T00:00:00Z" (i.e., 0s).
  EXPECT_EQ(-2, TimeUtil::TimestampToMicroseconds(
                    TimeUtil::NanosecondsToTimestamp(-1999)));
}

TEST(TimeUtilTest, TimeTConversion) {
  time_t value = time(nullptr);
  EXPECT_EQ(value,
            TimeUtil::TimestampToTimeT(TimeUtil::TimeTToTimestamp(value)));
  EXPECT_EQ(
      1, TimeUtil::TimestampToTimeT(TimeUtil::MillisecondsToTimestamp(1999)));
}

TEST(TimeUtilTest, TimevalConversion) {
  timeval value = TimeUtil::TimestampToTimeval(
      TimeUtil::NanosecondsToTimestamp(1999999999));
  EXPECT_EQ(1, value.tv_sec);
  EXPECT_EQ(999999, value.tv_usec);
  value = TimeUtil::TimestampToTimeval(
      TimeUtil::NanosecondsToTimestamp(-1999999999));
  EXPECT_EQ(-2, value.tv_sec);
  EXPECT_EQ(0, value.tv_usec);

  value =
      TimeUtil::DurationToTimeval(TimeUtil::NanosecondsToDuration(1999999999));
  EXPECT_EQ(1, value.tv_sec);
  EXPECT_EQ(999999, value.tv_usec);
  value =
      TimeUtil::DurationToTimeval(TimeUtil::NanosecondsToDuration(-1999999999));
  EXPECT_EQ(-2, value.tv_sec);
  EXPECT_EQ(1, value.tv_usec);
}

TEST(TimeUtilTest, DurationOperators) {
  Duration one_second = TimeUtil::SecondsToDuration(1);
  Duration one_nano = TimeUtil::NanosecondsToDuration(1);

  // Test +/-
  Duration a = one_second;
  a += one_second;
  a -= one_nano;
  EXPECT_EQ("1.999999999s", TimeUtil::ToString(a));
  Duration b = -a;
  EXPECT_EQ("-1.999999999s", TimeUtil::ToString(b));
  EXPECT_EQ("3.999999998s", TimeUtil::ToString(a + a));
  EXPECT_EQ("0s", TimeUtil::ToString(a + b));
  EXPECT_EQ("0s", TimeUtil::ToString(b + a));
  EXPECT_EQ("-3.999999998s", TimeUtil::ToString(b + b));
  EXPECT_EQ("3.999999998s", TimeUtil::ToString(a - b));
  EXPECT_EQ("0s", TimeUtil::ToString(a - a));
  EXPECT_EQ("0s", TimeUtil::ToString(b - b));
  EXPECT_EQ("-3.999999998s", TimeUtil::ToString(b - a));

  // Test *
  EXPECT_EQ(a + a, a * 2);
  EXPECT_EQ(b + b, a * (-2));
  EXPECT_EQ(b + b, b * 2);
  EXPECT_EQ(a + a, b * (-2));
  EXPECT_EQ("0.999999999s", TimeUtil::ToString(a * 0.5));
  EXPECT_EQ("-0.999999999s", TimeUtil::ToString(b * 0.5));
  // Multiplication should not overflow if the result fits into the supported
  // range of Duration (intermediate result may be larger than int64).
  EXPECT_EQ("315575999684.424s", TimeUtil::ToString((one_second - one_nano) *
                                                    int64_t{315576000000}));
  EXPECT_EQ("-315575999684.424s", TimeUtil::ToString((one_nano - one_second) *
                                                     int64_t{315576000000}));
  EXPECT_EQ("-315575999684.424s", TimeUtil::ToString((one_second - one_nano) *
                                                     (int64_t{-315576000000})));

  // Test / and %
  EXPECT_EQ("0.999999999s", TimeUtil::ToString(a / 2));
  EXPECT_EQ("-0.999999999s", TimeUtil::ToString(b / 2));
  Duration large =
      TimeUtil::SecondsToDuration(int64_t{315576000000}) - one_nano;
  // We have to handle division with values beyond 64 bits.
  EXPECT_EQ("0.999999999s", TimeUtil::ToString(large / int64_t{315576000000}));
  EXPECT_EQ("-0.999999999s",
            TimeUtil::ToString((-large) / int64_t{315576000000}));
  EXPECT_EQ("-0.999999999s",
            TimeUtil::ToString(large / (int64_t{-315576000000})));
  Duration large2 = large + one_nano;
  EXPECT_EQ(large, large % large2);
  EXPECT_EQ(-large, (-large) % large2);
  EXPECT_EQ(large, large % (-large2));
  EXPECT_EQ(one_nano, large2 % large);
  EXPECT_EQ(-one_nano, (-large2) % large);
  EXPECT_EQ(one_nano, large2 % (-large));
  // Some corner cases about negative values.
  //
  // (-5) / 2 = -2, remainder = -1
  // (-5) / (-2) = 2, remainder = -1
  a = TimeUtil::NanosecondsToDuration(-5);
  EXPECT_EQ(TimeUtil::NanosecondsToDuration(-2), a / 2);
  EXPECT_EQ(TimeUtil::NanosecondsToDuration(2), a / (-2));
  b = TimeUtil::NanosecondsToDuration(2);
  EXPECT_EQ(-2, a / b);
  EXPECT_EQ(TimeUtil::NanosecondsToDuration(-1), a % b);
  EXPECT_EQ(2, a / (-b));
  EXPECT_EQ(TimeUtil::NanosecondsToDuration(-1), a % (-b));

  // Test relational operators.
  EXPECT_TRUE(one_nano < one_second);
  EXPECT_FALSE(one_second < one_second);
  EXPECT_FALSE(one_second < one_nano);
  EXPECT_FALSE(-one_nano < -one_second);
  EXPECT_FALSE(-one_second < -one_second);
  EXPECT_TRUE(-one_second < -one_nano);
  EXPECT_TRUE(-one_nano < one_nano);
  EXPECT_FALSE(one_nano < -one_nano);

  EXPECT_FALSE(one_nano > one_second);
  EXPECT_FALSE(one_nano > one_nano);
  EXPECT_TRUE(one_second > one_nano);

  EXPECT_FALSE(one_nano >= one_second);
  EXPECT_TRUE(one_nano >= one_nano);
  EXPECT_TRUE(one_second >= one_nano);

  EXPECT_TRUE(one_nano <= one_second);
  EXPECT_TRUE(one_nano <= one_nano);
  EXPECT_FALSE(one_second <= one_nano);

  EXPECT_TRUE(one_nano == one_nano);
  EXPECT_FALSE(one_nano == one_second);

  EXPECT_FALSE(one_nano != one_nano);
  EXPECT_TRUE(one_nano != one_second);
}

TEST(TimeUtilTest, TimestampOperators) {
  Timestamp begin, end;
  EXPECT_TRUE(TimeUtil::FromString("0001-01-01T00:00:00Z", &begin));
  EXPECT_TRUE(TimeUtil::FromString("9999-12-31T23:59:59.999999999Z", &end));
  Duration d = end - begin;
  EXPECT_TRUE(end == begin + d);
  EXPECT_TRUE(end == d + begin);
  EXPECT_TRUE(begin == end - d);

  // Test relational operators
  Timestamp t1 = begin + d / 4;
  Timestamp t2 = end - d / 4;
  EXPECT_TRUE(t1 < t2);
  EXPECT_FALSE(t1 < t1);
  EXPECT_FALSE(t2 < t1);
  EXPECT_FALSE(t1 > t2);
  EXPECT_FALSE(t1 > t1);
  EXPECT_TRUE(t2 > t1);
  EXPECT_FALSE(t1 >= t2);
  EXPECT_TRUE(t1 >= t1);
  EXPECT_TRUE(t2 >= t1);
  EXPECT_TRUE(t1 <= t2);
  EXPECT_TRUE(t1 <= t1);
  EXPECT_FALSE(t2 <= t1);

  EXPECT_FALSE(t1 == t2);
  EXPECT_TRUE(t1 == t1);
  EXPECT_FALSE(t2 == t1);
  EXPECT_TRUE(t1 != t2);
  EXPECT_FALSE(t1 != t1);
  EXPECT_TRUE(t2 != t1);
}

TEST(TimeUtilTest, IsDurationValid) {
  Duration valid;
  Duration overflow;
  overflow.set_seconds(TimeUtil::kDurationMaxSeconds + 1);
  Duration underflow;
  underflow.set_seconds(TimeUtil::kDurationMinSeconds - 1);
  Duration overflow_nanos;
  overflow_nanos.set_nanos(TimeUtil::kDurationMaxNanoseconds + 1);
  Duration underflow_nanos;
  underflow_nanos.set_nanos(TimeUtil::kDurationMinNanoseconds - 1);
  Duration positive_seconds_negative_nanos;
  positive_seconds_negative_nanos.set_seconds(1);
  positive_seconds_negative_nanos.set_nanos(-1);
  Duration negative_seconds_positive_nanos;
  negative_seconds_positive_nanos.set_seconds(-1);
  negative_seconds_positive_nanos.set_nanos(1);

  EXPECT_TRUE(TimeUtil::IsDurationValid(valid));
  EXPECT_FALSE(TimeUtil::IsDurationValid(overflow));
  EXPECT_FALSE(TimeUtil::IsDurationValid(underflow));
  EXPECT_FALSE(TimeUtil::IsDurationValid(overflow_nanos));
  EXPECT_FALSE(TimeUtil::IsDurationValid(underflow_nanos));
  EXPECT_FALSE(TimeUtil::IsDurationValid(positive_seconds_negative_nanos));
  EXPECT_FALSE(TimeUtil::IsDurationValid(negative_seconds_positive_nanos));
}

TEST(TimeUtilTest, IsTimestampValid) {
  Timestamp valid;
  Timestamp overflow;
  overflow.set_seconds(TimeUtil::kTimestampMaxSeconds + 1);
  Timestamp underflow;
  underflow.set_seconds(TimeUtil::kTimestampMinSeconds - 1);
  Timestamp overflow_nanos;
  overflow_nanos.set_nanos(TimeUtil::kTimestampMaxNanoseconds + 1);
  Timestamp underflow_nanos;
  underflow_nanos.set_nanos(TimeUtil::kTimestampMinNanoseconds - 1);

  EXPECT_TRUE(TimeUtil::IsTimestampValid(valid));
  EXPECT_FALSE(TimeUtil::IsTimestampValid(overflow));
  EXPECT_FALSE(TimeUtil::IsTimestampValid(underflow));
  EXPECT_FALSE(TimeUtil::IsTimestampValid(overflow_nanos));
  EXPECT_FALSE(TimeUtil::IsTimestampValid(underflow_nanos));
}

#if GTEST_HAS_DEATH_TEST  // death tests do not work on Windows yet.
#ifndef NDEBUG

TEST(TimeUtilTest, DurationBounds) {
  Duration overflow;
  overflow.set_seconds(TimeUtil::kDurationMaxSeconds + 1);
  Duration underflow;
  underflow.set_seconds(TimeUtil::kDurationMinSeconds - 1);
  Duration overflow_nanos;
  overflow_nanos.set_nanos(TimeUtil::kDurationMaxNanoseconds + 1);
  Duration underflow_nanos;
  underflow_nanos.set_nanos(TimeUtil::kDurationMinNanoseconds - 1);

  EXPECT_DEATH({ TimeUtil::SecondsToDuration(overflow.seconds()); },
                     "Duration seconds");
  EXPECT_DEATH({ TimeUtil::SecondsToDuration(underflow.seconds()); },
                     "Duration seconds");
  EXPECT_DEATH(
      { TimeUtil::MinutesToDuration(overflow.seconds() / 60 + 1); },
      "Duration minutes");
  EXPECT_DEATH(
      { TimeUtil::MinutesToDuration(underflow.seconds() / 60 - 1); },
      "Duration minutes");
  EXPECT_DEATH(
      { TimeUtil::HoursToDuration(overflow.seconds() / 60 + 1); },
      "Duration hours");
  EXPECT_DEATH(
      { TimeUtil::HoursToDuration(underflow.seconds() / 60 - 1); },
      "Duration hours");

  EXPECT_DEATH({ TimeUtil::DurationToNanoseconds(overflow); },
                     "outside of the valid range");
  EXPECT_DEATH({ TimeUtil::DurationToNanoseconds(underflow); },
                     "outside of the valid range");
  EXPECT_DEATH({ TimeUtil::DurationToNanoseconds(overflow_nanos); },
                     "outside of the valid range");
  EXPECT_DEATH({ TimeUtil::DurationToNanoseconds(underflow_nanos); },
                     "outside of the valid range");
  EXPECT_DEATH({ TimeUtil::DurationToSeconds(overflow); },
                     "outside of the valid range");
  EXPECT_DEATH({ TimeUtil::DurationToSeconds(underflow); },
                     "outside of the valid range");
  EXPECT_DEATH({ TimeUtil::DurationToSeconds(overflow_nanos); },
                     "outside of the valid range");
  EXPECT_DEATH({ TimeUtil::DurationToSeconds(underflow_nanos); },
                     "outside of the valid range");
}

TEST(TimeUtilTest, TimestampBounds) {
  Timestamp overflow;
  overflow.set_seconds(TimeUtil::kDurationMaxSeconds + 1);
  Timestamp underflow;
  underflow.set_seconds(TimeUtil::kDurationMinSeconds - 1);
  Timestamp overflow_nanos;
  overflow_nanos.set_nanos(TimeUtil::kDurationMaxNanoseconds + 1);
  Timestamp underflow_nanos;
  underflow_nanos.set_nanos(TimeUtil::kDurationMinNanoseconds - 1);

  EXPECT_DEATH({ TimeUtil::TimestampToNanoseconds(overflow); },
                     "outside of the valid range");
  EXPECT_DEATH({ TimeUtil::TimestampToNanoseconds(underflow); },
                     "outside of the valid range");
  EXPECT_DEATH({ TimeUtil::TimestampToNanoseconds(overflow_nanos); },
                     "outside of the valid range");
  EXPECT_DEATH({ TimeUtil::TimestampToNanoseconds(underflow_nanos); },
                     "outside of the valid range");

  EXPECT_DEATH({ TimeUtil::TimestampToMicroseconds(overflow); },
                     "outside of the valid range");
  EXPECT_DEATH({ TimeUtil::TimestampToMicroseconds(underflow); },
                     "outside of the valid range");
  EXPECT_DEATH({ TimeUtil::TimestampToMicroseconds(overflow_nanos); },
                     "outside of the valid range");
  EXPECT_DEATH({ TimeUtil::TimestampToMicroseconds(underflow_nanos); },
                     "outside of the valid range");

  EXPECT_DEATH({ TimeUtil::TimestampToMilliseconds(overflow); },
                     "outside of the valid range");
  EXPECT_DEATH({ TimeUtil::TimestampToMilliseconds(underflow); },
                     "outside of the valid range");
  EXPECT_DEATH({ TimeUtil::TimestampToMilliseconds(overflow_nanos); },
                     "outside of the valid range");
  EXPECT_DEATH({ TimeUtil::TimestampToMilliseconds(underflow_nanos); },
                     "outside of the valid range");

  EXPECT_DEATH({ TimeUtil::TimestampToSeconds(overflow); },
                     "outside of the valid range");
  EXPECT_DEATH({ TimeUtil::TimestampToSeconds(underflow); },
                     "outside of the valid range");
  EXPECT_DEATH({ TimeUtil::TimestampToSeconds(overflow_nanos); },
                     "outside of the valid range");
  EXPECT_DEATH({ TimeUtil::TimestampToSeconds(underflow_nanos); },
                     "outside of the valid range");
}
#endif  // !NDEBUG
#endif  // GTEST_HAS_DEATH_TEST

TEST(TimeUtilTest, FromStringRejectsMalformedDuration) {
  Duration d;
  // Class A: leading whitespace + negative — signs mismatch
  EXPECT_FALSE(TimeUtil::FromString(" -3.54s", &d));
  // Class B: double minus — signs mismatch
  EXPECT_FALSE(TimeUtil::FromString("--3.54s", &d));
  // Class C: >9 fractional digits — nanos exceeds 999999999
  EXPECT_FALSE(TimeUtil::FromString("0.1234567890s", &d));
  // Class D: seconds > 315576000000 — out of range
  EXPECT_FALSE(TimeUtil::FromString("315576000001s", &d));
  // Valid inputs still work
  EXPECT_TRUE(TimeUtil::FromString("3.54s", &d));
  EXPECT_TRUE(TimeUtil::FromString("-3.54s", &d));
  EXPECT_TRUE(TimeUtil::FromString("315576000000s", &d));
}

TEST(TimeUtilTest, FromStringRejectsMalformedTimestamp) {
  Timestamp t;
  // Class E: year 0000
  EXPECT_FALSE(TimeUtil::FromString("0000-12-31T23:59:59Z", &t));
  // Class F: year 10000
  EXPECT_FALSE(TimeUtil::FromString("10000-01-01T00:00:00Z", &t));
  // Valid inputs still work
  EXPECT_TRUE(TimeUtil::FromString("0001-01-01T00:00:00Z", &t));
  EXPECT_TRUE(TimeUtil::FromString("9999-12-31T23:59:59Z", &t));
}

}  // namespace
}  // namespace util
}  // namespace protobuf
}  // namespace google
