[scudo][tests] Ensure test assertions have matching type

[ddcc]

Summary

gtest-like testers may use template deduction to select the correct overload, but type promotion is not considered when performing template substitution, so ensure both arguments have matching type

[ddcc]

@vitalybuka ping

[vitalybuka]

compiler-rt/lib/scudo/standalone/tests/combined_test.cpp

142

code looks less readable with unnecessary casts like this

compiler-rt/lib/scudo/standalone/tests/list_test.cpp

96

Are we going to have mismatch 32/64 here?

[ddcc]

Hmmm yeah this is pretty ugly, I'll look into changing the test matcher template instead.

compiler-rt/lib/scudo/standalone/tests/chunk_test.cpp

void *P = reinterpret_cast<void *>(reinterpret_cast<scudo::uptr>(Block) +
                                      HeaderSize);
   scudo::Chunk::storeHeader(Cookie, P, &OldHeader);
   memset(P, 'A', Size);
   scudo::Chunk::UnpackedHeader NewHeader = OldHeader;
   NewHeader.State = scudo::Chunk::State::Quarantined;
   scudo::Chunk::compareExchangeHeader(Cookie, P, &NewHeader, &OldHeader);
   NewHeader = {};
   EXPECT_TRUE(scudo::Chunk::isValid(Cookie, P, &NewHeader));
-  EXPECT_EQ(NewHeader.State, scudo::Chunk::State::Quarantined);
+  EXPECT_EQ(NewHeader.State,
+            static_cast<scudo::u8>(scudo::Chunk::State::Quarantined));
   EXPECT_FALSE(scudo::Chunk::isValid(InvalidCookie, P, &NewHeader));
   free(Block);
 }
 
 TEST(ScudoChunkDeathTest, CorruptHeader) {
   initChecksum();
   const scudo::uptr Size = 0x100U;
   scudo::Chunk::UnpackedHeader Header = {};

compiler-rt/lib/scudo/standalone/tests/combined_test.cpp

SCUDO_TYPED_TEST(ScudoCombinedTest, IsOwned) {
   EXPECT_FALSE(
       Allocator->isOwned(&StaticBuffer[scudo::Chunk::getHeaderSize()]));
 
   scudo::u8 StackBuffer[scudo::Chunk::getHeaderSize() + 1];
   for (scudo::uptr I = 0; I < sizeof(StackBuffer); I++)
     StackBuffer[I] = 0x42U;
   EXPECT_FALSE(Allocator->isOwned(&StackBuffer[scudo::Chunk::getHeaderSize()]));
   for (scudo::uptr I = 0; I < sizeof(StackBuffer); I++)
-    EXPECT_EQ(StackBuffer[I], 0x42U);
+    EXPECT_EQ(StackBuffer[I], static_cast<scudo::u8>(0x42U));
 }
 
 template <class Config>
 void ScudoCombinedTest<Config>::BasicTest(scudo::uptr SizeLog) {
   auto *Allocator = this->Allocator.get();
 
   // This allocates and deallocates a bunch of chunks, with a wide range of
   // sizes and alignments, with a focus on sizes that could trigger weird
SCUDO_TYPED_TEST(ScudoCombinedTest, ZeroContents) {
 
   // Ensure that specifying ZeroContents returns a zero'd out block.
   for (scudo::uptr SizeLog = 0U; SizeLog <= 20U; SizeLog++) {
     for (scudo::uptr Delta = 0U; Delta <= 4U; Delta++) {
       const scudo::uptr Size = (1U << SizeLog) + Delta * 128U;
       void *P = Allocator->allocate(Size, Origin, 1U << MinAlignLog, true);
       EXPECT_NE(P, nullptr);
       for (scudo::uptr I = 0; I < Size; I++)
-        ASSERT_EQ((reinterpret_cast<char *>(P))[I], 0);
+        ASSERT_EQ((reinterpret_cast<char *>(P))[I], static_cast<char>(0));
       memset(P, 0xaa, Size);
       Allocator->deallocate(P, Origin, Size);
     }
   }
 }
 
 SCUDO_TYPED_TEST(ScudoCombinedTest, ZeroFill) {
   auto *Allocator = this->Allocator.get();
 
   // Ensure that specifying ZeroFill returns a zero'd out block.
   Allocator->setFillContents(scudo::ZeroFill);
   for (scudo::uptr SizeLog = 0U; SizeLog <= 20U; SizeLog++) {
     for (scudo::uptr Delta = 0U; Delta <= 4U; Delta++) {
       const scudo::uptr Size = (1U << SizeLog) + Delta * 128U;
       void *P = Allocator->allocate(Size, Origin, 1U << MinAlignLog, false);
       EXPECT_NE(P, nullptr);
       for (scudo::uptr I = 0; I < Size; I++)
-        ASSERT_EQ((reinterpret_cast<char *>(P))[I], 0);
+        ASSERT_EQ((reinterpret_cast<char *>(P))[I], static_cast<char>(0));
       memset(P, 0xaa, Size);
       Allocator->deallocate(P, Origin, Size);
     }
   }
 }
 
 SCUDO_TYPED_TEST(ScudoCombinedTest, PatternOrZeroFill) {
   auto *Allocator = this->Allocator.get();
for (scudo::uptr I = 0; I <= MaxNumberOfChunks; I++) {
       else
         V.push_back(P);
     }
     while (!V.empty()) {
       Allocator->deallocate(V.back(), Origin);
       V.pop_back();
     }
   }
-  EXPECT_EQ(FailedAllocationsCount, 0U);
+  EXPECT_EQ(FailedAllocationsCount, 0UL);
 }
 
 // Ensure that releaseToOS can be called prior to any other allocator
 // operation without issue.
 SCUDO_TYPED_TEST(ScudoCombinedTest, ReleaseToOS) {
   auto *Allocator = this->Allocator.get();
   Allocator->releaseToOS();
 }
for (unsigned I = 0; I != Ptrs.size(); ++I) {
       Ptrs[I] = Allocator->allocate(Size - 8, Origin);
       memset(Ptrs[I], 0xbb, Size - 8);
     }
     for (unsigned I = 0; I != Ptrs.size(); ++I)
       Allocator->deallocate(Ptrs[I], Origin, Size - 8);
     for (unsigned I = 0; I != Ptrs.size(); ++I) {
       Ptrs[I] = Allocator->allocate(Size, Origin, 1U << MinAlignLog, true);
       for (scudo::uptr J = 0; J < Size; ++J)
-        ASSERT_EQ((reinterpret_cast<char *>(Ptrs[I]))[J], 0);
+        ASSERT_EQ((reinterpret_cast<char *>(Ptrs[I]))[J], static_cast<char>(0));
     }
   }
 
   Allocator->setOption(scudo::Option::ThreadDisableMemInit, 0);
 }
 
 SCUDO_TYPED_TEST(ScudoCombinedTest, ReallocateInPlaceStress) {
   auto *Allocator = this->Allocator.get();

compiler-rt/lib/scudo/standalone/tests/common_test.cpp

TEST(ScudoCommonTest, Zeros) {
 
   MapPlatformData Data = {};
   uptr *P = reinterpret_cast<uptr *>(map(nullptr, Size, "Zeros", 0, &Data));
   const ptrdiff_t N = Size / sizeof(*P);
   ASSERT_NE(nullptr, P);
   EXPECT_EQ(std::count(P, P + N, 0), N);
 
   memset(P, 1, Size);
-  EXPECT_EQ(std::count(P, P + N, 0), 0);
+  EXPECT_EQ(std::count(P, P + N, 0), 0L);
 
   releasePagesToOS((uptr)P, 0, Size, &Data);
   EXPECT_EQ(std::count(P, P + N, 0), N);
 
   unmap(P, Size, 0, &Data);
 }
 
 } // namespace scudo

compiler-rt/lib/scudo/standalone/tests/list_test.cpp

static void checkList(ListT *L, ListItem *I1, ListItem *I2 = nullptr,
   }
   EXPECT_TRUE(L->empty());
 }
 
 template <typename ListT> static void testListCommon(void) {
   ListT L;
   L.clear();
 
-  EXPECT_EQ(L.size(), 0U);
+  EXPECT_EQ(L.size(), 0UL);
   L.push_back(X);
-  EXPECT_EQ(L.size(), 1U);
+  EXPECT_EQ(L.size(), 1UL);
   EXPECT_EQ(L.back(), X);
   EXPECT_EQ(L.front(), X);
   L.pop_front();
   EXPECT_TRUE(L.empty());
   L.checkConsistency();
 
   L.push_front(X);
-  EXPECT_EQ(L.size(), 1U);
+  EXPECT_EQ(L.size(), 1UL);
   EXPECT_EQ(L.back(), X);
   EXPECT_EQ(L.front(), X);
   L.pop_front();
   EXPECT_TRUE(L.empty());
   L.checkConsistency();
 
   L.push_front(X);
   L.push_front(Y);
   L.push_front(Z);
-  EXPECT_EQ(L.size(), 3U);
+  EXPECT_EQ(L.size(), 3UL);
   EXPECT_EQ(L.front(), Z);
   EXPECT_EQ(L.back(), X);
   L.checkConsistency();
 
   L.pop_front();
-  EXPECT_EQ(L.size(), 2U);
+  EXPECT_EQ(L.size(), 2UL);
   EXPECT_EQ(L.front(), Y);
   EXPECT_EQ(L.back(), X);
   L.pop_front();
   L.pop_front();
   EXPECT_TRUE(L.empty());
   L.checkConsistency();
 
   L.push_back(X);
   L.push_back(Y);
   L.push_back(Z);
-  EXPECT_EQ(L.size(), 3U);
+  EXPECT_EQ(L.size(), 3UL);
   EXPECT_EQ(L.front(), X);
   EXPECT_EQ(L.back(), Z);
   L.checkConsistency();
 
   L.pop_front();
-  EXPECT_EQ(L.size(), 2U);
+  EXPECT_EQ(L.size(), 2UL);
   EXPECT_EQ(L.front(), Y);
   EXPECT_EQ(L.back(), Z);
   L.pop_front();
   L.pop_front();
   EXPECT_TRUE(L.empty());
   L.checkConsistency();
 }
 
 TEST(ScudoListTest, LinkedListCommon) {
   testListCommon<SLList>();
   testListCommon<DLList>();
 }
 
 TEST(ScudoListTest, SinglyLinkedList) {
   SLList L;
   L.clear();
 
   L.push_back(X);
   L.push_back(Y);
   L.push_back(Z);
   L.extract(X, Y);
-  EXPECT_EQ(L.size(), 2U);
+  EXPECT_EQ(L.size(), 2UL);
   EXPECT_EQ(L.front(), X);
   EXPECT_EQ(L.back(), Z);
   L.checkConsistency();
   L.extract(X, Z);
-  EXPECT_EQ(L.size(), 1U);
+  EXPECT_EQ(L.size(), 1UL);
   EXPECT_EQ(L.front(), X);
   EXPECT_EQ(L.back(), X);
   L.checkConsistency();
   L.pop_front();
   EXPECT_TRUE(L.empty());
 
   SLList L1, L2;
   L1.clear();
TEST(ScudoListTest, SinglyLinkedList) {
   EXPECT_TRUE(L2.empty());
 
   L1.clear();
   L2.clear();
   L1.push_back(X);
   L1.append_back(&L2);
   EXPECT_EQ(L1.back(), X);
   EXPECT_EQ(L1.front(), X);
-  EXPECT_EQ(L1.size(), 1U);
+  EXPECT_EQ(L1.size(), 1UL);
 }
 
 TEST(ScudoListTest, DoublyLinkedList) {
   DLList L;
   L.clear();
 
   L.push_back(X);
   L.push_back(Y);
   L.push_back(Z);
   L.remove(Y);
-  EXPECT_EQ(L.size(), 2U);
+  EXPECT_EQ(L.size(), 2UL);
   EXPECT_EQ(L.front(), X);
   EXPECT_EQ(L.back(), Z);
   L.checkConsistency();
   L.remove(Z);
-  EXPECT_EQ(L.size(), 1U);
+  EXPECT_EQ(L.size(), 1UL);
   EXPECT_EQ(L.front(), X);
   EXPECT_EQ(L.back(), X);
   L.checkConsistency();
   L.pop_front();
   EXPECT_TRUE(L.empty());
 
   L.push_back(X);
   L.insert(Y, X);
-  EXPECT_EQ(L.size(), 2U);
+  EXPECT_EQ(L.size(), 2UL);
   EXPECT_EQ(L.front(), Y);
   EXPECT_EQ(L.back(), X);
   L.checkConsistency();
   L.remove(Y);
-  EXPECT_EQ(L.size(), 1U);
+  EXPECT_EQ(L.size(), 1UL);
   EXPECT_EQ(L.front(), X);
   EXPECT_EQ(L.back(), X);
   L.checkConsistency();
   L.pop_front();
   EXPECT_TRUE(L.empty());
 }

compiler-rt/lib/scudo/standalone/tests/memtag_test.cpp

protected:
   MapPlatformData Data = {};
   u8 *Buffer = nullptr;
   uptr Addr = 0;
 };
 
 using MemtagDeathTest = MemtagTest;
 
 TEST_F(MemtagTest, ArchMemoryTagGranuleSize) {
-  EXPECT_GT(archMemoryTagGranuleSize(), 1u);
+  EXPECT_GT(archMemoryTagGranuleSize(), 1ul);
   EXPECT_TRUE(isPowerOfTwo(archMemoryTagGranuleSize()));
 }
 
 TEST_F(MemtagTest, ExtractTag) {
   uptr Tags = 0;
   // Try all value for the top byte and check the tags values are in the
   // expected range.
   for (u64 Top = 0; Top < 0x100; ++Top)
     Tags = Tags | (1u << extractTag(Addr | (Top << 56)));
-  EXPECT_EQ(0xffffull, Tags);
+  EXPECT_EQ(0xfffful, Tags);
 }
 
 TEST_F(MemtagDeathTest, AddFixedTag) {
-  for (uptr Tag = 0; Tag < 0x10; ++Tag)
+  for (uint8_t Tag = 0; Tag < 0x10; ++Tag)
     EXPECT_EQ(Tag, extractTag(addFixedTag(Addr, Tag)));
   if (SCUDO_DEBUG) {
     EXPECT_DEBUG_DEATH(addFixedTag(Addr, 16), "");
     EXPECT_DEBUG_DEATH(addFixedTag(~Addr, 0), "");
   }
 }
 
 TEST_F(MemtagTest, UntagPointer) {

 }
 
 TEST_F(MemtagTest, SelectRandomTag) {
   for (uptr SrcTag = 0; SrcTag < 0x10; ++SrcTag) {
     uptr Ptr = addFixedTag(Addr, SrcTag);
     uptr Tags = 0;
     for (uptr I = 0; I < 100000; ++I)
       Tags = Tags | (1u << extractTag(selectRandomTag(Ptr, 0)));
-    EXPECT_EQ(0xfffeull, Tags);
+    EXPECT_EQ(0xfffeul, Tags);
   }
 }
 
 TEST_F(MemtagTest, SelectRandomTagWithMask) {
-  for (uptr j = 0; j < 32; ++j) {
+  for (uint8_t j = 0; j < 32; ++j) {
     for (uptr i = 0; i < 1000; ++i)
       EXPECT_NE(j, extractTag(selectRandomTag(Addr, 1ull << j)));
   }
 }
 
 TEST_F(MemtagDeathTest, SKIP_NO_DEBUG(LoadStoreTagUnaligned)) {
   for (uptr P = Addr; P < Addr + 4 * archMemoryTagGranuleSize(); ++P) {
     if (P % archMemoryTagGranuleSize() == 0)

compiler-rt/lib/scudo/standalone/tests/primary_test.cpp

SCUDO_TYPED_TEST(ScudoPrimaryTest, ReleaseToOS) {
   Cache.init(nullptr, Allocator.get());
   const scudo::uptr Size = scudo::getPageSizeCached() * 2;
   EXPECT_TRUE(Primary::canAllocate(Size));
   const scudo::uptr ClassId = Primary::SizeClassMap::getClassIdBySize(Size);
   void *P = Cache.allocate(ClassId);
   EXPECT_NE(P, nullptr);
   Cache.deallocate(ClassId, P);
   Cache.destroy(nullptr);
-  EXPECT_GT(Allocator->releaseToOS(), 0U);
+  EXPECT_GT(Allocator->releaseToOS(), 0UL);
 }

compiler-rt/lib/scudo/standalone/tests/quarantine_test.cpp

TEST(ScudoQuarantineTest, QuarantineBatchMerge) {
   // Verify the trivial case.
   scudo::QuarantineBatch Into;
   Into.init(FakePtr, 4UL);
   scudo::QuarantineBatch From;
   From.init(FakePtr, 8UL);
 
   Into.merge(&From);
 
-  EXPECT_EQ(Into.Count, 2UL);
+  EXPECT_EQ(Into.Count, 2U);
   EXPECT_EQ(Into.Batch[0], FakePtr);
   EXPECT_EQ(Into.Batch[1], FakePtr);
   EXPECT_EQ(Into.Size, 12UL + sizeof(scudo::QuarantineBatch));
   EXPECT_EQ(Into.getQuarantinedSize(), 12UL);
 
-  EXPECT_EQ(From.Count, 0UL);
+  EXPECT_EQ(From.Count, 0U);
   EXPECT_EQ(From.Size, sizeof(scudo::QuarantineBatch));
   EXPECT_EQ(From.getQuarantinedSize(), 0UL);
 
   // Merge the batch to the limit.
   for (scudo::uptr I = 2; I < scudo::QuarantineBatch::MaxCount; ++I)
     From.push_back(FakePtr, 8UL);
   EXPECT_TRUE(Into.Count + From.Count == scudo::QuarantineBatch::MaxCount);
   EXPECT_TRUE(Into.canMerge(&From));

compiler-rt/lib/scudo/standalone/tests/stats_test.cpp

 //===-- stats_test.cpp ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "tests/scudo_unit_test.h"
 
 #include "stats.h"
 
 TEST(ScudoStatsTest, LocalStats) {
   scudo::LocalStats LStats;
   LStats.init();
   for (scudo::uptr I = 0; I < scudo::StatCount; I++)
-    EXPECT_EQ(LStats.get(static_cast<scudo::StatType>(I)), 0U);
+    EXPECT_EQ(LStats.get(static_cast<scudo::StatType>(I)), 0UL);
   LStats.add(scudo::StatAllocated, 4096U);
-  EXPECT_EQ(LStats.get(scudo::StatAllocated), 4096U);
+  EXPECT_EQ(LStats.get(scudo::StatAllocated), 4096UL);
   LStats.sub(scudo::StatAllocated, 4096U);
-  EXPECT_EQ(LStats.get(scudo::StatAllocated), 0U);
+  EXPECT_EQ(LStats.get(scudo::StatAllocated), 0UL);
   LStats.set(scudo::StatAllocated, 4096U);
-  EXPECT_EQ(LStats.get(scudo::StatAllocated), 4096U);
+  EXPECT_EQ(LStats.get(scudo::StatAllocated), 4096UL);
 }
 
 TEST(ScudoStatsTest, GlobalStats) {
   scudo::GlobalStats GStats;
   GStats.init();
   scudo::uptr Counters[scudo::StatCount] = {};
   GStats.get(Counters);
   for (scudo::uptr I = 0; I < scudo::StatCount; I++)
-    EXPECT_EQ(Counters[I], 0U);
+    EXPECT_EQ(Counters[I], 0UL);
   scudo::LocalStats LStats;
   LStats.init();
   GStats.link(&LStats);
   for (scudo::uptr I = 0; I < scudo::StatCount; I++)
-    LStats.add(static_cast<scudo::StatType>(I), 4096U);
+    LStats.add(static_cast<scudo::StatType>(I), 4096UL);
   GStats.get(Counters);
   for (scudo::uptr I = 0; I < scudo::StatCount; I++)
-    EXPECT_EQ(Counters[I], 4096U);
+    EXPECT_EQ(Counters[I], 4096UL);
   // Unlinking the local stats move numbers to the global stats.
   GStats.unlink(&LStats);
   GStats.get(Counters);
   for (scudo::uptr I = 0; I < scudo::StatCount; I++)
-    EXPECT_EQ(Counters[I], 4096U);
+    EXPECT_EQ(Counters[I], 4096UL);
 }

compiler-rt/lib/scudo/standalone/tests/tsd_test.cpp

for (scudo::uptr I = 0; I < ARRAY_SIZE(Threads); I++)
     std::unique_lock<std::mutex> Lock(Mutex);
     Ready = true;
     Cv.notify_all();
   }
   for (auto &T : Threads)
     T.join();
   // The initial number of TSDs we get will be the minimum of the default count
   // and the number of CPUs.
-  EXPECT_LE(Pointers.size(), 8U);
+  EXPECT_LE(Pointers.size(), 8UL);
   Pointers.clear();
   auto Registry = Allocator->getTSDRegistry();
   // Increase the number of TSDs to 16.
   Registry->setOption(scudo::Option::MaxTSDsCount, 16);
   Ready = false;
   for (scudo::uptr I = 0; I < ARRAY_SIZE(Threads); I++)
     Threads[I] = std::thread(stressSharedRegistry, Allocator.get());
   {
     std::unique_lock<std::mutex> Lock(Mutex);
     Ready = true;
     Cv.notify_all();
   }
   for (auto &T : Threads)
     T.join();
   // We should get 16 distinct TSDs back.
-  EXPECT_EQ(Pointers.size(), 16U);
+  EXPECT_EQ(Pointers.size(), 16UL);
 }

compiler-rt/lib/scudo/standalone/tests/vector_test.cpp

 //===-- vector_test.cpp -----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "tests/scudo_unit_test.h"
 
 #include "vector.h"
 
 TEST(ScudoVectorTest, Basic) {
   scudo::Vector<int> V;
-  EXPECT_EQ(V.size(), 0U);
+  EXPECT_EQ(V.size(), 0UL);
   V.push_back(42);
-  EXPECT_EQ(V.size(), 1U);
+  EXPECT_EQ(V.size(), 1UL);
   EXPECT_EQ(V[0], 42);
   V.push_back(43);
-  EXPECT_EQ(V.size(), 2U);
+  EXPECT_EQ(V.size(), 2UL);
   EXPECT_EQ(V[0], 42);
   EXPECT_EQ(V[1], 43);
 }
 
 TEST(ScudoVectorTest, Stride) {
   scudo::Vector<scudo::uptr> V;
   for (scudo::uptr I = 0; I < 1000; I++) {
     V.push_back(I);
-    EXPECT_EQ(V.size(), I + 1U);
+    EXPECT_EQ(V.size(), I + 1UL);
     EXPECT_EQ(V[I], I);
   }
   for (scudo::uptr I = 0; I < 1000; I++)
     EXPECT_EQ(V[I], I);
 }
 
 TEST(ScudoVectorTest, ResizeReduction) {
   scudo::Vector<int> V;
   V.push_back(0);
   V.push_back(0);
-  EXPECT_EQ(V.size(), 2U);
+  EXPECT_EQ(V.size(), 2UL);
   V.resize(1);
-  EXPECT_EQ(V.size(), 1U);
+  EXPECT_EQ(V.size(), 1UL);
 }

compiler-rt/lib/scudo/standalone/tests/wrappers_c_test.cpp

 // freed (this depends on the size obviously) and the following free succeeds.
 
 static const size_t Size = 100U;
 
 TEST(ScudoWrappersCDeathTest, Malloc) {
   void *P = malloc(Size);
   EXPECT_NE(P, nullptr);
   EXPECT_LE(Size, malloc_usable_size(P));
-  EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % FIRST_32_SECOND_64(8U, 16U), 0U);
+  EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % FIRST_32_SECOND_64(8U, 16U), 0UL);
 
   // An update to this warning in Clang now triggers in this line, but it's ok
   // because the check is expecting a bad pointer and should fail.
 #if defined(__has_warning) && __has_warning("-Wfree-nonheap-object")
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfree-nonheap-object"
 #endif
   EXPECT_DEATH(
#endif
   EXPECT_EQ(errno, ENOMEM);
 }
 
 TEST(ScudoWrappersCTest, Calloc) {
   void *P = calloc(1U, Size);
   EXPECT_NE(P, nullptr);
   EXPECT_LE(Size, malloc_usable_size(P));
   for (size_t I = 0; I < Size; I++)
-    EXPECT_EQ((reinterpret_cast<uint8_t *>(P))[I], 0U);
+    EXPECT_EQ((reinterpret_cast<uint8_t *>(P))[I], static_cast<uint8_t>(0U));
   free(P);
 
   P = calloc(1U, 0U);
   EXPECT_NE(P, nullptr);
   free(P);
   P = calloc(0U, 1U);
   EXPECT_NE(P, nullptr);
   free(P);

 TEST(ScudoWrappersCTest, Memalign) {
   void *P;
   for (size_t I = FIRST_32_SECOND_64(2U, 3U); I <= 18U; I++) {
     const size_t Alignment = 1U << I;
 
     P = memalign(Alignment, Size);
     EXPECT_NE(P, nullptr);
     EXPECT_LE(Size, malloc_usable_size(P));
-    EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % Alignment, 0U);
+    EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % Alignment, 0UL);
     free(P);
 
     P = nullptr;
     EXPECT_EQ(posix_memalign(&P, Alignment, Size), 0);
     EXPECT_NE(P, nullptr);
     EXPECT_LE(Size, malloc_usable_size(P));
-    EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % Alignment, 0U);
+    EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % Alignment, 0UL);
     free(P);
   }
 
   EXPECT_EQ(memalign(4096U, SIZE_MAX), nullptr);
   EXPECT_EQ(posix_memalign(&P, 15U, Size), EINVAL);
   EXPECT_EQ(posix_memalign(&P, 4096U, SIZE_MAX), ENOMEM);
 
   // Android's memalign accepts non power-of-2 alignments, and 0.
   if (SCUDO_ANDROID) {
     for (size_t Alignment = 0U; Alignment <= 128U; Alignment++) {
       P = memalign(Alignment, 1024U);
       EXPECT_NE(P, nullptr);
       free(P);
     }
   }
 }
 
 TEST(ScudoWrappersCTest, AlignedAlloc) {
   const size_t Alignment = 4096U;
   void *P = aligned_alloc(Alignment, Alignment * 4U);
   EXPECT_NE(P, nullptr);
   EXPECT_LE(Alignment * 4U, malloc_usable_size(P));
-  EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % Alignment, 0U);
+  EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % Alignment, 0UL);
   free(P);
 
   errno = 0;
   P = aligned_alloc(Alignment, Size);
   EXPECT_EQ(P, nullptr);
   EXPECT_EQ(errno, EINVAL);
 }
 
TEST(ScudoWrappersCDeathTest, Realloc) {
   EXPECT_NE(P, nullptr);
   EXPECT_LE(Size, malloc_usable_size(P));
   memset(P, 0x42, Size);
 
   P = realloc(P, Size * 2U);
   EXPECT_NE(P, nullptr);
   EXPECT_LE(Size * 2U, malloc_usable_size(P));
   for (size_t I = 0; I < Size; I++)
-    EXPECT_EQ(0x42, (reinterpret_cast<uint8_t *>(P))[I]);
+    EXPECT_EQ(static_cast<uint8_t>(0x42U), (reinterpret_cast<uint8_t *>(P))[I]);
 
   P = realloc(P, Size / 2U);
   EXPECT_NE(P, nullptr);
   EXPECT_LE(Size / 2U, malloc_usable_size(P));
   for (size_t I = 0; I < Size / 2U; I++)
-    EXPECT_EQ(0x42, (reinterpret_cast<uint8_t *>(P))[I]);
+    EXPECT_EQ(static_cast<uint8_t>(0x42U), (reinterpret_cast<uint8_t *>(P))[I]);
   free(P);
 
   EXPECT_DEATH(P = realloc(P, Size), "");
 
   errno = 0;
   EXPECT_EQ(realloc(nullptr, SIZE_MAX), nullptr);
   EXPECT_EQ(errno, ENOMEM);
   P = malloc(Size);
   EXPECT_NE(P, nullptr);
   errno = 0;
   EXPECT_EQ(realloc(P, SIZE_MAX), nullptr);
   EXPECT_EQ(errno, ENOMEM);
   free(P);
 
   // Android allows realloc of memalign pointers.
   if (SCUDO_ANDROID) {
     const size_t Alignment = 1024U;
     P = memalign(Alignment, Size);
     EXPECT_NE(P, nullptr);
     EXPECT_LE(Size, malloc_usable_size(P));
-    EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % Alignment, 0U);
+    EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % Alignment, 0UL);
     memset(P, 0x42, Size);
 
     P = realloc(P, Size * 2U);
     EXPECT_NE(P, nullptr);
     EXPECT_LE(Size * 2U, malloc_usable_size(P));
     for (size_t I = 0; I < Size; I++)
-      EXPECT_EQ(0x42, (reinterpret_cast<uint8_t *>(P))[I]);
+      EXPECT_EQ(static_cast<uint8_t>(0x42U), (reinterpret_cast<uint8_t *>(P))[I]);
     free(P);
   }
 }
 
 #if !SCUDO_FUCHSIA
 TEST(ScudoWrappersCTest, MallOpt) {
   errno = 0;
   EXPECT_EQ(mallopt(-1000, 1), 0);

 #endif
 
 TEST(ScudoWrappersCTest, OtherAlloc) {
 #if !SCUDO_FUCHSIA
   const size_t PageSize = sysconf(_SC_PAGESIZE);
 
   void *P = pvalloc(Size);
   EXPECT_NE(P, nullptr);
-  EXPECT_EQ(reinterpret_cast<uintptr_t>(P) & (PageSize - 1), 0U);
+  EXPECT_EQ(reinterpret_cast<uintptr_t>(P) & (PageSize - 1), 0UL);
   EXPECT_LE(PageSize, malloc_usable_size(P));
   free(P);
 
   EXPECT_EQ(pvalloc(SIZE_MAX), nullptr);
 
   P = pvalloc(Size);
   EXPECT_NE(P, nullptr);
-  EXPECT_EQ(reinterpret_cast<uintptr_t>(P) & (PageSize - 1), 0U);
+  EXPECT_EQ(reinterpret_cast<uintptr_t>(P) & (PageSize - 1), 0UL);
   free(P);
 #endif
 
   EXPECT_EQ(valloc(SIZE_MAX), nullptr);
 }
 
 #if !SCUDO_FUCHSIA
 TEST(ScudoWrappersCTest, MallInfo) {