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