re2 1.22.2 → 1.23.0

package/vendor/abseil-cpp/absl/synchronization/notification.cc

@@ -26,7 +26,7 @@ ABSL_NAMESPACE_BEGIN
 
 void Notification::Notify() {
   base_internal::TraceSignal(this, TraceObjectKind());
-  MutexLock l(&this->mutex_);
+  MutexLock l(this->mutex_);
 
 #ifndef NDEBUG
   if (ABSL_PREDICT_FALSE(notified_yet_.load(std::memory_order_relaxed))) {
@@ -43,7 +43,7 @@ void Notification::Notify() {
 Notification::~Notification() {
   // Make sure that the thread running Notify() exits before the object is
   // destructed.
-  MutexLock l(&this->mutex_);
+  MutexLock l(this->mutex_);
 }
 
 void Notification::WaitForNotification() const {
@@ -51,7 +51,7 @@ void Notification::WaitForNotification() const {
   if (!HasBeenNotifiedInternal(&this->notified_yet_)) {
     this->mutex_.LockWhen(
         Condition(&HasBeenNotifiedInternal, &this->notified_yet_));
-    this->mutex_.Unlock();
+    this->mutex_.unlock();
   }
   base_internal::TraceContinue(this, TraceObjectKind());
 }
@@ -63,7 +63,7 @@ bool Notification::WaitForNotificationWithTimeout(
   if (!notified) {
     notified = this->mutex_.LockWhenWithTimeout(
         Condition(&HasBeenNotifiedInternal, &this->notified_yet_), timeout);
-    this->mutex_.Unlock();
+    this->mutex_.unlock();
   }
   base_internal::TraceContinue(notified ? this : nullptr, TraceObjectKind());
   return notified;
@@ -75,7 +75,7 @@ bool Notification::WaitForNotificationWithDeadline(absl::Time deadline) const {
   if (!notified) {
     notified = this->mutex_.LockWhenWithDeadline(
         Condition(&HasBeenNotifiedInternal, &this->notified_yet_), deadline);
-    this->mutex_.Unlock();
+    this->mutex_.unlock();
   }
   base_internal::TraceContinue(notified ? this : nullptr, TraceObjectKind());
   return notified;

package/vendor/abseil-cpp/absl/synchronization/notification.h

@@ -75,7 +75,7 @@ class Notification {
   // Notification::HasBeenNotified()
   //
   // Returns the value of the notification's internal "notified" state.
-  ABSL_MUST_USE_RESULT bool HasBeenNotified() const {
+  [[nodiscard]] bool HasBeenNotified() const {
     if (HasBeenNotifiedInternal(&this->notified_yet_)) {
       base_internal::TraceObserved(this, TraceObjectKind());
       return true;

package/vendor/abseil-cpp/absl/synchronization/notification_test.cc

@@ -34,17 +34,17 @@ class ThreadSafeCounter {
   ThreadSafeCounter() : count_(0) {}
 
   void Increment() {
-    MutexLock lock(&mutex_);
+    MutexLock lock(mutex_);
     ++count_;
   }
 
   int Get() const {
-    MutexLock lock(&mutex_);
+    MutexLock lock(mutex_);
     return count_;
   }
 
   void WaitUntilGreaterOrEqual(int n) {
-    MutexLock lock(&mutex_);
+    MutexLock lock(mutex_);
     auto cond = [this, n]() { return count_ >= n; };
     mutex_.Await(Condition(&cond));
   }

package/vendor/abseil-cpp/absl/time/BUILD.bazel

@@ -14,6 +14,9 @@
 # limitations under the License.
 #
 
+load("@rules_cc//cc:cc_binary.bzl", "cc_binary")
+load("@rules_cc//cc:cc_library.bzl", "cc_library")
+load("@rules_cc//cc:cc_test.bzl", "cc_test")
 load(
     "//absl:copts/configure_copts.bzl",
     "ABSL_DEFAULT_COPTS",
@@ -57,6 +60,7 @@ cc_library(
         "//absl/base:raw_logging_internal",
         "//absl/numeric:int128",
         "//absl/strings",
+        "//absl/strings:string_view",
         "//absl/time/internal/cctz:civil_time",
         "//absl/time/internal/cctz:time_zone",
         "//absl/types:optional",
@@ -96,7 +100,9 @@ cc_test(
         ":time",
         "//absl/base:config",
         "//absl/base:core_headers",
+        "//absl/hash:hash_testing",
         "//absl/numeric:int128",
+        "//absl/random",
         "//absl/strings:str_format",
         "//absl/time/internal/cctz:time_zone",
         "@googletest//:gtest",
@@ -115,6 +121,7 @@ cc_test(
         "no_test_android_arm",
         "no_test_android_arm64",
         "no_test_android_x86",
+        "no_test_ios_sim_arm64",
         "no_test_ios_x86_64",
         "no_test_lexan",
         "no_test_loonix",
@@ -129,8 +136,9 @@ cc_test(
     ],
 )
 
-cc_test(
+cc_binary(
     name = "time_benchmark",
+    testonly = True,
     srcs = [
         "civil_time_benchmark.cc",
         "clock_benchmark.cc",

package/vendor/abseil-cpp/absl/time/CMakeLists.txt

@@ -49,7 +49,7 @@ absl_cc_library(
     "internal/cctz/include/cctz/civil_time.h"
     "internal/cctz/include/cctz/civil_time_detail.h"
   SRCS
-  "internal/cctz/src/civil_time_detail.cc"
+    "internal/cctz/src/civil_time_detail.cc"
   COPTS
     ${ABSL_DEFAULT_COPTS}
 )
@@ -121,6 +121,8 @@ absl_cc_test(
     absl::time
     absl::config
     absl::core_headers
+    absl::hash_testing
+    absl::random_random
     absl::strings
     absl::str_format
     absl::time_zone

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

@@ -14,6 +14,7 @@
 
 #include "absl/time/civil_time.h"
 
+#include <cerrno>
 #include <cstdlib>
 #include <ostream>
 #include <string>

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

@@ -21,6 +21,7 @@
 
 #include "gtest/gtest.h"
 #include "absl/base/macros.h"
+#include "absl/hash/hash_testing.h"
 #include "absl/strings/str_format.h"
 
 namespace {
@@ -1259,4 +1260,137 @@ TEST(CivilTime, DocumentationExample) {
   }
 }
 
+TEST(CivilTime, SupportsHash) {
+  // To check that every field is used by the hash implementation, test
+  // with values that have all fields the same bar one, for each field.
+
+  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly({
+      absl::CivilYear(2017),
+      absl::CivilYear(2018),
+  }));
+
+  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly({
+      absl::CivilMonth(2017, 1),
+      absl::CivilMonth(2017, 2),
+      absl::CivilMonth(2018, 1),
+      absl::CivilMonth(2018, 2),
+  }));
+
+  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly({
+      absl::CivilDay(2017, 1, 1),
+      absl::CivilDay(2017, 1, 2),
+      absl::CivilDay(2017, 2, 1),
+      absl::CivilDay(2017, 2, 2),
+      absl::CivilDay(2018, 1, 1),
+      absl::CivilDay(2018, 1, 2),
+      absl::CivilDay(2018, 2, 1),
+      absl::CivilDay(2018, 2, 2),
+  }));
+
+  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly({
+      absl::CivilHour(2017, 1, 1, 0),
+      absl::CivilHour(2017, 1, 1, 1),
+      absl::CivilHour(2017, 1, 2, 0),
+      absl::CivilHour(2017, 1, 2, 1),
+      absl::CivilHour(2017, 2, 1, 0),
+      absl::CivilHour(2017, 2, 1, 1),
+      absl::CivilHour(2017, 2, 2, 0),
+      absl::CivilHour(2017, 2, 2, 1),
+      absl::CivilHour(2018, 1, 1, 0),
+      absl::CivilHour(2018, 1, 1, 1),
+      absl::CivilHour(2018, 1, 2, 0),
+      absl::CivilHour(2018, 1, 2, 1),
+      absl::CivilHour(2018, 2, 1, 0),
+      absl::CivilHour(2018, 2, 1, 1),
+      absl::CivilHour(2018, 2, 2, 0),
+      absl::CivilHour(2018, 2, 2, 1),
+  }));
+
+  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly({
+      absl::CivilMinute(2017, 1, 1, 0, 0), absl::CivilMinute(2017, 1, 1, 0, 1),
+      absl::CivilMinute(2017, 1, 1, 1, 0), absl::CivilMinute(2017, 1, 1, 1, 1),
+      absl::CivilMinute(2017, 1, 2, 0, 0), absl::CivilMinute(2017, 1, 2, 0, 1),
+      absl::CivilMinute(2017, 1, 2, 1, 0), absl::CivilMinute(2017, 1, 2, 1, 1),
+      absl::CivilMinute(2017, 2, 1, 0, 0), absl::CivilMinute(2017, 2, 1, 0, 1),
+      absl::CivilMinute(2017, 2, 1, 1, 0), absl::CivilMinute(2017, 2, 1, 1, 1),
+      absl::CivilMinute(2017, 2, 2, 0, 0), absl::CivilMinute(2017, 2, 2, 0, 1),
+      absl::CivilMinute(2017, 2, 2, 1, 0), absl::CivilMinute(2017, 2, 2, 1, 1),
+      absl::CivilMinute(2018, 1, 1, 0, 0), absl::CivilMinute(2018, 1, 1, 0, 1),
+      absl::CivilMinute(2018, 1, 1, 1, 0), absl::CivilMinute(2018, 1, 1, 1, 1),
+      absl::CivilMinute(2018, 1, 2, 0, 0), absl::CivilMinute(2018, 1, 2, 0, 1),
+      absl::CivilMinute(2018, 1, 2, 1, 0), absl::CivilMinute(2018, 1, 2, 1, 1),
+      absl::CivilMinute(2018, 2, 1, 0, 0), absl::CivilMinute(2018, 2, 1, 0, 1),
+      absl::CivilMinute(2018, 2, 1, 1, 0), absl::CivilMinute(2018, 2, 1, 1, 1),
+      absl::CivilMinute(2018, 2, 2, 0, 0), absl::CivilMinute(2018, 2, 2, 0, 1),
+      absl::CivilMinute(2018, 2, 2, 1, 0), absl::CivilMinute(2018, 2, 2, 1, 1),
+  }));
+
+  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly({
+      absl::CivilSecond(2017, 1, 1, 0, 0, 0),
+      absl::CivilSecond(2017, 1, 1, 0, 0, 1),
+      absl::CivilSecond(2017, 1, 1, 0, 1, 0),
+      absl::CivilSecond(2017, 1, 1, 0, 1, 1),
+      absl::CivilSecond(2017, 1, 1, 1, 0, 0),
+      absl::CivilSecond(2017, 1, 1, 1, 0, 1),
+      absl::CivilSecond(2017, 1, 1, 1, 1, 0),
+      absl::CivilSecond(2017, 1, 1, 1, 1, 1),
+      absl::CivilSecond(2017, 1, 2, 0, 0, 0),
+      absl::CivilSecond(2017, 1, 2, 0, 0, 1),
+      absl::CivilSecond(2017, 1, 2, 0, 1, 0),
+      absl::CivilSecond(2017, 1, 2, 0, 1, 1),
+      absl::CivilSecond(2017, 1, 2, 1, 0, 0),
+      absl::CivilSecond(2017, 1, 2, 1, 0, 1),
+      absl::CivilSecond(2017, 1, 2, 1, 1, 0),
+      absl::CivilSecond(2017, 1, 2, 1, 1, 1),
+      absl::CivilSecond(2017, 2, 1, 0, 0, 0),
+      absl::CivilSecond(2017, 2, 1, 0, 0, 1),
+      absl::CivilSecond(2017, 2, 1, 0, 1, 0),
+      absl::CivilSecond(2017, 2, 1, 0, 1, 1),
+      absl::CivilSecond(2017, 2, 1, 1, 0, 0),
+      absl::CivilSecond(2017, 2, 1, 1, 0, 1),
+      absl::CivilSecond(2017, 2, 1, 1, 1, 0),
+      absl::CivilSecond(2017, 2, 1, 1, 1, 1),
+      absl::CivilSecond(2017, 2, 2, 0, 0, 0),
+      absl::CivilSecond(2017, 2, 2, 0, 0, 1),
+      absl::CivilSecond(2017, 2, 2, 0, 1, 0),
+      absl::CivilSecond(2017, 2, 2, 0, 1, 1),
+      absl::CivilSecond(2017, 2, 2, 1, 0, 0),
+      absl::CivilSecond(2017, 2, 2, 1, 0, 1),
+      absl::CivilSecond(2017, 2, 2, 1, 1, 0),
+      absl::CivilSecond(2017, 2, 2, 1, 1, 1),
+      absl::CivilSecond(2018, 1, 1, 0, 0, 0),
+      absl::CivilSecond(2018, 1, 1, 0, 0, 1),
+      absl::CivilSecond(2018, 1, 1, 0, 1, 0),
+      absl::CivilSecond(2018, 1, 1, 0, 1, 1),
+      absl::CivilSecond(2018, 1, 1, 1, 0, 0),
+      absl::CivilSecond(2018, 1, 1, 1, 0, 1),
+      absl::CivilSecond(2018, 1, 1, 1, 1, 0),
+      absl::CivilSecond(2018, 1, 1, 1, 1, 1),
+      absl::CivilSecond(2018, 1, 2, 0, 0, 0),
+      absl::CivilSecond(2018, 1, 2, 0, 0, 1),
+      absl::CivilSecond(2018, 1, 2, 0, 1, 0),
+      absl::CivilSecond(2018, 1, 2, 0, 1, 1),
+      absl::CivilSecond(2018, 1, 2, 1, 0, 0),
+      absl::CivilSecond(2018, 1, 2, 1, 0, 1),
+      absl::CivilSecond(2018, 1, 2, 1, 1, 0),
+      absl::CivilSecond(2018, 1, 2, 1, 1, 1),
+      absl::CivilSecond(2018, 2, 1, 0, 0, 0),
+      absl::CivilSecond(2018, 2, 1, 0, 0, 1),
+      absl::CivilSecond(2018, 2, 1, 0, 1, 0),
+      absl::CivilSecond(2018, 2, 1, 0, 1, 1),
+      absl::CivilSecond(2018, 2, 1, 1, 0, 0),
+      absl::CivilSecond(2018, 2, 1, 1, 0, 1),
+      absl::CivilSecond(2018, 2, 1, 1, 1, 0),
+      absl::CivilSecond(2018, 2, 1, 1, 1, 1),
+      absl::CivilSecond(2018, 2, 2, 0, 0, 0),
+      absl::CivilSecond(2018, 2, 2, 0, 0, 1),
+      absl::CivilSecond(2018, 2, 2, 0, 1, 0),
+      absl::CivilSecond(2018, 2, 2, 0, 1, 1),
+      absl::CivilSecond(2018, 2, 2, 1, 0, 0),
+      absl::CivilSecond(2018, 2, 2, 1, 0, 1),
+      absl::CivilSecond(2018, 2, 2, 1, 1, 0),
+      absl::CivilSecond(2018, 2, 2, 1, 1, 1),
+  }));
+}
+
 }  // namespace

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

@@ -135,7 +135,7 @@ static inline uint64_t SeqAcquire(std::atomic<uint64_t> *seq) {
   // fetch_add would be before it, not after.
   std::atomic_thread_fence(std::memory_order_release);
 
-  return x + 2;   // original word plus 2
+  return x + 2;  // original word plus 2
 }
 
 // Release seqlock (*seq) by writing x to it---a value previously returned by
@@ -160,8 +160,8 @@ static const uint64_t kMinNSBetweenSamples = 2000 << 20;
 // We require that kMinNSBetweenSamples shifted by kScale
 // have at least a bit left over for 64-bit calculations.
 static_assert(((kMinNSBetweenSamples << (kScale + 1)) >> (kScale + 1)) ==
-               kMinNSBetweenSamples,
-               "cannot represent kMaxBetweenSamplesNSScaled");
+                  kMinNSBetweenSamples,
+              "cannot represent kMaxBetweenSamplesNSScaled");
 
 // data from a sample of the kernel's time value
 struct TimeSampleAtomic {
@@ -206,8 +206,7 @@ struct ABSL_CACHELINE_ALIGNED TimeState {
 
   // A reader-writer lock protecting the static locations below.
   // See SeqAcquire() and SeqRelease() above.
-  absl::base_internal::SpinLock lock{absl::kConstInit,
-                                     base_internal::SCHEDULE_KERNEL_ONLY};
+  absl::base_internal::SpinLock lock{base_internal::SCHEDULE_KERNEL_ONLY};
 };
 ABSL_CONST_INIT static TimeState time_state;
 
@@ -416,7 +415,7 @@ static int64_t GetCurrentTimeNanosSlowPath()
     ABSL_LOCKS_EXCLUDED(time_state.lock) {
   // Serialize access to slow-path.  Fast-path readers are not blocked yet, and
   // code below must not modify last_sample until the seqlock is acquired.
-  time_state.lock.Lock();
+  base_internal::SpinLockHolder l(time_state.lock);
 
   // Sample the kernel time base.  This is the definition of
   // "now" if we take the slow path.
@@ -439,16 +438,14 @@ static int64_t GetCurrentTimeNanosSlowPath()
   if (delta_cycles < sample.min_cycles_per_sample) {
     // Another thread updated the sample.  This path does not take the seqlock
     // so that blocked readers can make progress without blocking new readers.
-    estimated_base_ns = sample.base_ns +
-        ((delta_cycles * sample.nsscaled_per_cycle) >> kScale);
+    estimated_base_ns =
+        sample.base_ns + ((delta_cycles * sample.nsscaled_per_cycle) >> kScale);
     time_state.stats_fast_slow_paths++;
   } else {
     estimated_base_ns =
         UpdateLastSample(now_cycles, now_ns, delta_cycles, &sample);
   }
 
-  time_state.lock.Unlock();
-
   return static_cast<int64_t>(estimated_base_ns);
 }
 
@@ -494,8 +491,8 @@ static uint64_t UpdateLastSample(uint64_t now_cycles, uint64_t now_ns,
         estimated_scaled_ns = (delta_cycles >> s) * sample->nsscaled_per_cycle;
       } while (estimated_scaled_ns / sample->nsscaled_per_cycle !=
                (delta_cycles >> s));
-      estimated_base_ns = sample->base_ns +
-                          (estimated_scaled_ns >> (kScale - s));
+      estimated_base_ns =
+          sample->base_ns + (estimated_scaled_ns >> (kScale - s));
     }
 
     // Compute the assumed cycle time kMinNSBetweenSamples ns into the future
@@ -522,8 +519,8 @@ static uint64_t UpdateLastSample(uint64_t now_cycles, uint64_t now_ns,
                                diff_ns - (diff_ns / 16));
     uint64_t new_nsscaled_per_cycle =
         SafeDivideAndScale(ns, assumed_next_sample_delta_cycles);
-    if (new_nsscaled_per_cycle != 0 &&
-        diff_ns < 100 * 1000 * 1000 && -diff_ns < 100 * 1000 * 1000) {
+    if (new_nsscaled_per_cycle != 0 && diff_ns < 100 * 1000 * 1000 &&
+        -diff_ns < 100 * 1000 * 1000) {
       // record the cycle time measurement
       time_state.last_sample.nsscaled_per_cycle.store(
           new_nsscaled_per_cycle, std::memory_order_relaxed);

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

@@ -202,7 +202,8 @@ inline bool SafeAddRepHi(double a_hi, double b_hi, Duration* d) {
     *d = -InfiniteDuration();
     return false;
   }
-  *d = time_internal::MakeDuration(c, time_internal::GetRepLo(*d));
+  *d = time_internal::MakeDuration(static_cast<int64_t>(c),
+                                   time_internal::GetRepLo(*d));
   return true;
 }
 
@@ -239,8 +240,8 @@ inline Duration ScaleFixed(Duration d, int64_t r) {
 template <template <typename> class Operation>
 inline Duration ScaleDouble(Duration d, double r) {
   Operation<double> op;
-  double hi_doub = op(time_internal::GetRepHi(d), r);
-  double lo_doub = op(time_internal::GetRepLo(d), r);
+  double hi_doub = op(static_cast<double>(time_internal::GetRepHi(d)), r);
+  double lo_doub = op(static_cast<double>(time_internal::GetRepLo(d)), r);
 
   double hi_int = 0;
   double hi_frac = std::modf(hi_doub, &hi_int);
@@ -253,12 +254,15 @@ inline Duration ScaleDouble(Duration d, double r) {
   double lo_frac = std::modf(lo_doub, &lo_int);
 
   // Rolls lo into hi if necessary.
-  int64_t lo64 = std::round(lo_frac * kTicksPerSecond);
+  int64_t lo64 = static_cast<int64_t>(std::round(lo_frac * kTicksPerSecond));
 
   Duration ans;
   if (!SafeAddRepHi(hi_int, lo_int, &ans)) return ans;
   int64_t hi64 = time_internal::GetRepHi(ans);
-  if (!SafeAddRepHi(hi64, lo64 / kTicksPerSecond, &ans)) return ans;
+  if (!SafeAddRepHi(static_cast<double>(hi64),
+                    static_cast<double>(lo64 / kTicksPerSecond), &ans)) {
+    return ans;
+  }
   hi64 = time_internal::GetRepHi(ans);
   lo64 %= kTicksPerSecond;
   NormalizeTicks(&hi64, &lo64);
@@ -465,7 +469,7 @@ Duration& Duration::operator*=(int64_t r) {
 
 Duration& Duration::operator*=(double r) {
   if (time_internal::IsInfiniteDuration(*this) || !IsFinite(r)) {
-    const bool is_neg = std::signbit(r) != (rep_hi_.Get() < 0);
+    const bool is_neg = std::isnan(r) || std::signbit(r) != (rep_hi_.Get() < 0);
     return *this = is_neg ? -InfiniteDuration() : InfiniteDuration();
   }
   return *this = ScaleDouble<std::multiplies>(*this, r);
@@ -481,7 +485,7 @@ Duration& Duration::operator/=(int64_t r) {
 
 Duration& Duration::operator/=(double r) {
   if (time_internal::IsInfiniteDuration(*this) || !IsValidDivisor(r)) {
-    const bool is_neg = std::signbit(r) != (rep_hi_.Get() < 0);
+    const bool is_neg = std::isnan(r) || std::signbit(r) != (rep_hi_.Get() < 0);
     return *this = is_neg ? -InfiniteDuration() : InfiniteDuration();
   }
   return *this = ScaleDouble<std::divides>(*this, r);
@@ -699,8 +703,9 @@ void AppendNumberUnit(std::string* out, double n, DisplayUnit unit) {
   char buf[kBufferSize];  // also large enough to hold integer part
   char* ep = buf + sizeof(buf);
   double d = 0;
-  int64_t frac_part = std::round(std::modf(n, &d) * unit.pow10);
-  int64_t int_part = d;
+  int64_t frac_part =
+      static_cast<int64_t>(std::round(std::modf(n, &d) * unit.pow10));
+  int64_t int_part = static_cast<int64_t>(d);
   if (int_part != 0 || frac_part != 0) {
     char* bp = Format64(ep, 0, int_part);  // always < 1000
     out->append(bp, static_cast<size_t>(ep - bp));

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

@@ -40,6 +40,7 @@
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
+#include "absl/random/random.h"
 #include "absl/strings/str_format.h"
 #include "absl/time/time.h"
 
@@ -840,18 +841,18 @@ TEST(Duration, DivisionByZero) {
 
 TEST(Duration, NaN) {
   // Note that IEEE 754 does not define the behavior of a nan's sign when it is
-  // copied, so the code below allows for either + or - InfiniteDuration.
+  // copied. We return -InfiniteDuration in either case.
 #define TEST_NAN_HANDLING(NAME, NAN)           \
   do {                                         \
     const auto inf = absl::InfiniteDuration(); \
     auto x = NAME(NAN);                        \
-    EXPECT_TRUE(x == inf || x == -inf);        \
+    EXPECT_TRUE(x == -inf);                    \
     auto y = NAME(42);                         \
     y *= NAN;                                  \
-    EXPECT_TRUE(y == inf || y == -inf);        \
+    EXPECT_TRUE(y == -inf);                    \
     auto z = NAME(42);                         \
     z /= NAN;                                  \
-    EXPECT_TRUE(z == inf || z == -inf);        \
+    EXPECT_TRUE(z == -inf);                    \
   } while (0)
 
   const double nan = std::numeric_limits<double>::quiet_NaN();
@@ -1514,9 +1515,7 @@ TEST(Duration, ToDoubleSecondsCheckEdgeCases) {
 }
 
 TEST(Duration, ToDoubleSecondsCheckRandom) {
-  std::random_device rd;
-  std::seed_seq seed({rd(), rd(), rd(), rd(), rd(), rd(), rd(), rd()});
-  std::mt19937_64 gen(seed);
+  absl::InsecureBitGen gen;
   // We want doubles distributed from 1/8ns up to 2^63, where
   // as many values are tested from 1ns to 2ns as from 1sec to 2sec,
   // so even distribute along a log-scale of those values, and

package/vendor/abseil-cpp/absl/time/internal/cctz/BUILD.bazel

@@ -12,6 +12,9 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
+load("@rules_cc//cc:cc_binary.bzl", "cc_binary")
+load("@rules_cc//cc:cc_library.bzl", "cc_library")
+load("@rules_cc//cc:cc_test.bzl", "cc_test")
 load("//absl:copts/configure_copts.bzl", "ABSL_DEFAULT_COPTS", "ABSL_DEFAULT_LINKOPTS", "ABSL_TEST_COPTS")
 
 package(features = [
@@ -80,9 +83,15 @@ cc_library(
 
 ### tests
 
-test_suite(
-    name = "all_tests",
-    visibility = ["//visibility:public"],
+cc_library(
+    name = "test_time_zone_names",
+    testonly = True,
+    srcs = ["src/test_time_zone_names.cc"],
+    hdrs = ["src/test_time_zone_names.h"],
+    copts = ABSL_DEFAULT_COPTS,
+    linkopts = ABSL_DEFAULT_LINKOPTS,
+    visibility = ["//visibility:private"],
+    deps = ["//absl/base:config"],
 )
 
 cc_test(
@@ -137,6 +146,7 @@ cc_test(
     ],
     deps = [
         ":civil_time",
+        ":test_time_zone_names",
         ":time_zone",
         "//absl/base:config",
         "@googletest//:gtest",
@@ -161,6 +171,7 @@ cc_test(
     tags = ["benchmark"],
     deps = [
         ":civil_time",
+        ":test_time_zone_names",
         ":time_zone",
         "//absl/base:config",
         "@google_benchmark//:benchmark_main",

package/vendor/abseil-cpp/absl/time/internal/cctz/include/cctz/civil_time_detail.h

@@ -96,6 +96,18 @@ CONSTEXPR_F int days_per_4years(int yi) noexcept {
 CONSTEXPR_F int days_per_year(year_t y, month_t m) noexcept {
   return is_leap_year(y + (m > 2)) ? 366 : 365;
 }
+// The compiler cannot optimize away the check if we use
+// -fsanitize=array-bounds.
+// m is guaranteed to be in [1:12] in the caller, but the compiler cannot
+// optimize away the check even when this function is inlined into BreakTime.
+// To reduce the overhead, we use no_sanitize to skip the unnecessary
+// -fsanitize=array-bounds check. Remove no_sanitize once the missed
+// optimization is fixed.
+#if defined(__clang__) && defined(__has_cpp_attribute)
+#if __has_cpp_attribute(clang::no_sanitize)
+[[clang::no_sanitize("array-bounds")]]
+#endif
+#endif
 CONSTEXPR_F int days_per_month(year_t y, month_t m) noexcept {
   CONSTEXPR_D int k_days_per_month[1 + 12] = {
       -1, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31  // non leap year

package/vendor/abseil-cpp/absl/time/internal/cctz/include/cctz/time_zone.h

@@ -200,7 +200,7 @@ class time_zone {
   // version() and description() provide additional information about the
   // time zone. The content of each of the returned strings is unspecified,
   // however, when the IANA Time Zone Database is the underlying data source
-  // the version() string will be in the familar form (e.g, "2018e") or
+  // the version() string will be in the familiar form (e.g, "2018e") or
   // empty when unavailable.
   //
   // Note: These functions are for informational or testing purposes only.