re2 1.22.2 → 1.23.0

package/vendor/abseil-cpp/absl/meta/type_traits_test.cc

@@ -16,6 +16,7 @@
 
 #include <cstdint>
 #include <string>
+#include <string_view>
 #include <type_traits>
 #include <utility>
 #include <vector>
@@ -26,10 +27,6 @@
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
 
-#ifdef ABSL_HAVE_STD_STRING_VIEW
-#include <string_view>
-#endif
-
 namespace {
 
 using ::testing::StaticAssertTypeEq;
@@ -45,12 +42,10 @@ static_assert(IsOwnerAndNotView<std::string>::value,
               "string is an owner, not a view");
 static_assert(IsOwnerAndNotView<std::wstring>::value,
               "wstring is an owner, not a view");
-#ifdef ABSL_HAVE_STD_STRING_VIEW
 static_assert(!IsOwnerAndNotView<std::string_view>::value,
               "string_view is a view, not an owner");
 static_assert(!IsOwnerAndNotView<std::wstring_view>::value,
               "wstring_view is a view, not an owner");
-#endif
 
 template <class T, class U>
 struct simple_pair {
@@ -90,10 +85,6 @@ template <class Class, class... T>
 using BarIsCallable =
     absl::type_traits_internal::is_detected<BarIsCallableImpl, Class, T...>;
 
-template <class Class, class... T>
-using BarIsCallableConv = absl::type_traits_internal::is_detected_convertible<
-    ReturnType, BarIsCallableImpl, Class, T...>;
-
 // NOTE: Test of detail type_traits_internal::is_detected.
 TEST(IsDetectedTest, BasicUsage) {
   EXPECT_TRUE((BarIsCallable<TypeWithBarFunction, StructA&, const StructB&,
@@ -110,286 +101,11 @@ TEST(IsDetectedTest, BasicUsage) {
                               StructC>::value));
 }
 
-// NOTE: Test of detail type_traits_internal::is_detected_convertible.
-TEST(IsDetectedConvertibleTest, BasicUsage) {
-  EXPECT_TRUE((BarIsCallableConv<TypeWithBarFunction, StructA&, const StructB&,
-                                 StructC>::value));
-  EXPECT_TRUE((BarIsCallableConv<TypeWithBarFunction, StructA&, StructB&,
-                                 StructC>::value));
-  EXPECT_TRUE((BarIsCallableConv<TypeWithBarFunction, StructA&, StructB,
-                                 StructC>::value));
-  EXPECT_TRUE((BarIsCallableConv<TypeWithBarFunctionAndConvertibleReturnType,
-                                 StructA&, const StructB&, StructC>::value));
-  EXPECT_TRUE((BarIsCallableConv<TypeWithBarFunctionAndConvertibleReturnType,
-                                 StructA&, StructB&, StructC>::value));
-  EXPECT_TRUE((BarIsCallableConv<TypeWithBarFunctionAndConvertibleReturnType,
-                                 StructA&, StructB, StructC>::value));
-
-  EXPECT_FALSE(
-      (BarIsCallableConv<int, StructA&, const StructB&, StructC>::value));
-  EXPECT_FALSE((BarIsCallableConv<TypeWithBarFunction&, StructA&,
-                                  const StructB&, StructC>::value));
-  EXPECT_FALSE((BarIsCallableConv<TypeWithBarFunction, StructA, const StructB&,
-                                  StructC>::value));
-  EXPECT_FALSE((BarIsCallableConv<TypeWithBarFunctionAndConvertibleReturnType&,
-                                  StructA&, const StructB&, StructC>::value));
-  EXPECT_FALSE((BarIsCallableConv<TypeWithBarFunctionAndConvertibleReturnType,
-                                  StructA, const StructB&, StructC>::value));
-}
-
 TEST(VoidTTest, BasicUsage) {
   StaticAssertTypeEq<void, absl::void_t<Dummy>>();
   StaticAssertTypeEq<void, absl::void_t<Dummy, Dummy, Dummy>>();
 }
 
-TEST(ConjunctionTest, BasicBooleanLogic) {
-  EXPECT_TRUE(absl::conjunction<>::value);
-  EXPECT_TRUE(absl::conjunction<std::true_type>::value);
-  EXPECT_TRUE((absl::conjunction<std::true_type, std::true_type>::value));
-  EXPECT_FALSE((absl::conjunction<std::true_type, std::false_type>::value));
-  EXPECT_FALSE((absl::conjunction<std::false_type, std::true_type>::value));
-  EXPECT_FALSE((absl::conjunction<std::false_type, std::false_type>::value));
-}
-
-struct MyTrueType {
-  static constexpr bool value = true;
-};
-
-struct MyFalseType {
-  static constexpr bool value = false;
-};
-
-TEST(ConjunctionTest, ShortCircuiting) {
-  EXPECT_FALSE(
-      (absl::conjunction<std::true_type, std::false_type, Dummy>::value));
-  EXPECT_TRUE((std::is_base_of<MyFalseType,
-                               absl::conjunction<std::true_type, MyFalseType,
-                                                 std::false_type>>::value));
-  EXPECT_TRUE(
-      (std::is_base_of<MyTrueType,
-                       absl::conjunction<std::true_type, MyTrueType>>::value));
-}
-
-TEST(DisjunctionTest, BasicBooleanLogic) {
-  EXPECT_FALSE(absl::disjunction<>::value);
-  EXPECT_FALSE(absl::disjunction<std::false_type>::value);
-  EXPECT_TRUE((absl::disjunction<std::true_type, std::true_type>::value));
-  EXPECT_TRUE((absl::disjunction<std::true_type, std::false_type>::value));
-  EXPECT_TRUE((absl::disjunction<std::false_type, std::true_type>::value));
-  EXPECT_FALSE((absl::disjunction<std::false_type, std::false_type>::value));
-}
-
-TEST(DisjunctionTest, ShortCircuiting) {
-  EXPECT_TRUE(
-      (absl::disjunction<std::false_type, std::true_type, Dummy>::value));
-  EXPECT_TRUE((
-      std::is_base_of<MyTrueType, absl::disjunction<std::false_type, MyTrueType,
-                                                    std::true_type>>::value));
-  EXPECT_TRUE((
-      std::is_base_of<MyFalseType,
-                      absl::disjunction<std::false_type, MyFalseType>>::value));
-}
-
-TEST(NegationTest, BasicBooleanLogic) {
-  EXPECT_FALSE(absl::negation<std::true_type>::value);
-  EXPECT_FALSE(absl::negation<MyTrueType>::value);
-  EXPECT_TRUE(absl::negation<std::false_type>::value);
-  EXPECT_TRUE(absl::negation<MyFalseType>::value);
-}
-
-// all member functions are trivial
-class Trivial {
-  int n_;
-};
-
-struct TrivialDestructor {
-  ~TrivialDestructor() = default;
-};
-
-struct NontrivialDestructor {
-  ~NontrivialDestructor() {}
-};
-
-struct DeletedDestructor {
-  ~DeletedDestructor() = delete;
-};
-
-class TrivialDefaultCtor {
- public:
-  TrivialDefaultCtor() = default;
-  explicit TrivialDefaultCtor(int n) : n_(n) {}
-
- private:
-  int n_;
-};
-
-class NontrivialDefaultCtor {
- public:
-  NontrivialDefaultCtor() : n_(1) {}
-
- private:
-  int n_;
-};
-
-class DeletedDefaultCtor {
- public:
-  DeletedDefaultCtor() = delete;
-  explicit DeletedDefaultCtor(int n) : n_(n) {}
-
- private:
-  int n_;
-};
-
-class TrivialMoveCtor {
- public:
-  explicit TrivialMoveCtor(int n) : n_(n) {}
-  TrivialMoveCtor(TrivialMoveCtor&&) = default;
-  TrivialMoveCtor& operator=(const TrivialMoveCtor& t) {
-    n_ = t.n_;
-    return *this;
-  }
-
- private:
-  int n_;
-};
-
-class NontrivialMoveCtor {
- public:
-  explicit NontrivialMoveCtor(int n) : n_(n) {}
-  NontrivialMoveCtor(NontrivialMoveCtor&& t) noexcept : n_(t.n_) {}
-  NontrivialMoveCtor& operator=(const NontrivialMoveCtor&) = default;
-
- private:
-  int n_;
-};
-
-class TrivialCopyCtor {
- public:
-  explicit TrivialCopyCtor(int n) : n_(n) {}
-  TrivialCopyCtor(const TrivialCopyCtor&) = default;
-  TrivialCopyCtor& operator=(const TrivialCopyCtor& t) {
-    n_ = t.n_;
-    return *this;
-  }
-
- private:
-  int n_;
-};
-
-class NontrivialCopyCtor {
- public:
-  explicit NontrivialCopyCtor(int n) : n_(n) {}
-  NontrivialCopyCtor(const NontrivialCopyCtor& t) : n_(t.n_) {}
-  NontrivialCopyCtor& operator=(const NontrivialCopyCtor&) = default;
-
- private:
-  int n_;
-};
-
-class DeletedCopyCtor {
- public:
-  explicit DeletedCopyCtor(int n) : n_(n) {}
-  DeletedCopyCtor(const DeletedCopyCtor&) = delete;
-  DeletedCopyCtor& operator=(const DeletedCopyCtor&) = default;
-
- private:
-  int n_;
-};
-
-class TrivialMoveAssign {
- public:
-  explicit TrivialMoveAssign(int n) : n_(n) {}
-  TrivialMoveAssign(const TrivialMoveAssign& t) : n_(t.n_) {}
-  TrivialMoveAssign& operator=(TrivialMoveAssign&&) = default;
-  ~TrivialMoveAssign() {}  // can have nontrivial destructor
- private:
-  int n_;
-};
-
-class NontrivialMoveAssign {
- public:
-  explicit NontrivialMoveAssign(int n) : n_(n) {}
-  NontrivialMoveAssign(const NontrivialMoveAssign&) = default;
-  NontrivialMoveAssign& operator=(NontrivialMoveAssign&& t) noexcept {
-    n_ = t.n_;
-    return *this;
-  }
-
- private:
-  int n_;
-};
-
-class TrivialCopyAssign {
- public:
-  explicit TrivialCopyAssign(int n) : n_(n) {}
-  TrivialCopyAssign(const TrivialCopyAssign& t) : n_(t.n_) {}
-  TrivialCopyAssign& operator=(const TrivialCopyAssign& t) = default;
-  ~TrivialCopyAssign() {}  // can have nontrivial destructor
- private:
-  int n_;
-};
-
-class NontrivialCopyAssign {
- public:
-  explicit NontrivialCopyAssign(int n) : n_(n) {}
-  NontrivialCopyAssign(const NontrivialCopyAssign&) = default;
-  NontrivialCopyAssign& operator=(const NontrivialCopyAssign& t) {
-    n_ = t.n_;
-    return *this;
-  }
-
- private:
-  int n_;
-};
-
-class DeletedCopyAssign {
- public:
-  explicit DeletedCopyAssign(int n) : n_(n) {}
-  DeletedCopyAssign(const DeletedCopyAssign&) = default;
-  DeletedCopyAssign& operator=(const DeletedCopyAssign&) = delete;
-
- private:
-  int n_;
-};
-
-struct MovableNonCopyable {
-  MovableNonCopyable() = default;
-  MovableNonCopyable(const MovableNonCopyable&) = delete;
-  MovableNonCopyable(MovableNonCopyable&&) = default;
-  MovableNonCopyable& operator=(const MovableNonCopyable&) = delete;
-  MovableNonCopyable& operator=(MovableNonCopyable&&) = default;
-};
-
-struct NonCopyableOrMovable {
-  NonCopyableOrMovable() = default;
-  virtual ~NonCopyableOrMovable() = default;
-  NonCopyableOrMovable(const NonCopyableOrMovable&) = delete;
-  NonCopyableOrMovable(NonCopyableOrMovable&&) = delete;
-  NonCopyableOrMovable& operator=(const NonCopyableOrMovable&) = delete;
-  NonCopyableOrMovable& operator=(NonCopyableOrMovable&&) = delete;
-};
-
-class Base {
- public:
-  virtual ~Base() {}
-};
-
-TEST(TypeTraitsTest, TestIsFunction) {
-  struct Callable {
-    void operator()() {}
-  };
-  EXPECT_TRUE(absl::is_function<void()>::value);
-  EXPECT_TRUE(absl::is_function<void()&>::value);
-  EXPECT_TRUE(absl::is_function<void() const>::value);
-  EXPECT_TRUE(absl::is_function<void() noexcept>::value);
-  EXPECT_TRUE(absl::is_function<void(...) noexcept>::value);
-
-  EXPECT_FALSE(absl::is_function<void (*)()>::value);
-  EXPECT_FALSE(absl::is_function<void (&)()>::value);
-  EXPECT_FALSE(absl::is_function<int>::value);
-  EXPECT_FALSE(absl::is_function<Callable>::value);
-}
-
 TEST(TypeTraitsTest, TestRemoveCVRef) {
   EXPECT_TRUE(
       (std::is_same<typename absl::remove_cvref<int>::type, int>::value));
@@ -418,124 +134,6 @@ TEST(TypeTraitsTest, TestRemoveCVRef) {
                             int[2]>::value));
 }
 
-#define ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(trait_name, ...)          \
-  EXPECT_TRUE((std::is_same<typename std::trait_name<__VA_ARGS__>::type, \
-                            absl::trait_name##_t<__VA_ARGS__>>::value))
-
-TEST(TypeTraitsTest, TestRemoveCVAliases) {
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_cv, int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_cv, const int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_cv, volatile int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_cv, const volatile int);
-
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_const, int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_const, const int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_const, volatile int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_const, const volatile int);
-
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_volatile, int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_volatile, const int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_volatile, volatile int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_volatile, const volatile int);
-}
-
-TEST(TypeTraitsTest, TestAddCVAliases) {
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_cv, int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_cv, const int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_cv, volatile int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_cv, const volatile int);
-
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_const, int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_const, const int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_const, volatile int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_const, const volatile int);
-
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_volatile, int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_volatile, const int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_volatile, volatile int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_volatile, const volatile int);
-}
-
-TEST(TypeTraitsTest, TestReferenceAliases) {
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_reference, int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_reference, volatile int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_reference, int&);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_reference, volatile int&);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_reference, int&&);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_reference, volatile int&&);
-
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_lvalue_reference, int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_lvalue_reference, volatile int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_lvalue_reference, int&);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_lvalue_reference, volatile int&);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_lvalue_reference, int&&);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_lvalue_reference, volatile int&&);
-
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_rvalue_reference, int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_rvalue_reference, volatile int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_rvalue_reference, int&);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_rvalue_reference, volatile int&);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_rvalue_reference, int&&);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_rvalue_reference, volatile int&&);
-}
-
-TEST(TypeTraitsTest, TestPointerAliases) {
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_pointer, int*);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_pointer, volatile int*);
-
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_pointer, int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_pointer, volatile int);
-}
-
-TEST(TypeTraitsTest, TestSignednessAliases) {
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(make_signed, int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(make_signed, volatile int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(make_signed, unsigned);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(make_signed, volatile unsigned);
-
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(make_unsigned, int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(make_unsigned, volatile int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(make_unsigned, unsigned);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(make_unsigned, volatile unsigned);
-}
-
-TEST(TypeTraitsTest, TestExtentAliases) {
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_extent, int[]);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_extent, int[1]);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_extent, int[1][1]);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_extent, int[][1]);
-
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_all_extents, int[]);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_all_extents, int[1]);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_all_extents, int[1][1]);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_all_extents, int[][1]);
-}
-
-TEST(TypeTraitsTest, TestDecay) {
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, const int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, volatile int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, const volatile int);
-
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int&);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, const int&);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, volatile int&);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, const volatile int&);
-
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int&);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, const int&);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, volatile int&);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, const volatile int&);
-
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int[1]);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int[1][1]);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int[][1]);
-
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int());
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int(float));      // NOLINT
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int(char, ...));  // NOLINT
-}
-
 struct TypeA {};
 struct TypeB {};
 struct TypeC {};
@@ -568,36 +166,6 @@ struct GetTypeT {
   // NOTE: TypeD is intentionally not handled
 } constexpr GetType = {};
 
-TEST(TypeTraitsTest, TestEnableIf) {
-  EXPECT_EQ(TypeEnum::A, GetType(Wrap<TypeA>()));
-  EXPECT_EQ(TypeEnum::B, GetType(Wrap<TypeB>()));
-  EXPECT_EQ(TypeEnum::C, GetType(Wrap<TypeC>()));
-}
-
-TEST(TypeTraitsTest, TestConditional) {
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(conditional, true, int, char);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(conditional, false, int, char);
-}
-
-// TODO(calabrese) Check with specialized std::common_type
-TEST(TypeTraitsTest, TestCommonType) {
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(common_type, int);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(common_type, int, char);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(common_type, int, char, int);
-
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(common_type, int&);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(common_type, int, char&);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(common_type, int, char, int&);
-}
-
-TEST(TypeTraitsTest, TestUnderlyingType) {
-  enum class enum_char : char {};
-  enum class enum_long_long : long long {};  // NOLINT(runtime/int)
-
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(underlying_type, enum_char);
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(underlying_type, enum_long_long);
-}
-
 struct GetTypeExtT {
   template <typename T>
   absl::result_of_t<const GetTypeT&(T)> operator()(T&& arg) const {
@@ -765,51 +333,6 @@ TEST(TriviallyRelocatable, UserProvidedDestructor) {
   static_assert(!absl::is_trivially_relocatable<S>::value, "");
 }
 
-// TODO(b/275003464): remove the opt-out for Clang on Windows once
-// __is_trivially_relocatable is used there again.
-// TODO(b/324278148): remove the opt-out for Apple once
-// __is_trivially_relocatable is fixed there.
-// TODO(b/325479096): remove the opt-out for Clang once
-// __is_trivially_relocatable is fixed there.
-#if defined(ABSL_HAVE_ATTRIBUTE_TRIVIAL_ABI) &&      \
-    ABSL_HAVE_BUILTIN(__is_trivially_relocatable) && \
-    (defined(__cpp_impl_trivially_relocatable) ||    \
-     (!defined(__clang__) && !defined(__APPLE__) && !defined(__NVCC__)))
-// A type marked with the "trivial ABI" attribute is trivially relocatable even
-// if it has user-provided special members.
-TEST(TriviallyRelocatable, TrivialAbi) {
-  struct ABSL_ATTRIBUTE_TRIVIAL_ABI S {
-    S(S&&) {}       // NOLINT(modernize-use-equals-default)
-    S(const S&) {}  // NOLINT(modernize-use-equals-default)
-    S& operator=(S&&) { return *this; }
-    S& operator=(const S&) { return *this; }
-    ~S() {}  // NOLINT(modernize-use-equals-default)
-  };
-
-  static_assert(absl::is_trivially_relocatable<S>::value, "");
-}
-#endif
-
-// TODO(b/275003464): remove the opt-out for Clang on Windows once
-// __is_trivially_relocatable is used there again.
-// TODO(b/324278148): remove the opt-out for Apple once
-// __is_trivially_relocatable is fixed there.
-#if defined(ABSL_HAVE_ATTRIBUTE_TRIVIAL_ABI) &&                            \
-    ABSL_HAVE_BUILTIN(__is_trivially_relocatable) && defined(__clang__) && \
-    !(defined(_WIN32) || defined(_WIN64)) && !defined(__APPLE__) &&        \
-    !defined(__NVCC__)
-// A type marked with the "trivial ABI" attribute is trivially relocatable even
-// if it has a user-provided copy constructor and a user-provided destructor.
-TEST(TriviallyRelocatable, TrivialAbi_NoUserProvidedMove) {
-  struct ABSL_ATTRIBUTE_TRIVIAL_ABI S {
-    S(const S&) {}  // NOLINT(modernize-use-equals-default)
-    ~S() {}  // NOLINT(modernize-use-equals-default)
-  };
-
-  static_assert(absl::is_trivially_relocatable<S>::value, "");
-}
-#endif
-
 #ifdef ABSL_HAVE_CONSTANT_EVALUATED
 
 constexpr int64_t NegateIfConstantEvaluated(int64_t i) {

package/vendor/abseil-cpp/absl/numeric/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",
@@ -41,6 +44,7 @@ cc_library(
     deps = [
         "//absl/base:config",
         "//absl/base:core_headers",
+        "//absl/base:endian",
     ],
 )
 
@@ -55,7 +59,6 @@ cc_binary(
         "//absl/base:core_headers",
         "//absl/random",
         "@google_benchmark//:benchmark_main",
-        "@googletest//:gtest",
     ],
 )
 
@@ -114,8 +117,9 @@ cc_test(
     ],
 )
 
-cc_test(
+cc_binary(
     name = "int128_benchmark",
+    testonly = True,
     srcs = ["int128_benchmark.cc"],
     copts = ABSL_TEST_COPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,
@@ -123,8 +127,8 @@ cc_test(
     deps = [
         ":int128",
         "//absl/base:config",
+        "//absl/random",
         "@google_benchmark//:benchmark_main",
-        "@googletest//:gtest",
     ],
 )
 

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

@@ -23,7 +23,9 @@ absl_cc_library(
   COPTS
     ${ABSL_DEFAULT_COPTS}
   DEPS
+    absl::config
     absl::core_headers
+    absl::endian
   PUBLIC
 )
 

package/vendor/abseil-cpp/absl/numeric/bits.h

@@ -27,6 +27,10 @@
 //  http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1355r2.html
 // P1956R1:
 //  http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p1956r1.pdf
+// P0463R1
+//  https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0463r1.html
+// P1272R4
+//  https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p1272r4.html
 //
 // When using a standard library that implements these functions, we use the
 // standard library's implementation.
@@ -45,6 +49,7 @@
 #endif
 
 #include "absl/base/attributes.h"
+#include "absl/base/internal/endian.h"
 #include "absl/numeric/internal/bits.h"
 
 namespace absl {
@@ -63,14 +68,14 @@ using std::rotr;
 
 // Rotating functions
 template <class T>
-ABSL_MUST_USE_RESULT constexpr
+[[nodiscard]] constexpr
     typename std::enable_if<std::is_unsigned<T>::value, T>::type
     rotl(T x, int s) noexcept {
   return numeric_internal::RotateLeft(x, s);
 }
 
 template <class T>
-ABSL_MUST_USE_RESULT constexpr
+[[nodiscard]] constexpr
     typename std::enable_if<std::is_unsigned<T>::value, T>::type
     rotr(T x, int s) noexcept {
   return numeric_internal::RotateRight(x, s);
@@ -190,6 +195,67 @@ ABSL_INTERNAL_CONSTEXPR_CLZ inline
 
 #endif
 
+#if defined(__cpp_lib_endian) && __cpp_lib_endian >= 201907L
+
+// https://en.cppreference.com/w/cpp/types/endian
+//
+// Indicates the endianness of all scalar types:
+//   * If all scalar types are little-endian, `absl::endian::native` equals
+//     absl::endian::little.
+//   * If all scalar types are big-endian, `absl::endian::native` equals
+//     `absl::endian::big`.
+//   * Platforms that use anything else are unsupported.
+using std::endian;
+
+#else
+
+enum class endian {
+  little,
+  big,
+#if defined(ABSL_IS_LITTLE_ENDIAN)
+  native = little
+#elif defined(ABSL_IS_BIG_ENDIAN)
+  native = big
+#else
+#error "Endian detection needs to be set up for this platform"
+#endif
+};
+
+#endif  // defined(__cpp_lib_endian) && __cpp_lib_endian >= 201907L
+
+#if defined(__cpp_lib_byteswap) && __cpp_lib_byteswap >= 202110L
+
+// https://en.cppreference.com/w/cpp/numeric/byteswap
+//
+// Reverses the bytes in the given integer value `x`.
+//
+// `absl::byteswap` participates in overload resolution only if `T` satisfies
+// integral, i.e., `T` is an integer type. The program is ill-formed if `T` has
+// padding bits.
+using std::byteswap;
+
+#else
+
+template <class T>
+[[nodiscard]] constexpr T byteswap(T x) noexcept {
+  static_assert(std::is_integral_v<T>,
+                "byteswap requires an integral argument");
+  static_assert(
+      sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4 || sizeof(T) == 8,
+      "byteswap works only with 8, 16, 32, or 64-bit integers");
+  if constexpr (sizeof(T) == 1) {
+    return x;
+  } else if constexpr (sizeof(T) == 2) {
+    return static_cast<T>(gbswap_16(static_cast<uint16_t>(x)));
+  } else if constexpr (sizeof(T) == 4) {
+    return static_cast<T>(gbswap_32(static_cast<uint32_t>(x)));
+  } else if constexpr (sizeof(T) == 8) {
+    return static_cast<T>(gbswap_64(static_cast<uint64_t>(x)));
+  }
+}
+
+#endif  // defined(__cpp_lib_byteswap) && __cpp_lib_byteswap >= 202110L
+
 ABSL_NAMESPACE_END
 }  // namespace absl