Cleanup: Handles -Wsign-compare -Werror
Handles -Wsign-compare when Emboss is tested against a more-strict
version of GUnit.
diff --git a/back_end/cpp/build_defs.bzl b/back_end/cpp/build_defs.bzl
index fd891da..a1df7aa 100644
--- a/back_end/cpp/build_defs.bzl
+++ b/back_end/cpp/build_defs.bzl
@@ -16,7 +16,7 @@
# vim:set ft=blazebuild:
"""Rule to generate cc_tests with and without system-specific optimizations."""
-def emboss_cc_test(name, copts = None, **kwargs):
+def emboss_cc_test(name, copts = None, no_w_sign_compare = False, **kwargs):
"""Generates cc_test rules with and without -DEMBOSS_NO_OPTIMIZATIONS."""
native.cc_test(
name = name,
@@ -28,6 +28,6 @@
copts = [
"-DEMBOSS_NO_OPTIMIZATIONS",
"-DEMBOSS_FORCE_ALL_CHECKS",
- ] + (copts or []),
+ ] + ([] if no_w_sign_compare else ["-Wsign-compare"]) + (copts or []),
**kwargs
)
diff --git a/back_end/cpp/testcode/auto_array_size_test.cc b/back_end/cpp/testcode/auto_array_size_test.cc
index 6fc2073..c689afb 100644
--- a/back_end/cpp/testcode/auto_array_size_test.cc
+++ b/back_end/cpp/testcode/auto_array_size_test.cc
@@ -198,36 +198,36 @@
TEST(AutoSizeView, CanReadAutoArrays) {
auto view = MakeAlignedAutoSizeView<const ::std::uint8_t, 8>(
kAutoSize, sizeof kAutoSize);
- EXPECT_EQ(22, view.SizeInBytes());
- EXPECT_EQ(3, view.array_size().Read());
- EXPECT_EQ(0x10, view.four_byte_array()[0].Read());
- EXPECT_EQ(0x20, view.four_byte_array()[1].Read());
- EXPECT_EQ(0x30, view.four_byte_array()[2].Read());
- EXPECT_EQ(0x40, view.four_byte_array()[3].Read());
- EXPECT_EQ(4, view.four_byte_array().SizeInBytes());
+ EXPECT_EQ(22U, view.SizeInBytes());
+ EXPECT_EQ(3U, view.array_size().Read());
+ EXPECT_EQ(0x10U, view.four_byte_array()[0].Read());
+ EXPECT_EQ(0x20U, view.four_byte_array()[1].Read());
+ EXPECT_EQ(0x30U, view.four_byte_array()[2].Read());
+ EXPECT_EQ(0x40U, view.four_byte_array()[3].Read());
+ EXPECT_EQ(4U, view.four_byte_array().SizeInBytes());
EXPECT_DEATH(view.four_byte_array()[4].Read(), "");
- EXPECT_EQ(0x11, view.four_struct_array()[0].a().Read());
- EXPECT_EQ(0x12, view.four_struct_array()[0].b().Read());
- EXPECT_EQ(0x21, view.four_struct_array()[1].a().Read());
- EXPECT_EQ(0x22, view.four_struct_array()[1].b().Read());
- EXPECT_EQ(0x31, view.four_struct_array()[2].a().Read());
- EXPECT_EQ(0x32, view.four_struct_array()[2].b().Read());
- EXPECT_EQ(0x41, view.four_struct_array()[3].a().Read());
- EXPECT_EQ(0x42, view.four_struct_array()[3].b().Read());
- EXPECT_EQ(8, view.four_struct_array().SizeInBytes());
+ EXPECT_EQ(0x11U, view.four_struct_array()[0].a().Read());
+ EXPECT_EQ(0x12U, view.four_struct_array()[0].b().Read());
+ EXPECT_EQ(0x21U, view.four_struct_array()[1].a().Read());
+ EXPECT_EQ(0x22U, view.four_struct_array()[1].b().Read());
+ EXPECT_EQ(0x31U, view.four_struct_array()[2].a().Read());
+ EXPECT_EQ(0x32U, view.four_struct_array()[2].b().Read());
+ EXPECT_EQ(0x41U, view.four_struct_array()[3].a().Read());
+ EXPECT_EQ(0x42U, view.four_struct_array()[3].b().Read());
+ EXPECT_EQ(8U, view.four_struct_array().SizeInBytes());
EXPECT_DEATH(view.four_struct_array()[4].a().Read(), "");
- EXPECT_EQ(0x50, view.dynamic_byte_array()[0].Read());
- EXPECT_EQ(0x60, view.dynamic_byte_array()[1].Read());
- EXPECT_EQ(0x70, view.dynamic_byte_array()[2].Read());
- EXPECT_EQ(3, view.dynamic_byte_array().SizeInBytes());
+ EXPECT_EQ(0x50U, view.dynamic_byte_array()[0].Read());
+ EXPECT_EQ(0x60U, view.dynamic_byte_array()[1].Read());
+ EXPECT_EQ(0x70U, view.dynamic_byte_array()[2].Read());
+ EXPECT_EQ(3U, view.dynamic_byte_array().SizeInBytes());
EXPECT_FALSE(view.dynamic_byte_array()[3].IsComplete());
- EXPECT_EQ(0x51, view.dynamic_struct_array()[0].a().Read());
- EXPECT_EQ(0x52, view.dynamic_struct_array()[0].b().Read());
- EXPECT_EQ(0x61, view.dynamic_struct_array()[1].a().Read());
- EXPECT_EQ(0x62, view.dynamic_struct_array()[1].b().Read());
- EXPECT_EQ(0x71, view.dynamic_struct_array()[2].a().Read());
- EXPECT_EQ(0x72, view.dynamic_struct_array()[2].b().Read());
- EXPECT_EQ(6, view.dynamic_struct_array().SizeInBytes());
+ EXPECT_EQ(0x51U, view.dynamic_struct_array()[0].a().Read());
+ EXPECT_EQ(0x52U, view.dynamic_struct_array()[0].b().Read());
+ EXPECT_EQ(0x61U, view.dynamic_struct_array()[1].a().Read());
+ EXPECT_EQ(0x62U, view.dynamic_struct_array()[1].b().Read());
+ EXPECT_EQ(0x71U, view.dynamic_struct_array()[2].a().Read());
+ EXPECT_EQ(0x72U, view.dynamic_struct_array()[2].b().Read());
+ EXPECT_EQ(6U, view.dynamic_struct_array().SizeInBytes());
EXPECT_FALSE(view.dynamic_struct_array()[3].IsComplete());
}
@@ -235,10 +235,10 @@
::std::vector<char> buffer(sizeof kAutoSize, 0);
auto writer = MakeAutoSizeView(&buffer);
writer.array_size().Write(0);
- EXPECT_EQ(13, writer.SizeInBytes());
+ EXPECT_EQ(13U, writer.SizeInBytes());
EXPECT_DEATH(writer.dynamic_byte_array()[0].Read(), "");
writer.array_size().Write(3);
- EXPECT_EQ(22, writer.SizeInBytes());
+ EXPECT_EQ(22U, writer.SizeInBytes());
writer.four_byte_array()[0].Write(0x10);
writer.four_byte_array()[1].Write(0x20);
writer.four_byte_array()[2].Write(0x30);
diff --git a/back_end/cpp/testcode/bcd_test.cc b/back_end/cpp/testcode/bcd_test.cc
index 74cd619..d545436 100644
--- a/back_end/cpp/testcode/bcd_test.cc
+++ b/back_end/cpp/testcode/bcd_test.cc
@@ -52,8 +52,8 @@
MakeAlignedBcdSizesView<const ::std::uint8_t, 8>(kBcd, sizeof kBcd);
EXPECT_EQ(2, view.one_byte().Read());
EXPECT_EQ(104, view.two_byte().Read());
- EXPECT_EQ(445566, view.three_byte().Read());
- EXPECT_EQ(3040506, view.four_byte().Read());
+ EXPECT_EQ(445566U, view.three_byte().Read());
+ EXPECT_EQ(3040506U, view.four_byte().Read());
EXPECT_EQ(9987654321UL, view.five_byte().Read());
EXPECT_EQ(123456789123UL, view.six_byte().Read());
EXPECT_EQ(91827364554637UL, view.seven_byte().Read());
@@ -63,18 +63,18 @@
EXPECT_EQ(307, view.ten_bit().Read());
EXPECT_EQ(123, view.twelve_bit().Read());
// Test that the views return appropriate integer widths.
- EXPECT_EQ(1, sizeof(view.one_byte().Read()));
- EXPECT_EQ(2, sizeof(view.two_byte().Read()));
- EXPECT_EQ(4, sizeof(view.three_byte().Read()));
- EXPECT_EQ(4, sizeof(view.four_byte().Read()));
- EXPECT_EQ(8, sizeof(view.five_byte().Read()));
- EXPECT_EQ(8, sizeof(view.six_byte().Read()));
- EXPECT_EQ(8, sizeof(view.seven_byte().Read()));
- EXPECT_EQ(8, sizeof(view.eight_byte().Read()));
- EXPECT_EQ(1, sizeof(view.four_bit().Read()));
- EXPECT_EQ(1, sizeof(view.six_bit().Read()));
- EXPECT_EQ(2, sizeof(view.ten_bit().Read()));
- EXPECT_EQ(2, sizeof(view.twelve_bit().Read()));
+ EXPECT_EQ(1U, sizeof(view.one_byte().Read()));
+ EXPECT_EQ(2U, sizeof(view.two_byte().Read()));
+ EXPECT_EQ(4U, sizeof(view.three_byte().Read()));
+ EXPECT_EQ(4U, sizeof(view.four_byte().Read()));
+ EXPECT_EQ(8U, sizeof(view.five_byte().Read()));
+ EXPECT_EQ(8U, sizeof(view.six_byte().Read()));
+ EXPECT_EQ(8U, sizeof(view.seven_byte().Read()));
+ EXPECT_EQ(8U, sizeof(view.eight_byte().Read()));
+ EXPECT_EQ(1U, sizeof(view.four_bit().Read()));
+ EXPECT_EQ(1U, sizeof(view.six_bit().Read()));
+ EXPECT_EQ(2U, sizeof(view.ten_bit().Read()));
+ EXPECT_EQ(2U, sizeof(view.twelve_bit().Read()));
}
TEST(BcdSizesWriter, CanWriteBcd) {
@@ -182,7 +182,7 @@
TEST(BcdBigEndianView, BigEndianReadWrite) {
::std::uint8_t big_endian[4] = {0x12, 0x34, 0x56, 0x78};
auto writer = BcdBigEndianWriter(big_endian, sizeof big_endian);
- EXPECT_EQ(12345678, writer.four_byte().Read());
+ EXPECT_EQ(12345678U, writer.four_byte().Read());
writer.four_byte().Write(87654321);
EXPECT_EQ(0x87, big_endian[0]);
EXPECT_EQ(0x65, big_endian[1]);
diff --git a/back_end/cpp/testcode/bits_test.cc b/back_end/cpp/testcode/bits_test.cc
index 1d24bc7..13e1180 100644
--- a/back_end/cpp/testcode/bits_test.cc
+++ b/back_end/cpp/testcode/bits_test.cc
@@ -116,8 +116,8 @@
EXPECT_EQ(true, array.array_in_bits().flags()[11].Read());
array.array_in_bits().flags()[8].Write(true);
EXPECT_EQ(0xab, data[1]);
- EXPECT_EQ(12, array.array_in_bits().flags().SizeInBits());
- EXPECT_EQ(12, array.array_in_bits().flags().ElementCount());
+ EXPECT_EQ(12U, array.array_in_bits().flags().SizeInBits());
+ EXPECT_EQ(12U, array.array_in_bits().flags().ElementCount());
EXPECT_TRUE(array.array_in_bits().flags().Ok());
EXPECT_TRUE(array.array_in_bits().flags().IsComplete());
}
diff --git a/back_end/cpp/testcode/condition_test.cc b/back_end/cpp/testcode/condition_test.cc
index 0750eea..8b88f23 100644
--- a/back_end/cpp/testcode/condition_test.cc
+++ b/back_end/cpp/testcode/condition_test.cc
@@ -76,7 +76,7 @@
TEST(Conditional, BasicConditionTrueSizeIncludesConditionalField) {
::std::uint8_t buffer[2] = {0, 2};
auto writer = BasicConditionalWriter(buffer, sizeof buffer);
- EXPECT_EQ(2, writer.SizeInBytes());
+ EXPECT_EQ(2U, writer.SizeInBytes());
EXPECT_EQ(2, BasicConditional::MaxSizeInBytes());
EXPECT_EQ(1, BasicConditional::MinSizeInBytes());
EXPECT_EQ(2, writer.MaxSizeInBytes().Read());
@@ -86,7 +86,7 @@
TEST(Conditional, BasicConditionFalseSizeDoesNotIncludeConditionalField) {
::std::uint8_t buffer[2] = {1, 2};
auto writer = BasicConditionalWriter(buffer, sizeof buffer);
- EXPECT_EQ(1, writer.SizeInBytes());
+ EXPECT_EQ(1U, writer.SizeInBytes());
EXPECT_EQ(2, writer.MaxSizeInBytes().Read());
EXPECT_EQ(1, writer.MinSizeInBytes().Read());
}
@@ -173,13 +173,13 @@
TEST(Conditional, NegativeConditionTrueSizeIncludesConditionalField) {
::std::uint8_t buffer[2] = {1, 2};
auto writer = NegativeConditionalWriter(buffer, sizeof buffer);
- EXPECT_EQ(2, writer.SizeInBytes());
+ EXPECT_EQ(2U, writer.SizeInBytes());
}
TEST(Conditional, NegativeConditionFalseSizeDoesNotIncludeConditionalField) {
::std::uint8_t buffer[2] = {0, 2};
auto writer = NegativeConditionalWriter(buffer, sizeof buffer);
- EXPECT_EQ(1, writer.SizeInBytes());
+ EXPECT_EQ(1U, writer.SizeInBytes());
}
TEST(Conditional, WithNegativeConditionFalseStructIsOkWhenBufferIsSmall) {
@@ -206,38 +206,39 @@
auto writer = ConditionalAndUnconditionalOverlappingFinalFieldWriter(
buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
- EXPECT_EQ(2, writer.SizeInBytes());
+ EXPECT_EQ(2U, writer.SizeInBytes());
}
TEST(Conditional,
SizeIsConstantWhenUnconditionalFieldsOverlapWithConditionalFields) {
EXPECT_EQ(
- 2, ConditionalAndUnconditionalOverlappingFinalFieldWriter::SizeInBytes());
+ 2U,
+ ConditionalAndUnconditionalOverlappingFinalFieldWriter::SizeInBytes());
}
TEST(Conditional, WhenConditionalFieldIsFirstSizeIsConstant) {
- EXPECT_EQ(2, ConditionalBasicConditionalFieldFirstWriter::SizeInBytes());
+ EXPECT_EQ(2U, ConditionalBasicConditionalFieldFirstWriter::SizeInBytes());
}
TEST(Conditional, WhenConditionIsFalseDynamicallyPlacedFieldDoesNotAffectSize) {
::std::uint8_t buffer[3] = {1, 0, 10};
auto writer = ConditionalAndDynamicLocationWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
- EXPECT_EQ(3, writer.SizeInBytes());
+ EXPECT_EQ(3U, writer.SizeInBytes());
}
TEST(Conditional, WhenConditionIsTrueDynamicallyPlacedFieldDoesAffectSize) {
::std::uint8_t buffer[4] = {0, 0, 3, 0};
auto writer = ConditionalAndDynamicLocationWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
- EXPECT_EQ(4, writer.SizeInBytes());
+ EXPECT_EQ(4U, writer.SizeInBytes());
}
TEST(Conditional, WhenConditionIsTrueDynamicallyPlacedFieldOutOfRangeIsError) {
::std::uint8_t buffer[3] = {0, 0, 3};
auto writer = ConditionalAndDynamicLocationWriter(buffer, sizeof buffer);
EXPECT_FALSE(writer.Ok());
- EXPECT_EQ(4, writer.SizeInBytes());
+ EXPECT_EQ(4U, writer.SizeInBytes());
}
TEST(Conditional, ConditionUsesMinInt) {
@@ -245,12 +246,12 @@
auto view = MakeConditionUsesMinIntView(buffer, sizeof buffer);
EXPECT_TRUE(view.Ok());
EXPECT_FALSE(view.has_xc().ValueOr(true));
- EXPECT_EQ(1, view.SizeInBytes());
+ EXPECT_EQ(1U, view.SizeInBytes());
buffer[0] = 0x80;
EXPECT_TRUE(view.Ok());
EXPECT_EQ(-0x80, view.x().Read());
EXPECT_TRUE(view.has_xc().ValueOr(false));
- EXPECT_EQ(2, view.SizeInBytes());
+ EXPECT_EQ(2U, view.SizeInBytes());
}
TEST(Conditional,
@@ -278,7 +279,7 @@
EXPECT_TRUE(writer.has_xcc().Known());
EXPECT_FALSE(writer.has_xcc().Value());
EXPECT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(1, writer.SizeInBytes());
+ EXPECT_EQ(1U, writer.SizeInBytes());
}
TEST(Conditional, StructWithNestedConditionIsOkWhenOuterConditionExists) {
@@ -290,19 +291,19 @@
EXPECT_TRUE(writer.has_xc().Value());
EXPECT_TRUE(writer.has_xcc().Known());
EXPECT_FALSE(writer.has_xcc().Value());
- EXPECT_EQ(2, writer.SizeInBytes());
+ EXPECT_EQ(2U, writer.SizeInBytes());
}
TEST(Conditional, AlwaysMissingFieldDoesNotContributeToStaticSize) {
- EXPECT_EQ(0, OnlyAlwaysFalseConditionWriter::SizeInBytes());
- EXPECT_EQ(1, AlwaysFalseConditionWriter::SizeInBytes());
+ EXPECT_EQ(0U, OnlyAlwaysFalseConditionWriter::SizeInBytes());
+ EXPECT_EQ(1U, AlwaysFalseConditionWriter::SizeInBytes());
}
TEST(Conditional, AlwaysMissingFieldDoesNotContributeToSize) {
::std::uint8_t buffer[1] = {0};
auto view = MakeAlwaysFalseConditionDynamicSizeView(buffer, sizeof buffer);
ASSERT_TRUE(view.SizeIsKnown());
- EXPECT_EQ(1, view.SizeInBytes());
+ EXPECT_EQ(1U, view.SizeInBytes());
}
TEST(Conditional, StructIsOkWithAlwaysMissingField) {
@@ -310,8 +311,8 @@
auto writer = AlwaysFalseConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(1, writer.SizeInBytes());
- EXPECT_EQ(1, AlwaysFalseConditionView::SizeInBytes());
+ EXPECT_EQ(1U, writer.SizeInBytes());
+ EXPECT_EQ(1U, AlwaysFalseConditionView::SizeInBytes());
}
TEST(Conditional, StructIsOkWithOnlyAlwaysMissingField) {
@@ -319,12 +320,12 @@
auto writer = OnlyAlwaysFalseConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(0, writer.SizeInBytes());
- EXPECT_EQ(0, OnlyAlwaysFalseConditionView::SizeInBytes());
+ EXPECT_EQ(0U, writer.SizeInBytes());
+ EXPECT_EQ(0U, OnlyAlwaysFalseConditionView::SizeInBytes());
}
TEST(Conditional, ConditionDoesNotBlockStaticSize) {
- EXPECT_EQ(3, ConditionDoesNotContributeToSizeView::SizeInBytes());
+ EXPECT_EQ(3U, ConditionDoesNotContributeToSizeView::SizeInBytes());
}
TEST(Conditional, EqualsHaveAllFields) {
@@ -431,7 +432,7 @@
auto writer = EnumConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(2, writer.SizeInBytes());
+ EXPECT_EQ(2U, writer.SizeInBytes());
EXPECT_EQ(0, writer.xc().Read());
}
@@ -440,7 +441,7 @@
auto writer = EnumConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(1, writer.SizeInBytes());
+ EXPECT_EQ(1U, writer.SizeInBytes());
EXPECT_FALSE(writer.xc().Ok());
}
@@ -449,7 +450,7 @@
auto writer = NegativeEnumConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(2, writer.SizeInBytes());
+ EXPECT_EQ(2U, writer.SizeInBytes());
EXPECT_EQ(0, writer.xc().Read());
}
@@ -458,7 +459,7 @@
auto writer = NegativeEnumConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(1, writer.SizeInBytes());
+ EXPECT_EQ(1U, writer.SizeInBytes());
EXPECT_FALSE(writer.xc().Ok());
}
@@ -467,7 +468,7 @@
auto writer = LessThanConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(2, writer.SizeInBytes());
+ EXPECT_EQ(2U, writer.SizeInBytes());
EXPECT_TRUE(writer.xc().Ok());
}
@@ -476,7 +477,7 @@
auto writer = LessThanConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(1, writer.SizeInBytes());
+ EXPECT_EQ(1U, writer.SizeInBytes());
EXPECT_FALSE(writer.xc().Ok());
}
@@ -485,7 +486,7 @@
auto writer = LessThanConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(1, writer.SizeInBytes());
+ EXPECT_EQ(1U, writer.SizeInBytes());
EXPECT_FALSE(writer.xc().Ok());
}
@@ -494,7 +495,7 @@
auto writer = LessThanOrEqualConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(2, writer.SizeInBytes());
+ EXPECT_EQ(2U, writer.SizeInBytes());
EXPECT_TRUE(writer.xc().Ok());
}
@@ -503,7 +504,7 @@
auto writer = LessThanOrEqualConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(2, writer.SizeInBytes());
+ EXPECT_EQ(2U, writer.SizeInBytes());
EXPECT_TRUE(writer.xc().Ok());
}
@@ -512,7 +513,7 @@
auto writer = LessThanOrEqualConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(1, writer.SizeInBytes());
+ EXPECT_EQ(1U, writer.SizeInBytes());
EXPECT_FALSE(writer.xc().Ok());
}
@@ -521,7 +522,7 @@
auto writer = GreaterThanConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(1, writer.SizeInBytes());
+ EXPECT_EQ(1U, writer.SizeInBytes());
EXPECT_FALSE(writer.xc().Ok());
}
@@ -530,7 +531,7 @@
auto writer = GreaterThanConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(1, writer.SizeInBytes());
+ EXPECT_EQ(1U, writer.SizeInBytes());
EXPECT_FALSE(writer.xc().Ok());
}
@@ -539,7 +540,7 @@
auto writer = GreaterThanConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(2, writer.SizeInBytes());
+ EXPECT_EQ(2U, writer.SizeInBytes());
EXPECT_TRUE(writer.xc().Ok());
}
@@ -548,7 +549,7 @@
auto writer = GreaterThanOrEqualConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(1, writer.SizeInBytes());
+ EXPECT_EQ(1U, writer.SizeInBytes());
EXPECT_FALSE(writer.xc().Ok());
}
@@ -557,7 +558,7 @@
auto writer = GreaterThanOrEqualConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(2, writer.SizeInBytes());
+ EXPECT_EQ(2U, writer.SizeInBytes());
EXPECT_TRUE(writer.xc().Ok());
}
@@ -566,7 +567,7 @@
auto writer = GreaterThanOrEqualConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(2, writer.SizeInBytes());
+ EXPECT_EQ(2U, writer.SizeInBytes());
EXPECT_TRUE(writer.xc().Ok());
}
@@ -575,7 +576,7 @@
auto writer = RangeConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(2, writer.SizeInBytes());
+ EXPECT_EQ(2U, writer.SizeInBytes());
EXPECT_FALSE(writer.xc().Ok());
}
@@ -584,7 +585,7 @@
auto writer = RangeConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(2, writer.SizeInBytes());
+ EXPECT_EQ(2U, writer.SizeInBytes());
EXPECT_FALSE(writer.xc().Ok());
}
@@ -593,7 +594,7 @@
auto writer = RangeConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(2, writer.SizeInBytes());
+ EXPECT_EQ(2U, writer.SizeInBytes());
EXPECT_FALSE(writer.xc().Ok());
}
@@ -602,7 +603,7 @@
auto writer = RangeConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(3, writer.SizeInBytes());
+ EXPECT_EQ(3U, writer.SizeInBytes());
EXPECT_TRUE(writer.xc().Ok());
}
@@ -611,7 +612,7 @@
auto writer = ReverseRangeConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(2, writer.SizeInBytes());
+ EXPECT_EQ(2U, writer.SizeInBytes());
EXPECT_FALSE(writer.xc().Ok());
}
@@ -620,7 +621,7 @@
auto writer = ReverseRangeConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(2, writer.SizeInBytes());
+ EXPECT_EQ(2U, writer.SizeInBytes());
EXPECT_FALSE(writer.xc().Ok());
}
@@ -629,7 +630,7 @@
auto writer = ReverseRangeConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(2, writer.SizeInBytes());
+ EXPECT_EQ(2U, writer.SizeInBytes());
EXPECT_FALSE(writer.xc().Ok());
}
@@ -638,7 +639,7 @@
auto writer = ReverseRangeConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(3, writer.SizeInBytes());
+ EXPECT_EQ(3U, writer.SizeInBytes());
EXPECT_TRUE(writer.xc().Ok());
}
@@ -647,7 +648,7 @@
auto writer = AndConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(2, writer.SizeInBytes());
+ EXPECT_EQ(2U, writer.SizeInBytes());
EXPECT_FALSE(writer.xc().Ok());
}
@@ -656,7 +657,7 @@
auto writer = AndConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(2, writer.SizeInBytes());
+ EXPECT_EQ(2U, writer.SizeInBytes());
EXPECT_FALSE(writer.xc().Ok());
}
@@ -665,7 +666,7 @@
auto writer = AndConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(2, writer.SizeInBytes());
+ EXPECT_EQ(2U, writer.SizeInBytes());
EXPECT_FALSE(writer.xc().Ok());
}
@@ -674,7 +675,7 @@
auto writer = AndConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(3, writer.SizeInBytes());
+ EXPECT_EQ(3U, writer.SizeInBytes());
EXPECT_TRUE(writer.xc().Ok());
}
@@ -683,7 +684,7 @@
auto writer = OrConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(2, writer.SizeInBytes());
+ EXPECT_EQ(2U, writer.SizeInBytes());
EXPECT_FALSE(writer.xc().Ok());
}
@@ -692,7 +693,7 @@
auto writer = OrConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(3, writer.SizeInBytes());
+ EXPECT_EQ(3U, writer.SizeInBytes());
EXPECT_TRUE(writer.xc().Ok());
}
@@ -701,7 +702,7 @@
auto writer = OrConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(3, writer.SizeInBytes());
+ EXPECT_EQ(3U, writer.SizeInBytes());
EXPECT_TRUE(writer.xc().Ok());
}
@@ -710,7 +711,7 @@
auto writer = OrConditionWriter(buffer, sizeof buffer);
EXPECT_TRUE(writer.Ok());
ASSERT_TRUE(writer.SizeIsKnown());
- EXPECT_EQ(3, writer.SizeInBytes());
+ EXPECT_EQ(3U, writer.SizeInBytes());
EXPECT_TRUE(writer.xc().Ok());
}
@@ -719,7 +720,7 @@
auto view = MakeChoiceConditionView(&buffer);
EXPECT_TRUE(view.Ok());
EXPECT_TRUE(view.SizeIsKnown());
- EXPECT_EQ(4, view.SizeInBytes());
+ EXPECT_EQ(4U, view.SizeInBytes());
EXPECT_TRUE(view.has_xyc().ValueOr(false));
EXPECT_EQ(10, view.xyc().Read());
}
@@ -729,7 +730,7 @@
auto view = MakeChoiceConditionView(&buffer);
EXPECT_TRUE(view.Ok());
EXPECT_TRUE(view.SizeIsKnown());
- EXPECT_EQ(3, view.SizeInBytes());
+ EXPECT_EQ(3U, view.SizeInBytes());
EXPECT_FALSE(view.has_xyc().ValueOr(true));
}
diff --git a/back_end/cpp/testcode/dynamic_size_test.cc b/back_end/cpp/testcode/dynamic_size_test.cc
index 43970b9..003f298 100644
--- a/back_end/cpp/testcode/dynamic_size_test.cc
+++ b/back_end/cpp/testcode/dynamic_size_test.cc
@@ -35,29 +35,29 @@
// MessageView::SizeInBytes() returns the expected value.
TEST(MessageView, DynamicSizeIsCorrect) {
auto view = MessageView(&kMessage);
- EXPECT_EQ(12, view.SizeInBytes());
+ EXPECT_EQ(12U, view.SizeInBytes());
}
// Fields read the correct values.
TEST(MessageView, FieldsAreCorrect) {
auto view = MessageView(&kMessage);
- EXPECT_EQ(2, view.header_length().Read());
- EXPECT_EQ(6, view.message_length().Read());
- EXPECT_EQ(1, view.message()[0].Read());
- EXPECT_EQ(2, view.message()[1].Read());
- EXPECT_EQ(3, view.message()[2].Read());
- EXPECT_EQ(4, view.message()[3].Read());
- EXPECT_EQ(5, view.message()[4].Read());
- EXPECT_EQ(6, view.message()[5].Read());
- EXPECT_EQ(6, view.message().SizeInBytes());
+ EXPECT_EQ(2U, view.header_length().Read());
+ EXPECT_EQ(6U, view.message_length().Read());
+ EXPECT_EQ(1U, view.message()[0].Read());
+ EXPECT_EQ(2U, view.message()[1].Read());
+ EXPECT_EQ(3U, view.message()[2].Read());
+ EXPECT_EQ(4U, view.message()[3].Read());
+ EXPECT_EQ(5U, view.message()[4].Read());
+ EXPECT_EQ(6U, view.message()[5].Read());
+ EXPECT_EQ(6U, view.message().SizeInBytes());
EXPECT_DEATH(view.message()[6].Read(), "");
- EXPECT_EQ(0x0a090807, view.crc32().Read());
+ EXPECT_EQ(0x0a090807U, view.crc32().Read());
}
// The zero-length padding field works as expected.
TEST(MessageView, PaddingFieldWorks) {
auto view = MessageView(&kMessage);
- EXPECT_EQ(0, view.padding().SizeInBytes());
+ EXPECT_EQ(0U, view.padding().SizeInBytes());
EXPECT_DEATH(view.padding()[0].Read(), "");
}
@@ -73,21 +73,21 @@
// Fields read the correct values.
TEST(MessageView, PaddedMessageFieldsAreCorrect) {
auto view = MessageView(&kPaddedMessage);
- EXPECT_EQ(6, view.header_length().Read());
- EXPECT_EQ(4, view.message_length().Read());
- EXPECT_EQ(1, view.padding()[0].Read());
- EXPECT_EQ(2, view.padding()[1].Read());
- EXPECT_EQ(3, view.padding()[2].Read());
- EXPECT_EQ(4, view.padding()[3].Read());
- EXPECT_EQ(4, view.padding().SizeInBytes());
+ EXPECT_EQ(6U, view.header_length().Read());
+ EXPECT_EQ(4U, view.message_length().Read());
+ EXPECT_EQ(1U, view.padding()[0].Read());
+ EXPECT_EQ(2U, view.padding()[1].Read());
+ EXPECT_EQ(3U, view.padding()[2].Read());
+ EXPECT_EQ(4U, view.padding()[3].Read());
+ EXPECT_EQ(4U, view.padding().SizeInBytes());
EXPECT_DEATH(view.padding()[4].Read(), "");
- EXPECT_EQ(5, view.message()[0].Read());
- EXPECT_EQ(6, view.message()[1].Read());
- EXPECT_EQ(7, view.message()[2].Read());
- EXPECT_EQ(8, view.message()[3].Read());
- EXPECT_EQ(4, view.message().SizeInBytes());
+ EXPECT_EQ(5U, view.message()[0].Read());
+ EXPECT_EQ(6U, view.message()[1].Read());
+ EXPECT_EQ(7U, view.message()[2].Read());
+ EXPECT_EQ(8U, view.message()[3].Read());
+ EXPECT_EQ(4U, view.message().SizeInBytes());
EXPECT_DEATH(view.message()[4].Read(), "");
- EXPECT_EQ(0x0c0b0a09, view.crc32().Read());
+ EXPECT_EQ(0x0c0b0a09U, view.crc32().Read());
}
// Writes to fields produce the correct byte values.
@@ -102,7 +102,7 @@
for (int i = 0; i < writer.message_length().Read(); ++i) {
writer.message()[i].Write(i + 1);
}
- EXPECT_EQ(12, writer.SizeInBytes());
+ EXPECT_EQ(12U, writer.SizeInBytes());
EXPECT_DEATH(writer.message()[writer.message_length().Read()].Read(), "");
EXPECT_DEATH(writer.padding()[0].Read(), "");
writer.crc32().Write(0x0a090807);
@@ -115,12 +115,12 @@
auto writer2 = MessageWriter(buffer, sizeof buffer);
writer2.header_length().Write(6);
// Writes made through one writer should be immediately visible to the other.
- EXPECT_EQ(6, writer.header_length().Read());
- EXPECT_EQ(6, writer2.header_length().Read());
+ EXPECT_EQ(6U, writer.header_length().Read());
+ EXPECT_EQ(6U, writer2.header_length().Read());
writer2.message_length().Write(4);
// The message() field is now pointing to a different place; it should read
// the data that was already there.
- EXPECT_EQ(5, writer2.message()[0].Read());
+ EXPECT_EQ(5U, writer2.message()[0].Read());
// The padding bytes are already set to the correct values; do not update
// them.
for (int i = 0; i < writer2.message_length().Read(); ++i) {
@@ -213,15 +213,15 @@
// the order of their declarations works.
TEST(TwoRegionsView, RegionAFirstWorks) {
auto view = TwoRegionsView(kTwoRegionsAFirst, sizeof kTwoRegionsAFirst);
- EXPECT_EQ(10, view.SizeInBytes());
- EXPECT_EQ(4, view.a_start().Read());
- EXPECT_EQ(2, view.a_size().Read());
- EXPECT_EQ(6, view.b_start().Read());
- EXPECT_EQ(10, view.b_end().Read());
- EXPECT_EQ(0x11, view.region_a()[0].Read());
- EXPECT_EQ(0x22, view.region_a()[1].Read());
- EXPECT_EQ(0x33, view.region_b()[0].Read());
- EXPECT_EQ(0x66, view.region_b()[3].Read());
+ EXPECT_EQ(10U, view.SizeInBytes());
+ EXPECT_EQ(4U, view.a_start().Read());
+ EXPECT_EQ(2U, view.a_size().Read());
+ EXPECT_EQ(6U, view.b_start().Read());
+ EXPECT_EQ(10U, view.b_end().Read());
+ EXPECT_EQ(0x11U, view.region_a()[0].Read());
+ EXPECT_EQ(0x22U, view.region_a()[1].Read());
+ EXPECT_EQ(0x33U, view.region_b()[0].Read());
+ EXPECT_EQ(0x66U, view.region_b()[3].Read());
}
static const ::std::uint8_t kTwoRegionsBFirst[14] = {
@@ -238,15 +238,15 @@
// of the order of their declarations works.
TEST(TwoRegionsView, RegionBFirstWorks) {
auto view = TwoRegionsView(kTwoRegionsBFirst, sizeof kTwoRegionsBFirst);
- EXPECT_EQ(14, view.SizeInBytes());
- EXPECT_EQ(10, view.a_start().Read());
- EXPECT_EQ(4, view.a_size().Read());
- EXPECT_EQ(4, view.b_start().Read());
- EXPECT_EQ(6, view.b_end().Read());
- EXPECT_EQ(0x33, view.region_a()[0].Read());
- EXPECT_EQ(0x66, view.region_a()[3].Read());
- EXPECT_EQ(0x11, view.region_b()[0].Read());
- EXPECT_EQ(0x22, view.region_b()[1].Read());
+ EXPECT_EQ(14U, view.SizeInBytes());
+ EXPECT_EQ(10U, view.a_start().Read());
+ EXPECT_EQ(4U, view.a_size().Read());
+ EXPECT_EQ(4U, view.b_start().Read());
+ EXPECT_EQ(6U, view.b_end().Read());
+ EXPECT_EQ(0x33U, view.region_a()[0].Read());
+ EXPECT_EQ(0x66U, view.region_a()[3].Read());
+ EXPECT_EQ(0x11U, view.region_b()[0].Read());
+ EXPECT_EQ(0x22U, view.region_b()[1].Read());
}
static const ::std::uint8_t kTwoRegionsAAndBOverlap[8] = {
@@ -262,17 +262,17 @@
TEST(TwoRegionsView, RegionAAndBOverlappedWorks) {
auto view =
TwoRegionsView(kTwoRegionsAAndBOverlap, sizeof kTwoRegionsAAndBOverlap);
- EXPECT_EQ(8, view.SizeInBytes());
- EXPECT_EQ(5, view.a_start().Read());
- EXPECT_EQ(2, view.a_size().Read());
- EXPECT_EQ(4, view.b_start().Read());
- EXPECT_EQ(8, view.b_end().Read());
- EXPECT_EQ(0x22, view.region_a()[0].Read());
- EXPECT_EQ(0x33, view.region_a()[1].Read());
- EXPECT_EQ(0x11, view.region_b()[0].Read());
- EXPECT_EQ(0x22, view.region_b()[1].Read());
- EXPECT_EQ(0x33, view.region_b()[2].Read());
- EXPECT_EQ(0x44, view.region_b()[3].Read());
+ EXPECT_EQ(8U, view.SizeInBytes());
+ EXPECT_EQ(5U, view.a_start().Read());
+ EXPECT_EQ(2U, view.a_size().Read());
+ EXPECT_EQ(4U, view.b_start().Read());
+ EXPECT_EQ(8U, view.b_end().Read());
+ EXPECT_EQ(0x22U, view.region_a()[0].Read());
+ EXPECT_EQ(0x33U, view.region_a()[1].Read());
+ EXPECT_EQ(0x11U, view.region_b()[0].Read());
+ EXPECT_EQ(0x22U, view.region_b()[1].Read());
+ EXPECT_EQ(0x33U, view.region_b()[2].Read());
+ EXPECT_EQ(0x44U, view.region_b()[3].Read());
}
TEST(TwoRegionsView, Write) {
@@ -323,12 +323,12 @@
writer.region_b()[1].Write(0xff);
writer.region_b()[2].Write(0xee);
writer.region_b()[3].Write(0x44);
- EXPECT_EQ(0xff, writer.region_a()[0].Read());
- EXPECT_EQ(0xee, writer.region_a()[1].Read());
+ EXPECT_EQ(0xffU, writer.region_a()[0].Read());
+ EXPECT_EQ(0xeeU, writer.region_a()[1].Read());
writer.region_a()[0].Write(0x22);
writer.region_a()[1].Write(0x33);
- EXPECT_EQ(0x22, writer.region_b()[1].Read());
- EXPECT_EQ(0x33, writer.region_b()[2].Read());
+ EXPECT_EQ(0x22U, writer.region_b()[1].Read());
+ EXPECT_EQ(0x33U, writer.region_b()[2].Read());
EXPECT_EQ(::std::vector</**/ ::std::uint8_t>(
kTwoRegionsAAndBOverlap,
kTwoRegionsAAndBOverlap + sizeof kTwoRegionsAAndBOverlap),
@@ -380,11 +380,11 @@
// fit in 8 bits.
TEST(MultipliedSizeView, MultipliedSizesUseWideEnoughArithmetic) {
auto view = MultipliedSizeView(kMultipliedSize, sizeof kMultipliedSize);
- EXPECT_EQ(299, view.SizeInBytes());
- EXPECT_EQ(9, view.width().Read());
- EXPECT_EQ(33, view.height().Read());
- EXPECT_EQ(1, view.data()[0].Read());
- EXPECT_EQ(0xff, view.data()[296].Read());
+ EXPECT_EQ(299U, view.SizeInBytes());
+ EXPECT_EQ(9U, view.width().Read());
+ EXPECT_EQ(33U, view.height().Read());
+ EXPECT_EQ(1U, view.data()[0].Read());
+ EXPECT_EQ(0xffU, view.data()[296].Read());
}
static const ::std::uint8_t kNegativeTermsInSizesAMinusBIsBiggest[7] = {
@@ -409,11 +409,11 @@
auto view =
NegativeTermsInSizesView(kNegativeTermsInSizesAMinusBIsBiggest,
sizeof kNegativeTermsInSizesAMinusBIsBiggest);
- EXPECT_EQ(6, view.SizeInBytes());
- EXPECT_EQ(7, view.a().Read());
- EXPECT_EQ(1, view.b().Read());
- EXPECT_EQ(2, view.c().Read());
- EXPECT_EQ(0x33, view.a_minus_b()[2].Read());
+ EXPECT_EQ(6U, view.SizeInBytes());
+ EXPECT_EQ(7U, view.a().Read());
+ EXPECT_EQ(1U, view.b().Read());
+ EXPECT_EQ(2U, view.c().Read());
+ EXPECT_EQ(0x33U, view.a_minus_b()[2].Read());
}
static const ::std::uint8_t kNegativeTermsInSizesAMinusCIsBiggest[7] = {
@@ -438,11 +438,11 @@
auto view =
NegativeTermsInSizesView(kNegativeTermsInSizesAMinusCIsBiggest,
sizeof kNegativeTermsInSizesAMinusCIsBiggest);
- EXPECT_EQ(6, view.SizeInBytes());
- EXPECT_EQ(7, view.a().Read());
- EXPECT_EQ(2, view.b().Read());
- EXPECT_EQ(1, view.c().Read());
- EXPECT_EQ(0x33, view.a_minus_c()[2].Read());
+ EXPECT_EQ(6U, view.SizeInBytes());
+ EXPECT_EQ(7U, view.a().Read());
+ EXPECT_EQ(2U, view.b().Read());
+ EXPECT_EQ(1U, view.c().Read());
+ EXPECT_EQ(0x33U, view.a_minus_c()[2].Read());
EXPECT_TRUE(view.a_minus_b().IsComplete());
EXPECT_TRUE(view.a_minus_2b().IsComplete());
}
@@ -469,11 +469,11 @@
auto view =
NegativeTermsInSizesView(kNegativeTermsInSizesTenMinusAIsBiggest,
sizeof kNegativeTermsInSizesTenMinusAIsBiggest);
- EXPECT_EQ(6, view.SizeInBytes());
- EXPECT_EQ(4, view.a().Read());
- EXPECT_EQ(0, view.b().Read());
- EXPECT_EQ(0, view.c().Read());
- EXPECT_EQ(0x33, view.ten_minus_a()[2].Read());
+ EXPECT_EQ(6U, view.SizeInBytes());
+ EXPECT_EQ(4U, view.a().Read());
+ EXPECT_EQ(0U, view.b().Read());
+ EXPECT_EQ(0U, view.c().Read());
+ EXPECT_EQ(0x33U, view.ten_minus_a()[2].Read());
EXPECT_TRUE(view.a_minus_b().IsComplete());
EXPECT_TRUE(view.a_minus_2b().IsComplete());
}
@@ -502,12 +502,12 @@
TEST(NegativeTermsInSizes, NegativeEnd) {
auto view = NegativeTermsInSizesView(kNegativeTermsEndWouldBeNegative,
sizeof kNegativeTermsEndWouldBeNegative);
- EXPECT_EQ(10, view.SizeInBytes());
+ EXPECT_EQ(10U, view.SizeInBytes());
EXPECT_TRUE(view.SizeIsKnown());
- EXPECT_EQ(0, view.a().Read());
- EXPECT_EQ(2, view.b().Read());
- EXPECT_EQ(2, view.c().Read());
- EXPECT_EQ(0x77, view.ten_minus_a()[6].Read());
+ EXPECT_EQ(0U, view.a().Read());
+ EXPECT_EQ(2U, view.b().Read());
+ EXPECT_EQ(2U, view.c().Read());
+ EXPECT_EQ(0x77U, view.ten_minus_a()[6].Read());
EXPECT_FALSE(view.a_minus_b().IsComplete());
EXPECT_FALSE(view.a_minus_2b().IsComplete());
}
@@ -534,15 +534,15 @@
TEST(ChainedSize, ChainedSizeInOrder) {
auto view = ChainedSizeView(kChainedSizeInOrder, sizeof kChainedSizeInOrder);
ASSERT_TRUE(view.SizeIsKnown());
- EXPECT_EQ(4, view.SizeInBytes());
+ EXPECT_EQ(4U, view.SizeInBytes());
ASSERT_TRUE(view.a().IsComplete());
- EXPECT_EQ(1, view.a().Read());
+ EXPECT_EQ(1U, view.a().Read());
ASSERT_TRUE(view.b().IsComplete());
- EXPECT_EQ(2, view.b().Read());
+ EXPECT_EQ(2U, view.b().Read());
ASSERT_TRUE(view.c().IsComplete());
- EXPECT_EQ(3, view.c().Read());
+ EXPECT_EQ(3U, view.c().Read());
ASSERT_TRUE(view.d().IsComplete());
- EXPECT_EQ(4, view.d().Read());
+ EXPECT_EQ(4U, view.d().Read());
}
static const ::std::uint8_t kChainedSizeNotInOrder[4] = {
@@ -559,15 +559,15 @@
ChainedSizeView(kChainedSizeNotInOrder, sizeof kChainedSizeNotInOrder);
ASSERT_TRUE(view.Ok());
ASSERT_TRUE(view.SizeIsKnown());
- EXPECT_EQ(4, view.SizeInBytes());
+ EXPECT_EQ(4U, view.SizeInBytes());
ASSERT_TRUE(view.a().IsComplete());
- EXPECT_EQ(3, view.a().Read());
+ EXPECT_EQ(3U, view.a().Read());
ASSERT_TRUE(view.b().IsComplete());
- EXPECT_EQ(2, view.b().Read());
+ EXPECT_EQ(2U, view.b().Read());
ASSERT_TRUE(view.c().IsComplete());
- EXPECT_EQ(1, view.c().Read());
+ EXPECT_EQ(1U, view.c().Read());
ASSERT_TRUE(view.d().IsComplete());
- EXPECT_EQ(4, view.d().Read());
+ EXPECT_EQ(4U, view.d().Read());
}
// Fields are readable, even through multiple levels of indirection.
@@ -608,13 +608,13 @@
sizeof kChainedSizeTooShortForD);
ASSERT_FALSE(view.Ok());
ASSERT_TRUE(view.SizeIsKnown());
- EXPECT_EQ(4, view.SizeInBytes());
+ EXPECT_EQ(4U, view.SizeInBytes());
ASSERT_TRUE(view.a().IsComplete());
- EXPECT_EQ(1, view.a().Read());
+ EXPECT_EQ(1U, view.a().Read());
ASSERT_TRUE(view.b().IsComplete());
- EXPECT_EQ(2, view.b().Read());
+ EXPECT_EQ(2U, view.b().Read());
ASSERT_TRUE(view.c().IsComplete());
- EXPECT_EQ(3, view.c().Read());
+ EXPECT_EQ(3U, view.c().Read());
ASSERT_FALSE(view.d().IsComplete());
}
@@ -633,9 +633,9 @@
ASSERT_FALSE(view.Ok());
EXPECT_FALSE(view.SizeIsKnown());
ASSERT_TRUE(view.a().IsComplete());
- EXPECT_EQ(1, view.a().Read());
+ EXPECT_EQ(1U, view.a().Read());
ASSERT_TRUE(view.b().IsComplete());
- EXPECT_EQ(2, view.b().Read());
+ EXPECT_EQ(2U, view.b().Read());
ASSERT_FALSE(view.c().IsComplete());
ASSERT_FALSE(view.d().IsComplete());
}
@@ -643,7 +643,7 @@
// A structure with static size and two end-aligned fields compiles and returns
// the correct size.
TEST(FinalFieldOverlaps, FinalSizeIsCorrect) {
- ASSERT_EQ(5, FinalFieldOverlapsView::SizeInBytes());
+ ASSERT_EQ(5U, FinalFieldOverlapsView::SizeInBytes());
}
static const ::std::uint8_t kDynamicFinalFieldOverlapsDynamicFieldIsLast[12] = {
@@ -668,11 +668,11 @@
auto dynamic_last_view = DynamicFinalFieldOverlapsView(
kDynamicFinalFieldOverlapsDynamicFieldIsLast,
sizeof kDynamicFinalFieldOverlapsDynamicFieldIsLast);
- ASSERT_EQ(12, dynamic_last_view.SizeInBytes());
+ ASSERT_EQ(12U, dynamic_last_view.SizeInBytes());
auto static_last_view = DynamicFinalFieldOverlapsView(
kDynamicFinalFieldOverlapsStaticFieldIsLast,
sizeof kDynamicFinalFieldOverlapsStaticFieldIsLast);
- ASSERT_EQ(10, static_last_view.SizeInBytes());
+ ASSERT_EQ(10U, static_last_view.SizeInBytes());
}
TEST(DynamicFieldDependsOnLaterField, DynamicLocationIsNotKnown) {
@@ -681,11 +681,11 @@
EXPECT_FALSE(view.b().Ok());
view = MakeDynamicFieldDependsOnLaterFieldView(bytes, 5);
EXPECT_TRUE(view.b().Ok());
- EXPECT_EQ(3, view.b().Read());
+ EXPECT_EQ(3U, view.b().Read());
}
TEST(DynamicFieldDoesNotAffectSize, DynamicFieldDoesNotAffectSize) {
- EXPECT_EQ(256, DynamicFieldDoesNotAffectSizeView::SizeInBytes());
+ EXPECT_EQ(256U, DynamicFieldDoesNotAffectSizeView::SizeInBytes());
}
} // namespace
diff --git a/back_end/cpp/testcode/enum_test.cc b/back_end/cpp/testcode/enum_test.cc
index 81386f5..a5a5e14 100644
--- a/back_end/cpp/testcode/enum_test.cc
+++ b/back_end/cpp/testcode/enum_test.cc
@@ -100,7 +100,7 @@
auto view = ManifestEntryView(kManifestEntryEdgeCases,
sizeof kManifestEntryEdgeCases);
EXPECT_EQ(static_cast<Kind>(255), view.kind().Read());
- EXPECT_EQ(255, static_cast</**/ ::std::uint64_t>(view.kind().Read()));
+ EXPECT_EQ(255U, static_cast</**/ ::std::uint64_t>(view.kind().Read()));
EXPECT_EQ(Kind::MAX32BIT, view.wide_kind().Read());
EXPECT_EQ(Kind::MAX32BIT, view.wide_kind_in_bits().Read());
}
diff --git a/back_end/cpp/testcode/int_sizes_test.cc b/back_end/cpp/testcode/int_sizes_test.cc
index e9a8330..c41f671 100644
--- a/back_end/cpp/testcode/int_sizes_test.cc
+++ b/back_end/cpp/testcode/int_sizes_test.cc
@@ -54,14 +54,14 @@
EXPECT_EQ(0x71e2d3c4b5a697, view.seven_byte().Read());
EXPECT_EQ(-0x7f00010203040506, view.eight_byte().Read());
// Test that the views return appropriate integer widths.
- EXPECT_EQ(1, sizeof(view.one_byte().Read()));
- EXPECT_EQ(2, sizeof(view.two_byte().Read()));
- EXPECT_EQ(4, sizeof(view.three_byte().Read()));
- EXPECT_EQ(4, sizeof(view.four_byte().Read()));
- EXPECT_EQ(8, sizeof(view.five_byte().Read()));
- EXPECT_EQ(8, sizeof(view.six_byte().Read()));
- EXPECT_EQ(8, sizeof(view.seven_byte().Read()));
- EXPECT_EQ(8, sizeof(view.eight_byte().Read()));
+ EXPECT_EQ(1U, sizeof(view.one_byte().Read()));
+ EXPECT_EQ(2U, sizeof(view.two_byte().Read()));
+ EXPECT_EQ(4U, sizeof(view.three_byte().Read()));
+ EXPECT_EQ(4U, sizeof(view.four_byte().Read()));
+ EXPECT_EQ(8U, sizeof(view.five_byte().Read()));
+ EXPECT_EQ(8U, sizeof(view.six_byte().Read()));
+ EXPECT_EQ(8U, sizeof(view.seven_byte().Read()));
+ EXPECT_EQ(8U, sizeof(view.eight_byte().Read()));
}
TEST(SizesWriter, CanWriteSizes) {
diff --git a/back_end/cpp/testcode/nested_structure_test.cc b/back_end/cpp/testcode/nested_structure_test.cc
index de88ccd..737d938 100644
--- a/back_end/cpp/testcode/nested_structure_test.cc
+++ b/back_end/cpp/testcode/nested_structure_test.cc
@@ -37,14 +37,14 @@
// ContainerView::SizeInBytes() returns the expected value.
TEST(ContainerView, StaticSizeIsCorrect) {
- EXPECT_EQ(20, ContainerView::SizeInBytes());
+ EXPECT_EQ(20U, ContainerView::SizeInBytes());
}
// ContainerView::SizeInBytes() returns the expected value.
TEST(ContainerView, SizeFieldIsCorrect) {
auto view = MakeAlignedContainerView<const ::std::uint8_t, 8>(
kContainer, sizeof kContainer);
- EXPECT_EQ(40, view.weight().Read());
+ EXPECT_EQ(40U, view.weight().Read());
}
// ContainerView::important_box() returns a BoxView, and not a different
@@ -53,7 +53,7 @@
auto container = MakeAlignedContainerView<const ::std::uint8_t, 8>(
kContainer, sizeof kContainer);
auto box = container.important_box();
- EXPECT_EQ(0x12345678, box.id().Read());
+ EXPECT_EQ(0x12345678U, box.id().Read());
}
// Box::SizeInBytes() returns the expected value, when retrieved from a
@@ -61,7 +61,7 @@
TEST(ContainerView, BoxSizeFieldIsCorrect) {
auto view = MakeAlignedContainerView<const ::std::uint8_t, 8>(
kContainer, sizeof kContainer);
- EXPECT_EQ(8, view.important_box().SizeInBytes());
+ EXPECT_EQ(8U, view.important_box().SizeInBytes());
}
// Box::id() and Box::count() return correct values when retrieved from
@@ -69,10 +69,10 @@
TEST(ContainerView, BoxFieldValuesAreCorrect) {
auto view = MakeAlignedContainerView<const ::std::uint8_t, 8>(
kContainer, sizeof kContainer);
- EXPECT_EQ(0x12345678, view.important_box().id().Read());
- EXPECT_EQ(0x010203, view.important_box().count().Read());
- EXPECT_EQ(0x87654321, view.other_box().id().Read());
- EXPECT_EQ(0xaabbcc, view.other_box().count().Read());
+ EXPECT_EQ(0x12345678U, view.important_box().id().Read());
+ EXPECT_EQ(0x010203U, view.important_box().count().Read());
+ EXPECT_EQ(0x87654321U, view.other_box().id().Read());
+ EXPECT_EQ(0xaabbccU, view.other_box().count().Read());
}
TEST(ContainerView, CanWriteValues) {
@@ -128,17 +128,17 @@
TEST(TruckView, ValuesAreCorrect) {
auto view =
MakeAlignedTruckView<const ::std::uint8_t, 8>(kTruck, sizeof kTruck);
- EXPECT_EQ(0x22446688, view.id().Read());
- EXPECT_EQ(100, view.cargo()[0].weight().Read());
- EXPECT_EQ(255, view.cargo()[0].important_box().id().Read());
- EXPECT_EQ(10, view.cargo()[0].important_box().count().Read());
- EXPECT_EQ(2000000000, view.cargo()[0].other_box().id().Read());
- EXPECT_EQ(500, view.cargo()[0].other_box().count().Read());
- EXPECT_EQ(101, view.cargo()[1].weight().Read());
- EXPECT_EQ(254, view.cargo()[1].important_box().id().Read());
- EXPECT_EQ(9, view.cargo()[1].important_box().count().Read());
- EXPECT_EQ(2000000001, view.cargo()[1].other_box().id().Read());
- EXPECT_EQ(499, view.cargo()[1].other_box().count().Read());
+ EXPECT_EQ(0x22446688U, view.id().Read());
+ EXPECT_EQ(100U, view.cargo()[0].weight().Read());
+ EXPECT_EQ(255U, view.cargo()[0].important_box().id().Read());
+ EXPECT_EQ(10U, view.cargo()[0].important_box().count().Read());
+ EXPECT_EQ(2000000000U, view.cargo()[0].other_box().id().Read());
+ EXPECT_EQ(500U, view.cargo()[0].other_box().count().Read());
+ EXPECT_EQ(101U, view.cargo()[1].weight().Read());
+ EXPECT_EQ(254U, view.cargo()[1].important_box().id().Read());
+ EXPECT_EQ(9U, view.cargo()[1].important_box().count().Read());
+ EXPECT_EQ(2000000001U, view.cargo()[1].other_box().id().Read());
+ EXPECT_EQ(499U, view.cargo()[1].other_box().count().Read());
}
TEST(TruckView, WriteValues) {
diff --git a/back_end/cpp/testcode/parameters_test.cc b/back_end/cpp/testcode/parameters_test.cc
index bb9c9cd..6179795 100644
--- a/back_end/cpp/testcode/parameters_test.cc
+++ b/back_end/cpp/testcode/parameters_test.cc
@@ -29,20 +29,20 @@
::std::array<char, 12> values = {1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0};
auto view = MakeAxesView(2, &values);
EXPECT_TRUE(view.Ok());
- EXPECT_EQ(2, view.values().ElementCount());
- EXPECT_EQ(1, view.values()[0].value().Read());
- EXPECT_EQ(1, view.x().x().Read());
- EXPECT_EQ(2, view.values()[1].value().Read());
- EXPECT_EQ(2, view.y().y().Read());
+ EXPECT_EQ(2U, view.values().ElementCount());
+ EXPECT_EQ(1U, view.values()[0].value().Read());
+ EXPECT_EQ(1U, view.x().x().Read());
+ EXPECT_EQ(2U, view.values()[1].value().Read());
+ EXPECT_EQ(2U, view.y().y().Read());
EXPECT_FALSE(view.has_z().Value());
view = MakeAxesView(3, &values);
EXPECT_TRUE(view.Ok());
- EXPECT_EQ(3, view.values().ElementCount());
- EXPECT_EQ(1, view.values()[0].value().Read());
- EXPECT_EQ(2, view.values()[1].value().Read());
- EXPECT_EQ(3, view.values()[2].value().Read());
- EXPECT_EQ(3, view.z().z().Read());
+ EXPECT_EQ(3U, view.values().ElementCount());
+ EXPECT_EQ(1U, view.values()[0].value().Read());
+ EXPECT_EQ(2U, view.values()[1].value().Read());
+ EXPECT_EQ(3U, view.values()[2].value().Read());
+ EXPECT_EQ(3U, view.z().z().Read());
view = MakeAxesView(4, &values);
EXPECT_FALSE(view.Ok());
@@ -60,7 +60,7 @@
auto view = MakeAxesEnvelopeView(&values);
EXPECT_TRUE(view.Ok());
EXPECT_EQ(0x80000000U, view.axes().x().value().Read());
- EXPECT_EQ(9, view.SizeInBytes());
+ EXPECT_EQ(9U, view.SizeInBytes());
}
TEST(AxesEnvelope, ParameterValueIsOutOfRange) {
@@ -74,11 +74,11 @@
::std::array<char, 13> values = {0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0};
auto view = MakeMultiversionView(Product::VERSION_1, &values);
EXPECT_TRUE(view.Ok());
- EXPECT_EQ(2, view.axes().y().y().Read());
+ EXPECT_EQ(2U, view.axes().y().y().Read());
EXPECT_FALSE(view.axes().has_z().Value());
view = MakeMultiversionView(Product::VERSION_X, &values);
EXPECT_TRUE(view.Ok());
- EXPECT_EQ(2, view.axes().y().y().Read());
+ EXPECT_EQ(2U, view.axes().y().y().Read());
EXPECT_TRUE(view.axes().has_z().Value());
}
@@ -88,13 +88,13 @@
EXPECT_TRUE(view.Ok());
EXPECT_TRUE(view.config().power().Read());
EXPECT_FALSE(view.has_config_vx().Value());
- EXPECT_EQ(5, view.SizeInBytes());
+ EXPECT_EQ(5U, view.SizeInBytes());
view = MakeMultiversionView(Product::VERSION_X, &values);
EXPECT_TRUE(view.Ok());
EXPECT_TRUE(view.config().power().Read());
EXPECT_TRUE(view.has_config_vx().Value());
- EXPECT_EQ(25600, view.config_vx().gain().Read());
- EXPECT_EQ(9, view.SizeInBytes());
+ EXPECT_EQ(25600U, view.config_vx().gain().Read());
+ EXPECT_EQ(9U, view.SizeInBytes());
}
TEST(StructContainingStructWithUnusedParameter, NoParameterIsNotOk) {
diff --git a/back_end/cpp/testcode/read_log_file_status_test.cc b/back_end/cpp/testcode/read_log_file_status_test.cc
index 3b46441..5f32b2d 100644
--- a/back_end/cpp/testcode/read_log_file_status_test.cc
+++ b/back_end/cpp/testcode/read_log_file_status_test.cc
@@ -43,15 +43,15 @@
// LogFileStatusView::SizeInBytes() returns the expected value.
TEST(LogFileStatusView, SizeIsCorrect) {
- EXPECT_EQ(24, LogFileStatusView::SizeInBytes());
+ EXPECT_EQ(24U, LogFileStatusView::SizeInBytes());
}
// LogFileStatusView's atomic field accessors work.
TEST(LogFileStatusView, AtomicFieldAccessorsWork) {
auto view = LogFileStatusView(kLogFileStatus, sizeof kLogFileStatus);
- EXPECT_EQ(0x04030201, view.file_state().Read());
- EXPECT_EQ(0x08070605, view.file_size_kb().Read());
- EXPECT_EQ(0x0c0b0a09, view.media().Read());
+ EXPECT_EQ(0x04030201U, view.file_state().Read());
+ EXPECT_EQ(0x08070605U, view.file_size_kb().Read());
+ EXPECT_EQ(0x0c0b0a09U, view.media().Read());
}
// LogFileStatusView's array field accessor works.
diff --git a/back_end/cpp/testcode/start_size_range_test.cc b/back_end/cpp/testcode/start_size_range_test.cc
index 1c42961..58a4158 100644
--- a/back_end/cpp/testcode/start_size_range_test.cc
+++ b/back_end/cpp/testcode/start_size_range_test.cc
@@ -32,7 +32,7 @@
TEST(StartSizeView, EverythingInPlace) {
auto view = StartSizeView(kStartSizeRange, sizeof kStartSizeRange);
- EXPECT_EQ(9, view.SizeInBytes());
+ EXPECT_EQ(9U, view.SizeInBytes());
EXPECT_EQ(2, view.size().Read());
EXPECT_EQ(1000, view.start_size_constants().Read());
EXPECT_EQ(0x11, view.payload()[0].Read());
diff --git a/back_end/cpp/testcode/uint_sizes_test.cc b/back_end/cpp/testcode/uint_sizes_test.cc
index 646b289..c96d201 100644
--- a/back_end/cpp/testcode/uint_sizes_test.cc
+++ b/back_end/cpp/testcode/uint_sizes_test.cc
@@ -49,19 +49,19 @@
EXPECT_EQ(260, view.two_byte().Read());
EXPECT_EQ(0x445566U, view.three_byte().Read());
EXPECT_EQ(0x03040506U, view.four_byte().Read());
- EXPECT_EQ(0xa987654321, view.five_byte().Read());
- EXPECT_EQ(0x123456789abc, view.six_byte().Read());
- EXPECT_EQ(0xf1e2d3c4b5a697, view.seven_byte().Read());
+ EXPECT_EQ(0xa987654321UL, view.five_byte().Read());
+ EXPECT_EQ(0x123456789abcUL, view.six_byte().Read());
+ EXPECT_EQ(0xf1e2d3c4b5a697UL, view.seven_byte().Read());
EXPECT_EQ(0xff00010203040506UL, view.eight_byte().Read());
// Test that the views return appropriate integer widths.
- EXPECT_EQ(1, sizeof(view.one_byte().Read()));
- EXPECT_EQ(2, sizeof(view.two_byte().Read()));
- EXPECT_EQ(4, sizeof(view.three_byte().Read()));
- EXPECT_EQ(4, sizeof(view.four_byte().Read()));
- EXPECT_EQ(8, sizeof(view.five_byte().Read()));
- EXPECT_EQ(8, sizeof(view.six_byte().Read()));
- EXPECT_EQ(8, sizeof(view.seven_byte().Read()));
- EXPECT_EQ(8, sizeof(view.eight_byte().Read()));
+ EXPECT_EQ(1U, sizeof(view.one_byte().Read()));
+ EXPECT_EQ(2U, sizeof(view.two_byte().Read()));
+ EXPECT_EQ(4U, sizeof(view.three_byte().Read()));
+ EXPECT_EQ(4U, sizeof(view.four_byte().Read()));
+ EXPECT_EQ(8U, sizeof(view.five_byte().Read()));
+ EXPECT_EQ(8U, sizeof(view.six_byte().Read()));
+ EXPECT_EQ(8U, sizeof(view.seven_byte().Read()));
+ EXPECT_EQ(8U, sizeof(view.eight_byte().Read()));
}
TEST(SizesWriter, CanWriteSizes) {
@@ -86,19 +86,19 @@
EXPECT_EQ(0x0401, view.two_byte().Read());
EXPECT_EQ(0x665544U, view.three_byte().Read());
EXPECT_EQ(0x06050403U, view.four_byte().Read());
- EXPECT_EQ(0x21436587a9, view.five_byte().Read());
- EXPECT_EQ(0xbc9a78563412, view.six_byte().Read());
- EXPECT_EQ(0x97a6b5c4d3e2f1, view.seven_byte().Read());
+ EXPECT_EQ(0x21436587a9UL, view.five_byte().Read());
+ EXPECT_EQ(0xbc9a78563412UL, view.six_byte().Read());
+ EXPECT_EQ(0x97a6b5c4d3e2f1UL, view.seven_byte().Read());
EXPECT_EQ(0x06050403020100ffUL, view.eight_byte().Read());
// Test that the views return appropriate integer widths.
- EXPECT_EQ(1, sizeof(view.one_byte().Read()));
- EXPECT_EQ(2, sizeof(view.two_byte().Read()));
- EXPECT_EQ(4, sizeof(view.three_byte().Read()));
- EXPECT_EQ(4, sizeof(view.four_byte().Read()));
- EXPECT_EQ(8, sizeof(view.five_byte().Read()));
- EXPECT_EQ(8, sizeof(view.six_byte().Read()));
- EXPECT_EQ(8, sizeof(view.seven_byte().Read()));
- EXPECT_EQ(8, sizeof(view.eight_byte().Read()));
+ EXPECT_EQ(1U, sizeof(view.one_byte().Read()));
+ EXPECT_EQ(2U, sizeof(view.two_byte().Read()));
+ EXPECT_EQ(4U, sizeof(view.three_byte().Read()));
+ EXPECT_EQ(4U, sizeof(view.four_byte().Read()));
+ EXPECT_EQ(8U, sizeof(view.five_byte().Read()));
+ EXPECT_EQ(8U, sizeof(view.six_byte().Read()));
+ EXPECT_EQ(8U, sizeof(view.seven_byte().Read()));
+ EXPECT_EQ(8U, sizeof(view.eight_byte().Read()));
}
TEST(SizesWriter, CanWriteSizesBigEndian) {
@@ -123,19 +123,19 @@
EXPECT_EQ(0x0104, view.two_byte().Read());
EXPECT_EQ(0x665544U, view.three_byte().Read());
EXPECT_EQ(0x03040506U, view.four_byte().Read());
- EXPECT_EQ(0x21436587a9, view.five_byte().Read());
- EXPECT_EQ(0x123456789abc, view.six_byte().Read());
- EXPECT_EQ(0x97a6b5c4d3e2f1, view.seven_byte().Read());
+ EXPECT_EQ(0x21436587a9UL, view.five_byte().Read());
+ EXPECT_EQ(0x123456789abcUL, view.six_byte().Read());
+ EXPECT_EQ(0x97a6b5c4d3e2f1UL, view.seven_byte().Read());
EXPECT_EQ(0xff00010203040506UL, view.eight_byte().Read());
// Test that the views return appropriate integer widths.
- EXPECT_EQ(1, sizeof(view.one_byte().Read()));
- EXPECT_EQ(2, sizeof(view.two_byte().Read()));
- EXPECT_EQ(4, sizeof(view.three_byte().Read()));
- EXPECT_EQ(4, sizeof(view.four_byte().Read()));
- EXPECT_EQ(8, sizeof(view.five_byte().Read()));
- EXPECT_EQ(8, sizeof(view.six_byte().Read()));
- EXPECT_EQ(8, sizeof(view.seven_byte().Read()));
- EXPECT_EQ(8, sizeof(view.eight_byte().Read()));
+ EXPECT_EQ(1U, sizeof(view.one_byte().Read()));
+ EXPECT_EQ(2U, sizeof(view.two_byte().Read()));
+ EXPECT_EQ(4U, sizeof(view.three_byte().Read()));
+ EXPECT_EQ(4U, sizeof(view.four_byte().Read()));
+ EXPECT_EQ(8U, sizeof(view.five_byte().Read()));
+ EXPECT_EQ(8U, sizeof(view.six_byte().Read()));
+ EXPECT_EQ(8U, sizeof(view.seven_byte().Read()));
+ EXPECT_EQ(8U, sizeof(view.eight_byte().Read()));
}
TEST(SizesWriter, CanWriteSizesAlternatingEndian) {
@@ -271,14 +271,14 @@
EXPECT_EQ(Enum::VALUE10000000, view.seven_byte().Read());
EXPECT_EQ(Enum::VALUE1000, view.eight_byte().Read());
// Emboss enums are always derived from uint64_t.
- EXPECT_EQ(8, sizeof(view.one_byte().Read()));
- EXPECT_EQ(8, sizeof(view.two_byte().Read()));
- EXPECT_EQ(8, sizeof(view.three_byte().Read()));
- EXPECT_EQ(8, sizeof(view.four_byte().Read()));
- EXPECT_EQ(8, sizeof(view.five_byte().Read()));
- EXPECT_EQ(8, sizeof(view.six_byte().Read()));
- EXPECT_EQ(8, sizeof(view.seven_byte().Read()));
- EXPECT_EQ(8, sizeof(view.eight_byte().Read()));
+ EXPECT_EQ(8U, sizeof(view.one_byte().Read()));
+ EXPECT_EQ(8U, sizeof(view.two_byte().Read()));
+ EXPECT_EQ(8U, sizeof(view.three_byte().Read()));
+ EXPECT_EQ(8U, sizeof(view.four_byte().Read()));
+ EXPECT_EQ(8U, sizeof(view.five_byte().Read()));
+ EXPECT_EQ(8U, sizeof(view.six_byte().Read()));
+ EXPECT_EQ(8U, sizeof(view.seven_byte().Read()));
+ EXPECT_EQ(8U, sizeof(view.eight_byte().Read()));
}
TEST(SizesWriter, CanWriteEnumSizes) {
@@ -374,23 +374,23 @@
EXPECT_EQ(0x445567U, view.three_byte()[1].Read());
EXPECT_EQ(0x03040506U, view.four_byte()[0].Read());
EXPECT_EQ(0x03040507U, view.four_byte()[1].Read());
- EXPECT_EQ(0xa987654321, view.five_byte()[0].Read());
- EXPECT_EQ(0xa987654322, view.five_byte()[1].Read());
- EXPECT_EQ(0x123456789abc, view.six_byte()[0].Read());
- EXPECT_EQ(0x123456789abd, view.six_byte()[1].Read());
- EXPECT_EQ(0xf1e2d3c4b5a697, view.seven_byte()[0].Read());
- EXPECT_EQ(0xf1e2d3c4b5a698, view.seven_byte()[1].Read());
+ EXPECT_EQ(0xa987654321UL, view.five_byte()[0].Read());
+ EXPECT_EQ(0xa987654322UL, view.five_byte()[1].Read());
+ EXPECT_EQ(0x123456789abcUL, view.six_byte()[0].Read());
+ EXPECT_EQ(0x123456789abdUL, view.six_byte()[1].Read());
+ EXPECT_EQ(0xf1e2d3c4b5a697UL, view.seven_byte()[0].Read());
+ EXPECT_EQ(0xf1e2d3c4b5a698UL, view.seven_byte()[1].Read());
EXPECT_EQ(0xff00010203040506UL, view.eight_byte()[0].Read());
EXPECT_EQ(0xff00010203040507UL, view.eight_byte()[1].Read());
// Test that the views return appropriate integer widths.
- EXPECT_EQ(1, sizeof(view.one_byte()[0].Read()));
- EXPECT_EQ(2, sizeof(view.two_byte()[0].Read()));
- EXPECT_EQ(4, sizeof(view.three_byte()[0].Read()));
- EXPECT_EQ(4, sizeof(view.four_byte()[0].Read()));
- EXPECT_EQ(8, sizeof(view.five_byte()[0].Read()));
- EXPECT_EQ(8, sizeof(view.six_byte()[0].Read()));
- EXPECT_EQ(8, sizeof(view.seven_byte()[0].Read()));
- EXPECT_EQ(8, sizeof(view.eight_byte()[0].Read()));
+ EXPECT_EQ(1U, sizeof(view.one_byte()[0].Read()));
+ EXPECT_EQ(2U, sizeof(view.two_byte()[0].Read()));
+ EXPECT_EQ(4U, sizeof(view.three_byte()[0].Read()));
+ EXPECT_EQ(4U, sizeof(view.four_byte()[0].Read()));
+ EXPECT_EQ(8U, sizeof(view.five_byte()[0].Read()));
+ EXPECT_EQ(8U, sizeof(view.six_byte()[0].Read()));
+ EXPECT_EQ(8U, sizeof(view.seven_byte()[0].Read()));
+ EXPECT_EQ(8U, sizeof(view.eight_byte()[0].Read()));
}
TEST(SizesView, CopyFrom) {
diff --git a/back_end/cpp/testcode/virtual_field_test.cc b/back_end/cpp/testcode/virtual_field_test.cc
index 493a4b4..7f00765 100644
--- a/back_end/cpp/testcode/virtual_field_test.cc
+++ b/back_end/cpp/testcode/virtual_field_test.cc
@@ -65,21 +65,21 @@
EXPECT_EQ(20, view.twenty().Read());
EXPECT_EQ(4000000000U, view.four_billion().Read());
EXPECT_EQ(10000000000L, view.ten_billion().Read());
- EXPECT_EQ(0, view.value().Read());
- EXPECT_EQ(0, view.alias_of_value().Read());
- EXPECT_EQ(0, view.alias_of_alias_of_value().Read());
+ EXPECT_EQ(0U, view.value().Read());
+ EXPECT_EQ(0U, view.alias_of_value().Read());
+ EXPECT_EQ(0U, view.alias_of_alias_of_value().Read());
view.alias_of_alias_of_value().Write(10);
- EXPECT_EQ(10, view.value().Read());
- EXPECT_EQ(10, view.alias_of_value().Read());
- EXPECT_EQ(10, view.alias_of_alias_of_value().Read());
+ EXPECT_EQ(10U, view.value().Read());
+ EXPECT_EQ(10U, view.alias_of_value().Read());
+ EXPECT_EQ(10U, view.alias_of_alias_of_value().Read());
}
TEST(Computed, Values) {
::std::array<char, 8> values = {5, 0, 0, 0, 50, 0, 0, 0};
const auto view = MakeStructureWithComputedValuesView(&values);
- EXPECT_EQ(5, view.value().Read());
- EXPECT_EQ(10, view.doubled().Read());
- EXPECT_EQ(15, view.plus_ten().Read());
+ EXPECT_EQ(5U, view.value().Read());
+ EXPECT_EQ(10U, view.doubled().Read());
+ EXPECT_EQ(15U, view.plus_ten().Read());
EXPECT_EQ(50, view.value2().Read());
EXPECT_EQ(100, view.signed_doubled().Read());
EXPECT_EQ(60, view.signed_plus_ten().Read());
@@ -239,13 +239,13 @@
EXPECT_FALSE(view.Ok());
view.x().Write(2);
EXPECT_TRUE(view.Ok());
- EXPECT_EQ(50, view.offset_two_x().Read());
- EXPECT_EQ(50, view.size_two_x().Read());
+ EXPECT_EQ(50U, view.offset_two_x().Read());
+ EXPECT_EQ(50U, view.size_two_x().Read());
view.x().Write(1);
EXPECT_FALSE(view.Ok());
- EXPECT_EQ(50 * 0x10000, view.offset_two_x().Read());
+ EXPECT_EQ(50 * 0x10000U, view.offset_two_x().Read());
view.x().Write(0);
- EXPECT_EQ(0, view.offset_two_x().Read());
+ EXPECT_EQ(0U, view.offset_two_x().Read());
}
TEST(BooleanVirtual, TrueAndFalse) {
@@ -287,7 +287,7 @@
::std::array<char, 14> values = {5, 0, 0, 0, 10, 0, 0, 0, 15, 0, 20, 0, 0, 0};
const auto view = MakeStructureUsingForeignConstantsView(&values);
EXPECT_TRUE(view.Ok());
- EXPECT_EQ(20, view.x().Read());
+ EXPECT_EQ(20U, view.x().Read());
EXPECT_EQ(100, view.one_hundred().Read());
}
@@ -364,11 +364,11 @@
0x22, 0x22, 0x22, 0x22};
const auto view = MakeUsesExternalSizeView(&values);
EXPECT_TRUE(view.Ok());
- EXPECT_EQ(8, view.SizeInBytes());
- EXPECT_EQ(view.x().SizeInBytes(), 4);
- EXPECT_EQ(view.y().SizeInBytes(), 4);
- EXPECT_EQ(view.x().value().Read(), 0x11111111);
- EXPECT_EQ(view.y().value().Read(), 0x22222222);
+ EXPECT_EQ(8U, view.SizeInBytes());
+ EXPECT_EQ(view.x().SizeInBytes(), 4U);
+ EXPECT_EQ(view.y().SizeInBytes(), 4U);
+ EXPECT_EQ(view.x().value().Read(), 0x11111111U);
+ EXPECT_EQ(view.y().value().Read(), 0x22222222U);
EXPECT_TRUE(view.IntrinsicSizeInBytes().Ok());
EXPECT_EQ(8, UsesExternalSizeView::IntrinsicSizeInBytes().Read());
EXPECT_EQ(8, UsesExternalSize::MaxSizeInBytes());
diff --git a/public/BUILD b/public/BUILD
index 45810a9..c33c069 100644
--- a/public/BUILD
+++ b/public/BUILD
@@ -161,7 +161,10 @@
srcs = [
"emboss_text_util_test.cc",
],
- copts = ["-DEMBOSS_FORCE_ALL_CHECKS"],
+ copts = [
+ "-DEMBOSS_FORCE_ALL_CHECKS",
+ "-Wsign-compare",
+ ],
deps = [
":cpp_utils",
"@com_google_googletest//:gtest_main",
diff --git a/public/build_defs.bzl b/public/build_defs.bzl
index 47ed4e1..caac8a7 100644
--- a/public/build_defs.bzl
+++ b/public/build_defs.bzl
@@ -78,7 +78,7 @@
"""Constructs two cc_test targets, with and without optimizations."""
native.cc_test(
name = name,
- copts = copts,
+ copts = copts + ["-Wsign-compare"],
**kwargs
)
native.cc_test(
diff --git a/public/emboss_array_view_test.cc b/public/emboss_array_view_test.cc
index 322ac74..612cb88 100644
--- a/public/emboss_array_view_test.cc
+++ b/public/emboss_array_view_test.cc
@@ -73,11 +73,11 @@
ReadWriteContiguousBuffer{bytes, sizeof bytes - 4}};
EXPECT_EQ(sizeof bytes - 4, uint32_array.SizeInBytes());
EXPECT_TRUE(uint32_array[0].Ok());
- EXPECT_EQ(0x0d0e0f10, uint32_array[0].Read());
- EXPECT_EQ(0x090a0b0c, uint32_array[1].Read());
- EXPECT_EQ(0x05060708, uint32_array[2].Read());
+ EXPECT_EQ(0x0d0e0f10U, uint32_array[0].Read());
+ EXPECT_EQ(0x090a0b0cU, uint32_array[1].Read());
+ EXPECT_EQ(0x05060708U, uint32_array[2].Read());
EXPECT_DEATH(uint32_array[3].Read(), "");
- EXPECT_EQ(0x01020304, uint32_array[3].UncheckedRead());
+ EXPECT_EQ(0x01020304U, uint32_array[3].UncheckedRead());
EXPECT_TRUE(uint32_array[2].IsComplete());
EXPECT_FALSE(uint32_array[3].IsComplete());
EXPECT_TRUE(uint32_array.Ok());
diff --git a/public/emboss_bit_util_test.cc b/public/emboss_bit_util_test.cc
index bccf6b4..7a0dbae 100644
--- a/public/emboss_bit_util_test.cc
+++ b/public/emboss_bit_util_test.cc
@@ -21,21 +21,21 @@
namespace test {
TEST(ByteSwap, ByteSwap) {
- EXPECT_EQ(0x01, ByteSwap(::std::uint8_t{0x01}));
- EXPECT_EQ(0x0102, ByteSwap(::std::uint16_t{0x0201}));
- EXPECT_EQ(0x01020304, ByteSwap(::std::uint32_t{0x04030201}));
+ EXPECT_EQ(0x01U, ByteSwap(::std::uint8_t{0x01}));
+ EXPECT_EQ(0x0102U, ByteSwap(::std::uint16_t{0x0201}));
+ EXPECT_EQ(0x01020304U, ByteSwap(::std::uint32_t{0x04030201}));
EXPECT_EQ(0x0102030405060708UL,
ByteSwap(::std::uint64_t{0x0807060504030201UL}));
}
TEST(MaskToNBits, MaskToNBits) {
- EXPECT_EQ(0xff, MaskToNBits(0xffffffffU, 8));
- EXPECT_EQ(0x00, MaskToNBits(0xffffff00U, 8));
- EXPECT_EQ(0x01, MaskToNBits(0xffffffffU, 1));
- EXPECT_EQ(0x00, MaskToNBits(0xfffffffeU, 1));
+ EXPECT_EQ(0xffU, MaskToNBits(0xffffffffU, 8));
+ EXPECT_EQ(0x00U, MaskToNBits(0xffffff00U, 8));
+ EXPECT_EQ(0x01U, MaskToNBits(0xffffffffU, 1));
+ EXPECT_EQ(0x00U, MaskToNBits(0xfffffffeU, 1));
EXPECT_EQ(0xffffffffU, MaskToNBits(0xffffffffU, 32));
EXPECT_EQ(0xffffffffffffffffU, MaskToNBits(0xffffffffffffffffU, 64));
- EXPECT_EQ(0xf, MaskToNBits(::std::uint8_t{0xff}, 4));
+ EXPECT_EQ(0xfU, MaskToNBits(::std::uint8_t{0xff}, 4));
}
TEST(IsPowerOfTwo, IsPowerOfTwo) {
@@ -85,7 +85,7 @@
reinterpret_cast<char *>(&data32)[1] = 0x02;
reinterpret_cast<char *>(&data32)[2] = 0x03;
reinterpret_cast<char *>(&data32)[3] = 0x04;
- EXPECT_EQ(0x04030201, EMBOSS_LITTLE_ENDIAN_TO_NATIVE(data32));
+ EXPECT_EQ(0x04030201U, EMBOSS_LITTLE_ENDIAN_TO_NATIVE(data32));
::std::uint64_t data64 = 0;
reinterpret_cast<char *>(&data64)[0] = 0x01;
@@ -96,7 +96,7 @@
reinterpret_cast<char *>(&data64)[5] = 0x06;
reinterpret_cast<char *>(&data64)[6] = 0x07;
reinterpret_cast<char *>(&data64)[7] = 0x08;
- EXPECT_EQ(0x0807060504030201, EMBOSS_LITTLE_ENDIAN_TO_NATIVE(data64));
+ EXPECT_EQ(0x0807060504030201UL, EMBOSS_LITTLE_ENDIAN_TO_NATIVE(data64));
}
#endif // defined(EMBOSS_LITTLE_ENDIAN_TO_NATIVE)
@@ -112,7 +112,7 @@
reinterpret_cast<char *>(&data32)[1] = 0x02;
reinterpret_cast<char *>(&data32)[2] = 0x03;
reinterpret_cast<char *>(&data32)[3] = 0x04;
- EXPECT_EQ(0x01020304, EMBOSS_BIG_ENDIAN_TO_NATIVE(data32));
+ EXPECT_EQ(0x01020304U, EMBOSS_BIG_ENDIAN_TO_NATIVE(data32));
::std::uint64_t data64 = 0;
reinterpret_cast<char *>(&data64)[0] = 0x01;
@@ -123,7 +123,7 @@
reinterpret_cast<char *>(&data64)[5] = 0x06;
reinterpret_cast<char *>(&data64)[6] = 0x07;
reinterpret_cast<char *>(&data64)[7] = 0x08;
- EXPECT_EQ(0x0102030405060708, EMBOSS_BIG_ENDIAN_TO_NATIVE(data64));
+ EXPECT_EQ(0x0102030405060708UL, EMBOSS_BIG_ENDIAN_TO_NATIVE(data64));
}
#endif // defined(EMBOSS_BIG_ENDIAN_TO_NATIVE)
diff --git a/public/emboss_cpp_types_test.cc b/public/emboss_cpp_types_test.cc
index 3650539..ab607a5 100644
--- a/public/emboss_cpp_types_test.cc
+++ b/public/emboss_cpp_types_test.cc
@@ -21,10 +21,10 @@
namespace test {
TEST(FloatTypes, Types) {
- EXPECT_EQ(32 / CHAR_BIT, sizeof(FloatType<32>::Type));
- EXPECT_EQ(64 / CHAR_BIT, sizeof(FloatType<64>::Type));
- EXPECT_EQ(32 / CHAR_BIT, sizeof(FloatType<32>::UIntType));
- EXPECT_EQ(64 / CHAR_BIT, sizeof(FloatType<64>::UIntType));
+ EXPECT_EQ(32U / CHAR_BIT, sizeof(FloatType<32>::Type));
+ EXPECT_EQ(64U / CHAR_BIT, sizeof(FloatType<64>::Type));
+ EXPECT_EQ(32U / CHAR_BIT, sizeof(FloatType<32>::UIntType));
+ EXPECT_EQ(64U / CHAR_BIT, sizeof(FloatType<64>::UIntType));
EXPECT_TRUE(::std::is_floating_point<FloatType<32>::Type>::value);
EXPECT_TRUE(::std::is_floating_point<FloatType<64>::Type>::value);
EXPECT_TRUE(
@@ -119,7 +119,7 @@
struct OneByte {
char c;
};
- EXPECT_EQ(1, sizeof(OneByte));
+ EXPECT_EQ(1U, sizeof(OneByte));
EXPECT_FALSE(IsChar<int>::value);
EXPECT_FALSE(IsChar<unsigned>::value);
EXPECT_FALSE(IsChar<const int>::value);
diff --git a/public/emboss_defines.h b/public/emboss_defines.h
index 3be4d66..04fc2b5 100644
--- a/public/emboss_defines.h
+++ b/public/emboss_defines.h
@@ -21,6 +21,7 @@
#include <assert.h>
#define EMBOSS_CHECK(x) assert((x))
#define EMBOSS_CHECK_LE(x, y) assert((x) <= (y))
+#define EMBOSS_CHECK_LT(x, y) assert((x) < (y))
#define EMBOSS_CHECK_GE(x, y) assert((x) >= (y))
#define EMBOSS_CHECK_GT(x, y) assert((x) > (y))
#define EMBOSS_CHECK_EQ(x, y) assert((x) == (y))
@@ -41,10 +42,10 @@
// so this should be a reasonably safe way to check that a pointer is aligned.
#define EMBOSS_DCHECK_POINTER_ALIGNMENT(p, align, offset) \
EMBOSS_DCHECK_EQ(reinterpret_cast</**/ ::std::uintptr_t>((p)) % (align), \
- (offset))
+ (static_cast</**/ ::std::uintptr_t>((offset))))
#define EMBOSS_CHECK_POINTER_ALIGNMENT(p, align, offset) \
EMBOSS_CHECK_EQ(reinterpret_cast</**/ ::std::uintptr_t>((p)) % (align), \
- (offset))
+ static_cast</**/ ::std::uintptr_t>((offset)))
// !! WARNING !!
//
diff --git a/public/emboss_memory_util.h b/public/emboss_memory_util.h
index 73a8362..00d6772 100644
--- a/public/emboss_memory_util.h
+++ b/public/emboss_memory_util.h
@@ -850,6 +850,8 @@
// the appropriate size.
ValueType ReadUInt() const {
EMBOSS_CHECK_GE(bit_block_.SizeInBits(), offset_ + size_);
+ EMBOSS_CHECK_GE(bit_block_.SizeInBits(),
+ static_cast</**/ ::std::uint64_t>(offset_ + size_));
EMBOSS_CHECK(Ok());
return MaskToNBits(bit_block_.ReadUInt(), offset_ + size_) >> offset_;
}
diff --git a/public/emboss_memory_util_test.cc b/public/emboss_memory_util_test.cc
index 532dc12..779332d 100644
--- a/public/emboss_memory_util_test.cc
+++ b/public/emboss_memory_util_test.cc
@@ -34,14 +34,14 @@
BitBlock<LittleEndianByteOrderer<ReadWriteContiguousBuffer>, kBits>;
TEST(GreatestCommonDivisor, GreatestCommonDivisor) {
- EXPECT_EQ(4, GreatestCommonDivisor(12, 20));
- EXPECT_EQ(4, GreatestCommonDivisor(20, 12));
- EXPECT_EQ(4, GreatestCommonDivisor(20, 4));
- EXPECT_EQ(6, GreatestCommonDivisor(12, 78));
- EXPECT_EQ(6, GreatestCommonDivisor(6, 0));
- EXPECT_EQ(6, GreatestCommonDivisor(0, 6));
- EXPECT_EQ(3, GreatestCommonDivisor(9, 6));
- EXPECT_EQ(0, GreatestCommonDivisor(0, 0));
+ EXPECT_EQ(4U, GreatestCommonDivisor(12, 20));
+ EXPECT_EQ(4U, GreatestCommonDivisor(20, 12));
+ EXPECT_EQ(4U, GreatestCommonDivisor(20, 4));
+ EXPECT_EQ(6U, GreatestCommonDivisor(12, 78));
+ EXPECT_EQ(6U, GreatestCommonDivisor(6, 0));
+ EXPECT_EQ(6U, GreatestCommonDivisor(0, 6));
+ EXPECT_EQ(3U, GreatestCommonDivisor(9, 6));
+ EXPECT_EQ(0U, GreatestCommonDivisor(0, 0));
}
// Because MemoryAccessor's parameters are template parameters, it is not
@@ -235,7 +235,7 @@
EXPECT_EQ(0x0807060504030201UL, buffer.template ReadBigEndianUInt<64>());
const auto offset_buffer = buffer.template GetOffsetStorage<1, 0>(4, 4);
- EXPECT_EQ(4, offset_buffer.SizeInBytes());
+ EXPECT_EQ(4U, offset_buffer.SizeInBytes());
EXPECT_EQ(0x04030201U, offset_buffer.template ReadBigEndianUInt<32>());
// The size of the resulting buffer should be the minimum of the available
@@ -244,7 +244,7 @@
(buffer.template GetOffsetStorage<1, 0>(2, bytes.size() - 4)
.SizeInBytes()));
EXPECT_EQ(
- 0,
+ 0U,
(buffer.template GetOffsetStorage<1, 0>(bytes.size(), 4).SizeInBytes()));
}
@@ -274,7 +274,7 @@
bytes);
bytes[4] = static_cast<CharType>(255);
- EXPECT_EQ(0x1020304ff060708, buffer.template ReadBigEndianUInt<64>());
+ EXPECT_EQ(0x1020304ff060708UL, buffer.template ReadBigEndianUInt<64>());
}
TEST(ContiguousBuffer, ReturnTypeOfReadUInt) {
@@ -338,20 +338,21 @@
EXPECT_DEATH(buffer.ReadBigEndianUInt<64>(), "");
EXPECT_TRUE(buffer.Ok());
EXPECT_EQ(bytes.size() - 4, buffer.SizeInBytes());
- EXPECT_EQ(0x100f0e0d0c0b0a09, buffer.UncheckedReadBigEndianUInt<64>());
- EXPECT_EQ(0x090a0b0c0d0e0f10, buffer.UncheckedReadLittleEndianUInt<64>());
+ EXPECT_EQ(0x100f0e0d0c0b0a09UL, buffer.UncheckedReadBigEndianUInt<64>());
+ EXPECT_EQ(0x090a0b0c0d0e0f10UL, buffer.UncheckedReadLittleEndianUInt<64>());
const auto offset_buffer = buffer.GetOffsetStorage<1, 0>(4, 4);
- EXPECT_EQ(0x0c0b0a09, offset_buffer.ReadBigEndianUInt<32>());
- EXPECT_EQ(0x090a0b0c, offset_buffer.ReadLittleEndianUInt<32>());
- EXPECT_EQ(0x0c0b0a0908070605, offset_buffer.UncheckedReadBigEndianUInt<64>());
- EXPECT_EQ(4, offset_buffer.SizeInBytes());
+ EXPECT_EQ(0x0c0b0a09U, offset_buffer.ReadBigEndianUInt<32>());
+ EXPECT_EQ(0x090a0b0cU, offset_buffer.ReadLittleEndianUInt<32>());
+ EXPECT_EQ(0x0c0b0a0908070605UL,
+ offset_buffer.UncheckedReadBigEndianUInt<64>());
+ EXPECT_EQ(4U, offset_buffer.SizeInBytes());
EXPECT_TRUE(offset_buffer.Ok());
const auto small_offset_buffer = buffer.GetOffsetStorage<1, 0>(4, 1);
- EXPECT_EQ(0x0c, small_offset_buffer.ReadBigEndianUInt<8>());
- EXPECT_EQ(0x0c, small_offset_buffer.ReadLittleEndianUInt<8>());
- EXPECT_EQ(1, small_offset_buffer.SizeInBytes());
+ EXPECT_EQ(0x0cU, small_offset_buffer.ReadBigEndianUInt<8>());
+ EXPECT_EQ(0x0cU, small_offset_buffer.ReadLittleEndianUInt<8>());
+ EXPECT_EQ(1U, small_offset_buffer.SizeInBytes());
EXPECT_TRUE(small_offset_buffer.Ok());
EXPECT_FALSE(ReadOnlyContiguousBuffer().Ok());
@@ -360,9 +361,9 @@
EXPECT_DEATH((ReadOnlyContiguousBuffer{static_cast<char *>(nullptr), 4}
.ReadBigEndianUInt<32>()),
"");
- EXPECT_EQ(0, ReadOnlyContiguousBuffer().SizeInBytes());
- EXPECT_EQ(0, (ReadOnlyContiguousBuffer{static_cast<char *>(nullptr), 12}
- .SizeInBytes()));
+ EXPECT_EQ(0U, ReadOnlyContiguousBuffer().SizeInBytes());
+ EXPECT_EQ(0U, (ReadOnlyContiguousBuffer{static_cast<char *>(nullptr), 12}
+ .SizeInBytes()));
EXPECT_DEATH(
(ReadOnlyContiguousBuffer{bytes.data(), 0}.ReadBigEndianUInt<8>()), "");
@@ -370,8 +371,8 @@
// size and the requested size.
EXPECT_EQ(bytes.size() - 8,
(buffer.GetOffsetStorage<1, 0>(4, bytes.size() - 4).SizeInBytes()));
- EXPECT_EQ(4, (buffer.GetOffsetStorage<1, 0>(0, 4).SizeInBytes()));
- EXPECT_EQ(0, (buffer.GetOffsetStorage<1, 0>(bytes.size(), 4).SizeInBytes()));
+ EXPECT_EQ(4U, (buffer.GetOffsetStorage<1, 0>(0, 4).SizeInBytes()));
+ EXPECT_EQ(0U, (buffer.GetOffsetStorage<1, 0>(bytes.size(), 4).SizeInBytes()));
EXPECT_FALSE((ReadOnlyContiguousBuffer().GetOffsetStorage<1, 0>(0, 0).Ok()));
}
@@ -381,8 +382,8 @@
const auto buffer = ReadWriteContiguousBuffer{bytes.data(), bytes.size() - 4};
// Read and Ok methods should work just as in ReadOnlyContiguousBuffer.
EXPECT_TRUE(buffer.Ok());
- EXPECT_EQ(bytes.size() - 4, buffer.SizeInBytes());
- EXPECT_EQ(0x0c0b0a0908070605, buffer.ReadBigEndianUInt<64>());
+ EXPECT_EQ(bytes.size() - 4U, buffer.SizeInBytes());
+ EXPECT_EQ(0x0c0b0a0908070605UL, buffer.ReadBigEndianUInt<64>());
buffer.WriteBigEndianUInt<64>(0x05060708090a0b0c);
EXPECT_EQ(
@@ -463,12 +464,12 @@
const int buffer_start = 2;
const auto buffer = LittleEndianByteOrderer<ReadWriteContiguousBuffer>{
ReadWriteContiguousBuffer{bytes.data() + buffer_start, 8}};
- EXPECT_EQ(8, buffer.SizeInBytes());
+ EXPECT_EQ(8U, buffer.SizeInBytes());
EXPECT_TRUE(buffer.Ok());
- EXPECT_EQ(0x0807060504030201, buffer.ReadUInt<64>());
- EXPECT_EQ(0x0807060504030201, buffer.UncheckedReadUInt<64>());
+ EXPECT_EQ(0x0807060504030201UL, buffer.ReadUInt<64>());
+ EXPECT_EQ(0x0807060504030201UL, buffer.UncheckedReadUInt<64>());
EXPECT_DEATH(buffer.ReadUInt<56>(), "");
- EXPECT_EQ(0x07060504030201, buffer.UncheckedReadUInt<56>());
+ EXPECT_EQ(0x07060504030201UL, buffer.UncheckedReadUInt<56>());
buffer.WriteUInt<64>(0x0102030405060708);
EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{21, 22, 8, 7, 6, 5, 4, 3, 2, 1,
23, 24}),
@@ -480,7 +481,7 @@
EXPECT_DEATH(buffer.WriteUInt<56>(0x77777777777777), "");
EXPECT_FALSE(LittleEndianByteOrderer<ReadOnlyContiguousBuffer>().Ok());
- EXPECT_EQ(0,
+ EXPECT_EQ(0U,
LittleEndianByteOrderer<ReadOnlyContiguousBuffer>().SizeInBytes());
EXPECT_EQ(bytes[1], (LittleEndianByteOrderer<ReadOnlyContiguousBuffer>{
ReadOnlyContiguousBuffer{bytes.data() + 1, 0}}
@@ -496,12 +497,12 @@
const int buffer_start = 2;
const auto buffer = BigEndianByteOrderer<ReadWriteContiguousBuffer>{
ReadWriteContiguousBuffer{bytes.data() + buffer_start, 8}};
- EXPECT_EQ(8, buffer.SizeInBytes());
+ EXPECT_EQ(8U, buffer.SizeInBytes());
EXPECT_TRUE(buffer.Ok());
- EXPECT_EQ(0x0102030405060708, buffer.ReadUInt<64>());
- EXPECT_EQ(0x0102030405060708, buffer.UncheckedReadUInt<64>());
+ EXPECT_EQ(0x0102030405060708UL, buffer.ReadUInt<64>());
+ EXPECT_EQ(0x0102030405060708UL, buffer.UncheckedReadUInt<64>());
EXPECT_DEATH(buffer.ReadUInt<56>(), "");
- EXPECT_EQ(0x01020304050607, buffer.UncheckedReadUInt<56>());
+ EXPECT_EQ(0x01020304050607UL, buffer.UncheckedReadUInt<56>());
buffer.WriteUInt<64>(0x0807060504030201);
EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{21, 22, 8, 7, 6, 5, 4, 3, 2, 1,
23, 24}),
@@ -513,7 +514,7 @@
EXPECT_DEATH(buffer.WriteUInt<56>(0x77777777777777), "");
EXPECT_FALSE(BigEndianByteOrderer<ReadOnlyContiguousBuffer>().Ok());
- EXPECT_EQ(0, BigEndianByteOrderer<ReadOnlyContiguousBuffer>().SizeInBytes());
+ EXPECT_EQ(0U, BigEndianByteOrderer<ReadOnlyContiguousBuffer>().SizeInBytes());
EXPECT_EQ(bytes[1], (BigEndianByteOrderer<ReadOnlyContiguousBuffer>{
ReadOnlyContiguousBuffer{bytes.data() + 1, 0}}
.UncheckedReadUInt<8>()));
@@ -531,14 +532,14 @@
// NullByteOrderer::UncheckedRead ignores its argument.
EXPECT_EQ(bytes[0], buffer.UncheckedReadUInt<8>());
buffer.WriteUInt<8>(0x24);
- EXPECT_EQ(0x24, bytes[0]);
+ EXPECT_EQ(0x24U, bytes[0]);
buffer.UncheckedWriteUInt<8>(0x25);
- EXPECT_EQ(0x25, bytes[0]);
- EXPECT_EQ(1, buffer.SizeInBytes());
+ EXPECT_EQ(0x25U, bytes[0]);
+ EXPECT_EQ(1U, buffer.SizeInBytes());
EXPECT_TRUE(buffer.Ok());
EXPECT_FALSE(NullByteOrderer<ReadOnlyContiguousBuffer>().Ok());
- EXPECT_EQ(0, NullByteOrderer<ReadOnlyContiguousBuffer>().SizeInBytes());
+ EXPECT_EQ(0U, NullByteOrderer<ReadOnlyContiguousBuffer>().SizeInBytes());
EXPECT_DEATH((NullByteOrderer<ReadOnlyContiguousBuffer>{
ReadOnlyContiguousBuffer{bytes, 0}}
.ReadUInt<8>()),
@@ -560,12 +561,12 @@
0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10};
const auto big_endian =
BigEndianBitBlockN<64>{ReadWriteContiguousBuffer{bytes + 4, 8}};
- EXPECT_EQ(64, big_endian.SizeInBits());
+ EXPECT_EQ(64U, big_endian.SizeInBits());
EXPECT_TRUE(big_endian.Ok());
EXPECT_EQ(0x05060708090a0b0cUL, big_endian.ReadUInt());
EXPECT_EQ(0x05060708090a0b0cUL, big_endian.UncheckedReadUInt());
EXPECT_FALSE(BigEndianBitBlockN<64>().Ok());
- EXPECT_EQ(64, BigEndianBitBlockN<64>().SizeInBits());
+ EXPECT_EQ(64U, BigEndianBitBlockN<64>().SizeInBits());
EXPECT_FALSE(
(BigEndianBitBlockN<64>{ReadWriteContiguousBuffer{bytes, 0}}.Ok()));
}
@@ -575,12 +576,12 @@
0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10};
const auto little_endian =
LittleEndianBitBlockN<64>{ReadWriteContiguousBuffer{bytes + 4, 8}};
- EXPECT_EQ(64, little_endian.SizeInBits());
+ EXPECT_EQ(64U, little_endian.SizeInBits());
EXPECT_TRUE(little_endian.Ok());
EXPECT_EQ(0x0c0b0a0908070605UL, little_endian.ReadUInt());
EXPECT_EQ(0x0c0b0a0908070605UL, little_endian.UncheckedReadUInt());
EXPECT_FALSE(LittleEndianBitBlockN<64>().Ok());
- EXPECT_EQ(64, LittleEndianBitBlockN<64>().SizeInBits());
+ EXPECT_EQ(64U, LittleEndianBitBlockN<64>().SizeInBits());
EXPECT_FALSE(
(LittleEndianBitBlockN<64>{ReadWriteContiguousBuffer{bytes, 0}}.Ok()));
}
@@ -592,15 +593,15 @@
LittleEndianBitBlockN<64>{ReadWriteContiguousBuffer{bytes, 8}};
const OffsetBitBlock<LittleEndianBitBlockN<64>> offset_block =
bit_block.GetOffsetStorage<1, 0>(4, 8);
- EXPECT_EQ(8, offset_block.SizeInBits());
- EXPECT_EQ(0xf1, offset_block.ReadUInt());
+ EXPECT_EQ(8U, offset_block.SizeInBits());
+ EXPECT_EQ(0xf1U, offset_block.ReadUInt());
EXPECT_EQ(bit_block.SizeInBits(),
(bit_block.GetOffsetStorage<1, 0>(8, bit_block.SizeInBits())
.SizeInBits()));
EXPECT_FALSE(
(bit_block.GetOffsetStorage<1, 0>(8, bit_block.SizeInBits()).Ok()));
- EXPECT_EQ(10, (bit_block.GetOffsetStorage<1, 0>(bit_block.SizeInBits(), 10)
- .SizeInBits()));
+ EXPECT_EQ(10U, (bit_block.GetOffsetStorage<1, 0>(bit_block.SizeInBits(), 10)
+ .SizeInBits()));
}
TEST(OffsetBitBlock, Methods) {
@@ -613,8 +614,8 @@
const auto offset_block = bit_block.GetOffsetStorage<1, 0>(8, 48);
EXPECT_FALSE((offset_block.GetOffsetStorage<1, 0>(40, 16).Ok()));
- EXPECT_EQ(0x0a0b0c0d0e0f, offset_block.ReadUInt());
- EXPECT_EQ(0x0a0b0c0d0e0f, offset_block.UncheckedReadUInt());
+ EXPECT_EQ(0x0a0b0c0d0e0fUL, offset_block.ReadUInt());
+ EXPECT_EQ(0x0a0b0c0d0e0fUL, offset_block.UncheckedReadUInt());
offset_block.WriteUInt(0x0f0e0d0c0b0a);
EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{0x10, 0x0a, 0x0b, 0x0c, 0x0d,
0x0e, 0x0f, 0x09}),
@@ -631,8 +632,8 @@
const auto offset_offset_block = offset_block.GetOffsetStorage<1, 0>(16, 16);
EXPECT_FALSE((offset_offset_block.GetOffsetStorage<1, 0>(8, 16).Ok()));
- EXPECT_EQ(0x0d0c, offset_offset_block.ReadUInt());
- EXPECT_EQ(0x0d0c, offset_offset_block.UncheckedReadUInt());
+ EXPECT_EQ(0x0d0cU, offset_offset_block.ReadUInt());
+ EXPECT_EQ(0x0d0cU, offset_offset_block.UncheckedReadUInt());
offset_offset_block.WriteUInt(0x0c0d);
EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{0x10, 0x0a, 0x0b, 0x0d, 0x0c,
0x0e, 0x0f, 0x09}),
@@ -649,7 +650,7 @@
const auto null_offset_block = OffsetBitBlock<BigEndianBitBlockN<32>>();
EXPECT_FALSE(null_offset_block.Ok());
- EXPECT_EQ(0, null_offset_block.SizeInBits());
+ EXPECT_EQ(0U, null_offset_block.SizeInBits());
}
} // namespace test
diff --git a/public/emboss_prelude_test.cc b/public/emboss_prelude_test.cc
index 97ac6fb..0938ca6 100644
--- a/public/emboss_prelude_test.cc
+++ b/public/emboss_prelude_test.cc
@@ -239,8 +239,8 @@
::std::vector</**/ ::std::uint8_t> bytes = {{0x10, 0x0f, 0x0e, 0x0d}};
auto uint24_view =
UIntViewN<24>{BitBlockN<24>{ReadWriteContiguousBuffer{bytes.data(), 3}}};
- EXPECT_EQ(0x0e0f10, uint24_view.Read());
- EXPECT_EQ(0x0e0f10, uint24_view.UncheckedRead());
+ EXPECT_EQ(0x0e0f10U, uint24_view.Read());
+ EXPECT_EQ(0x0e0f10U, uint24_view.UncheckedRead());
EXPECT_DEATH(uint24_view.Write(0x1000000), "");
uint24_view.Write(0x100f0e);
EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0x0e, 0x0f, 0x10, 0x0d}}),
@@ -257,7 +257,7 @@
auto uint24_view =
UIntViewN<24>{BitBlockN<24>{ReadWriteContiguousBuffer{bytes.data(), 2}}};
EXPECT_DEATH(uint24_view.Read(), "");
- EXPECT_EQ(0x0e0f10, uint24_view.UncheckedRead());
+ EXPECT_EQ(0x0e0f10U, uint24_view.UncheckedRead());
EXPECT_DEATH(uint24_view.Write(0x100f0e), "");
uint24_view.UncheckedWrite(0x100f0e);
EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0x0e, 0x0f, 0x10, 0x0d}}),
@@ -275,7 +275,7 @@
UIntView<ViewParameters<23>, OffsetBitBlock<BitBlockN<24>>>{BitBlockN<24>{
ReadWriteContiguousBuffer{bytes.data(),
3}}.GetOffsetStorage<1, 0>(0, 23)};
- EXPECT_EQ(0x0, uint23_view.Read());
+ EXPECT_EQ(0x0U, uint23_view.Read());
EXPECT_FALSE(uint23_view.CouldWriteValue(0x800f0e));
EXPECT_FALSE(uint23_view.CouldWriteValue(0x800000));
EXPECT_TRUE(uint23_view.CouldWriteValue(0x7fffff));
@@ -297,7 +297,7 @@
EXPECT_TRUE(UpdateFromText(uint24_view, "23"));
EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{23, 0x00, 0x00, 0xff}}),
bytes);
- EXPECT_EQ(23, uint24_view.Read());
+ EXPECT_EQ(23U, uint24_view.Read());
EXPECT_FALSE(UpdateFromText(uint24_view, "16777216"));
EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{23, 0x00, 0x00, 0xff}}),
bytes);
@@ -543,19 +543,19 @@
}
TEST(MaxBcd, Values) {
- EXPECT_EQ(0, MaxBcd</**/ ::std::uint64_t>(0));
- EXPECT_EQ(1, MaxBcd</**/ ::std::uint64_t>(1));
- EXPECT_EQ(3, MaxBcd</**/ ::std::uint64_t>(2));
- EXPECT_EQ(7, MaxBcd</**/ ::std::uint64_t>(3));
- EXPECT_EQ(9, MaxBcd</**/ ::std::uint64_t>(4));
- EXPECT_EQ(19, MaxBcd</**/ ::std::uint64_t>(5));
- EXPECT_EQ(39, MaxBcd</**/ ::std::uint64_t>(6));
- EXPECT_EQ(79, MaxBcd</**/ ::std::uint64_t>(7));
- EXPECT_EQ(99, MaxBcd</**/ ::std::uint64_t>(8));
- EXPECT_EQ(199, MaxBcd</**/ ::std::uint64_t>(9));
- EXPECT_EQ(999, MaxBcd</**/ ::std::uint64_t>(12));
- EXPECT_EQ(9999, MaxBcd</**/ ::std::uint64_t>(16));
- EXPECT_EQ(999999, MaxBcd</**/ ::std::uint64_t>(24));
+ EXPECT_EQ(0U, MaxBcd</**/ ::std::uint64_t>(0));
+ EXPECT_EQ(1U, MaxBcd</**/ ::std::uint64_t>(1));
+ EXPECT_EQ(3U, MaxBcd</**/ ::std::uint64_t>(2));
+ EXPECT_EQ(7U, MaxBcd</**/ ::std::uint64_t>(3));
+ EXPECT_EQ(9U, MaxBcd</**/ ::std::uint64_t>(4));
+ EXPECT_EQ(19U, MaxBcd</**/ ::std::uint64_t>(5));
+ EXPECT_EQ(39U, MaxBcd</**/ ::std::uint64_t>(6));
+ EXPECT_EQ(79U, MaxBcd</**/ ::std::uint64_t>(7));
+ EXPECT_EQ(99U, MaxBcd</**/ ::std::uint64_t>(8));
+ EXPECT_EQ(199U, MaxBcd</**/ ::std::uint64_t>(9));
+ EXPECT_EQ(999U, MaxBcd</**/ ::std::uint64_t>(12));
+ EXPECT_EQ(9999U, MaxBcd</**/ ::std::uint64_t>(16));
+ EXPECT_EQ(999999U, MaxBcd</**/ ::std::uint64_t>(24));
EXPECT_EQ(3999999999999999UL, MaxBcd</**/ ::std::uint64_t>(62));
EXPECT_EQ(7999999999999999UL, MaxBcd</**/ ::std::uint64_t>(63));
EXPECT_EQ(9999999999999999UL, MaxBcd</**/ ::std::uint64_t>(64));
@@ -689,8 +689,8 @@
::std::vector</**/ ::std::uint8_t> bytes = {{0x16, 0x15, 0x14, 0x13}};
auto bcd24_view =
BcdViewN<24>{BitBlockN<24>{ReadWriteContiguousBuffer{bytes.data(), 3}}};
- EXPECT_EQ(141516, bcd24_view.Read());
- EXPECT_EQ(141516, bcd24_view.UncheckedRead());
+ EXPECT_EQ(141516U, bcd24_view.Read());
+ EXPECT_EQ(141516U, bcd24_view.UncheckedRead());
bcd24_view.Write(161514);
EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0x14, 0x15, 0x16, 0x13}}),
bytes);
@@ -710,7 +710,7 @@
auto bcd24_view =
BcdViewN<24>{BitBlockN<24>{ReadWriteContiguousBuffer{bytes.data(), 2}}};
EXPECT_DEATH(bcd24_view.Read(), "");
- EXPECT_EQ(141516, bcd24_view.UncheckedRead());
+ EXPECT_EQ(141516U, bcd24_view.UncheckedRead());
EXPECT_DEATH(bcd24_view.Write(161514), "");
bcd24_view.UncheckedWrite(161514);
EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0x14, 0x15, 0x16, 0x13}}),
@@ -728,7 +728,7 @@
BcdView<ViewParameters<23>, OffsetBitBlock<BitBlockN<24>>>{BitBlockN<24>{
ReadWriteContiguousBuffer{bytes.data(),
3}}.GetOffsetStorage<1, 0>(0, 23)};
- EXPECT_EQ(0x0, bcd23_view.Read());
+ EXPECT_EQ(0x0U, bcd23_view.Read());
EXPECT_FALSE(bcd23_view.CouldWriteValue(800000));
EXPECT_TRUE(bcd23_view.CouldWriteValue(799999));
EXPECT_DEATH(bcd23_view.Write(800000), "");
diff --git a/public/emboss_text_util.h b/public/emboss_text_util.h
index 9eda1a2..906f8c0 100644
--- a/public/emboss_text_util.h
+++ b/public/emboss_text_util.h
@@ -576,12 +576,11 @@
::std::array<char, 30> buffer;
// TODO(bolms): Figure out how to get ::std::snprintf to work on
// microcontroller builds.
- EMBOSS_CHECK_LE(static_cast</**/ ::std::size_t>(
- ::snprintf(&(buffer[0]), buffer.size(), "%.*g",
- FloatConstants<Float>::kPrintfPrecision(),
- static_cast<double>(n)) +
- 1),
- buffer.size());
+ EMBOSS_CHECK_LE(
+ static_cast</**/ ::std::size_t>(::snprintf(
+ &(buffer[0]), buffer.size(), "%.*g",
+ FloatConstants<Float>::kPrintfPrecision(), static_cast<double>(n))),
+ buffer.size());
stream->Write(&buffer[0]);
// TODO(bolms): Support digit grouping.
