Modernize codebase by replacing NULL with nullptr

Fixes -Wzero-as-null-pointer-constant warning.

Test: m
Bug: 68236239
Change-Id: I5b4123bc6709641315120a191e36cc57541349b2
diff --git a/tests/TemporaryFile.h b/tests/TemporaryFile.h
index 070b71a..8af92d4 100644
--- a/tests/TemporaryFile.h
+++ b/tests/TemporaryFile.h
@@ -80,7 +80,7 @@
  private:
   bool init(const char* tmp_dir) {
     snprintf(dirname, sizeof(dirname), "%s/TemporaryDir-XXXXXX", tmp_dir);
-    return (mkdtemp(dirname) != NULL);
+    return (mkdtemp(dirname) != nullptr);
   }
 
   DISALLOW_COPY_AND_ASSIGN(TemporaryDir);
diff --git a/tests/async_safe_test.cpp b/tests/async_safe_test.cpp
index e71ba7a..4940e3a 100644
--- a/tests/async_safe_test.cpp
+++ b/tests/async_safe_test.cpp
@@ -36,7 +36,7 @@
   async_safe_format_buffer(buf, sizeof(buf), "a%sb", "01234");
   EXPECT_STREQ("a01234b", buf);
 
-  char* s = NULL;
+  char* s = nullptr;
   async_safe_format_buffer(buf, sizeof(buf), "a%sb", s);
   EXPECT_STREQ("a(null)b", buf);
 
@@ -97,7 +97,7 @@
   async_safe_format_buffer(buf, sizeof(buf), "a%03d:%d:%02dz", 5, 5, 5);
   EXPECT_STREQ("a005:5:05z", buf);
 
-  void* p = NULL;
+  void* p = nullptr;
   async_safe_format_buffer(buf, sizeof(buf), "a%d,%pz", 5, p);
   EXPECT_STREQ("a5,0x0z", buf);
 
diff --git a/tests/buffer_tests.h b/tests/buffer_tests.h
index 315083b..d496d51 100644
--- a/tests/buffer_tests.h
+++ b/tests/buffer_tests.h
@@ -22,16 +22,16 @@
 
 void RunSingleBufferAlignTest(
     size_t max_test_size, void (*test_func)(uint8_t*, size_t),
-    size_t (*set_incr)(size_t) = NULL);
+    size_t (*set_incr)(size_t) = nullptr);
 
 void RunSrcDstBufferAlignTest(
     size_t max_test_size, void (*test_func)(uint8_t*, uint8_t*, size_t),
-    size_t (*set_incr)(size_t) = NULL);
+    size_t (*set_incr)(size_t) = nullptr);
 
 void RunCmpBufferAlignTest(
     size_t max_test_size, void (*test_cmp_func)(uint8_t*, uint8_t*, size_t),
     void (*test_miscmp_func)(uint8_t*, uint8_t*, size_t, size_t),
-    size_t (*set_incr)(size_t) = NULL);
+    size_t (*set_incr)(size_t) = nullptr);
 
 void RunSingleBufferOverreadTest(void (*test_func)(uint8_t*, size_t));
 
diff --git a/tests/bug_26110743_test.cpp b/tests/bug_26110743_test.cpp
index ef474a0..89c6dcc 100644
--- a/tests/bug_26110743_test.cpp
+++ b/tests/bug_26110743_test.cpp
@@ -42,15 +42,15 @@
 
 static void* ProcSelfReadlink(void*) {
   ProcSelfReadlinkBody();
-  return NULL;
+  return nullptr;
 }
 
 TEST(bug_26110743, ProcSelfReadlink) {
   pthread_t t;
-  ASSERT_EQ(0, pthread_create(&t, NULL, ProcSelfReadlink, NULL));
+  ASSERT_EQ(0, pthread_create(&t, nullptr, ProcSelfReadlink, nullptr));
   void* result;
   ASSERT_EQ(0, pthread_join(t, &result));
-  ASSERT_EQ(NULL, result);
+  ASSERT_EQ(nullptr, result);
 }
 
 TEST(bug_26110743, ProcSelfReadlink_NotDumpable) {
@@ -62,10 +62,10 @@
   });
 
   pthread_t t;
-  ASSERT_EQ(0, pthread_create(&t, NULL, ProcSelfReadlink, NULL));
+  ASSERT_EQ(0, pthread_create(&t, nullptr, ProcSelfReadlink, nullptr));
   void* result;
   ASSERT_EQ(0, pthread_join(t, &result));
-  ASSERT_EQ(NULL, result);
+  ASSERT_EQ(nullptr, result);
 }
 
 static void ProcTaskFdReadlinkBody() {
@@ -86,15 +86,15 @@
 
 static void* ProcTaskFdReadlink(void*) {
   ProcTaskFdReadlinkBody();
-  return NULL;
+  return nullptr;
 }
 
 TEST(bug_26110743, ProcTaskFdReadlink) {
   pthread_t t;
-  ASSERT_EQ(0, pthread_create(&t, NULL, ProcTaskFdReadlink, NULL));
+  ASSERT_EQ(0, pthread_create(&t, nullptr, ProcTaskFdReadlink, nullptr));
   void* result;
   ASSERT_EQ(0, pthread_join(t, &result));
-  ASSERT_EQ(NULL, result);
+  ASSERT_EQ(nullptr, result);
 }
 
 TEST(bug_26110743, ProcTaskFdReadlink_NotDumpable) {
@@ -106,8 +106,8 @@
   });
 
   pthread_t t;
-  ASSERT_EQ(0, pthread_create(&t, NULL, ProcTaskFdReadlink, NULL));
+  ASSERT_EQ(0, pthread_create(&t, nullptr, ProcTaskFdReadlink, nullptr));
   void* result;
   ASSERT_EQ(0, pthread_join(t, &result));
-  ASSERT_EQ(NULL, result);
+  ASSERT_EQ(nullptr, result);
 }
diff --git a/tests/dirent_test.cpp b/tests/dirent_test.cpp
index fa05ca1..378aea4 100644
--- a/tests/dirent_test.cpp
+++ b/tests/dirent_test.cpp
@@ -51,11 +51,11 @@
 TEST(dirent, scandir_scandir64) {
   // Get everything from /proc/self...
   dirent** entries;
-  int entry_count = scandir("/proc/self", &entries, NULL, alphasort);
+  int entry_count = scandir("/proc/self", &entries, nullptr, alphasort);
   ASSERT_GE(entry_count, 0);
 
   dirent64** entries64;
-  int entry_count64 = scandir64("/proc/self", &entries64, NULL, alphasort64);
+  int entry_count64 = scandir64("/proc/self", &entries64, nullptr, alphasort64);
   ASSERT_EQ(entry_count, entry_count64);
 
   // Turn the directory entries into a set and vector of the names.
@@ -84,18 +84,18 @@
 TEST(dirent, scandirat_scandirat64) {
   // Get everything from /proc/self...
   dirent** entries;
-  int entry_count = scandir("/proc/self", &entries, NULL, alphasort);
+  int entry_count = scandir("/proc/self", &entries, nullptr, alphasort);
   ASSERT_GE(entry_count, 0);
 
   int proc_fd = open("/proc", O_DIRECTORY);
   ASSERT_NE(-1, proc_fd);
 
   dirent** entries_at;
-  int entry_count_at = scandirat(proc_fd, "self", &entries_at, NULL, alphasort);
+  int entry_count_at = scandirat(proc_fd, "self", &entries_at, nullptr, alphasort);
   ASSERT_EQ(entry_count, entry_count_at);
 
   dirent64** entries_at64;
-  int entry_count_at64 = scandirat64(proc_fd, "self", &entries_at64, NULL, alphasort64);
+  int entry_count_at64 = scandirat64(proc_fd, "self", &entries_at64, nullptr, alphasort64);
   ASSERT_EQ(entry_count, entry_count_at64);
 
   close(proc_fd);
@@ -148,12 +148,12 @@
 }
 
 TEST(dirent, fdopendir_invalid) {
-  ASSERT_TRUE(fdopendir(-1) == NULL);
+  ASSERT_TRUE(fdopendir(-1) == nullptr);
   ASSERT_EQ(EBADF, errno);
 
   int fd = open("/dev/null", O_RDONLY);
   ASSERT_NE(fd, -1);
-  ASSERT_TRUE(fdopendir(fd) == NULL);
+  ASSERT_TRUE(fdopendir(fd) == nullptr);
   ASSERT_EQ(ENOTDIR, errno);
   close(fd);
 }
@@ -161,7 +161,7 @@
 TEST(dirent, fdopendir) {
   int fd = open("/proc/self", O_RDONLY);
   DIR* d = fdopendir(fd);
-  ASSERT_TRUE(d != NULL);
+  ASSERT_TRUE(d != nullptr);
   dirent* e = readdir(d);
   ASSERT_STREQ(e->d_name, ".");
   ASSERT_EQ(closedir(d), 0);
@@ -172,40 +172,40 @@
 }
 
 TEST(dirent, opendir_invalid) {
-  ASSERT_TRUE(opendir("/does/not/exist") == NULL);
+  ASSERT_TRUE(opendir("/does/not/exist") == nullptr);
   ASSERT_EQ(ENOENT, errno);
 
-  ASSERT_TRUE(opendir("/dev/null") == NULL);
+  ASSERT_TRUE(opendir("/dev/null") == nullptr);
   ASSERT_EQ(ENOTDIR, errno);
 }
 
 TEST(dirent, opendir) {
   DIR* d = opendir("/proc/self");
-  ASSERT_TRUE(d != NULL);
+  ASSERT_TRUE(d != nullptr);
   dirent* e = readdir(d);
   ASSERT_STREQ(e->d_name, ".");
   ASSERT_EQ(closedir(d), 0);
 }
 
 TEST(dirent, closedir_invalid) {
-  DIR* d = NULL;
+  DIR* d = nullptr;
   ASSERT_EQ(closedir(d), -1);
   ASSERT_EQ(EINVAL, errno);
 }
 
 TEST(dirent, closedir) {
   DIR* d = opendir("/proc/self");
-  ASSERT_TRUE(d != NULL);
+  ASSERT_TRUE(d != nullptr);
   ASSERT_EQ(closedir(d), 0);
 }
 
 TEST(dirent, readdir) {
   DIR* d = opendir("/proc/self");
-  ASSERT_TRUE(d != NULL);
+  ASSERT_TRUE(d != nullptr);
   std::set<std::string> name_set;
   errno = 0;
   dirent* e;
-  while ((e = readdir(d)) != NULL) {
+  while ((e = readdir(d)) != nullptr) {
     name_set.insert(e->d_name);
   }
   // Reading to the end of the directory is not an error.
@@ -218,11 +218,11 @@
 
 TEST(dirent, readdir64) {
   DIR* d = opendir("/proc/self");
-  ASSERT_TRUE(d != NULL);
+  ASSERT_TRUE(d != nullptr);
   std::set<std::string> name_set;
   errno = 0;
   dirent64* e;
-  while ((e = readdir64(d)) != NULL) {
+  while ((e = readdir64(d)) != nullptr) {
     name_set.insert(e->d_name);
   }
   // Reading to the end of the directory is not an error.
@@ -235,12 +235,12 @@
 
 TEST(dirent, readdir_r) {
   DIR* d = opendir("/proc/self");
-  ASSERT_TRUE(d != NULL);
+  ASSERT_TRUE(d != nullptr);
   std::set<std::string> name_set;
   errno = 0;
   dirent storage;
-  dirent* e = NULL;
-  while (readdir_r(d, &storage, &e) == 0 && e != NULL) {
+  dirent* e = nullptr;
+  while (readdir_r(d, &storage, &e) == 0 && e != nullptr) {
     name_set.insert(e->d_name);
   }
   // Reading to the end of the directory is not an error.
@@ -253,12 +253,12 @@
 
 TEST(dirent, readdir64_r) {
   DIR* d = opendir("/proc/self");
-  ASSERT_TRUE(d != NULL);
+  ASSERT_TRUE(d != nullptr);
   std::set<std::string> name_set;
   errno = 0;
   dirent64 storage;
-  dirent64* e = NULL;
-  while (readdir64_r(d, &storage, &e) == 0 && e != NULL) {
+  dirent64* e = nullptr;
+  while (readdir64_r(d, &storage, &e) == 0 && e != nullptr) {
     name_set.insert(e->d_name);
   }
   // Reading to the end of the directory is not an error.
@@ -271,12 +271,12 @@
 
 TEST(dirent, rewinddir) {
   DIR* d = opendir("/proc/self");
-  ASSERT_TRUE(d != NULL);
+  ASSERT_TRUE(d != nullptr);
 
   // Get all the names once...
   std::vector<std::string> pass1;
   dirent* e;
-  while ((e = readdir(d)) != NULL) {
+  while ((e = readdir(d)) != nullptr) {
     pass1.push_back(e->d_name);
   }
 
@@ -285,7 +285,7 @@
 
   // ...and get all the names again.
   std::vector<std::string> pass2;
-  while ((e = readdir(d)) != NULL) {
+  while ((e = readdir(d)) != nullptr) {
     pass2.push_back(e->d_name);
   }
 
@@ -300,15 +300,15 @@
 
 TEST(dirent, seekdir_telldir) {
   DIR* d = opendir("/proc/self");
-  ASSERT_TRUE(d != NULL);
+  ASSERT_TRUE(d != nullptr);
   std::vector<long> offset_list;
   std::vector<std::string> name_list;
-  dirent* e = NULL;
+  dirent* e = nullptr;
 
   offset_list.push_back(telldir(d));
   ASSERT_EQ(0L, offset_list.back());
 
-  while ((e = readdir(d)) != NULL) {
+  while ((e = readdir(d)) != nullptr) {
     name_list.push_back(e->d_name);
     offset_list.push_back(telldir(d));
     // Make sure telldir() point to the next entry.
@@ -324,14 +324,14 @@
     seekdir(d, offset_list[i]);
     ASSERT_EQ(offset_list[i], telldir(d));
     e = readdir(d);
-    ASSERT_TRUE(e != NULL);
+    ASSERT_TRUE(e != nullptr);
     ASSERT_STREQ(name_list[i].c_str(), e->d_name);
   }
   for (int i = static_cast<int>(offset_list.size()) - 1; i >= 0; --i) {
     seekdir(d, offset_list[i]);
     ASSERT_EQ(offset_list[i], telldir(d));
     e = readdir(d);
-    ASSERT_TRUE(e != NULL);
+    ASSERT_TRUE(e != nullptr);
     ASSERT_STREQ(name_list[i].c_str(), e->d_name);
   }
 
@@ -339,7 +339,7 @@
   seekdir(d, end_offset);
   ASSERT_EQ(end_offset, telldir(d));
   errno = 0;
-  ASSERT_EQ(NULL, readdir(d));
+  ASSERT_EQ(nullptr, readdir(d));
   ASSERT_EQ(0, errno);
 
   ASSERT_EQ(0, closedir(d));
diff --git a/tests/error_test.cpp b/tests/error_test.cpp
index 5fee16f..e03c8d4 100644
--- a/tests/error_test.cpp
+++ b/tests/error_test.cpp
@@ -52,7 +52,7 @@
 
   error_at_line(0, 0, "blah.c", 123, "hello %s", "world");
 
-  error_print_progname = NULL;
+  error_print_progname = nullptr;
 }
 
 TEST(error_DeathTest, error_exit) {
diff --git a/tests/fcntl_test.cpp b/tests/fcntl_test.cpp
index 0a83dff..da44fee 100644
--- a/tests/fcntl_test.cpp
+++ b/tests/fcntl_test.cpp
@@ -174,10 +174,10 @@
 
   TemporaryFile tf;
 
-  ssize_t bytes_read = splice(in, 0, pipe_fds[1], NULL, 8*1024, SPLICE_F_MORE | SPLICE_F_MOVE);
+  ssize_t bytes_read = splice(in, nullptr, pipe_fds[1], nullptr, 8*1024, SPLICE_F_MORE | SPLICE_F_MOVE);
   ASSERT_NE(bytes_read, -1);
 
-  ssize_t bytes_written = splice(pipe_fds[0], NULL, tf.fd, 0, bytes_read, SPLICE_F_MORE | SPLICE_F_MOVE);
+  ssize_t bytes_written = splice(pipe_fds[0], nullptr, tf.fd, nullptr, bytes_read, SPLICE_F_MORE | SPLICE_F_MOVE);
   ASSERT_EQ(bytes_read, bytes_written);
 
   close(pipe_fds[0]);
@@ -200,8 +200,8 @@
 
   char buf[BUFSIZ];
   FILE* fp = fdopen(pipe_fds[0], "r");
-  ASSERT_TRUE(fp != NULL);
-  ASSERT_TRUE(fgets(buf, sizeof(buf), fp) != NULL);
+  ASSERT_TRUE(fp != nullptr);
+  ASSERT_TRUE(fgets(buf, sizeof(buf), fp) != nullptr);
   fclose(fp);
   ASSERT_STREQ("hello world\n", buf);
 }
@@ -209,8 +209,8 @@
 TEST(fcntl, tee) {
   char expected[BUFSIZ];
   FILE* expected_fp = fopen("/proc/version", "r");
-  ASSERT_TRUE(expected_fp != NULL);
-  ASSERT_TRUE(fgets(expected, sizeof(expected), expected_fp) != NULL);
+  ASSERT_TRUE(expected_fp != nullptr);
+  ASSERT_TRUE(fgets(expected, sizeof(expected), expected_fp) != nullptr);
   fclose(expected_fp);
 
   int pipe1[2];
@@ -223,7 +223,7 @@
   ASSERT_NE(in, -1);
 
   // Write /proc/version into pipe1.
-  ssize_t bytes_read = splice(in, 0, pipe1[1], NULL, 8*1024, SPLICE_F_MORE | SPLICE_F_MOVE);
+  ssize_t bytes_read = splice(in, nullptr, pipe1[1], nullptr, 8*1024, SPLICE_F_MORE | SPLICE_F_MOVE);
   ASSERT_NE(bytes_read, -1);
   close(pipe1[1]);
 
@@ -235,14 +235,14 @@
   // The out fds of both pipe1 and pipe2 should now contain /proc/version.
   char buf1[BUFSIZ];
   FILE* fp1 = fdopen(pipe1[0], "r");
-  ASSERT_TRUE(fp1 != NULL);
-  ASSERT_TRUE(fgets(buf1, sizeof(buf1), fp1) != NULL);
+  ASSERT_TRUE(fp1 != nullptr);
+  ASSERT_TRUE(fgets(buf1, sizeof(buf1), fp1) != nullptr);
   fclose(fp1);
 
   char buf2[BUFSIZ];
   FILE* fp2 = fdopen(pipe2[0], "r");
-  ASSERT_TRUE(fp2 != NULL);
-  ASSERT_TRUE(fgets(buf2, sizeof(buf2), fp2) != NULL);
+  ASSERT_TRUE(fp2 != nullptr);
+  ASSERT_TRUE(fgets(buf2, sizeof(buf2), fp2) != nullptr);
   fclose(fp2);
 
   ASSERT_STREQ(expected, buf1);
diff --git a/tests/fortify_filecheck_diagnostics_test.cpp b/tests/fortify_filecheck_diagnostics_test.cpp
index 375a156..5629408 100644
--- a/tests/fortify_filecheck_diagnostics_test.cpp
+++ b/tests/fortify_filecheck_diagnostics_test.cpp
@@ -211,7 +211,7 @@
   // NOLINTNEXTLINE(whitespace/line_length)
   // GCC: error: call to '__recvfrom_error' declared with attribute error: 'recvfrom' called with size bigger than buffer
   // CLANG: error: 'recvfrom' called with size bigger than buffer
-  recvfrom(0, buf, 6, 0, reinterpret_cast<sockaddr*>(&addr), NULL);
+  recvfrom(0, buf, 6, 0, reinterpret_cast<sockaddr*>(&addr), nullptr);
 }
 
 void test_recv() {
@@ -398,9 +398,9 @@
   realpath(".", buf);
 
   // This is fine.
-  realpath(".", NULL);
+  realpath(".", nullptr);
 
   char bigbuf[PATH_MAX];
   // CLANG: error: 'realpath': NULL path is never correct; flipped arguments?
-  realpath(NULL, bigbuf);
+  realpath(nullptr, bigbuf);
 }
diff --git a/tests/ftw_test.cpp b/tests/ftw_test.cpp
index 91e9fcf..22ab399 100644
--- a/tests/ftw_test.cpp
+++ b/tests/ftw_test.cpp
@@ -50,8 +50,8 @@
 }
 
 void sanity_check_ftw(const char* fpath, const struct stat* sb, int tflag) {
-  ASSERT_TRUE(fpath != NULL);
-  ASSERT_TRUE(sb != NULL);
+  ASSERT_TRUE(fpath != nullptr);
+  ASSERT_TRUE(sb != nullptr);
 
   // Was it a case where the struct stat we're given is meaningless?
   if (tflag == FTW_NS || tflag == FTW_SLN) {
diff --git a/tests/getcwd_test.cpp b/tests/getcwd_test.cpp
index b3b4136..f8f205e 100644
--- a/tests/getcwd_test.cpp
+++ b/tests/getcwd_test.cpp
@@ -23,8 +23,8 @@
 TEST(getcwd, auto_full) {
   // If we let the library do all the work, everything's fine.
   errno = 0;
-  char* cwd = getcwd(NULL, 0);
-  ASSERT_TRUE(cwd != NULL);
+  char* cwd = getcwd(nullptr, 0);
+  ASSERT_TRUE(cwd != nullptr);
   ASSERT_EQ(0, errno);
   ASSERT_GE(strlen(cwd), 1U);
   free(cwd);
@@ -33,8 +33,8 @@
 TEST(getcwd, auto_reasonable) {
   // If we ask the library to allocate a reasonable buffer, everything's fine.
   errno = 0;
-  char* cwd = getcwd(NULL, PATH_MAX);
-  ASSERT_TRUE(cwd != NULL);
+  char* cwd = getcwd(nullptr, PATH_MAX);
+  ASSERT_TRUE(cwd != nullptr);
   ASSERT_EQ(0, errno);
   ASSERT_GE(strlen(cwd), 1U);
   free(cwd);
@@ -43,16 +43,16 @@
 TEST(getcwd, auto_too_small) {
   // If we ask the library to allocate a too-small buffer, ERANGE.
   errno = 0;
-  char* cwd = getcwd(NULL, 1);
-  ASSERT_TRUE(cwd == NULL);
+  char* cwd = getcwd(nullptr, 1);
+  ASSERT_TRUE(cwd == nullptr);
   ASSERT_EQ(ERANGE, errno);
 }
 
 TEST(getcwd, auto_too_large) {
   // If we ask the library to allocate an unreasonably large buffer, ERANGE.
   errno = 0;
-  char* cwd = getcwd(NULL, static_cast<size_t>(-1));
-  ASSERT_TRUE(cwd == NULL);
+  char* cwd = getcwd(nullptr, static_cast<size_t>(-1));
+  ASSERT_TRUE(cwd == nullptr);
   ASSERT_EQ(ENOMEM, errno);
 }
 
@@ -61,7 +61,7 @@
   char tiny_buf[1];
   errno = 0;
   char* cwd = getcwd(tiny_buf, sizeof(tiny_buf));
-  ASSERT_TRUE(cwd == NULL);
+  ASSERT_TRUE(cwd == nullptr);
   ASSERT_EQ(ERANGE, errno);
 }
 
@@ -70,7 +70,7 @@
   char tiny_buf[1];
   errno = 0;
   char* cwd = getcwd(tiny_buf, 0);
-  ASSERT_TRUE(cwd == NULL);
+  ASSERT_TRUE(cwd == nullptr);
   ASSERT_EQ(EINVAL, errno);
 }
 
diff --git a/tests/grp_pwd_test.cpp b/tests/grp_pwd_test.cpp
index 2df1ef0..68897ed 100644
--- a/tests/grp_pwd_test.cpp
+++ b/tests/grp_pwd_test.cpp
@@ -50,15 +50,15 @@
 
 static void check_passwd(const passwd* pwd, const char* username, uid_t uid, uid_type_t uid_type,
                          bool check_username) {
-  ASSERT_TRUE(pwd != NULL);
+  ASSERT_TRUE(pwd != nullptr);
   if (check_username) {
     EXPECT_STREQ(username, pwd->pw_name);
   }
   EXPECT_EQ(uid, pwd->pw_uid);
   EXPECT_EQ(uid, pwd->pw_gid);
-  EXPECT_EQ(NULL, pwd->pw_passwd);
+  EXPECT_EQ(nullptr, pwd->pw_passwd);
 #ifdef __LP64__
-  EXPECT_EQ(NULL, pwd->pw_gecos);
+  EXPECT_EQ(nullptr, pwd->pw_gecos);
 #endif
 
   if (uid_type == TYPE_SYSTEM) {
@@ -94,7 +94,7 @@
   int result;
 
   errno = 0;
-  passwd* pwd = NULL;
+  passwd* pwd = nullptr;
   result = getpwuid_r(uid, &pwd_storage, buf, sizeof(buf), &pwd);
   ASSERT_EQ(0, result);
   ASSERT_EQ(0, errno);
@@ -109,7 +109,7 @@
   int result;
 
   errno = 0;
-  passwd* pwd = NULL;
+  passwd* pwd = nullptr;
   result = getpwnam_r(username, &pwd_storage, buf, sizeof(buf), &pwd);
   ASSERT_EQ(0, result);
   ASSERT_EQ(0, errno);
@@ -264,15 +264,15 @@
   std::set<uid_t> uids;
 
   setpwent();
-  while ((pwd = getpwent()) != NULL) {
-    ASSERT_TRUE(NULL != pwd->pw_name);
+  while ((pwd = getpwent()) != nullptr) {
+    ASSERT_TRUE(nullptr != pwd->pw_name);
 
     EXPECT_EQ(pwd->pw_gid, pwd->pw_uid) << "pwd->pw_uid: " << pwd->pw_uid;
-    EXPECT_EQ(NULL, pwd->pw_passwd) << "pwd->pw_uid: " << pwd->pw_uid;
+    EXPECT_EQ(nullptr, pwd->pw_passwd) << "pwd->pw_uid: " << pwd->pw_uid;
 #ifdef __LP64__
-    EXPECT_TRUE(NULL == pwd->pw_gecos) << "pwd->pw_uid: " << pwd->pw_uid;
+    EXPECT_TRUE(nullptr == pwd->pw_gecos) << "pwd->pw_uid: " << pwd->pw_uid;
 #endif
-    EXPECT_TRUE(NULL != pwd->pw_shell);
+    EXPECT_TRUE(nullptr != pwd->pw_shell);
     if (pwd->pw_uid < AID_APP_START || pwd->pw_uid == AID_OVERFLOWUID) {
       EXPECT_STREQ("/", pwd->pw_dir) << "pwd->pw_uid: " << pwd->pw_uid;
     } else {
@@ -299,16 +299,16 @@
 
 static void check_group(const group* grp, const char* group_name, gid_t gid,
                         bool check_groupname = true) {
-  ASSERT_TRUE(grp != NULL);
+  ASSERT_TRUE(grp != nullptr);
   if (check_groupname) {
     EXPECT_STREQ(group_name, grp->gr_name);
   }
   EXPECT_EQ(gid, grp->gr_gid);
-  ASSERT_TRUE(grp->gr_mem != NULL);
+  ASSERT_TRUE(grp->gr_mem != nullptr);
   if (check_groupname) {
     EXPECT_STREQ(group_name, grp->gr_mem[0]);
   }
-  EXPECT_TRUE(grp->gr_mem[1] == NULL);
+  EXPECT_TRUE(grp->gr_mem[1] == nullptr);
 }
 
 #if defined(__BIONIC__)
@@ -523,11 +523,11 @@
   std::set<gid_t> gids;
 
   setgrent();
-  while ((grp = getgrent()) != NULL) {
-    ASSERT_TRUE(grp->gr_name != NULL) << "grp->gr_gid: " << grp->gr_gid;
-    ASSERT_TRUE(grp->gr_mem != NULL) << "grp->gr_gid: " << grp->gr_gid;
+  while ((grp = getgrent()) != nullptr) {
+    ASSERT_TRUE(grp->gr_name != nullptr) << "grp->gr_gid: " << grp->gr_gid;
+    ASSERT_TRUE(grp->gr_mem != nullptr) << "grp->gr_gid: " << grp->gr_gid;
     EXPECT_STREQ(grp->gr_name, grp->gr_mem[0]) << "grp->gr_gid: " << grp->gr_gid;
-    EXPECT_TRUE(grp->gr_mem[1] == NULL) << "grp->gr_gid: " << grp->gr_gid;
+    EXPECT_TRUE(grp->gr_mem[1] == nullptr) << "grp->gr_gid: " << grp->gr_gid;
 
     // TODO(b/27999086): fix this check with the OEM range
     // If OEMs add their own AIDs to private/android_filesystem_config.h, this check will fail.
diff --git a/tests/gtest_main.cpp b/tests/gtest_main.cpp
index 8aa94bb..ba29825 100644
--- a/tests/gtest_main.cpp
+++ b/tests/gtest_main.cpp
@@ -263,7 +263,7 @@
 
 class TestResultPrinter : public testing::EmptyTestEventListener {
  public:
-  TestResultPrinter() : pinfo_(NULL) {}
+  TestResultPrinter() : pinfo_(nullptr) {}
   virtual void OnTestStart(const testing::TestInfo& test_info) {
     pinfo_ = &test_info; // Record test_info for use in OnTestPartResult.
   }
@@ -566,7 +566,7 @@
                                 time_t epoch_iteration_start_time,
                                 int64_t elapsed_time_ns) {
   FILE* fp = fopen(xml_output_filename.c_str(), "we");
-  if (fp == NULL) {
+  if (fp == nullptr) {
     fprintf(stderr, "failed to open '%s': %s\n", xml_output_filename.c_str(), strerror(errno));
     exit(1);
   }
@@ -683,7 +683,7 @@
   strcpy(filter_arg, "--gtest_filter=");
   strcat(filter_arg, test_name.c_str());
   new_argv[argc] = filter_arg;
-  new_argv[argc + 1] = NULL;
+  new_argv[argc + 1] = nullptr;
 
   int new_argc = argc + 1;
   testing::InitGoogleTest(&new_argc, new_argv);
@@ -848,7 +848,7 @@
     timespec sleep_time;
     sleep_time.tv_sec = 0;
     sleep_time.tv_nsec = 1000000;
-    nanosleep(&sleep_time, NULL);
+    nanosleep(&sleep_time, nullptr);
   }
 }
 
@@ -922,7 +922,7 @@
        ++iteration) {
     OnTestIterationStartPrint(testcase_list, iteration, iteration_count, job_count);
     int64_t iteration_start_time_ns = NanoTime();
-    time_t epoch_iteration_start_time = time(NULL);
+    time_t epoch_iteration_start_time = time(nullptr);
 
     // Run up to job_count tests in parallel, each test in a child process.
     std::vector<ChildProcInfo> child_proc_list;
@@ -1159,8 +1159,8 @@
         }
         // Make absolute path.
         if (success && output[0] != '/') {
-          char* cwd = getcwd(NULL, 0);
-          if (cwd != NULL) {
+          char* cwd = getcwd(nullptr, 0);
+          if (cwd != nullptr) {
             output = std::string(cwd) + "/" + output;
             free(cwd);
           } else {
@@ -1223,7 +1223,7 @@
     std::vector<TestCase> testcase_list;
 
     argc = static_cast<int>(arg_list.size());
-    arg_list.push_back(NULL);
+    arg_list.push_back(nullptr);
     if (EnumerateTests(argc, arg_list.data(), testcase_list) == false) {
       return 1;
     }
@@ -1232,7 +1232,7 @@
     return all_test_passed ? 0 : 1;
   } else {
     argc = static_cast<int>(arg_list.size());
-    arg_list.push_back(NULL);
+    arg_list.push_back(nullptr);
     testing::InitGoogleTest(&argc, arg_list.data());
     return RUN_ALL_TESTS();
   }
diff --git a/tests/inttypes_test.cpp b/tests/inttypes_test.cpp
index 08258ac..f7dfdb5 100644
--- a/tests/inttypes_test.cpp
+++ b/tests/inttypes_test.cpp
@@ -123,13 +123,13 @@
 
 TEST(inttypes, strtoimax_EINVAL) {
   errno = 0;
-  strtoimax("123", NULL, -1);
+  strtoimax("123", nullptr, -1);
   ASSERT_EQ(EINVAL, errno);
   errno = 0;
-  strtoimax("123", NULL, 1);
+  strtoimax("123", nullptr, 1);
   ASSERT_EQ(EINVAL, errno);
   errno = 0;
-  strtoimax("123", NULL, 37);
+  strtoimax("123", nullptr, 37);
   ASSERT_EQ(EINVAL, errno);
 }
 
@@ -153,37 +153,37 @@
 
 TEST(inttypes, strtoumax_EINVAL) {
   errno = 0;
-  strtoumax("123", NULL, -1);
+  strtoumax("123", nullptr, -1);
   ASSERT_EQ(EINVAL, errno);
   errno = 0;
-  strtoumax("123", NULL, 1);
+  strtoumax("123", nullptr, 1);
   ASSERT_EQ(EINVAL, errno);
   errno = 0;
-  strtoumax("123", NULL, 37);
+  strtoumax("123", nullptr, 37);
   ASSERT_EQ(EINVAL, errno);
 }
 
 TEST(inttypes, wcstoimax_EINVAL) {
   errno = 0;
-  wcstoimax(L"123", NULL, -1);
+  wcstoimax(L"123", nullptr, -1);
   ASSERT_EQ(EINVAL, errno);
   errno = 0;
-  wcstoimax(L"123", NULL, 1);
+  wcstoimax(L"123", nullptr, 1);
   ASSERT_EQ(EINVAL, errno);
   errno = 0;
-  wcstoimax(L"123", NULL, 37);
+  wcstoimax(L"123", nullptr, 37);
   ASSERT_EQ(EINVAL, errno);
 }
 
 TEST(inttypes, wcstoumax_EINVAL) {
   errno = 0;
-  wcstoumax(L"123", NULL, -1);
+  wcstoumax(L"123", nullptr, -1);
   ASSERT_EQ(EINVAL, errno);
   errno = 0;
-  wcstoumax(L"123", NULL, 1);
+  wcstoumax(L"123", nullptr, 1);
   ASSERT_EQ(EINVAL, errno);
   errno = 0;
-  wcstoumax(L"123", NULL, 37);
+  wcstoumax(L"123", nullptr, 37);
   ASSERT_EQ(EINVAL, errno);
 }
 
diff --git a/tests/libgen_basename_test.cpp b/tests/libgen_basename_test.cpp
index d97e0da..91ae960 100644
--- a/tests/libgen_basename_test.cpp
+++ b/tests/libgen_basename_test.cpp
@@ -49,7 +49,7 @@
 }
 
 static void __TestPosixBasename(const char* in, const char* expected_out, int line) {
-  char* writable_in = (in != NULL) ? strdup(in) : NULL;
+  char* writable_in = (in != nullptr) ? strdup(in) : nullptr;
   errno = 0;
   const char* out = posix_basename(&writable_in[0]);
   ASSERT_STREQ(expected_out, out) << "(" << line << "): " << in << std::endl;
@@ -76,7 +76,7 @@
 }
 
 TEST(libgen_basename, posix_basename) {
-  TestPosixBasename(NULL, ".");
+  TestPosixBasename(nullptr, ".");
   TestPosixBasename("", ".");
   TestPosixBasename("/usr/lib", "lib");
   TestPosixBasename("/system/bin/sh/", "sh");
diff --git a/tests/libgen_test.cpp b/tests/libgen_test.cpp
index 8a37a3f..d5b5eb6 100644
--- a/tests/libgen_test.cpp
+++ b/tests/libgen_test.cpp
@@ -20,7 +20,7 @@
 #include <gtest/gtest.h>
 
 static void TestDirname(const char* in, const char* expected_out) {
-  char* writable_in = (in != NULL) ? strdup(in) : NULL;
+  char* writable_in = (in != nullptr) ? strdup(in) : nullptr;
   errno = 0;
   const char* out = dirname(&writable_in[0]);
   ASSERT_STREQ(expected_out, out) << in;
@@ -29,7 +29,7 @@
 }
 
 TEST(libgen, dirname) {
-  TestDirname(NULL, ".");
+  TestDirname(nullptr, ".");
   TestDirname("", ".");
   TestDirname("/usr/lib", "/usr");
   TestDirname("/usr/", "/");
@@ -45,7 +45,7 @@
   errno = 0;
   int rc = basename_r(in, buf, buf_size);
   ASSERT_EQ(expected_rc, rc) << in;
-  if (rc != -1 && buf != NULL) {
+  if (rc != -1 && buf != nullptr) {
     ASSERT_STREQ(expected_out, buf) << in;
   }
   ASSERT_EQ(expected_errno, errno) << in;
@@ -56,7 +56,7 @@
   errno = 0;
   int rc = dirname_r(in, buf, buf_size);
   ASSERT_EQ(expected_rc, rc) << in;
-  if (rc != -1 && buf != NULL) {
+  if (rc != -1 && buf != nullptr) {
     ASSERT_STREQ(expected_out, buf) << in;
   }
   ASSERT_EQ(expected_errno, errno) << in;
@@ -66,7 +66,7 @@
 TEST(libgen, basename_r) {
 #if defined(__BIONIC__) && !defined(__LP64__)
   char buf[256];
-  TestBasename("", ".",  1, NULL, 0, 0);
+  TestBasename("", ".",  1, nullptr, 0, 0);
   TestBasename("", ".", -1, buf, 0, ERANGE);
   TestBasename("", ".", -1, buf, 1, ERANGE);
   TestBasename("", ".", 1, buf, 2, 0);
@@ -85,7 +85,7 @@
 TEST(libgen, dirname_r) {
 #if defined(__BIONIC__) && !defined(__LP64__)
   char buf[256];
-  TestDirname("", ".",  1, NULL, 0, 0);
+  TestDirname("", ".",  1, nullptr, 0, 0);
   TestDirname("", ".", -1, buf, 0, ERANGE);
   TestDirname("", ".", -1, buf, 1, ERANGE);
   TestDirname("", ".", 1, buf, 2, 0);
diff --git a/tests/libs/dlopen_testlib_ifunc.cpp b/tests/libs/dlopen_testlib_ifunc.cpp
index f8acba7..f2e0025 100644
--- a/tests/libs/dlopen_testlib_ifunc.cpp
+++ b/tests/libs/dlopen_testlib_ifunc.cpp
@@ -61,7 +61,7 @@
 
 extern "C" fn_ptr foo_ifunc() {
    char* choice = getenv("IFUNC_CHOICE");
-   return choice == NULL ? f1 : f2;
+   return choice == nullptr ? f1 : f2;
 }
 
 extern "C" const char* foo_library() {
diff --git a/tests/libs/dlopen_testlib_ifunc_variable_impl.cpp b/tests/libs/dlopen_testlib_ifunc_variable_impl.cpp
index a550fef..4b13eba 100644
--- a/tests/libs/dlopen_testlib_ifunc_variable_impl.cpp
+++ b/tests/libs/dlopen_testlib_ifunc_variable_impl.cpp
@@ -49,5 +49,5 @@
 
 extern "C" void* foo_ifunc() {
    char* choice = getenv("IFUNC_CHOICE");
-   return choice == NULL ? &v1 : &v2;
+   return choice == nullptr ? &v1 : &v2;
 }
diff --git a/tests/locale_test.cpp b/tests/locale_test.cpp
index 8b38c40..b4da6de 100644
--- a/tests/locale_test.cpp
+++ b/tests/locale_test.cpp
@@ -48,14 +48,14 @@
 }
 
 TEST(locale, setlocale) {
-  EXPECT_STREQ("C.UTF-8", setlocale(LC_ALL, NULL));
-  EXPECT_STREQ("C.UTF-8", setlocale(LC_CTYPE, NULL));
+  EXPECT_STREQ("C.UTF-8", setlocale(LC_ALL, nullptr));
+  EXPECT_STREQ("C.UTF-8", setlocale(LC_CTYPE, nullptr));
 
   errno = 0;
-  EXPECT_EQ(NULL, setlocale(-1, NULL));
+  EXPECT_EQ(nullptr, setlocale(-1, nullptr));
   EXPECT_EQ(EINVAL, errno);
   errno = 0;
-  EXPECT_EQ(NULL, setlocale(13, NULL));
+  EXPECT_EQ(nullptr, setlocale(13, nullptr));
   EXPECT_EQ(EINVAL, errno);
 
 #if defined(__BIONIC__)
@@ -68,53 +68,53 @@
   EXPECT_STREQ("C", setlocale(LC_ALL, "POSIX"));
 
   errno = 0;
-  EXPECT_EQ(NULL, setlocale(LC_ALL, "this-is-not-a-locale"));
+  EXPECT_EQ(nullptr, setlocale(LC_ALL, "this-is-not-a-locale"));
   EXPECT_EQ(ENOENT, errno); // POSIX specified, not an implementation detail!
 }
 
 TEST(locale, newlocale_invalid_category_mask) {
   errno = 0;
-  EXPECT_EQ(0, newlocale(1 << 20, "C", 0));
+  EXPECT_EQ(nullptr, newlocale(1 << 20, "C", nullptr));
   EXPECT_EQ(EINVAL, errno);
 }
 
 TEST(locale, newlocale_NULL_locale_name) {
   errno = 0;
-  EXPECT_EQ(0, newlocale(LC_ALL, NULL, 0));
+  EXPECT_EQ(nullptr, newlocale(LC_ALL, nullptr, nullptr));
   EXPECT_EQ(EINVAL, errno);
 }
 
 TEST(locale, newlocale_bad_locale_name) {
   errno = 0;
-  EXPECT_EQ(0, newlocale(LC_ALL, "this-is-not-a-locale", 0));
+  EXPECT_EQ(nullptr, newlocale(LC_ALL, "this-is-not-a-locale", nullptr));
   EXPECT_EQ(ENOENT, errno); // POSIX specified, not an implementation detail!
 }
 
 TEST(locale, newlocale) {
-  locale_t l = newlocale(LC_ALL, "C", 0);
-  ASSERT_TRUE(l != NULL);
+  locale_t l = newlocale(LC_ALL, "C", nullptr);
+  ASSERT_TRUE(l != nullptr);
   freelocale(l);
 }
 
 TEST(locale, duplocale) {
   locale_t cloned_global = duplocale(LC_GLOBAL_LOCALE);
-  ASSERT_TRUE(cloned_global != NULL);
+  ASSERT_TRUE(cloned_global != nullptr);
   freelocale(cloned_global);
 }
 
 TEST(locale, uselocale) {
-  locale_t original = uselocale(NULL);
-  EXPECT_FALSE(original == 0);
+  locale_t original = uselocale(nullptr);
+  EXPECT_FALSE(original == nullptr);
   EXPECT_EQ(LC_GLOBAL_LOCALE, original);
 
-  locale_t n = newlocale(LC_ALL, "C", 0);
-  EXPECT_FALSE(n == 0);
+  locale_t n = newlocale(LC_ALL, "C", nullptr);
+  EXPECT_FALSE(n == nullptr);
   EXPECT_FALSE(n == original);
 
   locale_t old = uselocale(n);
   EXPECT_TRUE(old == original);
 
-  EXPECT_EQ(n, uselocale(NULL));
+  EXPECT_EQ(n, uselocale(nullptr));
 }
 
 TEST(locale, mb_cur_max) {
@@ -122,8 +122,8 @@
   // initial program conditions because (unless we're the only test that was
   // run), another test has almost certainly called uselocale(3) in this thread.
   // See b/16685652.
-  locale_t cloc = newlocale(LC_ALL, "C", 0);
-  locale_t cloc_utf8 = newlocale(LC_ALL, "C.UTF-8", 0);
+  locale_t cloc = newlocale(LC_ALL, "C", nullptr);
+  locale_t cloc_utf8 = newlocale(LC_ALL, "C.UTF-8", nullptr);
 
   locale_t old_locale = uselocale(cloc);
   ASSERT_EQ(1U, MB_CUR_MAX);
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
 
diff --git a/tests/mntent_test.cpp b/tests/mntent_test.cpp
index 3fb2f86..b86af9f 100644
--- a/tests/mntent_test.cpp
+++ b/tests/mntent_test.cpp
@@ -20,15 +20,15 @@
 
 TEST(mntent, mntent_smoke) {
   FILE* fp = setmntent("/proc/mounts", "r");
-  ASSERT_TRUE(fp != NULL);
+  ASSERT_TRUE(fp != nullptr);
 
-  ASSERT_TRUE(getmntent(fp) != NULL);
+  ASSERT_TRUE(getmntent(fp) != nullptr);
 
   bool saw_proc = false;
 
   struct mntent entry;
   char buf[BUFSIZ];
-  while (getmntent_r(fp, &entry, buf, sizeof(buf)) != NULL) {
+  while (getmntent_r(fp, &entry, buf, sizeof(buf)) != nullptr) {
     if (strcmp(entry.mnt_fsname, "proc") == 0 && strcmp(entry.mnt_dir, "/proc") == 0) {
       saw_proc = true;
     }
diff --git a/tests/netdb_test.cpp b/tests/netdb_test.cpp
index a624138..a805693 100644
--- a/tests/netdb_test.cpp
+++ b/tests/netdb_test.cpp
@@ -26,13 +26,13 @@
 
 // https://code.google.com/p/android/issues/detail?id=13228
 TEST(netdb, freeaddrinfo_NULL) {
-  freeaddrinfo(NULL);
+  freeaddrinfo(nullptr);
 }
 
 TEST(netdb, getaddrinfo_NULL_host) {
   // It's okay for the host argument to be NULL, as long as service isn't.
-  addrinfo* ai = NULL;
-  ASSERT_EQ(0, getaddrinfo(NULL, "smtp", NULL, &ai));
+  addrinfo* ai = nullptr;
+  ASSERT_EQ(0, getaddrinfo(nullptr, "smtp", nullptr, &ai));
   // (sockaddr_in::sin_port and sockaddr_in6::sin6_port overlap.)
   ASSERT_EQ(25U, ntohs(reinterpret_cast<sockaddr_in*>(ai->ai_addr)->sin_port));
   freeaddrinfo(ai);
@@ -40,19 +40,19 @@
 
 TEST(netdb, getaddrinfo_NULL_service) {
   // It's okay for the service argument to be NULL, as long as host isn't.
-  addrinfo* ai = NULL;
-  ASSERT_EQ(0, getaddrinfo("localhost", NULL, NULL, &ai));
-  ASSERT_TRUE(ai != NULL);
+  addrinfo* ai = nullptr;
+  ASSERT_EQ(0, getaddrinfo("localhost", nullptr, nullptr, &ai));
+  ASSERT_TRUE(ai != nullptr);
   freeaddrinfo(ai);
 }
 
 TEST(netdb, getaddrinfo_NULL_hints) {
-  addrinfo* ai = NULL;
-  ASSERT_EQ(0, getaddrinfo("localhost", "9999", NULL, &ai));
+  addrinfo* ai = nullptr;
+  ASSERT_EQ(0, getaddrinfo("localhost", "9999", nullptr, &ai));
 
   bool saw_tcp = false;
   bool saw_udp = false;
-  for (addrinfo* p = ai; p != NULL; p = p->ai_next) {
+  for (addrinfo* p = ai; p != nullptr; p = p->ai_next) {
     ASSERT_TRUE(p->ai_family == AF_INET || p->ai_family == AF_INET6);
     if (p->ai_socktype == SOCK_STREAM) {
       ASSERT_EQ(IPPROTO_TCP, p->ai_protocol);
@@ -69,8 +69,8 @@
 }
 
 TEST(netdb, getaddrinfo_service_lookup) {
-  addrinfo* ai = NULL;
-  ASSERT_EQ(0, getaddrinfo("localhost", "smtp", NULL, &ai));
+  addrinfo* ai = nullptr;
+  ASSERT_EQ(0, getaddrinfo("localhost", "smtp", nullptr, &ai));
   ASSERT_EQ(SOCK_STREAM, ai->ai_socktype);
   ASSERT_EQ(IPPROTO_TCP, ai->ai_protocol);
   ASSERT_EQ(25, ntohs(reinterpret_cast<sockaddr_in*>(ai->ai_addr)->sin_port));
@@ -84,13 +84,13 @@
   hints.ai_socktype = SOCK_STREAM;
   hints.ai_protocol = IPPROTO_TCP;
 
-  addrinfo* ai = NULL;
+  addrinfo* ai = nullptr;
   ASSERT_EQ(0, getaddrinfo( "localhost", "9999", &hints, &ai));
-  ASSERT_TRUE(ai != NULL);
+  ASSERT_TRUE(ai != nullptr);
   // In glibc, getaddrinfo() converts ::1 to 127.0.0.1 for localhost,
   // so one or two addrinfo may be returned.
   addrinfo* tai = ai;
-  while (tai != NULL) {
+  while (tai != nullptr) {
     ASSERT_EQ(AF_INET, tai->ai_family);
     ASSERT_EQ(SOCK_STREAM, tai->ai_socktype);
     ASSERT_EQ(IPPROTO_TCP, tai->ai_protocol);
@@ -100,11 +100,11 @@
 }
 
 TEST(netdb, getaddrinfo_ip6_localhost) {
-  addrinfo* ai = NULL;
-  ASSERT_EQ(0, getaddrinfo("ip6-localhost", NULL, NULL, &ai));
-  ASSERT_TRUE(ai != NULL);
+  addrinfo* ai = nullptr;
+  ASSERT_EQ(0, getaddrinfo("ip6-localhost", nullptr, nullptr, &ai));
+  ASSERT_TRUE(ai != nullptr);
   ASSERT_GE(ai->ai_addrlen, static_cast<socklen_t>(sizeof(sockaddr_in6)));
-  ASSERT_TRUE(ai->ai_addr != NULL);
+  ASSERT_TRUE(ai->ai_addr != nullptr);
   sockaddr_in6 *addr = reinterpret_cast<sockaddr_in6*>(ai->ai_addr);
   ASSERT_EQ(addr->sin6_family, AF_INET6);
   ASSERT_EQ(0, memcmp(&addr->sin6_addr, &in6addr_loopback, sizeof(in6_addr)));
@@ -122,22 +122,22 @@
   socklen_t just_right = sizeof(sockaddr_in);
   socklen_t too_little = sizeof(sockaddr_in) - 1;
 
-  ASSERT_EQ(0, getnameinfo(sa, too_much, tmp, sizeof(tmp), NULL, 0, NI_NUMERICHOST));
+  ASSERT_EQ(0, getnameinfo(sa, too_much, tmp, sizeof(tmp), nullptr, 0, NI_NUMERICHOST));
   ASSERT_STREQ("0.0.0.0", tmp);
-  ASSERT_EQ(0, getnameinfo(sa, just_right, tmp, sizeof(tmp), NULL, 0, NI_NUMERICHOST));
+  ASSERT_EQ(0, getnameinfo(sa, just_right, tmp, sizeof(tmp), nullptr, 0, NI_NUMERICHOST));
   ASSERT_STREQ("0.0.0.0", tmp);
-  ASSERT_EQ(EAI_FAMILY, getnameinfo(sa, too_little, tmp, sizeof(tmp), NULL, 0, NI_NUMERICHOST));
+  ASSERT_EQ(EAI_FAMILY, getnameinfo(sa, too_little, tmp, sizeof(tmp), nullptr, 0, NI_NUMERICHOST));
 
   ss.ss_family = AF_INET6;
   just_right = sizeof(sockaddr_in6);
   too_little = sizeof(sockaddr_in6) - 1;
   too_much = just_right + 1;
 
-  ASSERT_EQ(0, getnameinfo(sa, too_much, tmp, sizeof(tmp), NULL, 0, NI_NUMERICHOST));
+  ASSERT_EQ(0, getnameinfo(sa, too_much, tmp, sizeof(tmp), nullptr, 0, NI_NUMERICHOST));
   ASSERT_STREQ("::", tmp);
-  ASSERT_EQ(0, getnameinfo(sa, just_right, tmp, sizeof(tmp), NULL, 0, NI_NUMERICHOST));
+  ASSERT_EQ(0, getnameinfo(sa, just_right, tmp, sizeof(tmp), nullptr, 0, NI_NUMERICHOST));
   ASSERT_STREQ("::", tmp);
-  ASSERT_EQ(EAI_FAMILY, getnameinfo(sa, too_little, tmp, sizeof(tmp), NULL, 0, NI_NUMERICHOST));
+  ASSERT_EQ(EAI_FAMILY, getnameinfo(sa, too_little, tmp, sizeof(tmp), nullptr, 0, NI_NUMERICHOST));
 }
 
 TEST(netdb, getnameinfo_localhost) {
@@ -147,7 +147,7 @@
   addr.sin_family = AF_INET;
   addr.sin_addr.s_addr = htonl(0x7f000001);
   ASSERT_EQ(0, getnameinfo(reinterpret_cast<sockaddr*>(&addr), sizeof(addr),
-                           host, sizeof(host), NULL, 0, 0));
+                           host, sizeof(host), nullptr, 0, 0));
   ASSERT_STREQ(host, "localhost");
 }
 
@@ -165,14 +165,14 @@
   addr.sin6_family = AF_INET6;
   addr.sin6_addr = in6addr_loopback;
   ASSERT_EQ(0, getnameinfo(reinterpret_cast<sockaddr*>(&addr), sizeof(addr),
-                           host, sizeof(host), NULL, 0, 0));
+                           host, sizeof(host), nullptr, 0, 0));
   VerifyLocalhostName(host);
 }
 
 static void VerifyLocalhost(hostent *hent) {
-  ASSERT_TRUE(hent != NULL);
+  ASSERT_TRUE(hent != nullptr);
   VerifyLocalhostName(hent->h_name);
-  for (size_t i = 0; hent->h_aliases[i] != NULL; ++i) {
+  for (size_t i = 0; hent->h_aliases[i] != nullptr; ++i) {
     VerifyLocalhostName(hent->h_aliases[i]);
   }
   ASSERT_EQ(hent->h_addrtype, AF_INET);
@@ -273,7 +273,7 @@
   int result = gethostbyname_r("localhost", &hent, buf, sizeof(buf), &hp, &err);
   EXPECT_EQ(NETDB_INTERNAL, err);
   EXPECT_EQ(ERANGE, result);
-  EXPECT_EQ(NULL, hp);
+  EXPECT_EQ(nullptr, hp);
 }
 
 TEST(netdb, gethostbyname2_r_ERANGE) {
@@ -284,7 +284,7 @@
   int result = gethostbyname2_r("localhost", AF_INET, &hent, buf, sizeof(buf), &hp, &err);
   EXPECT_EQ(NETDB_INTERNAL, err);
   EXPECT_EQ(ERANGE, result);
-  EXPECT_EQ(NULL, hp);
+  EXPECT_EQ(nullptr, hp);
 }
 
 TEST(netdb, gethostbyaddr_r_ERANGE) {
@@ -296,7 +296,7 @@
   int result = gethostbyaddr_r(&addr, sizeof(addr), AF_INET, &hent, buf, sizeof(buf), &hp, &err);
   EXPECT_EQ(NETDB_INTERNAL, err);
   EXPECT_EQ(ERANGE, result);
-  EXPECT_EQ(NULL, hp);
+  EXPECT_EQ(nullptr, hp);
 }
 
 TEST(netdb, gethostbyname_r_HOST_NOT_FOUND) {
@@ -307,7 +307,7 @@
   int result = gethostbyname_r("does.not.exist.google.com", &hent, buf, sizeof(buf), &hp, &err);
   EXPECT_EQ(HOST_NOT_FOUND, err);
   EXPECT_EQ(0, result);
-  EXPECT_EQ(NULL, hp);
+  EXPECT_EQ(nullptr, hp);
 }
 
 TEST(netdb, gethostbyname2_r_HOST_NOT_FOUND) {
@@ -318,7 +318,7 @@
   int result = gethostbyname2_r("does.not.exist.google.com", AF_INET, &hent, buf, sizeof(buf), &hp, &err);
   EXPECT_EQ(HOST_NOT_FOUND, err);
   EXPECT_EQ(0, result);
-  EXPECT_EQ(NULL, hp);
+  EXPECT_EQ(nullptr, hp);
 }
 
 TEST(netdb, gethostbyaddr_r_HOST_NOT_FOUND) {
@@ -330,7 +330,7 @@
   int result = gethostbyaddr_r(&addr, sizeof(addr), AF_INET, &hent, buf, sizeof(buf), &hp, &err);
   EXPECT_EQ(HOST_NOT_FOUND, err);
   EXPECT_EQ(0, result);
-  EXPECT_EQ(NULL, hp);
+  EXPECT_EQ(nullptr, hp);
 }
 
 TEST(netdb, getservbyname) {
diff --git a/tests/pthread_test.cpp b/tests/pthread_test.cpp
index f2f6e01..fc8945c 100644
--- a/tests/pthread_test.cpp
+++ b/tests/pthread_test.cpp
@@ -45,7 +45,7 @@
 
 TEST(pthread, pthread_key_create) {
   pthread_key_t key;
-  ASSERT_EQ(0, pthread_key_create(&key, NULL));
+  ASSERT_EQ(0, pthread_key_create(&key, nullptr));
   ASSERT_EQ(0, pthread_key_delete(key));
   // Can't delete a key that's already been deleted.
   ASSERT_EQ(EINVAL, pthread_key_delete(key));
@@ -76,7 +76,7 @@
   for (int i = 0; i < nkeys; ++i) {
     pthread_key_t key;
     // If this fails, it's likely that LIBC_PTHREAD_KEY_RESERVED_COUNT is wrong.
-    ASSERT_EQ(0, pthread_key_create(&key, NULL)) << i << " of " << nkeys;
+    ASSERT_EQ(0, pthread_key_create(&key, nullptr)) << i << " of " << nkeys;
     keys.push_back(key);
     ASSERT_EQ(0, pthread_setspecific(key, reinterpret_cast<void*>(i)));
   }
@@ -97,7 +97,7 @@
   // be more than we are allowed to allocate now.
   for (int i = 0; i < PTHREAD_KEYS_MAX; i++) {
     pthread_key_t key;
-    rv = pthread_key_create(&key, NULL);
+    rv = pthread_key_create(&key, nullptr);
     if (rv == EAGAIN) {
       break;
     }
@@ -119,12 +119,12 @@
 TEST(pthread, pthread_key_delete) {
   void* expected = reinterpret_cast<void*>(1234);
   pthread_key_t key;
-  ASSERT_EQ(0, pthread_key_create(&key, NULL));
+  ASSERT_EQ(0, pthread_key_create(&key, nullptr));
   ASSERT_EQ(0, pthread_setspecific(key, expected));
   ASSERT_EQ(expected, pthread_getspecific(key));
   ASSERT_EQ(0, pthread_key_delete(key));
-  // After deletion, pthread_getspecific returns NULL.
-  ASSERT_EQ(NULL, pthread_getspecific(key));
+  // After deletion, pthread_getspecific returns nullptr.
+  ASSERT_EQ(nullptr, pthread_getspecific(key));
   // And you can't use pthread_setspecific with the deleted key.
   ASSERT_EQ(EINVAL, pthread_setspecific(key, expected));
 }
@@ -132,7 +132,7 @@
 TEST(pthread, pthread_key_fork) {
   void* expected = reinterpret_cast<void*>(1234);
   pthread_key_t key;
-  ASSERT_EQ(0, pthread_key_create(&key, NULL));
+  ASSERT_EQ(0, pthread_key_create(&key, nullptr));
   ASSERT_EQ(0, pthread_setspecific(key, expected));
   ASSERT_EQ(expected, pthread_getspecific(key));
 
@@ -157,10 +157,10 @@
 
 TEST(pthread, pthread_key_dirty) {
   pthread_key_t key;
-  ASSERT_EQ(0, pthread_key_create(&key, NULL));
+  ASSERT_EQ(0, pthread_key_create(&key, nullptr));
 
   size_t stack_size = 640 * 1024;
-  void* stack = mmap(NULL, stack_size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
+  void* stack = mmap(nullptr, stack_size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
   ASSERT_NE(MAP_FAILED, stack);
   memset(stack, 0xff, stack_size);
 
@@ -217,7 +217,7 @@
  private:
   static void* SpinFn(void*) {
     while (spin_flag_) {}
-    return NULL;
+    return nullptr;
   }
   static std::atomic<bool> spin_flag_;
 };
@@ -228,7 +228,7 @@
 std::atomic<bool> SpinFunctionHelper::spin_flag_;
 
 static void* JoinFn(void* arg) {
-  return reinterpret_cast<void*>(pthread_join(reinterpret_cast<pthread_t>(arg), NULL));
+  return reinterpret_cast<void*>(pthread_join(reinterpret_cast<pthread_t>(arg), nullptr));
 }
 
 static void AssertDetached(pthread_t t, bool is_detached) {
@@ -241,15 +241,15 @@
 }
 
 static void MakeDeadThread(pthread_t& t) {
-  ASSERT_EQ(0, pthread_create(&t, NULL, IdFn, NULL));
-  ASSERT_EQ(0, pthread_join(t, NULL));
+  ASSERT_EQ(0, pthread_create(&t, nullptr, IdFn, nullptr));
+  ASSERT_EQ(0, pthread_join(t, nullptr));
 }
 
 TEST(pthread, pthread_create) {
   void* expected_result = reinterpret_cast<void*>(123);
   // Can we create a thread?
   pthread_t t;
-  ASSERT_EQ(0, pthread_create(&t, NULL, IdFn, expected_result));
+  ASSERT_EQ(0, pthread_create(&t, nullptr, IdFn, expected_result));
   // If we join, do we get the expected value back?
   void* result;
   ASSERT_EQ(0, pthread_join(t, &result));
@@ -262,32 +262,32 @@
   ASSERT_EQ(0, pthread_attr_setstacksize(&attributes, static_cast<size_t>(-1) & ~(getpagesize() - 1)));
 
   pthread_t t;
-  ASSERT_EQ(EAGAIN, pthread_create(&t, &attributes, IdFn, NULL));
+  ASSERT_EQ(EAGAIN, pthread_create(&t, &attributes, IdFn, nullptr));
 }
 
 TEST(pthread, pthread_no_join_after_detach) {
   SpinFunctionHelper spin_helper;
 
   pthread_t t1;
-  ASSERT_EQ(0, pthread_create(&t1, NULL, spin_helper.GetFunction(), NULL));
+  ASSERT_EQ(0, pthread_create(&t1, nullptr, spin_helper.GetFunction(), nullptr));
 
   // After a pthread_detach...
   ASSERT_EQ(0, pthread_detach(t1));
   AssertDetached(t1, true);
 
   // ...pthread_join should fail.
-  ASSERT_EQ(EINVAL, pthread_join(t1, NULL));
+  ASSERT_EQ(EINVAL, pthread_join(t1, nullptr));
 }
 
 TEST(pthread, pthread_no_op_detach_after_join) {
   SpinFunctionHelper spin_helper;
 
   pthread_t t1;
-  ASSERT_EQ(0, pthread_create(&t1, NULL, spin_helper.GetFunction(), NULL));
+  ASSERT_EQ(0, pthread_create(&t1, nullptr, spin_helper.GetFunction(), nullptr));
 
   // If thread 2 is already waiting to join thread 1...
   pthread_t t2;
-  ASSERT_EQ(0, pthread_create(&t2, NULL, JoinFn, reinterpret_cast<void*>(t1)));
+  ASSERT_EQ(0, pthread_create(&t2, nullptr, JoinFn, reinterpret_cast<void*>(t1)));
 
   sleep(1); // (Give t2 a chance to call pthread_join.)
 
@@ -307,7 +307,7 @@
 }
 
 TEST(pthread, pthread_join_self) {
-  ASSERT_EQ(EDEADLK, pthread_join(pthread_self(), NULL));
+  ASSERT_EQ(EDEADLK, pthread_join(pthread_self(), nullptr));
 }
 
 struct TestBug37410 {
@@ -317,18 +317,18 @@
   static void main() {
     TestBug37410 data;
     data.main_thread = pthread_self();
-    ASSERT_EQ(0, pthread_mutex_init(&data.mutex, NULL));
+    ASSERT_EQ(0, pthread_mutex_init(&data.mutex, nullptr));
     ASSERT_EQ(0, pthread_mutex_lock(&data.mutex));
 
     pthread_t t;
-    ASSERT_EQ(0, pthread_create(&t, NULL, TestBug37410::thread_fn, reinterpret_cast<void*>(&data)));
+    ASSERT_EQ(0, pthread_create(&t, nullptr, TestBug37410::thread_fn, reinterpret_cast<void*>(&data)));
 
     // Wait for the thread to be running...
     ASSERT_EQ(0, pthread_mutex_lock(&data.mutex));
     ASSERT_EQ(0, pthread_mutex_unlock(&data.mutex));
 
     // ...and exit.
-    pthread_exit(NULL);
+    pthread_exit(nullptr);
   }
 
  private:
@@ -339,9 +339,9 @@
     pthread_mutex_unlock(&data->mutex);
 
     // And wait for the main thread to exit.
-    pthread_join(data->main_thread, NULL);
+    pthread_join(data->main_thread, nullptr);
 
-    return NULL;
+    return nullptr;
   }
 };
 
@@ -365,29 +365,29 @@
   // Check that SIGUSR1 isn't blocked.
   sigset_t original_set;
   sigemptyset(&original_set);
-  ASSERT_EQ(0, pthread_sigmask(SIG_BLOCK, NULL, &original_set));
+  ASSERT_EQ(0, pthread_sigmask(SIG_BLOCK, nullptr, &original_set));
   ASSERT_FALSE(sigismember(&original_set, SIGUSR1));
 
   // Block SIGUSR1.
   sigset_t set;
   sigemptyset(&set);
   sigaddset(&set, SIGUSR1);
-  ASSERT_EQ(0, pthread_sigmask(SIG_BLOCK, &set, NULL));
+  ASSERT_EQ(0, pthread_sigmask(SIG_BLOCK, &set, nullptr));
 
   // Check that SIGUSR1 is blocked.
   sigset_t final_set;
   sigemptyset(&final_set);
-  ASSERT_EQ(0, pthread_sigmask(SIG_BLOCK, NULL, &final_set));
+  ASSERT_EQ(0, pthread_sigmask(SIG_BLOCK, nullptr, &final_set));
   ASSERT_TRUE(sigismember(&final_set, SIGUSR1));
   // ...and that sigprocmask agrees with pthread_sigmask.
   sigemptyset(&final_set);
-  ASSERT_EQ(0, sigprocmask(SIG_BLOCK, NULL, &final_set));
+  ASSERT_EQ(0, sigprocmask(SIG_BLOCK, nullptr, &final_set));
   ASSERT_TRUE(sigismember(&final_set, SIGUSR1));
 
   // Spawn a thread that calls sigwait and tells us what it received.
   pthread_t signal_thread;
   int received_signal = -1;
-  ASSERT_EQ(0, pthread_create(&signal_thread, NULL, SignalHandlerFn, &received_signal));
+  ASSERT_EQ(0, pthread_create(&signal_thread, nullptr, SignalHandlerFn, &received_signal));
 
   // Send that thread SIGUSR1.
   pthread_kill(signal_thread, SIGUSR1);
@@ -399,36 +399,36 @@
   ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(join_result));
 
   // Restore the original signal mask.
-  ASSERT_EQ(0, pthread_sigmask(SIG_SETMASK, &original_set, NULL));
+  ASSERT_EQ(0, pthread_sigmask(SIG_SETMASK, &original_set, nullptr));
 }
 
 TEST(pthread, pthread_sigmask64_SIGTRMIN) {
   // Check that SIGRTMIN isn't blocked.
   sigset64_t original_set;
   sigemptyset64(&original_set);
-  ASSERT_EQ(0, pthread_sigmask64(SIG_BLOCK, NULL, &original_set));
+  ASSERT_EQ(0, pthread_sigmask64(SIG_BLOCK, nullptr, &original_set));
   ASSERT_FALSE(sigismember64(&original_set, SIGRTMIN));
 
   // Block SIGRTMIN.
   sigset64_t set;
   sigemptyset64(&set);
   sigaddset64(&set, SIGRTMIN);
-  ASSERT_EQ(0, pthread_sigmask64(SIG_BLOCK, &set, NULL));
+  ASSERT_EQ(0, pthread_sigmask64(SIG_BLOCK, &set, nullptr));
 
   // Check that SIGRTMIN is blocked.
   sigset64_t final_set;
   sigemptyset64(&final_set);
-  ASSERT_EQ(0, pthread_sigmask64(SIG_BLOCK, NULL, &final_set));
+  ASSERT_EQ(0, pthread_sigmask64(SIG_BLOCK, nullptr, &final_set));
   ASSERT_TRUE(sigismember64(&final_set, SIGRTMIN));
   // ...and that sigprocmask64 agrees with pthread_sigmask64.
   sigemptyset64(&final_set);
-  ASSERT_EQ(0, sigprocmask64(SIG_BLOCK, NULL, &final_set));
+  ASSERT_EQ(0, sigprocmask64(SIG_BLOCK, nullptr, &final_set));
   ASSERT_TRUE(sigismember64(&final_set, SIGRTMIN));
 
   // Spawn a thread that calls sigwait64 and tells us what it received.
   pthread_t signal_thread;
   int received_signal = -1;
-  ASSERT_EQ(0, pthread_create(&signal_thread, NULL, SignalHandlerFn, &received_signal));
+  ASSERT_EQ(0, pthread_create(&signal_thread, nullptr, SignalHandlerFn, &received_signal));
 
   // Send that thread SIGRTMIN.
   pthread_kill(signal_thread, SIGRTMIN);
@@ -440,7 +440,7 @@
   ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(join_result));
 
   // Restore the original signal mask.
-  ASSERT_EQ(0, pthread_sigmask64(SIG_SETMASK, &original_set, NULL));
+  ASSERT_EQ(0, pthread_sigmask64(SIG_SETMASK, &original_set, nullptr));
 }
 
 static void test_pthread_setname_np__pthread_getname_np(pthread_t t) {
@@ -555,7 +555,7 @@
   SpinFunctionHelper spin_helper;
 
   pthread_t t;
-  ASSERT_EQ(0, pthread_create(&t, NULL, spin_helper.GetFunction(), NULL));
+  ASSERT_EQ(0, pthread_create(&t, nullptr, spin_helper.GetFunction(), nullptr));
 
   clockid_t c;
   ASSERT_EQ(0, pthread_getcpuclockid(t, &c));
@@ -627,12 +627,12 @@
   pthread_t dead_thread;
   MakeDeadThread(dead_thread);
 
-  EXPECT_DEATH(pthread_join(dead_thread, NULL), "invalid pthread_t");
+  EXPECT_DEATH(pthread_join(dead_thread, nullptr), "invalid pthread_t");
 }
 
 TEST_F(pthread_DeathTest, pthread_join__null_thread) {
   pthread_t null_thread = 0;
-  EXPECT_EQ(ESRCH, pthread_join(null_thread, NULL));
+  EXPECT_EQ(ESRCH, pthread_join(null_thread, nullptr));
 }
 
 TEST_F(pthread_DeathTest, pthread_kill__no_such_thread) {
@@ -651,15 +651,15 @@
   SpinFunctionHelper spin_helper;
 
   pthread_t t1;
-  ASSERT_EQ(0, pthread_create(&t1, NULL, spin_helper.GetFunction(), NULL));
+  ASSERT_EQ(0, pthread_create(&t1, nullptr, spin_helper.GetFunction(), nullptr));
 
   pthread_t t2;
-  ASSERT_EQ(0, pthread_create(&t2, NULL, JoinFn, reinterpret_cast<void*>(t1)));
+  ASSERT_EQ(0, pthread_create(&t2, nullptr, JoinFn, reinterpret_cast<void*>(t1)));
 
   sleep(1); // (Give t2 a chance to call pthread_join.)
 
   // Multiple joins to the same thread should fail.
-  ASSERT_EQ(EINVAL, pthread_join(t1, NULL));
+  ASSERT_EQ(EINVAL, pthread_join(t1, nullptr));
 
   spin_helper.UnSpin();
 
@@ -674,15 +674,15 @@
   // If the joiner unmapped the thread's stack, that could lead to SIGSEGV in the thread.
   for (size_t i = 0; i < 1024; ++i) {
     size_t stack_size = 640*1024;
-    void* stack = mmap(NULL, stack_size, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE, -1, 0);
+    void* stack = mmap(nullptr, stack_size, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE, -1, 0);
 
     pthread_attr_t a;
     pthread_attr_init(&a);
     pthread_attr_setstack(&a, stack, stack_size);
 
     pthread_t t;
-    ASSERT_EQ(0, pthread_create(&t, &a, IdFn, NULL));
-    ASSERT_EQ(0, pthread_join(t, NULL));
+    ASSERT_EQ(0, pthread_create(&t, &a, IdFn, nullptr));
+    ASSERT_EQ(0, pthread_join(t, nullptr));
     ASSERT_EQ(0, munmap(stack, stack_size));
   }
 }
@@ -691,14 +691,14 @@
   pthread_attr_t attributes;
   pthread_getattr_np(pthread_self(), &attributes);
   pthread_attr_getguardsize(&attributes, reinterpret_cast<size_t*>(arg));
-  return NULL;
+  return nullptr;
 }
 
 static size_t GetActualGuardSize(const pthread_attr_t& attributes) {
   size_t result;
   pthread_t t;
   pthread_create(&t, &attributes, GetActualGuardSizeFn, &result);
-  pthread_join(t, NULL);
+  pthread_join(t, nullptr);
   return result;
 }
 
@@ -706,14 +706,14 @@
   pthread_attr_t attributes;
   pthread_getattr_np(pthread_self(), &attributes);
   pthread_attr_getstacksize(&attributes, reinterpret_cast<size_t*>(arg));
-  return NULL;
+  return nullptr;
 }
 
 static size_t GetActualStackSize(const pthread_attr_t& attributes) {
   size_t result;
   pthread_t t;
   pthread_create(&t, &attributes, GetActualStackSizeFn, &result);
-  pthread_join(t, NULL);
+  pthread_join(t, nullptr);
   return result;
 }
 
@@ -827,13 +827,13 @@
 TEST(pthread, pthread_rwlock_init_same_as_PTHREAD_RWLOCK_INITIALIZER) {
   pthread_rwlock_t lock1 = PTHREAD_RWLOCK_INITIALIZER;
   pthread_rwlock_t lock2;
-  ASSERT_EQ(0, pthread_rwlock_init(&lock2, NULL));
+  ASSERT_EQ(0, pthread_rwlock_init(&lock2, nullptr));
   ASSERT_EQ(0, memcmp(&lock1, &lock2, sizeof(lock1)));
 }
 
 TEST(pthread, pthread_rwlock_smoke) {
   pthread_rwlock_t l;
-  ASSERT_EQ(0, pthread_rwlock_init(&l, NULL));
+  ASSERT_EQ(0, pthread_rwlock_init(&l, nullptr));
 
   // Single read lock
   ASSERT_EQ(0, pthread_rwlock_rdlock(&l));
@@ -911,7 +911,7 @@
 
 static void test_pthread_rwlock_reader_wakeup_writer(std::function<int (pthread_rwlock_t*)> lock_function) {
   RwlockWakeupHelperArg wakeup_arg;
-  ASSERT_EQ(0, pthread_rwlock_init(&wakeup_arg.lock, NULL));
+  ASSERT_EQ(0, pthread_rwlock_init(&wakeup_arg.lock, nullptr));
   ASSERT_EQ(0, pthread_rwlock_rdlock(&wakeup_arg.lock));
   wakeup_arg.progress = RwlockWakeupHelperArg::LOCK_INITIALIZED;
   wakeup_arg.tid = 0;
@@ -919,7 +919,7 @@
   wakeup_arg.lock_function = lock_function;
 
   pthread_t thread;
-  ASSERT_EQ(0, pthread_create(&thread, NULL,
+  ASSERT_EQ(0, pthread_create(&thread, nullptr,
     reinterpret_cast<void* (*)(void*)>(pthread_rwlock_wakeup_helper), &wakeup_arg));
   WaitUntilThreadSleep(wakeup_arg.tid);
   ASSERT_EQ(RwlockWakeupHelperArg::LOCK_WAITING, wakeup_arg.progress);
@@ -927,7 +927,7 @@
   wakeup_arg.progress = RwlockWakeupHelperArg::LOCK_RELEASED;
   ASSERT_EQ(0, pthread_rwlock_unlock(&wakeup_arg.lock));
 
-  ASSERT_EQ(0, pthread_join(thread, NULL));
+  ASSERT_EQ(0, pthread_join(thread, nullptr));
   ASSERT_EQ(RwlockWakeupHelperArg::LOCK_ACCESSED, wakeup_arg.progress);
   ASSERT_EQ(0, pthread_rwlock_destroy(&wakeup_arg.lock));
 }
@@ -960,7 +960,7 @@
 
 static void test_pthread_rwlock_writer_wakeup_reader(std::function<int (pthread_rwlock_t*)> lock_function) {
   RwlockWakeupHelperArg wakeup_arg;
-  ASSERT_EQ(0, pthread_rwlock_init(&wakeup_arg.lock, NULL));
+  ASSERT_EQ(0, pthread_rwlock_init(&wakeup_arg.lock, nullptr));
   ASSERT_EQ(0, pthread_rwlock_wrlock(&wakeup_arg.lock));
   wakeup_arg.progress = RwlockWakeupHelperArg::LOCK_INITIALIZED;
   wakeup_arg.tid = 0;
@@ -968,7 +968,7 @@
   wakeup_arg.lock_function = lock_function;
 
   pthread_t thread;
-  ASSERT_EQ(0, pthread_create(&thread, NULL,
+  ASSERT_EQ(0, pthread_create(&thread, nullptr,
     reinterpret_cast<void* (*)(void*)>(pthread_rwlock_wakeup_helper), &wakeup_arg));
   WaitUntilThreadSleep(wakeup_arg.tid);
   ASSERT_EQ(RwlockWakeupHelperArg::LOCK_WAITING, wakeup_arg.progress);
@@ -976,7 +976,7 @@
   wakeup_arg.progress = RwlockWakeupHelperArg::LOCK_RELEASED;
   ASSERT_EQ(0, pthread_rwlock_unlock(&wakeup_arg.lock));
 
-  ASSERT_EQ(0, pthread_join(thread, NULL));
+  ASSERT_EQ(0, pthread_join(thread, nullptr));
   ASSERT_EQ(RwlockWakeupHelperArg::LOCK_ACCESSED, wakeup_arg.progress);
   ASSERT_EQ(0, pthread_rwlock_destroy(&wakeup_arg.lock));
 }
@@ -1130,14 +1130,14 @@
   void CreateWriterThread(pthread_t& thread, std::atomic<pid_t>& tid) {
     tid = 0;
     ThreadArg* arg = new ThreadArg(this, tid);
-    ASSERT_EQ(0, pthread_create(&thread, NULL,
+    ASSERT_EQ(0, pthread_create(&thread, nullptr,
                                 reinterpret_cast<void* (*)(void*)>(WriterThreadFn), arg));
   }
 
   void CreateReaderThread(pthread_t& thread, std::atomic<pid_t>& tid) {
     tid = 0;
     ThreadArg* arg = new ThreadArg(this, tid);
-    ASSERT_EQ(0, pthread_create(&thread, NULL,
+    ASSERT_EQ(0, pthread_create(&thread, nullptr,
                                 reinterpret_cast<void* (*)(void*)>(ReaderThreadFn), arg));
   }
 
@@ -1185,10 +1185,10 @@
   pthread_t reader_thread;
   std::atomic<pid_t> reader_tid;
   helper.CreateReaderThread(reader_thread, reader_tid);
-  ASSERT_EQ(0, pthread_join(reader_thread, NULL));
+  ASSERT_EQ(0, pthread_join(reader_thread, nullptr));
 
   ASSERT_EQ(0, pthread_rwlock_unlock(&helper.lock));
-  ASSERT_EQ(0, pthread_join(writer_thread, NULL));
+  ASSERT_EQ(0, pthread_join(writer_thread, nullptr));
 }
 
 TEST(pthread, pthread_rwlock_kind_PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP) {
@@ -1206,8 +1206,8 @@
   WaitUntilThreadSleep(reader_tid);
 
   ASSERT_EQ(0, pthread_rwlock_unlock(&helper.lock));
-  ASSERT_EQ(0, pthread_join(writer_thread, NULL));
-  ASSERT_EQ(0, pthread_join(reader_thread, NULL));
+  ASSERT_EQ(0, pthread_join(writer_thread, nullptr));
+  ASSERT_EQ(0, pthread_join(reader_thread, nullptr));
 }
 
 static int g_once_fn_call_count = 0;
@@ -1366,7 +1366,7 @@
   void StartWaitingThread(std::function<int (pthread_cond_t* cond, pthread_mutex_t* mutex)> wait_function) {
     progress = INITIALIZED;
     this->wait_function = wait_function;
-    ASSERT_EQ(0, pthread_create(&thread, NULL, reinterpret_cast<void* (*)(void*)>(WaitThreadFn), this));
+    ASSERT_EQ(0, pthread_create(&thread, nullptr, reinterpret_cast<void* (*)(void*)>(WaitThreadFn), this));
     while (progress != WAITING) {
       usleep(5000);
     }
@@ -1517,7 +1517,7 @@
   // We do not use "[stack]" label because in native-bridge environment it is not
   // guaranteed to point to the right stack. A native bridge implementation may
   // keep separate stack for the guest code.
-  void* maps_stack_hi = NULL;
+  void* maps_stack_hi = nullptr;
   std::vector<map_record> maps;
   ASSERT_TRUE(Maps::parse_maps(&maps));
   uintptr_t stack_address = reinterpret_cast<uintptr_t>(&maps_stack_hi);
@@ -1621,7 +1621,7 @@
   ASSERT_EQ(getpid(), syscall(__NR_gettid));
 
   const size_t sig_stack_size = 16 * 1024;
-  void* sig_stack = mmap(NULL, sig_stack_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS,
+  void* sig_stack = mmap(nullptr, sig_stack_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS,
                          -1, 0);
   ASSERT_NE(MAP_FAILED, sig_stack);
   stack_t ss;
@@ -1667,10 +1667,10 @@
 // [stack_base, stack_base + stack_size). see b/18908062.
 TEST(pthread, pthread_attr_getstack_18908062) {
   pthread_t t;
-  ASSERT_EQ(0, pthread_create(&t, NULL,
+  ASSERT_EQ(0, pthread_create(&t, nullptr,
             reinterpret_cast<void* (*)(void*)>(pthread_attr_getstack_18908062_helper),
-            NULL));
-  ASSERT_EQ(0, pthread_join(t, NULL));
+            nullptr));
+  ASSERT_EQ(0, pthread_join(t, nullptr));
 }
 
 #if defined(__BIONIC__)
@@ -1682,7 +1682,7 @@
   // Wait for our parent to call pthread_gettid_np on us before exiting.
   pthread_mutex_lock(&pthread_gettid_np_mutex);
   pthread_mutex_unlock(&pthread_gettid_np_mutex);
-  return NULL;
+  return nullptr;
 }
 #endif
 
@@ -1696,13 +1696,13 @@
 
   pid_t t_gettid_result;
   pthread_t t;
-  pthread_create(&t, NULL, pthread_gettid_np_helper, &t_gettid_result);
+  pthread_create(&t, nullptr, pthread_gettid_np_helper, &t_gettid_result);
 
   pid_t t_pthread_gettid_np_result = pthread_gettid_np(t);
 
   // Release the other thread and wait for it to exit.
   pthread_mutex_unlock(&pthread_gettid_np_mutex);
-  ASSERT_EQ(0, pthread_join(t, NULL));
+  ASSERT_EQ(0, pthread_join(t, nullptr));
 
   ASSERT_EQ(t_gettid_result, t_pthread_gettid_np_result);
 #else
@@ -1721,15 +1721,15 @@
 }
 
 static void PthreadCleanupTester() {
-  pthread_cleanup_push(CountCleanupRoutine, NULL);
-  pthread_cleanup_push(CountCleanupRoutine, NULL);
-  pthread_cleanup_push(AbortCleanupRoutine, NULL);
+  pthread_cleanup_push(CountCleanupRoutine, nullptr);
+  pthread_cleanup_push(CountCleanupRoutine, nullptr);
+  pthread_cleanup_push(AbortCleanupRoutine, nullptr);
 
   pthread_cleanup_pop(0); // Pop the abort without executing it.
   pthread_cleanup_pop(1); // Pop one count while executing it.
   ASSERT_EQ(1U, cleanup_counter);
   // Exit while the other count is still on the cleanup stack.
-  pthread_exit(NULL);
+  pthread_exit(nullptr);
 
   // Calls to pthread_cleanup_pop/pthread_cleanup_push must always be balanced.
   pthread_cleanup_pop(0);
@@ -1737,13 +1737,13 @@
 
 static void* PthreadCleanupStartRoutine(void*) {
   PthreadCleanupTester();
-  return NULL;
+  return nullptr;
 }
 
 TEST(pthread, pthread_cleanup_push__pthread_cleanup_pop) {
   pthread_t t;
-  ASSERT_EQ(0, pthread_create(&t, NULL, PthreadCleanupStartRoutine, NULL));
-  ASSERT_EQ(0, pthread_join(t, NULL));
+  ASSERT_EQ(0, pthread_create(&t, nullptr, PthreadCleanupStartRoutine, nullptr));
+  ASSERT_EQ(0, pthread_join(t, nullptr));
   ASSERT_EQ(2U, cleanup_counter);
 }
 
@@ -1956,7 +1956,7 @@
     tid = 0;
 
     pthread_t thread;
-    ASSERT_EQ(0, pthread_create(&thread, NULL,
+    ASSERT_EQ(0, pthread_create(&thread, nullptr,
       reinterpret_cast<void* (*)(void*)>(MutexWakeupHelper::thread_fn), this));
 
     WaitUntilThreadSleep(tid);
@@ -1965,7 +1965,7 @@
     progress = LOCK_RELEASED;
     ASSERT_EQ(0, pthread_mutex_unlock(&m.lock));
 
-    ASSERT_EQ(0, pthread_join(thread, NULL));
+    ASSERT_EQ(0, pthread_join(thread, nullptr));
     ASSERT_EQ(LOCK_ACCESSED, progress);
   }
 };
@@ -2054,7 +2054,7 @@
     child_tid = 0;
 
     pthread_t thread;
-    ASSERT_EQ(0, pthread_create(&thread, NULL,
+    ASSERT_EQ(0, pthread_create(&thread, nullptr,
               reinterpret_cast<void* (*)(void*)>(PIMutexWakeupHelper::thread_fn), this));
 
     WaitUntilThreadSleep(child_tid);
@@ -2081,7 +2081,7 @@
 TEST(pthread, pthread_mutex_owner_tid_limit) {
 #if defined(__BIONIC__) && !defined(__LP64__)
   FILE* fp = fopen("/proc/sys/kernel/pid_max", "r");
-  ASSERT_TRUE(fp != NULL);
+  ASSERT_TRUE(fp != nullptr);
   long pid_max;
   ASSERT_EQ(1, fscanf(fp, "%ld", &pid_max));
   fclose(fp);
@@ -2168,7 +2168,7 @@
   };
 
   pthread_t thread;
-  ASSERT_EQ(0, pthread_create(&thread, NULL, ThreadFn, &thread_args));
+  ASSERT_EQ(0, pthread_create(&thread, nullptr, ThreadFn, &thread_args));
   void* result;
   ASSERT_EQ(0, pthread_join(thread, &result));
   ASSERT_EQ(ETIMEDOUT, reinterpret_cast<intptr_t>(result));
@@ -2242,21 +2242,21 @@
   StrictAlignmentAllocator allocator;
   pthread_mutex_t* mutex = reinterpret_cast<pthread_mutex_t*>(
                              allocator.allocate(sizeof(pthread_mutex_t), 4));
-  ASSERT_EQ(0, pthread_mutex_init(mutex, NULL));
+  ASSERT_EQ(0, pthread_mutex_init(mutex, nullptr));
   ASSERT_EQ(0, pthread_mutex_lock(mutex));
   ASSERT_EQ(0, pthread_mutex_unlock(mutex));
   ASSERT_EQ(0, pthread_mutex_destroy(mutex));
 
   pthread_cond_t* cond = reinterpret_cast<pthread_cond_t*>(
                            allocator.allocate(sizeof(pthread_cond_t), 4));
-  ASSERT_EQ(0, pthread_cond_init(cond, NULL));
+  ASSERT_EQ(0, pthread_cond_init(cond, nullptr));
   ASSERT_EQ(0, pthread_cond_signal(cond));
   ASSERT_EQ(0, pthread_cond_broadcast(cond));
   ASSERT_EQ(0, pthread_cond_destroy(cond));
 
   pthread_rwlock_t* rwlock = reinterpret_cast<pthread_rwlock_t*>(
                                allocator.allocate(sizeof(pthread_rwlock_t), 4));
-  ASSERT_EQ(0, pthread_rwlock_init(rwlock, NULL));
+  ASSERT_EQ(0, pthread_rwlock_init(rwlock, nullptr));
   ASSERT_EQ(0, pthread_rwlock_rdlock(rwlock));
   ASSERT_EQ(0, pthread_rwlock_unlock(rwlock));
   ASSERT_EQ(0, pthread_rwlock_wrlock(rwlock));
diff --git a/tests/pty_test.cpp b/tests/pty_test.cpp
index 609f2dc..75f228c 100644
--- a/tests/pty_test.cpp
+++ b/tests/pty_test.cpp
@@ -31,7 +31,7 @@
   int master, slave;
   char name[32];
   struct winsize w = { 123, 456, 9999, 999 };
-  ASSERT_EQ(0, openpty(&master, &slave, name, NULL, &w));
+  ASSERT_EQ(0, openpty(&master, &slave, name, nullptr, &w));
   ASSERT_NE(-1, master);
   ASSERT_NE(-1, slave);
   ASSERT_NE(master, slave);
@@ -55,7 +55,7 @@
   pid_t sid = getsid(0);
 
   int master;
-  pid_t pid = forkpty(&master, NULL, NULL, NULL);
+  pid_t pid = forkpty(&master, nullptr, nullptr, nullptr);
   ASSERT_NE(-1, pid);
 
   if (pid == 0) {
diff --git a/tests/regex_test.cpp b/tests/regex_test.cpp
index 0e7f8dd..0d88261 100644
--- a/tests/regex_test.cpp
+++ b/tests/regex_test.cpp
@@ -23,8 +23,8 @@
   // A quick test of all the regex functions.
   regex_t re;
   ASSERT_EQ(0, regcomp(&re, "ab*c", 0));
-  ASSERT_EQ(0, regexec(&re, "abbbc", 0, NULL, 0));
-  ASSERT_EQ(REG_NOMATCH, regexec(&re, "foo", 0, NULL, 0));
+  ASSERT_EQ(0, regexec(&re, "abbbc", 0, nullptr, 0));
+  ASSERT_EQ(REG_NOMATCH, regexec(&re, "foo", 0, nullptr, 0));
 
   char buf[80];
   regerror(REG_NOMATCH, &re, buf, sizeof(buf));
diff --git a/tests/sched_test.cpp b/tests/sched_test.cpp
index e70528e..9184026 100644
--- a/tests/sched_test.cpp
+++ b/tests/sched_test.cpp
@@ -56,7 +56,7 @@
   uintptr_t fake_child_stack[16];
   errno = 0;
   // If CLONE_THREAD is set, CLONE_SIGHAND must be set too.
-  ASSERT_EQ(-1, clone(child_fn, &fake_child_stack[16], CLONE_THREAD, NULL));
+  ASSERT_EQ(-1, clone(child_fn, &fake_child_stack[16], CLONE_THREAD, nullptr));
   ASSERT_EQ(EINVAL, errno);
 }
 
diff --git a/tests/search_test.cpp b/tests/search_test.cpp
index d5ab67c..1509199 100644
--- a/tests/search_test.cpp
+++ b/tests/search_test.cpp
@@ -151,18 +151,18 @@
 
   // Linear (not circular).
 
-  insque(&zero, NULL);
+  insque(&zero, nullptr);
   insque(&one, &zero);
   insque(&two, &one);
 
   int expected = 0;
-  for (q_node* q = &zero; q != NULL; q = q->next) {
+  for (q_node* q = &zero; q != nullptr; q = q->next) {
     ASSERT_EQ(expected, q->i);
     ++expected;
   }
   ASSERT_EQ(3, expected);
 
-  for (q_node* q = &two; q != NULL; q = q->prev) {
+  for (q_node* q = &two; q != nullptr; q = q->prev) {
     --expected;
     ASSERT_EQ(expected, q->i);
   }
diff --git a/tests/semaphore_test.cpp b/tests/semaphore_test.cpp
index 607e37f..10d99ea 100644
--- a/tests/semaphore_test.cpp
+++ b/tests/semaphore_test.cpp
@@ -78,9 +78,9 @@
   ASSERT_EQ(0, sem_init(&s, 0, 0));
 
   pthread_t t1, t2, t3;
-  ASSERT_EQ(0, pthread_create(&t1, NULL, SemWaitThreadFn, &s));
-  ASSERT_EQ(0, pthread_create(&t2, NULL, SemWaitThreadFn, &s));
-  ASSERT_EQ(0, pthread_create(&t3, NULL, SemWaitThreadFn, &s));
+  ASSERT_EQ(0, pthread_create(&t1, nullptr, SemWaitThreadFn, &s));
+  ASSERT_EQ(0, pthread_create(&t2, nullptr, SemWaitThreadFn, &s));
+  ASSERT_EQ(0, pthread_create(&t3, nullptr, SemWaitThreadFn, &s));
 
   ASSERT_EQ(0, sem_post(&s));
   ASSERT_EQ(0, sem_post(&s));
diff --git a/tests/setjmp_test.cpp b/tests/setjmp_test.cpp
index a49e910..05339a6 100644
--- a/tests/setjmp_test.cpp
+++ b/tests/setjmp_test.cpp
@@ -84,7 +84,7 @@
 
 void AssertSigmaskEquals(const sigset64_t& expected) {
   sigset64_t actual;
-  sigprocmask64(SIG_SETMASK, NULL, &actual);
+  sigprocmask64(SIG_SETMASK, nullptr, &actual);
   size_t end = sizeof(expected) * 8;
   for (size_t i = 1; i <= end; ++i) {
     EXPECT_EQ(sigismember64(&expected, i), sigismember64(&actual, i)) << i;
@@ -99,7 +99,7 @@
   sigprocmask64(SIG_SETMASK, &ss.one, nullptr);
   jmp_buf jb;
   if (_setjmp(jb) == 0) {
-    sigprocmask64(SIG_SETMASK, &ss.two, NULL);
+    sigprocmask64(SIG_SETMASK, &ss.two, nullptr);
     _longjmp(jb, 1);
     FAIL(); // Unreachable.
   } else {
@@ -117,7 +117,7 @@
   sigprocmask64(SIG_SETMASK, &ss.one, nullptr);
   jmp_buf jb;
   if (setjmp(jb) == 0) {
-    sigprocmask64(SIG_SETMASK, &ss.two, NULL);
+    sigprocmask64(SIG_SETMASK, &ss.two, nullptr);
     longjmp(jb, 1);
     FAIL(); // Unreachable.
   } else {
@@ -139,7 +139,7 @@
   sigprocmask64(SIG_SETMASK, &ss.one, nullptr);
   sigjmp_buf sjb;
   if (sigsetjmp(sjb, 0) == 0) {
-    sigprocmask64(SIG_SETMASK, &ss.two, NULL);
+    sigprocmask64(SIG_SETMASK, &ss.two, nullptr);
     siglongjmp(sjb, 1);
     FAIL(); // Unreachable.
   } else {
@@ -155,7 +155,7 @@
   sigprocmask64(SIG_SETMASK, &ss.one, nullptr);
   sigjmp_buf sjb;
   if (sigsetjmp(sjb, 1) == 0) {
-    sigprocmask64(SIG_SETMASK, &ss.two, NULL);
+    sigprocmask64(SIG_SETMASK, &ss.two, nullptr);
     siglongjmp(sjb, 1);
     FAIL(); // Unreachable.
   } else {
diff --git a/tests/signal_test.cpp b/tests/signal_test.cpp
index 53c91a2..cc95ef7 100644
--- a/tests/signal_test.cpp
+++ b/tests/signal_test.cpp
@@ -37,13 +37,13 @@
 
 template <typename SigSetT>
 static void TestSigSet1(int (fn)(SigSetT*)) {
-  // NULL sigset_t*/sigset64_t*.
-  SigSetT* set_ptr = NULL;
+  // nullptr sigset_t*/sigset64_t*.
+  SigSetT* set_ptr = nullptr;
   errno = 0;
   ASSERT_EQ(-1, fn(set_ptr));
   ASSERT_EQ(EINVAL, errno);
 
-  // Non-NULL.
+  // Non-nullptr.
   SigSetT set = {};
   errno = 0;
   ASSERT_EQ(0, fn(&set));
@@ -52,8 +52,8 @@
 
 template <typename SigSetT>
 static void TestSigSet2(int (fn)(SigSetT*, int)) {
-  // NULL sigset_t*/sigset64_t*.
-  SigSetT* set_ptr = NULL;
+  // nullptr sigset_t*/sigset64_t*.
+  SigSetT* set_ptr = nullptr;
   errno = 0;
   ASSERT_EQ(-1, fn(set_ptr, SIGSEGV));
   ASSERT_EQ(EINVAL, errno);
@@ -281,9 +281,9 @@
 
   // See what's currently set for this signal.
   SigActionT original_sa = {};
-  ASSERT_EQ(0, sigaction_fn(sig, NULL, &original_sa));
-  ASSERT_TRUE(original_sa.sa_handler == NULL);
-  ASSERT_TRUE(original_sa.sa_sigaction == NULL);
+  ASSERT_EQ(0, sigaction_fn(sig, nullptr, &original_sa));
+  ASSERT_TRUE(original_sa.sa_handler == nullptr);
+  ASSERT_TRUE(original_sa.sa_sigaction == nullptr);
   ASSERT_EQ(0U, original_sa.sa_flags & ~sa_restorer);
 #ifdef SA_RESTORER
   ASSERT_EQ(bool(original_sa.sa_flags & sa_restorer), bool(original_sa.sa_restorer));
@@ -295,11 +295,11 @@
   sigaddset_fn(&sa.sa_mask, sig);
   sa.sa_flags = SA_ONSTACK;
   sa.sa_handler = no_op_signal_handler;
-  ASSERT_EQ(0, sigaction_fn(sig, &sa, NULL));
+  ASSERT_EQ(0, sigaction_fn(sig, &sa, nullptr));
 
   // Check that we can read it back.
   sa = {};
-  ASSERT_EQ(0, sigaction_fn(sig, NULL, &sa));
+  ASSERT_EQ(0, sigaction_fn(sig, nullptr, &sa));
   ASSERT_TRUE(sa.sa_handler == no_op_signal_handler);
   ASSERT_TRUE((void*) sa.sa_sigaction == (void*) sa.sa_handler);
   ASSERT_EQ(static_cast<unsigned>(SA_ONSTACK), sa.sa_flags & ~sa_restorer);
@@ -313,11 +313,11 @@
   sigaddset_fn(&sa.sa_mask, sig);
   sa.sa_flags = SA_ONSTACK | SA_SIGINFO;
   sa.sa_sigaction = no_op_sigaction;
-  ASSERT_EQ(0, sigaction_fn(sig, &sa, NULL));
+  ASSERT_EQ(0, sigaction_fn(sig, &sa, nullptr));
 
   // Check that we can read it back.
   sa = {};
-  ASSERT_EQ(0, sigaction_fn(sig, NULL, &sa));
+  ASSERT_EQ(0, sigaction_fn(sig, nullptr, &sa));
   ASSERT_TRUE(sa.sa_sigaction == no_op_sigaction);
   ASSERT_TRUE((void*) sa.sa_sigaction == (void*) sa.sa_handler);
   ASSERT_EQ(static_cast<unsigned>(SA_ONSTACK | SA_SIGINFO), sa.sa_flags & ~sa_restorer);
@@ -326,7 +326,7 @@
 #endif
 
   // Put everything back how it was.
-  ASSERT_EQ(0, sigaction_fn(sig, &original_sa, NULL));
+  ASSERT_EQ(0, sigaction_fn(sig, &original_sa, nullptr));
 }
 
 TEST(signal, sigaction) {
@@ -547,7 +547,7 @@
 
 TEST(signal, sys_signame) {
 #if defined(__BIONIC__)
-  ASSERT_TRUE(sys_signame[0] == NULL);
+  ASSERT_TRUE(sys_signame[0] == nullptr);
   ASSERT_STREQ("HUP", sys_signame[SIGHUP]);
 #else
   GTEST_LOG_(INFO) << "This test does nothing.\n";
@@ -555,7 +555,7 @@
 }
 
 TEST(signal, sys_siglist) {
-  ASSERT_TRUE(sys_siglist[0] == NULL);
+  ASSERT_TRUE(sys_siglist[0] == nullptr);
   ASSERT_STREQ("Hangup", sys_siglist[SIGHUP]);
 }
 
@@ -708,7 +708,7 @@
   ASSERT_EQ(EAGAIN, errno);
   ASSERT_GE(NanoTime() - start_time, 1000000);
 
-  ASSERT_EQ(0, sigprocmask(SIG_SETMASK, &original_set, NULL));
+  ASSERT_EQ(0, sigprocmask(SIG_SETMASK, &original_set, nullptr));
 }
 
 #if defined(__BIONIC__)
@@ -806,7 +806,7 @@
 
   // sighold(SIGALRM/SIGRTMIN) should add SIGALRM/SIGRTMIN to the signal mask ...
   ASSERT_EQ(0, sighold(sig));
-  ASSERT_EQ(0, sigprocmask(SIG_SETMASK, 0, &set));
+  ASSERT_EQ(0, sigprocmask(SIG_SETMASK, nullptr, &set));
   EXPECT_TRUE(sigismember(&set, sig));
 
   // ... preventing our SIGALRM/SIGRTMIN handler from running ...
@@ -819,12 +819,12 @@
 
   if (sig >= SIGRTMIN && sizeof(void*) == 8) {
     // But sigpause(SIGALRM/SIGRTMIN) shouldn't permanently unblock SIGALRM/SIGRTMIN.
-    ASSERT_EQ(0, sigprocmask(SIG_SETMASK, 0, &set));
+    ASSERT_EQ(0, sigprocmask(SIG_SETMASK, nullptr, &set));
     EXPECT_TRUE(sigismember(&set, sig));
 
     // Whereas sigrelse(SIGALRM/SIGRTMIN) should.
     ASSERT_EQ(0, sigrelse(sig));
-    ASSERT_EQ(0, sigprocmask(SIG_SETMASK, 0, &set));
+    ASSERT_EQ(0, sigprocmask(SIG_SETMASK, nullptr, &set));
     EXPECT_FALSE(sigismember(&set, sig));
   } else {
     // sigismember won't work for SIGRTMIN on LP32.
diff --git a/tests/stack_protector_test.cpp b/tests/stack_protector_test.cpp
index 5f5a241..34e3c11 100644
--- a/tests/stack_protector_test.cpp
+++ b/tests/stack_protector_test.cpp
@@ -74,14 +74,14 @@
   size_t thread_count = 9;
   for (size_t i = 1; i < thread_count; ++i) {
     pthread_t t;
-    ASSERT_EQ(0, pthread_create(&t, NULL, [](void* arg) -> void* {
+    ASSERT_EQ(0, pthread_create(&t, nullptr, [](void* arg) -> void* {
       stack_protector_checker* checker = reinterpret_cast<stack_protector_checker*>(arg);
       checker->Check();
       return nullptr;
     }, &checker));
     void* result;
     ASSERT_EQ(0, pthread_join(t, &result));
-    ASSERT_EQ(NULL, result);
+    ASSERT_EQ(nullptr, result);
   }
   ASSERT_EQ(thread_count, checker.tids.size());
 
diff --git a/tests/stdatomic_test.cpp b/tests/stdatomic_test.cpp
index 389b251..d122d2f 100644
--- a/tests/stdatomic_test.cpp
+++ b/tests/stdatomic_test.cpp
@@ -206,7 +206,7 @@
     atomic_store_explicit(&a->z, i+1, memory_order_relaxed);
     atomic_store_explicit(&a->y, i+1, memory_order_release);
   }
-  return 0;
+  return nullptr;
 }
 
 static void* reader(void* arg) {
@@ -224,13 +224,13 @@
       // Cant just ASSERT, since we are in a non-void function.
       ADD_FAILURE() << "acquire-release ordering violation: "
                     << zval << " < " << yval << ", " << xval << "\n";
-      return 0; // Only report once.
+      return nullptr; // Only report once.
     }
     if (xval < yval) {
       // Cant just ASSERT, since we are in a non-void function.
       ADD_FAILURE() << "acquire-release ordering violation: "
                     << xval << " < " << yval << ", " << zval <<  "\n";
-      return 0; // Only report once.
+      return nullptr; // Only report once.
     }
     if (repeat < repeat_limit) ++repeat;
   }
@@ -238,7 +238,7 @@
   // But if it fails to hold, this test was useless, and we have a
   // serious scheduling issue that we should probably know about.
   EXPECT_EQ(repeat, repeat_limit);
-  return 0;
+  return nullptr;
 }
 
 TEST(stdatomic, ordering) {
@@ -249,12 +249,12 @@
   atomic_init(&a.y, 0ul);
   atomic_init(&a.z, 0ul);
   pthread_t t1,t2;
-  ASSERT_EQ(0, pthread_create(&t1, 0, reader, &a));
-  ASSERT_EQ(0, pthread_create(&t2, 0, writer, &a));
+  ASSERT_EQ(0, pthread_create(&t1, nullptr, reader, &a));
+  ASSERT_EQ(0, pthread_create(&t2, nullptr, writer, &a));
   ASSERT_EQ(0, pthread_join(t1, &result));
-  EXPECT_EQ(0, result);
+  EXPECT_EQ(nullptr, result);
   ASSERT_EQ(0, pthread_join(t2, &result));
-  EXPECT_EQ(0, result);
+  EXPECT_EQ(nullptr, result);
   EXPECT_EQ(atomic_load_explicit(&a.x, memory_order_consume), BIG + 1);
   EXPECT_EQ(atomic_load_explicit(&a.y, memory_order_seq_cst), BIG + 1);
   EXPECT_EQ(atomic_load(&a.z), BIG + 1);
diff --git a/tests/stdio_ext_test.cpp b/tests/stdio_ext_test.cpp
index 849bf0b..d4616ef 100644
--- a/tests/stdio_ext_test.cpp
+++ b/tests/stdio_ext_test.cpp
@@ -93,7 +93,7 @@
 
   char buf[16];
   char* s = fgets(buf, sizeof(buf), fp);
-  ASSERT_TRUE(s != NULL);
+  ASSERT_TRUE(s != nullptr);
   ASSERT_STREQ("b\n", s);
 
   fclose(fp);
diff --git a/tests/stdio_test.cpp b/tests/stdio_test.cpp
index d499ddb..844a9c0 100644
--- a/tests/stdio_test.cpp
+++ b/tests/stdio_test.cpp
@@ -95,7 +95,7 @@
 TEST(STDIO_TEST, flockfile_18208568_regular) {
   // We never had a bug for streams other than stdin/stdout/stderr, but test anyway.
   FILE* fp = fopen("/dev/null", "w");
-  ASSERT_TRUE(fp != NULL);
+  ASSERT_TRUE(fp != nullptr);
   flockfile(fp);
   feof(fp);
   funlockfile(fp);
@@ -104,7 +104,7 @@
 
 TEST(STDIO_TEST, tmpfile_fileno_fprintf_rewind_fgets) {
   FILE* fp = tmpfile();
-  ASSERT_TRUE(fp != NULL);
+  ASSERT_TRUE(fp != nullptr);
 
   int fd = fileno(fp);
   ASSERT_NE(fd, -1);
@@ -135,7 +135,7 @@
 
   lseek(tf.fd, 0, SEEK_SET);
   FILE* tfile = fdopen(tf.fd, "r");
-  ASSERT_TRUE(tfile != NULL);
+  ASSERT_TRUE(tfile != nullptr);
 
   AssertFileIs(tfile, "hello\n");
   fclose(tfile);
@@ -143,7 +143,7 @@
 
 TEST(STDIO_TEST, getdelim) {
   FILE* fp = tmpfile();
-  ASSERT_TRUE(fp != NULL);
+  ASSERT_TRUE(fp != nullptr);
 
   const char* line_written = "This  is a test";
   int rc = fprintf(fp, "%s", line_written);
@@ -151,7 +151,7 @@
 
   rewind(fp);
 
-  char* word_read = NULL;
+  char* word_read = nullptr;
   size_t allocated_length = 0;
 
   const char* expected[] = { "This ", " ", "is ", "a ", "test" };
@@ -178,26 +178,26 @@
 
 TEST(STDIO_TEST, getdelim_invalid) {
   FILE* fp = tmpfile();
-  ASSERT_TRUE(fp != NULL);
+  ASSERT_TRUE(fp != nullptr);
 
-  char* buffer = NULL;
+  char* buffer = nullptr;
   size_t buffer_length = 0;
 
   // The first argument can't be NULL.
   errno = 0;
-  ASSERT_EQ(getdelim(NULL, &buffer_length, ' ', fp), -1);
+  ASSERT_EQ(getdelim(nullptr, &buffer_length, ' ', fp), -1);
   ASSERT_EQ(EINVAL, errno);
 
   // The second argument can't be NULL.
   errno = 0;
-  ASSERT_EQ(getdelim(&buffer, NULL, ' ', fp), -1);
+  ASSERT_EQ(getdelim(&buffer, nullptr, ' ', fp), -1);
   ASSERT_EQ(EINVAL, errno);
   fclose(fp);
 }
 
 TEST(STDIO_TEST, getdelim_directory) {
   FILE* fp = fopen("/proc", "r");
-  ASSERT_TRUE(fp != NULL);
+  ASSERT_TRUE(fp != nullptr);
   char* word_read;
   size_t allocated_length;
   ASSERT_EQ(-1, getdelim(&word_read, &allocated_length, ' ', fp));
@@ -206,7 +206,7 @@
 
 TEST(STDIO_TEST, getline) {
   FILE* fp = tmpfile();
-  ASSERT_TRUE(fp != NULL);
+  ASSERT_TRUE(fp != nullptr);
 
   const char* line_written = "This is a test for getline\n";
   const size_t line_count = 5;
@@ -218,7 +218,7 @@
 
   rewind(fp);
 
-  char* line_read = NULL;
+  char* line_read = nullptr;
   size_t allocated_length = 0;
 
   size_t read_line_count = 0;
@@ -248,19 +248,19 @@
 
 TEST(STDIO_TEST, getline_invalid) {
   FILE* fp = tmpfile();
-  ASSERT_TRUE(fp != NULL);
+  ASSERT_TRUE(fp != nullptr);
 
-  char* buffer = NULL;
+  char* buffer = nullptr;
   size_t buffer_length = 0;
 
   // The first argument can't be NULL.
   errno = 0;
-  ASSERT_EQ(getline(NULL, &buffer_length, fp), -1);
+  ASSERT_EQ(getline(nullptr, &buffer_length, fp), -1);
   ASSERT_EQ(EINVAL, errno);
 
   // The second argument can't be NULL.
   errno = 0;
-  ASSERT_EQ(getline(&buffer, NULL, fp), -1);
+  ASSERT_EQ(getline(&buffer, nullptr, fp), -1);
   ASSERT_EQ(EINVAL, errno);
   fclose(fp);
 }
@@ -300,7 +300,7 @@
 
 TEST(STDIO_TEST, snprintf_ls) {
   char buf[BUFSIZ];
-  wchar_t* ws = NULL;
+  wchar_t* ws = nullptr;
   EXPECT_EQ(8, snprintf(buf, sizeof(buf), "<%ls>", ws));
   EXPECT_STREQ("<(null)>", buf);
 
@@ -312,7 +312,7 @@
 
 TEST(STDIO_TEST, snprintf_S) { // Synonym for %ls.
   char buf[BUFSIZ];
-  wchar_t* ws = NULL;
+  wchar_t* ws = nullptr;
   EXPECT_EQ(8, snprintf(buf, sizeof(buf), "<%S>", ws));
   EXPECT_STREQ("<(null)>", buf);
 
@@ -348,7 +348,7 @@
   snprintf(buf, sizeof(buf), "a%sb", "01234");
   EXPECT_STREQ("a01234b", buf);
 
-  char* s = NULL;
+  char* s = nullptr;
   snprintf(buf, sizeof(buf), "a%sb", s);
   EXPECT_STREQ("a(null)b", buf);
 
@@ -409,7 +409,7 @@
   snprintf(buf, sizeof(buf), "a%03d:%d:%02dz", 5, 5, 5);
   EXPECT_STREQ("a005:5:05z", buf);
 
-  void* p = NULL;
+  void* p = nullptr;
   snprintf(buf, sizeof(buf), "a%d,%pz", 5, p);
 #if defined(__BIONIC__)
   EXPECT_STREQ("a5,0x0z", buf);
@@ -786,7 +786,7 @@
 }
 
 TEST(STDIO_TEST, snprintf_utf8_15439554) {
-  locale_t cloc = newlocale(LC_ALL, "C.UTF-8", 0);
+  locale_t cloc = newlocale(LC_ALL, "C.UTF-8", nullptr);
   locale_t old_locale = uselocale(cloc);
 
   // http://b/15439554
@@ -862,7 +862,7 @@
 
   // Unbuffered case where the fprintf(3) itself fails.
   ASSERT_NE(nullptr, fp = tmpfile());
-  setbuf(fp, NULL);
+  setbuf(fp, nullptr);
   ASSERT_EQ(4, fprintf(fp, "epic"));
   ASSERT_NE(-1, dup2(fd_rdonly, fileno(fp)));
   ASSERT_EQ(-1, fprintf(fp, "fail"));
@@ -881,7 +881,7 @@
 
 TEST(STDIO_TEST, popen_r) {
   FILE* fp = popen("cat /proc/version", "r");
-  ASSERT_TRUE(fp != NULL);
+  ASSERT_TRUE(fp != nullptr);
 
   char buf[16];
   char* s = fgets(buf, sizeof(buf), fp);
@@ -893,7 +893,7 @@
 
 TEST(STDIO_TEST, popen_socketpair) {
   FILE* fp = popen("cat", "r+");
-  ASSERT_TRUE(fp != NULL);
+  ASSERT_TRUE(fp != nullptr);
 
   fputs("hello\nworld\n", fp);
   fflush(fp);
@@ -909,7 +909,7 @@
 
 TEST(STDIO_TEST, popen_socketpair_shutdown) {
   FILE* fp = popen("uniq -c", "r+");
-  ASSERT_TRUE(fp != NULL);
+  ASSERT_TRUE(fp != nullptr);
 
   fputs("a\na\na\na\nb\n", fp);
   fflush(fp);
@@ -926,7 +926,7 @@
 
 TEST(STDIO_TEST, popen_return_value_0) {
   FILE* fp = popen("true", "r");
-  ASSERT_TRUE(fp != NULL);
+  ASSERT_TRUE(fp != nullptr);
   int status = pclose(fp);
   EXPECT_TRUE(WIFEXITED(status));
   EXPECT_EQ(0, WEXITSTATUS(status));
@@ -934,7 +934,7 @@
 
 TEST(STDIO_TEST, popen_return_value_1) {
   FILE* fp = popen("false", "r");
-  ASSERT_TRUE(fp != NULL);
+  ASSERT_TRUE(fp != nullptr);
   int status = pclose(fp);
   EXPECT_TRUE(WIFEXITED(status));
   EXPECT_EQ(1, WEXITSTATUS(status));
@@ -942,7 +942,7 @@
 
 TEST(STDIO_TEST, popen_return_value_signal) {
   FILE* fp = popen("kill -7 $$", "r");
-  ASSERT_TRUE(fp != NULL);
+  ASSERT_TRUE(fp != nullptr);
   int status = pclose(fp);
   EXPECT_TRUE(WIFSIGNALED(status));
   EXPECT_EQ(7, WTERMSIG(status));
@@ -950,7 +950,7 @@
 
 TEST(STDIO_TEST, getc) {
   FILE* fp = fopen("/proc/version", "r");
-  ASSERT_TRUE(fp != NULL);
+  ASSERT_TRUE(fp != nullptr);
   ASSERT_EQ('L', getc(fp));
   ASSERT_EQ('i', getc(fp));
   ASSERT_EQ('n', getc(fp));
@@ -961,7 +961,7 @@
 
 TEST(STDIO_TEST, putc) {
   FILE* fp = fopen("/proc/version", "r");
-  ASSERT_TRUE(fp != NULL);
+  ASSERT_TRUE(fp != nullptr);
   ASSERT_EQ(EOF, putc('x', fp));
   fclose(fp);
 }
@@ -1328,7 +1328,7 @@
   uselocale(LC_GLOBAL_LOCALE);
 
   FILE* fp = tmpfile();
-  ASSERT_TRUE(fp != NULL);
+  ASSERT_TRUE(fp != nullptr);
 
   wchar_t mb_one_bytes = L'h';
   wchar_t mb_two_bytes = 0x00a2;
@@ -1398,7 +1398,7 @@
 
   TemporaryFile tf;
   FILE* fp = fdopen(tf.fd, "w+");
-  ASSERT_TRUE(fp != NULL);
+  ASSERT_TRUE(fp != nullptr);
 
   wchar_t mb_two_bytes = 0x00a2;
   wchar_t mb_three_bytes = 0x20ac;
@@ -1413,7 +1413,7 @@
   fclose(fp);
 
   fp = fopen(tf.filename, "r");
-  ASSERT_TRUE(fp != NULL);
+  ASSERT_TRUE(fp != nullptr);
 
   // Store a valid position.
   fpos_t mb_two_bytes_pos;
@@ -1900,7 +1900,7 @@
   AssertCloseOnExec(fd, false);
 
   FILE* fp = fdopen(fd, "re");
-  ASSERT_TRUE(fp != NULL);
+  ASSERT_TRUE(fp != nullptr);
 
   // ...but the new one does.
   AssertCloseOnExec(fileno(fp), true);
@@ -1910,7 +1910,7 @@
 
 TEST(STDIO_TEST, freopen_CLOEXEC) {
   FILE* fp = fopen("/proc/version", "r");
-  ASSERT_TRUE(fp != NULL);
+  ASSERT_TRUE(fp != nullptr);
 
   // This FILE* doesn't have O_CLOEXEC...
   AssertCloseOnExec(fileno(fp), false);
@@ -1935,19 +1935,19 @@
 // http://b/18556607
 TEST(STDIO_TEST, fread_unbuffered_pathological_performance) {
   FILE* fp = fopen("/dev/zero", "r");
-  ASSERT_TRUE(fp != NULL);
+  ASSERT_TRUE(fp != nullptr);
 
   // Make this stream unbuffered.
-  setvbuf(fp, 0, _IONBF, 0);
+  setvbuf(fp, nullptr, _IONBF, 0);
 
   char buf[65*1024];
   memset(buf, 0xff, sizeof(buf));
 
-  time_t t0 = time(NULL);
+  time_t t0 = time(nullptr);
   for (size_t i = 0; i < 1024; ++i) {
     ASSERT_EQ(1U, fread(buf, 64*1024, 1, fp));
   }
-  time_t t1 = time(NULL);
+  time_t t1 = time(nullptr);
 
   fclose(fp);
 
diff --git a/tests/stdlib_test.cpp b/tests/stdlib_test.cpp
index 2fbd937..6e41555 100644
--- a/tests/stdlib_test.cpp
+++ b/tests/stdlib_test.cpp
@@ -281,35 +281,35 @@
 TEST(stdlib, realpath__NULL_filename) {
   errno = 0;
   // Work around the compile-time error generated by FORTIFY here.
-  const char* path = NULL;
-  char* p = realpath(path, NULL);
-  ASSERT_TRUE(p == NULL);
+  const char* path = nullptr;
+  char* p = realpath(path, nullptr);
+  ASSERT_TRUE(p == nullptr);
   ASSERT_EQ(EINVAL, errno);
 }
 
 TEST(stdlib, realpath__empty_filename) {
   errno = 0;
-  char* p = realpath("", NULL);
-  ASSERT_TRUE(p == NULL);
+  char* p = realpath("", nullptr);
+  ASSERT_TRUE(p == nullptr);
   ASSERT_EQ(ENOENT, errno);
 }
 
 TEST(stdlib, realpath__ENOENT) {
   errno = 0;
-  char* p = realpath("/this/directory/path/almost/certainly/does/not/exist", NULL);
-  ASSERT_TRUE(p == NULL);
+  char* p = realpath("/this/directory/path/almost/certainly/does/not/exist", nullptr);
+  ASSERT_TRUE(p == nullptr);
   ASSERT_EQ(ENOENT, errno);
 }
 
 TEST(stdlib, realpath__component_after_non_directory) {
   errno = 0;
-  char* p = realpath("/dev/null/.", NULL);
-  ASSERT_TRUE(p == NULL);
+  char* p = realpath("/dev/null/.", nullptr);
+  ASSERT_TRUE(p == nullptr);
   ASSERT_EQ(ENOTDIR, errno);
 
   errno = 0;
-  p = realpath("/dev/null/..", NULL);
-  ASSERT_TRUE(p == NULL);
+  p = realpath("/dev/null/..", nullptr);
+  ASSERT_TRUE(p == nullptr);
   ASSERT_EQ(ENOTDIR, errno);
 }
 
@@ -324,7 +324,7 @@
   char* p = realpath("/proc/self/exe", buf);
   ASSERT_STREQ(executable_path, p);
 
-  p = realpath("/proc/self/exe", NULL);
+  p = realpath("/proc/self/exe", nullptr);
   ASSERT_STREQ(executable_path, p);
   free(p);
 }
@@ -354,18 +354,18 @@
 
 static void* TestBug57421_child(void* arg) {
   pthread_t main_thread = reinterpret_cast<pthread_t>(arg);
-  pthread_join(main_thread, NULL);
+  pthread_join(main_thread, nullptr);
   char* value = getenv("ENVIRONMENT_VARIABLE");
-  if (value == NULL) {
+  if (value == nullptr) {
     setenv("ENVIRONMENT_VARIABLE", "value", 1);
   }
-  return NULL;
+  return nullptr;
 }
 
 static void TestBug57421_main() {
   pthread_t t;
-  ASSERT_EQ(0, pthread_create(&t, NULL, TestBug57421_child, reinterpret_cast<void*>(pthread_self())));
-  pthread_exit(NULL);
+  ASSERT_EQ(0, pthread_create(&t, nullptr, TestBug57421_child, reinterpret_cast<void*>(pthread_self())));
+  pthread_exit(nullptr);
 }
 
 // Even though this isn't really a death test, we have to say "DeathTest" here so gtest knows to
@@ -483,20 +483,20 @@
 }
 
 TEST(stdlib, strtof_2206701) {
-  ASSERT_EQ(0.0f, strtof("7.0064923216240853546186479164495e-46", NULL));
-  ASSERT_EQ(1.4e-45f, strtof("7.0064923216240853546186479164496e-46", NULL));
+  ASSERT_EQ(0.0f, strtof("7.0064923216240853546186479164495e-46", nullptr));
+  ASSERT_EQ(1.4e-45f, strtof("7.0064923216240853546186479164496e-46", nullptr));
 }
 
 TEST(stdlib, strtod_largest_subnormal) {
   // This value has been known to cause javac and java to infinite loop.
   // http://www.exploringbinary.com/java-hangs-when-converting-2-2250738585072012e-308/
-  ASSERT_EQ(2.2250738585072014e-308, strtod("2.2250738585072012e-308", NULL));
-  ASSERT_EQ(2.2250738585072014e-308, strtod("0.00022250738585072012e-304", NULL));
-  ASSERT_EQ(2.2250738585072014e-308, strtod("00000002.2250738585072012e-308", NULL));
-  ASSERT_EQ(2.2250738585072014e-308, strtod("2.225073858507201200000e-308", NULL));
-  ASSERT_EQ(2.2250738585072014e-308, strtod("2.2250738585072012e-00308", NULL));
-  ASSERT_EQ(2.2250738585072014e-308, strtod("2.22507385850720129978001e-308", NULL));
-  ASSERT_EQ(-2.2250738585072014e-308, strtod("-2.2250738585072012e-308", NULL));
+  ASSERT_EQ(2.2250738585072014e-308, strtod("2.2250738585072012e-308", nullptr));
+  ASSERT_EQ(2.2250738585072014e-308, strtod("0.00022250738585072012e-304", nullptr));
+  ASSERT_EQ(2.2250738585072014e-308, strtod("00000002.2250738585072012e-308", nullptr));
+  ASSERT_EQ(2.2250738585072014e-308, strtod("2.225073858507201200000e-308", nullptr));
+  ASSERT_EQ(2.2250738585072014e-308, strtod("2.2250738585072012e-00308", nullptr));
+  ASSERT_EQ(2.2250738585072014e-308, strtod("2.22507385850720129978001e-308", nullptr));
+  ASSERT_EQ(-2.2250738585072014e-308, strtod("-2.2250738585072012e-308", nullptr));
 }
 
 TEST(stdlib, quick_exit) {
@@ -584,7 +584,7 @@
   int fd = getpt();
   ASSERT_NE(-1, fd);
   errno = 0;
-  char* buf = NULL;
+  char* buf = nullptr;
   ASSERT_EQ(EINVAL, ptsname_r(fd, buf, 128));
   ASSERT_EQ(EINVAL, errno);
   close(fd);
@@ -635,7 +635,7 @@
   int fd = getpt();
   ASSERT_NE(-1, fd);
   errno = 0;
-  char* buf = NULL;
+  char* buf = nullptr;
   ASSERT_EQ(EINVAL, ttyname_r(fd, buf, 128));
   ASSERT_EQ(EINVAL, errno);
   close(fd);
diff --git a/tests/string_test.cpp b/tests/string_test.cpp
index 0d42b05..8bfa964 100644
--- a/tests/string_test.cpp
+++ b/tests/string_test.cpp
@@ -78,7 +78,7 @@
   ASSERT_STREQ("Unknown error 1001", strerror1001);
 
   pthread_t t;
-  ASSERT_EQ(0, pthread_create(&t, NULL, ConcurrentStrErrorFn, NULL));
+  ASSERT_EQ(0, pthread_create(&t, nullptr, ConcurrentStrErrorFn, nullptr));
   void* result;
   ASSERT_EQ(0, pthread_join(t, &result));
   ASSERT_TRUE(static_cast<bool>(result));
@@ -144,7 +144,7 @@
   ASSERT_STREQ("Unknown signal 1001", strsignal1001);
 
   pthread_t t;
-  ASSERT_EQ(0, pthread_create(&t, NULL, ConcurrentStrSignalFn, NULL));
+  ASSERT_EQ(0, pthread_create(&t, nullptr, ConcurrentStrSignalFn, nullptr));
   void* result;
   ASSERT_EQ(0, pthread_join(t, &result));
   ASSERT_TRUE(static_cast<bool>(result));
@@ -451,7 +451,7 @@
         if (seek_char == 0) {
           expected = state.ptr1 + state.len[i] - 1;
         } else {
-          expected = NULL;
+          expected = nullptr;
         }
       } else {
         state.ptr1[pos] = seek_char;
@@ -763,7 +763,7 @@
         if (seek_char == 0) {
           expected = state.ptr1 + state.len[i] - 1;
         } else {
-          expected = NULL;
+          expected = nullptr;
         }
       } else {
         state.ptr1[pos] = seek_char;
@@ -785,7 +785,7 @@
       size_t pos = random() % state.MAX_LEN;
       char* expected;
       if (pos >= state.len[i]) {
-        expected = NULL;
+        expected = nullptr;
       } else {
         state.ptr1[pos] = seek_char;
         expected = state.ptr1 + pos;
@@ -800,8 +800,8 @@
   uint8_t* buffer;
   ASSERT_EQ(0, posix_memalign(reinterpret_cast<void**>(&buffer), 64, 64));
   memset(buffer, 10, 64);
-  ASSERT_TRUE(NULL == memchr(buffer, 5, 0));
-  ASSERT_TRUE(NULL == memchr(buffer, 10, 0));
+  ASSERT_TRUE(nullptr == memchr(buffer, 5, 0));
+  ASSERT_TRUE(nullptr == memchr(buffer, 10, 0));
 }
 
 TEST(STRING_TEST, memrchr) {
@@ -814,7 +814,7 @@
       size_t pos = random() % state.MAX_LEN;
       char* expected;
       if (pos >= state.len[i]) {
-        expected = NULL;
+        expected = nullptr;
       } else {
         state.ptr1[pos] = seek_char;
         expected = state.ptr1 + pos;
@@ -935,9 +935,9 @@
   char* glob_ptr2 = reinterpret_cast<char*>(malloc(2 * sizeof(char) * len + max_alignment));
   size_t pos = 64;
 
-  ASSERT_TRUE(ptr != NULL);
-  ASSERT_TRUE(ptr1 != NULL);
-  ASSERT_TRUE(glob_ptr2 != NULL);
+  ASSERT_TRUE(ptr != nullptr);
+  ASSERT_TRUE(ptr1 != nullptr);
+  ASSERT_TRUE(glob_ptr2 != nullptr);
 
   for (int i = 0; i < 5; i++) {
     char* ptr2 = glob_ptr2 + alignments[i];
@@ -966,10 +966,10 @@
 
 TEST(STRING_TEST, memmove_check) {
   char* buffer = reinterpret_cast<char*>(malloc(MEMMOVE_DATA_SIZE));
-  ASSERT_TRUE(buffer != NULL);
+  ASSERT_TRUE(buffer != nullptr);
 
   char* src_data = reinterpret_cast<char*>(malloc(MEMMOVE_DATA_SIZE));
-  ASSERT_TRUE(src_data != NULL);
+  ASSERT_TRUE(src_data != nullptr);
   // Initialize to a known pattern to copy into src for each test and
   // to compare dst against.
   for (size_t i = 0; i < MEMMOVE_DATA_SIZE; i++) {
diff --git a/tests/strings_test.cpp b/tests/strings_test.cpp
index 1716843..ac327d4 100644
--- a/tests/strings_test.cpp
+++ b/tests/strings_test.cpp
@@ -45,7 +45,7 @@
 }
 
 TEST(STRINGS_TEST, strcasecmp_l) {
-  locale_t l = newlocale(LC_ALL, "C", 0);
+  locale_t l = newlocale(LC_ALL, "C", nullptr);
   ASSERT_EQ(0, strcasecmp_l("hello", "HELLO", l));
   ASSERT_LT(strcasecmp_l("hello1", "hello2", l), 0);
   ASSERT_GT(strcasecmp_l("hello2", "hello1", l), 0);
@@ -60,7 +60,7 @@
 }
 
 TEST(STRINGS_TEST, strncasecmp_l) {
-  locale_t l = newlocale(LC_ALL, "C", 0);
+  locale_t l = newlocale(LC_ALL, "C", nullptr);
   ASSERT_EQ(0, strncasecmp_l("hello", "HELLO", 3, l));
   ASSERT_EQ(0, strncasecmp_l("abcXX", "ABCYY", 3, l));
   ASSERT_LT(strncasecmp_l("hello1", "hello2", 6, l), 0);
diff --git a/tests/sys_epoll_test.cpp b/tests/sys_epoll_test.cpp
index 7233ccc..18cf380 100644
--- a/tests/sys_epoll_test.cpp
+++ b/tests/sys_epoll_test.cpp
@@ -33,11 +33,11 @@
   ASSERT_EQ(0, epoll_wait(epoll_fd, events, 1, 1));
 
   // epoll_pwait without a sigset (which is equivalent to epoll_wait).
-  ASSERT_EQ(0, epoll_pwait(epoll_fd, events, 1, 1, NULL));
+  ASSERT_EQ(0, epoll_pwait(epoll_fd, events, 1, 1, nullptr));
 
 #if defined(__BIONIC__)
   // epoll_pwait64 without a sigset (which is equivalent to epoll_wait).
-  ASSERT_EQ(0, epoll_pwait64(epoll_fd, events, 1, 1, NULL));
+  ASSERT_EQ(0, epoll_pwait64(epoll_fd, events, 1, 1, nullptr));
 #endif
 
   // epoll_pwait with a sigset.
diff --git a/tests/sys_mman_test.cpp b/tests/sys_mman_test.cpp
index e44bfed..22dc383 100644
--- a/tests/sys_mman_test.cpp
+++ b/tests/sys_mman_test.cpp
@@ -24,13 +24,13 @@
 #include "TemporaryFile.h"
 
 TEST(sys_mman, mmap_std) {
-  void* map = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
+  void* map = mmap(nullptr, 4096, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
   ASSERT_NE(MAP_FAILED, map);
   ASSERT_EQ(0, munmap(map, 4096));
 }
 
 TEST(sys_mman, mmap64_std) {
-  void* map = mmap64(NULL, 4096, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
+  void* map = mmap64(nullptr, 4096, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
   ASSERT_NE(MAP_FAILED, map);
   ASSERT_EQ(0, munmap(map, 4096));
 }
@@ -38,14 +38,14 @@
 TEST(sys_mman, mmap_file_bad_offset) {
   TemporaryFile tf;
 
-  void* map = mmap(NULL, 100, PROT_READ, MAP_SHARED, tf.fd, 1);
+  void* map = mmap(nullptr, 100, PROT_READ, MAP_SHARED, tf.fd, 1);
   ASSERT_EQ(MAP_FAILED, map);
 }
 
 TEST(sys_mman, mmap64_file_bad_offset) {
   TemporaryFile tf;
 
-  void* map = mmap64(NULL, 100, PROT_READ, MAP_SHARED, tf.fd, 1);
+  void* map = mmap64(nullptr, 100, PROT_READ, MAP_SHARED, tf.fd, 1);
   ASSERT_EQ(MAP_FAILED, map);
 }
 
@@ -59,7 +59,7 @@
 
   ASSERT_EQ(STR_SSIZE(STRING_MSG), write(tf.fd, STRING_MSG, sizeof(STRING_MSG)));
 
-  void* map = mmap(NULL, sizeof(STRING_MSG), PROT_READ, MAP_SHARED, tf.fd, 0);
+  void* map = mmap(nullptr, sizeof(STRING_MSG), PROT_READ, MAP_SHARED, tf.fd, 0);
   ASSERT_NE(MAP_FAILED, map);
 
   char* data = reinterpret_cast<char*>(map);
@@ -74,7 +74,7 @@
   ASSERT_EQ(STR_SSIZE(INITIAL_MSG), write(tf.fd, INITIAL_MSG, sizeof(INITIAL_MSG)));
   lseek(tf.fd, 0, SEEK_SET);
 
-  void* map = mmap(NULL, sizeof(STRING_MSG), PROT_WRITE, MAP_SHARED, tf.fd, 0);
+  void* map = mmap(nullptr, sizeof(STRING_MSG), PROT_WRITE, MAP_SHARED, tf.fd, 0);
   ASSERT_NE(MAP_FAILED, map);
   close(tf.fd);
 
@@ -110,7 +110,7 @@
 
   ASSERT_NE(-1, lseek(tf.fd, 0, SEEK_SET));
 
-  void* map = mmap(NULL, pagesize, PROT_READ, MAP_SHARED, tf.fd, pagesize);
+  void* map = mmap(nullptr, pagesize, PROT_READ, MAP_SHARED, tf.fd, pagesize);
   ASSERT_NE(MAP_FAILED, map);
 
   char* data = reinterpret_cast<char*>(map);
@@ -118,7 +118,7 @@
 
   ASSERT_EQ(0, munmap(map, pagesize));
 
-  map = mmap(NULL, pagesize, PROT_READ, MAP_SHARED, tf.fd, 2 * pagesize);
+  map = mmap(nullptr, pagesize, PROT_READ, MAP_SHARED, tf.fd, 2 * pagesize);
   ASSERT_NE(MAP_FAILED, map);
 
   data = reinterpret_cast<char*>(map);
@@ -146,7 +146,7 @@
 
   ASSERT_NE(-1, lseek(tf.fd, 0, SEEK_SET));
 
-  void* map = mmap(NULL, pagesize, PROT_WRITE, MAP_SHARED, tf.fd, pagesize);
+  void* map = mmap(nullptr, pagesize, PROT_WRITE, MAP_SHARED, tf.fd, pagesize);
   ASSERT_NE(MAP_FAILED, map);
   close(tf.fd);
 
@@ -154,7 +154,7 @@
   ASSERT_EQ(0, munmap(map, pagesize));
 
   tf.reopen();
-  map = mmap(NULL, pagesize, PROT_WRITE, MAP_SHARED, tf.fd, 2 * pagesize);
+  map = mmap(nullptr, pagesize, PROT_WRITE, MAP_SHARED, tf.fd, 2 * pagesize);
   ASSERT_NE(MAP_FAILED, map);
   close(tf.fd);
 
@@ -181,7 +181,7 @@
 
   // Prepare environment.
   ASSERT_EQ(static_cast<ssize_t>(pagesize), write(tempfile.fd, buf, pagesize));
-  void* map = mmap(NULL, pagesize, PROT_READ | PROT_WRITE, MAP_SHARED, tempfile.fd, 0);
+  void* map = mmap(nullptr, pagesize, PROT_READ | PROT_WRITE, MAP_SHARED, tempfile.fd, 0);
   ASSERT_NE(MAP_FAILED, map);
 
   // Verify different options of posix_madvise.
@@ -199,7 +199,7 @@
 TEST(sys_mman, posix_madvise_POSIX_MADV_DONTNEED) {
   size_t pagesize = sysconf(_SC_PAGESIZE);
 
-  void* map = mmap(NULL, pagesize, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+  void* map = mmap(nullptr, pagesize, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
   ASSERT_NE(MAP_FAILED, map);
 
   int* int_ptr = reinterpret_cast<int*>(map);
diff --git a/tests/sys_msg_test.cpp b/tests/sys_msg_test.cpp
index 05ad01b..4eb5a14 100644
--- a/tests/sys_msg_test.cpp
+++ b/tests/sys_msg_test.cpp
@@ -71,7 +71,7 @@
   ASSERT_STREQ("hello world", msg.data);
 
   // Destroy the queue.
-  ASSERT_EQ(0, msgctl(id, IPC_RMID, 0));
+  ASSERT_EQ(0, msgctl(id, IPC_RMID, nullptr));
 }
 
 TEST(sys_msg, msgctl_failure) {
diff --git a/tests/sys_select_test.cpp b/tests/sys_select_test.cpp
index 0eab876..5f019e2 100644
--- a/tests/sys_select_test.cpp
+++ b/tests/sys_select_test.cpp
@@ -89,10 +89,10 @@
   int max = STDERR_FILENO + 1;
 
   // Invalid max fd.
-  ASSERT_EQ(-1, select(-1, &r, &w, &e, NULL));
+  ASSERT_EQ(-1, select(-1, &r, &w, &e, nullptr));
   ASSERT_EQ(EINVAL, errno);
 
-  int num_fds = select(max, &r, &w, &e, NULL);
+  int num_fds = select(max, &r, &w, &e, nullptr);
   // If there is data to be read on STDIN, then the number of
   // fds ready will be 3 instead of 2. Allow this case, but verify
   // every fd that is set.
@@ -117,7 +117,7 @@
 
   FD_ZERO(&r);
   FD_SET(fd, &r);
-  ASSERT_EQ(1, select(fd+1, &r, NULL, NULL, &tv));
+  ASSERT_EQ(1, select(fd+1, &r, nullptr, nullptr, &tv));
   // Both tv_sec and tv_nsec should have been updated.
   ASSERT_EQ(0, tv.tv_sec);
   ASSERT_NE(0, tv.tv_usec);
@@ -144,13 +144,13 @@
   int max = STDERR_FILENO + 1;
 
   // Invalid max fd.
-  ASSERT_EQ(-1, pselect(-1, &r, &w, &e, NULL, &ss));
+  ASSERT_EQ(-1, pselect(-1, &r, &w, &e, nullptr, &ss));
   ASSERT_EQ(EINVAL, errno);
 
   // If there is data to be read on STDIN, then the number of
   // fds ready will be 3 instead of 2. Allow this case, but verify
   // every fd that is set.
-  int num_fds = pselect(max, &r, &w, &e, NULL, &ss);
+  int num_fds = pselect(max, &r, &w, &e, nullptr, &ss);
   ASSERT_TRUE(num_fds == 2 || num_fds == 3) << "Num fds returned " << num_fds;
   ASSERT_TRUE(FD_ISSET(STDOUT_FILENO, &w));
   ASSERT_TRUE(FD_ISSET(STDERR_FILENO, &w));
@@ -172,7 +172,7 @@
 
   FD_ZERO(&r);
   FD_SET(fd, &r);
-  ASSERT_EQ(1, pselect(fd+1, &r, NULL, NULL, &tv, NULL));
+  ASSERT_EQ(1, pselect(fd+1, &r, nullptr, nullptr, &tv, nullptr));
   // Neither tv_sec nor tv_nsec should have been updated.
   ASSERT_EQ(1, tv.tv_sec);
   ASSERT_EQ(0, tv.tv_nsec);
diff --git a/tests/sys_shm_test.cpp b/tests/sys_shm_test.cpp
index cf7f3a5..ca2d01a 100644
--- a/tests/sys_shm_test.cpp
+++ b/tests/sys_shm_test.cpp
@@ -52,19 +52,19 @@
   ASSERT_EQ(1234U, ds.shm_segsz);
 
   // Attach.
-  void* p = shmat(id, 0, SHM_RDONLY);
+  void* p = shmat(id, nullptr, SHM_RDONLY);
   ASSERT_NE(p, nullptr);
 
   // Detach.
   ASSERT_EQ(0, shmdt(p));
 
   // Destroy the segment.
-  ASSERT_EQ(0, shmctl(id, IPC_RMID, 0));
+  ASSERT_EQ(0, shmctl(id, IPC_RMID, nullptr));
 }
 
 TEST(sys_shm, shmat_failure) {
   errno = 0;
-  ASSERT_EQ(reinterpret_cast<void*>(-1), shmat(-1, 0, SHM_RDONLY));
+  ASSERT_EQ(reinterpret_cast<void*>(-1), shmat(-1, nullptr, SHM_RDONLY));
   ASSERT_TRUE(errno == EINVAL || errno == ENOSYS);
 }
 
diff --git a/tests/sys_socket_test.cpp b/tests/sys_socket_test.cpp
index 506e01f..0342547 100644
--- a/tests/sys_socket_test.cpp
+++ b/tests/sys_socket_test.cpp
@@ -34,7 +34,7 @@
 static void* ConnectFn(void* data) {
   ConnectData* pdata = reinterpret_cast<ConnectData*>(data);
   bool (*callback_fn)(int) = pdata->callback_fn;
-  void* return_value = NULL;
+  void* return_value = nullptr;
 
   int fd = socket(PF_UNIX, SOCK_SEQPACKET | SOCK_CLOEXEC | SOCK_NONBLOCK, 0);
   if (fd < 0) {
@@ -52,7 +52,7 @@
     GTEST_LOG_(ERROR) << "connect call failed: " << strerror(errno);
     return_value = reinterpret_cast<void*>(-1);
   }
-  else if (callback_fn != NULL && !callback_fn(fd)) {
+  else if (callback_fn != nullptr && !callback_fn(fd)) {
     return_value = reinterpret_cast<void*>(-1);
   }
 
@@ -79,7 +79,7 @@
   ConnectData connect_data(callback_fn, sock_path);
 
   pthread_t thread;
-  ASSERT_EQ(0, pthread_create(&thread, NULL, ConnectFn, &connect_data));
+  ASSERT_EQ(0, pthread_create(&thread, nullptr, ConnectFn, &connect_data));
 
   fd_set read_set;
   FD_ZERO(&read_set);
@@ -87,19 +87,19 @@
   timeval tv;
   tv.tv_sec = 5;
   tv.tv_usec = 0;
-  ASSERT_LT(0, select(fd+1, &read_set, NULL, NULL, &tv));
+  ASSERT_LT(0, select(fd+1, &read_set, nullptr, nullptr, &tv));
 
   test_fn(&addr, fd);
 
   void* ret_val;
   ASSERT_EQ(0, pthread_join(thread, &ret_val));
-  ASSERT_EQ(NULL, ret_val);
+  ASSERT_EQ(nullptr, ret_val);
 
   close(fd);
 }
 
 TEST(sys_socket, accept4_error) {
-  ASSERT_EQ(-1, accept4(-1, NULL, NULL, 0));
+  ASSERT_EQ(-1, accept4(-1, nullptr, nullptr, 0));
   ASSERT_EQ(EBADF, errno);
 }
 
@@ -115,7 +115,7 @@
 }
 
 TEST(sys_socket, accept4_smoke) {
-  RunTest(TestAccept4, NULL, "test_accept");
+  RunTest(TestAccept4, nullptr, "test_accept");
 }
 
 const char* g_RecvMsgs[] = {
@@ -174,7 +174,7 @@
 }
 
 TEST(sys_socket, recvmmsg_error) {
-  ASSERT_EQ(-1, recvmmsg(-1, NULL, 0, 0, NULL));
+  ASSERT_EQ(-1, recvmmsg(-1, nullptr, 0, 0, nullptr));
   ASSERT_EQ(EBADF, errno);
 }
 
@@ -217,7 +217,7 @@
     timeval tv;
     tv.tv_sec = 5;
     tv.tv_usec = 0;
-    ASSERT_LT(0, select(fd_acc+1, &read_set, NULL, NULL, &tv));
+    ASSERT_LT(0, select(fd_acc+1, &read_set, nullptr, nullptr, &tv));
     char buffer[100];
     ASSERT_EQ(strlen(g_SendMsgs[i]) + 1,
               static_cast<size_t>(recv(fd_acc, buffer, sizeof(buffer), 0)));
@@ -232,6 +232,6 @@
 }
 
 TEST(sys_socket, sendmmsg_error) {
-  ASSERT_EQ(-1, sendmmsg(-1, NULL, 0, 0));
+  ASSERT_EQ(-1, sendmmsg(-1, nullptr, 0, 0));
   ASSERT_EQ(EBADF, errno);
 }
diff --git a/tests/sys_stat_test.cpp b/tests/sys_stat_test.cpp
index 7c387ba..c0a576d 100644
--- a/tests/sys_stat_test.cpp
+++ b/tests/sys_stat_test.cpp
@@ -25,7 +25,7 @@
 
 TEST(sys_stat, futimens) {
   FILE* fp = tmpfile();
-  ASSERT_TRUE(fp != NULL);
+  ASSERT_TRUE(fp != nullptr);
 
   int fd = fileno(fp);
   ASSERT_NE(fd, -1);
diff --git a/tests/sys_time_test.cpp b/tests/sys_time_test.cpp
index e041ba0..b3ec161 100644
--- a/tests/sys_time_test.cpp
+++ b/tests/sys_time_test.cpp
@@ -134,9 +134,9 @@
 TEST(sys_time, gettimeofday) {
   // Try to ensure that our vdso gettimeofday is working.
   timeval tv1;
-  ASSERT_EQ(0, gettimeofday(&tv1, NULL));
+  ASSERT_EQ(0, gettimeofday(&tv1, nullptr));
   timeval tv2;
-  ASSERT_EQ(0, syscall(__NR_gettimeofday, &tv2, NULL));
+  ASSERT_EQ(0, syscall(__NR_gettimeofday, &tv2, nullptr));
 
   // What's the difference between the two?
   tv2.tv_sec -= tv1.tv_sec;
diff --git a/tests/sys_xattr_test.cpp b/tests/sys_xattr_test.cpp
index 113ec26..006e840 100644
--- a/tests/sys_xattr_test.cpp
+++ b/tests/sys_xattr_test.cpp
@@ -107,7 +107,7 @@
   ASSERT_EQ(0, fsetxattr(tf.fd, "user.foo", "bar", 4, 0));
   ssize_t result = flistxattr(tf.fd, buf, sizeof(buf));
   ASSERT_TRUE(result >= 9);
-  ASSERT_TRUE(memmem(buf, sizeof(buf), "user.foo", 9) != NULL);
+  ASSERT_TRUE(memmem(buf, sizeof(buf), "user.foo", 9) != nullptr);
 }
 
 TEST(sys_xattr, flistattr_opath) {
@@ -120,7 +120,7 @@
 #if defined(__BIONIC__)
   ASSERT_TRUE(res >= 9);
   ASSERT_TRUE(static_cast<size_t>(res) <= sizeof(buf));
-  ASSERT_TRUE(memmem(buf, res, "user.foo", 9) != NULL);
+  ASSERT_TRUE(memmem(buf, res, "user.foo", 9) != nullptr);
 #else
   ASSERT_EQ(-1, res);
   ASSERT_EQ(EBADF, errno);
diff --git a/tests/time_test.cpp b/tests/time_test.cpp
index 216f846..e82f15d 100644
--- a/tests/time_test.cpp
+++ b/tests/time_test.cpp
@@ -59,7 +59,7 @@
 TEST(time, gmtime) {
   time_t t = 0;
   tm* broken_down = gmtime(&t);
-  ASSERT_TRUE(broken_down != NULL);
+  ASSERT_TRUE(broken_down != nullptr);
   ASSERT_EQ(0, broken_down->tm_sec);
   ASSERT_EQ(0, broken_down->tm_min);
   ASSERT_EQ(0, broken_down->tm_hour);
@@ -86,11 +86,11 @@
   // Ensure we'll actually have to enter tzload by using a time zone that doesn't exist.
   setenv("TZ", "gmtime_stack_overflow_14313703", 1);
   tzset();
-  if (original_tz != NULL) {
+  if (original_tz != nullptr) {
     setenv("TZ", original_tz, 1);
   }
   tzset();
-  return NULL;
+  return nullptr;
 }
 
 TEST(time, gmtime_no_stack_overflow_14313703) {
@@ -102,7 +102,7 @@
   ASSERT_EQ(0, pthread_attr_setstacksize(&a, PTHREAD_STACK_MIN));
 
   pthread_t t;
-  ASSERT_EQ(0, pthread_create(&t, &a, gmtime_no_stack_overflow_14313703_fn, NULL));
+  ASSERT_EQ(0, pthread_create(&t, &a, gmtime_no_stack_overflow_14313703_fn, nullptr));
   ASSERT_EQ(0, pthread_join(t, nullptr));
 }
 
@@ -242,7 +242,7 @@
 }
 
 TEST(time, strftime_l) {
-  locale_t cloc = newlocale(LC_ALL, "C.UTF-8", 0);
+  locale_t cloc = newlocale(LC_ALL, "C.UTF-8", nullptr);
   locale_t old_locale = uselocale(cloc);
 
   setenv("TZ", "UTC", 1);
@@ -302,7 +302,7 @@
   ts.it_value.tv_nsec = value_ns;
   ts.it_interval.tv_sec = interval_s;
   ts.it_interval.tv_nsec = interval_ns;
-  ASSERT_EQ(0, timer_settime(t, 0, &ts, NULL));
+  ASSERT_EQ(0, timer_settime(t, 0, &ts, nullptr));
 }
 
 static void NoOpNotifyFunction(sigval_t) {
@@ -356,7 +356,7 @@
   ts.it_value.tv_nsec = 1;
   ts.it_interval.tv_sec = 0;
   ts.it_interval.tv_nsec = 0;
-  ASSERT_EQ(0, timer_settime(timer_id, 0, &ts, NULL));
+  ASSERT_EQ(0, timer_settime(timer_id, 0, &ts, nullptr));
 
   usleep(500000);
   ASSERT_EQ(1, timer_create_SIGEV_SIGNAL_signal_handler_invocation_count);
@@ -405,8 +405,8 @@
 
   bool ValueUpdated() {
     int current_value = value;
-    time_t start = time(NULL);
-    while (current_value == value && (time(NULL) - start) < 5) {
+    time_t start = time(nullptr);
+    while (current_value == value && (time(nullptr) - start) < 5) {
     }
     return current_value != value;
   }
@@ -458,7 +458,7 @@
 TEST(time, timer_create_NULL) {
   // A NULL sigevent* is equivalent to asking for SIGEV_SIGNAL for SIGALRM.
   timer_t timer_id;
-  ASSERT_EQ(0, timer_create(CLOCK_MONOTONIC, NULL, &timer_id));
+  ASSERT_EQ(0, timer_create(CLOCK_MONOTONIC, nullptr, &timer_id));
 
   timer_create_NULL_signal_handler_invocation_count = 0;
   ScopedSignalHandler ssh(SIGALRM, timer_create_NULL_signal_handler);
@@ -476,7 +476,7 @@
 
   // A SIGEV_SIGNAL timer is easy; the kernel does all that.
   timer_t timer_id;
-  ASSERT_EQ(-1, timer_create(invalid_clock, NULL, &timer_id));
+  ASSERT_EQ(-1, timer_create(invalid_clock, nullptr, &timer_id));
   ASSERT_EQ(EINVAL, errno);
 
   // A SIGEV_THREAD timer is more interesting because we have stuff to clean up.
@@ -490,7 +490,7 @@
 
 TEST(time, timer_delete_multiple) {
   timer_t timer_id;
-  ASSERT_EQ(0, timer_create(CLOCK_MONOTONIC, NULL, &timer_id));
+  ASSERT_EQ(0, timer_create(CLOCK_MONOTONIC, nullptr, &timer_id));
   ASSERT_EQ(0, timer_delete(timer_id));
   ASSERT_EQ(-1, timer_delete(timer_id));
   ASSERT_EQ(EINVAL, errno);
@@ -593,10 +593,10 @@
   ts.it_value.tv_nsec = 0;
   ts.it_interval.tv_sec = 0;
   ts.it_interval.tv_nsec = 0;
-  ASSERT_EQ(0, timer_settime(tdd.timer_id, 0, &ts, NULL));
+  ASSERT_EQ(0, timer_settime(tdd.timer_id, 0, &ts, nullptr));
 
-  time_t cur_time = time(NULL);
-  while (!tdd.complete && (time(NULL) - cur_time) < 5);
+  time_t cur_time = time(nullptr);
+  while (!tdd.complete && (time(nullptr) - cur_time) < 5);
   ASSERT_TRUE(tdd.complete);
 
 #if defined(__BIONIC__)
diff --git a/tests/uchar_test.cpp b/tests/uchar_test.cpp
index 2b4c4d3..522d5ac 100644
--- a/tests/uchar_test.cpp
+++ b/tests/uchar_test.cpp
@@ -49,19 +49,19 @@
 
   // Any non-initial state is invalid when calling c32rtomb.
   memset(&ps, 0, sizeof(ps));
-  EXPECT_EQ(static_cast<size_t>(-2), mbrtoc32(NULL, "\xc2", 1, &ps));
+  EXPECT_EQ(static_cast<size_t>(-2), mbrtoc32(nullptr, "\xc2", 1, &ps));
   EXPECT_EQ(static_cast<size_t>(-1), c32rtomb(out, 0x00a2, &ps));
   EXPECT_EQ(EILSEQ, errno);
 
-  // If the first argument to c32rtomb is NULL or the second is L'\0' the shift
+  // If the first argument to c32rtomb is nullptr or the second is L'\0' the shift
   // state should be reset.
   memset(&ps, 0, sizeof(ps));
-  EXPECT_EQ(static_cast<size_t>(-2), mbrtoc32(NULL, "\xc2", 1, &ps));
-  EXPECT_EQ(1U, c32rtomb(NULL, 0x00a2, &ps));
+  EXPECT_EQ(static_cast<size_t>(-2), mbrtoc32(nullptr, "\xc2", 1, &ps));
+  EXPECT_EQ(1U, c32rtomb(nullptr, 0x00a2, &ps));
   EXPECT_TRUE(mbsinit(&ps));
 
   memset(&ps, 0, sizeof(ps));
-  EXPECT_EQ(static_cast<size_t>(-2), mbrtoc32(NULL, "\xf0\xa4", 1, &ps));
+  EXPECT_EQ(static_cast<size_t>(-2), mbrtoc32(nullptr, "\xf0\xa4", 1, &ps));
   EXPECT_EQ(1U, c32rtomb(out, L'\0', &ps));
   EXPECT_TRUE(mbsinit(&ps));
 #else
@@ -71,8 +71,8 @@
 
 TEST(uchar, c16rtomb_null_out) {
 #if HAVE_UCHAR
-  EXPECT_EQ(1U, c16rtomb(NULL, L'\0', NULL));
-  EXPECT_EQ(1U, c16rtomb(NULL, L'h', NULL));
+  EXPECT_EQ(1U, c16rtomb(nullptr, L'\0', nullptr));
+  EXPECT_EQ(1U, c16rtomb(nullptr, L'h', nullptr));
 #else
   GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
 #endif
@@ -81,7 +81,7 @@
 TEST(uchar, c16rtomb_null_char) {
 #if HAVE_UCHAR
   char bytes[MB_LEN_MAX];
-  EXPECT_EQ(1U, c16rtomb(bytes, L'\0', NULL));
+  EXPECT_EQ(1U, c16rtomb(bytes, L'\0', nullptr));
 #else
   GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
 #endif
@@ -92,7 +92,7 @@
   char bytes[MB_LEN_MAX];
 
   memset(bytes, 0, sizeof(bytes));
-  EXPECT_EQ(1U, c16rtomb(bytes, L'h', NULL));
+  EXPECT_EQ(1U, c16rtomb(bytes, L'h', nullptr));
   EXPECT_EQ('h', bytes[0]);
 
   ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
@@ -100,16 +100,16 @@
 
   // 1-byte UTF-8.
   memset(bytes, 0, sizeof(bytes));
-  EXPECT_EQ(1U, c16rtomb(bytes, L'h', NULL));
+  EXPECT_EQ(1U, c16rtomb(bytes, L'h', nullptr));
   EXPECT_EQ('h', bytes[0]);
   // 2-byte UTF-8.
   memset(bytes, 0, sizeof(bytes));
-  EXPECT_EQ(2U, c16rtomb(bytes, 0x00a2, NULL));
+  EXPECT_EQ(2U, c16rtomb(bytes, 0x00a2, nullptr));
   EXPECT_EQ('\xc2', bytes[0]);
   EXPECT_EQ('\xa2', bytes[1]);
   // 3-byte UTF-8.
   memset(bytes, 0, sizeof(bytes));
-  EXPECT_EQ(3U, c16rtomb(bytes, 0x20ac, NULL));
+  EXPECT_EQ(3U, c16rtomb(bytes, 0x20ac, nullptr));
   EXPECT_EQ('\xe2', bytes[0]);
   EXPECT_EQ('\x82', bytes[1]);
   EXPECT_EQ('\xac', bytes[2]);
@@ -123,8 +123,8 @@
   char bytes[MB_LEN_MAX];
 
   memset(bytes, 0, sizeof(bytes));
-  EXPECT_EQ(0U, c16rtomb(bytes, 0xdbea, NULL));
-  EXPECT_EQ(4U, c16rtomb(bytes, 0xdfcd, NULL));
+  EXPECT_EQ(0U, c16rtomb(bytes, 0xdbea, nullptr));
+  EXPECT_EQ(4U, c16rtomb(bytes, 0xdfcd, nullptr));
   EXPECT_EQ('\xf4', bytes[0]);
   EXPECT_EQ('\x8a', bytes[1]);
   EXPECT_EQ('\xaf', bytes[2]);
@@ -139,10 +139,10 @@
   char bytes[MB_LEN_MAX];
 
   memset(bytes, 0, sizeof(bytes));
-  EXPECT_EQ(static_cast<size_t>(-1), c16rtomb(bytes, 0xdfcd, NULL));
+  EXPECT_EQ(static_cast<size_t>(-1), c16rtomb(bytes, 0xdfcd, nullptr));
 
-  EXPECT_EQ(0U, c16rtomb(bytes, 0xdbea, NULL));
-  EXPECT_EQ(static_cast<size_t>(-1), c16rtomb(bytes, 0xdbea, NULL));
+  EXPECT_EQ(0U, c16rtomb(bytes, 0xdbea, nullptr));
+  EXPECT_EQ(static_cast<size_t>(-1), c16rtomb(bytes, 0xdbea, nullptr));
 #else
   GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
 #endif
@@ -150,7 +150,7 @@
 
 TEST(uchar, mbrtoc16_null) {
 #if HAVE_UCHAR
-  ASSERT_EQ(0U, mbrtoc16(NULL, NULL, 0, NULL));
+  ASSERT_EQ(0U, mbrtoc16(nullptr, nullptr, 0, nullptr));
 #else
   GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
 #endif
@@ -161,12 +161,12 @@
   char16_t out;
 
   out = L'x';
-  ASSERT_EQ(0U, mbrtoc16(&out, "hello", 0, NULL));
+  ASSERT_EQ(0U, mbrtoc16(&out, "hello", 0, nullptr));
   ASSERT_EQ(L'x', out);
 
-  ASSERT_EQ(0U, mbrtoc16(&out, "hello", 0, NULL));
-  ASSERT_EQ(0U, mbrtoc16(&out, "", 0, NULL));
-  ASSERT_EQ(1U, mbrtoc16(&out, "hello", 1, NULL));
+  ASSERT_EQ(0U, mbrtoc16(&out, "hello", 0, nullptr));
+  ASSERT_EQ(0U, mbrtoc16(&out, "", 0, nullptr));
+  ASSERT_EQ(1U, mbrtoc16(&out, "hello", 1, nullptr));
   ASSERT_EQ(L'h', out);
 #else
   GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
@@ -181,13 +181,13 @@
   uselocale(LC_GLOBAL_LOCALE);
 
   // 1-byte UTF-8.
-  ASSERT_EQ(1U, mbrtoc16(&out, "abcdef", 6, NULL));
+  ASSERT_EQ(1U, mbrtoc16(&out, "abcdef", 6, nullptr));
   ASSERT_EQ(L'a', out);
   // 2-byte UTF-8.
-  ASSERT_EQ(2U, mbrtoc16(&out, "\xc2\xa2" "cdef", 6, NULL));
+  ASSERT_EQ(2U, mbrtoc16(&out, "\xc2\xa2" "cdef", 6, nullptr));
   ASSERT_EQ(static_cast<char16_t>(0x00a2), out);
   // 3-byte UTF-8.
-  ASSERT_EQ(3U, mbrtoc16(&out, "\xe2\x82\xac" "def", 6, NULL));
+  ASSERT_EQ(3U, mbrtoc16(&out, "\xe2\x82\xac" "def", 6, nullptr));
   ASSERT_EQ(static_cast<char16_t>(0x20ac), out);
 #else
   GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
@@ -199,9 +199,9 @@
   char16_t out;
 
   ASSERT_EQ(static_cast<size_t>(-3),
-            mbrtoc16(&out, "\xf4\x8a\xaf\x8d", 6, NULL));
+            mbrtoc16(&out, "\xf4\x8a\xaf\x8d", 6, nullptr));
   ASSERT_EQ(static_cast<char16_t>(0xdbea), out);
-  ASSERT_EQ(4U, mbrtoc16(&out, "\xf4\x8a\xaf\x8d" "ef", 6, NULL));
+  ASSERT_EQ(4U, mbrtoc16(&out, "\xf4\x8a\xaf\x8d" "ef", 6, nullptr));
   ASSERT_EQ(static_cast<char16_t>(0xdfcd), out);
 #else
   GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
@@ -212,7 +212,7 @@
 #if HAVE_UCHAR
   char16_t out;
   ASSERT_EQ(static_cast<size_t>(-1),
-            mbrtoc16(&out, "\xf0\x80\xbf\xbf", 6, NULL));
+            mbrtoc16(&out, "\xf0\x80\xbf\xbf", 6, nullptr));
 #else
   GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
 #endif
@@ -222,7 +222,7 @@
 #if HAVE_UCHAR
   char16_t out;
   ASSERT_EQ(static_cast<size_t>(-1),
-            mbrtoc16(&out, "\xf5\x80\x80\x80", 6, NULL));
+            mbrtoc16(&out, "\xf5\x80\x80\x80", 6, nullptr));
 #else
   GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
 #endif
@@ -267,7 +267,7 @@
   memset(&ps, 0, sizeof(ps));
 
   test_mbrtoc16_incomplete(&ps);
-  test_mbrtoc16_incomplete(NULL);
+  test_mbrtoc16_incomplete(nullptr);
 #else
   GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
 #endif
@@ -275,18 +275,18 @@
 
 TEST(uchar, c32rtomb) {
 #if HAVE_UCHAR
-  EXPECT_EQ(1U, c32rtomb(NULL, L'\0', NULL));
-  EXPECT_EQ(1U, c32rtomb(NULL, L'h', NULL));
+  EXPECT_EQ(1U, c32rtomb(nullptr, L'\0', nullptr));
+  EXPECT_EQ(1U, c32rtomb(nullptr, L'h', nullptr));
 
   char bytes[MB_LEN_MAX];
 
   memset(bytes, 1, sizeof(bytes));
-  EXPECT_EQ(1U, c32rtomb(bytes, L'\0', NULL));
+  EXPECT_EQ(1U, c32rtomb(bytes, L'\0', nullptr));
   EXPECT_EQ('\0', bytes[0]);
   EXPECT_EQ('\x01', bytes[1]);
 
   memset(bytes, 0, sizeof(bytes));
-  EXPECT_EQ(1U, c32rtomb(bytes, L'h', NULL));
+  EXPECT_EQ(1U, c32rtomb(bytes, L'h', nullptr));
   EXPECT_EQ('h', bytes[0]);
 
   ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
@@ -294,28 +294,28 @@
 
   // 1-byte UTF-8.
   memset(bytes, 0, sizeof(bytes));
-  EXPECT_EQ(1U, c32rtomb(bytes, L'h', NULL));
+  EXPECT_EQ(1U, c32rtomb(bytes, L'h', nullptr));
   EXPECT_EQ('h', bytes[0]);
   // 2-byte UTF-8.
   memset(bytes, 0, sizeof(bytes));
-  EXPECT_EQ(2U, c32rtomb(bytes, 0x00a2, NULL));
+  EXPECT_EQ(2U, c32rtomb(bytes, 0x00a2, nullptr));
   EXPECT_EQ('\xc2', bytes[0]);
   EXPECT_EQ('\xa2', bytes[1]);
   // 3-byte UTF-8.
   memset(bytes, 0, sizeof(bytes));
-  EXPECT_EQ(3U, c32rtomb(bytes, 0x20ac, NULL));
+  EXPECT_EQ(3U, c32rtomb(bytes, 0x20ac, nullptr));
   EXPECT_EQ('\xe2', bytes[0]);
   EXPECT_EQ('\x82', bytes[1]);
   EXPECT_EQ('\xac', bytes[2]);
   // 4-byte UTF-8.
   memset(bytes, 0, sizeof(bytes));
-  EXPECT_EQ(4U, c32rtomb(bytes, 0x24b62, NULL));
+  EXPECT_EQ(4U, c32rtomb(bytes, 0x24b62, nullptr));
   EXPECT_EQ('\xf0', bytes[0]);
   EXPECT_EQ('\xa4', bytes[1]);
   EXPECT_EQ('\xad', bytes[2]);
   EXPECT_EQ('\xa2', bytes[3]);
   // Invalid code point.
-  EXPECT_EQ(static_cast<size_t>(-1), c32rtomb(bytes, 0xffffffff, NULL));
+  EXPECT_EQ(static_cast<size_t>(-1), c32rtomb(bytes, 0xffffffff, nullptr));
   EXPECT_EQ(EILSEQ, errno);
 #else
   GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
@@ -356,42 +356,42 @@
   char32_t out[8];
 
   out[0] = L'x';
-  ASSERT_EQ(0U, mbrtoc32(out, "hello", 0, NULL));
+  ASSERT_EQ(0U, mbrtoc32(out, "hello", 0, nullptr));
   ASSERT_EQ(static_cast<char32_t>(L'x'), out[0]);
 
-  ASSERT_EQ(0U, mbrtoc32(out, "hello", 0, NULL));
-  ASSERT_EQ(0U, mbrtoc32(out, "", 0, NULL));
-  ASSERT_EQ(1U, mbrtoc32(out, "hello", 1, NULL));
+  ASSERT_EQ(0U, mbrtoc32(out, "hello", 0, nullptr));
+  ASSERT_EQ(0U, mbrtoc32(out, "", 0, nullptr));
+  ASSERT_EQ(1U, mbrtoc32(out, "hello", 1, nullptr));
   ASSERT_EQ(static_cast<char32_t>(L'h'), out[0]);
 
-  ASSERT_EQ(0U, mbrtoc32(NULL, "hello", 0, NULL));
-  ASSERT_EQ(0U, mbrtoc32(NULL, "", 0, NULL));
-  ASSERT_EQ(1U, mbrtoc32(NULL, "hello", 1, NULL));
+  ASSERT_EQ(0U, mbrtoc32(nullptr, "hello", 0, nullptr));
+  ASSERT_EQ(0U, mbrtoc32(nullptr, "", 0, nullptr));
+  ASSERT_EQ(1U, mbrtoc32(nullptr, "hello", 1, nullptr));
 
-  ASSERT_EQ(0U, mbrtoc32(NULL, NULL, 0, NULL));
+  ASSERT_EQ(0U, mbrtoc32(nullptr, nullptr, 0, nullptr));
 
   ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
   uselocale(LC_GLOBAL_LOCALE);
 
   // 1-byte UTF-8.
-  ASSERT_EQ(1U, mbrtoc32(out, "abcdef", 6, NULL));
+  ASSERT_EQ(1U, mbrtoc32(out, "abcdef", 6, nullptr));
   ASSERT_EQ(static_cast<char32_t>(L'a'), out[0]);
   // 2-byte UTF-8.
-  ASSERT_EQ(2U, mbrtoc32(out, "\xc2\xa2" "cdef", 6, NULL));
+  ASSERT_EQ(2U, mbrtoc32(out, "\xc2\xa2" "cdef", 6, nullptr));
   ASSERT_EQ(static_cast<char32_t>(0x00a2), out[0]);
   // 3-byte UTF-8.
-  ASSERT_EQ(3U, mbrtoc32(out, "\xe2\x82\xac" "def", 6, NULL));
+  ASSERT_EQ(3U, mbrtoc32(out, "\xe2\x82\xac" "def", 6, nullptr));
   ASSERT_EQ(static_cast<char32_t>(0x20ac), out[0]);
   // 4-byte UTF-8.
-  ASSERT_EQ(4U, mbrtoc32(out, "\xf0\xa4\xad\xa2" "ef", 6, NULL));
+  ASSERT_EQ(4U, mbrtoc32(out, "\xf0\xa4\xad\xa2" "ef", 6, nullptr));
   ASSERT_EQ(static_cast<char32_t>(0x24b62), out[0]);
 #if defined(__BIONIC__) // glibc allows this.
   // Illegal 5-byte UTF-8.
-  ASSERT_EQ(static_cast<size_t>(-1), mbrtoc32(out, "\xf8\xa1\xa2\xa3\xa4" "f", 6, NULL));
+  ASSERT_EQ(static_cast<size_t>(-1), mbrtoc32(out, "\xf8\xa1\xa2\xa3\xa4" "f", 6, nullptr));
   ASSERT_EQ(EILSEQ, errno);
 #endif
   // Illegal over-long sequence.
-  ASSERT_EQ(static_cast<size_t>(-1), mbrtoc32(out, "\xf0\x82\x82\xac" "ef", 6, NULL));
+  ASSERT_EQ(static_cast<size_t>(-1), mbrtoc32(out, "\xf0\x82\x82\xac" "ef", 6, nullptr));
   ASSERT_EQ(EILSEQ, errno);
 #else
   GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
@@ -435,7 +435,7 @@
   memset(&ps, 0, sizeof(ps));
 
   test_mbrtoc32_incomplete(&ps);
-  test_mbrtoc32_incomplete(NULL);
+  test_mbrtoc32_incomplete(nullptr);
 #else
   GTEST_LOG_(INFO) << "uchar.h is unavailable.\n";
 #endif
diff --git a/tests/unistd_test.cpp b/tests/unistd_test.cpp
index fd99455..1f7f555 100644
--- a/tests/unistd_test.cpp
+++ b/tests/unistd_test.cpp
@@ -273,7 +273,7 @@
   ASSERT_EQ(0, setenv("test-variable", "hello", 1));
   ASSERT_STREQ("hello", getenv("test-variable"));
   ASSERT_EQ(0, unsetenv("test-variable"));
-  ASSERT_TRUE(getenv("test-variable") == NULL);
+  ASSERT_TRUE(getenv("test-variable") == nullptr);
 }
 
 TEST(UNISTD_TEST, unsetenv_EINVAL) {
@@ -284,9 +284,9 @@
 }
 
 TEST(UNISTD_TEST, setenv_EINVAL) {
-  EXPECT_EQ(-1, setenv(NULL, "value", 0));
+  EXPECT_EQ(-1, setenv(nullptr, "value", 0));
   EXPECT_EQ(EINVAL, errno);
-  EXPECT_EQ(-1, setenv(NULL, "value", 1));
+  EXPECT_EQ(-1, setenv(nullptr, "value", 1));
   EXPECT_EQ(EINVAL, errno);
   EXPECT_EQ(-1, setenv("", "value", 0));
   EXPECT_EQ(EINVAL, errno);
@@ -353,14 +353,14 @@
 
   // Stash a copy.
   std::vector<char*> old_environ;
-  for (size_t i = 0; environ[i] != NULL; ++i) {
+  for (size_t i = 0; environ[i] != nullptr; ++i) {
     old_environ.push_back(strdup(environ[i]));
   }
 
   ASSERT_EQ(0, clearenv());
 
-  EXPECT_TRUE(environ == NULL || environ[0] == NULL);
-  EXPECT_EQ(NULL, getenv("test-variable"));
+  EXPECT_TRUE(environ == nullptr || environ[0] == nullptr);
+  EXPECT_EQ(nullptr, getenv("test-variable"));
   EXPECT_EQ(0, setenv("test-variable", "post-clear", 1));
   EXPECT_STREQ("post-clear", getenv("test-variable"));
 
@@ -539,7 +539,7 @@
 
 static int CloneStartRoutine(int (*start_routine)(void*)) {
   void* child_stack[1024];
-  return clone(start_routine, &child_stack[1024], SIGCHLD, NULL);
+  return clone(start_routine, &child_stack[1024], SIGCHLD, nullptr);
 }
 
 static int GetPidCachingCloneStartRoutine(void*) {
@@ -594,20 +594,20 @@
 
 static void* GetPidCachingPthreadStartRoutine(void*) {
   AssertGetPidCorrect();
-  return NULL;
+  return nullptr;
 }
 
 TEST(UNISTD_TEST, getpid_caching_and_pthread_create) {
   pid_t parent_pid = getpid();
 
   pthread_t t;
-  ASSERT_EQ(0, pthread_create(&t, NULL, GetPidCachingPthreadStartRoutine, NULL));
+  ASSERT_EQ(0, pthread_create(&t, nullptr, GetPidCachingPthreadStartRoutine, nullptr));
 
   ASSERT_EQ(parent_pid, getpid());
 
   void* result;
   ASSERT_EQ(0, pthread_join(t, &result));
-  ASSERT_EQ(NULL, result);
+  ASSERT_EQ(nullptr, result);
 }
 
 static void* GetTidCachingPthreadStartRoutine(void*) {
@@ -620,7 +620,7 @@
   pid_t parent_tid = GetTidForTest();
 
   pthread_t t;
-  ASSERT_EQ(0, pthread_create(&t, NULL, GetTidCachingPthreadStartRoutine, &parent_tid));
+  ASSERT_EQ(0, pthread_create(&t, nullptr, GetTidCachingPthreadStartRoutine, &parent_tid));
 
   ASSERT_EQ(parent_tid, GetTidForTest());
 
diff --git a/tests/wchar_test.cpp b/tests/wchar_test.cpp
index e2def07..9aef800 100644
--- a/tests/wchar_test.cpp
+++ b/tests/wchar_test.cpp
@@ -35,32 +35,32 @@
 
 TEST(wchar, mbrlen) {
   char bytes[] = { 'h', 'e', 'l', 'l', 'o', '\0' };
-  EXPECT_EQ(0U, mbrlen(&bytes[0], 0, NULL));
-  EXPECT_EQ(1U, mbrlen(&bytes[0], 1, NULL));
+  EXPECT_EQ(0U, mbrlen(&bytes[0], 0, nullptr));
+  EXPECT_EQ(1U, mbrlen(&bytes[0], 1, nullptr));
 
-  EXPECT_EQ(1U, mbrlen(&bytes[4], 1, NULL));
-  EXPECT_EQ(0U, mbrlen(&bytes[5], 1, NULL));
+  EXPECT_EQ(1U, mbrlen(&bytes[4], 1, nullptr));
+  EXPECT_EQ(0U, mbrlen(&bytes[5], 1, nullptr));
 }
 
 TEST(wchar, wctomb_wcrtomb) {
   // wctomb and wcrtomb behave differently when s == NULL.
-  EXPECT_EQ(0, wctomb(NULL, L'h'));
-  EXPECT_EQ(0, wctomb(NULL, L'\0'));
-  EXPECT_EQ(1U, wcrtomb(NULL, L'\0', NULL));
-  EXPECT_EQ(1U, wcrtomb(NULL, L'h', NULL));
+  EXPECT_EQ(0, wctomb(nullptr, L'h'));
+  EXPECT_EQ(0, wctomb(nullptr, L'\0'));
+  EXPECT_EQ(1U, wcrtomb(nullptr, L'\0', nullptr));
+  EXPECT_EQ(1U, wcrtomb(nullptr, L'h', nullptr));
 
   char bytes[MB_LEN_MAX];
 
   // wctomb and wcrtomb behave similarly for the null wide character.
   EXPECT_EQ(1, wctomb(bytes, L'\0'));
-  EXPECT_EQ(1U, wcrtomb(bytes, L'\0', NULL));
+  EXPECT_EQ(1U, wcrtomb(bytes, L'\0', nullptr));
 
   // ...and for regular characters.
   memset(bytes, 0, sizeof(bytes));
   EXPECT_EQ(1, wctomb(bytes, L'h'));
   EXPECT_EQ('h', bytes[0]);
   memset(bytes, 0, sizeof(bytes));
-  EXPECT_EQ(1U, wcrtomb(bytes, L'h', NULL));
+  EXPECT_EQ(1U, wcrtomb(bytes, L'h', nullptr));
   EXPECT_EQ('h', bytes[0]);
 
   ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
@@ -68,28 +68,28 @@
 
   // 1-byte UTF-8.
   memset(bytes, 0, sizeof(bytes));
-  EXPECT_EQ(1U, wcrtomb(bytes, L'h', NULL));
+  EXPECT_EQ(1U, wcrtomb(bytes, L'h', nullptr));
   EXPECT_EQ('h', bytes[0]);
   // 2-byte UTF-8.
   memset(bytes, 0, sizeof(bytes));
-  EXPECT_EQ(2U, wcrtomb(bytes, 0x00a2, NULL));
+  EXPECT_EQ(2U, wcrtomb(bytes, 0x00a2, nullptr));
   EXPECT_EQ('\xc2', bytes[0]);
   EXPECT_EQ('\xa2', bytes[1]);
   // 3-byte UTF-8.
   memset(bytes, 0, sizeof(bytes));
-  EXPECT_EQ(3U, wcrtomb(bytes, 0x20ac, NULL));
+  EXPECT_EQ(3U, wcrtomb(bytes, 0x20ac, nullptr));
   EXPECT_EQ('\xe2', bytes[0]);
   EXPECT_EQ('\x82', bytes[1]);
   EXPECT_EQ('\xac', bytes[2]);
   // 4-byte UTF-8.
   memset(bytes, 0, sizeof(bytes));
-  EXPECT_EQ(4U, wcrtomb(bytes, 0x24b62, NULL));
+  EXPECT_EQ(4U, wcrtomb(bytes, 0x24b62, nullptr));
   EXPECT_EQ('\xf0', bytes[0]);
   EXPECT_EQ('\xa4', bytes[1]);
   EXPECT_EQ('\xad', bytes[2]);
   EXPECT_EQ('\xa2', bytes[3]);
   // Invalid code point.
-  EXPECT_EQ(static_cast<size_t>(-1), wcrtomb(bytes, 0xffffffff, NULL));
+  EXPECT_EQ(static_cast<size_t>(-1), wcrtomb(bytes, 0xffffffff, nullptr));
   EXPECT_EQ(EILSEQ, errno);
 }
 
@@ -99,19 +99,19 @@
 
   // Any non-initial state is invalid when calling wcrtomb.
   memset(&ps, 0, sizeof(ps));
-  EXPECT_EQ(static_cast<size_t>(-2), mbrtowc(NULL, "\xc2", 1, &ps));
+  EXPECT_EQ(static_cast<size_t>(-2), mbrtowc(nullptr, "\xc2", 1, &ps));
   EXPECT_EQ(static_cast<size_t>(-1), wcrtomb(out, 0x00a2, &ps));
   EXPECT_EQ(EILSEQ, errno);
 
   // If the first argument to wcrtomb is NULL or the second is L'\0' the shift
   // state should be reset.
   memset(&ps, 0, sizeof(ps));
-  EXPECT_EQ(static_cast<size_t>(-2), mbrtowc(NULL, "\xc2", 1, &ps));
-  EXPECT_EQ(1U, wcrtomb(NULL, 0x00a2, &ps));
+  EXPECT_EQ(static_cast<size_t>(-2), mbrtowc(nullptr, "\xc2", 1, &ps));
+  EXPECT_EQ(1U, wcrtomb(nullptr, 0x00a2, &ps));
   EXPECT_TRUE(mbsinit(&ps));
 
   memset(&ps, 0, sizeof(ps));
-  EXPECT_EQ(static_cast<size_t>(-2), mbrtowc(NULL, "\xf0\xa4", 1, &ps));
+  EXPECT_EQ(static_cast<size_t>(-2), mbrtowc(nullptr, "\xf0\xa4", 1, &ps));
   EXPECT_EQ(1U, wcrtomb(out, L'\0', &ps));
   EXPECT_TRUE(mbsinit(&ps));
 }
@@ -123,37 +123,37 @@
   char bytes[BUFSIZ];
 
   // Given a NULL destination, these functions count valid characters.
-  EXPECT_EQ(5U, wcstombs(NULL, chars, 0));
-  EXPECT_EQ(5U, wcstombs(NULL, chars, 4));
-  EXPECT_EQ(5U, wcstombs(NULL, chars, 256));
+  EXPECT_EQ(5U, wcstombs(nullptr, chars, 0));
+  EXPECT_EQ(5U, wcstombs(nullptr, chars, 4));
+  EXPECT_EQ(5U, wcstombs(nullptr, chars, 256));
   src = chars;
-  EXPECT_EQ(5U, wcsrtombs(NULL, &src, 0, NULL));
+  EXPECT_EQ(5U, wcsrtombs(nullptr, &src, 0, nullptr));
   EXPECT_EQ(&chars[0], src);
   src = chars;
-  EXPECT_EQ(5U, wcsrtombs(NULL, &src, 4, NULL));
+  EXPECT_EQ(5U, wcsrtombs(nullptr, &src, 4, nullptr));
   EXPECT_EQ(&chars[0], src);
   src = chars;
-  EXPECT_EQ(5U, wcsrtombs(NULL, &src, 256, NULL));
+  EXPECT_EQ(5U, wcsrtombs(nullptr, &src, 256, nullptr));
   EXPECT_EQ(&chars[0], src);
 
   // An unrepresentable char just returns an error from wcstombs...
   errno = 0;
-  EXPECT_EQ(static_cast<size_t>(-1), wcstombs(NULL, bad_chars, 0));
+  EXPECT_EQ(static_cast<size_t>(-1), wcstombs(nullptr, bad_chars, 0));
   EXPECT_EQ(EILSEQ, errno);
   errno = 0;
-  EXPECT_EQ(static_cast<size_t>(-1), wcstombs(NULL, bad_chars, 256));
+  EXPECT_EQ(static_cast<size_t>(-1), wcstombs(nullptr, bad_chars, 256));
   EXPECT_EQ(EILSEQ, errno);
 
   // And wcsrtombs doesn't tell us where it got stuck because we didn't ask it
   // to actually convert anything...
   errno = 0;
   src = bad_chars;
-  EXPECT_EQ(static_cast<size_t>(-1), wcsrtombs(NULL, &src, 0, NULL));
+  EXPECT_EQ(static_cast<size_t>(-1), wcsrtombs(nullptr, &src, 0, nullptr));
   EXPECT_EQ(&bad_chars[0], src);
   EXPECT_EQ(EILSEQ, errno);
   errno = 0;
   src = bad_chars;
-  EXPECT_EQ(static_cast<size_t>(-1), wcsrtombs(NULL, &src, 256, NULL));
+  EXPECT_EQ(static_cast<size_t>(-1), wcsrtombs(nullptr, &src, 256, nullptr));
   EXPECT_EQ(&bad_chars[0], src);
   EXPECT_EQ(EILSEQ, errno);
 
@@ -180,13 +180,13 @@
   // wcsrtombs is a bit more informative...
   memset(bytes, 'x', sizeof(bytes));
   src = chars;
-  EXPECT_EQ(0U, wcsrtombs(bytes, &src, 0, NULL));
+  EXPECT_EQ(0U, wcsrtombs(bytes, &src, 0, nullptr));
   EXPECT_EQ(&chars[0], src); // No input consumed.
   EXPECT_EQ(EILSEQ, errno);
 
   memset(bytes, 'x', sizeof(bytes));
   src = chars;
-  EXPECT_EQ(4U, wcsrtombs(bytes, &src, 4, NULL));
+  EXPECT_EQ(4U, wcsrtombs(bytes, &src, 4, nullptr));
   EXPECT_EQ(&chars[4], src); // Some input consumed.
   EXPECT_EQ(EILSEQ, errno);
   bytes[5] = 0;
@@ -194,21 +194,21 @@
 
   memset(bytes, 'x', sizeof(bytes));
   src = chars;
-  EXPECT_EQ(5U, wcsrtombs(bytes, &src, 256, NULL));
-  EXPECT_EQ(NULL, src); // All input consumed!
+  EXPECT_EQ(5U, wcsrtombs(bytes, &src, 256, nullptr));
+  EXPECT_EQ(nullptr, src); // All input consumed!
   EXPECT_EQ(EILSEQ, errno);
   EXPECT_STREQ("hello", bytes);
 
   memset(bytes, 'x', sizeof(bytes));
   src = chars;
-  EXPECT_EQ(5U, wcsrtombs(bytes, &src, 6, NULL));
-  EXPECT_EQ(NULL, src); // All input consumed.
+  EXPECT_EQ(5U, wcsrtombs(bytes, &src, 6, nullptr));
+  EXPECT_EQ(nullptr, src); // All input consumed.
   EXPECT_EQ(EILSEQ, errno);
   EXPECT_STREQ("hello", bytes);
 
   memset(bytes, 'x', sizeof(bytes));
   src = bad_chars;
-  EXPECT_EQ(static_cast<size_t>(-1), wcsrtombs(bytes, &src, 256, NULL));
+  EXPECT_EQ(static_cast<size_t>(-1), wcsrtombs(bytes, &src, 256, nullptr));
   EXPECT_EQ(&bad_chars[2], src);
   EXPECT_EQ(EILSEQ, errno);
   bytes[3] = 0;
@@ -218,8 +218,8 @@
   mbstate_t ps;
   src = chars;
   memset(&ps, 0, sizeof(ps));
-  ASSERT_EQ(static_cast<size_t>(-2), mbrtowc(NULL, "\xc2", 1, &ps));
-  EXPECT_EQ(static_cast<size_t>(-1), wcsrtombs(NULL, &src, 0, &ps));
+  ASSERT_EQ(static_cast<size_t>(-2), mbrtowc(nullptr, "\xc2", 1, &ps));
+  EXPECT_EQ(static_cast<size_t>(-1), wcsrtombs(nullptr, &src, 0, &ps));
   EXPECT_EQ(EILSEQ, errno);
 }
 
@@ -235,12 +235,12 @@
 
   ASSERT_EQ(haystack, wcsstr(haystack, empty_needle));
   ASSERT_EQ(&haystack[10], wcsstr(haystack, good_needle));
-  ASSERT_EQ(NULL, wcsstr(haystack, bad_needle));
+  ASSERT_EQ(nullptr, wcsstr(haystack, bad_needle));
 }
 
 TEST(wchar, wcsstr_80199) {
   // https://code.google.com/p/android/issues/detail?id=80199
-  ASSERT_TRUE(wcsstr(L"romrom", L"rom") != NULL);
+  ASSERT_TRUE(wcsstr(L"romrom", L"rom") != nullptr);
 }
 
 TEST(wchar, mbtowc) {
@@ -255,53 +255,53 @@
   ASSERT_EQ(1, mbtowc(out, "hello", 1));
   ASSERT_EQ(L'h', out[0]);
 
-  ASSERT_EQ(0, mbtowc(NULL, "hello", 0));
-  ASSERT_EQ(0, mbtowc(NULL, "", 0));
-  ASSERT_EQ(1, mbtowc(NULL, "hello", 1));
+  ASSERT_EQ(0, mbtowc(nullptr, "hello", 0));
+  ASSERT_EQ(0, mbtowc(nullptr, "", 0));
+  ASSERT_EQ(1, mbtowc(nullptr, "hello", 1));
 
-  ASSERT_EQ(0, mbtowc(NULL, NULL, 0));
+  ASSERT_EQ(0, mbtowc(nullptr, nullptr, 0));
 }
 
 TEST(wchar, mbrtowc) {
   wchar_t out[8];
 
   out[0] = 'x';
-  ASSERT_EQ(0U, mbrtowc(out, "hello", 0, NULL));
+  ASSERT_EQ(0U, mbrtowc(out, "hello", 0, nullptr));
   ASSERT_EQ('x', out[0]);
 
-  ASSERT_EQ(0U, mbrtowc(out, "hello", 0, NULL));
-  ASSERT_EQ(0U, mbrtowc(out, "", 0, NULL));
-  ASSERT_EQ(1U, mbrtowc(out, "hello", 1, NULL));
+  ASSERT_EQ(0U, mbrtowc(out, "hello", 0, nullptr));
+  ASSERT_EQ(0U, mbrtowc(out, "", 0, nullptr));
+  ASSERT_EQ(1U, mbrtowc(out, "hello", 1, nullptr));
   ASSERT_EQ(L'h', out[0]);
 
-  ASSERT_EQ(0U, mbrtowc(NULL, "hello", 0, NULL));
-  ASSERT_EQ(0U, mbrtowc(NULL, "", 0, NULL));
-  ASSERT_EQ(1U, mbrtowc(NULL, "hello", 1, NULL));
+  ASSERT_EQ(0U, mbrtowc(nullptr, "hello", 0, nullptr));
+  ASSERT_EQ(0U, mbrtowc(nullptr, "", 0, nullptr));
+  ASSERT_EQ(1U, mbrtowc(nullptr, "hello", 1, nullptr));
 
-  ASSERT_EQ(0U, mbrtowc(NULL, NULL, 0, NULL));
+  ASSERT_EQ(0U, mbrtowc(nullptr, nullptr, 0, nullptr));
 
   ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
   uselocale(LC_GLOBAL_LOCALE);
 
   // 1-byte UTF-8.
-  ASSERT_EQ(1U, mbrtowc(out, "abcdef", 6, NULL));
+  ASSERT_EQ(1U, mbrtowc(out, "abcdef", 6, nullptr));
   ASSERT_EQ(L'a', out[0]);
   // 2-byte UTF-8.
-  ASSERT_EQ(2U, mbrtowc(out, "\xc2\xa2" "cdef", 6, NULL));
+  ASSERT_EQ(2U, mbrtowc(out, "\xc2\xa2" "cdef", 6, nullptr));
   ASSERT_EQ(static_cast<wchar_t>(0x00a2), out[0]);
   // 3-byte UTF-8.
-  ASSERT_EQ(3U, mbrtowc(out, "\xe2\x82\xac" "def", 6, NULL));
+  ASSERT_EQ(3U, mbrtowc(out, "\xe2\x82\xac" "def", 6, nullptr));
   ASSERT_EQ(static_cast<wchar_t>(0x20ac), out[0]);
   // 4-byte UTF-8.
-  ASSERT_EQ(4U, mbrtowc(out, "\xf0\xa4\xad\xa2" "ef", 6, NULL));
+  ASSERT_EQ(4U, mbrtowc(out, "\xf0\xa4\xad\xa2" "ef", 6, nullptr));
   ASSERT_EQ(static_cast<wchar_t>(0x24b62), out[0]);
 #if defined(__BIONIC__) // glibc allows this.
   // Illegal 5-byte UTF-8.
-  ASSERT_EQ(static_cast<size_t>(-1), mbrtowc(out, "\xf8\xa1\xa2\xa3\xa4" "f", 6, NULL));
+  ASSERT_EQ(static_cast<size_t>(-1), mbrtowc(out, "\xf8\xa1\xa2\xa3\xa4" "f", 6, nullptr));
   ASSERT_EQ(EILSEQ, errno);
 #endif
   // Illegal over-long sequence.
-  ASSERT_EQ(static_cast<size_t>(-1), mbrtowc(out, "\xf0\x82\x82\xac" "ef", 6, NULL));
+  ASSERT_EQ(static_cast<size_t>(-1), mbrtowc(out, "\xf0\x82\x82\xac" "ef", 6, nullptr));
   ASSERT_EQ(EILSEQ, errno);
 }
 
@@ -361,7 +361,7 @@
   memset(&ps, 0, sizeof(ps));
 
   test_mbrtowc_incomplete(&ps);
-  test_mbrtowc_incomplete(NULL);
+  test_mbrtowc_incomplete(nullptr);
 }
 
 static void test_mbsrtowcs(mbstate_t* ps) {
@@ -419,7 +419,7 @@
   mbstate_t ps;
   memset(&ps, 0, sizeof(ps));
   test_mbsrtowcs(&ps);
-  test_mbsrtowcs(NULL);
+  test_mbsrtowcs(nullptr);
 
   // Invalid multi byte continuation.
   const char* invalid = "\x20";
@@ -531,18 +531,18 @@
 
   memset(dst, 0, sizeof(dst));
   src = s;
-  ASSERT_EQ(0U, mbsnrtowcs(dst, &src, 0, 0, NULL));
+  ASSERT_EQ(0U, mbsnrtowcs(dst, &src, 0, 0, nullptr));
 
   memset(dst, 0, sizeof(dst));
   src = s;
-  ASSERT_EQ(2U, mbsnrtowcs(dst, &src, 2, 123, NULL)); // glibc chokes on SIZE_MAX here.
+  ASSERT_EQ(2U, mbsnrtowcs(dst, &src, 2, 123, nullptr)); // glibc chokes on SIZE_MAX here.
   ASSERT_EQ(L'h', dst[0]);
   ASSERT_EQ(L'e', dst[1]);
   ASSERT_EQ(&s[2], src);
 
   memset(dst, 0, sizeof(dst));
   src = s;
-  ASSERT_EQ(3U, mbsnrtowcs(dst, &src, SIZE_MAX, 3, NULL));
+  ASSERT_EQ(3U, mbsnrtowcs(dst, &src, SIZE_MAX, 3, nullptr));
   ASSERT_EQ(L'h', dst[0]);
   ASSERT_EQ(L'e', dst[1]);
   ASSERT_EQ(L'l', dst[2]);
@@ -669,19 +669,19 @@
   size_t n;
 
   // 1-byte character.
-  n = mbrtowc(&wc, "x", MB_CUR_MAX, NULL);
+  n = mbrtowc(&wc, "x", MB_CUR_MAX, nullptr);
   EXPECT_EQ(1U, n);
   EXPECT_EQ(L'x', wc);
   // 2-byte character.
-  n = mbrtowc(&wc, "\xc2\xa2", MB_CUR_MAX, NULL);
+  n = mbrtowc(&wc, "\xc2\xa2", MB_CUR_MAX, nullptr);
   EXPECT_EQ(2U, n);
   EXPECT_EQ(L'¢', wc);
   // 3-byte character.
-  n = mbrtowc(&wc, "\xe2\x82\xac", MB_CUR_MAX, NULL);
+  n = mbrtowc(&wc, "\xe2\x82\xac", MB_CUR_MAX, nullptr);
   EXPECT_EQ(3U, n);
   EXPECT_EQ(L'€', wc);
   // 4-byte character.
-  n = mbrtowc(&wc, "\xf0\xa4\xad\xa2", MB_CUR_MAX, NULL);
+  n = mbrtowc(&wc, "\xf0\xa4\xad\xa2", MB_CUR_MAX, nullptr);
   EXPECT_EQ(4U, n);
   EXPECT_EQ(L'𤭢', wc);
 }
@@ -719,73 +719,73 @@
 
 TEST(wchar, wcstol_EINVAL) {
   errno = 0;
-  wcstol(L"123", NULL, -1);
+  wcstol(L"123", nullptr, -1);
   ASSERT_EQ(EINVAL, errno);
   errno = 0;
-  wcstol(L"123", NULL, 1);
+  wcstol(L"123", nullptr, 1);
   ASSERT_EQ(EINVAL, errno);
   errno = 0;
-  wcstol(L"123", NULL, 37);
+  wcstol(L"123", nullptr, 37);
   ASSERT_EQ(EINVAL, errno);
 }
 
 TEST(wchar, wcstoll_EINVAL) {
   errno = 0;
-  wcstoll(L"123", NULL, -1);
+  wcstoll(L"123", nullptr, -1);
   ASSERT_EQ(EINVAL, errno);
   errno = 0;
-  wcstoll(L"123", NULL, 1);
+  wcstoll(L"123", nullptr, 1);
   ASSERT_EQ(EINVAL, errno);
   errno = 0;
-  wcstoll(L"123", NULL, 37);
+  wcstoll(L"123", nullptr, 37);
   ASSERT_EQ(EINVAL, errno);
 }
 
 TEST(wchar, wcstoul_EINVAL) {
   errno = 0;
-  wcstoul(L"123", NULL, -1);
+  wcstoul(L"123", nullptr, -1);
   ASSERT_EQ(EINVAL, errno);
   errno = 0;
-  wcstoul(L"123", NULL, 1);
+  wcstoul(L"123", nullptr, 1);
   ASSERT_EQ(EINVAL, errno);
   errno = 0;
-  wcstoul(L"123", NULL, 37);
+  wcstoul(L"123", nullptr, 37);
   ASSERT_EQ(EINVAL, errno);
 }
 
 TEST(wchar, wcstoull_EINVAL) {
   errno = 0;
-  wcstoull(L"123", NULL, -1);
+  wcstoull(L"123", nullptr, -1);
   ASSERT_EQ(EINVAL, errno);
   errno = 0;
-  wcstoull(L"123", NULL, 1);
+  wcstoull(L"123", nullptr, 1);
   ASSERT_EQ(EINVAL, errno);
   errno = 0;
-  wcstoull(L"123", NULL, 37);
+  wcstoull(L"123", nullptr, 37);
   ASSERT_EQ(EINVAL, errno);
 }
 
 TEST(wchar, wcstoll_l_EINVAL) {
   errno = 0;
-  wcstoll_l(L"123", NULL, -1, LC_GLOBAL_LOCALE);
+  wcstoll_l(L"123", nullptr, -1, LC_GLOBAL_LOCALE);
   ASSERT_EQ(EINVAL, errno);
   errno = 0;
-  wcstoll_l(L"123", NULL, 1, LC_GLOBAL_LOCALE);
+  wcstoll_l(L"123", nullptr, 1, LC_GLOBAL_LOCALE);
   ASSERT_EQ(EINVAL, errno);
   errno = 0;
-  wcstoll_l(L"123", NULL, 37, LC_GLOBAL_LOCALE);
+  wcstoll_l(L"123", nullptr, 37, LC_GLOBAL_LOCALE);
   ASSERT_EQ(EINVAL, errno);
 }
 
 TEST(wchar, wcstoull_l_EINVAL) {
   errno = 0;
-  wcstoull_l(L"123", NULL, -1, LC_GLOBAL_LOCALE);
+  wcstoull_l(L"123", nullptr, -1, LC_GLOBAL_LOCALE);
   ASSERT_EQ(EINVAL, errno);
   errno = 0;
-  wcstoull_l(L"123", NULL, 1, LC_GLOBAL_LOCALE);
+  wcstoull_l(L"123", nullptr, 1, LC_GLOBAL_LOCALE);
   ASSERT_EQ(EINVAL, errno);
   errno = 0;
-  wcstoull_l(L"123", NULL, 37, LC_GLOBAL_LOCALE);
+  wcstoull_l(L"123", nullptr, 37, LC_GLOBAL_LOCALE);
   ASSERT_EQ(EINVAL, errno);
 }
 
diff --git a/tests/wctype_test.cpp b/tests/wctype_test.cpp
index 7da53e0..06e1571 100644
--- a/tests/wctype_test.cpp
+++ b/tests/wctype_test.cpp
@@ -24,7 +24,7 @@
 
 class UtfLocale {
  public:
-  UtfLocale() : l(newlocale(LC_ALL, "C.UTF-8", 0)) {}
+  UtfLocale() : l(newlocale(LC_ALL, "C.UTF-8", nullptr)) {}
   ~UtfLocale() { freelocale(l); }
   locale_t l;
 };
@@ -215,18 +215,18 @@
 }
 
 TEST(wctype, towctrans) {
-  EXPECT_TRUE(wctrans("tolower") != 0);
-  EXPECT_TRUE(wctrans("toupper") != 0);
+  EXPECT_TRUE(wctrans("tolower") != nullptr);
+  EXPECT_TRUE(wctrans("toupper") != nullptr);
 
-  EXPECT_TRUE(wctrans("monkeys") == 0);
+  EXPECT_TRUE(wctrans("monkeys") == nullptr);
 }
 
 TEST(wctype, towctrans_l) {
   UtfLocale l;
-  EXPECT_TRUE(wctrans_l("tolower", l.l) != 0);
-  EXPECT_TRUE(wctrans_l("toupper", l.l) != 0);
+  EXPECT_TRUE(wctrans_l("tolower", l.l) != nullptr);
+  EXPECT_TRUE(wctrans_l("toupper", l.l) != nullptr);
 
-  EXPECT_TRUE(wctrans_l("monkeys", l.l) == 0);
+  EXPECT_TRUE(wctrans_l("monkeys", l.l) == nullptr);
 }
 
 TEST(wctype, wctrans) {