re2 1.24.1 → 1.25.0

package/vendor/abseil-cpp/absl/time/internal/cctz/src/time_zone_format_test.cc

@@ -142,7 +142,7 @@ TEST(Format, Basics) {
   time_zone tz = utc_time_zone();
   time_point<chrono::nanoseconds> tp = chrono::system_clock::from_time_t(0);
 
-  // Starts with a couple basic edge cases.
+  // Start with basic edge cases.
   EXPECT_EQ("", absl::time_internal::cctz::format("", tp, tz));
   EXPECT_EQ(" ", absl::time_internal::cctz::format(" ", tp, tz));
   EXPECT_EQ("  ", absl::time_internal::cctz::format("  ", tp, tz));
@@ -786,6 +786,36 @@ TEST(Format, Week) {
             absl::time_internal::cctz::format("%Y-%W-%w", tp, utc));
 }
 
+TEST(Format, NULsInFormatString) {
+  time_zone tz = utc_time_zone();
+  time_point<chrono::nanoseconds> tp = chrono::system_clock::from_time_t(0);
+
+  // All NULs.
+  std::string nuls(32, '\0');
+  EXPECT_EQ(nuls, absl::time_internal::cctz::format(nuls, tp, tz));
+
+  // NULs amongst ordinary text plus the internal "%\0" specifier.
+  std::string percent_nul("\0X\0\0X%\0\0X\0\0X\0", 13);
+  EXPECT_EQ(percent_nul,
+            absl::time_internal::cctz::format(percent_nul, tp, tz));
+
+  // NULs amongst ordinary text plus a non-internal specifier (%I).
+  EXPECT_EQ(std::string("X\0\0\0X12\0X\0\0\0X", 13),
+            absl::time_internal::cctz::format(
+                std::string("X\0\0\0X%I\0X\0\0\0X", 13), tp, tz));
+
+#if defined(__linux__) && defined(__GLIBC__)
+  // Depending upon strftime() behavior on "%E"
+  // and "%O", "%E\0" and "%0\0" produce themselves.
+  std::string percent_E_nul("abc%E\0xyz", 9);
+  EXPECT_EQ(percent_E_nul,
+            absl::time_internal::cctz::format(percent_E_nul, tp, tz));
+  std::string percent_O_nul("abc%O\0xyz", 9);
+  EXPECT_EQ(percent_O_nul,
+            absl::time_internal::cctz::format(percent_O_nul, tp, tz));
+#endif
+}
+
 //
 // Testing parse()
 //
@@ -930,6 +960,9 @@ TEST(Parse, ErrorCases) {
   const time_zone tz = utc_time_zone();
   auto tp = chrono::system_clock::from_time_t(0);
 
+  // No data.
+  EXPECT_FALSE(parse("X", "", tz, &tp));
+
   // Illegal trailing data.
   EXPECT_FALSE(parse("%S", "123", tz, &tp));
 
@@ -1578,6 +1611,41 @@ TEST(Parse, WeekYearShift) {
   EXPECT_FALSE(parse("%Y-%U-%u", "9223372036854775807-53-7", utc, &tp));
 }
 
+TEST(Parse, NULsInFormatAndInputStrings) {
+  const time_zone utc = utc_time_zone();
+  time_point<absl::time_internal::cctz::seconds> tp;
+
+  // Check that NULs are parsed just like any other chars.
+  EXPECT_FALSE(
+      parse(std::string("abc\0def", 7), std::string("abc\0xyz", 7), utc, &tp));
+  EXPECT_FALSE(
+      parse(std::string("%Y\0def", 6), std::string("2026\0xyz", 8), utc, &tp));
+  EXPECT_TRUE(
+      parse(std::string("%Y\0xyz", 6), std::string("2026\0xyz", 8), utc, &tp));
+  ExpectTime(tp, utc, 2026, 1, 1, 0, 0, 0, 0, false, "UTC");
+
+  // All NULs.
+  std::string nuls(32, '\0');
+  EXPECT_TRUE(parse(nuls, nuls, utc, &tp));
+  ExpectTime(tp, utc, 1970, 1, 1, 0, 0, 0, 0, false, "UTC");
+
+  // The "%\0" specifier never matches, even on the empty string and itself.
+  std::string percent_nul("%\0", 2);
+  EXPECT_FALSE(parse(percent_nul, "", utc, &tp));
+  EXPECT_FALSE(parse(percent_nul, percent_nul, utc, &tp));
+
+#if defined(__linux__) && defined(__GLIBC__)
+  // Depending upon strptime() behavior on "%E"
+  // and "%O", "%E\0" and "%0\0" also never match.
+  std::string percent_E_nul("%E\0", 3);
+  EXPECT_FALSE(parse(percent_E_nul, "", utc, &tp));
+  EXPECT_FALSE(parse(percent_E_nul, percent_E_nul, utc, &tp));
+  std::string percent_O_nul("%O\0", 3);
+  EXPECT_FALSE(parse(percent_O_nul, "", utc, &tp));
+  EXPECT_FALSE(parse(percent_O_nul, percent_O_nul, utc, &tp));
+#endif
+}
+
 TEST(Parse, MaxRange) {
   const time_zone utc = utc_time_zone();
   time_point<absl::time_internal::cctz::seconds> tp;
@@ -1707,10 +1775,18 @@ TEST(FormatParse, RoundTrip) {
   const auto in = convert(civil_second(1977, 6, 28, 9, 8, 7), lax);
   const auto subseconds = chrono::nanoseconds(654321);
 
+  // No format specifiers, but include NUL.
+  {
+    time_point<chrono::nanoseconds> out;
+    const auto fmt = std::string("\0\1\2\3\4\5\6\7abcdefgh01234567");
+    const auto s = absl::time_internal::cctz::format(fmt, in, lax);
+    EXPECT_TRUE(parse(fmt, s, lax, &out)) << s;
+  }
+
   // RFC3339, which renders subseconds.
   {
     time_point<chrono::nanoseconds> out;
-    const std::string s =
+    const auto s =
         absl::time_internal::cctz::format(RFC3339_full, in + subseconds, lax);
     EXPECT_TRUE(parse(RFC3339_full, s, lax, &out)) << s;
     EXPECT_EQ(in + subseconds, out);  // RFC3339_full includes %Ez
@@ -1719,8 +1795,7 @@ TEST(FormatParse, RoundTrip) {
   // RFC1123, which only does whole seconds.
   {
     time_point<chrono::nanoseconds> out;
-    const std::string s =
-        absl::time_internal::cctz::format(RFC1123_full, in, lax);
+    const auto s = absl::time_internal::cctz::format(RFC1123_full, in, lax);
     EXPECT_TRUE(parse(RFC1123_full, s, lax, &out)) << s;
     EXPECT_EQ(in, out);  // RFC1123_full includes %z
   }
@@ -1738,7 +1813,7 @@ TEST(FormatParse, RoundTrip) {
   {
     time_point<chrono::nanoseconds> out;
     time_zone utc = utc_time_zone();
-    const std::string s = absl::time_internal::cctz::format("%c", in, utc);
+    const auto s = absl::time_internal::cctz::format("%c", in, utc);
     EXPECT_TRUE(parse("%c", s, utc, &out)) << s;
     EXPECT_EQ(in, out);
   }

package/vendor/abseil-cpp/absl/time/internal/cctz/src/time_zone_name_win.cc

@@ -131,7 +131,7 @@ ucal_getTimeZoneIDForWindowsID_func LoadIcuGetTimeZoneIDForWindowsID() {
 
 // Convert wchar_t array (UTF-16) to UTF-8 string
 std::string Utf16ToUtf8(const wchar_t* ptr, size_t size) {
-  if (size > std::numeric_limits<int>::max()) {
+  if (size > static_cast<size_t>(std::numeric_limits<int>::max())) {
     return std::string();
   }
   const int chars_len = static_cast<int>(size);
@@ -140,7 +140,6 @@ std::string Utf16ToUtf8(const wchar_t* ptr, size_t size) {
       std::min<size_t>(result.capacity(), std::numeric_limits<int>::max()), 1);
   do {
     result.resize(len);
-    // TODO: Switch to std::string::data() when we require C++17 or higher.
     len = static_cast<std::size_t>(::WideCharToMultiByte(
         CP_UTF8, WC_ERR_INVALID_CHARS, ptr, chars_len, &result[0],
         static_cast<int>(len), nullptr, nullptr));

package/vendor/abseil-cpp/absl/time/internal/cctz/src/tzfile.h

@@ -17,15 +17,8 @@
 ** Thank you!
 */
 
-/*
-** Information about time zone files.
-*/
-
-#ifndef TZDEFRULES
-#define TZDEFRULES "posixrules"
-#endif /* !defined TZDEFRULES */
-
-/* See Internet RFC 9636 for more details about the following format.  */
+/* Information about time zone files.
+   See Internet RFC 9636 for more details about the following format.  */
 
 /*
 ** Each file begins with. . .
@@ -96,23 +89,25 @@ struct tzhead {
 */
 
 #ifndef TZ_MAX_TIMES
-/* This must be at least 242 for Europe/London with 'zic -b fat'.  */
+/* The following limit applies to localtime.c; zic has no such limit.
+   The limit must be at least 310 for Asia/Hebron with 'zic -b fat'.  */
 #define TZ_MAX_TIMES 2000
 #endif /* !defined TZ_MAX_TIMES */
 
 #ifndef TZ_MAX_TYPES
 /* This must be at least 18 for Europe/Vilnius with 'zic -b fat'.  */
-#define TZ_MAX_TYPES 256 /* Limited by what (unsigned char)'s can hold */
+#define TZ_MAX_TYPES 256 /* Limited to 256 by Internet RFC 9636.  */
 #endif                   /* !defined TZ_MAX_TYPES */
 
 #ifndef TZ_MAX_CHARS
 /* This must be at least 40 for America/Anchorage.  */
-#define TZ_MAX_CHARS 50 /* Maximum number of abbreviation characters */
-                        /* (limited by what unsigned chars can hold) */
-#endif                  /* !defined TZ_MAX_CHARS */
+#define TZ_MAX_CHARS 256 /* Maximum number of abbreviation characters */
+                         /* (limited to 256 by Internet RFC 9636) */
+#endif                   /* !defined TZ_MAX_CHARS */
 
 #ifndef TZ_MAX_LEAPS
-/* This must be at least 27 for leap seconds from 1972 through mid-2023.
+/* The following limit applies to localtime.c; zic has no such limit.
+   The limit must be at least 27 for leap seconds from 1972 through mid-2023.
    There's a plan to discontinue leap seconds by 2035.  */
 #define TZ_MAX_LEAPS 50 /* Maximum number of leap second corrections */
 #endif                  /* !defined TZ_MAX_LEAPS */

package/vendor/abseil-cpp/absl/time/internal/cctz/testdata/version

@@ -1 +1 @@
-2025c
+2026b

package/vendor/abseil-cpp/absl/time/internal/cctz/testdata/zoneinfo/zone1970.tab

@@ -115,11 +115,11 @@ CA	+5017-10750	America/Swift_Current	CST - SK (midwest)
 CA	+5333-11328	America/Edmonton	Mountain - AB, BC(E), NT(E), SK(W)
 CA	+690650-1050310	America/Cambridge_Bay	Mountain - NU (west)
 CA	+682059-1334300	America/Inuvik	Mountain - NT (west)
+CA	+4916-12307	America/Vancouver	MST - BC (most areas)
 CA	+5546-12014	America/Dawson_Creek	MST - BC (Dawson Cr, Ft St John)
 CA	+5848-12242	America/Fort_Nelson	MST - BC (Ft Nelson)
 CA	+6043-13503	America/Whitehorse	MST - Yukon (east)
 CA	+6404-13925	America/Dawson	MST - Yukon (west)
-CA	+4916-12307	America/Vancouver	Pacific - BC (most areas)
 CH,DE,LI	+4723+00832	Europe/Zurich	Büsingen
 CI,BF,GH,GM,GN,IS,ML,MR,SH,SL,SN,TG	+0519-00402	Africa/Abidjan
 CK	-2114-15946	Pacific/Rarotonga

package/vendor/abseil-cpp/absl/time/internal/cctz/testdata/zoneinfo/zonenow.tab

@@ -58,6 +58,9 @@ XX	-2504-13005	Pacific/Pitcairn	Pitcairn
 # -08/-07 - PST/PDT (North America DST)
 XX	+340308-1181434	America/Los_Angeles	Pacific (PST/PDT) - US & Canada; Mexico near US border
 #
+# -08/-07 - PST/PDT (North America DST) until 2026-11-01 02:00; then MST
+XX	+4916-12307	America/Vancouver	MST - BC (most areas)
+#
 # -07 - MST
 XX	+332654-1120424	America/Phoenix	Mountain Standard (MST) - Arizona; western Mexico; Yukon
 #
@@ -166,9 +169,6 @@ XX	+3003+03115	Africa/Cairo	Egypt
 # +02/+03 - EET/EEST (Lebanon DST)
 XX	+3353+03530	Asia/Beirut	Lebanon
 #
-# +02/+03 - EET/EEST (Moldova DST)
-XX	+4700+02850	Europe/Chisinau	Moldova
-#
 # +02/+03 - EET/EEST (Palestine DST)
 XX	+3130+03428	Asia/Gaza	Palestine
 #

package/vendor/abseil-cpp/absl/time/simulated_clock.cc

@@ -0,0 +1,225 @@
+// Copyright 2026 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/time/simulated_clock.h"
+
+#include <cstdint>
+#include <map>
+#include <memory>
+#include <optional>
+#include <utility>
+#include <vector>
+
+#include "absl/base/config.h"
+#include "absl/base/macros.h"
+#include "absl/base/nullability.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/synchronization/mutex.h"
+#include "absl/time/clock.h"
+#include "absl/time/time.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// There are a few tricky details in the implementation of SimulatedClock.
+//
+// The external mutex that is passed as a param of AwaitWithDeadline() is not
+// under the control of SimulatedClock; in particular, it can be destroyed any
+// time after AwaitWithDeadline() returns.  This requires the wakeup call from
+// AdvanceTime() to avoid grabbing the external mutex if AwaitWithDeadline()
+// has returned.  This is accomplished by allowing the waiter to be cancelled
+// via a bool guarded by a mutex in WakeUpInfo.
+//
+// Once AwaitWithDeadline() has released lock_, someone nefarious might call
+// the SimulatedClock destructor, so it isn't possible for AwaitWithDeadline()
+// to remove the wakeup call from waiters_ if the condition it is awaiting
+// becomes true; it cancels the waiter instead.  This means that,
+// theoretically, many obsolete entries could pile up in waiters_ if
+// AwaitWithDeadline() keeps being called but simulated time is not advanced.
+// This seems unlikely to happen in practice.
+//
+// The WakeUpInfo in waiters_ are always awoken via WakeUp() (and
+// removed) or cancelled before AwaitWithDeadline() returns.  If a
+// waiters_ value is cancelled then calling its WakeUp() method will
+// short-circuit before touching the external mutex.
+
+class SimulatedClock::WakeUpInfo {
+ public:
+  WakeUpInfo(absl::Mutex* mu, absl::Condition cond)
+      : mu_(mu),
+        cond_(cond),
+        wakeup_time_passed_(false),
+        cancelled_(false),
+        wakeup_called_(false) {}
+
+  void WakeUp() {
+    // If we are cancelled then AwaitWithDeadline may have returned, in which
+    // case we can't lock mu_.
+    {
+      absl::MutexLock lock(cancellation_mu_);
+      if (cancelled_) return;
+      wakeup_called_ = true;
+    }
+    absl::MutexLock lock(*mu_);
+    wakeup_time_passed_ = true;
+  }
+
+  void AwaitConditionOrWakeUp() {
+    mu_->Await(absl::Condition(this, &WakeUpInfo::Ready));
+  }
+
+  void CancelOrAwaitWakeUp() {
+    bool wakeup_called;
+    {
+      absl::MutexLock lock(cancellation_mu_);
+      cancelled_ = true;
+      wakeup_called = wakeup_called_;
+    }
+    if (wakeup_called && !wakeup_time_passed_) {
+      // Wait for WakeUp to complete.
+      //
+      // Note that this will unlock 'mu_'; this is actually necessary
+      // so that WakeUp() can unblock and complete.  This does allow
+      // for 'cond_' to potentially change from true to false; that is
+      // OK, since WakeUp() is being called, so the deadline must be
+      // past, and so this method is fulfilling its duties.  (Well, the
+      // destructor might be calling WakeUp(), but if you're deleting
+      // time itself while waiting for a deadline to pass, you deserve
+      // what you get.)
+      mu_->Await(absl::Condition(&wakeup_time_passed_));
+    }
+  }
+
+ private:
+  bool Ready() const { return wakeup_time_passed_ || cond_.Eval(); }
+
+  absl::Mutex* mu_;
+  absl::Condition cond_;
+  bool wakeup_time_passed_;
+  absl::Mutex cancellation_mu_;
+  bool cancelled_ ABSL_GUARDED_BY(cancellation_mu_);
+  bool wakeup_called_ ABSL_GUARDED_BY(cancellation_mu_);
+};
+
+SimulatedClock::SimulatedClock(absl::Time t) : now_(t) {}
+
+SimulatedClock::~SimulatedClock() {
+  // Wake up all existing waiters.
+  WaiterList waiters;
+  {
+    absl::MutexLock l(lock_);
+    waiters.swap(waiters_);
+  }
+  for (auto& iter : waiters) {
+    iter.second->WakeUp();
+  }
+}
+
+absl::Time SimulatedClock::TimeNow() {
+  absl::ReaderMutexLock l(lock_);
+  return now_;
+}
+
+void SimulatedClock::Sleep(absl::Duration d) { SleepUntil(TimeNow() + d); }
+
+int64_t SimulatedClock::SetTime(absl::Time t) ABSL_NO_THREAD_SAFETY_ANALYSIS {
+  return UpdateTime([this, t]()
+                        ABSL_EXCLUSIVE_LOCKS_REQUIRED(lock_) { now_ = t; });
+}
+
+int64_t SimulatedClock::AdvanceTime(absl::Duration d)
+    ABSL_NO_THREAD_SAFETY_ANALYSIS {
+  return UpdateTime([this, d]()
+                        ABSL_EXCLUSIVE_LOCKS_REQUIRED(lock_) { now_ += d; });
+}
+
+template <class T>
+int64_t SimulatedClock::UpdateTime(const T& now_updater) {
+  // Deadlock could occur if UpdateTime() were to hold lock_ while waking up
+  // waiters, since waking up requires acquiring the external mutex, and
+  // AwaitWithDeadline() acquires the mutexes in the opposite order.  So let's
+  // first grab all the wakeup callbacks, then release lock_, then call the
+  // callbacks.
+  std::vector<WaiterList::mapped_type> wakeup_calls;
+
+  lock_.lock();
+  now_updater();  // reset now_
+  WaiterList::iterator iter;
+  while (((iter = waiters_.begin()) != waiters_.end()) &&
+         (iter->first <= now_)) {
+    wakeup_calls.push_back(std::move(iter->second));
+    waiters_.erase(iter);
+  }
+  lock_.unlock();
+
+  for (const auto& wakeup_call : wakeup_calls) {
+    wakeup_call->WakeUp();
+  }
+
+  return static_cast<int64_t>(wakeup_calls.size());
+}
+
+void SimulatedClock::SleepUntil(absl::Time wakeup_time) {
+  absl::Mutex mu;
+  absl::MutexLock lock(mu);
+  bool f = false;
+  AwaitWithDeadline(&mu, absl::Condition(&f), wakeup_time);
+}
+
+bool SimulatedClock::AwaitWithDeadline(absl::Mutex* mu,
+                                       const absl::Condition& cond,
+                                       absl::Time deadline) {
+  mu->AssertReaderHeld();
+
+  // Evaluate cond outside our own lock to minimize contention.
+  const bool ready = cond.Eval();
+
+  lock_.lock();
+  num_await_calls_++;
+
+  // Return now if the deadline is already past, or if the condition is true.
+  // This avoids creating a WakeUpInfo that won't be deleted until an
+  // appropriate UpdateTime() call.
+  if (deadline <= now_ || ready) {
+    lock_.unlock();
+    return ready;
+  }
+
+  auto wakeup_info = std::make_shared<WakeUpInfo>(mu, cond);
+  waiters_.insert(std::make_pair(deadline, wakeup_info));
+
+  lock_.unlock();
+  // SimulatedClock may be destroyed any time after this, so we can't
+  // acquire lock_ again.
+
+  // Wait until either cond.Eval() becomes true, or the deadline has passed.
+  wakeup_info->AwaitConditionOrWakeUp();
+
+  // Cancel the wakeup call, or if it's already in progress, wait for it to
+  // finish, since we must ensure no one touches 'mu' or 'cond' after we return.
+  wakeup_info->CancelOrAwaitWakeUp();
+
+  return cond.Eval();
+}
+
+std::optional<absl::Time> SimulatedClock::GetEarliestWakeupTime() const {
+  absl::ReaderMutexLock l(lock_);
+  if (waiters_.empty()) {
+    return std::nullopt;
+  }
+  return waiters_.begin()->first;
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl

package/vendor/abseil-cpp/absl/time/simulated_clock.h

@@ -0,0 +1,109 @@
+// Copyright 2026 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: simulated_clock.h
+// -----------------------------------------------------------------------------
+
+#ifndef ABSL_TIME_SIMULATED_CLOCK_H_
+#define ABSL_TIME_SIMULATED_CLOCK_H_
+
+#include <cstdint>
+#include <map>
+#include <memory>
+#include <optional>
+
+#include "absl/base/config.h"
+#include "absl/base/macros.h"
+#include "absl/base/nullability.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/synchronization/mutex.h"
+#include "absl/time/clock.h"
+#include "absl/time/clock_interface.h"
+#include "absl/time/time.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// A simulated clock is a concrete Clock implementation that does not "tick"
+// on its own.  Time is advanced by explicit calls to the AdvanceTime() or
+// SetTime() functions.
+//
+// Example:
+//   absl::SimulatedClock sim_clock;
+//   absl::Time now = sim_clock.TimeNow();
+//   // now == absl::UnixEpoch()
+//
+//   now = sim_clock.TimeNow();
+//   // now == absl::UnixEpoch() (still)
+//
+//   sim_clock.AdvanceTime(absl::Seconds(3));
+//   now = sim_clock.TimeNow();
+//   // now == absl::UnixEpoch() + absl::Seconds(3)
+//
+// This class is thread-safe.
+class SimulatedClock : public Clock {
+ public:
+  explicit SimulatedClock(absl::Time t);
+  SimulatedClock() : SimulatedClock(absl::UnixEpoch()) {}
+
+  // The destructor should be called only if all Sleep(), etc. and
+  // AdvanceTime() calls have completed. The code does its best to let
+  // any pending calls finish gracefully, but there are no guarantees.
+  ~SimulatedClock() override;
+
+  // Returns the simulated time.
+  absl::Time TimeNow() override;
+
+  // Sleeps until the specified duration has elapsed according to this clock.
+  void Sleep(absl::Duration d) override;
+
+  // Sleeps until the specified wakeup_time.
+  void SleepUntil(absl::Time wakeup_time) override;
+
+  // Sets the simulated time to the argument.  Wakes up any threads whose
+  // sleeps have now expired. Returns the number of woken threads.
+  int64_t SetTime(absl::Time t);
+
+  // Advances the simulated time by the specified duration.  Wakes up any
+  // threads whose sleeps have now expired. Returns the number of woken threads.
+  int64_t AdvanceTime(absl::Duration d);
+
+  // Blocks until the condition is true or until the simulated clock is
+  // advanced to or beyond the wakeup time (or both).
+  bool AwaitWithDeadline(absl::Mutex* absl_nonnull mu,
+                         const absl::Condition& cond,
+                         absl::Time deadline) override
+      ABSL_SHARED_LOCKS_REQUIRED(mu);
+
+  // Returns the earliest wakeup time.
+  std::optional<absl::Time> GetEarliestWakeupTime() const;
+
+ private:
+  template <class T>
+  int64_t UpdateTime(const T& now_updater) ABSL_LOCKS_EXCLUDED(lock_);
+
+  class WakeUpInfo;
+  using WaiterList = std::multimap<absl::Time, std::shared_ptr<WakeUpInfo>>;
+
+  mutable absl::Mutex lock_;
+  absl::Time now_ ABSL_GUARDED_BY(lock_);
+  WaiterList waiters_ ABSL_GUARDED_BY(lock_);
+  int64_t num_await_calls_ ABSL_GUARDED_BY(lock_) = 0;
+};
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_TIME_SIMULATED_CLOCK_H_