Skip to content

Commit b62af18

Browse files
hjmjohnsonhjmjohnson
authored
Merge pull request InsightSoftwareConsortium#6690 from hjmjohnson/itk-test-gtest-warning-cleanup
COMP: Fix GCC -Wextra warnings in GoogleTest test code (sign-compare, maybe-uninitialized)
2 parents 6d4f041 + 8d379ba commit b62af18

29 files changed

Lines changed: 108 additions & 106 deletions

‎Modules/Core/Common/test/itkAggregateTypesGTest.cxx‎

Lines changed: 10 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -134,11 +134,11 @@ class CommonTests
134134
const AggregateType knownAll6s{ { 6, 6, 6, 6 } };
135135

136136
EXPECT_EQ((std::is_standard_layout_v<AggregateType> && std::is_trivial_v<AggregateType>), true);
137-
EXPECT_EQ(AggregateType::Dimension, 4);
137+
EXPECT_EQ(AggregateType::Dimension, 4u);
138138

139139
AggregateType index1 = { { 10, 20, 30, 40 } };
140-
EXPECT_EQ(index1.size(), 4);
141-
EXPECT_EQ(index1.max_size(), 4);
140+
EXPECT_EQ(index1.size(), 4u);
141+
EXPECT_EQ(index1.max_size(), 4u);
142142
EXPECT_EQ(index1.empty(), false);
143143

144144
for (auto i : { 0, 1, 2, 3 })
@@ -167,9 +167,10 @@ class CommonTests
167167
index2.back() = 6; // Non const ref
168168
ITK_EXPECT_VECTOR_NEAR(index2, knownAll6s, 0);
169169
index2.Fill(7);
170-
EXPECT_EQ(index2.back(), 7);
171-
EXPECT_EQ(index2.back(), 7);
172-
EXPECT_EQ(index2.data()[3], 7); // Test const data access
170+
using ValueType = typename AggregateType::value_type;
171+
EXPECT_EQ(index2.back(), ValueType{ 7 });
172+
EXPECT_EQ(index2.back(), ValueType{ 7 });
173+
EXPECT_EQ(index2.data()[3], ValueType{ 7 }); // Test const data access
173174

174175
index2.swap(index1);
175176
ITK_EXPECT_VECTOR_NEAR(index1, knownAll7s, 0);
@@ -325,7 +326,7 @@ TEST(Specialized, IndexOffset)
325326
TEST(Specialized, Index)
326327
{
327328
EXPECT_EQ((std::is_standard_layout_v<itk::Index<13>> && std::is_trivial_v<itk::Index<13>>), true);
328-
EXPECT_EQ(itk::Index<2>::GetIndexDimension(), 2);
329+
EXPECT_EQ(itk::Index<2>::GetIndexDimension(), 2u);
329330

330331
using IndexType = itk::Index<4>;
331332

@@ -349,7 +350,7 @@ TEST(Specialized, Offset)
349350
{
350351

351352
EXPECT_EQ((std::is_standard_layout_v<itk::Offset<13>> && std::is_trivial_v<itk::Offset<13>>), true);
352-
EXPECT_EQ(itk::Offset<13>::GetOffsetDimension(), 13);
353+
EXPECT_EQ(itk::Offset<13>::GetOffsetDimension(), 13u);
353354

354355
using OffsetType = itk::Offset<4>;
355356

@@ -372,7 +373,7 @@ TEST(Specialized, Offset)
372373
TEST(Specialized, Size)
373374
{
374375
EXPECT_EQ((std::is_standard_layout_v<itk::Size<13>> && std::is_trivial_v<itk::Size<13>>), true);
375-
EXPECT_EQ(itk::Size<7>::GetSizeDimension(), 7);
376+
EXPECT_EQ(itk::Size<7>::GetSizeDimension(), 7u);
376377

377378
using SizeType = itk::Size<4>;
378379
constexpr SizeType known3s{ 3, 3, 3, 3 };

‎Modules/Core/Common/test/itkFixedArrayGTest.cxx‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -330,7 +330,7 @@ TEST(FixedArray, StdMemberFunctionsWork)
330330
d3arr[1] = 2;
331331
d3arr[2] = 3;
332332
// size
333-
EXPECT_EQ(d3arr.size(), 3);
333+
EXPECT_EQ(d3arr.size(), 3u);
334334
// const and non-const data
335335
const auto cdata = d3arr.data();
336336
EXPECT_EQ(cdata[0], 1);

‎Modules/Core/Common/test/itkMakeUniqueForOverwriteGTest.cxx‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -37,7 +37,7 @@ TEST(MakeUniqueForOverwrite, CreatesAnArrayThatCanBeWrittenTo)
3737
// Check that each value is correctly written to the corresponding element.
3838
for (std::size_t i = 0; i < numberOfElements; ++i)
3939
{
40-
EXPECT_EQ(data[i], i);
40+
EXPECT_EQ(data[i], static_cast<int>(i));
4141
}
4242
}
4343
}

‎Modules/Core/Common/test/itkMathGTest.cxx‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -352,7 +352,7 @@ TEST(itkMath, Abs)
352352
EXPECT_EQ(itk::Math::Absolute<long long>(-5LL), 5ull);
353353
EXPECT_EQ(itk::Math::Absolute<double>(-5.0), 5.0);
354354
EXPECT_EQ(itk::Math::Absolute<float>(-5.0f), 5.0f);
355-
EXPECT_EQ(itk::Math::Absolute(-5), 5);
355+
EXPECT_EQ(itk::Math::Absolute(-5), 5u);
356356

357357
// Check using the minimum possible value of signed integer types as argument:
358358
{

‎Modules/Core/Common/test/itkNeighborhoodAllocatorGTest.cxx‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -101,15 +101,15 @@ TEST(NeighborhoodAllocator, DeallocateSetsSizeToZero)
101101

102102
neighborhoodAllocator.set_size(i);
103103
neighborhoodAllocator.Deallocate();
104-
EXPECT_EQ(neighborhoodAllocator.size(), 0);
104+
EXPECT_EQ(neighborhoodAllocator.size(), 0u);
105105
}
106106
}
107107

108108

109109
// Tests that neighborhoodAllocator.Allocate(i) constructs the specified number of objects.
110110
TEST(NeighborhoodAllocator, AllocateConstructsTheSpecifiedNumberOfObjects)
111111
{
112-
ASSERT_EQ(ObjectCounter::GetCount(), 0);
112+
ASSERT_EQ(ObjectCounter::GetCount(), 0u);
113113

114114
for (unsigned int i{}; i <= 3; ++i)
115115
{
@@ -125,7 +125,7 @@ TEST(NeighborhoodAllocator, AllocateConstructsTheSpecifiedNumberOfObjects)
125125
// Tests that neighborhoodAllocator.Deallocate() destructs all objects that were there.
126126
TEST(NeighborhoodAllocator, DeallocateDestructsAllObjects)
127127
{
128-
ASSERT_EQ(ObjectCounter::GetCount(), 0);
128+
ASSERT_EQ(ObjectCounter::GetCount(), 0u);
129129

130130
for (unsigned int i{}; i <= 3; ++i)
131131
{
@@ -136,6 +136,6 @@ TEST(NeighborhoodAllocator, DeallocateDestructsAllObjects)
136136
neighborhoodAllocator.Deallocate();
137137

138138
// Expect that there are zero objects left, after Deallocate():
139-
EXPECT_EQ(ObjectCounter::GetCount(), 0);
139+
EXPECT_EQ(ObjectCounter::GetCount(), 0u);
140140
}
141141
}

‎Modules/Core/Common/test/itkOptimizerParametersGTest.cxx‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -32,14 +32,15 @@ TEST(OptimizerParameters, ConstructWithSpecifiedSizeAndInitialValue)
3232

3333
for (double initialValue{ -1.0 }; initialValue <= 1.0; ++initialValue)
3434
{
35-
EXPECT_EQ(OptimizerParametersType(0, initialValue).size(), 0);
35+
EXPECT_EQ(OptimizerParametersType(0, initialValue).size(), 0u);
3636

3737
for (size_t size{ 1 }; size <= 4; ++size)
3838
{
3939
const OptimizerParametersType optimizerParameters(size, initialValue);
4040

4141
EXPECT_EQ(optimizerParameters.size(), size);
42-
EXPECT_EQ(std::count(optimizerParameters.begin(), optimizerParameters.end(), initialValue), size);
42+
EXPECT_EQ(static_cast<size_t>(std::count(optimizerParameters.begin(), optimizerParameters.end(), initialValue)),
43+
size);
4344
}
4445
}
4546
}

‎Modules/Core/Common/test/itkRangeGTestUtilities.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -55,7 +55,7 @@ class RangeGTestUtilities
5555
ExpectZeroSizeWhenRangeIsDefaultConstructed()
5656
{
5757
TRange defaultConstructedRange;
58-
EXPECT_EQ(defaultConstructedRange.size(), 0);
58+
EXPECT_EQ(defaultConstructedRange.size(), 0u);
5959
}
6060

6161

‎Modules/Core/Common/test/itkShapedImageNeighborhoodRangeGTest.cxx‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -957,7 +957,7 @@ TEST(ShapedImageNeighborhoodRange, ConstructorSupportsRValueShapeOffsets)
957957
// Note that the expression 'std::vector<OffsetType>{1}' is an rvalue.
958958
// The code is carefully written so that this rvalue remains alive while
959959
// the range 'RangeType{...}' is being used.
960-
ASSERT_EQ((RangeType{ *image, location, std::vector<OffsetType>{ 1 } }).size(), 1);
960+
ASSERT_EQ((RangeType{ *image, location, std::vector<OffsetType>{ 1 } }).size(), 1u);
961961
}
962962

963963

‎Modules/Core/Common/test/itkSmartPointerGTest.cxx‎

Lines changed: 31 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -220,135 +220,135 @@ TEST(SmartPointer, ConvertingRegisterCount)
220220
// Copy constructor to const
221221
{
222222
const Derived1Pointer d1ptr = Derived1::New();
223-
EXPECT_EQ(1, d1ptr->GetRegisterCount());
223+
EXPECT_EQ(1u, d1ptr->GetRegisterCount());
224224

225225
const ConstDerived1Pointer cd1ptr = d1ptr;
226-
EXPECT_EQ(2, d1ptr->GetRegisterCount());
227-
EXPECT_EQ(2, cd1ptr->GetRegisterCount());
226+
EXPECT_EQ(2u, d1ptr->GetRegisterCount());
227+
EXPECT_EQ(2u, cd1ptr->GetRegisterCount());
228228
}
229229

230230
// Copy constructor to base
231231
{
232232
const Derived1Pointer d1ptr = Derived1::New();
233-
EXPECT_EQ(1, d1ptr->GetRegisterCount());
233+
EXPECT_EQ(1u, d1ptr->GetRegisterCount());
234234

235235
const BasePointer bptr = d1ptr;
236-
EXPECT_EQ(2, d1ptr->GetRegisterCount());
237-
EXPECT_EQ(2, static_cast<const Derived1 *>(bptr.GetPointer())->GetRegisterCount());
236+
EXPECT_EQ(2u, d1ptr->GetRegisterCount());
237+
EXPECT_EQ(2u, static_cast<const Derived1 *>(bptr.GetPointer())->GetRegisterCount());
238238
}
239239

240240
// Assignment operator
241241
{
242242
const Derived1Pointer d1ptr = Derived1::New();
243-
EXPECT_EQ(1, d1ptr->GetRegisterCount());
243+
EXPECT_EQ(1u, d1ptr->GetRegisterCount());
244244

245245
const Derived1Pointer d1ptr2 = d1ptr;
246246

247-
EXPECT_EQ(2, d1ptr->GetRegisterCount());
248-
EXPECT_EQ(2, d1ptr2->GetRegisterCount());
247+
EXPECT_EQ(2u, d1ptr->GetRegisterCount());
248+
EXPECT_EQ(2u, d1ptr2->GetRegisterCount());
249249
}
250250

251251
// Assignment to const pointer
252252
{
253253
const Derived1Pointer d1ptr = Derived1::New();
254-
EXPECT_EQ(1, d1ptr->GetRegisterCount());
254+
EXPECT_EQ(1u, d1ptr->GetRegisterCount());
255255

256256
const ConstDerived1Pointer cd1ptr = d1ptr;
257257

258-
EXPECT_EQ(2, d1ptr->GetRegisterCount());
259-
EXPECT_EQ(2, cd1ptr->GetRegisterCount());
258+
EXPECT_EQ(2u, d1ptr->GetRegisterCount());
259+
EXPECT_EQ(2u, cd1ptr->GetRegisterCount());
260260
}
261261

262262
// Assignment to base pointer
263263
{
264264
const Derived1Pointer d1ptr = Derived1::New();
265-
EXPECT_EQ(1, d1ptr->GetRegisterCount());
265+
EXPECT_EQ(1u, d1ptr->GetRegisterCount());
266266

267267
const BasePointer bptr = d1ptr;
268268

269-
EXPECT_EQ(2, d1ptr->GetRegisterCount());
270-
EXPECT_EQ(2, static_cast<const Derived1 *>(bptr.GetPointer())->GetRegisterCount());
269+
EXPECT_EQ(2u, d1ptr->GetRegisterCount());
270+
EXPECT_EQ(2u, static_cast<const Derived1 *>(bptr.GetPointer())->GetRegisterCount());
271271
}
272272

273273
// Assignment to raw pointer
274274
{
275275
const Derived1Pointer d1ptr = Derived1::New();
276-
EXPECT_EQ(1, d1ptr->GetRegisterCount());
276+
EXPECT_EQ(1u, d1ptr->GetRegisterCount());
277277

278278
Derived1 * rptr = d1ptr;
279-
EXPECT_EQ(1, d1ptr->GetRegisterCount());
279+
EXPECT_EQ(1u, d1ptr->GetRegisterCount());
280280
EXPECT_TRUE(rptr != nullptr);
281281
}
282282

283283
// Assignment to raw const pointer
284284
{
285285
const Derived1Pointer d1ptr = Derived1::New();
286-
EXPECT_EQ(1, d1ptr->GetRegisterCount());
286+
EXPECT_EQ(1u, d1ptr->GetRegisterCount());
287287

288288
const Derived1 * rptr = d1ptr;
289-
EXPECT_EQ(1, d1ptr->GetRegisterCount());
289+
EXPECT_EQ(1u, d1ptr->GetRegisterCount());
290290
EXPECT_TRUE(rptr != nullptr);
291291
}
292292

293293
// Move constructor
294294
{
295295
Derived1Pointer d1ptr = Derived1::New();
296-
EXPECT_EQ(1, d1ptr->GetRegisterCount());
296+
EXPECT_EQ(1u, d1ptr->GetRegisterCount());
297297

298298
const Derived1Pointer d1ptr2(std::move(d1ptr));
299-
EXPECT_EQ(1, d1ptr2->GetRegisterCount());
299+
EXPECT_EQ(1u, d1ptr2->GetRegisterCount());
300300
EXPECT_TRUE(d1ptr.IsNull());
301301
}
302302

303303
// Move constructor to const
304304
{
305305
Derived1Pointer d1ptr = Derived1::New();
306-
EXPECT_EQ(1, d1ptr->GetRegisterCount());
306+
EXPECT_EQ(1u, d1ptr->GetRegisterCount());
307307

308308
const ConstDerived1Pointer cd1ptr(std::move(d1ptr));
309-
EXPECT_EQ(1, cd1ptr->GetRegisterCount());
309+
EXPECT_EQ(1u, cd1ptr->GetRegisterCount());
310310
EXPECT_TRUE(d1ptr.IsNull());
311311
}
312312

313313
// Move constructor to base
314314
{
315315
Derived1Pointer d1ptr = Derived1::New();
316-
EXPECT_EQ(1, d1ptr->GetRegisterCount());
316+
EXPECT_EQ(1u, d1ptr->GetRegisterCount());
317317

318318
const BasePointer bptr(std::move(d1ptr));
319-
EXPECT_EQ(1, static_cast<const Derived1 *>(bptr.GetPointer())->GetRegisterCount());
319+
EXPECT_EQ(1u, static_cast<const Derived1 *>(bptr.GetPointer())->GetRegisterCount());
320320
EXPECT_TRUE(d1ptr.IsNull());
321321
}
322322

323323
// Move assignment
324324
{
325325
Derived1Pointer d1ptr = Derived1::New();
326-
EXPECT_EQ(1, d1ptr->GetRegisterCount());
326+
EXPECT_EQ(1u, d1ptr->GetRegisterCount());
327327

328328
const Derived1Pointer d1ptr2 = std::move(d1ptr);
329-
EXPECT_EQ(1, d1ptr2->GetRegisterCount());
329+
EXPECT_EQ(1u, d1ptr2->GetRegisterCount());
330330
EXPECT_TRUE(d1ptr.IsNull());
331331
}
332332

333333
// Move assignment to const
334334
{
335335
Derived1Pointer d1ptr = Derived1::New();
336-
EXPECT_EQ(1, d1ptr->GetRegisterCount());
336+
EXPECT_EQ(1u, d1ptr->GetRegisterCount());
337337

338338
const ConstDerived1Pointer cd1ptr = std::move(d1ptr);
339339

340-
EXPECT_EQ(1, cd1ptr->GetRegisterCount());
340+
EXPECT_EQ(1u, cd1ptr->GetRegisterCount());
341341
EXPECT_TRUE(d1ptr.IsNull());
342342
}
343343

344344
// Move assignment to base
345345
{
346346
Derived1Pointer d1ptr = Derived1::New();
347-
EXPECT_EQ(1, d1ptr->GetRegisterCount());
347+
EXPECT_EQ(1u, d1ptr->GetRegisterCount());
348348

349349
const BasePointer bptr = std::move(d1ptr);
350350

351-
EXPECT_EQ(1, static_cast<const Derived1 *>(bptr.GetPointer())->GetRegisterCount());
351+
EXPECT_EQ(1u, static_cast<const Derived1 *>(bptr.GetPointer())->GetRegisterCount());
352352
EXPECT_TRUE(d1ptr.IsNull());
353353
}
354354
}

‎Modules/Core/Common/test/itkVnlSVDEngineGTest.cxx‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -148,7 +148,7 @@ TEST(VnlSVDEngine, RankAndNullspace)
148148

149149
EXPECT_NEAR((svd.recompose() - P).fro_norm(), 0.0, 1e-12);
150150
EXPECT_EQ(svd.singularities(), 2);
151-
EXPECT_EQ(svd.rank(), 2);
151+
EXPECT_EQ(svd.rank(), 2u);
152152

153153
const vnl_matrix<double> nullSpace = svd.nullspace();
154154
EXPECT_EQ(nullSpace.columns(), 2u);

0 commit comments

Comments
 (0)