Skip to content

Commit ba2229e

Browse files
mjpt777mjpt777
committed
[C++] Warnings cleanup.
1 parent eac0e6b commit ba2229e

File tree

2 files changed

+55
-47
lines changed

2 files changed

+55
-47
lines changed

‎sbe-tool/src/test/c/CodeGenTest.cpp‎

Lines changed: 17 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -58,7 +58,7 @@ static const std::uint8_t FUEL_FIGURES_COUNT = 3;
5858
static const std::uint8_t ACCELERATION_COUNT = 3;
5959

6060
static const std::uint64_t expectedHeaderSize = 8;
61-
static const std::uint64_t expectedCarSize = 191;
61+
static const std::uint64_t expectedCarEncodedLength = 191;
6262

6363
static const std::uint16_t fuel1Speed = 30;
6464
static const float fuel1Mpg = 35.9f;
@@ -487,14 +487,14 @@ TEST_F(CodeGenTest, shouldBeAbleToEncodeHeaderPlusCarCorrectly)
487487
const char *bp = buffer;
488488

489489
std::uint64_t hdrSz = encodeHdr(buffer, 0, sizeof(buffer));
490-
std::uint64_t carSz = encodeCar(
490+
std::uint64_t carEncodedLength = encodeCar(
491491
buffer, CGT(messageHeader_encoded_length)(), sizeof(buffer) - CGT(messageHeader_encoded_length)());
492492

493493
EXPECT_EQ(hdrSz, expectedHeaderSize);
494-
EXPECT_EQ(carSz, expectedCarSize);
494+
EXPECT_EQ(carEncodedLength, expectedCarEncodedLength);
495495

496496
EXPECT_EQ(*((std::uint16_t *)bp), CGT(car_sbe_block_length)());
497-
const size_t activationCodePosition = hdrSz + carSz - ACTIVATION_CODE_LENGTH;
497+
const size_t activationCodePosition = hdrSz + carEncodedLength - ACTIVATION_CODE_LENGTH;
498498
const size_t activationCodeLengthPosition = activationCodePosition - sizeof(std::uint16_t);
499499
EXPECT_EQ(*(std::uint16_t *)(bp + activationCodeLengthPosition), ACTIVATION_CODE_LENGTH);
500500
EXPECT_EQ(std::string(bp + activationCodePosition, ACTIVATION_CODE_LENGTH), ACTIVATION_CODE);
@@ -505,11 +505,11 @@ TEST_F(CodeGenTest, shouldBeAbleToEncodeAndDecodeHeaderPlusCarCorrectly)
505505
char buffer[BUFFER_LEN];
506506

507507
std::uint64_t hdrSz = encodeHdr(buffer, 0, sizeof(buffer));
508-
std::uint64_t carSz = encodeCar(
508+
std::uint64_t carEncodedLength = encodeCar(
509509
buffer, CGT(messageHeader_encoded_length)(), sizeof(buffer) - CGT(messageHeader_encoded_length)());
510510

511511
EXPECT_EQ(hdrSz, expectedHeaderSize);
512-
EXPECT_EQ(carSz, expectedCarSize);
512+
EXPECT_EQ(carEncodedLength, expectedCarEncodedLength);
513513

514514
if (!CGT(messageHeader_wrap)(&m_hdrDecoder, buffer, 0, 0, hdrSz))
515515
{
@@ -528,7 +528,7 @@ TEST_F(CodeGenTest, shouldBeAbleToEncodeAndDecodeHeaderPlusCarCorrectly)
528528
CGT(messageHeader_encoded_length)(),
529529
CGT(car_sbe_block_length)(),
530530
CGT(car_sbe_schema_version)(),
531-
hdrSz + carSz))
531+
hdrSz + carEncodedLength))
532532
{
533533
throw std::runtime_error(sbe_strerror(errno));
534534
}
@@ -669,7 +669,7 @@ TEST_F(CodeGenTest, shouldBeAbleToEncodeAndDecodeHeaderPlusCarCorrectly)
669669
EXPECT_EQ(CGT(car_activationCode_length)(&m_carDecoder), ACTIVATION_CODE_LENGTH);
670670
EXPECT_EQ(std::string(CGT(car_activationCode)(&m_carDecoder), ACTIVATION_CODE_LENGTH), ACTIVATION_CODE);
671671

672-
EXPECT_EQ(CGT(car_encoded_length)(&m_carDecoder), expectedCarSize);
672+
EXPECT_EQ(CGT(car_encoded_length)(&m_carDecoder), expectedCarEncodedLength);
673673
}
674674

675675
struct CallbacksForEach
@@ -703,10 +703,10 @@ TEST_F(CodeGenTest, shouldBeAbleUseOnStackCodecsAndGroupForEach)
703703
}
704704

705705
std::uint64_t hdrSz = encodeHdr(hdr);
706-
std::uint64_t carSz = encodeCar(car);
706+
std::uint64_t carEncodedLength = encodeCar(car);
707707

708708
EXPECT_EQ(hdrSz, expectedHeaderSize);
709-
EXPECT_EQ(carSz, expectedCarSize);
709+
EXPECT_EQ(carEncodedLength, expectedCarEncodedLength);
710710

711711
CGT(messageHeader) hdrDecoder;
712712
if (!CGT(messageHeader_reset)(&hdrDecoder, buffer, 0, hdrSz, 0))
@@ -725,7 +725,7 @@ TEST_F(CodeGenTest, shouldBeAbleUseOnStackCodecsAndGroupForEach)
725725
&carDecoder,
726726
buffer + CGT(messageHeader_encoded_length)(),
727727
0,
728-
carSz,
728+
carEncodedLength,
729729
CGT(car_sbe_block_length)(),
730730
CGT(car_sbe_schema_version)()))
731731
{
@@ -797,7 +797,7 @@ TEST_F(CodeGenTest, shouldBeAbleUseOnStackCodecsAndGroupForEach)
797797
EXPECT_EQ(CGT(car_get_manufacturer)(&carDecoder, tmp, sizeof(tmp)), ACTIVATION_CODE_LENGTH);
798798
EXPECT_EQ(std::string(tmp, ACTIVATION_CODE_LENGTH), ACTIVATION_CODE);
799799

800-
EXPECT_EQ(CGT(car_encoded_length)(&carDecoder), expectedCarSize);
800+
EXPECT_EQ(CGT(car_encoded_length)(&carDecoder), expectedCarEncodedLength);
801801
}
802802

803803
static const std::size_t offsetVehicleCode = 32;
@@ -874,7 +874,7 @@ TEST_F(CodeGenTest, shouldBeAbleToUseStdStringMethodsForEncode)
874874
const char *acti = activationCode.c_str();
875875
CGT(car_put_activationCode)(&car, acti, strlen(acti));
876876

877-
EXPECT_EQ(CGT(car_encoded_length)(&car), expectedCarSize);
877+
EXPECT_EQ(CGT(car_encoded_length)(&car), expectedCarEncodedLength);
878878

879879
EXPECT_EQ(std::string(buffer + baseOffset + offsetVehicleCode, VEHICLE_CODE_LENGTH), vehicleCode);
880880

@@ -915,12 +915,12 @@ TEST_F(CodeGenTest, shouldBeAbleToUseStdStringMethodsForDecode)
915915
CGT(car) carEncoder;
916916
CGT(car_reset)(&carEncoder, buffer, 0, sizeof(buffer), CGT(car_sbe_block_length)(), CGT(car_sbe_schema_version)());
917917

918-
std::uint64_t carSz = encodeCar(carEncoder);
918+
std::uint64_t carEncodedLength = encodeCar(carEncoder);
919919

920-
EXPECT_EQ(carSz, expectedCarSize);
920+
EXPECT_EQ(carEncodedLength, expectedCarEncodedLength);
921921

922922
CGT(car) carDecoder;
923-
CGT(car_reset)(&carDecoder, buffer, 0, carSz, CGT(car_sbe_block_length)(), CGT(car_sbe_schema_version)());
923+
CGT(car_reset)(&carDecoder, buffer, 0, carEncodedLength, CGT(car_sbe_block_length)(), CGT(car_sbe_schema_version)());
924924

925925
std::string vehicleCode(VEHICLE_CODE, CGT(car_vehicleCode_length)());
926926

@@ -997,5 +997,5 @@ TEST_F(CodeGenTest, shouldBeAbleToUseStdStringMethodsForDecode)
997997
std::string(ACTIVATION_CODE, ACTIVATION_CODE_LENGTH));
998998
}
999999

1000-
EXPECT_EQ(CGT(car_encoded_length)(&carDecoder), expectedCarSize);
1000+
EXPECT_EQ(CGT(car_encoded_length)(&carDecoder), expectedCarEncodedLength);
10011001
}

‎sbe-tool/src/test/cpp/CodeGenTest.cpp‎

Lines changed: 38 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -58,7 +58,7 @@ static const std::uint8_t FUEL_FIGURES_COUNT = 3;
5858
static const std::uint8_t ACCELERATION_COUNT = 3;
5959

6060
static const std::uint64_t expectedHeaderSize = 8;
61-
static const std::uint64_t expectedCarSize = 207;
61+
static const std::uint64_t expectedCarEncodedLength = 207;
6262

6363
static const std::uint16_t fuel1Speed = 30;
6464
static const float fuel1Mpg = 35.9f;
@@ -443,6 +443,7 @@ TEST_F(CodeGenTest, shouldBeAbleToEncodeCarCorrectly)
443443
ACTIVATION_CODE_LENGTH,
444444
COLOR_LENGTH
445445
);
446+
446447
EXPECT_EQ(sz, predictedCarSz);
447448
EXPECT_EQ(Car::isConstLength(), false);
448449
EXPECT_EQ(Car::PerformanceFigures::Acceleration::isConstLength(), true);
@@ -454,14 +455,14 @@ TEST_F(CodeGenTest, shouldBeAbleToEncodeHeaderPlusCarCorrectly)
454455
const char *bp = buffer;
455456

456457
std::uint64_t hdrSz = encodeHdr(buffer, 0, sizeof(buffer));
457-
std::uint64_t carSz = encodeCar(buffer, m_hdr.encodedLength(), sizeof(buffer) - m_hdr.encodedLength());
458+
std::uint64_t carEncodedLength = encodeCar(buffer, m_hdr.encodedLength(), sizeof(buffer) - m_hdr.encodedLength());
458459

459460
EXPECT_EQ(hdrSz, expectedHeaderSize);
460-
EXPECT_EQ(carSz, expectedCarSize);
461+
EXPECT_EQ(carEncodedLength, expectedCarEncodedLength);
461462

462463
EXPECT_EQ(*((std::uint16_t *)bp), Car::sbeBlockLength());
463464
const size_t activationCodePosition =
464-
(hdrSz + carSz) - (ACTIVATION_CODE_LENGTH + sizeof(std::uint32_t) + COLOR_LENGTH);
465+
(hdrSz + carEncodedLength) - (ACTIVATION_CODE_LENGTH + sizeof(std::uint32_t) + COLOR_LENGTH);
465466
const size_t activationCodeLengthPosition = activationCodePosition - sizeof(std::uint16_t);
466467
EXPECT_EQ(*(std::uint16_t *)(bp + activationCodeLengthPosition), ACTIVATION_CODE_LENGTH);
467468
EXPECT_EQ(std::string(bp + activationCodePosition, ACTIVATION_CODE_LENGTH), ACTIVATION_CODE);
@@ -472,10 +473,10 @@ TEST_F(CodeGenTest, shouldBeAbleToEncodeAndDecodeHeaderPlusCarCorrectly)
472473
char buffer[BUFFER_LEN];
473474

474475
std::uint64_t hdrSz = encodeHdr(buffer, 0, sizeof(buffer));
475-
std::uint64_t carSz = encodeCar(buffer, m_hdr.encodedLength(), sizeof(buffer) - m_hdr.encodedLength());
476+
std::uint64_t carEncodedLength = encodeCar(buffer, m_hdr.encodedLength(), sizeof(buffer) - m_hdr.encodedLength());
476477

477478
EXPECT_EQ(hdrSz, expectedHeaderSize);
478-
EXPECT_EQ(carSz, expectedCarSize);
479+
EXPECT_EQ(carEncodedLength, expectedCarEncodedLength);
479480

480481
m_hdrDecoder.wrap(buffer, 0, 0, hdrSz);
481482

@@ -485,9 +486,9 @@ TEST_F(CodeGenTest, shouldBeAbleToEncodeAndDecodeHeaderPlusCarCorrectly)
485486
EXPECT_EQ(m_hdrDecoder.version(), Car::sbeSchemaVersion());
486487
EXPECT_EQ(m_hdrDecoder.encodedLength(), expectedHeaderSize);
487488

488-
m_carDecoder.wrapForDecode(buffer, m_hdrDecoder.encodedLength(), Car::sbeBlockLength(), Car::sbeSchemaVersion(), hdrSz + carSz);
489+
m_carDecoder.wrapForDecode(buffer, m_hdrDecoder.encodedLength(), Car::sbeBlockLength(), Car::sbeSchemaVersion(), hdrSz + carEncodedLength);
489490

490-
EXPECT_EQ(m_carDecoder.decodeLength(), expectedCarSize);
491+
EXPECT_EQ(m_carDecoder.decodeLength(), expectedCarEncodedLength);
491492

492493
EXPECT_EQ(m_carDecoder.serialNumber(), SERIAL_NUMBER);
493494
EXPECT_EQ(m_carDecoder.modelYear(), MODEL_YEAR);
@@ -599,8 +600,8 @@ TEST_F(CodeGenTest, shouldBeAbleToEncodeAndDecodeHeaderPlusCarCorrectly)
599600
EXPECT_EQ(m_carDecoder.colorLength(), COLOR_LENGTH);
600601
EXPECT_EQ(std::string(m_carDecoder.color(), COLOR_LENGTH), COLOR);
601602

602-
EXPECT_EQ(m_carDecoder.encodedLength(), expectedCarSize);
603-
EXPECT_EQ(m_carDecoder.decodeLength(), expectedCarSize);
603+
EXPECT_EQ(m_carDecoder.encodedLength(), expectedCarEncodedLength);
604+
EXPECT_EQ(m_carDecoder.decodeLength(), expectedCarEncodedLength);
604605
}
605606

606607
struct CallbacksForEach
@@ -638,10 +639,10 @@ TEST_F(CodeGenTest, shouldBeAbleUseOnStackCodecsAndGroupForEach)
638639
Car car(buffer + hdr.encodedLength(), sizeof(buffer) - hdr.encodedLength());
639640

640641
std::uint64_t hdrSz = encodeHdr(hdr);
641-
std::uint64_t carSz = encodeCar(car);
642+
std::uint64_t carEncodedLength = encodeCar(car);
642643

643644
EXPECT_EQ(hdrSz, expectedHeaderSize);
644-
EXPECT_EQ(carSz, expectedCarSize);
645+
EXPECT_EQ(carEncodedLength, expectedCarEncodedLength);
645646

646647
const MessageHeader hdrDecoder(buffer, hdrSz, 0);
647648

@@ -651,7 +652,7 @@ TEST_F(CodeGenTest, shouldBeAbleUseOnStackCodecsAndGroupForEach)
651652
EXPECT_EQ(hdrDecoder.version(), Car::sbeSchemaVersion());
652653
EXPECT_EQ(hdrDecoder.encodedLength(), expectedHeaderSize);
653654

654-
Car carDecoder(buffer + hdrDecoder.encodedLength(), carSz, hdrDecoder.blockLength(), hdrDecoder.version());
655+
Car carDecoder(buffer + hdrDecoder.encodedLength(), carEncodedLength, hdrDecoder.blockLength(), hdrDecoder.version());
655656
CallbacksForEach cbs;
656657

657658
Car::FuelFigures &fuelFigures = carDecoder.fuelFigures();
@@ -707,7 +708,7 @@ TEST_F(CodeGenTest, shouldBeAbleUseOnStackCodecsAndGroupForEach)
707708
EXPECT_EQ(carDecoder.getColor(tmp, sizeof(tmp)), COLOR_LENGTH);
708709
EXPECT_EQ(std::string(tmp, COLOR_LENGTH), COLOR);
709710

710-
EXPECT_EQ(carDecoder.encodedLength(), expectedCarSize);
711+
EXPECT_EQ(carDecoder.encodedLength(), expectedCarEncodedLength);
711712
}
712713

713714
static const std::size_t offsetVehicleCode = 32;
@@ -762,29 +763,36 @@ TEST_F(CodeGenTest, shouldBeAbleToUseStdStringMethodsForEncode)
762763
.putActivationCode(activationCode)
763764
.putColor(color);
764765

765-
EXPECT_EQ(car.encodedLength(), expectedCarSize);
766+
EXPECT_EQ(car.encodedLength(), expectedCarEncodedLength);
766767

767768
EXPECT_EQ(std::string(buffer + baseOffset + offsetVehicleCode, VEHICLE_CODE_LENGTH), vehicleCode);
768769

769-
EXPECT_EQ(*(std::uint16_t *)(buffer + baseOffset + offsetUsageDesc1Length), FUEL_FIGURES_1_USAGE_DESCRIPTION_LENGTH);
770+
EXPECT_EQ(*(std::uint16_t *)(buffer + baseOffset + offsetUsageDesc1Length),
771+
static_cast<std::uint16_t>(FUEL_FIGURES_1_USAGE_DESCRIPTION_LENGTH));
770772
EXPECT_EQ(std::string(buffer + baseOffset + offsetUsageDesc1Data, FUEL_FIGURES_1_USAGE_DESCRIPTION_LENGTH), usageDesc1);
771773

772-
EXPECT_EQ(*(std::uint16_t *)(buffer + baseOffset + offsetUsageDesc2Length), FUEL_FIGURES_2_USAGE_DESCRIPTION_LENGTH);
774+
EXPECT_EQ(*(std::uint16_t *)(buffer + baseOffset + offsetUsageDesc2Length),
775+
static_cast<std::uint16_t>(FUEL_FIGURES_2_USAGE_DESCRIPTION_LENGTH));
773776
EXPECT_EQ(std::string(buffer + baseOffset + offsetUsageDesc2Data, FUEL_FIGURES_2_USAGE_DESCRIPTION_LENGTH), usageDesc2);
774777

775-
EXPECT_EQ(*(std::uint16_t *)(buffer + baseOffset + offsetUsageDesc3Length), FUEL_FIGURES_3_USAGE_DESCRIPTION_LENGTH);
778+
EXPECT_EQ(*(std::uint16_t *)(buffer + baseOffset + offsetUsageDesc3Length),
779+
static_cast<std::uint16_t>(FUEL_FIGURES_3_USAGE_DESCRIPTION_LENGTH));
776780
EXPECT_EQ(std::string(buffer + baseOffset + offsetUsageDesc3Data, FUEL_FIGURES_3_USAGE_DESCRIPTION_LENGTH), usageDesc3);
777781

778-
EXPECT_EQ(*(std::uint16_t *)(buffer + baseOffset + offsetManufacturerLength), MANUFACTURER_LENGTH);
782+
EXPECT_EQ(*(std::uint16_t *)(buffer + baseOffset + offsetManufacturerLength),
783+
static_cast<std::uint16_t>(MANUFACTURER_LENGTH));
779784
EXPECT_EQ(std::string(buffer + baseOffset + offsetManufacturerData, MANUFACTURER_LENGTH), manufacturer);
780785

781-
EXPECT_EQ(*(std::uint16_t *)(buffer + baseOffset + offsetModelLength), MODEL_LENGTH);
786+
EXPECT_EQ(*(std::uint16_t *)(buffer + baseOffset + offsetModelLength),
787+
static_cast<std::uint16_t>(MODEL_LENGTH));
782788
EXPECT_EQ(std::string(buffer + baseOffset + offsetModelData, MODEL_LENGTH), model);
783789

784-
EXPECT_EQ(*(std::uint16_t *)(buffer + baseOffset + offsetActivationCodeLength), ACTIVATION_CODE_LENGTH);
790+
EXPECT_EQ(*(std::uint16_t *)(buffer + baseOffset + offsetActivationCodeLength),
791+
static_cast<std::uint16_t>(ACTIVATION_CODE_LENGTH));
785792
EXPECT_EQ(std::string(buffer + baseOffset + offsetActivationCodeData, ACTIVATION_CODE_LENGTH), activationCode);
786793

787-
EXPECT_EQ(*(std::uint16_t *)(buffer + baseOffset + offsetColorLength), COLOR_LENGTH);
794+
EXPECT_EQ(*(std::uint16_t *)(buffer + baseOffset + offsetColorLength),
795+
static_cast<std::uint16_t>(COLOR_LENGTH));
788796
EXPECT_EQ(std::string(buffer + baseOffset + offsetColorData, COLOR_LENGTH), color);
789797
}
790798

@@ -793,11 +801,11 @@ TEST_F(CodeGenTest, shouldBeAbleToUseStdStringMethodsForDecode)
793801
char buffer[2048];
794802
Car carEncoder(buffer, sizeof(buffer));
795803

796-
std::uint64_t carSz = encodeCar(carEncoder);
804+
std::uint64_t carEncodedLength = encodeCar(carEncoder);
797805

798-
EXPECT_EQ(carSz, expectedCarSize);
806+
EXPECT_EQ(carEncodedLength, expectedCarEncodedLength);
799807

800-
Car carDecoder(buffer, carSz, Car::sbeBlockLength(), Car::sbeSchemaVersion());
808+
Car carDecoder(buffer, carEncodedLength, Car::sbeBlockLength(), Car::sbeSchemaVersion());
801809

802810
std::string vehicleCode(VEHICLE_CODE, Car::vehicleCodeLength());
803811
std::string usageDesc1(FUEL_FIGURES_1_USAGE_DESCRIPTION, FUEL_FIGURES_1_USAGE_DESCRIPTION_LENGTH);
@@ -837,7 +845,7 @@ TEST_F(CodeGenTest, shouldBeAbleToUseStdStringMethodsForDecode)
837845
EXPECT_EQ(carDecoder.getActivationCodeAsString(), activationCode);
838846
EXPECT_EQ(carDecoder.getColorAsString(), color);
839847

840-
EXPECT_EQ(carDecoder.encodedLength(), expectedCarSize);
848+
EXPECT_EQ(carDecoder.encodedLength(), expectedCarEncodedLength);
841849
}
842850

843851
TEST_F(CodeGenTest, shouldPrintFullDecodedFlyweightRegardlessOfReadPosition)
@@ -861,11 +869,11 @@ TEST_F(CodeGenTest, shouldPrintFullDecodedFlyweightRegardlessOfReadPosition)
861869
memset(buffer, 0, 2048);
862870
Car carEncoder(buffer, sizeof(buffer));
863871

864-
std::uint64_t carSz = encodeCar(carEncoder);
872+
std::uint64_t carEncodedLength = encodeCar(carEncoder);
865873

866-
EXPECT_EQ(carSz, expectedCarSize);
874+
EXPECT_EQ(carEncodedLength, expectedCarEncodedLength);
867875

868-
Car carDecoder(buffer, carSz, Car::sbeBlockLength(), Car::sbeSchemaVersion());
876+
Car carDecoder(buffer, carEncodedLength, Car::sbeBlockLength(), Car::sbeSchemaVersion());
869877

870878
std::string vehicleCode(VEHICLE_CODE, Car::vehicleCodeLength());
871879
std::string usageDesc1(FUEL_FIGURES_1_USAGE_DESCRIPTION, FUEL_FIGURES_1_USAGE_DESCRIPTION_LENGTH);
@@ -916,5 +924,5 @@ TEST_F(CodeGenTest, shouldPrintFullDecodedFlyweightRegardlessOfReadPosition)
916924

917925
expectDisplayString(expectedDisplayString, carDecoder);
918926

919-
EXPECT_EQ(carDecoder.encodedLength(), expectedCarSize);
927+
EXPECT_EQ(carDecoder.encodedLength(), expectedCarEncodedLength);
920928
}

0 commit comments

Comments
 (0)