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) {