Export of internal Abseil changes

--
dab53ef01a1c8ceebd1347a4918a0def0d7d4ce5 by Derek Mauro <dmauro@google.com>:

Migrate away from the remaining usages of GoogleTest's legacy TestCase API
and use the new TestSuite API instead

PiperOrigin-RevId: 424668744
GitOrigin-RevId: dab53ef01a1c8ceebd1347a4918a0def0d7d4ce5
Change-Id: I599de09f3349d18c2d74795b1f867fa6c99c3eed

absl/container/inlined_vector_test.cc

@@ -1545,7 +1545,7 @@ TYPED_TEST_P(InstanceTest, InitializerListAssign) {
   }
   }
 }
 }
 
 
-REGISTER_TYPED_TEST_CASE_P(InstanceTest, Swap, CountConstructorsDestructors,
+REGISTER_TYPED_TEST_SUITE_P(InstanceTest, Swap, CountConstructorsDestructors,
                             CountConstructorsDestructorsOnCopyConstruction,
                             CountConstructorsDestructorsOnCopyConstruction,
                             CountConstructorsDestructorsOnMoveConstruction,
                             CountConstructorsDestructorsOnMoveConstruction,
                             CountConstructorsDestructorsOnAssignment,
                             CountConstructorsDestructorsOnAssignment,
@@ -1555,7 +1555,8 @@ REGISTER_TYPED_TEST_CASE_P(InstanceTest, Swap, CountConstructorsDestructors,
 
 
 using InstanceTypes =
 using InstanceTypes =
     ::testing::Types<CopyableOnlyInstance, CopyableMovableInstance>;
     ::testing::Types<CopyableOnlyInstance, CopyableMovableInstance>;
-INSTANTIATE_TYPED_TEST_CASE_P(InstanceTestOnTypes, InstanceTest, InstanceTypes);
+INSTANTIATE_TYPED_TEST_SUITE_P(InstanceTestOnTypes, InstanceTest,
+                               InstanceTypes);
 
 
 TEST(DynamicVec, DynamicVecCompiles) {
 TEST(DynamicVec, DynamicVecCompiles) {
   DynamicVec v;
   DynamicVec v;

absl/container/internal/hash_function_defaults_test.cc

@@ -310,7 +310,7 @@ struct StringLikeTest : public ::testing::Test {
   hash_default_hash<typename T::first_type> hash;
   hash_default_hash<typename T::first_type> hash;
 };
 };
 
 
-TYPED_TEST_CASE_P(StringLikeTest);
+TYPED_TEST_SUITE_P(StringLikeTest);
 
 
 TYPED_TEST_P(StringLikeTest, Eq) {
 TYPED_TEST_P(StringLikeTest, Eq) {
   EXPECT_TRUE(this->eq(this->a1, this->b1));
   EXPECT_TRUE(this->eq(this->a1, this->b1));

absl/container/internal/unordered_map_constructor_test.h

@@ -476,7 +476,7 @@ TYPED_TEST_P(ConstructorTest, AssignmentOnSelf) {
 // containers in unspecified state (and in practice in causes memory-leak
 // containers in unspecified state (and in practice in causes memory-leak
 // according to heap-checker!).
 // according to heap-checker!).
 
 
-REGISTER_TYPED_TEST_CASE_P(
+REGISTER_TYPED_TEST_SUITE_P(
     ConstructorTest, NoArgs, BucketCount, BucketCountHash, BucketCountHashEqual,
     ConstructorTest, NoArgs, BucketCount, BucketCountHash, BucketCountHashEqual,
     BucketCountHashEqualAlloc, BucketCountAlloc, BucketCountHashAlloc, Alloc,
     BucketCountHashEqualAlloc, BucketCountAlloc, BucketCountHashAlloc, Alloc,
     InputIteratorBucketHashEqualAlloc, InputIteratorBucketAlloc,
     InputIteratorBucketHashEqualAlloc, InputIteratorBucketAlloc,

absl/container/internal/unordered_map_lookup_test.h

@@ -107,7 +107,7 @@ TYPED_TEST_P(LookupTest, EqualRange) {
   }
   }
 }
 }
 
 
-REGISTER_TYPED_TEST_CASE_P(LookupTest, At, OperatorBracket, Count, Find,
+REGISTER_TYPED_TEST_SUITE_P(LookupTest, At, OperatorBracket, Count, Find,
                             EqualRange);
                             EqualRange);
 
 
 }  // namespace container_internal
 }  // namespace container_internal

absl/container/internal/unordered_map_modifiers_test.h

@@ -297,11 +297,12 @@ TYPED_TEST_P(ModifiersTest, Swap) {
 // TODO(alkis): Write tests for extract.
 // TODO(alkis): Write tests for extract.
 // TODO(alkis): Write tests for merge.
 // TODO(alkis): Write tests for merge.
 
 
-REGISTER_TYPED_TEST_CASE_P(ModifiersTest, Clear, Insert, InsertHint,
+REGISTER_TYPED_TEST_SUITE_P(ModifiersTest, Clear, Insert, InsertHint,
                             InsertRange, InsertWithinCapacity,
                             InsertRange, InsertWithinCapacity,
                             InsertRangeWithinCapacity, InsertOrAssign,
                             InsertRangeWithinCapacity, InsertOrAssign,
-                           InsertOrAssignHint, Emplace, EmplaceHint, TryEmplace,
-                           TryEmplaceHint, Erase, EraseRange, EraseKey, Swap);
+                            InsertOrAssignHint, Emplace, EmplaceHint,
+                            TryEmplace, TryEmplaceHint, Erase, EraseRange,
+                            EraseKey, Swap);
 
 
 template <typename Type>
 template <typename Type>
 struct is_unique_ptr : std::false_type {};
 struct is_unique_ptr : std::false_type {};

absl/container/internal/unordered_set_constructor_test.h

@@ -478,7 +478,7 @@ TYPED_TEST_P(ConstructorTest, AssignmentOnSelf) {
   EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
   EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
 }
 }
 
 
-REGISTER_TYPED_TEST_CASE_P(
+REGISTER_TYPED_TEST_SUITE_P(
     ConstructorTest, NoArgs, BucketCount, BucketCountHash, BucketCountHashEqual,
     ConstructorTest, NoArgs, BucketCount, BucketCountHash, BucketCountHashEqual,
     BucketCountHashEqualAlloc, BucketCountAlloc, BucketCountHashAlloc, Alloc,
     BucketCountHashEqualAlloc, BucketCountAlloc, BucketCountHashAlloc, Alloc,
     InputIteratorBucketHashEqualAlloc, InputIteratorBucketAlloc,
     InputIteratorBucketHashEqualAlloc, InputIteratorBucketAlloc,

absl/container/internal/unordered_set_lookup_test.h

@@ -82,7 +82,7 @@ TYPED_TEST_P(LookupTest, EqualRange) {
   }
   }
 }
 }
 
 
-REGISTER_TYPED_TEST_CASE_P(LookupTest, Count, Find, EqualRange);
+REGISTER_TYPED_TEST_SUITE_P(LookupTest, Count, Find, EqualRange);
 
 
 }  // namespace container_internal
 }  // namespace container_internal
 ABSL_NAMESPACE_END
 ABSL_NAMESPACE_END

absl/container/internal/unordered_set_modifiers_test.h

@@ -209,7 +209,7 @@ TYPED_TEST_P(ModifiersTest, Swap) {
 // TODO(alkis): Write tests for extract.
 // TODO(alkis): Write tests for extract.
 // TODO(alkis): Write tests for merge.
 // TODO(alkis): Write tests for merge.
 
 
-REGISTER_TYPED_TEST_CASE_P(ModifiersTest, Clear, Insert, InsertHint,
+REGISTER_TYPED_TEST_SUITE_P(ModifiersTest, Clear, Insert, InsertHint,
                             InsertRange, InsertWithinCapacity,
                             InsertRange, InsertWithinCapacity,
                             InsertRangeWithinCapacity, Emplace, EmplaceHint,
                             InsertRangeWithinCapacity, Emplace, EmplaceHint,
                             Erase, EraseRange, EraseKey, Swap);
                             Erase, EraseRange, EraseKey, Swap);

absl/random/beta_distribution_test.cc

@@ -54,7 +54,7 @@ using RealTypes =
     std::conditional<absl::numeric_internal::IsDoubleDouble(),
     std::conditional<absl::numeric_internal::IsDoubleDouble(),
                      ::testing::Types<float, double>,
                      ::testing::Types<float, double>,
                      ::testing::Types<float, double, long double>>::type;
                      ::testing::Types<float, double, long double>>::type;
-TYPED_TEST_CASE(BetaDistributionInterfaceTest, RealTypes);
+TYPED_TEST_SUITE(BetaDistributionInterfaceTest, RealTypes);
 
 
 TYPED_TEST(BetaDistributionInterfaceTest, SerializeTest) {
 TYPED_TEST(BetaDistributionInterfaceTest, SerializeTest) {
   // The threshold for whether std::exp(1/a) is finite.
   // The threshold for whether std::exp(1/a) is finite.
@@ -431,13 +431,13 @@ std::string ParamName(
   return absl::StrReplaceAll(name, {{"+", "_"}, {"-", "_"}, {".", "_"}});
   return absl::StrReplaceAll(name, {{"+", "_"}, {"-", "_"}, {".", "_"}});
 }
 }
 
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     TestSampleStatisticsCombinations, BetaDistributionTest,
     TestSampleStatisticsCombinations, BetaDistributionTest,
     ::testing::Combine(::testing::Values(0.1, 0.2, 0.9, 1.1, 2.5, 10.0, 123.4),
     ::testing::Combine(::testing::Values(0.1, 0.2, 0.9, 1.1, 2.5, 10.0, 123.4),
                        ::testing::Values(0.1, 0.2, 0.9, 1.1, 2.5, 10.0, 123.4)),
                        ::testing::Values(0.1, 0.2, 0.9, 1.1, 2.5, 10.0, 123.4)),
     ParamName);
     ParamName);
 
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     TestSampleStatistics_SelectedPairs, BetaDistributionTest,
     TestSampleStatistics_SelectedPairs, BetaDistributionTest,
     ::testing::Values(std::make_pair(0.5, 1000), std::make_pair(1000, 0.5),
     ::testing::Values(std::make_pair(0.5, 1000), std::make_pair(1000, 0.5),
                       std::make_pair(900, 1000), std::make_pair(10000, 20000),
                       std::make_pair(900, 1000), std::make_pair(10000, 20000),

absl/random/exponential_distribution_test.cc

@@ -58,7 +58,7 @@ using RealTypes =
     std::conditional<absl::numeric_internal::IsDoubleDouble(),
     std::conditional<absl::numeric_internal::IsDoubleDouble(),
                      ::testing::Types<float, double>,
                      ::testing::Types<float, double>,
                      ::testing::Types<float, double, long double>>::type;
                      ::testing::Types<float, double, long double>>::type;
-TYPED_TEST_CASE(ExponentialDistributionTypedTest, RealTypes);
+TYPED_TEST_SUITE(ExponentialDistributionTypedTest, RealTypes);
 
 
 TYPED_TEST(ExponentialDistributionTypedTest, SerializeTest) {
 TYPED_TEST(ExponentialDistributionTypedTest, SerializeTest) {
   using param_type =
   using param_type =
@@ -343,7 +343,7 @@ std::string ParamName(const ::testing::TestParamInfo<Param>& info) {
   return absl::StrReplaceAll(name, {{"+", "_"}, {"-", "_"}, {".", "_"}});
   return absl::StrReplaceAll(name, {{"+", "_"}, {"-", "_"}, {".", "_"}});
 }
 }
 
 
-INSTANTIATE_TEST_CASE_P(All, ExponentialDistributionTests,
+INSTANTIATE_TEST_SUITE_P(All, ExponentialDistributionTests,
                          ::testing::ValuesIn(GenParams()), ParamName);
                          ::testing::ValuesIn(GenParams()), ParamName);
 
 
 // NOTE: absl::exponential_distribution is not guaranteed to be stable.
 // NOTE: absl::exponential_distribution is not guaranteed to be stable.

absl/random/gaussian_distribution_test.cc

@@ -54,7 +54,7 @@ using RealTypes =
     std::conditional<absl::numeric_internal::IsDoubleDouble(),
     std::conditional<absl::numeric_internal::IsDoubleDouble(),
                      ::testing::Types<float, double>,
                      ::testing::Types<float, double>,
                      ::testing::Types<float, double, long double>>::type;
                      ::testing::Types<float, double, long double>>::type;
-TYPED_TEST_CASE(GaussianDistributionInterfaceTest, RealTypes);
+TYPED_TEST_SUITE(GaussianDistributionInterfaceTest, RealTypes);
 
 
 TYPED_TEST(GaussianDistributionInterfaceTest, SerializeTest) {
 TYPED_TEST(GaussianDistributionInterfaceTest, SerializeTest) {
   using param_type =
   using param_type =

absl/random/log_uniform_int_distribution_test.cc

@@ -42,7 +42,7 @@ class LogUniformIntDistributionTypeTest : public ::testing::Test {};
 
 
 using IntTypes = ::testing::Types<int8_t, int16_t, int32_t, int64_t,  //
 using IntTypes = ::testing::Types<int8_t, int16_t, int32_t, int64_t,  //
                                   uint8_t, uint16_t, uint32_t, uint64_t>;
                                   uint8_t, uint16_t, uint32_t, uint64_t>;
-TYPED_TEST_CASE(LogUniformIntDistributionTypeTest, IntTypes);
+TYPED_TEST_SUITE(LogUniformIntDistributionTypeTest, IntTypes);
 
 
 TYPED_TEST(LogUniformIntDistributionTypeTest, SerializeTest) {
 TYPED_TEST(LogUniformIntDistributionTypeTest, SerializeTest) {
   using param_type =
   using param_type =

absl/random/poisson_distribution_test.cc

@@ -73,7 +73,7 @@ class PoissonDistributionInterfaceTest : public ::testing::Test {};
 
 
 using IntTypes = ::testing::Types<int, int8_t, int16_t, int32_t, int64_t,
 using IntTypes = ::testing::Types<int, int8_t, int16_t, int32_t, int64_t,
                                   uint8_t, uint16_t, uint32_t, uint64_t>;
                                   uint8_t, uint16_t, uint32_t, uint64_t>;
-TYPED_TEST_CASE(PoissonDistributionInterfaceTest, IntTypes);
+TYPED_TEST_SUITE(PoissonDistributionInterfaceTest, IntTypes);
 
 
 TYPED_TEST(PoissonDistributionInterfaceTest, SerializeTest) {
 TYPED_TEST(PoissonDistributionInterfaceTest, SerializeTest) {
   using param_type = typename absl::poisson_distribution<TypeParam>::param_type;
   using param_type = typename absl::poisson_distribution<TypeParam>::param_type;

absl/random/zipf_distribution_test.cc

@@ -44,7 +44,7 @@ class ZipfDistributionTypedTest : public ::testing::Test {};
 
 
 using IntTypes = ::testing::Types<int, int8_t, int16_t, int32_t, int64_t,
 using IntTypes = ::testing::Types<int, int8_t, int16_t, int32_t, int64_t,
                                   uint8_t, uint16_t, uint32_t, uint64_t>;
                                   uint8_t, uint16_t, uint32_t, uint64_t>;
-TYPED_TEST_CASE(ZipfDistributionTypedTest, IntTypes);
+TYPED_TEST_SUITE(ZipfDistributionTypedTest, IntTypes);
 
 
 TYPED_TEST(ZipfDistributionTypedTest, SerializeTest) {
 TYPED_TEST(ZipfDistributionTypedTest, SerializeTest) {
   using param_type = typename absl::zipf_distribution<TypeParam>::param_type;
   using param_type = typename absl::zipf_distribution<TypeParam>::param_type;

absl/strings/internal/str_format/convert_test.cc

@@ -473,7 +473,7 @@ TYPED_TEST_P(TypedFormatConvertTest, Char) {
   }
   }
 }
 }
 
 
-REGISTER_TYPED_TEST_CASE_P(TypedFormatConvertTest, AllIntsWithFlags, Char);
+REGISTER_TYPED_TEST_SUITE_P(TypedFormatConvertTest, AllIntsWithFlags, Char);
 
 
 typedef ::testing::Types<
 typedef ::testing::Types<
     int, unsigned, volatile int,
     int, unsigned, volatile int,
@@ -482,7 +482,7 @@ typedef ::testing::Types<
     long long, unsigned long long,
     long long, unsigned long long,
     signed char, unsigned char, char>
     signed char, unsigned char, char>
     AllIntTypes;
     AllIntTypes;
-INSTANTIATE_TYPED_TEST_CASE_P(TypedFormatConvertTestWithAllIntTypes,
+INSTANTIATE_TYPED_TEST_SUITE_P(TypedFormatConvertTestWithAllIntTypes,
                                TypedFormatConvertTest, AllIntTypes);
                                TypedFormatConvertTest, AllIntTypes);
 TEST_F(FormatConvertTest, VectorBool) {
 TEST_F(FormatConvertTest, VectorBool) {
   // Make sure vector<bool>'s values behave as bools.
   // Make sure vector<bool>'s values behave as bools.