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