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
Unified 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 // 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) { for (size_t i = flats.size() - 1; i > 0; --i) {
ASSERT_THAT(nav.Previous(), Eq(flats[i])); ASSERT_THAT(nav.Previous(), Eq(flats[i - 1]));
EXPECT_THAT(nav.Current(), Eq(flats[i])); 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) { for (size_t i = flats.size() - 1; i > 0; --i) {
ASSERT_THAT(nav.Previous(), Eq(flats[i])); ASSERT_THAT(nav.Previous(), Eq(flats[i - 1]));
EXPECT_THAT(nav.Current(), Eq(flats[i])); 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 (size_t index1 = 0; index1 < count; ++index1) {
for (int index2 = index1; index2 < count; ++index2) { for (size_t index2 = index1; index2 < count; ++index2) {
for (int char_offset = 0; char_offset < kCharsPerFlat; ++char_offset) { 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 (size_t index = 0; index < count; ++index) {
for (int char_offset = 0; char_offset < kCharsPerFlat; ++char_offset) { 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);
} }

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

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

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) { 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 (size_t offset = 0; offset < data.length(); ++offset) {
for (int length = 1; length <= data.length() - offset; ++length) { 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;

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); 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(crc->crc, Eq(12345u));
EXPECT_THAT(new_crc->crc, Eq(54321)); EXPECT_THAT(new_crc->crc, Eq(54321u));
CordRep::Unref(crc); CordRep::Unref(crc);
CordRep::Unref(new_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 // 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;

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

@ -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, local_stack.resize(static_cast<size_t>(
/*skip_count=*/1)); 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);

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. // Exponent digits.
if (exp > 99) { if (exp > 99) {
out->push_back(static_cast<char>(exp / 100) + '0'); out->push_back(static_cast<char>(exp / 100 + '0'));
out->push_back(exp / 10 % 10 + '0'); out->push_back(static_cast<char>(exp / 10 % 10 + '0'));
out->push_back(exp % 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(static_cast<char>(exp / 10 + '0'));
out->push_back(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 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;

Write Preview
Loading…
Cancel
Save