From 2594f855145255e2c0e21f423e6a1149f2055962 Mon Sep 17 00:00:00 2001 From: Abseil Team Date: Thu, 8 Sep 2022 12:27:50 -0700 Subject: 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 --- absl/types/variant_test.cc | 80 +++++++++++++++++++++++----------------------- 1 file changed, 40 insertions(+), 40 deletions(-) (limited to 'absl/types/variant_test.cc') diff --git a/absl/types/variant_test.cc b/absl/types/variant_test.cc index cf237334..4cd5b7a3 100644 --- a/absl/types/variant_test.cc +++ b/absl/types/variant_test.cc @@ -281,7 +281,7 @@ TEST(VariantTest, TestDefaultConstructor) { using X = variant; constexpr variant 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::value); } @@ -290,7 +290,7 @@ TEST(VariantTest, TestDefaultConstructor) { using X = variant; 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::value); } @@ -299,7 +299,7 @@ TEST(VariantTest, TestDefaultConstructor) { using X = variant; 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::value); } @@ -308,7 +308,7 @@ TEST(VariantTest, TestDefaultConstructor) { using X = variant; 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::value); } @@ -480,7 +480,7 @@ TEST(VariantTest, InPlaceType) { ASSERT_TRUE(absl::holds_alternative(v2)); EXPECT_EQ("ABC", absl::get(v2)); - Var v3(in_place_type_t(), "ABC", 2); + Var v3(in_place_type_t(), "ABC", 2u); ASSERT_TRUE(absl::holds_alternative(v3)); EXPECT_EQ("AB", absl::get(v3)); @@ -503,7 +503,7 @@ TEST(VariantTest, InPlaceTypeVariableTemplate) { ASSERT_TRUE(absl::holds_alternative(v2)); EXPECT_EQ("ABC", absl::get(v2)); - Var v3(in_place_type, "ABC", 2); + Var v3(in_place_type, "ABC", 2u); ASSERT_TRUE(absl::holds_alternative(v3)); EXPECT_EQ("AB", absl::get(v3)); @@ -544,7 +544,7 @@ TEST(VariantTest, InPlaceIndex) { ASSERT_TRUE(absl::holds_alternative(v2)); EXPECT_EQ("ABC", absl::get(v2)); - Var v3(in_place_index_t<1>(), "ABC", 2); + Var v3(in_place_index_t<1>(), "ABC", 2u); ASSERT_TRUE(absl::holds_alternative(v3)); EXPECT_EQ("AB", absl::get(v3)); @@ -571,7 +571,7 @@ TEST(VariantTest, InPlaceIndexVariableTemplate) { ASSERT_TRUE(absl::holds_alternative(v2)); EXPECT_EQ("ABC", absl::get(v2)); - Var v3(in_place_index<1>, "ABC", 2); + Var v3(in_place_index<1>, "ABC", 2u); ASSERT_TRUE(absl::holds_alternative(v3)); EXPECT_EQ("AB", absl::get(v3)); @@ -688,11 +688,11 @@ TEST(VariantTest, TestSelfAssignment) { EXPECT_EQ(long_str, foo); variant 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; 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(3); - EXPECT_EQ(0, v2.index()); + EXPECT_EQ(0u, v2.index()); } TEST(VariantTest, NotValuelessByException) { @@ -1002,11 +1002,11 @@ TEST(VariantTest, IndexValuelessByException) { using Var = variant; 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; - EXPECT_EQ(1, absl::variant_size::value); - EXPECT_EQ(1, absl::variant_size::value); - EXPECT_EQ(1, absl::variant_size::value); - EXPECT_EQ(1, absl::variant_size::value); + EXPECT_EQ(1u, absl::variant_size::value); + EXPECT_EQ(1u, absl::variant_size::value); + EXPECT_EQ(1u, absl::variant_size::value); + EXPECT_EQ(1u, absl::variant_size::value); } { using Size3Variant = absl::variant; - EXPECT_EQ(3, absl::variant_size::value); - EXPECT_EQ(3, absl::variant_size::value); - EXPECT_EQ(3, absl::variant_size::value); - EXPECT_EQ(3, absl::variant_size::value); + EXPECT_EQ(3u, absl::variant_size::value); + EXPECT_EQ(3u, absl::variant_size::value); + EXPECT_EQ(3u, absl::variant_size::value); + EXPECT_EQ(3u, absl::variant_size::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 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>::value, @@ -2312,9 +2312,9 @@ TEST(VariantTest, TestRvalueConversion) { EXPECT_EQ(42, absl::get(variant2)); variant2 = - ConvertVariantTo>(variant(42)); + ConvertVariantTo>(variant(42u)); ASSERT_TRUE(absl::holds_alternative(variant2)); - EXPECT_EQ(42, absl::get(variant2)); + EXPECT_EQ(42u, absl::get(variant2)); #endif // !ABSL_USES_STD_VARIANT variant variant3( @@ -2361,10 +2361,10 @@ TEST(VariantTest, TestLvalueConversion) { ASSERT_TRUE(absl::holds_alternative(variant2)); EXPECT_EQ(42, absl::get(variant2)); - variant source6(42); + variant source6(42u); variant2 = ConvertVariantTo>(source6); ASSERT_TRUE(absl::holds_alternative(variant2)); - EXPECT_EQ(42, absl::get(variant2)); + EXPECT_EQ(42u, absl::get(variant2)); #endif variant source7((Convertible1())); @@ -2455,8 +2455,8 @@ TEST(VariantTest, TestRvalueConversionViaConvertVariantTo) { EXPECT_THAT(absl::get_if(&variant2), Pointee(42)); variant2 = - ConvertVariantTo>(variant(42)); - EXPECT_THAT(absl::get_if(&variant2), Pointee(42)); + ConvertVariantTo>(variant(42u)); + EXPECT_THAT(absl::get_if(&variant2), Pointee(42u)); #endif variant variant3( @@ -2499,9 +2499,9 @@ TEST(VariantTest, TestLvalueConversionViaConvertVariantTo) { ConvertVariantTo>(source5)); EXPECT_THAT(absl::get_if(&variant2), Pointee(42)); - variant source6(42); + variant source6(42u); variant2 = ConvertVariantTo>(source6); - EXPECT_THAT(absl::get_if(&variant2), Pointee(42)); + EXPECT_THAT(absl::get_if(&variant2), Pointee(42u)); #endif // !ABSL_USES_STD_VARIANT variant 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>(another_vec[0])); EXPECT_EQ("Hello", absl::get(another_vec[1])); } -- cgit v1.2.3