re2 1.23.0 → 1.23.2

package/vendor/abseil-cpp/absl/numeric/int128_have_intrinsic.inc

@@ -73,17 +73,11 @@ constexpr int128::int128(unsigned long long v) : v_{v} {}
 
 constexpr int128::int128(unsigned __int128 v) : v_{static_cast<__int128>(v)} {}
 
-inline int128::int128(float v) {
-  v_ = static_cast<__int128>(v);
-}
+constexpr int128::int128(float v) : v_{static_cast<__int128>(v)} {}
 
-inline int128::int128(double v) {
-  v_ = static_cast<__int128>(v);
-}
+constexpr int128::int128(double v) : v_{static_cast<__int128>(v)} {}
 
-inline int128::int128(long double v) {
-  v_ = static_cast<__int128>(v);
-}
+constexpr int128::int128(long double v) : v_{static_cast<__int128>(v)} {}
 
 constexpr int128::int128(uint128 v) : v_{static_cast<__int128>(v)} {}
 
@@ -119,9 +113,7 @@ constexpr int128::operator unsigned short() const {  // NOLINT(runtime/int)
   return static_cast<unsigned short>(v_);            // NOLINT(runtime/int)
 }
 
-constexpr int128::operator int() const {
-  return static_cast<int>(v_);
-}
+constexpr int128::operator int() const { return static_cast<int>(v_); }
 
 constexpr int128::operator unsigned int() const {
   return static_cast<unsigned int>(v_);
@@ -153,17 +145,17 @@ constexpr int128::operator unsigned __int128() const {
 // conversions. In that case, we do the conversion with a similar implementation
 // to the conversion operators in int128_no_intrinsic.inc.
 #if defined(__clang__) && !defined(__ppc64__)
-inline int128::operator float() const { return static_cast<float>(v_); }
+constexpr int128::operator float() const { return static_cast<float>(v_); }
 
-inline int128::operator double() const { return static_cast<double>(v_); }
+constexpr int128::operator double() const { return static_cast<double>(v_); }
 
-inline int128::operator long double() const {
+constexpr int128::operator long double() const {
   return static_cast<long double>(v_);
 }
 
-#else  // Clang on PowerPC
+#else   // Clang on PowerPC
 
-inline int128::operator float() const {
+constexpr int128::operator float() const {
   // We must convert the absolute value and then negate as needed, because
   // floating point types are typically sign-magnitude. Otherwise, the
   // difference between the high and low 64 bits when interpreted as two's
@@ -177,7 +169,7 @@ inline int128::operator float() const {
                    static_cast<float>(Int128High64(*this)) * pow_2_64;
 }
 
-inline int128::operator double() const {
+constexpr int128::operator double() const {
   // See comment in int128::operator float() above.
   constexpr double pow_2_64 = 18446744073709551616.0;
   return v_ < 0 && *this != Int128Min()
@@ -186,7 +178,7 @@ inline int128::operator double() const {
                    static_cast<double>(Int128High64(*this)) * pow_2_64;
 }
 
-inline int128::operator long double() const {
+constexpr int128::operator long double() const {
   // See comment in int128::operator float() above.
   constexpr long double pow_2_64 = 18446744073709551616.0L;
   return v_ < 0 && *this != Int128Min()
@@ -254,17 +246,19 @@ constexpr int128 operator-(int128 lhs, int128 rhs) {
   return static_cast<__int128>(lhs) - static_cast<__int128>(rhs);
 }
 
-inline int128 operator*(int128 lhs, int128 rhs) {
+#if defined(ABSL_HAVE_INTRINSIC_INT128)
+constexpr int128 operator*(int128 lhs, int128 rhs) {
   return static_cast<__int128>(lhs) * static_cast<__int128>(rhs);
 }
 
-inline int128 operator/(int128 lhs, int128 rhs) {
+constexpr int128 operator/(int128 lhs, int128 rhs) {
   return static_cast<__int128>(lhs) / static_cast<__int128>(rhs);
 }
 
-inline int128 operator%(int128 lhs, int128 rhs) {
+constexpr int128 operator%(int128 lhs, int128 rhs) {
   return static_cast<__int128>(lhs) % static_cast<__int128>(rhs);
 }
+#endif  // ABSL_HAVE_INTRINSIC_INT128
 
 inline int128 int128::operator++(int) {
   int128 tmp(*this);

package/vendor/abseil-cpp/absl/numeric/int128_no_intrinsic.inc

@@ -132,7 +132,7 @@ constexpr int128::operator unsigned long long() const {  // NOLINT(runtime/int)
   return static_cast<unsigned long long>(lo_);           // NOLINT(runtime/int)
 }
 
-inline int128::operator float() const {
+constexpr int128::operator float() const {
   // We must convert the absolute value and then negate as needed, because
   // floating point types are typically sign-magnitude. Otherwise, the
   // difference between the high and low 64 bits when interpreted as two's
@@ -142,20 +142,18 @@ inline int128::operator float() const {
   constexpr float pow_2_64 = 18446744073709551616.0f;
   return hi_ < 0 && *this != Int128Min()
              ? -static_cast<float>(-*this)
-             : static_cast<float>(lo_) +
-                   static_cast<float>(hi_) * pow_2_64;
+             : static_cast<float>(lo_) + static_cast<float>(hi_) * pow_2_64;
 }
 
-inline int128::operator double() const {
+constexpr int128::operator double() const {
   // See comment in int128::operator float() above.
   constexpr double pow_2_64 = 18446744073709551616.0;
   return hi_ < 0 && *this != Int128Min()
              ? -static_cast<double>(-*this)
-             : static_cast<double>(lo_) +
-                   static_cast<double>(hi_) * pow_2_64;
+             : static_cast<double>(lo_) + static_cast<double>(hi_) * pow_2_64;
 }
 
-inline int128::operator long double() const {
+constexpr int128::operator long double() const {
   // See comment in int128::operator float() above.
   constexpr long double pow_2_64 = 18446744073709551616.0L;
   return hi_ < 0 && *this != Int128Min()

package/vendor/abseil-cpp/absl/numeric/int128_test.cc

@@ -350,7 +350,7 @@ TEST(Uint128, Multiply) {
   c = a * b;
   EXPECT_EQ(absl::MakeUint128(0x530EDA741C71D4C3, 0xBF25975319080000), c);
   EXPECT_EQ(0, c - b * a);
-  EXPECT_EQ(a*a - b*b, (a+b) * (a-b));
+  EXPECT_EQ(a * a - b * b, (a + b) * (a - b));
 
   // Verified with dc.
   a = absl::MakeUint128(0x0123456789abcdef, 0xfedcba9876543210);
@@ -358,7 +358,7 @@ TEST(Uint128, Multiply) {
   c = a * b;
   EXPECT_EQ(absl::MakeUint128(0x97a87f4f261ba3f2, 0x342d0bbf48948200), c);
   EXPECT_EQ(0, c - b * a);
-  EXPECT_EQ(a*a - b*b, (a+b) * (a-b));
+  EXPECT_EQ(a * a - b * b, (a + b) * (a - b));
 }
 
 TEST(Uint128, AliasTests) {
@@ -462,6 +462,26 @@ TEST(Uint128, ConstexprTest) {
   EXPECT_EQ(zero, absl::uint128(0));
   EXPECT_EQ(one, absl::uint128(1));
   EXPECT_EQ(minus_two, absl::MakeUint128(-1, -2));
+
+  constexpr double f = static_cast<float>(absl::uint128(123));
+  EXPECT_EQ(f, 123.0f);
+
+  constexpr double d = static_cast<double>(absl::uint128(123));
+  EXPECT_EQ(d, 123.0);
+
+  constexpr long double ld = static_cast<long double>(absl::uint128(123));
+  EXPECT_EQ(ld, 123.0);
+
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+  constexpr absl::uint128 division = absl::uint128(10) / absl::uint128(2);
+  EXPECT_EQ(division, absl::uint128(5));
+
+  constexpr absl::uint128 modulus = absl::int128(10) % absl::int128(3);
+  EXPECT_EQ(modulus, absl::uint128(1));
+
+  constexpr absl::uint128 multiplication = absl::uint128(10) * absl::uint128(3);
+  EXPECT_EQ(multiplication, absl::uint128(30));
+#endif  // ABSL_HAVE_INTRINSIC_INT128
 }
 
 TEST(Uint128, NumericLimitsTest) {
@@ -522,7 +542,6 @@ TEST(Uint128, Hash) {
   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(values));
 }
 
-
 TEST(Int128Uint128, ConversionTest) {
   absl::int128 nonnegative_signed_values[] = {
       0,
@@ -540,8 +559,7 @@ TEST(Int128Uint128, ConversionTest) {
   }
 
   absl::int128 negative_values[] = {
-      -1, -0x1234567890abcdef,
-      absl::MakeInt128(-0x5544332211ffeedd, 0),
+      -1, -0x1234567890abcdef, absl::MakeInt128(-0x5544332211ffeedd, 0),
       -absl::MakeInt128(0x76543210fedcba98, 0xabcdef0123456789)};
   for (absl::int128 value : negative_values) {
     EXPECT_EQ(absl::uint128(-value), -absl::uint128(value));
@@ -769,6 +787,35 @@ TEST(Int128, ConstexprTest) {
   EXPECT_EQ(minus_two, absl::MakeInt128(-1, -2));
   EXPECT_GT(max, one);
   EXPECT_LT(min, minus_two);
+
+  constexpr double f = static_cast<float>(absl::int128(123));
+  EXPECT_EQ(f, 123.0f);
+
+  constexpr double d = static_cast<double>(absl::int128(123));
+  EXPECT_EQ(d, 123.0);
+
+  constexpr long double ld = static_cast<long double>(absl::int128(123));
+  EXPECT_EQ(ld, 123.0);
+
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+  constexpr absl::int128 f_int128(static_cast<float>(123.0));
+  EXPECT_EQ(f_int128, absl::int128(123));
+
+  constexpr absl::int128 d_int128(static_cast<double>(123.0));
+  EXPECT_EQ(d_int128, absl::int128(123));
+
+  constexpr absl::int128 ld_int128(static_cast<long double>(123.0));
+  EXPECT_EQ(ld_int128, absl::int128(123));
+
+  constexpr absl::int128 division = absl::int128(10) / absl::int128(2);
+  EXPECT_EQ(division, absl::int128(5));
+
+  constexpr absl::int128 modulus = absl::int128(10) % absl::int128(3);
+  EXPECT_EQ(modulus, absl::int128(1));
+
+  constexpr absl::int128 multiplication = absl::int128(10) * absl::int128(3);
+  EXPECT_EQ(multiplication, absl::int128(30));
+#endif  // ABSL_HAVE_INTRINSIC_INT128
 }
 
 TEST(Int128, ComparisonTest) {

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

@@ -161,6 +161,7 @@ cc_library(
         "//absl/container:btree",
         "//absl/container:flat_hash_map",
         "//absl/strings",
+        "//absl/strings:str_format",
         "//absl/types:span",
     ],
 )

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

@@ -109,6 +109,7 @@ absl_cc_library(
     absl::flat_hash_map
     absl::btree
     absl::strings
+    absl::str_format
     absl::span
 )
 

package/vendor/abseil-cpp/absl/profiling/hashtable.cc

@@ -42,6 +42,8 @@ StatusOr<std::string> MarshalHashtableProfile() {
 
 namespace debugging_internal {
 
+static void DroppedHashtableSample() {}
+
 StatusOr<std::string> MarshalHashtableProfile(
     container_internal::HashtablezSampler& sampler, Time now) {
   static constexpr absl::string_view kDropFrames =
@@ -58,6 +60,7 @@ StatusOr<std::string> MarshalHashtableProfile(
   const auto capacity_id = builder.InternString("capacity");
   const auto size_id = builder.InternString("size");
   const auto num_erases_id = builder.InternString("num_erases");
+  const auto num_insert_hits_id = builder.InternString("num_insert_hits");
   const auto num_rehashes_id = builder.InternString("num_rehashes");
   const auto max_probe_length_id = builder.InternString("max_probe_length");
   const auto total_probe_length_id = builder.InternString("total_probe_length");
@@ -67,7 +70,6 @@ StatusOr<std::string> MarshalHashtableProfile(
   const auto key_size_id = builder.InternString("key_size");
   const auto value_size_id = builder.InternString("value_size");
   const auto soo_capacity_id = builder.InternString("soo_capacity");
-  const auto checksum_id = builder.InternString("checksum");
   const auto table_age_id = builder.InternString("table_age");
   const auto max_reserve_id = builder.InternString("max_reserve");
 
@@ -87,6 +89,9 @@ StatusOr<std::string> MarshalHashtableProfile(
         add_label(size_id, info.size.load(std::memory_order_relaxed));
         add_label(num_erases_id,
                   info.num_erases.load(std::memory_order_relaxed));
+        // TODO(b/436909492): Revisit whether this value is useful.
+        add_label(num_insert_hits_id,
+                  info.num_insert_hits.load(std::memory_order_relaxed));
         add_label(num_rehashes_id,
                   info.num_rehashes.load(std::memory_order_relaxed));
         add_label(max_probe_length_id,
@@ -100,8 +105,6 @@ StatusOr<std::string> MarshalHashtableProfile(
         add_label(key_size_id, info.key_size);
         add_label(value_size_id, info.value_size);
         add_label(soo_capacity_id, info.soo_capacity);
-        add_label(checksum_id,
-                  info.hashes_bitwise_xor.load(std::memory_order_relaxed));
         add_label(
             table_age_id,
             static_cast<uint64_t>(ToInt64Microseconds(now - info.create_time)));
@@ -111,10 +114,18 @@ StatusOr<std::string> MarshalHashtableProfile(
                           MakeSpan(info.stack, info.depth), labels);
       });
 
-  // TODO(b/262310142): Make this more structured data.
-  StringId comment_id =
-      builder.InternString(StrCat("dropped_samples: ", dropped));
-  builder.set_comment_id(comment_id);
+  if (dropped > 0) {
+    // If we dropped samples, we don't have information for them, including
+    // their sizes.  The non-zero weight allows it to be noticed in the profile
+    // and examined more closely.
+    //
+    // We compensate for the fixup done by AddSample by adjusting the address
+    // here.
+    const void* kFakeStack[] = {
+      absl::bit_cast<void*>(
+          reinterpret_cast<uintptr_t>(&DroppedHashtableSample)+1)};
+    builder.AddSample(static_cast<int64_t>(dropped), kFakeStack, {});
+  }
   builder.AddCurrentMappings();
   return std::move(builder).Emit();
 }

package/vendor/abseil-cpp/absl/profiling/internal/profile_builder.cc

@@ -32,6 +32,7 @@
 #include "absl/base/internal/raw_logging.h"
 #include "absl/strings/escaping.h"
 #include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
 #include "absl/types/span.h"
 
 namespace absl {

package/vendor/abseil-cpp/absl/random/internal/fastmath_test.cc

@@ -16,12 +16,10 @@
 
 #include "gtest/gtest.h"
 
-#if defined(__native_client__) || defined(__EMSCRIPTEN__)
-// NACL has a less accurate implementation of std::log2 than most of
+#if defined(__EMSCRIPTEN__)
+// Emscripten has a less accurate implementation of std::log2 than most of
 // the other platforms. For some values which should have integral results,
-// sometimes NACL returns slightly larger values.
-//
-// The MUSL libc used by emscripten also has a similar bug.
+// sometimes Emscripten returns slightly larger values.
 #define ABSL_RANDOM_INACCURATE_LOG2
 #endif
 

package/vendor/abseil-cpp/absl/random/internal/platform.h

@@ -35,7 +35,6 @@
 //   Darwin (macOS and iOS)            __APPLE__
 //   Akaros (http://akaros.org)        __ros__
 //   Windows                           _WIN32
-//   NaCL                              __native_client__
 //   AsmJS                             __asmjs__
 //   WebAssembly                       __wasm__
 //   Fuchsia                           __Fuchsia__
@@ -125,12 +124,6 @@
 
 #endif
 
-// NaCl does not allow AES.
-#if defined(__native_client__)
-#undef ABSL_HAVE_ACCELERATED_AES
-#define ABSL_HAVE_ACCELERATED_AES 0
-#endif
-
 // ABSL_RANDOM_INTERNAL_AES_DISPATCH indicates whether the currently active
 // platform has, or should use run-time dispatch for selecting the
 // accelerated Randen implementation.
@@ -162,10 +155,4 @@
 #define ABSL_RANDOM_INTERNAL_AES_DISPATCH 1
 #endif
 
-// NaCl does not allow dispatch.
-#if defined(__native_client__)
-#undef ABSL_RANDOM_INTERNAL_AES_DISPATCH
-#define ABSL_RANDOM_INTERNAL_AES_DISPATCH 0
-#endif
-
 #endif  // ABSL_RANDOM_INTERNAL_PLATFORM_H_

package/vendor/abseil-cpp/absl/random/internal/randen_engine_test.cc

@@ -632,7 +632,6 @@ TEST(RandenTest, IsFastOrSlow) {
   //
   // linux, optimized ~5ns
   // ppc, optimized ~7ns
-  // nacl (slow), ~1100ns
   //
   // `kCount` is chosen below so that, in debug builds and without hardware
   // acceleration, the test (assuming ~1us per call) should finish in ~0.1s

package/vendor/abseil-cpp/absl/random/internal/seed_material.cc

@@ -41,12 +41,7 @@
 #include "absl/types/optional.h"
 #include "absl/types/span.h"
 
-#if defined(__native_client__)
-
-#include <nacl/nacl_random.h>
-#define ABSL_RANDOM_USE_NACL_SECURE_RANDOM 1
-
-#elif defined(_WIN32)
+#if defined(_WIN32)
 
 #include <windows.h>
 #define ABSL_RANDOM_USE_BCRYPT 1
@@ -109,27 +104,6 @@ bool ReadSeedMaterialFromOSEntropyImpl(absl::Span<uint32_t> values) {
   return BCRYPT_SUCCESS(ret);
 }
 
-#elif defined(ABSL_RANDOM_USE_NACL_SECURE_RANDOM)
-
-// On NaCL use nacl_secure_random to acquire bytes.
-bool ReadSeedMaterialFromOSEntropyImpl(absl::Span<uint32_t> values) {
-  auto buffer = reinterpret_cast<uint8_t*>(values.data());
-  size_t buffer_size = sizeof(uint32_t) * values.size();
-
-  uint8_t* output_ptr = buffer;
-  while (buffer_size > 0) {
-    size_t nread = 0;
-    const int error = nacl_secure_random(output_ptr, buffer_size, &nread);
-    if (error != 0 || nread > buffer_size) {
-      ABSL_RAW_LOG(ERROR, "Failed to read secure_random seed data: %d", error);
-      return false;
-    }
-    output_ptr += nread;
-    buffer_size -= nread;
-  }
-  return true;
-}
-
 #elif defined(__Fuchsia__)
 
 bool ReadSeedMaterialFromOSEntropyImpl(absl::Span<uint32_t> values) {

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

@@ -192,3 +192,20 @@ cc_test(
         "@googletest//:gtest_main",
     ],
 )
+
+cc_test(
+    name = "status_matchers_with_unqualified_macros_test",
+    size = "small",
+    srcs = ["status_matchers_test.cc"],
+    copts = ABSL_TEST_COPTS,
+    linkopts = ABSL_DEFAULT_LINKOPTS,
+    local_defines = ["ABSL_DEFINE_UNQUALIFIED_STATUS_TESTING_MACROS"],
+    deps = [
+        ":status",
+        ":status_matchers",
+        ":statusor",
+        "//absl/strings",
+        "@googletest//:gtest",
+        "@googletest//:gtest_main",
+    ],
+)

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

@@ -141,3 +141,19 @@ absl_cc_test(
     absl::status_matchers
     GTest::gmock_main
 )
+
+absl_cc_test(
+  NAME
+    status_matchers_with_unqualified_macros_test
+  SRCS
+   "status_matchers_test.cc"
+  COPTS
+    ${ABSL_TEST_COPTS}
+  DEFINES
+    "ABSL_DEFINE_UNQUALIFIED_STATUS_TESTING_MACROS"
+  DEPS
+    absl::status
+    absl::statusor
+    absl::status_matchers
+    GTest::gmock_main
+)

package/vendor/abseil-cpp/absl/status/internal/status_internal.h

@@ -38,9 +38,11 @@ ABSL_NAMESPACE_BEGIN
 // TODO(b/176172494): ABSL_MUST_USE_RESULT should expand to the more strict
 // [[nodiscard]]. For now, just use [[nodiscard]] directly when it is available.
 #if ABSL_HAVE_CPP_ATTRIBUTE(nodiscard)
-class [[nodiscard]] ABSL_ATTRIBUTE_TRIVIAL_ABI Status;
+class [[nodiscard]] ABSL_ATTRIBUTE_TRIVIAL_ABI
+    Status;
 #else
-class ABSL_MUST_USE_RESULT ABSL_ATTRIBUTE_TRIVIAL_ABI Status;
+class ABSL_MUST_USE_RESULT ABSL_ATTRIBUTE_TRIVIAL_ABI
+    Status;
 #endif
 ABSL_NAMESPACE_END
 }  // namespace absl

package/vendor/abseil-cpp/absl/status/internal/status_matchers.h

@@ -69,8 +69,8 @@ class IsOkAndHoldsMatcherImpl
   bool MatchAndExplain(
       StatusOrType actual_value,
       ::testing::MatchResultListener* result_listener) const override {
-    if (!GetStatus(actual_value).ok()) {
-      *result_listener << "which has status " << GetStatus(actual_value);
+    if (!actual_value.ok()) {
+      *result_listener << "which has status " << actual_value.status();
       return false;
     }
 

package/vendor/abseil-cpp/absl/status/internal/statusor_internal.h

@@ -29,7 +29,8 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 
 template <typename T>
-class ABSL_MUST_USE_RESULT StatusOr;
+class ABSL_MUST_USE_RESULT
+    StatusOr;
 
 namespace internal_statusor {
 

package/vendor/abseil-cpp/absl/status/status.cc

@@ -47,6 +47,10 @@ static_assert(
     "absl::Status assumes it can use the bottom 2 bits of a StatusRep*.");
 
 std::string StatusCodeToString(StatusCode code) {
+  return std::string(absl::StatusCodeToStringView(code));
+}
+
+absl::string_view StatusCodeToStringView(StatusCode code) {
   switch (code) {
     case StatusCode::kOk:
       return "OK";

package/vendor/abseil-cpp/absl/status/status.h

@@ -284,6 +284,11 @@ enum class StatusCode : int {
 // Returns the name for the status code, or "" if it is an unknown value.
 std::string StatusCodeToString(StatusCode code);
 
+// StatusCodeToStringView()
+//
+// Same as StatusCodeToString(), but returns a string_view.
+absl::string_view StatusCodeToStringView(StatusCode code);
+
 // operator<<
 //
 // Streams StatusCodeToString(code) to `os`.

package/vendor/abseil-cpp/absl/status/status_matchers.h

@@ -20,6 +20,24 @@
 //
 // Defines the following utilities:
 //
+//   =================
+//   ABSL_EXPECT_OK(s)
+//
+//   ABSL_ASSERT_OK(s)
+//   =================
+//   Convenience macros for `EXPECT_THAT(s, IsOk())`, where `s` is either
+//   a `Status` or a `StatusOr<T>`.
+//
+//   There are no EXPECT_NOT_OK/ASSERT_NOT_OK macros since they would not
+//   provide much value (when they fail, they would just print the OK status
+//   which conveys no more information than `EXPECT_FALSE(s.ok())`. You can
+//   of course use `EXPECT_THAT(s, Not(IsOk()))` if you prefer _THAT style.
+//
+//   If you want to check for particular errors, better alternatives are:
+//   EXPECT_THAT(s, StatusIs(expected_error));
+//   EXPECT_THAT(s, StatusIs(_, _, HasSubstr("expected error")));
+//
+//
 //   ===============
 //   `IsOkAndHolds(m)`
 //   ===============
@@ -76,6 +94,13 @@
 namespace absl_testing {
 ABSL_NAMESPACE_BEGIN
 
+// Macros for testing the results of functions that return absl::Status or
+// absl::StatusOr<T> (for any type T).
+#define ABSL_EXPECT_OK(expression) \
+  EXPECT_THAT(expression, ::absl_testing::IsOk())
+#define ABSL_ASSERT_OK(expression) \
+  ASSERT_THAT(expression, ::absl_testing::IsOk())
+
 // Returns a gMock matcher that matches a StatusOr<> whose status is
 // OK and whose value matches the inner matcher.
 template <typename InnerMatcherT>
@@ -112,6 +137,29 @@ inline status_internal::IsOkMatcher IsOk() {
   return status_internal::IsOkMatcher();
 }
 
+// By defining ABSL_DEFINE_UNQUALIFIED_STATUS_TESTING_MACROS, this library also
+// provides unqualified versions of macros
+//
+// Unqualified macro names are likely to collide with those other projects, and
+// so are not recommended.  Further, this is true of any transitive dependency
+// of Abseil; it is impossible to be confident no downstream library will not
+// also define these macros itself nor depend on a different library that also
+// defines them.
+//
+// To enable this, define `ABSL_DEFINE_UNQUALIFIED_STATUS_TESTING_MACROS`
+// preferably at the command line, e.g.
+// `-DABSL_DEFINE_UNQUALIFIED_STATUS_TESTING_MACROS` or
+// `local_defines = ["ABSL_DEFINE_UNQUALIFIED_STATUS_TESTING_MACROS"]` if using
+// Bazel.
+//
+// These are turned on by default inside Google's internal codebase where their
+// use is historically ubiquitous.  Other OSS Google projects should use the
+// qualified versions or the `EXPECT_THAT(..., IsOk())` form.
+#ifdef ABSL_DEFINE_UNQUALIFIED_STATUS_TESTING_MACROS
+#define EXPECT_OK(expression) ABSL_EXPECT_OK(expression)
+#define ASSERT_OK(expression) ABSL_ASSERT_OK(expression)
+#endif  // ABSL_DEFINE_UNQUALIFIED_STATUS_TESTING_MACROS
+
 ABSL_NAMESPACE_END
 }  // namespace absl_testing
 

package/vendor/abseil-cpp/absl/status/status_matchers_test.cc

@@ -39,6 +39,33 @@ using ::testing::MatchesRegex;
 using ::testing::Not;
 using ::testing::Ref;
 
+TEST(StatusMatcherTest, AbslExpectAssertOk) {
+  ABSL_EXPECT_OK(absl::OkStatus());
+  ABSL_ASSERT_OK(absl::OkStatus());
+  EXPECT_NONFATAL_FAILURE(ABSL_EXPECT_OK(absl::InternalError("Smigla error")),
+                          "Smigla error");
+  EXPECT_FATAL_FAILURE(ABSL_ASSERT_OK(absl::InternalError("Smigla error")),
+                       "Smigla error");
+}
+
+TEST(StatusMatcherTest, ExpectAssertOk) {
+#ifdef ABSL_DEFINE_UNQUALIFIED_STATUS_TESTING_MACROS
+  EXPECT_OK(absl::OkStatus());
+  ASSERT_OK(absl::OkStatus());
+  EXPECT_NONFATAL_FAILURE(EXPECT_OK(absl::InternalError("Smigla error")),
+                          "Smigla error");
+  EXPECT_FATAL_FAILURE(ASSERT_OK(absl::InternalError("Smigla error")),
+                       "Smigla error");
+#else
+#ifdef EXPECT_OK
+  static_assert(false, "EXPECT_OK defined despite being turned off.");
+#endif  // EXPECT_OK
+#ifdef ASSERT_OK
+  static_assert(false, "ASSERT_OK defined despite being turned off.");
+#endif  // ASSERT_OK
+#endif  // ABSL_DEFINE_UNQUALIFIED_STATUS_TESTING_MACROS
+}
+
 TEST(StatusMatcherTest, StatusIsOk) { EXPECT_THAT(absl::OkStatus(), IsOk()); }
 
 TEST(StatusMatcherTest, StatusOrIsOk) {

package/vendor/abseil-cpp/absl/status/status_test.cc

@@ -39,6 +39,7 @@ TEST(StatusCode, InsertionOperator) {
   std::ostringstream oss;
   oss << code;
   EXPECT_EQ(oss.str(), absl::StatusCodeToString(code));
+  EXPECT_EQ(oss.str(), absl::StatusCodeToStringView(code));
 }
 
 // This structure holds the details for testing a single error code,

package/vendor/abseil-cpp/absl/status/statusor.h

@@ -45,8 +45,8 @@
 #include <utility>
 
 #include "absl/base/attributes.h"
-#include "absl/base/nullability.h"
 #include "absl/base/call_once.h"
+#include "absl/base/nullability.h"
 #include "absl/meta/type_traits.h"
 #include "absl/status/internal/statusor_internal.h"
 #include "absl/status/status.h"