re2 1.24.0 → 1.25.0

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

@@ -0,0 +1,614 @@
+// 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 <cstddef>
+#include <cstdint>
+#include <memory>
+#include <thread>  // NOLINT(build/c++11)
+#include <vector>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/random/random.h"
+#include "absl/synchronization/blocking_counter.h"
+#include "absl/synchronization/mutex.h"
+#include "absl/synchronization/notification.h"
+#include "absl/time/clock.h"
+#include "absl/time/clock_interface.h"
+#include "absl/time/time.h"
+
+namespace {
+
+constexpr absl::Duration kShortPause = absl::Milliseconds(20);
+constexpr absl::Duration kLongPause = absl::Milliseconds(1000);
+
+#ifdef _MSC_VER
+// As of 2026-01-29, multithreaded tests on MSVC are too flaky.
+const char* kSkipFlakyReason =
+    "Skipping this timing test because it is too flaky";
+#else
+const char* kSkipFlakyReason = nullptr;
+#endif
+
+TEST(SimulatedClock, TimeInitializedToZero) {
+  absl::SimulatedClock simclock;
+  EXPECT_EQ(absl::UnixEpoch(), simclock.TimeNow());
+}
+
+TEST(SimulatedClock, NowSetTime) {
+  absl::SimulatedClock simclock;
+  absl::Time now = simclock.TimeNow();
+
+  now += absl::Seconds(123);
+  simclock.SetTime(now);
+  EXPECT_EQ(now, simclock.TimeNow());
+
+  now += absl::Seconds(123);
+  simclock.SetTime(now);
+  EXPECT_EQ(now, simclock.TimeNow());
+
+  now += absl::ZeroDuration();
+  simclock.SetTime(now);
+  EXPECT_EQ(now, simclock.TimeNow());
+}
+
+TEST(SimulatedClock, NowAdvanceTime) {
+  absl::SimulatedClock simclock;
+  absl::Time now = simclock.TimeNow();
+
+  simclock.AdvanceTime(absl::Seconds(123));
+  now += absl::Seconds(123);
+  EXPECT_EQ(now, simclock.TimeNow());
+
+  simclock.AdvanceTime(absl::Seconds(123));
+  now += absl::Seconds(123);
+  EXPECT_EQ(now, simclock.TimeNow());
+
+  simclock.AdvanceTime(absl::ZeroDuration());
+  now += absl::ZeroDuration();
+  EXPECT_EQ(now, simclock.TimeNow());
+}
+
+void SleepAndNotify(absl::Clock* clock, absl::Duration sleep_secs,
+                    absl::Notification* note) {
+  clock->Sleep(sleep_secs);
+  note->Notify();
+}
+
+TEST(SimulatedClock, Sleep_SetToSleepTime) {
+  if (kSkipFlakyReason != nullptr) {
+    GTEST_SKIP() << kSkipFlakyReason;
+  }
+
+  absl::SimulatedClock simclock;
+  absl::Notification note;
+
+  std::thread tr(SleepAndNotify, &simclock, absl::Seconds(123), &note);
+
+  // wait for SleepAndNotify() to block
+  absl::SleepFor(kLongPause);
+  simclock.SetTime(absl::FromUnixSeconds(122));
+  // give Sleep() the opportunity to fail
+  absl::SleepFor(kShortPause);
+  EXPECT_FALSE(note.HasBeenNotified());
+  simclock.SetTime(absl::FromUnixSeconds(122 + 1));
+  // wait for Sleep() to return
+  absl::SleepFor(kLongPause);
+  EXPECT_TRUE(note.HasBeenNotified());
+  note.WaitForNotification();  // in case the expectation fails
+  tr.join();
+}
+
+TEST(SimulatedClock, SleepAdvanceToSleepTime) {
+  if (kSkipFlakyReason != nullptr) {
+    GTEST_SKIP() << kSkipFlakyReason;
+  }
+
+  absl::SimulatedClock simclock;
+  absl::Notification note;
+
+  std::thread tr(SleepAndNotify, &simclock, absl::Seconds(123), &note);
+  // wait for SleepAndNotify() to block
+  absl::SleepFor(kLongPause);
+  simclock.AdvanceTime(absl::Seconds(122));
+  // give Sleep() the opportunity to fail
+  absl::SleepFor(kShortPause);
+  EXPECT_FALSE(note.HasBeenNotified());
+  simclock.AdvanceTime(absl::Seconds(1));
+  // wait for Sleep() to return
+  absl::SleepFor(kLongPause);
+  EXPECT_TRUE(note.HasBeenNotified());
+  note.WaitForNotification();  // in case the expectation fails
+  tr.join();
+}
+
+TEST(SimulatedClock, SleepSetPastSleepTime) {
+  if (kSkipFlakyReason != nullptr) {
+    GTEST_SKIP() << kSkipFlakyReason;
+  }
+
+  absl::SimulatedClock simclock;
+  absl::Notification note;
+
+  std::thread tr(SleepAndNotify, &simclock, absl::Seconds(123), &note);
+  // wait for SleepAndNotify() to block
+  absl::SleepFor(kLongPause);
+  simclock.SetTime(absl::FromUnixSeconds(122));
+  // give Sleep() the opportunity to fail
+  absl::SleepFor(kShortPause);
+  EXPECT_FALSE(note.HasBeenNotified());
+  simclock.SetTime(absl::FromUnixSeconds(122 + 2));
+  // wait for Sleep() to return
+  absl::SleepFor(kLongPause);
+  EXPECT_TRUE(note.HasBeenNotified());
+  note.WaitForNotification();  // in case the expectation fails
+  tr.join();
+}
+
+TEST(SimulatedClock, SleepAdvancePastSleepTime) {
+  if (kSkipFlakyReason != nullptr) {
+    GTEST_SKIP() << kSkipFlakyReason;
+  }
+
+  absl::SimulatedClock simclock;
+  absl::Notification note;
+
+  std::thread tr(SleepAndNotify, &simclock, absl::Seconds(123), &note);
+  // wait for SleepAndNotify() to block
+  absl::SleepFor(kLongPause);
+  simclock.AdvanceTime(absl::Seconds(122));
+  // give Sleep() the opportunity to fail
+  absl::SleepFor(kShortPause);
+  EXPECT_FALSE(note.HasBeenNotified());
+  simclock.AdvanceTime(absl::Seconds(2));
+  // wait for Sleep() to return
+  absl::SleepFor(kLongPause);
+  EXPECT_TRUE(note.HasBeenNotified());
+  note.WaitForNotification();  // in case the expectation fails
+  tr.join();
+}
+
+TEST(SimulatedClock, SleepZeroSleepTime) {
+  if (kSkipFlakyReason != nullptr) {
+    GTEST_SKIP() << kSkipFlakyReason;
+  }
+
+  absl::SimulatedClock simclock;
+  absl::Notification note;
+
+  std::thread tr(SleepAndNotify, &simclock, absl::ZeroDuration(), &note);
+  // wait for SleepAndNotify() to ping note
+  absl::SleepFor(kLongPause);
+  EXPECT_TRUE(note.HasBeenNotified());
+  note.WaitForNotification();  // in case the expectation fails
+  tr.join();
+}
+
+void SleepUntilAndNotify(absl::Clock* clock, absl::Time wakeup_time,
+                         absl::Notification* note) {
+  clock->SleepUntil(wakeup_time);
+  note->Notify();
+}
+
+TEST(SimulatedClock, SleepUntilSetToSleepTime) {
+  if (kSkipFlakyReason != nullptr) {
+    GTEST_SKIP() << kSkipFlakyReason;
+  }
+
+  absl::SimulatedClock simclock;
+  absl::Notification note;
+
+  simclock.SetTime(absl::FromUnixSeconds(123));
+  std::thread tr(SleepUntilAndNotify, &simclock,
+                 absl::UnixEpoch() + absl::Seconds(246), &note);
+  // wait for SleepUntilAndNotify() to block
+  absl::SleepFor(kLongPause);
+  simclock.SetTime(absl::FromUnixSeconds(123 + 122));
+  // give SleepUntil() the opportunity to fail
+  absl::SleepFor(kShortPause);
+  EXPECT_FALSE(note.HasBeenNotified());
+  simclock.SetTime(absl::FromUnixSeconds(123 + 122 + 1));
+  absl::Time start = absl::Now();
+  note.WaitForNotification();  // SleepUntilAndNotify() should ping note
+  EXPECT_GE(absl::Milliseconds(50), absl::Now() - start);
+  tr.join();
+}
+
+TEST(SimulatedClock, SleepUntilAdvanceToSleepTime) {
+  if (kSkipFlakyReason != nullptr) {
+    GTEST_SKIP() << kSkipFlakyReason;
+  }
+
+  absl::SimulatedClock simclock;
+  absl::Notification note;
+
+  simclock.AdvanceTime(absl::Seconds(123));
+  std::thread tr(SleepUntilAndNotify, &simclock,
+                 absl::UnixEpoch() + absl::Seconds(246), &note);
+  // wait for SleepUntilAndNotify() to block
+  absl::SleepFor(kLongPause);
+  simclock.AdvanceTime(absl::Seconds(122));
+  // give SleepUntil() the opportunity to fail
+  absl::SleepFor(kShortPause);
+  EXPECT_FALSE(note.HasBeenNotified());
+  simclock.AdvanceTime(absl::Seconds(1));
+  absl::Time start = absl::Now();
+  note.WaitForNotification();  // SleepUntilAndNotify() should ping note
+  EXPECT_GE(absl::Milliseconds(70), absl::Now() - start);
+  tr.join();
+}
+
+TEST(SimulatedClock, SleepUntilSetPastSleepTime) {
+  if (kSkipFlakyReason != nullptr) {
+    GTEST_SKIP() << kSkipFlakyReason;
+  }
+
+  absl::SimulatedClock simclock;
+  absl::Notification note;
+
+  simclock.SetTime(absl::FromUnixSeconds(123));
+  std::thread tr(SleepUntilAndNotify, &simclock,
+                 absl::UnixEpoch() + absl::Seconds(246), &note);
+  // wait for SleepUntilAndNotify() to block
+  absl::SleepFor(kLongPause);
+  simclock.SetTime(absl::FromUnixSeconds(123 + 122));
+  // give SleepUntil() the opportunity to fail
+  absl::SleepFor(kShortPause);
+  EXPECT_FALSE(note.HasBeenNotified());
+  simclock.SetTime(absl::FromUnixSeconds(123 + 122 + 2));
+  // wait for SleepUntilAndNotify() to ping note
+  absl::SleepFor(kLongPause);
+  EXPECT_TRUE(note.HasBeenNotified());
+  note.WaitForNotification();  // in case the expectation fails
+  tr.join();
+}
+
+TEST(SimulatedClock, SleepUntilAdvancePastSleepTime) {
+  if (kSkipFlakyReason != nullptr) {
+    GTEST_SKIP() << kSkipFlakyReason;
+  }
+
+  absl::SimulatedClock simclock;
+  absl::Notification note;
+
+  simclock.AdvanceTime(absl::Seconds(123));
+  std::thread tr(SleepUntilAndNotify, &simclock,
+                 absl::UnixEpoch() + absl::Seconds(246), &note);
+  // wait for SleepUntilAndNotify() to block
+  absl::SleepFor(kLongPause);
+  simclock.AdvanceTime(absl::Seconds(122));
+  // give SleepUntil() the opportunity to fail
+  absl::SleepFor(kShortPause);
+  EXPECT_FALSE(note.HasBeenNotified());
+  simclock.AdvanceTime(absl::Seconds(2));
+  // wait for SleepUntilAndNotify() to ping note
+  absl::SleepFor(kLongPause);
+  EXPECT_TRUE(note.HasBeenNotified());
+  note.WaitForNotification();  // in case the expectation fails
+  tr.join();
+}
+
+TEST(SimulatedClock, SleepUntilTimeAlreadyPassed) {
+  if (kSkipFlakyReason != nullptr) {
+    GTEST_SKIP() << kSkipFlakyReason;
+  }
+
+  absl::SimulatedClock simclock;
+  absl::Notification note;
+
+  simclock.AdvanceTime(absl::Seconds(123));
+  std::thread tr(SleepUntilAndNotify, &simclock,
+                 absl::UnixEpoch() + absl::Seconds(123), &note);
+  // wait for SleepUntilAndNotify() to ping note
+  absl::SleepFor(kLongPause);
+  EXPECT_TRUE(note.HasBeenNotified());
+  note.WaitForNotification();  // in case the expectation fails
+  tr.join();
+}
+
+void AwaitWithDeadlineAndNotify(absl::Clock* clock, absl::Mutex* mu,
+                                absl::Condition* cond, absl::Time wakeup_time,
+                                absl::Notification* note, bool* return_val) {
+  mu->lock_shared();
+  *return_val = clock->AwaitWithDeadline(mu, *cond, wakeup_time);
+  mu->unlock_shared();
+  note->Notify();
+}
+
+TEST(SimulatedClock, AwaitWithDeadlineConditionInitiallyTrue) {
+  absl::SimulatedClock simclock;
+  absl::Mutex mu;
+  bool f = true;
+  absl::Condition cond(&f);
+  absl::MutexLock lock(mu);
+  ASSERT_TRUE(simclock.AwaitWithDeadline(&mu, cond, absl::InfiniteFuture()));
+}
+
+TEST(SimulatedClock, AwaitWithDeadlineConditionInitiallyFalse) {
+  if (kSkipFlakyReason != nullptr) {
+    GTEST_SKIP() << kSkipFlakyReason;
+  }
+
+  absl::SimulatedClock simclock;
+  absl::Mutex mu;
+  bool f = false;
+  absl::Condition cond(&f);
+  absl::Notification note;
+  bool return_val;
+
+  std::thread tr(AwaitWithDeadlineAndNotify, &simclock, &mu, &cond,
+                 absl::UnixEpoch() + absl::Seconds(123), &note, &return_val);
+  // wait for AwaitWithDeadline...() to block
+  absl::SleepFor(kShortPause);
+  EXPECT_FALSE(note.HasBeenNotified());
+  mu.lock();
+  f = true;
+  mu.unlock();
+  // wait for AwaitWithDeadline...() to ping note
+  absl::SleepFor(kLongPause);
+  EXPECT_TRUE(note.HasBeenNotified());
+  EXPECT_TRUE(return_val);
+  note.WaitForNotification();  // in case the expectation fails
+  tr.join();
+}
+
+TEST(SimulatedClock, AwaitWithDeadlineDeadlinePassed) {
+  if (kSkipFlakyReason != nullptr) {
+    GTEST_SKIP() << kSkipFlakyReason;
+  }
+
+  absl::SimulatedClock simclock;
+  absl::Mutex mu;
+  bool f = false;
+  absl::Condition cond(&f);
+  absl::Notification note;
+  bool return_val;
+
+  std::thread tr(AwaitWithDeadlineAndNotify, &simclock, &mu, &cond,
+                 absl::UnixEpoch() + absl::Seconds(123), &note, &return_val);
+  // wait for AwaitWithDeadline...() to block
+  absl::SleepFor(kLongPause);
+  EXPECT_FALSE(note.HasBeenNotified());
+  simclock.AdvanceTime(absl::Seconds(124));
+  // wait for AwaitWithDeadline...() to ping note
+  absl::SleepFor(kLongPause);
+  EXPECT_TRUE(note.HasBeenNotified());
+  EXPECT_FALSE(return_val);
+  note.WaitForNotification();  // in case the expectation fails
+  tr.join();
+}
+
+TEST(SimulatedClock, AwaitWithDeadlineDeadlineAlreadyPassed) {
+  if (kSkipFlakyReason != nullptr) {
+    GTEST_SKIP() << kSkipFlakyReason;
+  }
+
+  absl::SimulatedClock simclock;
+  absl::Mutex mu;
+  bool f = false;
+  absl::Condition cond(&f);
+  absl::Notification note;
+  bool return_val;
+
+  std::thread tr(AwaitWithDeadlineAndNotify, &simclock, &mu, &cond,
+                 absl::UnixEpoch(), &note, &return_val);
+  // wait for AwaitWithDeadline...() to ping note
+  absl::SleepFor(kLongPause);
+  EXPECT_TRUE(note.HasBeenNotified());
+  EXPECT_FALSE(return_val);
+  note.WaitForNotification();  // in case the expectation fails
+  tr.join();
+}
+
+void RacerMakesConditionTrue(absl::Notification* start_note, absl::Mutex* mu,
+                             bool* f, absl::BlockingCounter* threads_done) {
+  start_note->WaitForNotification();
+  absl::SleepFor(absl::Milliseconds(1));
+  mu->lock();
+  *f = true;
+  mu->unlock();
+  threads_done->DecrementCount();
+}
+
+void RacerAdvancesTime(absl::Notification* start_note,
+                       absl::SimulatedClock* simclock, absl::Duration d,
+                       absl::BlockingCounter* threads_done) {
+  start_note->WaitForNotification();
+  absl::SleepFor(absl::Milliseconds(1));
+  simclock->AdvanceTime(d);
+  threads_done->DecrementCount();
+}
+
+TEST(SimulatedClock, SimultaneousConditionTrueAndDeadline) {
+  absl::SimulatedClock simclock;
+  for (int iteration = 0; iteration < 100; ++iteration) {
+    auto mu = std::make_unique<absl::Mutex>();
+    bool f = false;
+    absl::Condition cond(&f);
+    absl::Notification note_start;
+    absl::BlockingCounter threads_done(2);
+    std::thread tr1(RacerMakesConditionTrue, &note_start, mu.get(), &f,
+                    &threads_done);
+    std::thread tr2(RacerAdvancesTime, &note_start, &simclock,
+                    absl::Seconds(20), &threads_done);
+    note_start.Notify();
+    mu->lock();
+    absl::Time deadline = simclock.TimeNow() + absl::Seconds(10);
+    simclock.AwaitWithDeadline(mu.get(), cond, deadline);
+    EXPECT_TRUE(f || (simclock.TimeNow() >= deadline));
+    if (f) {
+      // RacerMakesConditionTrue has unlocked mu and AwaitWithDeadline has
+      // returned, so it is safe to destruct mu. Do so while RacerAdvancesTime
+      // is possibly still running in an attempt to catch simclock holding on
+      // to a reference to mu and using it after AwaitWithDeadline returns.
+      mu->unlock();
+      mu = nullptr;
+    } else {
+      mu->unlock();
+    }
+    threads_done.Wait();
+    tr1.join();
+    tr2.join();
+  }
+}
+
+void RacerDeletesClock(absl::Mutex* mu, absl::Notification* start_note,
+                       absl::Clock* clock,
+                       absl::BlockingCounter* threads_done) {
+  start_note->WaitForNotification();
+  // mu is acquired temporarily to make sure that AwaitWithDeadline() in
+  // SimultaneousConditionTrueAndDestruction has blocked.
+  mu->lock();
+  mu->unlock();
+  absl::SleepFor(absl::Milliseconds(1));
+  delete clock;
+  threads_done->DecrementCount();
+}
+
+TEST(SimulatedClock, SimultaneousConditionTrueAndDestruction) {
+  for (int iteration = 0; iteration < 100; ++iteration) {
+    absl::Clock* clock = new absl::SimulatedClock();
+    absl::Mutex mu;
+    bool f = false;
+    absl::Condition cond(&f);
+    absl::Notification note_start;
+    absl::BlockingCounter threads_done(2);
+    std::thread tr1([&note_start, &mu, &f, &threads_done] {
+      RacerMakesConditionTrue(&note_start, &mu, &f, &threads_done);
+    });
+    std::thread tr2([&mu, &note_start, clock, &threads_done] {
+      RacerDeletesClock(&mu, &note_start, clock, &threads_done);
+    });
+    mu.lock();
+    note_start.Notify();
+    absl::Time deadline = absl::UnixEpoch() + absl::Seconds(100000);
+    clock->AwaitWithDeadline(&mu, cond, deadline);
+    mu.unlock();
+    threads_done.Wait();
+    tr1.join();
+    tr2.join();
+  }
+}
+
+class SimulatedClockTorturer {
+ public:
+  SimulatedClockTorturer(absl::SimulatedClock* simclock, int num_threads,
+                         int num_iterations)
+      : simclock_(simclock),
+        num_threads_(num_threads),
+        num_iterations_(num_iterations),
+        num_flags_(2 * num_threads),
+        mutex_and_flag_(static_cast<size_t>(num_flags_)) {}
+
+  // Implements a torture test.
+  //
+  // This method uses several groups of:
+  //   SimulatedClock
+  //   Mutex protected flag
+  // It starts several threads that call AwaitWithDeadline() and several
+  // threads that call AdvanceTime() or toggle flag values.
+  void DoTorture() {
+    // The threads calling AwaitWithDeadline() have a separate BlockingCounter
+    // than the threads calling AdvanceTime()/toggling flags, since the former
+    // would be deadlocked if all the threads that might unblock them had
+    // already finished.
+    absl::Notification go;
+    absl::BlockingCounter await_threads_done(num_threads_);
+    absl::Notification signal_threads_should_exit;
+    absl::BlockingCounter signal_threads_done(num_threads_);
+    std::vector<std::thread> trs;
+    for (int i = 0; i < num_threads_; ++i) {
+      trs.emplace_back(&SimulatedClockTorturer::AwaitRandomly, this, &go,
+                       &await_threads_done);
+    }
+    for (int i = 0; i < num_threads_; ++i) {
+      trs.emplace_back(&SimulatedClockTorturer::SignalRandomly, this, &go,
+                       &signal_threads_should_exit, &signal_threads_done);
+    }
+    go.Notify();
+    await_threads_done.Wait();
+    signal_threads_should_exit.Notify();
+    signal_threads_done.Wait();
+    for (auto& thread : trs) {
+      thread.join();
+    }
+  }
+
+ private:
+  // Randomly call AwaitWithDeadline() for num_iterations_ times.
+  void AwaitRandomly(absl::Notification* go,
+                     absl::BlockingCounter* threads_done) {
+    go->WaitForNotification();
+
+    absl::BitGen gen;
+    for (int i = 0; i < num_iterations_; ++i) {
+      auto& [mu, f] = mutex_and_flag_[absl::Uniform<size_t>(gen, size_t{0},
+                                         static_cast<size_t>(num_flags_))];
+      absl::MutexLock lock(mu);
+      absl::Time deadline = simclock_->TimeNow() + absl::Seconds(1);
+      simclock_->AwaitWithDeadline(&mu, absl::Condition(&f), deadline);
+      ABSL_RAW_CHECK(f || simclock_->TimeNow() >= deadline, "");
+    }
+
+    threads_done->DecrementCount();
+  }
+
+  // Randomly call AdvanceTime() or toggle a flag value until notified to
+  // stop.
+  void SignalRandomly(absl::Notification* go, absl::Notification* should_exit,
+                      absl::BlockingCounter* threads_done) {
+    go->WaitForNotification();
+
+    absl::BitGen gen;
+    while (!should_exit->HasBeenNotified()) {
+      int action = absl::Uniform<int>(gen, 0, num_flags_ + 1);
+      if (action < num_flags_) {
+        // Change a flag value.
+        auto& [mutex, flag] = mutex_and_flag_[static_cast<size_t>(action)];
+        absl::MutexLock lock(mutex);
+        flag = !flag;
+      } else {
+        // Advance time.
+        simclock_->AdvanceTime(absl::Seconds(1));
+      }
+    }
+
+    threads_done->DecrementCount();
+  }
+
+  absl::SimulatedClock* simclock_;
+  int num_threads_;
+  int num_iterations_;
+  int num_flags_;
+
+  struct MutexAndFlag {
+    absl::Mutex mutex;
+    bool flag ABSL_GUARDED_BY(mutex) = false;
+  };
+  std::vector<MutexAndFlag> mutex_and_flag_;
+};
+
+TEST(SimulatedClock, Torture) {
+  absl::SimulatedClock simclock;
+  constexpr int kNumThreads = 10;
+  constexpr int kNumIterations = 1000;
+  SimulatedClockTorturer torturer(&simclock, kNumThreads, kNumIterations);
+  torturer.DoTorture();
+}
+
+}  // namespace