Add a zero-allocation fast path to absl::ParseTime() for RFC3339_full and RFC3339_sec.
Matches RFC3339_full (%Y-%m-%d%ET%H:%M:%E*S%Ez) and RFC3339_sec
(%Y-%m-%d%ET%H:%M:%S%Ez) by length and pointer/value equality, and parses
standard 4-digit-year (0000-9999) inputs directly without constructing
temporary std::string copies or invoking cctz::detail::parse().
Preserves exact behavioral compatibility with cctz::detail::parse():
- Handles leading/trailing ASCII whitespace, 'T'/'t', optional fractional
seconds with exact 0.25ns (rep_lo) scaling, and all %Ez offset forms
('Z'/'z' and (+/-)HH[[:]MM[[:]SS]]).
- Falls back to cctz::detail::parse() without dereferencing *time or modifying
*err on any unusual or invalid input (non-4-digit/negative years, 1-digit
fields, leap second :60, infinite-future/infinite-past, embedded NULs,
non-ASCII bytes, or malformed syntax).
Benchmarks (BM_Format_ParseTime, --config=benchmark, 5 reps):
- RFC3339_full: 404 ns -> 28.4 ns (14.2x faster, -93.0% CPU)
- RFC3339_sec: 319 ns -> 20.5 ns (15.6x faster, -93.6% CPU)
PiperOrigin-RevId: 1025164600
diff --git a/absl/time/format.cc b/absl/time/format.cc
index 0794d7d..48d172e 100644
--- a/absl/time/format.cc
+++ b/absl/time/format.cc
@@ -14,12 +14,13 @@
#include <string.h>
-#include <cctype>
#include <chrono> // NOLINT(build/c++11)
+#include <cstddef>
#include <cstdint>
#include <string>
#include <utility>
+#include "absl/base/attributes.h"
#include "absl/base/config.h"
#include "absl/strings/ascii.h"
#include "absl/strings/match.h"
@@ -43,6 +44,278 @@
constexpr absl::string_view kInfiniteFutureStr = "infinite-future";
constexpr absl::string_view kInfinitePastStr = "infinite-past";
+constexpr size_t kRfc3339FullSize = sizeof(RFC3339_full) - 1;
+constexpr size_t kRfc3339SecSize = sizeof(RFC3339_sec) - 1;
+
+enum class FractionalSeconds {
+ kForbidden,
+ kOptional,
+};
+
+constexpr uint32_t kZeroChar = static_cast<unsigned char>('0');
+
+inline uint32_t DigitValue(char ch) {
+ return static_cast<uint32_t>(static_cast<unsigned char>(ch)) - kZeroChar;
+}
+
+inline bool TryConsumeDigit(const char** cursor, const char* end,
+ uint32_t* digit) {
+ if (*cursor >= end) return false;
+ const uint32_t value = DigitValue(**cursor);
+ if (value > 9) return false;
+ *digit = value;
+ ++(*cursor);
+ return true;
+}
+
+inline bool ParseTwoDigits(const char* cursor, uint32_t* out) {
+ const uint32_t d0 = DigitValue(cursor[0]);
+ const uint32_t d1 = DigitValue(cursor[1]);
+ if (d0 > 9 || d1 > 9) return false;
+ *out = d0 * 10 + d1;
+ return true;
+}
+
+inline bool IsLeapYear(uint32_t year) {
+ return (year % 4 == 0) && (year % 100 != 0 || year % 400 == 0);
+}
+
+// Parses optional fractional seconds (".<digits>") for %E*S and scales them to
+// absl::Duration's 0.25ns rep_lo ticks, matching cctz::detail::ParseSubSeconds
+// followed by Join() truncation.
+ABSL_ATTRIBUTE_ALWAYS_INLINE inline bool ParseFractionalSeconds(
+ const char** cursor, const char* end, uint32_t* rep_lo) {
+ static_assert(time_internal::kTicksPerNanosecond == 4,
+ "Subsecond tick scaling assumes 0.25ns ticks (4 per ns).");
+ constexpr uint32_t kTicksPerNs =
+ static_cast<uint32_t>(time_internal::kTicksPerNanosecond);
+
+ const char* pos = *cursor;
+ if (pos >= end || *pos != '.') {
+ *rep_lo = 0;
+ return true;
+ }
+ ++pos;
+
+ uint32_t digit = 0;
+ if (!TryConsumeDigit(&pos, end, &digit)) return false;
+
+ uint32_t nanos = digit;
+ uint32_t digits = 1;
+ const char* const nine_end = (end - pos < 8) ? end : pos + 8;
+ while (TryConsumeDigit(&pos, nine_end, &digit)) {
+ nanos = nanos * 10 + digit;
+ ++digits;
+ }
+
+ static constexpr uint32_t kPow10[9] = {
+ 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000};
+ if (digits < 9) {
+ *rep_lo = (nanos * kPow10[9U - digits]) * kTicksPerNs;
+ } else {
+ // Digits 10 and 11 determine the 0.25ns quarter-nanosecond ticks:
+ // floor(femtoseconds / 250000) == nanos * 4 + (d10 * 10 + d11) / 25.
+ // Digits 12..15 contribute at most 9999 femtoseconds and cannot change the
+ // quotient, while digits 16+ are consumed and ignored by ParseSubSeconds.
+ uint32_t ticks = nanos * kTicksPerNs;
+ if (TryConsumeDigit(&pos, end, &digit)) {
+ uint32_t sub_nano = digit * 10;
+ if (TryConsumeDigit(&pos, end, &digit)) {
+ sub_nano += digit;
+ while (pos < end && DigitValue(*pos) <= 9) {
+ ++pos;
+ }
+ }
+ ticks += sub_nano / 25;
+ }
+ *rep_lo = ticks;
+ }
+
+ *cursor = pos;
+ return true;
+}
+
+// Attempts to consume an optional "[:]DD" offset field in [0, 59], advancing
+// `*cursor` and storing `*out` only on success (matching cctz::ParseOffset).
+ABSL_ATTRIBUTE_ALWAYS_INLINE inline bool TryConsumeOptionalOffsetField(
+ const char** cursor, const char* end, uint32_t* out) {
+ const char* pos = *cursor;
+ if (pos < end && *pos == ':') ++pos;
+ uint32_t value = 0;
+ if (end - pos < 2 || !ParseTwoDigits(pos, &value) || value > 59) {
+ return false;
+ }
+ *out = value;
+ *cursor = pos + 2;
+ return true;
+}
+
+// Parses a %Ez UTC offset: 'Z'/'z', or (+|-)HH[[:]MM[[:]SS]].
+ABSL_ATTRIBUTE_ALWAYS_INLINE inline bool ParseUtcOffset(
+ const char** cursor, const char* end, int64_t* offset_seconds) {
+ const char* pos = *cursor;
+ if (pos >= end) return false;
+ const char tz_char = *pos++;
+ if (tz_char == 'Z' || tz_char == 'z') {
+ *offset_seconds = 0;
+ *cursor = pos;
+ return true;
+ }
+ if (tz_char != '+' && tz_char != '-') return false;
+
+ uint32_t offset_hours = 0;
+ if (end - pos < 2 || !ParseTwoDigits(pos, &offset_hours) ||
+ offset_hours > 23) {
+ return false;
+ }
+ pos += 2;
+
+ uint32_t offset_minutes = 0;
+ uint32_t offset_secs = 0;
+ if (TryConsumeOptionalOffsetField(&pos, end, &offset_minutes)) {
+ TryConsumeOptionalOffsetField(&pos, end, &offset_secs);
+ }
+
+ int64_t total_seconds = static_cast<int64_t>(
+ (offset_hours * 60 + offset_minutes) * 60 + offset_secs);
+ if (tz_char == '-') total_seconds = -total_seconds;
+ *offset_seconds = total_seconds;
+ *cursor = pos;
+ return true;
+}
+
+// Converts a validated Gregorian civil date in [0000-01-01, 9999-12-31] to
+// days since 1970-01-01. Self-contained (avoiding private cctz::detail::impl
+// coupling) and algebraically identical to cctz::detail::impl::ymd_ord().
+ABSL_ATTRIBUTE_ALWAYS_INLINE inline int64_t DaysSinceUnixEpoch(uint32_t year,
+ uint32_t month,
+ uint32_t day) {
+ // 719468 is days from 0000-03-01 to 1970-01-01; 146097 is days per 400-year
+ // Gregorian cycle from shifting `year` by +400 so `adjusted_year >= 399` and
+ // unsigned division equals exact floor division.
+ constexpr int64_t kShiftedEpochOffsetDays = 719468 + 146097;
+ static constexpr uint32_t kMonthDayOffset[12] = {
+ 306, 337, 0, 31, 61, 92, 122, 153, 184, 214, 245, 275};
+ const uint32_t adjusted_year = year + 400U - (month <= 2 ? 1U : 0U);
+ const uint32_t raw_days = adjusted_year * 365U + adjusted_year / 4U -
+ adjusted_year / 100U + adjusted_year / 400U +
+ kMonthDayOffset[month - 1] + (day - 1);
+ return static_cast<int64_t>(raw_days) - kShiftedEpochOffsetDays;
+}
+
+// Fast-path parser for RFC3339_full (%Y-%m-%d%ET%H:%M:%E*S%Ez) and
+// RFC3339_sec (%Y-%m-%d%ET%H:%M:%S%Ez) inputs with standard 4-digit years
+// (0000-9999), 2-digit fields, and non-leap seconds (00-59).
+//
+// Returns true and sets `*time` on success. On any unusual or invalid input
+// (such as non-4-digit years, single-digit fields, leap seconds ":60",
+// "infinite-future"/"infinite-past", or malformed syntax), returns false
+// without dereferencing `time` so the caller falls back to
+// cctz::detail::parse() for exact compatibility and error reporting.
+//
+// Marked NOINLINE to avoid duplicating the parser body across both ParseTime()
+// overloads and AbslParseFlag(), and to keep non-RFC3339 ParseTime() calls
+// shrink-wrapped as a direct tail-call to ParseTimeSlowPath().
+ABSL_ATTRIBUTE_NOINLINE bool TryParseRfc3339(absl::string_view input,
+ FractionalSeconds fractional_mode,
+ absl::Time* time) {
+ // Minimum valid fast-path input is "YYYY-MM-DDTHH:MM:SSZ" (20 bytes).
+ // Checking input.size() first avoids pointer arithmetic on empty/null views.
+ if (input.size() < 20) return false;
+
+ const char* cursor = input.data();
+ const char* const end = cursor + input.size();
+
+ // Skip leading ASCII whitespace, matching StripLeadingAsciiWhitespace().
+ if (static_cast<unsigned char>(*cursor) <= ' ') {
+ while (cursor < end &&
+ absl::ascii_isspace(static_cast<unsigned char>(*cursor))) {
+ ++cursor;
+ }
+ if (end - cursor < 20) return false;
+ }
+
+ // Validate fixed separator positions first: YYYY-MM-DD[Tt]HH:MM:SS
+ if (cursor[4] != '-' || cursor[7] != '-' ||
+ (cursor[10] != 'T' && cursor[10] != 't') || cursor[13] != ':' ||
+ cursor[16] != ':') {
+ return false;
+ }
+
+ uint32_t year_hi = 0;
+ uint32_t year_lo = 0;
+ uint32_t month = 0;
+ uint32_t day = 0;
+ uint32_t hour = 0;
+ uint32_t minute = 0;
+ uint32_t second = 0;
+ if (!ParseTwoDigits(cursor, &year_hi) ||
+ !ParseTwoDigits(cursor + 2, &year_lo) ||
+ !ParseTwoDigits(cursor + 5, &month) ||
+ !ParseTwoDigits(cursor + 8, &day) ||
+ !ParseTwoDigits(cursor + 11, &hour) ||
+ !ParseTwoDigits(cursor + 14, &minute) ||
+ !ParseTwoDigits(cursor + 17, &second)) {
+ return false;
+ }
+
+ const uint32_t year = year_hi * 100 + year_lo;
+ if (month < 1 || month > 12 || hour > 23 || minute > 59 || second > 59) {
+ return false;
+ }
+
+ static constexpr uint32_t kDaysInMonth[13] = {0, 31, 28, 31, 30, 31, 30,
+ 31, 31, 30, 31, 30, 31};
+ uint32_t max_day = kDaysInMonth[month];
+ if (month == 2 && IsLeapYear(year)) {
+ max_day = 29;
+ }
+ if (day < 1 || day > max_day) return false;
+
+ cursor += 19;
+
+ uint32_t rep_lo = 0;
+ if (fractional_mode == FractionalSeconds::kOptional &&
+ !ParseFractionalSeconds(&cursor, end, &rep_lo)) {
+ return false;
+ }
+
+ int64_t offset_seconds = 0;
+ if (!ParseUtcOffset(&cursor, end, &offset_seconds)) {
+ return false;
+ }
+
+ // Trailing characters must be ASCII whitespace; otherwise fall back to
+ // cctz::detail::parse() for locale whitespace or exact error messages.
+ while (cursor < end) {
+ if (!absl::ascii_isspace(static_cast<unsigned char>(*cursor))) return false;
+ ++cursor;
+ }
+
+ const int64_t days = DaysSinceUnixEpoch(year, month, day);
+ const int64_t seconds_of_day =
+ static_cast<int64_t>(hour * 3600U + minute * 60U + second);
+ const int64_t unix_seconds = days * 86400 + seconds_of_day - offset_seconds;
+ *time = time_internal::FromUnixDuration(
+ time_internal::MakeDuration(unix_seconds, rep_lo));
+ return true;
+}
+
+bool TryParseRfc3339Format(absl::string_view format, absl::string_view input,
+ absl::Time* time) {
+ if (format.size() == kRfc3339FullSize &&
+ (format.data() == RFC3339_full ||
+ format == absl::string_view(RFC3339_full, kRfc3339FullSize))) {
+ return TryParseRfc3339(input, FractionalSeconds::kOptional, time);
+ }
+ if (format.size() == kRfc3339SecSize &&
+ (format.data() == RFC3339_sec ||
+ format == absl::string_view(RFC3339_sec, kRfc3339SecSize))) {
+ return TryParseRfc3339(input, FractionalSeconds::kForbidden, time);
+ }
+ return false;
+}
+
struct cctz_parts {
cctz::time_point<cctz::seconds> sec;
cctz::detail::femtoseconds fem;
@@ -75,34 +348,8 @@
return time_internal::FromUnixDuration(d);
}
-} // namespace
-
-std::string FormatTime(absl::string_view format, absl::Time t,
- absl::TimeZone tz) {
- if (t == absl::InfiniteFuture()) return std::string(kInfiniteFutureStr);
- if (t == absl::InfinitePast()) return std::string(kInfinitePastStr);
- const auto parts = Split(t);
- return cctz::detail::format(std::string(format), parts.sec, parts.fem,
- cctz::time_zone(tz));
-}
-
-std::string FormatTime(absl::Time t, absl::TimeZone tz) {
- return FormatTime(RFC3339_full, t, tz);
-}
-
-std::string FormatTime(absl::Time t) {
- return absl::FormatTime(RFC3339_full, t, absl::LocalTimeZone());
-}
-
-bool ParseTime(absl::string_view format, absl::string_view input,
- absl::Time* time, std::string* err) {
- return absl::ParseTime(format, input, absl::UTCTimeZone(), time, err);
-}
-
-// If the input string does not contain an explicit UTC offset, interpret
-// the fields with respect to the given TimeZone.
-bool ParseTime(absl::string_view format, absl::string_view input,
- absl::TimeZone tz, absl::Time* time, std::string* err) {
+bool ParseTimeSlowPath(absl::string_view format, absl::string_view input,
+ absl::TimeZone tz, absl::Time* time, std::string* err) {
static constexpr struct Literal {
absl::string_view name;
absl::Time value;
@@ -135,9 +382,49 @@
return b;
}
+} // namespace
+
+std::string FormatTime(absl::string_view format, absl::Time t,
+ absl::TimeZone tz) {
+ if (t == absl::InfiniteFuture()) return std::string(kInfiniteFutureStr);
+ if (t == absl::InfinitePast()) return std::string(kInfinitePastStr);
+ const auto parts = Split(t);
+ return cctz::detail::format(std::string(format), parts.sec, parts.fem,
+ cctz::time_zone(tz));
+}
+
+std::string FormatTime(absl::Time t, absl::TimeZone tz) {
+ return FormatTime(RFC3339_full, t, tz);
+}
+
+std::string FormatTime(absl::Time t) {
+ return absl::FormatTime(RFC3339_full, t, absl::LocalTimeZone());
+}
+
+bool ParseTime(absl::string_view format, absl::string_view input,
+ absl::Time* time, std::string* err) {
+ if (TryParseRfc3339Format(format, input, time)) {
+ return true;
+ }
+ return ParseTimeSlowPath(format, input, absl::UTCTimeZone(), time, err);
+}
+
+// If the input string does not contain an explicit UTC offset, interpret
+// the fields with respect to the given TimeZone.
+bool ParseTime(absl::string_view format, absl::string_view input,
+ absl::TimeZone tz, absl::Time* time, std::string* err) {
+ if (TryParseRfc3339Format(format, input, time)) {
+ return true;
+ }
+ return ParseTimeSlowPath(format, input, tz, time, err);
+}
+
// Functions required to support absl::Time flags.
bool AbslParseFlag(absl::string_view text, absl::Time* t, std::string* error) {
- return absl::ParseTime(RFC3339_full, text, absl::UTCTimeZone(), t, error);
+ if (TryParseRfc3339(text, FractionalSeconds::kOptional, t)) {
+ return true;
+ }
+ return ParseTimeSlowPath(RFC3339_full, text, absl::UTCTimeZone(), t, error);
}
std::string AbslUnparseFlag(absl::Time t) {
diff --git a/absl/time/format_test.cc b/absl/time/format_test.cc
index 0222b6e..ea90f95 100644
--- a/absl/time/format_test.cc
+++ b/absl/time/format_test.cc
@@ -18,6 +18,8 @@
#include "gmock/gmock.h"
#include "gtest/gtest.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
#include "absl/time/civil_time.h"
#include "absl/time/internal/test_util.h"
#include "absl/time/time.h"
@@ -451,4 +453,391 @@
EXPECT_EQ(in, out);
}
+TEST(ParseTime, Rfc3339DifferentialEquivalence) {
+ // Trailing space in the format string is semantically identical to the base
+ // RFC3339 format in cctz::detail::parse() (which always skips trailing
+ // whitespace), while bypassing the RFC3339 fast path in absl::ParseTime().
+ const std::string ref_full = std::string(absl::RFC3339_full) + " ";
+ const std::string ref_sec = std::string(absl::RFC3339_sec) + " ";
+ const std::string copy_full = absl::RFC3339_full;
+ const std::string copy_sec = absl::RFC3339_sec;
+
+ const absl::TimeZone utc = absl::UTCTimeZone();
+ const absl::TimeZone lax =
+ absl::time_internal::LoadTimeZone("America/Los_Angeles");
+ const absl::Time sentinel = absl::FromUnixSeconds(123456789);
+ constexpr absl::string_view kErrSentinel = "unchanged";
+
+ static constexpr absl::string_view kInputs[] = {
+ // Standard valid timestamps (epoch, pre-epoch, extreme 4-digit years).
+ "1970-01-01T00:00:00Z",
+ "1970-01-01t00:00:00z",
+ "1969-12-31T23:59:59Z",
+ "1969-12-31T23:59:59.999999Z",
+ "1969-12-31T23:59:59.999999999Z",
+ "0000-01-01T00:00:00Z",
+ "0000-02-29T12:34:56Z",
+ "0000-03-01T00:00:00Z",
+ "9999-12-31T23:59:59Z",
+ "9999-12-31T23:59:59.999999999Z",
+ "9999-12-31T23:59:59-23:59:59",
+ "0000-01-01T00:00:00+23:59:59",
+
+ // Leap year and calendar boundary cases.
+ "1900-02-28T23:59:59Z",
+ "1900-02-29T00:00:00Z",
+ "2000-02-29T00:00:00Z",
+ "2023-02-29T00:00:00Z",
+ "2024-02-29T00:00:00Z",
+ "2100-02-29T00:00:00Z",
+ "2400-02-29T00:00:00Z",
+ "2024-04-30T00:00:00Z",
+ "2024-04-31T00:00:00Z",
+ "2024-06-31T00:00:00Z",
+ "2024-09-31T00:00:00Z",
+ "2024-11-31T00:00:00Z",
+ "2024-00-01T00:00:00Z",
+ "2024-13-01T00:00:00Z",
+ "2024-01-00T00:00:00Z",
+ "2024-01-32T00:00:00Z",
+
+ // Fractional seconds: 1..20 digits and quarter-nanosecond boundaries.
+ "2024-05-06T07:08:09.0Z",
+ "2024-05-06T07:08:09.5Z",
+ "2024-05-06T07:08:09.12Z",
+ "2024-05-06T07:08:09.123Z",
+ "2024-05-06T07:08:09.1234Z",
+ "2024-05-06T07:08:09.12345Z",
+ "2024-05-06T07:08:09.123456Z",
+ "2024-05-06T07:08:09.1234567Z",
+ "2024-05-06T07:08:09.12345678Z",
+ "2024-05-06T07:08:09.123456789Z",
+ "2024-05-06T07:08:09.0000000000Z",
+ "2024-05-06T07:08:09.0000000002Z",
+ "2024-05-06T07:08:09.0000000003Z",
+ "2024-05-06T07:08:09.0000000005Z",
+ "2024-05-06T07:08:09.0000000007Z",
+ "2024-05-06T07:08:09.0000000008Z",
+ "2024-05-06T07:08:09.00000000024Z",
+ "2024-05-06T07:08:09.00000000025Z",
+ "2024-05-06T07:08:09.00000000049Z",
+ "2024-05-06T07:08:09.00000000050Z",
+ "2024-05-06T07:08:09.00000000074Z",
+ "2024-05-06T07:08:09.00000000075Z",
+ "2024-05-06T07:08:09.00000000099Z",
+ "2024-05-06T07:08:09.000000000249999Z",
+ "2024-05-06T07:08:09.00000000024999999999Z",
+ "2024-05-06T07:08:09.2147483647Z",
+ "2024-05-06T07:08:09.2147483648Z",
+ "2024-05-06T07:08:09.99999999999999999999Z",
+ "2024-05-06T07:08:09.123456789",
+ "2024-05-06T07:08:09.1234567890",
+ "2024-05-06T07:08:09.12345678901",
+ "2024-05-06T07:08:09.12345678901234567890",
+ "2024-05-06T07:08:09.Z",
+ "2024-05-06T07:08:09.",
+
+ // All valid and invalid %Ez offset forms.
+ "2024-05-06T07:08:09+00:00",
+ "2024-05-06T07:08:09-00:00",
+ "2024-05-06T07:08:09+00",
+ "2024-05-06T07:08:09-00",
+ "2024-05-06T07:08:09+0000",
+ "2024-05-06T07:08:09-0000",
+ "2024-05-06T07:08:09+00:00:00",
+ "2024-05-06T07:08:09-00:00:00",
+ "2024-05-06T07:08:09+000000",
+ "2024-05-06T07:08:09-000000",
+ "2024-05-06T07:08:09+05:30",
+ "2024-05-06T07:08:09-07:00",
+ "2024-05-06T07:08:09+0530",
+ "2024-05-06T07:08:09-0700",
+ "2024-05-06T07:08:09+01:02:03",
+ "2024-05-06T07:08:09-01:02:03",
+ "2024-05-06T07:08:09+010203",
+ "2024-05-06T07:08:09-010203",
+ "2024-05-06T07:08:09+01:0203",
+ "2024-05-06T07:08:09+0102:03",
+ "2024-05-06T07:08:09+01:02 ",
+ "2024-05-06T07:08:09+02",
+ "2024-05-06T07:08:09-12",
+ "2024-05-06T07:08:09+23:59:59",
+ "2024-05-06T07:08:09-23:59:59",
+ "2024-05-06T07:08:09+24:00",
+ "2024-05-06T07:08:09-24:00",
+ "2024-05-06T07:08:09+00:60",
+ "2024-05-06T07:08:09+00:00:60",
+ "2024-05-06T07:08:09+08:99",
+ "2024-05-06T07:08:09+01::02",
+ "2024-05-06T07:08:09+01020304",
+ "2024-05-06T07:08:09+01:",
+ "2024-05-06T07:08:09+01:2",
+ "2024-05-06T07:08:09+01:23:",
+ "2024-05-06T07:08:09+01:23:4",
+ "2024-05-06T07:08:09+1",
+ "2024-05-06T07:08:09-1",
+ "2024-05-06T07:08:09+",
+ "2024-05-06T07:08:09-",
+ "2024-05-06T07:08:09+-08:00",
+ "2024-05-06T07:08:09-00:-0",
+ "2024-05-06T07:08:09",
+
+ // Leap seconds and out-of-range time fields.
+ "2016-12-31T23:59:60Z",
+ "2016-12-31T23:59:60.999Z",
+ "2016-12-31T23:59:60-05:00",
+ "2016-12-31T23:59:61Z",
+ "2024-05-06T24:00:00Z",
+ "2024-05-06T00:60:00Z",
+
+ // Fallback valid cases: non-4-digit years, single-digit fields,
+ // infinities.
+ "77-06-28T09:08:07Z",
+ "999-01-01T00:00:00Z",
+ "10000-01-01T00:00:00Z",
+ "-0001-01-01T00:00:00Z",
+ "-2024-01-01T00:00:00Z",
+ "2024-1-2T3:4:5Z",
+ "2024-01-2T03:04:05Z",
+ "infinite-future",
+ " infinite-future ",
+ " infinite-future ",
+ "infinite-past",
+ "\tinfinite-past\n",
+
+ // Leading/trailing whitespace (including >=20-byte whitespace-padded
+ // short inputs), trailing junk, and malformed syntax.
+ " ",
+ " 2024-05-06T07:08:09",
+ " 2024-05-06T07:08:09Z",
+ "\t\n\r\v\f2024-05-06T07:08:09Z",
+ "2024-05-06T07:08:09Z ",
+ "2024-05-06T07:08:09Z \t\n\r\v\f",
+ " 2024-05-06T07:08:09.123456-07:00 ",
+ "2024-05-06T07:08:09Z extra",
+ "2024-05-06T07:08:09Z0",
+ "2024-05-06 07:08:09Z",
+ "2024/05/06T07:08:09Z",
+ "2024-05-06T07:08:09.123.456Z",
+ "-000-01-01T00:00:00Z",
+ "",
+ "2024-05-06T07:08:0",
+ "\x80"
+ "2024-05-06T07:08:09Z",
+ "2024-05-06T07:08:09Z\xa0",
+ absl::string_view("2024-05-06T07:08:09Z\0", 21),
+ absl::string_view("2024-05-06T07:08:09Z \0", 22),
+ absl::string_view("2024-05-06\0T07:08:09Z", 21),
+ };
+
+ auto check_tz_variant =
+ [&](absl::string_view label, absl::string_view ref_fmt,
+ absl::string_view fast_ptr_fmt, absl::string_view fast_copy_fmt,
+ absl::string_view input, absl::TimeZone tz) {
+ absl::Time expected_t = sentinel;
+ std::string expected_err(kErrSentinel);
+ const bool expected_ok =
+ absl::ParseTime(ref_fmt, input, tz, &expected_t, &expected_err);
+
+ for (const absl::string_view fmt : {fast_ptr_fmt, fast_copy_fmt}) {
+ absl::Time actual_t = sentinel;
+ std::string actual_err(kErrSentinel);
+ const bool actual_ok =
+ absl::ParseTime(fmt, input, tz, &actual_t, &actual_err);
+ EXPECT_EQ(actual_ok, expected_ok)
+ << label << " tz=" << tz.name()
+ << " input=" << testing::PrintToString(input);
+ EXPECT_EQ(actual_t, expected_t)
+ << label << " tz=" << tz.name()
+ << " input=" << testing::PrintToString(input);
+ EXPECT_EQ(actual_err, expected_err)
+ << label << " tz=" << tz.name()
+ << " input=" << testing::PrintToString(input);
+
+ absl::Time null_err_t = sentinel;
+ EXPECT_EQ(absl::ParseTime(fmt, input, tz, &null_err_t, nullptr),
+ expected_ok)
+ << label << " nullptr err tz=" << tz.name()
+ << " input=" << testing::PrintToString(input);
+ EXPECT_EQ(null_err_t, expected_t)
+ << label << " nullptr err tz=" << tz.name()
+ << " input=" << testing::PrintToString(input);
+ }
+ };
+
+ for (const absl::string_view input : kInputs) {
+ for (const absl::TimeZone tz : {utc, lax}) {
+ check_tz_variant("RFC3339_full", ref_full, absl::RFC3339_full, copy_full,
+ input, tz);
+ check_tz_variant("RFC3339_sec", ref_sec, absl::RFC3339_sec, copy_sec,
+ input, tz);
+ }
+
+ // Exercise the 4-arg ParseTime overload and AbslParseFlag directly.
+ absl::Time expected_full_t = sentinel;
+ std::string expected_full_err(kErrSentinel);
+ const bool expected_full_ok =
+ absl::ParseTime(ref_full, input, &expected_full_t, &expected_full_err);
+
+ absl::Time four_arg_full_t = sentinel;
+ std::string four_arg_full_err(kErrSentinel);
+ EXPECT_EQ(absl::ParseTime(absl::RFC3339_full, input, &four_arg_full_t,
+ &four_arg_full_err),
+ expected_full_ok)
+ << "4-arg RFC3339_full input=" << testing::PrintToString(input);
+ EXPECT_EQ(four_arg_full_t, expected_full_t)
+ << "4-arg RFC3339_full input=" << testing::PrintToString(input);
+ EXPECT_EQ(four_arg_full_err, expected_full_err)
+ << "4-arg RFC3339_full input=" << testing::PrintToString(input);
+
+ absl::Time flag_t = sentinel;
+ std::string flag_err(kErrSentinel);
+ EXPECT_EQ(absl::AbslParseFlag(input, &flag_t, &flag_err), expected_full_ok)
+ << "AbslParseFlag input=" << testing::PrintToString(input);
+ EXPECT_EQ(flag_t, expected_full_t)
+ << "AbslParseFlag input=" << testing::PrintToString(input);
+ EXPECT_EQ(flag_err, expected_full_err)
+ << "AbslParseFlag input=" << testing::PrintToString(input);
+
+ absl::Time expected_sec_t = sentinel;
+ std::string expected_sec_err(kErrSentinel);
+ const bool expected_sec_ok =
+ absl::ParseTime(ref_sec, input, &expected_sec_t, &expected_sec_err);
+
+ absl::Time four_arg_sec_t = sentinel;
+ std::string four_arg_sec_err(kErrSentinel);
+ EXPECT_EQ(absl::ParseTime(absl::RFC3339_sec, input, &four_arg_sec_t,
+ &four_arg_sec_err),
+ expected_sec_ok)
+ << "4-arg RFC3339_sec input=" << testing::PrintToString(input);
+ EXPECT_EQ(four_arg_sec_t, expected_sec_t)
+ << "4-arg RFC3339_sec input=" << testing::PrintToString(input);
+ EXPECT_EQ(four_arg_sec_err, expected_sec_err)
+ << "4-arg RFC3339_sec input=" << testing::PrintToString(input);
+ }
+}
+
+TEST(ParseTime, Rfc3339NullStringView) {
+ const absl::Time sentinel = absl::FromUnixSeconds(42);
+ absl::Time t = sentinel;
+ std::string err;
+
+ // Default-constructed string_view has data() == nullptr and size() == 0.
+ const absl::string_view null_sv;
+ ASSERT_EQ(null_sv.data(), nullptr);
+ EXPECT_FALSE(absl::ParseTime(absl::RFC3339_full, null_sv, &t, &err));
+ EXPECT_EQ(t, sentinel);
+ EXPECT_FALSE(absl::ParseTime(absl::RFC3339_sec, null_sv, &t, &err));
+ EXPECT_EQ(t, sentinel);
+ EXPECT_FALSE(absl::AbslParseFlag(null_sv, &t, &err));
+ EXPECT_EQ(t, sentinel);
+}
+
+TEST(ParseTime, Rfc3339NullTimeOnInvalidInput) {
+ // Passing nullptr for `time` on invalid input (both <20-byte and >=20-byte
+ // fast-path candidates) must not dereference `time` or form a null reference.
+ static constexpr absl::string_view kInvalidInputs[] = {
+ "not-a-time",
+ "2024-05-06T07:08:09Z extra",
+ "2024-02-30T07:08:09Z",
+ };
+ for (const absl::string_view input : kInvalidInputs) {
+ std::string err;
+ EXPECT_FALSE(absl::ParseTime(absl::RFC3339_full, input, nullptr, &err))
+ << input;
+ EXPECT_FALSE(err.empty()) << input;
+
+ err.clear();
+ EXPECT_FALSE(absl::ParseTime(absl::RFC3339_sec, input, absl::UTCTimeZone(),
+ nullptr, &err))
+ << input;
+ EXPECT_FALSE(err.empty()) << input;
+
+ err.clear();
+ EXPECT_FALSE(
+ absl::AbslParseFlag(input, static_cast<absl::Time*>(nullptr), &err))
+ << input;
+ EXPECT_FALSE(err.empty()) << input;
+ }
+}
+
+TEST(ParseTime, Rfc3339EmbeddedNulFormatNotMatched) {
+ // 24-byte and 22-byte formats with an embedded NUL must not match
+ // RFC3339_full or RFC3339_sec.
+ const absl::Time sentinel = absl::FromUnixSeconds(42);
+ absl::Time t = sentinel;
+ std::string err;
+ const std::string nul_full_fmt("%Y-%m-%d%ET%H:%M:%E*S\0Ez", 24);
+ const std::string nul_sec_fmt("%Y-%m-%d%ET%H:%M:%S\0Ez", 22);
+ EXPECT_FALSE(absl::ParseTime(nul_full_fmt, "2024-05-06T07:08:09Z", &t, &err));
+ EXPECT_EQ(t, sentinel);
+ EXPECT_FALSE(absl::ParseTime(nul_sec_fmt, "2024-05-06T07:08:09Z", &t, &err));
+ EXPECT_EQ(t, sentinel);
+}
+
+TEST(ParseTime, Rfc3339FormatSubsliceNotMatchedAsFull) {
+ // Ensure pointer-based format matching still checks format.size() for both
+ // RFC3339_full and RFC3339_sec.
+ const absl::Time sentinel = absl::FromUnixSeconds(42);
+ for (const absl::string_view date_only :
+ {absl::string_view(absl::RFC3339_full, 8),
+ absl::string_view(absl::RFC3339_sec, 8)}) {
+ ASSERT_EQ(date_only, "%Y-%m-%d");
+ absl::Time t = sentinel;
+ std::string err;
+ EXPECT_TRUE(absl::ParseTime(date_only, "2024-05-06", &t, &err)) << err;
+ EXPECT_EQ(t,
+ absl::FromCivil(absl::CivilDay(2024, 5, 6), absl::UTCTimeZone()));
+
+ // A full >=20-byte RFC3339 timestamp must be rejected (not fast-pathed).
+ t = sentinel;
+ err.clear();
+ EXPECT_FALSE(absl::ParseTime(date_only, "2024-05-06T07:08:09Z", &t, &err));
+ EXPECT_EQ(t, sentinel);
+ EXPECT_THAT(err, HasSubstr("Illegal trailing data"));
+ }
+}
+
+TEST(ParseTime, Rfc3339CalendarExhaustive400YearCycle) {
+ // Verify civil-to-Unix-seconds conversion across a full 400-year Gregorian
+ // cycle (0000..0400) plus modern years (1968..2035).
+ const absl::TimeZone utc = absl::UTCTimeZone();
+ auto check_date = [&](int year, int month, int day) {
+ const std::string input =
+ absl::StrFormat("%04d-%02d-%02dT12:34:56Z", year, month, day);
+ absl::Time t;
+ std::string err;
+ ASSERT_TRUE(absl::ParseTime(absl::RFC3339_sec, input, &t, &err))
+ << input << ": " << err;
+ EXPECT_EQ(t, absl::FromCivil(
+ absl::CivilSecond(year, month, day, 12, 34, 56), utc))
+ << input;
+ };
+
+ for (int year = 0; year <= 400; ++year) {
+ check_date(year, 1, 1);
+ check_date(year, 2, 28);
+ check_date(year, 3, 1);
+ check_date(year, 12, 31);
+ const bool is_leap = absl::CivilDay(year, 2, 29).month() == 2;
+ const std::string feb29 = absl::StrFormat("%04d-02-29T00:00:00Z", year);
+ absl::Time t;
+ std::string err;
+ if (is_leap) {
+ ASSERT_TRUE(absl::ParseTime(absl::RFC3339_sec, feb29, &t, &err))
+ << feb29 << ": " << err;
+ EXPECT_EQ(t, absl::FromCivil(absl::CivilDay(year, 2, 29), utc)) << feb29;
+ } else {
+ EXPECT_FALSE(absl::ParseTime(absl::RFC3339_sec, feb29, &t, &err))
+ << feb29;
+ }
+ }
+
+ for (int year = 1968; year <= 2035; ++year) {
+ for (int month = 1; month <= 12; ++month) {
+ check_date(year, month, 1);
+ }
+ }
+}
+
} // namespace