diff --git a/tests/malloc_test.cpp b/tests/malloc_test.cpp
index ddd78b0..4161c90 100644
--- a/tests/malloc_test.cpp
+++ b/tests/malloc_test.cpp
@@ -29,14 +29,14 @@
 TEST(malloc, malloc_std) {
   // Simple malloc test.
   void *ptr = malloc(100);
-  ASSERT_TRUE(ptr != NULL);
+  ASSERT_TRUE(ptr != nullptr);
   ASSERT_LE(100U, malloc_usable_size(ptr));
   free(ptr);
 }
 
 TEST(malloc, malloc_overflow) {
   errno = 0;
-  ASSERT_EQ(NULL, malloc(SIZE_MAX));
+  ASSERT_EQ(nullptr, malloc(SIZE_MAX));
   ASSERT_EQ(ENOMEM, errno);
 }
 
@@ -44,7 +44,7 @@
   // Simple calloc test.
   size_t alloc_len = 100;
   char *ptr = (char *)calloc(1, alloc_len);
-  ASSERT_TRUE(ptr != NULL);
+  ASSERT_TRUE(ptr != nullptr);
   ASSERT_LE(alloc_len, malloc_usable_size(ptr));
   for (size_t i = 0; i < alloc_len; i++) {
     ASSERT_EQ(0, ptr[i]);
@@ -54,22 +54,22 @@
 
 TEST(malloc, calloc_illegal) {
   errno = 0;
-  ASSERT_EQ(NULL, calloc(-1, 100));
+  ASSERT_EQ(nullptr, calloc(-1, 100));
   ASSERT_EQ(ENOMEM, errno);
 }
 
 TEST(malloc, calloc_overflow) {
   errno = 0;
-  ASSERT_EQ(NULL, calloc(1, SIZE_MAX));
+  ASSERT_EQ(nullptr, calloc(1, SIZE_MAX));
   ASSERT_EQ(ENOMEM, errno);
   errno = 0;
-  ASSERT_EQ(NULL, calloc(SIZE_MAX, SIZE_MAX));
+  ASSERT_EQ(nullptr, calloc(SIZE_MAX, SIZE_MAX));
   ASSERT_EQ(ENOMEM, errno);
   errno = 0;
-  ASSERT_EQ(NULL, calloc(2, SIZE_MAX));
+  ASSERT_EQ(nullptr, calloc(2, SIZE_MAX));
   ASSERT_EQ(ENOMEM, errno);
   errno = 0;
-  ASSERT_EQ(NULL, calloc(SIZE_MAX, 2));
+  ASSERT_EQ(nullptr, calloc(SIZE_MAX, 2));
   ASSERT_EQ(ENOMEM, errno);
 }
 
@@ -78,7 +78,7 @@
   for (size_t i = 0; i <= 12; i++) {
     for (size_t alignment = 1 << i; alignment < (1U << (i+1)); alignment++) {
       char *ptr = reinterpret_cast<char*>(memalign(alignment, 100));
-      ASSERT_TRUE(ptr != NULL) << "Failed at alignment " << alignment;
+      ASSERT_TRUE(ptr != nullptr) << "Failed at alignment " << alignment;
       ASSERT_LE(100U, malloc_usable_size(ptr)) << "Failed at alignment " << alignment;
       ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(ptr) % ((1U << i)))
           << "Failed at alignment " << alignment;
@@ -88,14 +88,14 @@
 }
 
 TEST(malloc, memalign_overflow) {
-  ASSERT_EQ(NULL, memalign(4096, SIZE_MAX));
+  ASSERT_EQ(nullptr, memalign(4096, SIZE_MAX));
 }
 
 TEST(malloc, memalign_non_power2) {
   void* ptr;
   for (size_t align = 0; align <= 256; align++) {
     ptr = memalign(align, 1024);
-    ASSERT_TRUE(ptr != NULL) << "Failed at align " << align;
+    ASSERT_TRUE(ptr != nullptr) << "Failed at align " << align;
     free(ptr);
   }
 }
@@ -104,22 +104,22 @@
   // Memalign and then realloc the pointer a couple of times.
   for (size_t alignment = 1; alignment <= 4096; alignment <<= 1) {
     char *ptr = (char*)memalign(alignment, 100);
-    ASSERT_TRUE(ptr != NULL);
+    ASSERT_TRUE(ptr != nullptr);
     ASSERT_LE(100U, malloc_usable_size(ptr));
     ASSERT_EQ(0U, (intptr_t)ptr % alignment);
     memset(ptr, 0x23, 100);
 
     ptr = (char*)realloc(ptr, 200);
-    ASSERT_TRUE(ptr != NULL);
+    ASSERT_TRUE(ptr != nullptr);
     ASSERT_LE(200U, malloc_usable_size(ptr));
-    ASSERT_TRUE(ptr != NULL);
+    ASSERT_TRUE(ptr != nullptr);
     for (size_t i = 0; i < 100; i++) {
       ASSERT_EQ(0x23, ptr[i]);
     }
     memset(ptr, 0x45, 200);
 
     ptr = (char*)realloc(ptr, 300);
-    ASSERT_TRUE(ptr != NULL);
+    ASSERT_TRUE(ptr != nullptr);
     ASSERT_LE(300U, malloc_usable_size(ptr));
     for (size_t i = 0; i < 200; i++) {
       ASSERT_EQ(0x45, ptr[i]);
@@ -127,7 +127,7 @@
     memset(ptr, 0x67, 300);
 
     ptr = (char*)realloc(ptr, 250);
-    ASSERT_TRUE(ptr != NULL);
+    ASSERT_TRUE(ptr != nullptr);
     ASSERT_LE(250U, malloc_usable_size(ptr));
     for (size_t i = 0; i < 250; i++) {
       ASSERT_EQ(0x67, ptr[i]);
@@ -139,12 +139,12 @@
 TEST(malloc, malloc_realloc_larger) {
   // Realloc to a larger size, malloc is used for the original allocation.
   char *ptr = (char *)malloc(100);
-  ASSERT_TRUE(ptr != NULL);
+  ASSERT_TRUE(ptr != nullptr);
   ASSERT_LE(100U, malloc_usable_size(ptr));
   memset(ptr, 67, 100);
 
   ptr = (char *)realloc(ptr, 200);
-  ASSERT_TRUE(ptr != NULL);
+  ASSERT_TRUE(ptr != nullptr);
   ASSERT_LE(200U, malloc_usable_size(ptr));
   for (size_t i = 0; i < 100; i++) {
     ASSERT_EQ(67, ptr[i]);
@@ -155,12 +155,12 @@
 TEST(malloc, malloc_realloc_smaller) {
   // Realloc to a smaller size, malloc is used for the original allocation.
   char *ptr = (char *)malloc(200);
-  ASSERT_TRUE(ptr != NULL);
+  ASSERT_TRUE(ptr != nullptr);
   ASSERT_LE(200U, malloc_usable_size(ptr));
   memset(ptr, 67, 200);
 
   ptr = (char *)realloc(ptr, 100);
-  ASSERT_TRUE(ptr != NULL);
+  ASSERT_TRUE(ptr != nullptr);
   ASSERT_LE(100U, malloc_usable_size(ptr));
   for (size_t i = 0; i < 100; i++) {
     ASSERT_EQ(67, ptr[i]);
@@ -171,26 +171,26 @@
 TEST(malloc, malloc_multiple_realloc) {
   // Multiple reallocs, malloc is used for the original allocation.
   char *ptr = (char *)malloc(200);
-  ASSERT_TRUE(ptr != NULL);
+  ASSERT_TRUE(ptr != nullptr);
   ASSERT_LE(200U, malloc_usable_size(ptr));
   memset(ptr, 0x23, 200);
 
   ptr = (char *)realloc(ptr, 100);
-  ASSERT_TRUE(ptr != NULL);
+  ASSERT_TRUE(ptr != nullptr);
   ASSERT_LE(100U, malloc_usable_size(ptr));
   for (size_t i = 0; i < 100; i++) {
     ASSERT_EQ(0x23, ptr[i]);
   }
 
   ptr = (char*)realloc(ptr, 50);
-  ASSERT_TRUE(ptr != NULL);
+  ASSERT_TRUE(ptr != nullptr);
   ASSERT_LE(50U, malloc_usable_size(ptr));
   for (size_t i = 0; i < 50; i++) {
     ASSERT_EQ(0x23, ptr[i]);
   }
 
   ptr = (char*)realloc(ptr, 150);
-  ASSERT_TRUE(ptr != NULL);
+  ASSERT_TRUE(ptr != nullptr);
   ASSERT_LE(150U, malloc_usable_size(ptr));
   for (size_t i = 0; i < 50; i++) {
     ASSERT_EQ(0x23, ptr[i]);
@@ -198,7 +198,7 @@
   memset(ptr, 0x23, 150);
 
   ptr = (char*)realloc(ptr, 425);
-  ASSERT_TRUE(ptr != NULL);
+  ASSERT_TRUE(ptr != nullptr);
   ASSERT_LE(425U, malloc_usable_size(ptr));
   for (size_t i = 0; i < 150; i++) {
     ASSERT_EQ(0x23, ptr[i]);
@@ -209,11 +209,11 @@
 TEST(malloc, calloc_realloc_larger) {
   // Realloc to a larger size, calloc is used for the original allocation.
   char *ptr = (char *)calloc(1, 100);
-  ASSERT_TRUE(ptr != NULL);
+  ASSERT_TRUE(ptr != nullptr);
   ASSERT_LE(100U, malloc_usable_size(ptr));
 
   ptr = (char *)realloc(ptr, 200);
-  ASSERT_TRUE(ptr != NULL);
+  ASSERT_TRUE(ptr != nullptr);
   ASSERT_LE(200U, malloc_usable_size(ptr));
   for (size_t i = 0; i < 100; i++) {
     ASSERT_EQ(0, ptr[i]);
@@ -224,11 +224,11 @@
 TEST(malloc, calloc_realloc_smaller) {
   // Realloc to a smaller size, calloc is used for the original allocation.
   char *ptr = (char *)calloc(1, 200);
-  ASSERT_TRUE(ptr != NULL);
+  ASSERT_TRUE(ptr != nullptr);
   ASSERT_LE(200U, malloc_usable_size(ptr));
 
   ptr = (char *)realloc(ptr, 100);
-  ASSERT_TRUE(ptr != NULL);
+  ASSERT_TRUE(ptr != nullptr);
   ASSERT_LE(100U, malloc_usable_size(ptr));
   for (size_t i = 0; i < 100; i++) {
     ASSERT_EQ(0, ptr[i]);
@@ -239,25 +239,25 @@
 TEST(malloc, calloc_multiple_realloc) {
   // Multiple reallocs, calloc is used for the original allocation.
   char *ptr = (char *)calloc(1, 200);
-  ASSERT_TRUE(ptr != NULL);
+  ASSERT_TRUE(ptr != nullptr);
   ASSERT_LE(200U, malloc_usable_size(ptr));
 
   ptr = (char *)realloc(ptr, 100);
-  ASSERT_TRUE(ptr != NULL);
+  ASSERT_TRUE(ptr != nullptr);
   ASSERT_LE(100U, malloc_usable_size(ptr));
   for (size_t i = 0; i < 100; i++) {
     ASSERT_EQ(0, ptr[i]);
   }
 
   ptr = (char*)realloc(ptr, 50);
-  ASSERT_TRUE(ptr != NULL);
+  ASSERT_TRUE(ptr != nullptr);
   ASSERT_LE(50U, malloc_usable_size(ptr));
   for (size_t i = 0; i < 50; i++) {
     ASSERT_EQ(0, ptr[i]);
   }
 
   ptr = (char*)realloc(ptr, 150);
-  ASSERT_TRUE(ptr != NULL);
+  ASSERT_TRUE(ptr != nullptr);
   ASSERT_LE(150U, malloc_usable_size(ptr));
   for (size_t i = 0; i < 50; i++) {
     ASSERT_EQ(0, ptr[i]);
@@ -265,7 +265,7 @@
   memset(ptr, 0, 150);
 
   ptr = (char*)realloc(ptr, 425);
-  ASSERT_TRUE(ptr != NULL);
+  ASSERT_TRUE(ptr != nullptr);
   ASSERT_LE(425U, malloc_usable_size(ptr));
   for (size_t i = 0; i < 150; i++) {
     ASSERT_EQ(0, ptr[i]);
@@ -275,12 +275,12 @@
 
 TEST(malloc, realloc_overflow) {
   errno = 0;
-  ASSERT_EQ(NULL, realloc(NULL, SIZE_MAX));
+  ASSERT_EQ(nullptr, realloc(nullptr, SIZE_MAX));
   ASSERT_EQ(ENOMEM, errno);
   void* ptr = malloc(100);
-  ASSERT_TRUE(ptr != NULL);
+  ASSERT_TRUE(ptr != nullptr);
   errno = 0;
-  ASSERT_EQ(NULL, realloc(ptr, SIZE_MAX));
+  ASSERT_EQ(nullptr, realloc(ptr, SIZE_MAX));
   ASSERT_EQ(ENOMEM, errno);
   free(ptr);
 }
@@ -292,26 +292,26 @@
 TEST(malloc, pvalloc_std) {
   size_t pagesize = sysconf(_SC_PAGESIZE);
   void* ptr = pvalloc(100);
-  ASSERT_TRUE(ptr != NULL);
+  ASSERT_TRUE(ptr != nullptr);
   ASSERT_TRUE((reinterpret_cast<uintptr_t>(ptr) & (pagesize-1)) == 0);
   ASSERT_LE(pagesize, malloc_usable_size(ptr));
   free(ptr);
 }
 
 TEST(malloc, pvalloc_overflow) {
-  ASSERT_EQ(NULL, pvalloc(SIZE_MAX));
+  ASSERT_EQ(nullptr, pvalloc(SIZE_MAX));
 }
 
 TEST(malloc, valloc_std) {
   size_t pagesize = sysconf(_SC_PAGESIZE);
   void* ptr = pvalloc(100);
-  ASSERT_TRUE(ptr != NULL);
+  ASSERT_TRUE(ptr != nullptr);
   ASSERT_TRUE((reinterpret_cast<uintptr_t>(ptr) & (pagesize-1)) == 0);
   free(ptr);
 }
 
 TEST(malloc, valloc_overflow) {
-  ASSERT_EQ(NULL, valloc(SIZE_MAX));
+  ASSERT_EQ(nullptr, valloc(SIZE_MAX));
 }
 #endif