Export of internal Abseil changes

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

Internal change

PiperOrigin-RevId: 424639048

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

Disable tests Table.EnsureNonQuadraticTopNXorSeedByProbeSeqLength and Table.EnsureNonQuadraticTopNLinearTransformByProbeSeqLength again
as they are (still) flaky

PiperOrigin-RevId: 424616745

--
e624119171d9bceec2f6df023b220a6642070cfb by Abseil Team <absl-team@google.com>:

Switch from *_TEST_CASE_P to *_TEST_SUITE_P gtest macros.

PiperOrigin-RevId: 424404790

--
a110698c10554fb1f640412db8cd7c5a38b7b8e8 by Abseil Team <absl-team@google.com>:

Remove extraneous newline in documentation.

PiperOrigin-RevId: 424328502
GitOrigin-RevId: 7fbe730c56c0890f27df47f9ad4f0cfa600c6ad9
Change-Id: I56fd8c7cecf65fe37cb4cf2dde70842867d637d7

absl/container/internal/raw_hash_set_test.cc

@@ -1258,7 +1258,8 @@ ExpectedStats XorSeedExpectedStats() {
   return {};
   return {};
 }
 }
 
 
-TEST(Table, EnsureNonQuadraticTopNXorSeedByProbeSeqLength) {
+// TODO(b/80415403): Figure out why this test is so flaky, esp. on MSVC
+TEST(Table, DISABLED_EnsureNonQuadraticTopNXorSeedByProbeSeqLength) {
   ProbeStatsPerSize stats;
   ProbeStatsPerSize stats;
   std::vector<size_t> sizes = {Group::kWidth << 5, Group::kWidth << 10};
   std::vector<size_t> sizes = {Group::kWidth << 5, Group::kWidth << 10};
   for (size_t size : sizes) {
   for (size_t size : sizes) {
@@ -1352,7 +1353,8 @@ ExpectedStats LinearTransformExpectedStats() {
   return {};
   return {};
 }
 }
 
 
-TEST(Table, EnsureNonQuadraticTopNLinearTransformByProbeSeqLength) {
+// TODO(b/80415403): Figure out why this test is so flaky.
+TEST(Table, DISABLED_EnsureNonQuadraticTopNLinearTransformByProbeSeqLength) {
   ProbeStatsPerSize stats;
   ProbeStatsPerSize stats;
   std::vector<size_t> sizes = {Group::kWidth << 5, Group::kWidth << 10};
   std::vector<size_t> sizes = {Group::kWidth << 5, Group::kWidth << 10};
   for (size_t size : sizes) {
   for (size_t size : sizes) {

absl/hash/hash_test.cc

@@ -139,10 +139,10 @@ TYPED_TEST_P(HashValueIntTest, FastPath) {
             absl::Hash<std::tuple<TypeParam>>{}(std::tuple<TypeParam>(n)));
             absl::Hash<std::tuple<TypeParam>>{}(std::tuple<TypeParam>(n)));
 }
 }
 
 
-REGISTER_TYPED_TEST_CASE_P(HashValueIntTest, BasicUsage, FastPath);
+REGISTER_TYPED_TEST_SUITE_P(HashValueIntTest, BasicUsage, FastPath);
 using IntTypes = testing::Types<unsigned char, char, int, int32_t, int64_t,
 using IntTypes = testing::Types<unsigned char, char, int, int32_t, int64_t,
                                 uint32_t, uint64_t, size_t>;
                                 uint32_t, uint64_t, size_t>;
-INSTANTIATE_TYPED_TEST_CASE_P(My, HashValueIntTest, IntTypes);
+INSTANTIATE_TYPED_TEST_SUITE_P(My, HashValueIntTest, IntTypes);
 
 
 enum LegacyEnum { kValue1, kValue2, kValue3 };
 enum LegacyEnum { kValue1, kValue2, kValue3 };
 
 
@@ -507,7 +507,7 @@ TYPED_TEST_P(HashValueSequenceTest, BasicUsage) {
   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(exemplars));
   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(exemplars));
 }
 }
 
 
-REGISTER_TYPED_TEST_CASE_P(HashValueSequenceTest, BasicUsage);
+REGISTER_TYPED_TEST_SUITE_P(HashValueSequenceTest, BasicUsage);
 using IntSequenceTypes = testing::Types<
 using IntSequenceTypes = testing::Types<
     std::deque<int>, std::forward_list<int>, std::list<int>, std::vector<int>,
     std::deque<int>, std::forward_list<int>, std::list<int>, std::vector<int>,
     std::vector<bool>, TypeErasedContainer<std::vector<int>>, std::set<int>,
     std::vector<bool>, TypeErasedContainer<std::vector<int>>, std::set<int>,
@@ -515,7 +515,7 @@ using IntSequenceTypes = testing::Types<
     TypeErasedContainer<UnorderedSequence<int>>, std::unordered_set<int>,
     TypeErasedContainer<UnorderedSequence<int>>, std::unordered_set<int>,
     std::unordered_multiset<int>, absl::flat_hash_set<int>,
     std::unordered_multiset<int>, absl::flat_hash_set<int>,
     absl::node_hash_set<int>, absl::btree_set<int>>;
     absl::node_hash_set<int>, absl::btree_set<int>>;
-INSTANTIATE_TYPED_TEST_CASE_P(My, HashValueSequenceTest, IntSequenceTypes);
+INSTANTIATE_TYPED_TEST_SUITE_P(My, HashValueSequenceTest, IntSequenceTypes);
 
 
 template <typename T>
 template <typename T>
 class HashValueNestedSequenceTest : public testing::Test {};
 class HashValueNestedSequenceTest : public testing::Test {};
@@ -541,7 +541,7 @@ TYPED_TEST_P(HashValueNestedSequenceTest, BasicUsage) {
   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(exemplars));
   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(exemplars));
 }
 }
 
 
-REGISTER_TYPED_TEST_CASE_P(HashValueNestedSequenceTest, BasicUsage);
+REGISTER_TYPED_TEST_SUITE_P(HashValueNestedSequenceTest, BasicUsage);
 template <typename T>
 template <typename T>
 using TypeErasedSet = TypeErasedContainer<UnorderedSequence<T>>;
 using TypeErasedSet = TypeErasedContainer<UnorderedSequence<T>>;
 
 
@@ -551,7 +551,7 @@ using NestedIntSequenceTypes = testing::Types<
     UnorderedSequence<UnorderedSequence<int>>,
     UnorderedSequence<UnorderedSequence<int>>,
     UnorderedSequence<TypeErasedSet<int>>, TypeErasedSet<std::vector<int>>,
     UnorderedSequence<TypeErasedSet<int>>, TypeErasedSet<std::vector<int>>,
     TypeErasedSet<UnorderedSequence<int>>, TypeErasedSet<TypeErasedSet<int>>>;
     TypeErasedSet<UnorderedSequence<int>>, TypeErasedSet<TypeErasedSet<int>>>;
-INSTANTIATE_TYPED_TEST_CASE_P(My, HashValueNestedSequenceTest,
+INSTANTIATE_TYPED_TEST_SUITE_P(My, HashValueNestedSequenceTest,
                               NestedIntSequenceTypes);
                               NestedIntSequenceTypes);
 
 
 // Private type that only supports AbslHashValue to make sure our chosen hash
 // Private type that only supports AbslHashValue to make sure our chosen hash
@@ -732,13 +732,13 @@ TYPED_TEST_P(HashValueAssociativeMapTest, BasicUsage) {
   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(exemplars));
   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(exemplars));
 }
 }
 
 
-REGISTER_TYPED_TEST_CASE_P(HashValueAssociativeMapTest, BasicUsage);
+REGISTER_TYPED_TEST_SUITE_P(HashValueAssociativeMapTest, BasicUsage);
 using AssociativeMapTypes = testing::Types<
 using AssociativeMapTypes = testing::Types<
     std::map<int, std::string>, std::unordered_map<int, std::string>,
     std::map<int, std::string>, std::unordered_map<int, std::string>,
     absl::flat_hash_map<int, std::string>,
     absl::flat_hash_map<int, std::string>,
     absl::node_hash_map<int, std::string>, absl::btree_map<int, std::string>,
     absl::node_hash_map<int, std::string>, absl::btree_map<int, std::string>,
     UnorderedSequence<std::pair<const int, std::string>>>;
     UnorderedSequence<std::pair<const int, std::string>>>;
-INSTANTIATE_TYPED_TEST_CASE_P(My, HashValueAssociativeMapTest,
+INSTANTIATE_TYPED_TEST_SUITE_P(My, HashValueAssociativeMapTest,
                               AssociativeMapTypes);
                               AssociativeMapTypes);
 
 
 template <typename T>
 template <typename T>
@@ -763,11 +763,11 @@ TYPED_TEST_P(HashValueAssociativeMultimapTest, BasicUsage) {
   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(exemplars));
   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(exemplars));
 }
 }
 
 
-REGISTER_TYPED_TEST_CASE_P(HashValueAssociativeMultimapTest, BasicUsage);
+REGISTER_TYPED_TEST_SUITE_P(HashValueAssociativeMultimapTest, BasicUsage);
 using AssociativeMultimapTypes =
 using AssociativeMultimapTypes =
     testing::Types<std::multimap<int, std::string>,
     testing::Types<std::multimap<int, std::string>,
                    std::unordered_multimap<int, std::string>>;
                    std::unordered_multimap<int, std::string>>;
-INSTANTIATE_TYPED_TEST_CASE_P(My, HashValueAssociativeMultimapTest,
+INSTANTIATE_TYPED_TEST_SUITE_P(My, HashValueAssociativeMultimapTest,
                               AssociativeMultimapTypes);
                               AssociativeMultimapTypes);
 
 
 TEST(HashValueTest, ReferenceWrapper) {
 TEST(HashValueTest, ReferenceWrapper) {
@@ -1007,10 +1007,10 @@ TYPED_TEST_P(HashIntTest, BasicUsage) {
             Hash<CombineVariadic<TypeParam>>()({}));
             Hash<CombineVariadic<TypeParam>>()({}));
 }
 }
 
 
-REGISTER_TYPED_TEST_CASE_P(HashIntTest, BasicUsage);
+REGISTER_TYPED_TEST_SUITE_P(HashIntTest, BasicUsage);
 using IntTypes = testing::Types<unsigned char, char, int, int32_t, int64_t,
 using IntTypes = testing::Types<unsigned char, char, int, int32_t, int64_t,
                                 uint32_t, uint64_t, size_t>;
                                 uint32_t, uint64_t, size_t>;
-INSTANTIATE_TYPED_TEST_CASE_P(My, HashIntTest, IntTypes);
+INSTANTIATE_TYPED_TEST_SUITE_P(My, HashIntTest, IntTypes);
 
 
 struct StructWithPadding {
 struct StructWithPadding {
   char c;
   char c;

absl/strings/internal/str_format/checker.h

@@ -22,7 +22,6 @@
 // Compile time check support for entry points.
 // Compile time check support for entry points.
 
 
 #ifndef ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
 #ifndef ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
-
 // We disable format checker under vscode intellisense compilation.
 // We disable format checker under vscode intellisense compilation.
 // See https://github.com/microsoft/vscode-cpptools/issues/3683 for
 // See https://github.com/microsoft/vscode-cpptools/issues/3683 for
 // more details.
 // more details.

absl/strings/str_split.h

@@ -461,8 +461,7 @@ using EnableSplitIfString =
 // first two split strings become the `std::pair` `.first` and `.second`
 // first two split strings become the `std::pair` `.first` and `.second`
 // members, respectively. The remaining split substrings are discarded. If there
 // members, respectively. The remaining split substrings are discarded. If there
 // are less than two split substrings, the empty string is used for the
 // are less than two split substrings, the empty string is used for the
-// corresponding
-// `std::pair` member.
+// corresponding `std::pair` member.
 //
 //
 // Example:
 // Example:
 //
 //