Chiebot-Mirror
/
abseil-cpp
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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

Browse Source 
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
pull/1267/head
Abseil Team 3 years ago committed by Copybara-Service
parent 92fdbfb301
commit 75691f1c32
8 changed files with 88 additions and 83 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 42
      absl/strings/internal/cord_rep_btree_navigator_test.cc
  2. 38
      absl/strings/internal/cord_rep_btree_reader_test.cc
  3. 57
      absl/strings/internal/cord_rep_btree_test.cc
  4. 8
      absl/strings/internal/cord_rep_crc_test.cc
  5. 6
      absl/strings/internal/cordz_info_statistics_test.cc
  6. 7
      absl/strings/internal/cordz_info_test.cc
  7. 10
      absl/strings/internal/str_format/float_conversion.cc
  8. 3
      absl/strings/internal/str_split_internal.h

42
absl/strings/internal/cord_rep_btree_navigator_test.cc
Unescape View File

@ -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<int> {
class CordRepBtreeNavigatorTest : public testing::TestWithParam<size_t> {
public:
using Flats = std::vector<CordRep*>;
static constexpr size_t kCharsPerFlat = 3;
@ -71,12 +71,12 @@ class CordRepBtreeNavigatorTest : public testing::TestWithParam<int> {
~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<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");
}
@ -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<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.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<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.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);
}

38
absl/strings/internal/cord_rep_btree_reader_test.cc
Unescape View File

@ -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<CordRep*> 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<CordRep*> 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<CordRep*> 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<CordRep*> flats = CreateFlatsFromString(data, kChars);
CordRepBtree* node = CordRepBtreeFromFlats(flats);

57
absl/strings/internal/cord_rep_btree_test.cc
Unescape View File

@ -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<int> dist_height(0, 3);
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);
};
@ -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<int> dist(0, left->height());
std::uniform_int_distribution<size_t> dist(
0, static_cast<size_t>(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<int> dist(0, right->height());
std::uniform_int_distribution<size_t> dist(
0, static_cast<size_t>(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<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(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<CordRepFlat*> 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;

8
absl/strings/internal/cord_rep_crc_test.cc
Unescape View File

@ -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);

6
absl/strings/internal/cordz_info_statistics_test.cc
Unescape View File

@ -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<CordRepExternal*>(
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;

7
absl/strings/internal/cordz_info_test.cc
Unescape View File

@ -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<size_t>(
absl::GetStackTrace(local_stack.data(), kMaxStackDepth,
/*skip_count=*/1)));
std::string got_stack = FormatStack(info->GetStack());
std::string expected_stack = FormatStack(local_stack);

10
absl/strings/internal/str_format/float_conversion.cc
Unescape View File

@ -1090,12 +1090,12 @@ void PrintExponent(int exp, char e, Buffer *out) {
}
// Exponent digits.
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 {
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'));
}
}

3
absl/strings/internal/str_split_internal.h
Unescape View File

@ -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<size_t>(d.data() - (text.data() + pos_)));
pos_ += curr_.size() + d.size();
} while (!predicate_(curr_));
return *this;

Write Preview
Loading…
Cancel
Save