Skip to content

A
abseil-cpp
Commit 2594f855 by Abseil Team Committed by Copybara-Service
Options

Fix "unsafe narrowing" warnings in absl, 10/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 tests.)

Bug: chromium:1292951
PiperOrigin-RevId: 473055916
Change-Id: I40cdd6c87ba9d0a5fb2db5746cff04f14ee829c2
parent 69199fce
Showing with 145 additions and 148 deletions
absl/algorithm/container_test.cc
......@@ -67,13 +67,16 @@ bool Equals(int v1, int v2) { return v1 == v2; }
bool IsOdd(int x) { return x % 2 != 0; }
TEST_F(NonMutatingTest, Distance) {
EXPECT_EQ(container_.size(), absl::c_distance(container_));
EXPECT_EQ(sequence_.size(), absl::c_distance(sequence_));
EXPECT_EQ(vector_.size(), absl::c_distance(vector_));
EXPECT_EQ(ABSL_ARRAYSIZE(array_), absl::c_distance(array_));
EXPECT_EQ(container_.size(),
static_cast<size_t>(absl::c_distance(container_)));
EXPECT_EQ(sequence_.size(), static_cast<size_t>(absl::c_distance(sequence_)));
EXPECT_EQ(vector_.size(), static_cast<size_t>(absl::c_distance(vector_)));
EXPECT_EQ(ABSL_ARRAYSIZE(array_),
static_cast<size_t>(absl::c_distance(array_)));
// Works with a temporary argument.
EXPECT_EQ(vector_.size(), absl::c_distance(std::vector<int>(vector_)));
EXPECT_EQ(vector_.size(),
static_cast<size_t>(absl::c_distance(std::vector<int>(vector_))));
}
TEST_F(NonMutatingTest, Distance_OverloadedBeginEnd) {
......
absl/base/spinlock_test_common.cc
......@@ -34,7 +34,7 @@
#include "absl/synchronization/blocking_counter.h"
#include "absl/synchronization/notification.h"
constexpr int32_t kNumThreads = 10;
constexpr uint32_t kNumThreads = 10;
constexpr int32_t kIters = 1000;
namespace absl {
......@@ -55,7 +55,7 @@ struct SpinLockTest {
namespace {
static constexpr int kArrayLength = 10;
static constexpr size_t kArrayLength = 10;
static uint32_t values[kArrayLength];
ABSL_CONST_INIT static SpinLock static_cooperative_spinlock(
......@@ -79,11 +79,11 @@ static uint32_t Hash32(uint32_t a, uint32_t c) {
return c;
}
static void TestFunction(int thread_salt, SpinLock* spinlock) {
static void TestFunction(uint32_t thread_salt, SpinLock* spinlock) {
for (int i = 0; i < kIters; i++) {
SpinLockHolder h(spinlock);
for (int j = 0; j < kArrayLength; j++) {
const int index = (j + thread_salt) % kArrayLength;
for (size_t j = 0; j < kArrayLength; j++) {
const size_t index = (j + thread_salt) % kArrayLength;
values[index] = Hash32(values[index], thread_salt);
std::this_thread::yield();
}
......@@ -93,7 +93,7 @@ static void TestFunction(int thread_salt, SpinLock* spinlock) {
static void ThreadedTest(SpinLock* spinlock) {
std::vector<std::thread> threads;
threads.reserve(kNumThreads);
for (int i = 0; i < kNumThreads; ++i) {
for (uint32_t i = 0; i < kNumThreads; ++i) {
threads.push_back(std::thread(TestFunction, i, spinlock));
}
for (auto& thread : threads) {
......@@ -101,7 +101,7 @@ static void ThreadedTest(SpinLock* spinlock) {
}
SpinLockHolder h(spinlock);
for (int i = 1; i < kArrayLength; i++) {
for (size_t i = 1; i < kArrayLength; i++) {
EXPECT_EQ(values[0], values[i]);
}
}
......@@ -153,7 +153,7 @@ TEST(SpinLock, WaitCyclesEncoding) {
int64_t cycles = cycle_distribution(generator);
int64_t end_time = start_time + cycles;
uint32_t lock_value = SpinLockTest::EncodeWaitCycles(start_time, end_time);
EXPECT_EQ(0, lock_value & kLockwordReservedMask);
EXPECT_EQ(0u, lock_value & kLockwordReservedMask);
int64_t decoded = SpinLockTest::DecodeWaitCycles(lock_value);
EXPECT_EQ(0, decoded & kProfileTimestampMask);
EXPECT_EQ(cycles & ~kProfileTimestampMask, decoded);
......
absl/hash/hash_test.cc
......@@ -222,7 +222,7 @@ TEST(HashValueTest, PointerAlignment) {
// Limit the scope to the bits we would be using for Swisstable.
constexpr size_t kMask = (1 << (kLog2NumValues + 7)) - 1;
size_t stuck_bits = (~bits_or | bits_and) & kMask;
EXPECT_EQ(stuck_bits, 0) << "0x" << std::hex << stuck_bits;
EXPECT_EQ(stuck_bits, 0u) << "0x" << std::hex << stuck_bits;
}
}
......@@ -737,10 +737,10 @@ TEST(HashValueTest, CombinePiecewiseBuffer) {
//
// This test is run on a buffer that is a multiple of the stride size, and one
// that isn't.
for (size_t big_buffer_size : {1024 * 2 + 512, 1024 * 3}) {
for (size_t big_buffer_size : {1024u * 2 + 512u, 1024u * 3}) {
SCOPED_TRACE(big_buffer_size);
std::string big_buffer;
for (int i = 0; i < big_buffer_size; ++i) {
for (size_t i = 0; i < big_buffer_size; ++i) {
// Arbitrary string
big_buffer.push_back(32 + (i * (i / 3)) % 64);
}
......@@ -1135,10 +1135,10 @@ TEST(HashTest, HashNonUniquelyRepresentedType) {
unsigned char buffer2[kNumStructs * sizeof(StructWithPadding)];
std::memset(buffer2, 255, sizeof(buffer2));
auto* s2 = reinterpret_cast<StructWithPadding*>(buffer2);
for (int i = 0; i < kNumStructs; ++i) {
for (size_t i = 0; i < kNumStructs; ++i) {
SCOPED_TRACE(i);
s1[i].c = s2[i].c = '0' + i;
s1[i].i = s2[i].i = i;
s1[i].c = s2[i].c = static_cast<char>('0' + i);
s1[i].i = s2[i].i = static_cast<int>(i);
ASSERT_FALSE(memcmp(buffer1 + i * sizeof(StructWithPadding),
buffer2 + i * sizeof(StructWithPadding),
sizeof(StructWithPadding)) == 0)
......@@ -1226,7 +1226,9 @@ struct ValueWithBoolConversion {
namespace std {
template <>
struct hash<ValueWithBoolConversion> {
size_t operator()(ValueWithBoolConversion v) { return v.i; }
size_t operator()(ValueWithBoolConversion v) {
return static_cast<size_t>(v.i);
}
};
} // namespace std
......
absl/status/statusor_test.cc
......@@ -1521,7 +1521,7 @@ static absl::StatusOr<int> MakeStatus() { return 100; }
TEST(StatusOr, TestIgnoreError) { MakeStatus().IgnoreError(); }
TEST(StatusOr, EqualityOperator) {
constexpr int kNumCases = 4;
constexpr size_t kNumCases = 4;
std::array<absl::StatusOr<int>, kNumCases> group1 = {
absl::StatusOr<int>(1), absl::StatusOr<int>(2),
absl::StatusOr<int>(absl::InvalidArgumentError("msg")),
......@@ -1530,8 +1530,8 @@ TEST(StatusOr, EqualityOperator) {
absl::StatusOr<int>(1), absl::StatusOr<int>(2),
absl::StatusOr<int>(absl::InvalidArgumentError("msg")),
absl::StatusOr<int>(absl::InternalError("msg"))};
for (int i = 0; i < kNumCases; ++i) {
for (int j = 0; j < kNumCases; ++j) {
for (size_t i = 0; i < kNumCases; ++i) {
for (size_t j = 0; j < kNumCases; ++j) {
if (i == j) {
EXPECT_TRUE(group1[i] == group2[j]);
EXPECT_FALSE(group1[i] != group2[j]);
......
absl/types/optional_test.cc
......@@ -988,8 +988,8 @@ TEST(optionalTest, PointerStuff) {
EXPECT_EQ("foo", *opt);
const auto& opt_const = opt;
EXPECT_EQ("foo", *opt_const);
EXPECT_EQ(opt->size(), 3);
EXPECT_EQ(opt_const->size(), 3);
EXPECT_EQ(opt->size(), 3u);
EXPECT_EQ(opt_const->size(), 3u);
constexpr absl::optional<ConstexprType> opt1(1);
static_assert((*opt1).x == ConstexprType::kCtorInt, "");
......@@ -1523,7 +1523,7 @@ TEST(optionalTest, Hash) {
for (int i = 0; i < 100; ++i) {
hashcodes.insert(hash(i));
}
EXPECT_GT(hashcodes.size(), 90);
EXPECT_GT(hashcodes.size(), 90u);
static_assert(is_hash_enabled_for<absl::optional<int>>::value, "");
static_assert(is_hash_enabled_for<absl::optional<Hashable>>::value, "");
......
absl/types/variant_test.cc
......@@ -281,7 +281,7 @@ TEST(VariantTest, TestDefaultConstructor) {
using X = variant<int>;
constexpr variant<int> x{};
ASSERT_FALSE(x.valueless_by_exception());
ASSERT_EQ(0, x.index());
ASSERT_EQ(0u, x.index());
EXPECT_EQ(0, absl::get<0>(x));
EXPECT_TRUE(std::is_nothrow_default_constructible<X>::value);
}
......@@ -290,7 +290,7 @@ TEST(VariantTest, TestDefaultConstructor) {
using X = variant<NonNoexceptDefaultConstructible>;
X x{};
ASSERT_FALSE(x.valueless_by_exception());
ASSERT_EQ(0, x.index());
ASSERT_EQ(0u, x.index());
EXPECT_EQ(5, absl::get<0>(x).value);
EXPECT_FALSE(std::is_nothrow_default_constructible<X>::value);
}
......@@ -299,7 +299,7 @@ TEST(VariantTest, TestDefaultConstructor) {
using X = variant<int, NonNoexceptDefaultConstructible>;
X x{};
ASSERT_FALSE(x.valueless_by_exception());
ASSERT_EQ(0, x.index());
ASSERT_EQ(0u, x.index());
EXPECT_EQ(0, absl::get<0>(x));
EXPECT_TRUE(std::is_nothrow_default_constructible<X>::value);
}
......@@ -308,7 +308,7 @@ TEST(VariantTest, TestDefaultConstructor) {
using X = variant<NonNoexceptDefaultConstructible, int>;
X x{};
ASSERT_FALSE(x.valueless_by_exception());
ASSERT_EQ(0, x.index());
ASSERT_EQ(0u, x.index());
EXPECT_EQ(5, absl::get<0>(x).value);
EXPECT_FALSE(std::is_nothrow_default_constructible<X>::value);
}
......@@ -480,7 +480,7 @@ TEST(VariantTest, InPlaceType) {
ASSERT_TRUE(absl::holds_alternative<std::string>(v2));
EXPECT_EQ("ABC", absl::get<std::string>(v2));
Var v3(in_place_type_t<std::string>(), "ABC", 2);
Var v3(in_place_type_t<std::string>(), "ABC", 2u);
ASSERT_TRUE(absl::holds_alternative<std::string>(v3));
EXPECT_EQ("AB", absl::get<std::string>(v3));
......@@ -503,7 +503,7 @@ TEST(VariantTest, InPlaceTypeVariableTemplate) {
ASSERT_TRUE(absl::holds_alternative<std::string>(v2));
EXPECT_EQ("ABC", absl::get<std::string>(v2));
Var v3(in_place_type<std::string>, "ABC", 2);
Var v3(in_place_type<std::string>, "ABC", 2u);
ASSERT_TRUE(absl::holds_alternative<std::string>(v3));
EXPECT_EQ("AB", absl::get<std::string>(v3));
......@@ -544,7 +544,7 @@ TEST(VariantTest, InPlaceIndex) {
ASSERT_TRUE(absl::holds_alternative<std::string>(v2));
EXPECT_EQ("ABC", absl::get<std::string>(v2));
Var v3(in_place_index_t<1>(), "ABC", 2);
Var v3(in_place_index_t<1>(), "ABC", 2u);
ASSERT_TRUE(absl::holds_alternative<std::string>(v3));
EXPECT_EQ("AB", absl::get<std::string>(v3));
......@@ -571,7 +571,7 @@ TEST(VariantTest, InPlaceIndexVariableTemplate) {
ASSERT_TRUE(absl::holds_alternative<std::string>(v2));
EXPECT_EQ("ABC", absl::get<std::string>(v2));
Var v3(in_place_index<1>, "ABC", 2);
Var v3(in_place_index<1>, "ABC", 2u);
ASSERT_TRUE(absl::holds_alternative<std::string>(v3));
EXPECT_EQ("AB", absl::get<std::string>(v3));
......@@ -688,11 +688,11 @@ TEST(VariantTest, TestSelfAssignment) {
EXPECT_EQ(long_str, foo);
variant<int, std::string> so = long_str;
ASSERT_EQ(1, so.index());
ASSERT_EQ(1u, so.index());
EXPECT_EQ(long_str, absl::get<1>(so));
so = *&so;
ASSERT_EQ(1, so.index());
ASSERT_EQ(1u, so.index());
EXPECT_EQ(long_str, absl::get<1>(so));
}
......@@ -968,16 +968,16 @@ TEST(VariantTest, Index) {
using Var = variant<int, std::string, double>;
Var v = 1;
EXPECT_EQ(0, v.index());
EXPECT_EQ(0u, v.index());
v = "str";
EXPECT_EQ(1, v.index());
EXPECT_EQ(1u, v.index());
v = 0.;
EXPECT_EQ(2, v.index());
EXPECT_EQ(2u, v.index());
Var v2 = v;
EXPECT_EQ(2, v2.index());
EXPECT_EQ(2u, v2.index());
v2.emplace<int>(3);
EXPECT_EQ(0, v2.index());
EXPECT_EQ(0u, v2.index());
}
TEST(VariantTest, NotValuelessByException) {
......@@ -1002,11 +1002,11 @@ TEST(VariantTest, IndexValuelessByException) {
using Var = variant<MoveCanThrow, std::string, double>;
Var v(absl::in_place_index<0>);
EXPECT_EQ(0, v.index());
EXPECT_EQ(0u, v.index());
ToValuelessByException(v);
EXPECT_EQ(absl::variant_npos, v.index());
v = "str";
EXPECT_EQ(1, v.index());
EXPECT_EQ(1u, v.index());
}
TEST(VariantTest, ValuelessByException) {
......@@ -1084,18 +1084,18 @@ TEST(VariantTest, MemberSwap) {
TEST(VariantTest, VariantSize) {
{
using Size1Variant = absl::variant<int>;
EXPECT_EQ(1, absl::variant_size<Size1Variant>::value);
EXPECT_EQ(1, absl::variant_size<const Size1Variant>::value);
EXPECT_EQ(1, absl::variant_size<volatile Size1Variant>::value);
EXPECT_EQ(1, absl::variant_size<const volatile Size1Variant>::value);
EXPECT_EQ(1u, absl::variant_size<Size1Variant>::value);
EXPECT_EQ(1u, absl::variant_size<const Size1Variant>::value);
EXPECT_EQ(1u, absl::variant_size<volatile Size1Variant>::value);
EXPECT_EQ(1u, absl::variant_size<const volatile Size1Variant>::value);
}
{
using Size3Variant = absl::variant<int, float, int>;
EXPECT_EQ(3, absl::variant_size<Size3Variant>::value);
EXPECT_EQ(3, absl::variant_size<const Size3Variant>::value);
EXPECT_EQ(3, absl::variant_size<volatile Size3Variant>::value);
EXPECT_EQ(3, absl::variant_size<const volatile Size3Variant>::value);
EXPECT_EQ(3u, absl::variant_size<Size3Variant>::value);
EXPECT_EQ(3u, absl::variant_size<const Size3Variant>::value);
EXPECT_EQ(3u, absl::variant_size<volatile Size3Variant>::value);
EXPECT_EQ(3u, absl::variant_size<const volatile Size3Variant>::value);
}
}
......@@ -1799,14 +1799,14 @@ TEST(VariantTest, VisitSimple) {
EXPECT_EQ("B", piece);
struct StrLen {
int operator()(const char* s) const { return strlen(s); }
int operator()(const std::string& s) const { return s.size(); }
size_t operator()(const char* s) const { return strlen(s); }
size_t operator()(const std::string& s) const { return s.size(); }
};
v = "SomeStr";
EXPECT_EQ(7, absl::visit(StrLen{}, v));
EXPECT_EQ(7u, absl::visit(StrLen{}, v));
v = std::string("VeryLargeThisTime");
EXPECT_EQ(17, absl::visit(StrLen{}, v));
EXPECT_EQ(17u, absl::visit(StrLen{}, v));
}
TEST(VariantTest, VisitRValue) {
......@@ -1979,7 +1979,7 @@ TEST(VariantTest, MonostateBasic) {
TEST(VariantTest, VariantMonostateDefaultConstruction) {
absl::variant<absl::monostate, NonDefaultConstructible> var;
EXPECT_EQ(var.index(), 0);
EXPECT_EQ(var.index(), 0u);
}
////////////////////////////////
......@@ -2100,7 +2100,7 @@ TEST(VariantTest, Hash) {
for (int i = 0; i < 100; ++i) {
hashcodes.insert(hash(i));
}
EXPECT_GT(hashcodes.size(), 90);
EXPECT_GT(hashcodes.size(), 90u);
// test const-qualified
static_assert(type_traits_internal::IsHashable<variant<const int>>::value,
......@@ -2312,9 +2312,9 @@ TEST(VariantTest, TestRvalueConversion) {
EXPECT_EQ(42, absl::get<int32_t>(variant2));
variant2 =
ConvertVariantTo<variant<int32_t, uint32_t>>(variant<uint32_t>(42));
ConvertVariantTo<variant<int32_t, uint32_t>>(variant<uint32_t>(42u));
ASSERT_TRUE(absl::holds_alternative<uint32_t>(variant2));
EXPECT_EQ(42, absl::get<uint32_t>(variant2));
EXPECT_EQ(42u, absl::get<uint32_t>(variant2));
#endif // !ABSL_USES_STD_VARIANT
variant<Convertible1, Convertible2> variant3(
......@@ -2361,10 +2361,10 @@ TEST(VariantTest, TestLvalueConversion) {
ASSERT_TRUE(absl::holds_alternative<int32_t>(variant2));
EXPECT_EQ(42, absl::get<int32_t>(variant2));
variant<uint32_t> source6(42);
variant<uint32_t> source6(42u);
variant2 = ConvertVariantTo<variant<int32_t, uint32_t>>(source6);
ASSERT_TRUE(absl::holds_alternative<uint32_t>(variant2));
EXPECT_EQ(42, absl::get<uint32_t>(variant2));
EXPECT_EQ(42u, absl::get<uint32_t>(variant2));
#endif
variant<Convertible2, Convertible1> source7((Convertible1()));
......@@ -2455,8 +2455,8 @@ TEST(VariantTest, TestRvalueConversionViaConvertVariantTo) {
EXPECT_THAT(absl::get_if<int32_t>(&variant2), Pointee(42));
variant2 =
ConvertVariantTo<variant<int32_t, uint32_t>>(variant<uint32_t>(42));
EXPECT_THAT(absl::get_if<uint32_t>(&variant2), Pointee(42));
ConvertVariantTo<variant<int32_t, uint32_t>>(variant<uint32_t>(42u));
EXPECT_THAT(absl::get_if<uint32_t>(&variant2), Pointee(42u));
#endif
variant<Convertible1, Convertible2> variant3(
......@@ -2499,9 +2499,9 @@ TEST(VariantTest, TestLvalueConversionViaConvertVariantTo) {
ConvertVariantTo<variant<int32_t, uint32_t>>(source5));
EXPECT_THAT(absl::get_if<int32_t>(&variant2), Pointee(42));
variant<uint32_t> source6(42);
variant<uint32_t> source6(42u);
variant2 = ConvertVariantTo<variant<int32_t, uint32_t>>(source6);
EXPECT_THAT(absl::get_if<uint32_t>(&variant2), Pointee(42));
EXPECT_THAT(absl::get_if<uint32_t>(&variant2), Pointee(42u));
#endif // !ABSL_USES_STD_VARIANT
variant<Convertible2, Convertible1> source7((Convertible1()));
......@@ -2570,7 +2570,7 @@ TEST(VariantTest, TestVectorOfMoveonlyVariant) {
vec.reserve(3);
auto another_vec = absl::move(vec);
// As a sanity check, verify vector contents.
ASSERT_EQ(2, another_vec.size());
ASSERT_EQ(2u, another_vec.size());
EXPECT_EQ(42, *absl::get<std::unique_ptr<int>>(another_vec[0]));
EXPECT_EQ("Hello", absl::get<std::string>(another_vec[1]));
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment