Fix "unsafe narrowing" warnings in absl, 6/n.

Addresses failures with the following, in some files:
-Wshorten-64-to-32
-Wimplicit-int-conversion
-Wsign-compare
-Wsign-conversion
-Wtautological-unsigned-zero-compare

(This specific CL focuses on .cc files in strings/internal/.)

Bug: chromium:1292951
PiperOrigin-RevId: 470810568
Change-Id: Ibd316a7e62cc43cb198ba22daed565c9573ce235

absl/strings/internal/cord_rep_btree_navigator_test.cc

@@ -48,7 +48,7 @@ using Position = CordRepBtreeNavigator::Position;
 // CordRepBtreeNavigatorTest is a test fixture which automatically creates a
 // CordRepBtreeNavigatorTest is a test fixture which automatically creates a
 // tree to test navigation logic on. The parameter `count' defines the number of
 // tree to test navigation logic on. The parameter `count' defines the number of
 // data edges in the test tree.
 // data edges in the test tree.
-class CordRepBtreeNavigatorTest : public testing::TestWithParam<int> {
+class CordRepBtreeNavigatorTest : public testing::TestWithParam<size_t> {
  public:
  public:
   using Flats = std::vector<CordRep*>;
   using Flats = std::vector<CordRep*>;
   static constexpr size_t kCharsPerFlat = 3;
   static constexpr size_t kCharsPerFlat = 3;
@@ -71,12 +71,12 @@ class CordRepBtreeNavigatorTest : public testing::TestWithParam<int> {
 
 
   ~CordRepBtreeNavigatorTest() override { CordRep::Unref(tree_); }
   ~CordRepBtreeNavigatorTest() override { CordRep::Unref(tree_); }
 
 
-  int count() const { return GetParam(); }
+  size_t count() const { return GetParam(); }
   CordRepBtree* tree() { return tree_; }
   CordRepBtree* tree() { return tree_; }
   const std::string& data() const { return data_; }
   const std::string& data() const { return data_; }
   const std::vector<CordRep*>& flats() const { return flats_; }
   const std::vector<CordRep*>& flats() const { return flats_; }
 
 
-  static std::string ToString(testing::TestParamInfo<int> param) {
+  static std::string ToString(testing::TestParamInfo<size_t> param) {
     return absl::StrCat(param.param, "_Flats");
     return absl::StrCat(param.param, "_Flats");
   }
   }
 
 
@@ -131,15 +131,15 @@ TEST_P(CordRepBtreeNavigatorTest, NextPrev) {
 
 
   EXPECT_THAT(nav.Previous(), Eq(nullptr));
   EXPECT_THAT(nav.Previous(), Eq(nullptr));
   EXPECT_THAT(nav.Current(), Eq(flats.front()));
   EXPECT_THAT(nav.Current(), Eq(flats.front()));
-  for (int i = 1; i < flats.size(); ++i) {
+  for (size_t i = 1; i < flats.size(); ++i) {
     ASSERT_THAT(nav.Next(), Eq(flats[i]));
     ASSERT_THAT(nav.Next(), Eq(flats[i]));
     EXPECT_THAT(nav.Current(), Eq(flats[i]));
     EXPECT_THAT(nav.Current(), Eq(flats[i]));
   }
   }
   EXPECT_THAT(nav.Next(), Eq(nullptr));
   EXPECT_THAT(nav.Next(), Eq(nullptr));
   EXPECT_THAT(nav.Current(), Eq(flats.back()));
   EXPECT_THAT(nav.Current(), Eq(flats.back()));
-  for (int i = static_cast<int>(flats.size()) - 2; i >= 0; --i) {
-    ASSERT_THAT(nav.Previous(), Eq(flats[i]));
-    EXPECT_THAT(nav.Current(), Eq(flats[i]));
+  for (size_t i = flats.size() - 1; i > 0; --i) {
+    ASSERT_THAT(nav.Previous(), Eq(flats[i - 1]));
+    EXPECT_THAT(nav.Current(), Eq(flats[i - 1]));
   }
   }
   EXPECT_THAT(nav.Previous(), Eq(nullptr));
   EXPECT_THAT(nav.Previous(), Eq(nullptr));
   EXPECT_THAT(nav.Current(), Eq(flats.front()));
   EXPECT_THAT(nav.Current(), Eq(flats.front()));
@@ -152,13 +152,13 @@ TEST_P(CordRepBtreeNavigatorTest, PrevNext) {
 
 
   EXPECT_THAT(nav.Next(), Eq(nullptr));
   EXPECT_THAT(nav.Next(), Eq(nullptr));
   EXPECT_THAT(nav.Current(), Eq(flats.back()));
   EXPECT_THAT(nav.Current(), Eq(flats.back()));
-  for (int i = static_cast<int>(flats.size()) - 2; i >= 0; --i) {
-    ASSERT_THAT(nav.Previous(), Eq(flats[i]));
-    EXPECT_THAT(nav.Current(), Eq(flats[i]));
+  for (size_t i = flats.size() - 1; i > 0; --i) {
+    ASSERT_THAT(nav.Previous(), Eq(flats[i - 1]));
+    EXPECT_THAT(nav.Current(), Eq(flats[i - 1]));
   }
   }
   EXPECT_THAT(nav.Previous(), Eq(nullptr));
   EXPECT_THAT(nav.Previous(), Eq(nullptr));
   EXPECT_THAT(nav.Current(), Eq(flats.front()));
   EXPECT_THAT(nav.Current(), Eq(flats.front()));
-  for (int i = 1; i < flats.size(); ++i) {
+  for (size_t i = 1; i < flats.size(); ++i) {
     ASSERT_THAT(nav.Next(), Eq(flats[i]));
     ASSERT_THAT(nav.Next(), Eq(flats[i]));
     EXPECT_THAT(nav.Current(), Eq(flats[i]));
     EXPECT_THAT(nav.Current(), Eq(flats[i]));
   }
   }
@@ -180,21 +180,21 @@ TEST(CordRepBtreeNavigatorTest, Reset) {
 }
 }
 
 
 TEST_P(CordRepBtreeNavigatorTest, Skip) {
 TEST_P(CordRepBtreeNavigatorTest, Skip) {
-  int count = this->count();
+  size_t count = this->count();
   const Flats& flats = this->flats();
   const Flats& flats = this->flats();
   CordRepBtreeNavigator nav;
   CordRepBtreeNavigator nav;
   nav.InitFirst(tree());
   nav.InitFirst(tree());
 
 
-  for (int char_offset = 0; char_offset < kCharsPerFlat; ++char_offset) {
+  for (size_t char_offset = 0; char_offset < kCharsPerFlat; ++char_offset) {
     Position pos = nav.Skip(char_offset);
     Position pos = nav.Skip(char_offset);
     EXPECT_THAT(pos.edge, Eq(nav.Current()));
     EXPECT_THAT(pos.edge, Eq(nav.Current()));
     EXPECT_THAT(pos.edge, Eq(flats[0]));
     EXPECT_THAT(pos.edge, Eq(flats[0]));
     EXPECT_THAT(pos.offset, Eq(char_offset));
     EXPECT_THAT(pos.offset, Eq(char_offset));
   }
   }
 
 
-  for (int index1 = 0; index1 < count; ++index1) {
-    for (int index2 = index1; index2 < count; ++index2) {
-      for (int char_offset = 0; char_offset < kCharsPerFlat; ++char_offset) {
+  for (size_t index1 = 0; index1 < count; ++index1) {
+    for (size_t index2 = index1; index2 < count; ++index2) {
+      for (size_t char_offset = 0; char_offset < kCharsPerFlat; ++char_offset) {
         CordRepBtreeNavigator nav;
         CordRepBtreeNavigator nav;
         nav.InitFirst(tree());
         nav.InitFirst(tree());
 
 
@@ -215,20 +215,20 @@ TEST_P(CordRepBtreeNavigatorTest, Skip) {
 }
 }
 
 
 TEST_P(CordRepBtreeNavigatorTest, Seek) {
 TEST_P(CordRepBtreeNavigatorTest, Seek) {
-  int count = this->count();
+  size_t count = this->count();
   const Flats& flats = this->flats();
   const Flats& flats = this->flats();
   CordRepBtreeNavigator nav;
   CordRepBtreeNavigator nav;
   nav.InitFirst(tree());
   nav.InitFirst(tree());
 
 
-  for (int char_offset = 0; char_offset < kCharsPerFlat; ++char_offset) {
+  for (size_t char_offset = 0; char_offset < kCharsPerFlat; ++char_offset) {
     Position pos = nav.Seek(char_offset);
     Position pos = nav.Seek(char_offset);
     EXPECT_THAT(pos.edge, Eq(nav.Current()));
     EXPECT_THAT(pos.edge, Eq(nav.Current()));
     EXPECT_THAT(pos.edge, Eq(flats[0]));
     EXPECT_THAT(pos.edge, Eq(flats[0]));
     EXPECT_THAT(pos.offset, Eq(char_offset));
     EXPECT_THAT(pos.offset, Eq(char_offset));
   }
   }
 
 
-  for (int index = 0; index < count; ++index) {
-    for (int char_offset = 0; char_offset < kCharsPerFlat; ++char_offset) {
+  for (size_t index = 0; index < count; ++index) {
+    for (size_t char_offset = 0; char_offset < kCharsPerFlat; ++char_offset) {
       size_t offset = index * kCharsPerFlat + char_offset;
       size_t offset = index * kCharsPerFlat + char_offset;
       Position pos1 = nav.Seek(offset);
       Position pos1 = nav.Seek(offset);
       ASSERT_THAT(pos1.edge, Eq(flats[index]));
       ASSERT_THAT(pos1.edge, Eq(flats[index]));
@@ -249,7 +249,7 @@ TEST(CordRepBtreeNavigatorTest, InitOffset) {
   EXPECT_THAT(nav.btree(), Eq(tree));
   EXPECT_THAT(nav.btree(), Eq(tree));
   EXPECT_THAT(pos.edge, Eq(tree->Edges()[1]));
   EXPECT_THAT(pos.edge, Eq(tree->Edges()[1]));
   EXPECT_THAT(pos.edge, Eq(nav.Current()));
   EXPECT_THAT(pos.edge, Eq(nav.Current()));
-  EXPECT_THAT(pos.offset, Eq(2));
+  EXPECT_THAT(pos.offset, Eq(2u));
   CordRep::Unref(tree);
   CordRep::Unref(tree);
 }
 }
 
 

absl/strings/internal/cord_rep_btree_reader_test.cc

@@ -50,9 +50,9 @@ using ReadResult = CordRepBtreeReader::ReadResult;
 TEST(CordRepBtreeReaderTest, Next) {
 TEST(CordRepBtreeReaderTest, Next) {
   constexpr size_t kChars = 3;
   constexpr size_t kChars = 3;
   const size_t cap = CordRepBtree::kMaxCapacity;
   const size_t cap = CordRepBtree::kMaxCapacity;
-  int counts[] = {1, 2, cap, cap * cap, cap * cap + 1, cap * cap * 2 + 17};
+  size_t counts[] = {1, 2, cap, cap * cap, cap * cap + 1, cap * cap * 2 + 17};
 
 
-  for (int count : counts) {
+  for (size_t count : counts) {
     std::string data = CreateRandomString(count * kChars);
     std::string data = CreateRandomString(count * kChars);
     std::vector<CordRep*> flats = CreateFlatsFromString(data, kChars);
     std::vector<CordRep*> flats = CreateFlatsFromString(data, kChars);
     CordRepBtree* node = CordRepBtreeFromFlats(flats);
     CordRepBtree* node = CordRepBtreeFromFlats(flats);
@@ -74,7 +74,7 @@ TEST(CordRepBtreeReaderTest, Next) {
       EXPECT_THAT(reader.remaining(), Eq(remaining));
       EXPECT_THAT(reader.remaining(), Eq(remaining));
     }
     }
 
 
-    EXPECT_THAT(reader.remaining(), Eq(0));
+    EXPECT_THAT(reader.remaining(), Eq(0u));
 
 
     // Verify trying to read beyond EOF returns empty string_view
     // Verify trying to read beyond EOF returns empty string_view
     EXPECT_THAT(reader.Next(), testing::IsEmpty());
     EXPECT_THAT(reader.Next(), testing::IsEmpty());
@@ -86,9 +86,9 @@ TEST(CordRepBtreeReaderTest, Next) {
 TEST(CordRepBtreeReaderTest, Skip) {
 TEST(CordRepBtreeReaderTest, Skip) {
   constexpr size_t kChars = 3;
   constexpr size_t kChars = 3;
   const size_t cap = CordRepBtree::kMaxCapacity;
   const size_t cap = CordRepBtree::kMaxCapacity;
-  int counts[] = {1, 2, cap, cap * cap, cap * cap + 1, cap * cap * 2 + 17};
+  size_t counts[] = {1, 2, cap, cap * cap, cap * cap + 1, cap * cap * 2 + 17};
 
 
-  for (int count : counts) {
+  for (size_t count : counts) {
     std::string data = CreateRandomString(count * kChars);
     std::string data = CreateRandomString(count * kChars);
     std::vector<CordRep*> flats = CreateFlatsFromString(data, kChars);
     std::vector<CordRep*> flats = CreateFlatsFromString(data, kChars);
     CordRepBtree* node = CordRepBtreeFromFlats(flats);
     CordRepBtree* node = CordRepBtreeFromFlats(flats);
@@ -125,16 +125,16 @@ TEST(CordRepBtreeReaderTest, SkipBeyondLength) {
   CordRepBtreeReader reader;
   CordRepBtreeReader reader;
   reader.Init(tree);
   reader.Init(tree);
   EXPECT_THAT(reader.Skip(100), IsEmpty());
   EXPECT_THAT(reader.Skip(100), IsEmpty());
-  EXPECT_THAT(reader.remaining(), Eq(0));
+  EXPECT_THAT(reader.remaining(), Eq(0u));
   CordRep::Unref(tree);
   CordRep::Unref(tree);
 }
 }
 
 
 TEST(CordRepBtreeReaderTest, Seek) {
 TEST(CordRepBtreeReaderTest, Seek) {
   constexpr size_t kChars = 3;
   constexpr size_t kChars = 3;
   const size_t cap = CordRepBtree::kMaxCapacity;
   const size_t cap = CordRepBtree::kMaxCapacity;
-  int counts[] = {1, 2, cap, cap * cap, cap * cap + 1, cap * cap * 2 + 17};
+  size_t counts[] = {1, 2, cap, cap * cap, cap * cap + 1, cap * cap * 2 + 17};
 
 
-  for (int count : counts) {
+  for (size_t count : counts) {
     std::string data = CreateRandomString(count * kChars);
     std::string data = CreateRandomString(count * kChars);
     std::vector<CordRep*> flats = CreateFlatsFromString(data, kChars);
     std::vector<CordRep*> flats = CreateFlatsFromString(data, kChars);
     CordRepBtree* node = CordRepBtreeFromFlats(flats);
     CordRepBtree* node = CordRepBtreeFromFlats(flats);
@@ -159,9 +159,9 @@ TEST(CordRepBtreeReaderTest, SeekBeyondLength) {
   CordRepBtreeReader reader;
   CordRepBtreeReader reader;
   reader.Init(tree);
   reader.Init(tree);
   EXPECT_THAT(reader.Seek(6), IsEmpty());
   EXPECT_THAT(reader.Seek(6), IsEmpty());
-  EXPECT_THAT(reader.remaining(), Eq(0));
+  EXPECT_THAT(reader.remaining(), Eq(0u));
   EXPECT_THAT(reader.Seek(100), IsEmpty());
   EXPECT_THAT(reader.Seek(100), IsEmpty());
-  EXPECT_THAT(reader.remaining(), Eq(0));
+  EXPECT_THAT(reader.remaining(), Eq(0u));
   CordRep::Unref(tree);
   CordRep::Unref(tree);
 }
 }
 
 
@@ -179,7 +179,7 @@ TEST(CordRepBtreeReaderTest, Read) {
   chunk = reader.Read(0, chunk.length(), tree);
   chunk = reader.Read(0, chunk.length(), tree);
   EXPECT_THAT(tree, Eq(nullptr));
   EXPECT_THAT(tree, Eq(nullptr));
   EXPECT_THAT(chunk, Eq("abcde"));
   EXPECT_THAT(chunk, Eq("abcde"));
-  EXPECT_THAT(reader.remaining(), Eq(10));
+  EXPECT_THAT(reader.remaining(), Eq(10u));
   EXPECT_THAT(reader.Next(), Eq("fghij"));
   EXPECT_THAT(reader.Next(), Eq("fghij"));
 
 
   // Read in full
   // Read in full
@@ -188,7 +188,7 @@ TEST(CordRepBtreeReaderTest, Read) {
   EXPECT_THAT(tree, Ne(nullptr));
   EXPECT_THAT(tree, Ne(nullptr));
   EXPECT_THAT(CordToString(tree), Eq("abcdefghijklmno"));
   EXPECT_THAT(CordToString(tree), Eq("abcdefghijklmno"));
   EXPECT_THAT(chunk, Eq(""));
   EXPECT_THAT(chunk, Eq(""));
-  EXPECT_THAT(reader.remaining(), Eq(0));
+  EXPECT_THAT(reader.remaining(), Eq(0u));
   CordRep::Unref(tree);
   CordRep::Unref(tree);
 
 
   // Read < chunk bytes
   // Read < chunk bytes
@@ -197,7 +197,7 @@ TEST(CordRepBtreeReaderTest, Read) {
   ASSERT_THAT(tree, Ne(nullptr));
   ASSERT_THAT(tree, Ne(nullptr));
   EXPECT_THAT(CordToString(tree), Eq("abc"));
   EXPECT_THAT(CordToString(tree), Eq("abc"));
   EXPECT_THAT(chunk, Eq("de"));
   EXPECT_THAT(chunk, Eq("de"));
-  EXPECT_THAT(reader.remaining(), Eq(10));
+  EXPECT_THAT(reader.remaining(), Eq(10u));
   EXPECT_THAT(reader.Next(), Eq("fghij"));
   EXPECT_THAT(reader.Next(), Eq("fghij"));
   CordRep::Unref(tree);
   CordRep::Unref(tree);
 
 
@@ -207,7 +207,7 @@ TEST(CordRepBtreeReaderTest, Read) {
   ASSERT_THAT(tree, Ne(nullptr));
   ASSERT_THAT(tree, Ne(nullptr));
   EXPECT_THAT(CordToString(tree), Eq("cd"));
   EXPECT_THAT(CordToString(tree), Eq("cd"));
   EXPECT_THAT(chunk, Eq("e"));
   EXPECT_THAT(chunk, Eq("e"));
-  EXPECT_THAT(reader.remaining(), Eq(10));
+  EXPECT_THAT(reader.remaining(), Eq(10u));
   EXPECT_THAT(reader.Next(), Eq("fghij"));
   EXPECT_THAT(reader.Next(), Eq("fghij"));
   CordRep::Unref(tree);
   CordRep::Unref(tree);
 
 
@@ -217,7 +217,7 @@ TEST(CordRepBtreeReaderTest, Read) {
   ASSERT_THAT(tree, Ne(nullptr));
   ASSERT_THAT(tree, Ne(nullptr));
   EXPECT_THAT(CordToString(tree), Eq("fgh"));
   EXPECT_THAT(CordToString(tree), Eq("fgh"));
   EXPECT_THAT(chunk, Eq("ij"));
   EXPECT_THAT(chunk, Eq("ij"));
-  EXPECT_THAT(reader.remaining(), Eq(5));
+  EXPECT_THAT(reader.remaining(), Eq(5u));
   EXPECT_THAT(reader.Next(), Eq("klmno"));
   EXPECT_THAT(reader.Next(), Eq("klmno"));
   CordRep::Unref(tree);
   CordRep::Unref(tree);
 
 
@@ -227,7 +227,7 @@ TEST(CordRepBtreeReaderTest, Read) {
   ASSERT_THAT(tree, Ne(nullptr));
   ASSERT_THAT(tree, Ne(nullptr));
   EXPECT_THAT(CordToString(tree), Eq("cdefghijklmn"));
   EXPECT_THAT(CordToString(tree), Eq("cdefghijklmn"));
   EXPECT_THAT(chunk, Eq("o"));
   EXPECT_THAT(chunk, Eq("o"));
-  EXPECT_THAT(reader.remaining(), Eq(0));
+  EXPECT_THAT(reader.remaining(), Eq(0u));
   CordRep::Unref(tree);
   CordRep::Unref(tree);
 
 
   // Read across chunks landing on exact edge boundary
   // Read across chunks landing on exact edge boundary
@@ -236,7 +236,7 @@ TEST(CordRepBtreeReaderTest, Read) {
   ASSERT_THAT(tree, Ne(nullptr));
   ASSERT_THAT(tree, Ne(nullptr));
   EXPECT_THAT(CordToString(tree), Eq("cdefghij"));
   EXPECT_THAT(CordToString(tree), Eq("cdefghij"));
   EXPECT_THAT(chunk, Eq("klmno"));
   EXPECT_THAT(chunk, Eq("klmno"));
-  EXPECT_THAT(reader.remaining(), Eq(0));
+  EXPECT_THAT(reader.remaining(), Eq(0u));
   CordRep::Unref(tree);
   CordRep::Unref(tree);
 
 
   CordRep::Unref(node);
   CordRep::Unref(node);
@@ -245,9 +245,9 @@ TEST(CordRepBtreeReaderTest, Read) {
 TEST(CordRepBtreeReaderTest, ReadExhaustive) {
 TEST(CordRepBtreeReaderTest, ReadExhaustive) {
   constexpr size_t kChars = 3;
   constexpr size_t kChars = 3;
   const size_t cap = CordRepBtree::kMaxCapacity;
   const size_t cap = CordRepBtree::kMaxCapacity;
-  int counts[] = {1, 2, cap, cap * cap + 1, cap * cap * cap * 2 + 17};
+  size_t counts[] = {1, 2, cap, cap * cap + 1, cap * cap * cap * 2 + 17};
 
 
-  for (int count : counts) {
+  for (size_t count : counts) {
     std::string data = CreateRandomString(count * kChars);
     std::string data = CreateRandomString(count * kChars);
     std::vector<CordRep*> flats = CreateFlatsFromString(data, kChars);
     std::vector<CordRep*> flats = CreateFlatsFromString(data, kChars);
     CordRepBtree* node = CordRepBtreeFromFlats(flats);
     CordRepBtree* node = CordRepBtreeFromFlats(flats);

absl/strings/internal/cord_rep_btree_test.cc

@@ -284,13 +284,14 @@ INSTANTIATE_TEST_SUITE_P(WithParam, CordRepBtreeDualTest,
 TEST(CordRepBtreeTest, SizeIsMultipleOf64) {
 TEST(CordRepBtreeTest, SizeIsMultipleOf64) {
   // Only enforce for fully 64-bit platforms.
   // Only enforce for fully 64-bit platforms.
   if (sizeof(size_t) == 8 && sizeof(void*) == 8) {
   if (sizeof(size_t) == 8 && sizeof(void*) == 8) {
-    EXPECT_THAT(sizeof(CordRepBtree) % 64, Eq(0)) << "Should be multiple of 64";
+    EXPECT_THAT(sizeof(CordRepBtree) % 64, Eq(0u))
+        << "Should be multiple of 64";
   }
   }
 }
 }
 
 
 TEST(CordRepBtreeTest, NewDestroyEmptyTree) {
 TEST(CordRepBtreeTest, NewDestroyEmptyTree) {
   auto* tree = CordRepBtree::New();
   auto* tree = CordRepBtree::New();
-  EXPECT_THAT(tree->size(), Eq(0));
+  EXPECT_THAT(tree->size(), Eq(0u));
   EXPECT_THAT(tree->height(), Eq(0));
   EXPECT_THAT(tree->height(), Eq(0));
   EXPECT_THAT(tree->Edges(), ElementsAre());
   EXPECT_THAT(tree->Edges(), ElementsAre());
   CordRepBtree::Destroy(tree);
   CordRepBtree::Destroy(tree);
@@ -298,7 +299,7 @@ TEST(CordRepBtreeTest, NewDestroyEmptyTree) {
 
 
 TEST(CordRepBtreeTest, NewDestroyEmptyTreeAtHeight) {
 TEST(CordRepBtreeTest, NewDestroyEmptyTreeAtHeight) {
   auto* tree = CordRepBtree::New(3);
   auto* tree = CordRepBtree::New(3);
-  EXPECT_THAT(tree->size(), Eq(0));
+  EXPECT_THAT(tree->size(), Eq(0u));
   EXPECT_THAT(tree->height(), Eq(3));
   EXPECT_THAT(tree->height(), Eq(3));
   EXPECT_THAT(tree->Edges(), ElementsAre());
   EXPECT_THAT(tree->Edges(), ElementsAre());
   CordRepBtree::Destroy(tree);
   CordRepBtree::Destroy(tree);
@@ -356,7 +357,7 @@ TEST(CordRepBtreeTest, EdgeData) {
 TEST(CordRepBtreeTest, CreateUnrefLeaf) {
 TEST(CordRepBtreeTest, CreateUnrefLeaf) {
   auto* flat = MakeFlat("a");
   auto* flat = MakeFlat("a");
   auto* leaf = CordRepBtree::Create(flat);
   auto* leaf = CordRepBtree::Create(flat);
-  EXPECT_THAT(leaf->size(), Eq(1));
+  EXPECT_THAT(leaf->size(), Eq(1u));
   EXPECT_THAT(leaf->height(), Eq(0));
   EXPECT_THAT(leaf->height(), Eq(0));
   EXPECT_THAT(leaf->Edges(), ElementsAre(flat));
   EXPECT_THAT(leaf->Edges(), ElementsAre(flat));
   CordRepBtree::Unref(leaf);
   CordRepBtree::Unref(leaf);
@@ -365,7 +366,7 @@ TEST(CordRepBtreeTest, CreateUnrefLeaf) {
 TEST(CordRepBtreeTest, NewUnrefNode) {
 TEST(CordRepBtreeTest, NewUnrefNode) {
   auto* leaf = CordRepBtree::Create(MakeFlat("a"));
   auto* leaf = CordRepBtree::Create(MakeFlat("a"));
   CordRepBtree* tree = CordRepBtree::New(leaf);
   CordRepBtree* tree = CordRepBtree::New(leaf);
-  EXPECT_THAT(tree->size(), Eq(1));
+  EXPECT_THAT(tree->size(), Eq(1u));
   EXPECT_THAT(tree->height(), Eq(1));
   EXPECT_THAT(tree->height(), Eq(1));
   EXPECT_THAT(tree->Edges(), ElementsAre(leaf));
   EXPECT_THAT(tree->Edges(), ElementsAre(leaf));
   CordRepBtree::Unref(tree);
   CordRepBtree::Unref(tree);
@@ -653,7 +654,7 @@ TEST_P(CordRepBtreeDualTest, MergeEqualHeightTrees) {
     CordRepBtree* tree = use_append ? CordRepBtree::Append(left, right)
     CordRepBtree* tree = use_append ? CordRepBtree::Append(left, right)
                                     : CordRepBtree::Prepend(right, left);
                                     : CordRepBtree::Prepend(right, left);
     EXPECT_THAT(tree, IsNode(1));
     EXPECT_THAT(tree, IsNode(1));
-    EXPECT_THAT(tree->Edges(), SizeIs(5));
+    EXPECT_THAT(tree->Edges(), SizeIs(5u));
 
 
     // `tree` contains all flats originally belonging to `left` and `right`.
     // `tree` contains all flats originally belonging to `left` and `right`.
     EXPECT_THAT(GetLeafEdges(tree), ElementsAreArray(flats));
     EXPECT_THAT(GetLeafEdges(tree), ElementsAreArray(flats));
@@ -681,7 +682,7 @@ TEST_P(CordRepBtreeDualTest, MergeLeafWithTreeNotExceedingLeafCapacity) {
     CordRepBtree* tree = use_append ? CordRepBtree::Append(left, right)
     CordRepBtree* tree = use_append ? CordRepBtree::Append(left, right)
                                     : CordRepBtree::Prepend(right, left);
                                     : CordRepBtree::Prepend(right, left);
     EXPECT_THAT(tree, IsNode(1));
     EXPECT_THAT(tree, IsNode(1));
-    EXPECT_THAT(tree->Edges(), SizeIs(3));
+    EXPECT_THAT(tree->Edges(), SizeIs(3u));
 
 
     // `tree` contains all flats originally belonging to `left` and `right`.
     // `tree` contains all flats originally belonging to `left` and `right`.
     EXPECT_THAT(GetLeafEdges(tree), ElementsAreArray(flats));
     EXPECT_THAT(GetLeafEdges(tree), ElementsAreArray(flats));
@@ -709,7 +710,7 @@ TEST_P(CordRepBtreeDualTest, MergeLeafWithTreeExceedingLeafCapacity) {
     CordRepBtree* tree = use_append ? CordRepBtree::Append(left, right)
     CordRepBtree* tree = use_append ? CordRepBtree::Append(left, right)
                                     : CordRepBtree::Prepend(right, left);
                                     : CordRepBtree::Prepend(right, left);
     EXPECT_THAT(tree, IsNode(1));
     EXPECT_THAT(tree, IsNode(1));
-    EXPECT_THAT(tree->Edges(), SizeIs(4));
+    EXPECT_THAT(tree->Edges(), SizeIs(4u));
 
 
     // `tree` contains all flats originally belonging to `left` and `right`.
     // `tree` contains all flats originally belonging to `left` and `right`.
     EXPECT_THAT(GetLeafEdges(tree), ElementsAreArray(flats));
     EXPECT_THAT(GetLeafEdges(tree), ElementsAreArray(flats));
@@ -738,7 +739,7 @@ TEST(CordRepBtreeTest, MergeFuzzTest) {
   auto random_leaf_count = [&]() {
   auto random_leaf_count = [&]() {
     std::uniform_int_distribution<int> dist_height(0, 3);
     std::uniform_int_distribution<int> dist_height(0, 3);
     std::uniform_int_distribution<int> dist_leaf(0, max_cap - 1);
     std::uniform_int_distribution<int> dist_leaf(0, max_cap - 1);
-    const size_t height = dist_height(rnd);
+    const int height = dist_height(rnd);
     return (height ? pow(max_cap, height) : 0) + dist_leaf(rnd);
     return (height ? pow(max_cap, height) : 0) + dist_leaf(rnd);
   };
   };
 
 
@@ -749,14 +750,16 @@ TEST(CordRepBtreeTest, MergeFuzzTest) {
     CordRepBtree* left = MakeTree(random_leaf_count(), coin_flip(rnd));
     CordRepBtree* left = MakeTree(random_leaf_count(), coin_flip(rnd));
     GetLeafEdges(left, flats);
     GetLeafEdges(left, flats);
     if (dice_throw(rnd) == 1) {
     if (dice_throw(rnd) == 1) {
-      std::uniform_int_distribution<int> dist(0, left->height());
+      std::uniform_int_distribution<size_t> dist(
+          0, static_cast<size_t>(left->height()));
       RefEdgesAt(dist(rnd), refs, left);
       RefEdgesAt(dist(rnd), refs, left);
     }
     }
 
 
     CordRepBtree* right = MakeTree(random_leaf_count(), coin_flip(rnd));
     CordRepBtree* right = MakeTree(random_leaf_count(), coin_flip(rnd));
     GetLeafEdges(right, flats);
     GetLeafEdges(right, flats);
     if (dice_throw(rnd) == 1) {
     if (dice_throw(rnd) == 1) {
-      std::uniform_int_distribution<int> dist(0, right->height());
+      std::uniform_int_distribution<size_t> dist(
+          0, static_cast<size_t>(right->height()));
       RefEdgesAt(dist(rnd), refs, right);
       RefEdgesAt(dist(rnd), refs, right);
     }
     }
 
 
@@ -784,7 +787,7 @@ TEST_P(CordRepBtreeTest, RemoveSuffix) {
       CordRep::Unref(node);
       CordRep::Unref(node);
     }
     }
 
 
-    for (int n = 1; n < data.length(); ++n) {
+    for (size_t n = 1; n < data.length(); ++n) {
       AutoUnref refs;
       AutoUnref refs;
       auto flats = CreateFlatsFromString(data, 512);
       auto flats = CreateFlatsFromString(data, 512);
       CordRepBtree* node = refs.RefIf(shared(), CreateTree(flats));
       CordRepBtree* node = refs.RefIf(shared(), CreateTree(flats));
@@ -802,10 +805,10 @@ TEST_P(CordRepBtreeTest, RemoveSuffix) {
       const size_t last_length = rep->length - edges.size() * 512;
       const size_t last_length = rep->length - edges.size() * 512;
 
 
       // All flats except the last edge must be kept or copied 'as is'
       // All flats except the last edge must be kept or copied 'as is'
-      int index = 0;
+      size_t index = 0;
       for (CordRep* edge : edges) {
       for (CordRep* edge : edges) {
         ASSERT_THAT(edge, Eq(flats[index++]));
         ASSERT_THAT(edge, Eq(flats[index++]));
-        ASSERT_THAT(edge->length, Eq(512));
+        ASSERT_THAT(edge->length, Eq(512u));
       }
       }
 
 
       // CordRepBtree may optimize small substrings to avoid waste, so only
       // CordRepBtree may optimize small substrings to avoid waste, so only
@@ -813,7 +816,7 @@ TEST_P(CordRepBtreeTest, RemoveSuffix) {
       if (last_length >= 500) {
       if (last_length >= 500) {
         EXPECT_THAT(last_edge, Eq(flats[index++]));
         EXPECT_THAT(last_edge, Eq(flats[index++]));
         if (shared()) {
         if (shared()) {
-          EXPECT_THAT(last_edge->length, Eq(512));
+          EXPECT_THAT(last_edge->length, Eq(512u));
         } else {
         } else {
           EXPECT_TRUE(last_edge->refcount.IsOne());
           EXPECT_TRUE(last_edge->refcount.IsOne());
           EXPECT_THAT(last_edge->length, Eq(last_length));
           EXPECT_THAT(last_edge->length, Eq(last_length));
@@ -837,8 +840,8 @@ TEST(CordRepBtreeTest, SubTree) {
     node = CordRepBtree::Append(node, CordRep::Ref(flats[i]));
     node = CordRepBtree::Append(node, CordRep::Ref(flats[i]));
   }
   }
 
 
-  for (int offset = 0; offset < data.length(); ++offset) {
-    for (int length = 1; length <= data.length() - offset; ++length) {
+  for (size_t offset = 0; offset < data.length(); ++offset) {
+    for (size_t length = 1; length <= data.length() - offset; ++length) {
       CordRep* rep = node->SubTree(offset, length);
       CordRep* rep = node->SubTree(offset, length);
       EXPECT_THAT(CordToString(rep), Eq(data.substr(offset, length)));
       EXPECT_THAT(CordToString(rep), Eq(data.substr(offset, length)));
       CordRep::Unref(rep);
       CordRep::Unref(rep);
@@ -865,12 +868,12 @@ TEST(CordRepBtreeTest, SubTreeOnExistingSubstring) {
   ASSERT_THAT(result->tag, Eq(BTREE));
   ASSERT_THAT(result->tag, Eq(BTREE));
   CordRep::Unref(leaf);
   CordRep::Unref(leaf);
   leaf = result->btree();
   leaf = result->btree();
-  ASSERT_THAT(leaf->Edges(), ElementsAre(_, IsSubstring(0, 990)));
+  ASSERT_THAT(leaf->Edges(), ElementsAre(_, IsSubstring(0u, 990u)));
   EXPECT_THAT(leaf->Edges()[1]->substring()->child, Eq(flat));
   EXPECT_THAT(leaf->Edges()[1]->substring()->child, Eq(flat));
 
 
   // Verify substring of substring.
   // Verify substring of substring.
   result = leaf->SubTree(3 + 5, 970);
   result = leaf->SubTree(3 + 5, 970);
-  ASSERT_THAT(result, IsSubstring(5, 970));
+  ASSERT_THAT(result, IsSubstring(5u, 970u));
   EXPECT_THAT(result->substring()->child, Eq(flat));
   EXPECT_THAT(result->substring()->child, Eq(flat));
   CordRep::Unref(result);
   CordRep::Unref(result);
 
 
@@ -1092,7 +1095,7 @@ TEST_P(CordRepBtreeHeightTest, GetAppendBufferNotFlat) {
   for (int i = 1; i <= height(); ++i) {
   for (int i = 1; i <= height(); ++i) {
     tree = CordRepBtree::New(tree);
     tree = CordRepBtree::New(tree);
   }
   }
-  EXPECT_THAT(tree->GetAppendBuffer(1), SizeIs(0));
+  EXPECT_THAT(tree->GetAppendBuffer(1), SizeIs(0u));
   CordRepBtree::Unref(tree);
   CordRepBtree::Unref(tree);
 }
 }
 
 
@@ -1102,7 +1105,7 @@ TEST_P(CordRepBtreeHeightTest, GetAppendBufferFlatNotPrivate) {
   for (int i = 1; i <= height(); ++i) {
   for (int i = 1; i <= height(); ++i) {
     tree = CordRepBtree::New(tree);
     tree = CordRepBtree::New(tree);
   }
   }
-  EXPECT_THAT(tree->GetAppendBuffer(1), SizeIs(0));
+  EXPECT_THAT(tree->GetAppendBuffer(1), SizeIs(0u));
   CordRepBtree::Unref(tree);
   CordRepBtree::Unref(tree);
   CordRep::Unref(flat);
   CordRep::Unref(flat);
 }
 }
@@ -1116,7 +1119,7 @@ TEST_P(CordRepBtreeHeightTest, GetAppendBufferTreeNotPrivate) {
     if (i == (height() + 1) / 2) refs.Ref(tree);
     if (i == (height() + 1) / 2) refs.Ref(tree);
     tree = CordRepBtree::New(tree);
     tree = CordRepBtree::New(tree);
   }
   }
-  EXPECT_THAT(tree->GetAppendBuffer(1), SizeIs(0));
+  EXPECT_THAT(tree->GetAppendBuffer(1), SizeIs(0u));
   CordRepBtree::Unref(tree);
   CordRepBtree::Unref(tree);
   CordRep::Unref(flat);
   CordRep::Unref(flat);
 }
 }
@@ -1128,7 +1131,7 @@ TEST_P(CordRepBtreeHeightTest, GetAppendBufferFlatNoCapacity) {
   for (int i = 1; i <= height(); ++i) {
   for (int i = 1; i <= height(); ++i) {
     tree = CordRepBtree::New(tree);
     tree = CordRepBtree::New(tree);
   }
   }
-  EXPECT_THAT(tree->GetAppendBuffer(1), SizeIs(0));
+  EXPECT_THAT(tree->GetAppendBuffer(1), SizeIs(0u));
   CordRepBtree::Unref(tree);
   CordRepBtree::Unref(tree);
 }
 }
 
 
@@ -1139,9 +1142,9 @@ TEST_P(CordRepBtreeHeightTest, GetAppendBufferFlatWithCapacity) {
     tree = CordRepBtree::New(tree);
     tree = CordRepBtree::New(tree);
   }
   }
   absl::Span<char> span = tree->GetAppendBuffer(2);
   absl::Span<char> span = tree->GetAppendBuffer(2);
-  EXPECT_THAT(span, SizeIs(2));
+  EXPECT_THAT(span, SizeIs(2u));
   EXPECT_THAT(span.data(), TypedEq<void*>(flat->Data() + 3));
   EXPECT_THAT(span.data(), TypedEq<void*>(flat->Data() + 3));
-  EXPECT_THAT(tree->length, Eq(5));
+  EXPECT_THAT(tree->length, Eq(5u));
 
 
   size_t avail = flat->Capacity() - 5;
   size_t avail = flat->Capacity() - 5;
   span = tree->GetAppendBuffer(avail + 100);
   span = tree->GetAppendBuffer(avail + 100);
@@ -1393,11 +1396,11 @@ TEST(CordRepBtreeTest, CheckAssertValidShallowVsDeep) {
 }
 }
 
 
 TEST_P(CordRepBtreeTest, Rebuild) {
 TEST_P(CordRepBtreeTest, Rebuild) {
-  for (size_t size : {3, 8, 100, 10000, 1000000}) {
+  for (size_t size : {3u, 8u, 100u, 10000u, 1000000u}) {
     SCOPED_TRACE(absl::StrCat("Rebuild @", size));
     SCOPED_TRACE(absl::StrCat("Rebuild @", size));
 
 
     std::vector<CordRepFlat*> flats;
     std::vector<CordRepFlat*> flats;
-    for (int i = 0; i < size; ++i) {
+    for (size_t i = 0; i < size; ++i) {
       flats.push_back(CordRepFlat::New(2));
       flats.push_back(CordRepFlat::New(2));
       flats.back()->Data()[0] = 'x';
       flats.back()->Data()[0] = 'x';
       flats.back()->length = 1;
       flats.back()->length = 1;

absl/strings/internal/cord_rep_crc_test.cc

@@ -46,7 +46,7 @@ TEST(CordRepCrc, NewDestroy) {
   CordRepCrc* crc = CordRepCrc::New(rep, 12345);
   CordRepCrc* crc = CordRepCrc::New(rep, 12345);
   EXPECT_TRUE(crc->refcount.IsOne());
   EXPECT_TRUE(crc->refcount.IsOne());
   EXPECT_THAT(crc->child, Eq(rep));
   EXPECT_THAT(crc->child, Eq(rep));
-  EXPECT_THAT(crc->crc, Eq(12345));
+  EXPECT_THAT(crc->crc, Eq(12345u));
   EXPECT_TRUE(rep->refcount.IsOne());
   EXPECT_TRUE(rep->refcount.IsOne());
   CordRepCrc::Destroy(crc);
   CordRepCrc::Destroy(crc);
 }
 }
@@ -58,7 +58,7 @@ TEST(CordRepCrc, NewExistingCrcNotShared) {
   EXPECT_THAT(new_crc, Eq(crc));
   EXPECT_THAT(new_crc, Eq(crc));
   EXPECT_TRUE(new_crc->refcount.IsOne());
   EXPECT_TRUE(new_crc->refcount.IsOne());
   EXPECT_THAT(new_crc->child, Eq(rep));
   EXPECT_THAT(new_crc->child, Eq(rep));
-  EXPECT_THAT(new_crc->crc, Eq(54321));
+  EXPECT_THAT(new_crc->crc, Eq(54321u));
   EXPECT_TRUE(rep->refcount.IsOne());
   EXPECT_TRUE(rep->refcount.IsOne());
   CordRepCrc::Destroy(new_crc);
   CordRepCrc::Destroy(new_crc);
 }
 }
@@ -75,8 +75,8 @@ TEST(CordRepCrc, NewExistingCrcShared) {
   EXPECT_FALSE(rep->refcount.IsOne());
   EXPECT_FALSE(rep->refcount.IsOne());
   EXPECT_THAT(crc->child, Eq(rep));
   EXPECT_THAT(crc->child, Eq(rep));
   EXPECT_THAT(new_crc->child, Eq(rep));
   EXPECT_THAT(new_crc->child, Eq(rep));
-  EXPECT_THAT(crc->crc, Eq(12345));
-  EXPECT_THAT(new_crc->crc, Eq(54321));
+  EXPECT_THAT(crc->crc, Eq(12345u));
+  EXPECT_THAT(new_crc->crc, Eq(54321u));
 
 
   CordRep::Unref(crc);
   CordRep::Unref(crc);
   CordRep::Unref(new_crc);
   CordRep::Unref(new_crc);

absl/strings/internal/cordz_info_statistics_test.cc

@@ -62,7 +62,7 @@ CordRepFlat* Flat(size_t size) {
 }
 }
 
 
 // Creates an external of the specified length
 // Creates an external of the specified length
-CordRepExternal* External(int length = 512) {
+CordRepExternal* External(size_t length = 512) {
   return static_cast<CordRepExternal*>(
   return static_cast<CordRepExternal*>(
       NewExternalRep(absl::string_view("", length), [](absl::string_view) {}));
       NewExternalRep(absl::string_view("", length), [](absl::string_view) {}));
 }
 }
@@ -352,7 +352,7 @@ TEST(CordzInfoStatisticsTest, SharedSubstringRing) {
 }
 }
 
 
 TEST(CordzInfoStatisticsTest, BtreeLeaf) {
 TEST(CordzInfoStatisticsTest, BtreeLeaf) {
-  ASSERT_THAT(CordRepBtree::kMaxCapacity, Ge(3));
+  ASSERT_THAT(CordRepBtree::kMaxCapacity, Ge(3u));
   RefHelper ref;
   RefHelper ref;
   auto* flat1 = Flat(2000);
   auto* flat1 = Flat(2000);
   auto* flat2 = Flat(200);
   auto* flat2 = Flat(200);
@@ -392,7 +392,7 @@ TEST(CordzInfoStatisticsTest, BtreeNodeShared) {
   RefHelper ref;
   RefHelper ref;
   static constexpr int leaf_count = 3;
   static constexpr int leaf_count = 3;
   const size_t flat3_count = CordRepBtree::kMaxCapacity - 3;
   const size_t flat3_count = CordRepBtree::kMaxCapacity - 3;
-  ASSERT_THAT(flat3_count, Ge(0));
+  ASSERT_THAT(flat3_count, Ge(0u));
 
 
   CordRepBtree* tree = nullptr;
   CordRepBtree* tree = nullptr;
   size_t mem_size = 0;
   size_t mem_size = 0;

absl/strings/internal/cordz_info_test.cc

@@ -124,7 +124,7 @@ TEST(CordzInfoTest, UntrackCord) {
   CordzInfo* info = data.data.cordz_info();
   CordzInfo* info = data.data.cordz_info();
 
 
   info->Untrack();
   info->Untrack();
-  EXPECT_THAT(DeleteQueue(), SizeIs(0));
+  EXPECT_THAT(DeleteQueue(), SizeIs(0u));
 }
 }
 
 
 TEST(CordzInfoTest, UntrackCordWithSnapshot) {
 TEST(CordzInfoTest, UntrackCordWithSnapshot) {
@@ -263,8 +263,9 @@ TEST(CordzInfoTest, StackV2) {
   // resultant formatted stack will be "", but that still equals the stack
   // resultant formatted stack will be "", but that still equals the stack
   // recorded in CordzInfo, which is also empty. The skip_count is 1 so that the
   // recorded in CordzInfo, which is also empty. The skip_count is 1 so that the
   // line number of the current stack isn't included in the HasSubstr check.
   // line number of the current stack isn't included in the HasSubstr check.
-  local_stack.resize(absl::GetStackTrace(local_stack.data(), kMaxStackDepth,
-                                         /*skip_count=*/1));
+  local_stack.resize(static_cast<size_t>(
+      absl::GetStackTrace(local_stack.data(), kMaxStackDepth,
+                          /*skip_count=*/1)));
 
 
   std::string got_stack = FormatStack(info->GetStack());
   std::string got_stack = FormatStack(info->GetStack());
   std::string expected_stack = FormatStack(local_stack);
   std::string expected_stack = FormatStack(local_stack);

absl/strings/internal/str_format/float_conversion.cc

@@ -1090,12 +1090,12 @@ void PrintExponent(int exp, char e, Buffer *out) {
   }
   }
   // Exponent digits.
   // Exponent digits.
   if (exp > 99) {
   if (exp > 99) {
-    out->push_back(static_cast<char>(exp / 100) + '0');
-    out->push_back(exp / 10 % 10 + '0');
-    out->push_back(exp % 10 + '0');
+    out->push_back(static_cast<char>(exp / 100 + '0'));
+    out->push_back(static_cast<char>(exp / 10 % 10 + '0'));
+    out->push_back(static_cast<char>(exp % 10 + '0'));
   } else {
   } else {
-    out->push_back(static_cast<char>(exp / 10) + '0');
-    out->push_back(exp % 10 + '0');
+    out->push_back(static_cast<char>(exp / 10 + '0'));
+    out->push_back(static_cast<char>(exp % 10 + '0'));
   }
   }
 }
 }
 
 

absl/strings/internal/str_split_internal.h

@@ -132,7 +132,8 @@ class SplitIterator {
       const absl::string_view text = splitter_->text();
       const absl::string_view text = splitter_->text();
       const absl::string_view d = delimiter_.Find(text, pos_);
       const absl::string_view d = delimiter_.Find(text, pos_);
       if (d.data() == text.data() + text.size()) state_ = kLastState;
       if (d.data() == text.data() + text.size()) state_ = kLastState;
-      curr_ = text.substr(pos_, d.data() - (text.data() + pos_));
+      curr_ = text.substr(pos_,
+                          static_cast<size_t>(d.data() - (text.data() + pos_)));
       pos_ += curr_.size() + d.size();
       pos_ += curr_.size() + d.size();
     } while (!predicate_(curr_));
     } while (!predicate_(curr_));
     return *this;
     return *this;