From 75691f1c3292969c5a85288a3cee8ae831203302 Mon Sep 17 00:00:00 2001 From: Abseil Team Date: Mon, 29 Aug 2022 14:08:26 -0700 Subject: 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 --- .../internal/cord_rep_btree_navigator_test.cc | 42 ++++++++-------- .../strings/internal/cord_rep_btree_reader_test.cc | 38 +++++++-------- absl/strings/internal/cord_rep_btree_test.cc | 57 ++++++++++++---------- absl/strings/internal/cord_rep_crc_test.cc | 8 +-- .../strings/internal/cordz_info_statistics_test.cc | 6 +-- absl/strings/internal/cordz_info_test.cc | 7 +-- .../internal/str_format/float_conversion.cc | 10 ++-- absl/strings/internal/str_split_internal.h | 3 +- 8 files changed, 88 insertions(+), 83 deletions(-) (limited to 'absl/strings/internal') diff --git a/absl/strings/internal/cord_rep_btree_navigator_test.cc b/absl/strings/internal/cord_rep_btree_navigator_test.cc index 4f9bd4e5..bed75508 100644 --- a/absl/strings/internal/cord_rep_btree_navigator_test.cc +++ b/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 // tree to test navigation logic on. The parameter `count' defines the number of // data edges in the test tree. -class CordRepBtreeNavigatorTest : public testing::TestWithParam { +class CordRepBtreeNavigatorTest : public testing::TestWithParam { public: using Flats = std::vector; static constexpr size_t kCharsPerFlat = 3; @@ -71,12 +71,12 @@ class CordRepBtreeNavigatorTest : public testing::TestWithParam { ~CordRepBtreeNavigatorTest() override { CordRep::Unref(tree_); } - int count() const { return GetParam(); } + size_t count() const { return GetParam(); } CordRepBtree* tree() { return tree_; } const std::string& data() const { return data_; } const std::vector& flats() const { return flats_; } - static std::string ToString(testing::TestParamInfo param) { + static std::string ToString(testing::TestParamInfo param) { return absl::StrCat(param.param, "_Flats"); } @@ -131,15 +131,15 @@ TEST_P(CordRepBtreeNavigatorTest, NextPrev) { EXPECT_THAT(nav.Previous(), Eq(nullptr)); 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])); EXPECT_THAT(nav.Current(), Eq(flats[i])); } EXPECT_THAT(nav.Next(), Eq(nullptr)); EXPECT_THAT(nav.Current(), Eq(flats.back())); - for (int i = static_cast(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.Current(), Eq(flats.front())); @@ -152,13 +152,13 @@ TEST_P(CordRepBtreeNavigatorTest, PrevNext) { EXPECT_THAT(nav.Next(), Eq(nullptr)); EXPECT_THAT(nav.Current(), Eq(flats.back())); - for (int i = static_cast(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.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])); EXPECT_THAT(nav.Current(), Eq(flats[i])); } @@ -180,21 +180,21 @@ TEST(CordRepBtreeNavigatorTest, Reset) { } TEST_P(CordRepBtreeNavigatorTest, Skip) { - int count = this->count(); + size_t count = this->count(); const Flats& flats = this->flats(); CordRepBtreeNavigator nav; 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); EXPECT_THAT(pos.edge, Eq(nav.Current())); EXPECT_THAT(pos.edge, Eq(flats[0])); 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; nav.InitFirst(tree()); @@ -215,20 +215,20 @@ TEST_P(CordRepBtreeNavigatorTest, Skip) { } TEST_P(CordRepBtreeNavigatorTest, Seek) { - int count = this->count(); + size_t count = this->count(); const Flats& flats = this->flats(); CordRepBtreeNavigator nav; 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); EXPECT_THAT(pos.edge, Eq(nav.Current())); EXPECT_THAT(pos.edge, Eq(flats[0])); 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; Position pos1 = nav.Seek(offset); ASSERT_THAT(pos1.edge, Eq(flats[index])); @@ -249,7 +249,7 @@ TEST(CordRepBtreeNavigatorTest, InitOffset) { EXPECT_THAT(nav.btree(), Eq(tree)); EXPECT_THAT(pos.edge, Eq(tree->Edges()[1])); EXPECT_THAT(pos.edge, Eq(nav.Current())); - EXPECT_THAT(pos.offset, Eq(2)); + EXPECT_THAT(pos.offset, Eq(2u)); CordRep::Unref(tree); } diff --git a/absl/strings/internal/cord_rep_btree_reader_test.cc b/absl/strings/internal/cord_rep_btree_reader_test.cc index 9b27a81f..b4cdd8e5 100644 --- a/absl/strings/internal/cord_rep_btree_reader_test.cc +++ b/absl/strings/internal/cord_rep_btree_reader_test.cc @@ -50,9 +50,9 @@ using ReadResult = CordRepBtreeReader::ReadResult; TEST(CordRepBtreeReaderTest, Next) { constexpr size_t kChars = 3; 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::vector flats = CreateFlatsFromString(data, kChars); CordRepBtree* node = CordRepBtreeFromFlats(flats); @@ -74,7 +74,7 @@ TEST(CordRepBtreeReaderTest, Next) { 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 EXPECT_THAT(reader.Next(), testing::IsEmpty()); @@ -86,9 +86,9 @@ TEST(CordRepBtreeReaderTest, Next) { TEST(CordRepBtreeReaderTest, Skip) { constexpr size_t kChars = 3; 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::vector flats = CreateFlatsFromString(data, kChars); CordRepBtree* node = CordRepBtreeFromFlats(flats); @@ -125,16 +125,16 @@ TEST(CordRepBtreeReaderTest, SkipBeyondLength) { CordRepBtreeReader reader; reader.Init(tree); EXPECT_THAT(reader.Skip(100), IsEmpty()); - EXPECT_THAT(reader.remaining(), Eq(0)); + EXPECT_THAT(reader.remaining(), Eq(0u)); CordRep::Unref(tree); } TEST(CordRepBtreeReaderTest, Seek) { constexpr size_t kChars = 3; 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::vector flats = CreateFlatsFromString(data, kChars); CordRepBtree* node = CordRepBtreeFromFlats(flats); @@ -159,9 +159,9 @@ TEST(CordRepBtreeReaderTest, SeekBeyondLength) { CordRepBtreeReader reader; reader.Init(tree); 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.remaining(), Eq(0)); + EXPECT_THAT(reader.remaining(), Eq(0u)); CordRep::Unref(tree); } @@ -179,7 +179,7 @@ TEST(CordRepBtreeReaderTest, Read) { chunk = reader.Read(0, chunk.length(), tree); EXPECT_THAT(tree, Eq(nullptr)); EXPECT_THAT(chunk, Eq("abcde")); - EXPECT_THAT(reader.remaining(), Eq(10)); + EXPECT_THAT(reader.remaining(), Eq(10u)); EXPECT_THAT(reader.Next(), Eq("fghij")); // Read in full @@ -188,7 +188,7 @@ TEST(CordRepBtreeReaderTest, Read) { EXPECT_THAT(tree, Ne(nullptr)); EXPECT_THAT(CordToString(tree), Eq("abcdefghijklmno")); EXPECT_THAT(chunk, Eq("")); - EXPECT_THAT(reader.remaining(), Eq(0)); + EXPECT_THAT(reader.remaining(), Eq(0u)); CordRep::Unref(tree); // Read < chunk bytes @@ -197,7 +197,7 @@ TEST(CordRepBtreeReaderTest, Read) { ASSERT_THAT(tree, Ne(nullptr)); EXPECT_THAT(CordToString(tree), Eq("abc")); EXPECT_THAT(chunk, Eq("de")); - EXPECT_THAT(reader.remaining(), Eq(10)); + EXPECT_THAT(reader.remaining(), Eq(10u)); EXPECT_THAT(reader.Next(), Eq("fghij")); CordRep::Unref(tree); @@ -207,7 +207,7 @@ TEST(CordRepBtreeReaderTest, Read) { ASSERT_THAT(tree, Ne(nullptr)); EXPECT_THAT(CordToString(tree), Eq("cd")); EXPECT_THAT(chunk, Eq("e")); - EXPECT_THAT(reader.remaining(), Eq(10)); + EXPECT_THAT(reader.remaining(), Eq(10u)); EXPECT_THAT(reader.Next(), Eq("fghij")); CordRep::Unref(tree); @@ -217,7 +217,7 @@ TEST(CordRepBtreeReaderTest, Read) { ASSERT_THAT(tree, Ne(nullptr)); EXPECT_THAT(CordToString(tree), Eq("fgh")); EXPECT_THAT(chunk, Eq("ij")); - EXPECT_THAT(reader.remaining(), Eq(5)); + EXPECT_THAT(reader.remaining(), Eq(5u)); EXPECT_THAT(reader.Next(), Eq("klmno")); CordRep::Unref(tree); @@ -227,7 +227,7 @@ TEST(CordRepBtreeReaderTest, Read) { ASSERT_THAT(tree, Ne(nullptr)); EXPECT_THAT(CordToString(tree), Eq("cdefghijklmn")); EXPECT_THAT(chunk, Eq("o")); - EXPECT_THAT(reader.remaining(), Eq(0)); + EXPECT_THAT(reader.remaining(), Eq(0u)); CordRep::Unref(tree); // Read across chunks landing on exact edge boundary @@ -236,7 +236,7 @@ TEST(CordRepBtreeReaderTest, Read) { ASSERT_THAT(tree, Ne(nullptr)); EXPECT_THAT(CordToString(tree), Eq("cdefghij")); EXPECT_THAT(chunk, Eq("klmno")); - EXPECT_THAT(reader.remaining(), Eq(0)); + EXPECT_THAT(reader.remaining(), Eq(0u)); CordRep::Unref(tree); CordRep::Unref(node); @@ -245,9 +245,9 @@ TEST(CordRepBtreeReaderTest, Read) { TEST(CordRepBtreeReaderTest, ReadExhaustive) { constexpr size_t kChars = 3; 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::vector flats = CreateFlatsFromString(data, kChars); CordRepBtree* node = CordRepBtreeFromFlats(flats); diff --git a/absl/strings/internal/cord_rep_btree_test.cc b/absl/strings/internal/cord_rep_btree_test.cc index 51b90db1..9d6ce484 100644 --- a/absl/strings/internal/cord_rep_btree_test.cc +++ b/absl/strings/internal/cord_rep_btree_test.cc @@ -284,13 +284,14 @@ INSTANTIATE_TEST_SUITE_P(WithParam, CordRepBtreeDualTest, TEST(CordRepBtreeTest, SizeIsMultipleOf64) { // Only enforce for fully 64-bit platforms. 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) { 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->Edges(), ElementsAre()); CordRepBtree::Destroy(tree); @@ -298,7 +299,7 @@ TEST(CordRepBtreeTest, NewDestroyEmptyTree) { TEST(CordRepBtreeTest, NewDestroyEmptyTreeAtHeight) { 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->Edges(), ElementsAre()); CordRepBtree::Destroy(tree); @@ -356,7 +357,7 @@ TEST(CordRepBtreeTest, EdgeData) { TEST(CordRepBtreeTest, CreateUnrefLeaf) { auto* flat = MakeFlat("a"); 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->Edges(), ElementsAre(flat)); CordRepBtree::Unref(leaf); @@ -365,7 +366,7 @@ TEST(CordRepBtreeTest, CreateUnrefLeaf) { TEST(CordRepBtreeTest, NewUnrefNode) { auto* leaf = CordRepBtree::Create(MakeFlat("a")); 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->Edges(), ElementsAre(leaf)); CordRepBtree::Unref(tree); @@ -653,7 +654,7 @@ TEST_P(CordRepBtreeDualTest, MergeEqualHeightTrees) { CordRepBtree* tree = use_append ? CordRepBtree::Append(left, right) : CordRepBtree::Prepend(right, left); 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`. EXPECT_THAT(GetLeafEdges(tree), ElementsAreArray(flats)); @@ -681,7 +682,7 @@ TEST_P(CordRepBtreeDualTest, MergeLeafWithTreeNotExceedingLeafCapacity) { CordRepBtree* tree = use_append ? CordRepBtree::Append(left, right) : CordRepBtree::Prepend(right, left); 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`. EXPECT_THAT(GetLeafEdges(tree), ElementsAreArray(flats)); @@ -709,7 +710,7 @@ TEST_P(CordRepBtreeDualTest, MergeLeafWithTreeExceedingLeafCapacity) { CordRepBtree* tree = use_append ? CordRepBtree::Append(left, right) : CordRepBtree::Prepend(right, left); 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`. EXPECT_THAT(GetLeafEdges(tree), ElementsAreArray(flats)); @@ -738,7 +739,7 @@ TEST(CordRepBtreeTest, MergeFuzzTest) { auto random_leaf_count = [&]() { std::uniform_int_distribution dist_height(0, 3); std::uniform_int_distribution 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); }; @@ -749,14 +750,16 @@ TEST(CordRepBtreeTest, MergeFuzzTest) { CordRepBtree* left = MakeTree(random_leaf_count(), coin_flip(rnd)); GetLeafEdges(left, flats); if (dice_throw(rnd) == 1) { - std::uniform_int_distribution dist(0, left->height()); + std::uniform_int_distribution dist( + 0, static_cast(left->height())); RefEdgesAt(dist(rnd), refs, left); } CordRepBtree* right = MakeTree(random_leaf_count(), coin_flip(rnd)); GetLeafEdges(right, flats); if (dice_throw(rnd) == 1) { - std::uniform_int_distribution dist(0, right->height()); + std::uniform_int_distribution dist( + 0, static_cast(right->height())); RefEdgesAt(dist(rnd), refs, right); } @@ -784,7 +787,7 @@ TEST_P(CordRepBtreeTest, RemoveSuffix) { CordRep::Unref(node); } - for (int n = 1; n < data.length(); ++n) { + for (size_t n = 1; n < data.length(); ++n) { AutoUnref refs; auto flats = CreateFlatsFromString(data, 512); 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; // All flats except the last edge must be kept or copied 'as is' - int index = 0; + size_t index = 0; for (CordRep* edge : edges) { 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 @@ -813,7 +816,7 @@ TEST_P(CordRepBtreeTest, RemoveSuffix) { if (last_length >= 500) { EXPECT_THAT(last_edge, Eq(flats[index++])); if (shared()) { - EXPECT_THAT(last_edge->length, Eq(512)); + EXPECT_THAT(last_edge->length, Eq(512u)); } else { EXPECT_TRUE(last_edge->refcount.IsOne()); EXPECT_THAT(last_edge->length, Eq(last_length)); @@ -837,8 +840,8 @@ TEST(CordRepBtreeTest, SubTree) { 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); EXPECT_THAT(CordToString(rep), Eq(data.substr(offset, length))); CordRep::Unref(rep); @@ -865,12 +868,12 @@ TEST(CordRepBtreeTest, SubTreeOnExistingSubstring) { ASSERT_THAT(result->tag, Eq(BTREE)); CordRep::Unref(leaf); 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)); // Verify substring of substring. 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)); CordRep::Unref(result); @@ -1092,7 +1095,7 @@ TEST_P(CordRepBtreeHeightTest, GetAppendBufferNotFlat) { for (int i = 1; i <= height(); ++i) { tree = CordRepBtree::New(tree); } - EXPECT_THAT(tree->GetAppendBuffer(1), SizeIs(0)); + EXPECT_THAT(tree->GetAppendBuffer(1), SizeIs(0u)); CordRepBtree::Unref(tree); } @@ -1102,7 +1105,7 @@ TEST_P(CordRepBtreeHeightTest, GetAppendBufferFlatNotPrivate) { for (int i = 1; i <= height(); ++i) { tree = CordRepBtree::New(tree); } - EXPECT_THAT(tree->GetAppendBuffer(1), SizeIs(0)); + EXPECT_THAT(tree->GetAppendBuffer(1), SizeIs(0u)); CordRepBtree::Unref(tree); CordRep::Unref(flat); } @@ -1116,7 +1119,7 @@ TEST_P(CordRepBtreeHeightTest, GetAppendBufferTreeNotPrivate) { if (i == (height() + 1) / 2) refs.Ref(tree); tree = CordRepBtree::New(tree); } - EXPECT_THAT(tree->GetAppendBuffer(1), SizeIs(0)); + EXPECT_THAT(tree->GetAppendBuffer(1), SizeIs(0u)); CordRepBtree::Unref(tree); CordRep::Unref(flat); } @@ -1128,7 +1131,7 @@ TEST_P(CordRepBtreeHeightTest, GetAppendBufferFlatNoCapacity) { for (int i = 1; i <= height(); ++i) { tree = CordRepBtree::New(tree); } - EXPECT_THAT(tree->GetAppendBuffer(1), SizeIs(0)); + EXPECT_THAT(tree->GetAppendBuffer(1), SizeIs(0u)); CordRepBtree::Unref(tree); } @@ -1139,9 +1142,9 @@ TEST_P(CordRepBtreeHeightTest, GetAppendBufferFlatWithCapacity) { tree = CordRepBtree::New(tree); } absl::Span span = tree->GetAppendBuffer(2); - EXPECT_THAT(span, SizeIs(2)); + EXPECT_THAT(span, SizeIs(2u)); EXPECT_THAT(span.data(), TypedEq(flat->Data() + 3)); - EXPECT_THAT(tree->length, Eq(5)); + EXPECT_THAT(tree->length, Eq(5u)); size_t avail = flat->Capacity() - 5; span = tree->GetAppendBuffer(avail + 100); @@ -1393,11 +1396,11 @@ TEST(CordRepBtreeTest, CheckAssertValidShallowVsDeep) { } 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)); std::vector flats; - for (int i = 0; i < size; ++i) { + for (size_t i = 0; i < size; ++i) { flats.push_back(CordRepFlat::New(2)); flats.back()->Data()[0] = 'x'; flats.back()->length = 1; diff --git a/absl/strings/internal/cord_rep_crc_test.cc b/absl/strings/internal/cord_rep_crc_test.cc index 80f53485..d73ea7b3 100644 --- a/absl/strings/internal/cord_rep_crc_test.cc +++ b/absl/strings/internal/cord_rep_crc_test.cc @@ -46,7 +46,7 @@ TEST(CordRepCrc, NewDestroy) { CordRepCrc* crc = CordRepCrc::New(rep, 12345); EXPECT_TRUE(crc->refcount.IsOne()); EXPECT_THAT(crc->child, Eq(rep)); - EXPECT_THAT(crc->crc, Eq(12345)); + EXPECT_THAT(crc->crc, Eq(12345u)); EXPECT_TRUE(rep->refcount.IsOne()); CordRepCrc::Destroy(crc); } @@ -58,7 +58,7 @@ TEST(CordRepCrc, NewExistingCrcNotShared) { EXPECT_THAT(new_crc, Eq(crc)); EXPECT_TRUE(new_crc->refcount.IsOne()); 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()); CordRepCrc::Destroy(new_crc); } @@ -75,8 +75,8 @@ TEST(CordRepCrc, NewExistingCrcShared) { EXPECT_FALSE(rep->refcount.IsOne()); EXPECT_THAT(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(new_crc); diff --git a/absl/strings/internal/cordz_info_statistics_test.cc b/absl/strings/internal/cordz_info_statistics_test.cc index 476c38d2..6d6feb52 100644 --- a/absl/strings/internal/cordz_info_statistics_test.cc +++ b/absl/strings/internal/cordz_info_statistics_test.cc @@ -62,7 +62,7 @@ CordRepFlat* Flat(size_t size) { } // Creates an external of the specified length -CordRepExternal* External(int length = 512) { +CordRepExternal* External(size_t length = 512) { return static_cast( NewExternalRep(absl::string_view("", length), [](absl::string_view) {})); } @@ -352,7 +352,7 @@ TEST(CordzInfoStatisticsTest, SharedSubstringRing) { } TEST(CordzInfoStatisticsTest, BtreeLeaf) { - ASSERT_THAT(CordRepBtree::kMaxCapacity, Ge(3)); + ASSERT_THAT(CordRepBtree::kMaxCapacity, Ge(3u)); RefHelper ref; auto* flat1 = Flat(2000); auto* flat2 = Flat(200); @@ -392,7 +392,7 @@ TEST(CordzInfoStatisticsTest, BtreeNodeShared) { RefHelper ref; static constexpr int leaf_count = 3; const size_t flat3_count = CordRepBtree::kMaxCapacity - 3; - ASSERT_THAT(flat3_count, Ge(0)); + ASSERT_THAT(flat3_count, Ge(0u)); CordRepBtree* tree = nullptr; size_t mem_size = 0; diff --git a/absl/strings/internal/cordz_info_test.cc b/absl/strings/internal/cordz_info_test.cc index b98343ae..cd226c3e 100644 --- a/absl/strings/internal/cordz_info_test.cc +++ b/absl/strings/internal/cordz_info_test.cc @@ -124,7 +124,7 @@ TEST(CordzInfoTest, UntrackCord) { CordzInfo* info = data.data.cordz_info(); info->Untrack(); - EXPECT_THAT(DeleteQueue(), SizeIs(0)); + EXPECT_THAT(DeleteQueue(), SizeIs(0u)); } TEST(CordzInfoTest, UntrackCordWithSnapshot) { @@ -263,8 +263,9 @@ TEST(CordzInfoTest, StackV2) { // 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 // 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( + absl::GetStackTrace(local_stack.data(), kMaxStackDepth, + /*skip_count=*/1))); std::string got_stack = FormatStack(info->GetStack()); std::string expected_stack = FormatStack(local_stack); diff --git a/absl/strings/internal/str_format/float_conversion.cc b/absl/strings/internal/str_format/float_conversion.cc index 3895001a..8e497852 100644 --- a/absl/strings/internal/str_format/float_conversion.cc +++ b/absl/strings/internal/str_format/float_conversion.cc @@ -1090,12 +1090,12 @@ void PrintExponent(int exp, char e, Buffer *out) { } // Exponent digits. if (exp > 99) { - out->push_back(static_cast(exp / 100) + '0'); - out->push_back(exp / 10 % 10 + '0'); - out->push_back(exp % 10 + '0'); + out->push_back(static_cast(exp / 100 + '0')); + out->push_back(static_cast(exp / 10 % 10 + '0')); + out->push_back(static_cast(exp % 10 + '0')); } else { - out->push_back(static_cast(exp / 10) + '0'); - out->push_back(exp % 10 + '0'); + out->push_back(static_cast(exp / 10 + '0')); + out->push_back(static_cast(exp % 10 + '0')); } } diff --git a/absl/strings/internal/str_split_internal.h b/absl/strings/internal/str_split_internal.h index e7664216..35edf3aa 100644 --- a/absl/strings/internal/str_split_internal.h +++ b/absl/strings/internal/str_split_internal.h @@ -132,7 +132,8 @@ class SplitIterator { const absl::string_view text = splitter_->text(); const absl::string_view d = delimiter_.Find(text, pos_); if (d.data() == text.data() + text.size()) state_ = kLastState; - curr_ = text.substr(pos_, d.data() - (text.data() + pos_)); + curr_ = text.substr(pos_, + static_cast(d.data() - (text.data() + pos_))); pos_ += curr_.size() + d.size(); } while (!predicate_(curr_)); return *this; -- cgit v1.2.3