Add ASSERT_ERRNO and EXPECT_ERRNO (and use them).
We've talked about this many times in the past, but partners struggle to
understand "expected 38, got 22" in these contexts, and I always have to
go and check the header files just to be sure I'm sure.
I actually think the glibc geterrorname_np() function (which would
return "ENOSYS" rather than "Function not implemented") would be more
helpful, but I'll have to go and implement that first, and then come
back.
Being forced to go through all our errno assertions did also make me
want to use a more consistent style for our ENOSYS assertions in
particular --- there's a particularly readable idiom, and I'll also come
back and move more of those checks to the most readable idiom.
I've added a few missing `errno = 0`s before tests, and removed a few
stray `errno = 0`s from tests that don't actually make assertions about
errno, since I had to look at every single reference to errno anyway.
Test: treehugger
Change-Id: Iba7c56f2adc30288c3e00ade106635e515e88179
diff --git a/tests/dirent_test.cpp b/tests/dirent_test.cpp
index 3ea9cbd..4d21246 100644
--- a/tests/dirent_test.cpp
+++ b/tests/dirent_test.cpp
@@ -29,6 +29,8 @@
#include <set>
#include <string>
+#include "utils.h"
+
static void CheckProcSelf(std::set<std::string>& names) {
// We have a good idea of what should be in /proc/self.
ASSERT_TRUE(names.find(".") != names.end());
@@ -124,7 +126,6 @@
TEST(dirent, scandir_filter) {
dirent** entries;
- errno = 0;
ASSERT_EQ(1, scandir("/proc", &entries, is_version_filter, nullptr));
ASSERT_STREQ("version", entries[0]->d_name);
free(entries);
@@ -134,14 +135,14 @@
dirent** entries;
errno = 0;
ASSERT_EQ(-1, scandir("/does-not-exist", &entries, nullptr, nullptr));
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
}
TEST(dirent, scandir64_ENOENT) {
dirent64** entries;
errno = 0;
ASSERT_EQ(-1, scandir64("/does-not-exist", &entries, nullptr, nullptr));
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
}
TEST(dirent, scandirat_ENOENT) {
@@ -151,7 +152,7 @@
dirent** entries;
errno = 0;
ASSERT_EQ(-1, scandirat(root_fd, "does-not-exist", &entries, nullptr, nullptr));
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
close(root_fd);
#else
GTEST_SKIP() << "musl doesn't have scandirat or scandirat64";
@@ -165,7 +166,7 @@
dirent64** entries;
errno = 0;
ASSERT_EQ(-1, scandirat64(root_fd, "does-not-exist", &entries, nullptr, nullptr));
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
close(root_fd);
#else
GTEST_SKIP() << "musl doesn't have scandirat or scandirat64";
@@ -174,12 +175,12 @@
TEST(dirent, fdopendir_invalid) {
ASSERT_TRUE(fdopendir(-1) == nullptr);
- ASSERT_EQ(EBADF, errno);
+ ASSERT_ERRNO(EBADF);
int fd = open("/dev/null", O_RDONLY);
ASSERT_NE(fd, -1);
ASSERT_TRUE(fdopendir(fd) == nullptr);
- ASSERT_EQ(ENOTDIR, errno);
+ ASSERT_ERRNO(ENOTDIR);
close(fd);
}
@@ -193,15 +194,17 @@
// fdopendir(3) took ownership, so closedir(3) closed our fd.
ASSERT_EQ(close(fd), -1);
- ASSERT_EQ(EBADF, errno);
+ ASSERT_ERRNO(EBADF);
}
TEST(dirent, opendir_invalid) {
+ errno = 0;
ASSERT_TRUE(opendir("/does/not/exist") == nullptr);
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
+ errno = 0;
ASSERT_TRUE(opendir("/dev/null") == nullptr);
- ASSERT_EQ(ENOTDIR, errno);
+ ASSERT_ERRNO(ENOTDIR);
}
TEST(dirent, opendir) {
@@ -215,7 +218,7 @@
TEST(dirent, closedir_invalid) {
DIR* d = nullptr;
ASSERT_EQ(closedir(d), -1);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(dirent, closedir) {
@@ -235,7 +238,7 @@
}
// Reading to the end of the directory is not an error.
// readdir(3) returns NULL, but leaves errno as 0.
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
ASSERT_EQ(closedir(d), 0);
CheckProcSelf(name_set);
@@ -252,7 +255,7 @@
}
// Reading to the end of the directory is not an error.
// readdir64(3) returns NULL, but leaves errno as 0.
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
ASSERT_EQ(closedir(d), 0);
CheckProcSelf(name_set);
@@ -270,7 +273,7 @@
}
// Reading to the end of the directory is not an error.
// readdir_r(3) returns NULL, but leaves errno as 0.
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
ASSERT_EQ(closedir(d), 0);
CheckProcSelf(name_set);
@@ -288,7 +291,7 @@
}
// Reading to the end of the directory is not an error.
// readdir64_r(3) returns NULL, but leaves errno as 0.
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
ASSERT_EQ(closedir(d), 0);
CheckProcSelf(name_set);
@@ -365,7 +368,7 @@
ASSERT_EQ(end_offset, telldir(d));
errno = 0;
ASSERT_EQ(nullptr, readdir(d));
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
ASSERT_EQ(0, closedir(d));
}
diff --git a/tests/dlfcn_test.cpp b/tests/dlfcn_test.cpp
index b68ee7b..67f1973 100644
--- a/tests/dlfcn_test.cpp
+++ b/tests/dlfcn_test.cpp
@@ -835,7 +835,7 @@
// this case.
uintptr_t page_start = reinterpret_cast<uintptr_t>(taxicab_number) & ~(PAGE_SIZE - 1);
ASSERT_TRUE(mprotect(reinterpret_cast<void*>(page_start), PAGE_SIZE, PROT_NONE) != 0);
- ASSERT_EQ(ENOMEM, errno) << strerror(errno);
+ ASSERT_ERRNO(ENOMEM);
}
static void ConcurrentDlErrorFn(std::string& error) {
diff --git a/tests/eventfd_test.cpp b/tests/eventfd_test.cpp
index eb423c1..3107a46 100644
--- a/tests/eventfd_test.cpp
+++ b/tests/eventfd_test.cpp
@@ -34,7 +34,7 @@
// Reading clears the counter.
ASSERT_EQ(-1, eventfd_read(fd, &value));
- ASSERT_EQ(EAGAIN, errno);
+ ASSERT_ERRNO(EAGAIN);
// Values written are added until the next read.
ASSERT_EQ(0, eventfd_write(fd, 1));
@@ -88,7 +88,7 @@
// The counter is cleared after the initial value decrements to 0.
ASSERT_EQ(-1, eventfd_read(fd, &value));
- ASSERT_EQ(EAGAIN, errno);
+ ASSERT_ERRNO(EAGAIN);
close(fd);
}
diff --git a/tests/fcntl_test.cpp b/tests/fcntl_test.cpp
index c1c586c..f8f559b 100644
--- a/tests/fcntl_test.cpp
+++ b/tests/fcntl_test.cpp
@@ -34,6 +34,8 @@
#include <linux/magic.h>
#endif
+#include "utils.h"
+
using fcntl_DeathTest = SilentDeathTest;
TEST(fcntl, fcntl_smoke) {
@@ -80,9 +82,9 @@
TEST(fcntl, creat_creat64) {
ASSERT_EQ(-1, creat("", 0666));
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
ASSERT_EQ(-1, creat64("", 0666));
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
}
TEST(fcntl, posix_fadvise) {
@@ -90,16 +92,16 @@
errno = 0;
EXPECT_EQ(EBADF, posix_fadvise(-1, 0, 0, POSIX_FADV_NORMAL));
- EXPECT_EQ(0, errno);
+ EXPECT_ERRNO(0);
EXPECT_EQ(EBADF, posix_fadvise64(-1, 0, 0, POSIX_FADV_NORMAL));
- EXPECT_EQ(0, errno);
+ EXPECT_ERRNO(0);
EXPECT_EQ(EINVAL, posix_fadvise(tf.fd, 0, 0, -1));
- EXPECT_EQ(0, errno);
+ EXPECT_ERRNO(0);
EXPECT_EQ(EINVAL, posix_fadvise64(tf.fd, 0, 0, -1));
- EXPECT_EQ(0, errno);
+ EXPECT_ERRNO(0);
EXPECT_EQ(0, posix_fadvise(tf.fd, 0, 0, POSIX_FADV_NORMAL));
EXPECT_EQ(0, posix_fadvise64(tf.fd, 0, 0, POSIX_FADV_NORMAL));
@@ -113,19 +115,19 @@
errno = 0;
ASSERT_EQ(-1, fallocate(tf.fd, 0, 0, -1));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
ASSERT_EQ(-1, fallocate64(tf.fd, 0, 0, -1));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
ASSERT_EQ(EINVAL, posix_fallocate(tf.fd, 0, -1));
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
errno = 0;
ASSERT_EQ(EINVAL, posix_fallocate64(tf.fd, 0, -1));
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
}
TEST(fcntl, fallocate) {
@@ -269,14 +271,14 @@
// Just check that the function is available.
errno = 0;
ASSERT_EQ(-1, readahead(-1, 0, 123));
- ASSERT_EQ(EBADF, errno);
+ ASSERT_ERRNO(EBADF);
}
TEST(fcntl, sync_file_range) {
// Just check that the function is available.
errno = 0;
ASSERT_EQ(-1, sync_file_range(-1, 0, 0, 0));
- ASSERT_EQ(EBADF, errno);
+ ASSERT_ERRNO(EBADF);
TemporaryFile tf;
ASSERT_EQ(0, sync_file_range(tf.fd, 0, 0, 0));
@@ -285,7 +287,7 @@
// Check that the `flags` argument gets passed to the kernel correctly.
errno = 0;
ASSERT_EQ(-1, sync_file_range(tf.fd, 0, 0, ~0));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
static bool parse_kernel_release(long* const major, long* const minor) {
@@ -312,7 +314,7 @@
ASSERT_EQ(0, fstatfs(tf.fd, &sfs));
if (sfs.f_type == EXT4_SUPER_MAGIC) {
ASSERT_EQ(-1, fallocate(tf.fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, 0, 1));
- ASSERT_EQ(errno, EOPNOTSUPP);
+ ASSERT_ERRNO(EOPNOTSUPP);
}
}
}
@@ -355,7 +357,7 @@
ASSERT_EQ(-1, linkat(AT_FDCWD, android::base::StringPrintf("/proc/self/fd/%d", fd).c_str(),
AT_FDCWD, android::base::StringPrintf("%s/no_chance", dir.path).c_str(),
AT_SYMLINK_FOLLOW));
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
ASSERT_EQ(0, close(fd));
#endif
}
diff --git a/tests/fdtrack_test.cpp b/tests/fdtrack_test.cpp
index 9fcb402..ff6d8c8 100644
--- a/tests/fdtrack_test.cpp
+++ b/tests/fdtrack_test.cpp
@@ -40,6 +40,8 @@
#include <android-base/logging.h>
#include <android-base/unique_fd.h>
+#include "utils.h"
+
using android::base::ReceiveFileDescriptors;
using android::base::SendFileDescriptors;
using android::base::unique_fd;
@@ -234,7 +236,7 @@
FDTRACK_TEST(pidfd_open, ({
int rc = pidfd_open(getpid(), 0);
if (rc == -1) {
- ASSERT_EQ(ENOSYS, errno);
+ ASSERT_ERRNO(ENOSYS);
GTEST_SKIP() << "pidfd_open not available";
}
rc;
@@ -244,14 +246,14 @@
android_fdtrack_set_enabled(false);
int pidfd_self = pidfd_open(getpid(), 0);
if (pidfd_self == -1) {
- ASSERT_EQ(ENOSYS, errno);
+ ASSERT_ERRNO(ENOSYS);
GTEST_SKIP() << "pidfd_open not available";
}
android_fdtrack_set_enabled(true);
int rc = pidfd_getfd(pidfd_self, STDIN_FILENO, 0);
if (rc == -1) {
- ASSERT_EQ(ENOSYS, errno);
+ ASSERT_ERRNO(ENOSYS);
GTEST_SKIP() << "pidfd_getfd not available";
}
diff --git a/tests/ftw_test.cpp b/tests/ftw_test.cpp
index 6473f71..9d9c1d3 100644
--- a/tests/ftw_test.cpp
+++ b/tests/ftw_test.cpp
@@ -28,6 +28,8 @@
#include <android-base/stringprintf.h>
#include <gtest/gtest.h>
+#include "utils.h"
+
static void MakeTree(const char* root) {
char path[PATH_MAX];
@@ -167,35 +169,35 @@
TEST(ftw, ftw_non_existent_ENOENT) {
errno = 0;
ASSERT_EQ(-1, ftw("/does/not/exist", null_ftw_callback<struct stat>, 128));
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
errno = 0;
ASSERT_EQ(-1, ftw64("/does/not/exist", null_ftw_callback<struct stat64>, 128));
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
}
TEST(ftw, nftw_non_existent_ENOENT) {
errno = 0;
ASSERT_EQ(-1, nftw("/does/not/exist", null_nftw_callback<struct stat>, 128, FTW_PHYS));
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
errno = 0;
ASSERT_EQ(-1, nftw64("/does/not/exist", null_nftw_callback<struct stat64>, 128, FTW_PHYS));
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
}
TEST(ftw, ftw_empty_ENOENT) {
errno = 0;
ASSERT_EQ(-1, ftw("", null_ftw_callback<struct stat>, 128));
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
errno = 0;
ASSERT_EQ(-1, ftw64("", null_ftw_callback<struct stat64>, 128));
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
}
TEST(ftw, nftw_empty_ENOENT) {
errno = 0;
ASSERT_EQ(-1, nftw("", null_nftw_callback<struct stat>, 128, FTW_PHYS));
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
errno = 0;
ASSERT_EQ(-1, nftw64("", null_nftw_callback<struct stat64>, 128, FTW_PHYS));
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
}
diff --git a/tests/getauxval_test.cpp b/tests/getauxval_test.cpp
index f4ec7f5..3016432 100644
--- a/tests/getauxval_test.cpp
+++ b/tests/getauxval_test.cpp
@@ -21,6 +21,8 @@
#include <sys/utsname.h>
#include <gtest/gtest.h>
+#include "utils.h"
+
TEST(getauxval, expected_values) {
ASSERT_EQ(0UL, getauxval(AT_SECURE));
ASSERT_EQ(getuid(), getauxval(AT_UID));
@@ -38,7 +40,7 @@
TEST(getauxval, unexpected_values) {
errno = 0;
ASSERT_EQ(0UL, getauxval(0xdeadbeef));
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
}
TEST(getauxval, arm_has_AT_HWCAP2) {
@@ -57,7 +59,7 @@
// to check errno to see whether we got a "true" 0 or a "not found" 0.
errno = 0;
getauxval(AT_HWCAP2);
- ASSERT_EQ(0, errno) << "64-bit kernel not reporting AT_HWCAP2 to 32-bit ARM process";
+ ASSERT_ERRNO(0) << "64-bit kernel not reporting AT_HWCAP2 to 32-bit ARM process";
return;
}
#endif
diff --git a/tests/getcwd_test.cpp b/tests/getcwd_test.cpp
index 4fec40b..26ea75f 100644
--- a/tests/getcwd_test.cpp
+++ b/tests/getcwd_test.cpp
@@ -29,7 +29,7 @@
errno = 0;
char* cwd = getcwd(nullptr, 0);
ASSERT_TRUE(cwd != nullptr);
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
ASSERT_GE(strlen(cwd), 1U);
free(cwd);
}
@@ -39,7 +39,7 @@
errno = 0;
char* cwd = getcwd(nullptr, PATH_MAX);
ASSERT_TRUE(cwd != nullptr);
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
ASSERT_GE(strlen(cwd), 1U);
free(cwd);
}
@@ -49,7 +49,7 @@
errno = 0;
char* cwd = getcwd(nullptr, 1);
ASSERT_TRUE(cwd == nullptr);
- ASSERT_EQ(ERANGE, errno);
+ ASSERT_ERRNO(ERANGE);
}
TEST(getcwd, auto_too_large) {
@@ -58,7 +58,7 @@
errno = 0;
char* cwd = getcwd(nullptr, static_cast<size_t>(-1));
ASSERT_TRUE(cwd == nullptr);
- ASSERT_EQ(ENOMEM, errno);
+ ASSERT_ERRNO(ENOMEM);
}
TEST(getcwd, manual_too_small) {
@@ -67,7 +67,7 @@
errno = 0;
char* cwd = getcwd(tiny_buf, sizeof(tiny_buf));
ASSERT_TRUE(cwd == nullptr);
- ASSERT_EQ(ERANGE, errno);
+ ASSERT_ERRNO(ERANGE);
}
TEST(getcwd, manual_zero) {
@@ -76,7 +76,7 @@
errno = 0;
char* cwd = getcwd(tiny_buf, 0);
ASSERT_TRUE(cwd == nullptr);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(getcwd, manual_path_max) {
@@ -84,7 +84,7 @@
errno = 0;
char* cwd = getcwd(buf, PATH_MAX);
ASSERT_TRUE(cwd == buf);
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
ASSERT_GE(strlen(cwd), 1U);
delete[] cwd;
}
diff --git a/tests/grp_pwd_test.cpp b/tests/grp_pwd_test.cpp
index 65a54a6..d3acf03 100644
--- a/tests/grp_pwd_test.cpp
+++ b/tests/grp_pwd_test.cpp
@@ -41,6 +41,8 @@
// Generated android_ids array
#include "generated_android_ids.h"
+#include "utils.h"
+
using android::base::Join;
using android::base::ReadFileToString;
using android::base::Split;
@@ -86,7 +88,7 @@
bool check_username) {
errno = 0;
passwd* pwd = getpwuid(uid);
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
SCOPED_TRACE("getpwuid");
check_passwd(pwd, username, uid, uid_type, check_username);
}
@@ -95,7 +97,7 @@
bool check_username) {
errno = 0;
passwd* pwd = getpwnam(username);
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
SCOPED_TRACE("getpwnam");
check_passwd(pwd, username, uid, uid_type, check_username);
}
@@ -110,7 +112,7 @@
passwd* pwd = nullptr;
result = getpwuid_r(uid, &pwd_storage, buf, sizeof(buf), &pwd);
ASSERT_EQ(0, result);
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
SCOPED_TRACE("getpwuid_r");
check_passwd(pwd, username, uid, uid_type, check_username);
}
@@ -125,7 +127,7 @@
passwd* pwd = nullptr;
result = getpwnam_r(username, &pwd_storage, buf, sizeof(buf), &pwd);
ASSERT_EQ(0, result);
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
SCOPED_TRACE("getpwnam_r");
check_passwd(pwd, username, uid, uid_type, check_username);
}
@@ -145,7 +147,7 @@
passwd* passwd = nullptr;
passwd = getpwuid(uid);
EXPECT_EQ(nullptr, passwd) << "name = '" << passwd->pw_name << "'";
- EXPECT_EQ(ENOENT, errno);
+ EXPECT_ERRNO(ENOENT);
struct passwd passwd_storage;
char buf[512];
@@ -159,7 +161,7 @@
passwd* passwd = nullptr;
passwd = getpwnam(username);
EXPECT_EQ(nullptr, passwd) << "name = '" << passwd->pw_name << "'";
- EXPECT_EQ(ENOENT, errno);
+ EXPECT_ERRNO(ENOENT);
struct passwd passwd_storage;
char buf[512];
@@ -507,7 +509,7 @@
static void check_getgrgid(const char* group_name, gid_t gid, bool check_groupname) {
errno = 0;
group* grp = getgrgid(gid);
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
SCOPED_TRACE("getgrgid");
check_group(grp, group_name, gid, check_groupname);
}
@@ -515,7 +517,7 @@
static void check_getgrnam(const char* group_name, gid_t gid, bool check_groupname) {
errno = 0;
group* grp = getgrnam(group_name);
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
SCOPED_TRACE("getgrnam");
check_group(grp, group_name, gid, check_groupname);
}
@@ -528,7 +530,7 @@
errno = 0;
int result = getgrgid_r(gid, &grp_storage, buf, sizeof(buf), &grp);
ASSERT_EQ(0, result);
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
SCOPED_TRACE("getgrgid_r");
check_group(grp, group_name, gid, check_groupname);
}
@@ -541,7 +543,7 @@
errno = 0;
int result = getgrnam_r(group_name, &grp_storage, buf, sizeof(buf), &grp);
ASSERT_EQ(0, result);
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
SCOPED_TRACE("getgrnam_r");
check_group(grp, group_name, gid, check_groupname);
}
@@ -560,7 +562,7 @@
group* group = nullptr;
group = getgrgid(gid);
EXPECT_EQ(nullptr, group) << "name = '" << group->gr_name << "'";
- EXPECT_EQ(ENOENT, errno);
+ EXPECT_ERRNO(ENOENT);
struct group group_storage;
char buf[512];
@@ -574,7 +576,7 @@
group* group = nullptr;
group = getgrnam(groupname);
EXPECT_EQ(nullptr, group) << "name = '" << group->gr_name << "'";
- EXPECT_EQ(ENOENT, errno);
+ EXPECT_ERRNO(ENOENT);
struct group group_storage;
char buf[512];
diff --git a/tests/iconv_test.cpp b/tests/iconv_test.cpp
index bd99000..9a2a46f 100644
--- a/tests/iconv_test.cpp
+++ b/tests/iconv_test.cpp
@@ -18,18 +18,20 @@
#include <iconv.h>
+#include "utils.h"
+
#define INVALID_ICONV_T reinterpret_cast<iconv_t>(-1)
TEST(iconv, iconv_open_EINVAL) {
errno = 0;
ASSERT_EQ(INVALID_ICONV_T, iconv_open("silly", "silly"));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
ASSERT_EQ(INVALID_ICONV_T, iconv_open("silly", "UTF-8"));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
ASSERT_EQ(INVALID_ICONV_T, iconv_open("UTF-8", "silly"));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(iconv, iconv_open_comparator) {
@@ -44,10 +46,10 @@
// "...but not "utf-80" or "ut8"."
errno = 0;
ASSERT_EQ(INVALID_ICONV_T, iconv_open("UTF-8", "utf-80"));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
ASSERT_EQ(INVALID_ICONV_T, iconv_open("UTF-8", "ut80"));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(iconv, iconv_smoke) {
@@ -122,7 +124,7 @@
// With "//IGNORE", we just skip them (but return failure).
errno = 0;
EXPECT_EQ(static_cast<size_t>(-1), iconv(c, &in, &in_bytes, &out, &out_bytes));
- EXPECT_EQ(EILSEQ, errno);
+ EXPECT_ERRNO(EILSEQ);
EXPECT_EQ('a', buf[0]);
EXPECT_EQ('z', buf[1]);
@@ -149,7 +151,7 @@
// The second input character isn't representable as ASCII, so we stop there.
errno = 0;
EXPECT_EQ(static_cast<size_t>(-1), iconv(c, &in, &in_bytes, &out, &out_bytes));
- EXPECT_EQ(EILSEQ, errno);
+ EXPECT_ERRNO(EILSEQ);
EXPECT_EQ('a', buf[0]);
EXPECT_EQ(0, buf[1]);
@@ -175,13 +177,13 @@
// The second input byte is a malformed character, so we stop there.
errno = 0;
EXPECT_EQ(static_cast<size_t>(-1), iconv(c, &in, &in_bytes, &out, &out_bytes));
- EXPECT_EQ(EILSEQ, errno);
+ EXPECT_ERRNO(EILSEQ);
EXPECT_EQ('\xd9', *in); // *in is left pointing to the start of the invalid sequence.
++in;
--in_bytes;
errno = 0;
EXPECT_EQ(0U, iconv(c, &in, &in_bytes, &out, &out_bytes));
- EXPECT_EQ(0, errno);
+ EXPECT_ERRNO(0);
EXPECT_EQ('a', buf[0]);
EXPECT_EQ('z', buf[1]);
@@ -208,7 +210,7 @@
// The second input byte is just the start of a character, and we don't have any more bytes.
errno = 0;
EXPECT_EQ(static_cast<size_t>(-1), iconv(c, &in, &in_bytes, &out, &out_bytes));
- EXPECT_EQ(EINVAL, errno);
+ EXPECT_ERRNO(EINVAL);
EXPECT_EQ('\xd9', *in); // *in is left pointing to the start of the incomplete sequence.
EXPECT_EQ('a', buf[0]);
@@ -236,7 +238,7 @@
out_bytes = 1;
errno = 0;
EXPECT_EQ(static_cast<size_t>(-1), iconv(c, &in, &in_bytes, &out, &out_bytes));
- EXPECT_EQ(E2BIG, errno);
+ EXPECT_ERRNO(E2BIG);
EXPECT_EQ(2U, in_bytes);
EXPECT_EQ(0U, out_bytes);
@@ -244,7 +246,7 @@
out_bytes = 0;
errno = 0;
EXPECT_EQ(static_cast<size_t>(-1), iconv(c, &in, &in_bytes, &out, &out_bytes));
- EXPECT_EQ(E2BIG, errno);
+ EXPECT_ERRNO(E2BIG);
EXPECT_EQ(2U, in_bytes);
EXPECT_EQ(0U, out_bytes);
@@ -252,7 +254,7 @@
out_bytes = 1;
errno = 0;
EXPECT_EQ(static_cast<size_t>(-1), iconv(c, &in, &in_bytes, &out, &out_bytes));
- EXPECT_EQ(E2BIG, errno);
+ EXPECT_ERRNO(E2BIG);
EXPECT_EQ(1U, in_bytes);
EXPECT_EQ(0U, out_bytes);
@@ -260,7 +262,7 @@
out_bytes = 1;
errno = 0;
EXPECT_EQ(0U, iconv(c, &in, &in_bytes, &out, &out_bytes));
- EXPECT_EQ(0, errno);
+ EXPECT_ERRNO(0);
EXPECT_EQ(0U, in_bytes);
EXPECT_EQ(0U, out_bytes);
@@ -279,13 +281,13 @@
size_t out_bytes = 0;
errno = 0;
ASSERT_EQ(static_cast<size_t>(-1), iconv(INVALID_ICONV_T, &in, &in_bytes, &out, &out_bytes));
- ASSERT_EQ(EBADF, errno);
+ ASSERT_ERRNO(EBADF);
}
TEST(iconv, iconv_close_invalid_converter_EBADF) {
errno = 0;
ASSERT_EQ(-1, iconv_close(INVALID_ICONV_T));
- ASSERT_EQ(EBADF, errno);
+ ASSERT_ERRNO(EBADF);
}
static void RoundTrip(const char* dst_enc, const char* expected_bytes, size_t n) {
@@ -368,7 +370,7 @@
char* out = reinterpret_cast<char*>(out_buf);
errno = 0;
ASSERT_EQ(static_cast<size_t>(-1), iconv(c, &in, &in_bytes, &out, &out_bytes));
- EXPECT_EQ(expected_errno, errno);
+ EXPECT_ERRNO(expected_errno);
EXPECT_EQ(0, iconv_close(c));
}
@@ -442,13 +444,13 @@
// Points to a null pointer...
errno = 0;
ASSERT_EQ(static_cast<size_t>(0), iconv(c, &in, &in_bytes, &out, &out_bytes));
- EXPECT_EQ(0, errno);
+ EXPECT_ERRNO(0);
EXPECT_EQ(sizeof(out_buf), out_bytes);
// Is a null pointer...
errno = 0;
ASSERT_EQ(static_cast<size_t>(0), iconv(c, nullptr, &in_bytes, &out, &out_bytes));
- EXPECT_EQ(0, errno);
+ EXPECT_ERRNO(0);
EXPECT_EQ(sizeof(out_buf), out_bytes);
// Is a null pointer and so is in_bytes. This isn't specified by POSIX, but
@@ -456,7 +458,7 @@
// https://issuetracker.google.com/180598400
errno = 0;
ASSERT_EQ(static_cast<size_t>(0), iconv(c, nullptr, nullptr, &out, &out_bytes));
- EXPECT_EQ(0, errno);
+ EXPECT_ERRNO(0);
EXPECT_EQ(sizeof(out_buf), out_bytes);
EXPECT_EQ(0, iconv_close(c));
diff --git a/tests/ifaddrs_test.cpp b/tests/ifaddrs_test.cpp
index 4b9d4d8..95562be 100644
--- a/tests/ifaddrs_test.cpp
+++ b/tests/ifaddrs_test.cpp
@@ -32,6 +32,8 @@
#include <thread>
#include <vector>
+#include "utils.h"
+
TEST(ifaddrs, freeifaddrs_null) {
freeifaddrs(nullptr);
}
@@ -294,7 +296,7 @@
while (true) {
int fd = open("/dev/null", O_RDONLY|O_CLOEXEC);
if (fd == -1) {
- ASSERT_EQ(EMFILE, errno);
+ ASSERT_ERRNO(EMFILE);
break;
}
fds.push_back(fd);
@@ -302,7 +304,7 @@
ifaddrs* addrs;
EXPECT_EQ(-1, getifaddrs(&addrs));
- EXPECT_EQ(EMFILE, errno);
+ EXPECT_ERRNO(EMFILE);
for (int fd : fds) close(fd);
}
diff --git a/tests/inttypes_test.cpp b/tests/inttypes_test.cpp
index f7dfdb5..70163e6 100644
--- a/tests/inttypes_test.cpp
+++ b/tests/inttypes_test.cpp
@@ -20,6 +20,8 @@
#include <gtest/gtest.h>
#include <stdio.h>
+#include "utils.h"
+
#define PRINTF_TYPED(FMT_SUFFIX, TYPE_SUFFIX) \
do { \
char buf[512]; \
@@ -124,13 +126,13 @@
TEST(inttypes, strtoimax_EINVAL) {
errno = 0;
strtoimax("123", nullptr, -1);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
strtoimax("123", nullptr, 1);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
strtoimax("123", nullptr, 37);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(inttypes, strtoumax_dec) {
@@ -154,37 +156,37 @@
TEST(inttypes, strtoumax_EINVAL) {
errno = 0;
strtoumax("123", nullptr, -1);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
strtoumax("123", nullptr, 1);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
strtoumax("123", nullptr, 37);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(inttypes, wcstoimax_EINVAL) {
errno = 0;
wcstoimax(L"123", nullptr, -1);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
wcstoimax(L"123", nullptr, 1);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
wcstoimax(L"123", nullptr, 37);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(inttypes, wcstoumax_EINVAL) {
errno = 0;
wcstoumax(L"123", nullptr, -1);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
wcstoumax(L"123", nullptr, 1);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
wcstoumax(L"123", nullptr, 37);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(inttypes, div) {
diff --git a/tests/leak_test.cpp b/tests/leak_test.cpp
index 0a881e1..bdb0ca9 100644
--- a/tests/leak_test.cpp
+++ b/tests/leak_test.cpp
@@ -48,7 +48,7 @@
if (syscall(__NR_tgkill, getpid(), tids[i], 0) == 0) {
alive = true;
} else {
- EXPECT_EQ(errno, ESRCH);
+ EXPECT_ERRNO(ESRCH);
tids[i] = 0; // Skip in next loop.
}
}
diff --git a/tests/locale_test.cpp b/tests/locale_test.cpp
index a220c83..a8ebca7 100644
--- a/tests/locale_test.cpp
+++ b/tests/locale_test.cpp
@@ -20,6 +20,8 @@
#include <limits.h>
#include <locale.h>
+#include "utils.h"
+
TEST(locale, localeconv) {
EXPECT_STREQ(".", localeconv()->decimal_point);
EXPECT_STREQ("", localeconv()->thousands_sep);
@@ -53,10 +55,10 @@
errno = 0;
EXPECT_EQ(nullptr, setlocale(-1, nullptr));
- EXPECT_EQ(EINVAL, errno);
+ EXPECT_ERRNO(EINVAL);
errno = 0;
EXPECT_EQ(nullptr, setlocale(13, nullptr));
- EXPECT_EQ(EINVAL, errno);
+ EXPECT_ERRNO(EINVAL);
#if defined(__BIONIC__)
// The "" locale is implementation-defined. For bionic, it's the C.UTF-8 locale, which is
@@ -69,13 +71,13 @@
errno = 0;
EXPECT_EQ(nullptr, setlocale(LC_ALL, "this-is-not-a-locale"));
- EXPECT_EQ(ENOENT, errno); // POSIX specified, not an implementation detail!
+ EXPECT_ERRNO(ENOENT); // POSIX specified, not an implementation detail!
}
TEST(locale, newlocale_invalid_category_mask) {
errno = 0;
EXPECT_EQ(nullptr, newlocale(1 << 20, "C", nullptr));
- EXPECT_EQ(EINVAL, errno);
+ EXPECT_ERRNO(EINVAL);
}
TEST(locale, newlocale_NULL_locale_name) {
@@ -83,14 +85,14 @@
#pragma clang diagnostic ignored "-Wnonnull"
errno = 0;
EXPECT_EQ(nullptr, newlocale(LC_ALL, nullptr, nullptr));
- EXPECT_EQ(EINVAL, errno);
+ EXPECT_ERRNO(EINVAL);
#pragma clang diagnostic pop
}
TEST(locale, newlocale_bad_locale_name) {
errno = 0;
EXPECT_EQ(nullptr, newlocale(LC_ALL, "this-is-not-a-locale", nullptr));
- EXPECT_EQ(ENOENT, errno); // POSIX specified, not an implementation detail!
+ EXPECT_ERRNO(ENOENT); // POSIX specified, not an implementation detail!
}
TEST(locale, newlocale) {
diff --git a/tests/malloc_test.cpp b/tests/malloc_test.cpp
index aa53450..2411753 100644
--- a/tests/malloc_test.cpp
+++ b/tests/malloc_test.cpp
@@ -83,7 +83,7 @@
SKIP_WITH_HWASAN;
errno = 0;
ASSERT_EQ(nullptr, malloc(SIZE_MAX));
- ASSERT_EQ(ENOMEM, errno);
+ ASSERT_ERRNO(ENOMEM);
}
TEST(malloc, calloc_std) {
@@ -120,23 +120,23 @@
SKIP_WITH_HWASAN;
errno = 0;
ASSERT_EQ(nullptr, calloc(-1, 100));
- ASSERT_EQ(ENOMEM, errno);
+ ASSERT_ERRNO(ENOMEM);
}
TEST(malloc, calloc_overflow) {
SKIP_WITH_HWASAN;
errno = 0;
ASSERT_EQ(nullptr, calloc(1, SIZE_MAX));
- ASSERT_EQ(ENOMEM, errno);
+ ASSERT_ERRNO(ENOMEM);
errno = 0;
ASSERT_EQ(nullptr, calloc(SIZE_MAX, SIZE_MAX));
- ASSERT_EQ(ENOMEM, errno);
+ ASSERT_ERRNO(ENOMEM);
errno = 0;
ASSERT_EQ(nullptr, calloc(2, SIZE_MAX));
- ASSERT_EQ(ENOMEM, errno);
+ ASSERT_ERRNO(ENOMEM);
errno = 0;
ASSERT_EQ(nullptr, calloc(SIZE_MAX, 2));
- ASSERT_EQ(ENOMEM, errno);
+ ASSERT_ERRNO(ENOMEM);
}
TEST(malloc, memalign_multiple) {
@@ -346,12 +346,12 @@
SKIP_WITH_HWASAN;
errno = 0;
ASSERT_EQ(nullptr, realloc(nullptr, SIZE_MAX));
- ASSERT_EQ(ENOMEM, errno);
+ ASSERT_ERRNO(ENOMEM);
void* ptr = malloc(100);
ASSERT_TRUE(ptr != nullptr);
errno = 0;
ASSERT_EQ(nullptr, realloc(ptr, SIZE_MAX));
- ASSERT_EQ(ENOMEM, errno);
+ ASSERT_ERRNO(ENOMEM);
free(ptr);
}
@@ -669,7 +669,7 @@
errno = 0;
ASSERT_EQ(0, mallopt(-1000, 1));
// mallopt doesn't set errno.
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
#else
GTEST_SKIP() << "bionic-only test";
#endif
@@ -678,7 +678,6 @@
TEST(malloc, mallopt_decay) {
#if defined(__BIONIC__)
SKIP_WITH_HWASAN << "hwasan does not implement mallopt";
- errno = 0;
ASSERT_EQ(1, mallopt(M_DECAY_TIME, 1));
ASSERT_EQ(1, mallopt(M_DECAY_TIME, 0));
ASSERT_EQ(1, mallopt(M_DECAY_TIME, 1));
@@ -691,7 +690,6 @@
TEST(malloc, mallopt_purge) {
#if defined(__BIONIC__)
SKIP_WITH_HWASAN << "hwasan does not implement mallopt";
- errno = 0;
ASSERT_EQ(1, mallopt(M_PURGE, 0));
#else
GTEST_SKIP() << "bionic-only test";
@@ -701,7 +699,6 @@
TEST(malloc, mallopt_purge_all) {
#if defined(__BIONIC__)
SKIP_WITH_HWASAN << "hwasan does not implement mallopt";
- errno = 0;
ASSERT_EQ(1, mallopt(M_PURGE_ALL, 0));
#else
GTEST_SKIP() << "bionic-only test";
@@ -797,11 +794,11 @@
errno = 0;
ASSERT_TRUE(reallocarray(nullptr, a, b) == nullptr);
- ASSERT_EQ(ENOMEM, errno);
+ ASSERT_ERRNO(ENOMEM);
errno = 0;
ASSERT_TRUE(reallocarray(nullptr, b, a) == nullptr);
- ASSERT_EQ(ENOMEM, errno);
+ ASSERT_ERRNO(ENOMEM);
#else
GTEST_SKIP() << "reallocarray not available";
#endif
@@ -1120,7 +1117,7 @@
const int unrecognized_option = -1;
errno = 0;
EXPECT_EQ(false, android_mallopt(unrecognized_option, nullptr, 0));
- EXPECT_EQ(ENOTSUP, errno);
+ EXPECT_ERRNO(ENOTSUP);
#else
GTEST_SKIP() << "bionic-only test";
#endif
@@ -1151,11 +1148,11 @@
errno = 0;
if (IsDynamic()) {
EXPECT_EQ(true, android_mallopt(M_INIT_ZYGOTE_CHILD_PROFILING, nullptr, 0));
- EXPECT_EQ(0, errno);
+ EXPECT_ERRNO(0);
} else {
// Not supported in static executables.
EXPECT_EQ(false, android_mallopt(M_INIT_ZYGOTE_CHILD_PROFILING, nullptr, 0));
- EXPECT_EQ(ENOTSUP, errno);
+ EXPECT_ERRNO(ENOTSUP);
}
// Unexpected arguments rejected.
@@ -1163,9 +1160,9 @@
char unexpected = 0;
EXPECT_EQ(false, android_mallopt(M_INIT_ZYGOTE_CHILD_PROFILING, &unexpected, 1));
if (IsDynamic()) {
- EXPECT_EQ(EINVAL, errno);
+ EXPECT_ERRNO(EINVAL);
} else {
- EXPECT_EQ(ENOTSUP, errno);
+ EXPECT_ERRNO(ENOTSUP);
}
#else
GTEST_SKIP() << "bionic-only test";
diff --git a/tests/membarrier_test.cpp b/tests/membarrier_test.cpp
index 6f650e7..891488b 100644
--- a/tests/membarrier_test.cpp
+++ b/tests/membarrier_test.cpp
@@ -22,6 +22,8 @@
#include <linux/membarrier.h>
#include <sys/syscall.h>
+#include "utils.h"
+
class ScopedErrnoCleaner {
public:
ScopedErrnoCleaner() { errno = 0; }
@@ -92,7 +94,7 @@
} else {
// Private barrier should fail.
ASSERT_EQ(-1, syscall(__NR_membarrier, membarrier_cmd_barrier, 0));
- ASSERT_EQ(EPERM, errno);
+ ASSERT_ERRNO(EPERM);
errno = 0;
}
diff --git a/tests/netinet_in_test.cpp b/tests/netinet_in_test.cpp
index b7dd7c5..48f438c 100644
--- a/tests/netinet_in_test.cpp
+++ b/tests/netinet_in_test.cpp
@@ -23,6 +23,8 @@
#include <android-base/macros.h>
+#include "utils.h"
+
static constexpr uint16_t le16 = 0x1234;
static constexpr uint32_t le32 = 0x12345678;
static constexpr uint64_t le64 = 0x123456789abcdef0;
@@ -41,7 +43,7 @@
sockaddr_in sin = {.sin_family = AF_INET6};
errno = 0;
ASSERT_EQ(-1, bindresvport(-1, &sin));
- ASSERT_EQ(EPFNOSUPPORT, errno);
+ ASSERT_ERRNO(EPFNOSUPPORT);
#else
GTEST_SKIP() << "musl doesn't support bindresvport";
#endif
diff --git a/tests/nl_types_test.cpp b/tests/nl_types_test.cpp
index 2e3995b..6104d16 100644
--- a/tests/nl_types_test.cpp
+++ b/tests/nl_types_test.cpp
@@ -19,6 +19,8 @@
#include <errno.h>
#include <gtest/gtest.h>
+#include "utils.h"
+
TEST(nl_types, smoke) {
nl_catd cat = catopen("/does/not/exist", NL_CAT_LOCALE);
ASSERT_EQ(reinterpret_cast<nl_catd>(-1), cat);
@@ -27,5 +29,5 @@
errno = 0;
ASSERT_EQ(-1, catclose(cat));
- ASSERT_EQ(EBADF, errno);
+ ASSERT_ERRNO(EBADF);
}
diff --git a/tests/pidfd_test.cpp b/tests/pidfd_test.cpp
index b9fadb4..e2e2046 100644
--- a/tests/pidfd_test.cpp
+++ b/tests/pidfd_test.cpp
@@ -29,6 +29,8 @@
#include <android-base/silent_death_test.h>
#include <android-base/unique_fd.h>
+#include "utils.h"
+
using android::base::unique_fd;
using namespace std::chrono_literals;
@@ -44,14 +46,14 @@
unique_fd pidfd(pidfd_open(child, 0));
if (pidfd.get() == -1) {
- ASSERT_EQ(ENOSYS, errno);
+ ASSERT_ERRNO(ENOSYS);
GTEST_SKIP() << "pidfd_open not available";
}
siginfo_t siginfo;
int rc = waitid(P_PIDFD, pidfd.get(), &siginfo, WEXITED);
if (rc == -1) {
- ASSERT_EQ(EINVAL, errno) << strerror(errno);
+ ASSERT_ERRNO(EINVAL);
GTEST_SKIP() << "P_PIDFD not available";
}
@@ -65,13 +67,13 @@
ASSERT_TRUE(android::base::Pipe(&r, &w));
unique_fd self(pidfd_open(getpid(), 0));
if (self.get() == -1) {
- ASSERT_EQ(ENOSYS, errno);
+ ASSERT_ERRNO(ENOSYS);
GTEST_SKIP() << "pidfd_open not available";
}
unique_fd dup(pidfd_getfd(self.get(), r.get(), 0));
if (dup.get() == -1) {
- ASSERT_EQ(ENOSYS, errno) << strerror(errno);
+ ASSERT_ERRNO(ENOSYS);
GTEST_SKIP() << "pidfd_getfd not available";
}
@@ -87,12 +89,12 @@
#if defined(__BIONIC__)
unique_fd self(pidfd_open(getpid(), 0));
if (self.get() == -1) {
- ASSERT_EQ(ENOSYS, errno);
+ ASSERT_ERRNO(ENOSYS);
GTEST_SKIP() << "pidfd_open not available";
}
if (pidfd_send_signal(self.get(), 0, nullptr, 0) == -1) {
- ASSERT_EQ(ENOSYS, errno);
+ ASSERT_ERRNO(ENOSYS);
GTEST_SKIP() << "pidfd_send_signal not available";
}
diff --git a/tests/poll_test.cpp b/tests/poll_test.cpp
index 2a3e5e0..33143f8 100644
--- a/tests/poll_test.cpp
+++ b/tests/poll_test.cpp
@@ -31,11 +31,13 @@
#include <errno.h>
#include <poll.h>
+#include "utils.h"
+
TEST(poll, poll_null_fds) {
// Because nanosleep(2) is relatively new to POSIX, code sometimes abuses poll.
errno = 0;
ASSERT_EQ(0, poll(nullptr, 0, 1));
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
}
TEST(poll, ppoll_null_fds) {
@@ -43,7 +45,7 @@
errno = 0;
timespec ts = { .tv_nsec = 100 };
ASSERT_EQ(0, ppoll(nullptr, 0, &ts, nullptr));
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
}
TEST(poll, ppoll64_null_fds) {
@@ -52,6 +54,6 @@
errno = 0;
timespec ts = { .tv_nsec = 100 };
ASSERT_EQ(0, ppoll64(nullptr, 0, &ts, nullptr));
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
#endif
}
diff --git a/tests/pthread_test.cpp b/tests/pthread_test.cpp
index aad2a4d..73090e1 100644
--- a/tests/pthread_test.cpp
+++ b/tests/pthread_test.cpp
@@ -585,7 +585,7 @@
while (TEMP_FAILURE_RETRY(syscall(__NR_tgkill, getpid(), tid, 0)) != -1) {
continue;
}
- ASSERT_EQ(ESRCH, errno);
+ ASSERT_ERRNO(ESRCH);
ASSERT_EQ(ESRCH, pthread_kill(thread, 0));
}
diff --git a/tests/sched_test.cpp b/tests/sched_test.cpp
index fa1a07f..0231de4 100644
--- a/tests/sched_test.cpp
+++ b/tests/sched_test.cpp
@@ -21,6 +21,8 @@
#include <sys/types.h>
#include <sys/wait.h>
+#include "utils.h"
+
static int child_fn(void* i_ptr) {
*reinterpret_cast<int*>(i_ptr) = 42;
return 123;
@@ -57,14 +59,14 @@
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, nullptr));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(sched, clone_null_child_stack) {
int i = 0;
errno = 0;
ASSERT_EQ(-1, clone(child_fn, nullptr, CLONE_VM, &i));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(sched, cpu_set) {
@@ -289,7 +291,7 @@
p.sched_priority = sched_get_priority_min(original_policy);
errno = 0;
ASSERT_EQ(-1, sched_setscheduler(getpid(), INT_MAX, &p));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
ASSERT_EQ(0, sched_getparam(getpid(), &p));
ASSERT_EQ(original_policy, sched_setscheduler(getpid(), SCHED_BATCH, &p));
diff --git a/tests/search_test.cpp b/tests/search_test.cpp
index 8b8359d..5066709 100644
--- a/tests/search_test.cpp
+++ b/tests/search_test.cpp
@@ -18,6 +18,8 @@
#include <search.h>
+#include "utils.h"
+
static int int_cmp(const void* lhs, const void* rhs) {
return *reinterpret_cast<const int*>(rhs) - *reinterpret_cast<const int*>(lhs);
}
@@ -276,7 +278,7 @@
// Check missing.
errno = 0;
ASSERT_EQ(0, hsearch_r(ENTRY{.key = const_cast<char*>("b"), .data = nullptr}, FIND, &e, &h1));
- ASSERT_EQ(ESRCH, errno);
+ ASSERT_ERRNO(ESRCH);
// Check present.
ASSERT_EQ(1, hsearch_r(ENTRY{.key = const_cast<char*>("a"), .data = nullptr}, FIND, &e, &h1));
diff --git a/tests/semaphore_test.cpp b/tests/semaphore_test.cpp
index 6f8797f..5b061be 100644
--- a/tests/semaphore_test.cpp
+++ b/tests/semaphore_test.cpp
@@ -28,6 +28,8 @@
#include "SignalUtils.h"
#include "private/bionic_constants.h"
+#include "utils.h"
+
using semaphore_DeathTest = SilentDeathTest;
TEST(semaphore, sem_init) {
@@ -41,7 +43,7 @@
// Too small an initial value.
errno = 0;
ASSERT_EQ(-1, sem_init(&s, 0, -1));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
ASSERT_EQ(SEM_VALUE_MAX, sysconf(_SC_SEM_VALUE_MAX));
@@ -51,7 +53,7 @@
// Too large an initial value.
errno = 0;
ASSERT_EQ(-1, sem_init(&s, 0, SEM_VALUE_MAX + 1));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
ASSERT_EQ(0, sem_destroy(&s));
}
@@ -64,7 +66,7 @@
ASSERT_EQ(0, sem_trywait(&s));
errno = 0;
ASSERT_EQ(-1, sem_trywait(&s));
- ASSERT_EQ(EAGAIN, errno);
+ ASSERT_ERRNO(EAGAIN);
ASSERT_EQ(0, sem_destroy(&s));
}
@@ -116,23 +118,23 @@
errno = 0;
ASSERT_EQ(-1, wait_function(&s, &ts));
- ASSERT_EQ(ETIMEDOUT, errno);
+ ASSERT_ERRNO(ETIMEDOUT);
// A negative timeout is an error.
errno = 0;
ts.tv_nsec = -1;
ASSERT_EQ(-1, wait_function(&s, &ts));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
ts.tv_nsec = NS_PER_S;
ASSERT_EQ(-1, wait_function(&s, &ts));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
ts.tv_nsec = NS_PER_S - 1;
ts.tv_sec = -1;
ASSERT_EQ(-1, wait_function(&s, &ts));
- ASSERT_EQ(ETIMEDOUT, errno);
+ ASSERT_ERRNO(ETIMEDOUT);
ASSERT_EQ(0, sem_destroy(&s));
}
diff --git a/tests/signal_test.cpp b/tests/signal_test.cpp
index 2e6908c..de126da 100644
--- a/tests/signal_test.cpp
+++ b/tests/signal_test.cpp
@@ -56,13 +56,13 @@
SigSetT* set_ptr = nullptr;
errno = 0;
ASSERT_EQ(-1, fn(set_ptr));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
// Non-nullptr.
SigSetT set = {};
errno = 0;
ASSERT_EQ(0, fn(&set));
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
}
template <typename SigSetT>
@@ -71,26 +71,26 @@
SigSetT* set_ptr = nullptr;
errno = 0;
ASSERT_EQ(-1, fn(set_ptr, SIGSEGV));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
SigSetT set = {};
// Bad signal number: too small.
errno = 0;
ASSERT_EQ(-1, fn(&set, 0));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
// Bad signal number: too high.
errno = 0;
ASSERT_EQ(-1, fn(&set, SIGNAL_MAX(&set) + 1));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
// Good signal numbers, low and high ends of range.
errno = 0;
ASSERT_EQ(0, fn(&set, SIGNAL_MIN()));
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
ASSERT_EQ(0, fn(&set, SIGNAL_MAX(&set)));
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
}
TEST(signal, sigaddset_invalid) {
@@ -146,7 +146,7 @@
TEST(signal, raise_invalid) {
errno = 0;
ASSERT_EQ(-1, raise(-1));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
static void raise_in_signal_handler_helper(int signal_number) {
@@ -199,7 +199,7 @@
sigfillset(¬_SIGALRM);
sigdelset(¬_SIGALRM, SIGALRM);
ASSERT_EQ(-1, sigsuspend(¬_SIGALRM));
- ASSERT_EQ(EINTR, errno);
+ ASSERT_ERRNO(EINTR);
// ...and check that we now receive our pending SIGALRM.
ASSERT_EQ(1, g_sigsuspend_signal_handler_call_count);
}
@@ -241,7 +241,7 @@
sigfillset64(¬_SIGRTMIN);
sigdelset64(¬_SIGRTMIN, SIGRTMIN);
ASSERT_EQ(-1, sigsuspend64(¬_SIGRTMIN));
- ASSERT_EQ(EINTR, errno);
+ ASSERT_ERRNO(EINTR);
// ...and check that we now receive our pending SIGRTMIN.
ASSERT_EQ(1, g_sigsuspend64_signal_handler_call_count);
}
@@ -598,7 +598,7 @@
sigval sigval = {.sival_int = 1};
errno = 0;
ASSERT_EQ(0, sigqueue(getpid(), SIGALRM, sigval));
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
ASSERT_EQ(1, g_sigqueue_signal_handler_call_count);
}
@@ -608,7 +608,7 @@
sigval sigval = {.sival_int = 1};
errno = 0;
ASSERT_EQ(0, pthread_sigqueue(pthread_self(), SIGALRM, sigval));
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
ASSERT_EQ(1, g_sigqueue_signal_handler_call_count);
#else
GTEST_SKIP() << "musl doesn't have pthread_sigqueue";
@@ -636,7 +636,7 @@
errno = 0;
ASSERT_EQ(0, pthread_sigqueue(thread, SIGALRM, sigval));
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
pthread_join(thread, nullptr);
ASSERT_EQ(1, g_sigqueue_signal_handler_call_count);
#else
@@ -699,7 +699,7 @@
siginfo_t info;
errno = 0;
ASSERT_EQ(SIGALRM, sigwaitinfo(&just_SIGALRM, &info));
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
ASSERT_EQ(SIGALRM, info.si_signo);
ASSERT_EQ(1, info.si_value.sival_int);
}
@@ -721,7 +721,7 @@
siginfo_t info;
errno = 0;
ASSERT_EQ(SIGRTMIN, sigwaitinfo64(&just_SIGRTMIN, &info));
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
ASSERT_EQ(SIGRTMIN, info.si_signo);
ASSERT_EQ(1, info.si_value.sival_int);
}
@@ -744,7 +744,7 @@
timespec timeout = { .tv_sec = 2, .tv_nsec = 0 };
errno = 0;
ASSERT_EQ(SIGALRM, sigtimedwait(&just_SIGALRM, &info, &timeout));
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
}
TEST(signal, sigtimedwait64_SIGRTMIN) {
@@ -765,7 +765,7 @@
timespec timeout = { .tv_sec = 2, .tv_nsec = 0 };
errno = 0;
ASSERT_EQ(SIGRTMIN, sigtimedwait64(&just_SIGRTMIN, &info, &timeout));
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
}
TEST(signal, sigtimedwait_timeout) {
@@ -782,7 +782,7 @@
timespec timeout = { .tv_sec = 0, .tv_nsec = 1000000 };
errno = 0;
ASSERT_EQ(-1, sigtimedwait(&just_SIGALRM, &info, &timeout));
- ASSERT_EQ(EAGAIN, errno);
+ ASSERT_ERRNO(EAGAIN);
auto t1 = std::chrono::steady_clock::now();
ASSERT_GE(t1-t0, 1000000ns);
@@ -836,17 +836,17 @@
TEST(signal, sigignore_EINVAL) {
errno = 0;
ASSERT_EQ(-1, sigignore(99999));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(signal, sigignore) {
errno = 0;
EXPECT_EQ(-1, sigignore(SIGKILL));
- EXPECT_EQ(errno, EINVAL);
+ EXPECT_ERRNO(EINVAL);
errno = 0;
EXPECT_EQ(-1, sigignore(SIGSTOP));
- EXPECT_EQ(errno, EINVAL);
+ EXPECT_ERRNO(EINVAL);
ScopedSignalHandler sigalrm{SIGALRM};
ASSERT_EQ(0, sigignore(SIGALRM));
@@ -859,19 +859,19 @@
TEST(signal, sighold_EINVAL) {
errno = 0;
ASSERT_EQ(-1, sighold(99999));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(signal, sigpause_EINVAL) {
errno = 0;
ASSERT_EQ(-1, sigpause(99999));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(signal, sigrelse_EINVAL) {
errno = 0;
ASSERT_EQ(-1, sigpause(99999));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
static void TestSigholdSigpauseSigrelse(int sig) {
@@ -890,7 +890,7 @@
ASSERT_EQ(0, signal_handler_call_count);
// ... until sigpause(SIGALRM/SIGRTMIN) temporarily unblocks it.
ASSERT_EQ(-1, sigpause(sig));
- ASSERT_EQ(EINTR, errno);
+ ASSERT_ERRNO(EINTR);
ASSERT_EQ(1, signal_handler_call_count);
if (sig >= SIGRTMIN && sizeof(void*) == 8) {
@@ -918,7 +918,7 @@
TEST(signal, sigset_EINVAL) {
errno = 0;
ASSERT_EQ(SIG_ERR, sigset(99999, SIG_DFL));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(signal, sigset_RT) {
@@ -980,5 +980,5 @@
// and passes 0 through to kill(2).
errno = 0;
ASSERT_EQ(-1, killpg(-1, SIGKILL));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
diff --git a/tests/stdio_test.cpp b/tests/stdio_test.cpp
index b0f59bb..eed873a 100644
--- a/tests/stdio_test.cpp
+++ b/tests/stdio_test.cpp
@@ -220,7 +220,7 @@
// It should set the end-of-file indicator for the stream, though.
errno = 0;
ASSERT_EQ(getdelim(&word_read, &allocated_length, ' ', fp), -1);
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
ASSERT_TRUE(feof(fp));
free(word_read);
@@ -239,12 +239,12 @@
// The first argument can't be NULL.
errno = 0;
ASSERT_EQ(getdelim(nullptr, &buffer_length, ' ', fp), -1);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
// The second argument can't be NULL.
errno = 0;
ASSERT_EQ(getdelim(&buffer, nullptr, ' ', fp), -1);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
fclose(fp);
#pragma clang diagnostic pop
}
@@ -293,7 +293,7 @@
// It should set the end-of-file indicator for the stream, though.
errno = 0;
ASSERT_EQ(getline(&line_read, &allocated_length, fp), -1);
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
ASSERT_TRUE(feof(fp));
free(line_read);
@@ -312,12 +312,12 @@
// The first argument can't be NULL.
errno = 0;
ASSERT_EQ(getline(nullptr, &buffer_length, fp), -1);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
// The second argument can't be NULL.
errno = 0;
ASSERT_EQ(getline(&buffer, nullptr, fp), -1);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
fclose(fp);
#pragma clang diagnostic pop
}
@@ -916,7 +916,7 @@
ASSERT_EQ(12, snprintf(buf, sizeof(buf), "%.2147483646s%c", "hello world", '!'));
ASSERT_EQ(12, snprintf(buf, sizeof(buf), "%.2147483647s%c", "hello world", '!'));
ASSERT_EQ(-1, snprintf(buf, sizeof(buf), "%.2147483648s%c", "hello world", '!'));
- ASSERT_EQ(ENOMEM, errno);
+ ASSERT_ERRNO(ENOMEM);
}
TEST(STDIO_TEST, swprintf_asterisk_overflow) {
@@ -931,7 +931,7 @@
ASSERT_EQ(12, swprintf(buf, sizeof(buf), L"%.2147483646s%c", "hello world", '!'));
ASSERT_EQ(12, swprintf(buf, sizeof(buf), L"%.2147483647s%c", "hello world", '!'));
ASSERT_EQ(-1, swprintf(buf, sizeof(buf), L"%.2147483648s%c", "hello world", '!'));
- ASSERT_EQ(ENOMEM, errno);
+ ASSERT_ERRNO(ENOMEM);
}
// Inspired by https://github.com/landley/toybox/issues/163.
@@ -1402,30 +1402,30 @@
errno = 0;
EXPECT_EQ(EOF, putc('x', fp));
- EXPECT_EQ(EBADF, errno);
+ EXPECT_ERRNO(EBADF);
errno = 0;
EXPECT_EQ(EOF, fprintf(fp, "hello"));
- EXPECT_EQ(EBADF, errno);
+ EXPECT_ERRNO(EBADF);
errno = 0;
EXPECT_EQ(EOF, fwprintf(fp, L"hello"));
#if defined(__BIONIC__)
- EXPECT_EQ(EBADF, errno);
+ EXPECT_ERRNO(EBADF);
#endif
errno = 0;
EXPECT_EQ(0U, fwrite("hello", 1, 2, fp));
- EXPECT_EQ(EBADF, errno);
+ EXPECT_ERRNO(EBADF);
errno = 0;
EXPECT_EQ(EOF, fputs("hello", fp));
- EXPECT_EQ(EBADF, errno);
+ EXPECT_ERRNO(EBADF);
errno = 0;
EXPECT_EQ(WEOF, fputwc(L'x', fp));
#if defined(__BIONIC__)
- EXPECT_EQ(EBADF, errno);
+ EXPECT_ERRNO(EBADF);
#endif
}
@@ -1540,7 +1540,7 @@
// Reading from within a byte should produce an error.
ASSERT_EQ(WEOF, fgetwc(fp));
- ASSERT_EQ(EILSEQ, errno);
+ ASSERT_ERRNO(EILSEQ);
// Reverting to a valid position should work.
ASSERT_EQ(0, fsetpos(fp, &mb_two_bytes_pos));
@@ -1550,7 +1550,7 @@
// produce an error.
ASSERT_EQ(0, fsetpos(fp, &pos_inside_mb));
ASSERT_EQ(WEOF, fgetwc(fp));
- ASSERT_EQ(EILSEQ, errno);
+ ASSERT_ERRNO(EILSEQ);
ASSERT_EQ(0, fclose(fp));
}
@@ -1951,7 +1951,7 @@
ASSERT_TRUE(fp != nullptr);
errno = 0;
ASSERT_EQ(-1, fileno(fp));
- ASSERT_EQ(EBADF, errno);
+ ASSERT_ERRNO(EBADF);
ASSERT_EQ(0, fclose(fp));
}
@@ -1999,12 +1999,12 @@
// Invalid buffer.
errno = 0;
ASSERT_EQ(nullptr, open_memstream(nullptr, &size));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
// Invalid size.
errno = 0;
ASSERT_EQ(nullptr, open_memstream(&p, nullptr));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
#pragma clang diagnostic pop
#else
GTEST_SKIP() << "glibc is broken";
@@ -2139,7 +2139,7 @@
std::vector<char> buf(n, 0);
errno = 0;
ASSERT_EQ(0U, fread(&buf[0], n, 1, fp));
- ASSERT_EQ(EBADF, errno);
+ ASSERT_ERRNO(EBADF);
ASSERT_TRUE(ferror(fp));
ASSERT_FALSE(feof(fp));
fclose(fp);
@@ -2271,7 +2271,7 @@
// especially because they might actually correspond to a real stream.
errno = 0;
ASSERT_EQ(-1, fileno(stdin));
- ASSERT_EQ(EBADF, errno);
+ ASSERT_ERRNO(EBADF);
}
TEST(STDIO_TEST, fseek_ftell_unseekable) {
@@ -2283,17 +2283,17 @@
// Check that ftell balks on an unseekable FILE*.
errno = 0;
ASSERT_EQ(-1, ftell(fp));
- ASSERT_EQ(ESPIPE, errno);
+ ASSERT_ERRNO(ESPIPE);
// SEEK_CUR is rewritten as SEEK_SET internally...
errno = 0;
ASSERT_EQ(-1, fseek(fp, 0, SEEK_CUR));
- ASSERT_EQ(ESPIPE, errno);
+ ASSERT_ERRNO(ESPIPE);
// ...so it's worth testing the direct seek path too.
errno = 0;
ASSERT_EQ(-1, fseek(fp, 0, SEEK_SET));
- ASSERT_EQ(ESPIPE, errno);
+ ASSERT_ERRNO(ESPIPE);
fclose(fp);
#else
@@ -2305,7 +2305,7 @@
#if defined(__BIONIC__)
errno = 0;
ASSERT_EQ(nullptr, funopen(nullptr, nullptr, nullptr, nullptr, nullptr));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
#else
GTEST_SKIP() << "glibc uses fopencookie instead";
#endif
@@ -2326,7 +2326,7 @@
EXPECT_EQ(0xfedcba12LL, pos);
#else
EXPECT_EQ(-1, fgetpos(fp, &pos)) << strerror(errno);
- EXPECT_EQ(EOVERFLOW, errno);
+ EXPECT_ERRNO(EOVERFLOW);
#endif
FILE* fp64 = funopen64(nullptr, read_fn, nullptr, seek64_fn, nullptr);
@@ -2428,24 +2428,24 @@
// Bad whence.
errno = 0;
ASSERT_EQ(-1, fseek(fp, 0, 123));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
ASSERT_EQ(-1, fseeko(fp, 0, 123));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
ASSERT_EQ(-1, fseeko64(fp, 0, 123));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
// Bad offset.
errno = 0;
ASSERT_EQ(-1, fseek(fp, -1, SEEK_SET));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
ASSERT_EQ(-1, fseeko(fp, -1, SEEK_SET));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
ASSERT_EQ(-1, fseeko64(fp, -1, SEEK_SET));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
fclose(fp);
}
@@ -2464,20 +2464,20 @@
TemporaryFile tf;
ASSERT_EQ(0, remove(tf.path));
ASSERT_EQ(-1, lstat(tf.path, &sb));
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
TemporaryDir td;
ASSERT_EQ(0, remove(td.path));
ASSERT_EQ(-1, lstat(td.path, &sb));
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
errno = 0;
ASSERT_EQ(-1, remove(tf.path));
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
errno = 0;
ASSERT_EQ(-1, remove(td.path));
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
}
TEST_F(STDIO_DEATHTEST, snprintf_30445072_known_buffer_size) {
@@ -2688,7 +2688,7 @@
#if defined(__BIONIC__) && !defined(__LP64__)
ASSERT_EQ(0, fseek(fp, 0x7fff'ffff, SEEK_SET));
ASSERT_EQ(-1, fseek(fp, 1, SEEK_CUR));
- ASSERT_EQ(EOVERFLOW, errno);
+ ASSERT_ERRNO(EOVERFLOW);
#endif
// Neither Bionic nor glibc implement the overflow checking for SEEK_END.
@@ -2807,7 +2807,7 @@
// Rename and check it moved.
ASSERT_EQ(-1, renameat2(dirfd, "old", dirfd, "new", RENAME_NOREPLACE));
- ASSERT_EQ(EEXIST, errno);
+ ASSERT_ERRNO(EEXIST);
#endif
}
@@ -2830,25 +2830,25 @@
errno = 0;
fp = fdopen(fd, "nonsense");
ASSERT_TRUE(fp == nullptr);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
// Mode that isn't a subset of the fd's actual mode.
errno = 0;
fp = fdopen(fd, "w");
ASSERT_TRUE(fp == nullptr);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
// Can't set append on the underlying fd.
errno = 0;
fp = fdopen(fd, "a");
ASSERT_TRUE(fp == nullptr);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
// Bad fd.
errno = 0;
fp = fdopen(-1, "re");
ASSERT_TRUE(fp == nullptr);
- ASSERT_EQ(EBADF, errno);
+ ASSERT_ERRNO(EBADF);
close(fd);
}
@@ -2857,14 +2857,14 @@
errno = 0;
FILE* fp = fmemopen(nullptr, 16, "nonsense");
ASSERT_TRUE(fp == nullptr);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(STDIO_TEST, fopen_invalid_mode) {
errno = 0;
FILE* fp = fopen("/proc/version", "nonsense");
ASSERT_TRUE(fp == nullptr);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(STDIO_TEST, freopen_invalid_mode) {
@@ -2874,7 +2874,7 @@
errno = 0;
fp = freopen("/proc/version", "nonsense", fp);
ASSERT_TRUE(fp == nullptr);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(STDIO_TEST, asprintf_smoke) {
@@ -2888,7 +2888,7 @@
errno = 0;
FILE* fp = fopen("/proc/does-not-exist", "re");
ASSERT_TRUE(fp == nullptr);
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
}
static void tempnam_test(bool has_TMPDIR, const char* dir, const char* prefix, const char* re) {
diff --git a/tests/stdlib_test.cpp b/tests/stdlib_test.cpp
index 45169e3..21c79c8 100644
--- a/tests/stdlib_test.cpp
+++ b/tests/stdlib_test.cpp
@@ -279,7 +279,7 @@
for (size_t fail_align = last_align + 1; fail_align < align; fail_align++) {
ASSERT_TRUE(aligned_alloc(fail_align, fail_align) == nullptr)
<< "Unexpected success at align " << fail_align;
- ASSERT_EQ(EINVAL, errno) << "Unexpected errno at align " << fail_align;
+ ASSERT_ERRNO(EINVAL) << "Unexpected errno at align " << fail_align;
}
void* ptr = aligned_alloc(align, 2 * align);
ASSERT_TRUE(ptr != nullptr) << "Unexpected failure at align " << align;
@@ -310,21 +310,21 @@
const char* path = nullptr;
char* p = realpath(path, nullptr);
ASSERT_TRUE(p == nullptr);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(stdlib, realpath__empty_filename) {
errno = 0;
char* p = realpath("", nullptr);
ASSERT_TRUE(p == nullptr);
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
}
TEST(stdlib, realpath__ENOENT) {
errno = 0;
char* p = realpath("/this/directory/path/almost/certainly/does/not/exist", nullptr);
ASSERT_TRUE(p == nullptr);
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
}
TEST(stdlib, realpath__ELOOP) {
@@ -335,19 +335,19 @@
errno = 0;
char* p = realpath(link.c_str(), nullptr);
ASSERT_TRUE(p == nullptr);
- ASSERT_EQ(ELOOP, errno);
+ ASSERT_ERRNO(ELOOP);
}
TEST(stdlib, realpath__component_after_non_directory) {
errno = 0;
char* p = realpath("/dev/null/.", nullptr);
ASSERT_TRUE(p == nullptr);
- ASSERT_EQ(ENOTDIR, errno);
+ ASSERT_ERRNO(ENOTDIR);
errno = 0;
p = realpath("/dev/null/..", nullptr);
ASSERT_TRUE(p == nullptr);
- ASSERT_EQ(ENOTDIR, errno);
+ ASSERT_ERRNO(ENOTDIR);
}
TEST(stdlib, realpath) {
@@ -403,7 +403,7 @@
errno = 0;
char* result = realpath(path.c_str(), nullptr);
ASSERT_EQ(nullptr, result) << result;
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
free(result);
}
@@ -695,7 +695,7 @@
errno = 0;
char buf[128];
ASSERT_EQ(ENOTTY, ptsname_r(STDOUT_FILENO, buf, sizeof(buf)));
- ASSERT_EQ(ENOTTY, errno);
+ ASSERT_ERRNO(ENOTTY);
}
TEST(stdlib, ptsname_r_EINVAL) {
@@ -704,7 +704,7 @@
errno = 0;
char* buf = nullptr;
ASSERT_EQ(EINVAL, ptsname_r(fd, buf, 128));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
close(fd);
}
@@ -714,7 +714,7 @@
errno = 0;
char buf[1];
ASSERT_EQ(ERANGE, ptsname_r(fd, buf, sizeof(buf)));
- ASSERT_EQ(ERANGE, errno);
+ ASSERT_ERRNO(ERANGE);
close(fd);
}
@@ -745,7 +745,7 @@
errno = 0;
char buf[128];
ASSERT_EQ(ENOTTY, ttyname_r(fd, buf, sizeof(buf)));
- ASSERT_EQ(ENOTTY, errno);
+ ASSERT_ERRNO(ENOTTY);
close(fd);
}
@@ -755,7 +755,7 @@
errno = 0;
char* buf = nullptr;
ASSERT_EQ(EINVAL, ttyname_r(fd, buf, 128));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
close(fd);
}
@@ -765,7 +765,7 @@
errno = 0;
char buf[1];
ASSERT_EQ(ERANGE, ttyname_r(fd, buf, sizeof(buf)));
- ASSERT_EQ(ERANGE, errno);
+ ASSERT_ERRNO(ERANGE);
close(fd);
}
@@ -773,7 +773,7 @@
int fd = open("/dev/null", O_WRONLY);
errno = 0;
ASSERT_EQ(-1, unlockpt(fd));
- ASSERT_EQ(ENOTTY, errno);
+ ASSERT_ERRNO(ENOTTY);
close(fd);
}
@@ -830,17 +830,17 @@
// Negative base => invalid.
errno = 0;
ASSERT_EQ(T(0), fn("123", &end_p, -1));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
// Base 1 => invalid (base 0 means "please guess").
errno = 0;
ASSERT_EQ(T(0), fn("123", &end_p, 1));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
// Base > 36 => invalid.
errno = 0;
ASSERT_EQ(T(0), fn("123", &end_p, 37));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
// Both leading + or - are always allowed (even for the strtou* family).
ASSERT_EQ(T(-123), fn("-123", &end_p, 10));
@@ -875,14 +875,14 @@
end_p = nullptr;
errno = 0;
ASSERT_EQ(std::numeric_limits<T>::min(), fn(min.c_str(), &end_p, 0));
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
ASSERT_EQ('\0', *end_p);
// Too negative (such as -129).
min.back() = (min.back() + 1);
end_p = nullptr;
errno = 0;
ASSERT_EQ(std::numeric_limits<T>::min(), fn(min.c_str(), &end_p, 0));
- ASSERT_EQ(ERANGE, errno);
+ ASSERT_ERRNO(ERANGE);
ASSERT_EQ('\0', *end_p);
}
@@ -891,14 +891,14 @@
end_p = nullptr;
errno = 0;
ASSERT_EQ(std::numeric_limits<T>::max(), fn(max.c_str(), &end_p, 0));
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
ASSERT_EQ('\0', *end_p);
// Too positive (such as 128).
max.back() = (max.back() + 1);
end_p = nullptr;
errno = 0;
ASSERT_EQ(std::numeric_limits<T>::max(), fn(max.c_str(), &end_p, 0));
- ASSERT_EQ(ERANGE, errno);
+ ASSERT_ERRNO(ERANGE);
ASSERT_EQ('\0', *end_p);
// In case of overflow, strto* leaves us pointing past the end of the number,
@@ -907,14 +907,14 @@
errno = 0;
ASSERT_EQ(std::numeric_limits<T>::max(),
fn("99999999999999999999999999999999999999999999999999999abc", &end_p, 0));
- ASSERT_EQ(ERANGE, errno);
+ ASSERT_ERRNO(ERANGE);
ASSERT_STREQ("abc", end_p);
if (std::numeric_limits<T>::is_signed) {
end_p = nullptr;
errno = 0;
ASSERT_EQ(std::numeric_limits<T>::min(),
fn("-99999999999999999999999999999999999999999999999999999abc", &end_p, 0));
- ASSERT_EQ(ERANGE, errno);
+ ASSERT_ERRNO(ERANGE);
ASSERT_STREQ("abc", end_p);
}
}
diff --git a/tests/string_test.cpp b/tests/string_test.cpp
index 38957e2..50db4fb 100644
--- a/tests/string_test.cpp
+++ b/tests/string_test.cpp
@@ -29,6 +29,7 @@
#include <vector>
#include "buffer_tests.h"
+#include "utils.h"
#if defined(NOFORTIFY)
#define STRING_TEST string_nofortify
@@ -123,7 +124,7 @@
ASSERT_EQ(buf, strerror_r(4567, buf, 2));
ASSERT_STREQ("U", buf);
// The GNU strerror_r doesn't set errno (the POSIX one sets it to ERANGE).
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
#else
GTEST_SKIP() << "musl doesn't have GNU strerror_r";
#endif
@@ -1483,7 +1484,7 @@
errno = 0;
const char* out = basename(in);
ASSERT_STREQ(expected_out, out) << in;
- ASSERT_EQ(0, errno) << in;
+ ASSERT_ERRNO(0) << in;
}
#endif
diff --git a/tests/sys_epoll_test.cpp b/tests/sys_epoll_test.cpp
index 8dee93f..abd928a 100644
--- a/tests/sys_epoll_test.cpp
+++ b/tests/sys_epoll_test.cpp
@@ -122,7 +122,7 @@
TEST(sys_epoll, epoll_create_invalid_size) {
errno = 0;
ASSERT_EQ(-1, epoll_create(0));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(sys_epoll, epoll_event_data) {
diff --git a/tests/sys_mman_test.cpp b/tests/sys_mman_test.cpp
index 803852a..9421565 100644
--- a/tests/sys_mman_test.cpp
+++ b/tests/sys_mman_test.cpp
@@ -23,6 +23,8 @@
#include <android-base/file.h>
#include <gtest/gtest.h>
+#include "utils.h"
+
TEST(sys_mman, mmap_std) {
void* map = mmap(nullptr, 4096, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
ASSERT_NE(MAP_FAILED, map);
@@ -278,7 +280,7 @@
errno = 0;
int fd = memfd_create("doesn't matter", 0);
if (fd == -1) {
- ASSERT_EQ(ENOSYS, errno);
+ ASSERT_ERRNO(ENOSYS);
GTEST_SKIP() << "no memfd_create available";
}
int f = fcntl(fd, F_GETFD);
diff --git a/tests/sys_prctl_test.cpp b/tests/sys_prctl_test.cpp
index 6d1fa1d..bbc1c67 100644
--- a/tests/sys_prctl_test.cpp
+++ b/tests/sys_prctl_test.cpp
@@ -31,6 +31,8 @@
#include "android-base/file.h"
#include "android-base/strings.h"
+#include "utils.h"
+
// http://b/20017123.
TEST(sys_prctl, bug_20017123) {
#if defined(PR_SET_VMA) // PR_SET_VMA is only available in Android kernels.
@@ -91,7 +93,7 @@
// but they can check or lower it
err = prctl(PR_CAP_AMBIENT, PR_CAP_AMBIENT_RAISE, CAP_SYS_ADMIN, 0, 0);
EXPECT_EQ(-1, err);
- EXPECT_EQ(EPERM, errno);
+ EXPECT_ERRNO(EPERM);
err = prctl(PR_CAP_AMBIENT, PR_CAP_AMBIENT_IS_SET, CAP_SYS_ADMIN, 0, 0);
EXPECT_EQ(0, err);
@@ -102,15 +104,15 @@
// ULONG_MAX isn't a legal cap
err = prctl(PR_CAP_AMBIENT, PR_CAP_AMBIENT_RAISE, ULONG_MAX, 0, 0);
EXPECT_EQ(-1, err);
- EXPECT_EQ(EINVAL, errno);
+ EXPECT_ERRNO(EINVAL);
err = prctl(PR_CAP_AMBIENT, PR_CAP_AMBIENT_IS_SET, ULONG_MAX, 0, 0);
EXPECT_EQ(-1, err);
- EXPECT_EQ(EINVAL, errno);
+ EXPECT_ERRNO(EINVAL);
err = prctl(PR_CAP_AMBIENT, PR_CAP_AMBIENT_LOWER, ULONG_MAX, 0, 0);
EXPECT_EQ(-1, err);
- EXPECT_EQ(EINVAL, errno);
+ EXPECT_ERRNO(EINVAL);
#else
GTEST_SKIP() << "PR_CAP_AMBIENT not available";
#endif
diff --git a/tests/sys_ptrace_test.cpp b/tests/sys_ptrace_test.cpp
index b8c1537..93daac3 100644
--- a/tests/sys_ptrace_test.cpp
+++ b/tests/sys_ptrace_test.cpp
@@ -64,10 +64,11 @@
static void check_hw_feature_supported(pid_t child, HwFeature feature) {
#if defined(__arm__)
+ errno = 0;
long capabilities;
long result = ptrace(PTRACE_GETHBPREGS, child, 0, &capabilities);
if (result == -1) {
- EXPECT_EQ(EIO, errno);
+ EXPECT_ERRNO(EIO);
GTEST_SKIP() << "Hardware debug support disabled at kernel configuration time";
}
uint8_t hb_count = capabilities & 0xff;
@@ -88,10 +89,11 @@
iov.iov_base = &dreg_state;
iov.iov_len = sizeof(dreg_state);
+ errno = 0;
long result = ptrace(PTRACE_GETREGSET, child,
feature == HwFeature::Watchpoint ? NT_ARM_HW_WATCH : NT_ARM_HW_BREAK, &iov);
if (result == -1) {
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
GTEST_SKIP() << "Hardware support missing";
} else if ((dreg_state.dbg_info & 0xff) == 0) {
if (feature == HwFeature::Watchpoint) {
@@ -134,7 +136,7 @@
ASSERT_EQ(0, ptrace(PTRACE_POKEUSER, child, offsetof(user, u_debugreg[0]), address)) << strerror(errno);
errno = 0;
unsigned data = ptrace(PTRACE_PEEKUSER, child, offsetof(user, u_debugreg[7]), nullptr);
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
const unsigned size_flag = (size == 8) ? 2 : size - 1;
const unsigned enable = 1;
@@ -323,7 +325,7 @@
<< strerror(errno);
errno = 0;
unsigned data = ptrace(PTRACE_PEEKUSER, child, offsetof(user, u_debugreg[7]), nullptr);
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
const unsigned size = 0;
const unsigned enable = 1;
diff --git a/tests/sys_random_test.cpp b/tests/sys_random_test.cpp
index e0cbf78..4425dba 100644
--- a/tests/sys_random_test.cpp
+++ b/tests/sys_random_test.cpp
@@ -34,6 +34,8 @@
#include <errno.h>
#include <gtest/gtest.h>
+#include "utils.h"
+
TEST(sys_random, getentropy) {
#if defined(HAVE_SYS_RANDOM)
char buf1[64];
@@ -53,7 +55,7 @@
#if defined(HAVE_SYS_RANDOM)
errno = 0;
ASSERT_EQ(-1, getentropy(nullptr, 1));
- ASSERT_EQ(EFAULT, errno);
+ ASSERT_ERRNO(EFAULT);
#else
GTEST_SKIP() << "<sys/random.h> not available";
#endif
@@ -67,7 +69,7 @@
errno = 0;
ASSERT_EQ(-1, getentropy(buf, sizeof(buf)));
- ASSERT_EQ(EIO, errno);
+ ASSERT_ERRNO(EIO);
#else
GTEST_SKIP() << "<sys/random.h> not available";
#endif
@@ -92,7 +94,7 @@
#if defined(HAVE_SYS_RANDOM)
errno = 0;
ASSERT_EQ(-1, getrandom(nullptr, 256, 0));
- ASSERT_EQ(EFAULT, errno);
+ ASSERT_ERRNO(EFAULT);
#else
GTEST_SKIP() << "<sys/random.h> not available";
#endif
@@ -104,7 +106,7 @@
errno = 0;
char buf[64];
ASSERT_EQ(-1, getrandom(buf, sizeof(buf), ~0));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
#else
GTEST_SKIP() << "<sys/random.h> not available";
#endif
diff --git a/tests/sys_select_test.cpp b/tests/sys_select_test.cpp
index 5f019e2..076409d 100644
--- a/tests/sys_select_test.cpp
+++ b/tests/sys_select_test.cpp
@@ -90,7 +90,7 @@
// Invalid max fd.
ASSERT_EQ(-1, select(-1, &r, &w, &e, nullptr));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
int num_fds = select(max, &r, &w, &e, nullptr);
// If there is data to be read on STDIN, then the number of
@@ -108,7 +108,7 @@
tv.tv_sec = -1;
tv.tv_usec = 0;
ASSERT_EQ(-1, select(max, &r, &w, &e, &tv));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
// Valid timeout...
tv.tv_sec = 1;
@@ -145,7 +145,7 @@
// Invalid max fd.
ASSERT_EQ(-1, pselect(-1, &r, &w, &e, nullptr, &ss));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
// 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
@@ -163,7 +163,7 @@
tv.tv_sec = -1;
tv.tv_nsec = 0;
ASSERT_EQ(-1, pselect(max, &r, &w, &e, &tv, &ss));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
// Valid timeout...
tv.tv_sec = 1;
diff --git a/tests/sys_sem_test.cpp b/tests/sys_sem_test.cpp
index 4bac92f..27943cf 100644
--- a/tests/sys_sem_test.cpp
+++ b/tests/sys_sem_test.cpp
@@ -33,6 +33,8 @@
#include <android-base/file.h>
+#include "utils.h"
+
TEST(sys_sem, smoke) {
if (semctl(-1, 0, IPC_RMID) == -1 && errno == ENOSYS) {
GTEST_SKIP() << "no <sys/sem.h> support in this kernel";
@@ -62,7 +64,7 @@
ops[0] = { .sem_num = 0, .sem_op = 0, .sem_flg = 0 };
errno = 0;
ASSERT_EQ(-1, semtimedop(id, ops, 1, &ts));
- ASSERT_EQ(EAGAIN, errno);
+ ASSERT_ERRNO(EAGAIN);
ASSERT_EQ(1, semctl(id, 0, GETVAL));
// Decrement.
diff --git a/tests/sys_socket_test.cpp b/tests/sys_socket_test.cpp
index 422b7f2..1cfbfb2 100644
--- a/tests/sys_socket_test.cpp
+++ b/tests/sys_socket_test.cpp
@@ -100,7 +100,7 @@
TEST(sys_socket, accept4_error) {
ASSERT_EQ(-1, accept4(-1, nullptr, nullptr, 0));
- ASSERT_EQ(EBADF, errno);
+ ASSERT_ERRNO(EBADF);
}
static void TestAccept4(struct sockaddr_un* addr, int fd) {
@@ -177,7 +177,7 @@
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wnonnull"
ASSERT_EQ(-1, recvmmsg(-1, nullptr, 0, 0, nullptr));
- ASSERT_EQ(EBADF, errno);
+ ASSERT_ERRNO(EBADF);
#pragma clang diagnostic pop
}
@@ -238,6 +238,6 @@
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wnonnull"
ASSERT_EQ(-1, sendmmsg(-1, nullptr, 0, 0));
- ASSERT_EQ(EBADF, errno);
+ ASSERT_ERRNO(EBADF);
#pragma clang diagnostic pop
}
diff --git a/tests/sys_stat_test.cpp b/tests/sys_stat_test.cpp
index f36007e..b00f6e2 100644
--- a/tests/sys_stat_test.cpp
+++ b/tests/sys_stat_test.cpp
@@ -22,6 +22,8 @@
#include <android-base/file.h>
#include <gtest/gtest.h>
+#include "utils.h"
+
#if defined(__BIONIC__)
#define HAVE_STATX
#elif defined(__GLIBC_PREREQ)
@@ -59,19 +61,19 @@
times[1].tv_sec = 456;
times[1].tv_nsec = 0;
ASSERT_EQ(-1, futimens(-1, times));
- ASSERT_EQ(EBADF, errno);
+ ASSERT_ERRNO(EBADF);
}
TEST(sys_stat, mkfifo_failure) {
errno = 0;
ASSERT_EQ(-1, mkfifo("/", 0666));
- ASSERT_EQ(EEXIST, errno);
+ ASSERT_ERRNO(EEXIST);
}
TEST(sys_stat, mkfifoat_failure) {
errno = 0;
ASSERT_EQ(-1, mkfifoat(-2, "x", 0666));
- ASSERT_EQ(EBADF, errno);
+ ASSERT_ERRNO(EBADF);
}
TEST(sys_stat, mkfifo) {
@@ -122,48 +124,48 @@
TEST(sys_stat, fchmod_EBADF) {
ASSERT_EQ(-1, fchmod(-1, 0751));
- ASSERT_EQ(EBADF, errno);
+ ASSERT_ERRNO(EBADF);
}
TEST(sys_stat, fchmodat_EFAULT_file) {
ASSERT_EQ(-1, fchmodat(AT_FDCWD, (char *) 0x1, 0751, 0));
- ASSERT_EQ(EFAULT, errno);
+ ASSERT_ERRNO(EFAULT);
}
TEST(sys_stat, fchmodat_AT_SYMLINK_NOFOLLOW_EFAULT_file) {
ASSERT_EQ(-1, fchmodat(AT_FDCWD, (char *) 0x1, 0751, AT_SYMLINK_NOFOLLOW));
#if defined(__BIONIC__)
- ASSERT_EQ(EFAULT, errno);
+ ASSERT_ERRNO(EFAULT);
#else
// glibc 2.19 does not implement AT_SYMLINK_NOFOLLOW and always
// returns ENOTSUP
- ASSERT_EQ(ENOTSUP, errno);
+ ASSERT_ERRNO(ENOTSUP);
#endif
}
TEST(sys_stat, fchmodat_bad_flags) {
ASSERT_EQ(-1, fchmodat(AT_FDCWD, "/blah", 0751, ~AT_SYMLINK_NOFOLLOW));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(sys_stat, fchmodat_bad_flags_ALL) {
ASSERT_EQ(-1, fchmodat(AT_FDCWD, "/blah", 0751, ~0));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(sys_stat, fchmodat_nonexistant_file) {
ASSERT_EQ(-1, fchmodat(AT_FDCWD, "/blah", 0751, 0));
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
}
TEST(sys_stat, fchmodat_AT_SYMLINK_NOFOLLOW_nonexistant_file) {
ASSERT_EQ(-1, fchmodat(AT_FDCWD, "/blah", 0751, AT_SYMLINK_NOFOLLOW));
#if defined(__BIONIC__)
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
#else
// glibc 2.19 does not implement AT_SYMLINK_NOFOLLOW and always
// returns ENOTSUP
- ASSERT_EQ(ENOTSUP, errno);
+ ASSERT_ERRNO(ENOTSUP);
#endif
}
@@ -188,13 +190,13 @@
#if defined(__BIONIC__)
ASSERT_EQ(0, result);
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
AssertFileModeEquals(0751, tf.path);
#else
// glibc 2.19 does not implement AT_SYMLINK_NOFOLLOW and always
// returns ENOTSUP
ASSERT_EQ(-1, result);
- ASSERT_EQ(ENOTSUP, errno);
+ ASSERT_ERRNO(ENOTSUP);
#endif
}
@@ -220,7 +222,7 @@
ASSERT_EQ(0, symlink(target, linkname));
ASSERT_EQ(-1, fchmodat(AT_FDCWD, linkname, 0751, 0));
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
unlink(linkname);
}
@@ -246,7 +248,7 @@
AssertSymlinkModeEquals(0751, linkname);
} else {
ASSERT_EQ(-1, result);
- ASSERT_EQ(ENOTSUP, errno);
+ ASSERT_ERRNO(ENOTSUP);
}
// Target file mode shouldn't be modified.
@@ -269,7 +271,7 @@
AssertSymlinkModeEquals(0751, linkname);
} else {
ASSERT_EQ(-1, result);
- ASSERT_EQ(ENOTSUP, errno);
+ ASSERT_ERRNO(ENOTSUP);
}
unlink(linkname);
@@ -277,14 +279,14 @@
TEST(sys_stat, faccessat_EINVAL) {
ASSERT_EQ(-1, faccessat(AT_FDCWD, "/dev/null", F_OK, ~AT_SYMLINK_NOFOLLOW));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
#if defined(__BIONIC__)
ASSERT_EQ(-1, faccessat(AT_FDCWD, "/dev/null", ~(R_OK | W_OK | X_OK), 0));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
#else
ASSERT_EQ(0, faccessat(AT_FDCWD, "/dev/null", ~(R_OK | W_OK | X_OK), AT_SYMLINK_NOFOLLOW));
ASSERT_EQ(-1, faccessat(AT_FDCWD, "/dev/null", ~(R_OK | W_OK | X_OK), 0));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
#endif
}
@@ -292,7 +294,7 @@
#if defined(__BIONIC__)
// Android doesn't support AT_SYMLINK_NOFOLLOW
ASSERT_EQ(-1, faccessat(AT_FDCWD, "/dev/null", F_OK, AT_SYMLINK_NOFOLLOW));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
#else
ASSERT_EQ(0, faccessat(AT_FDCWD, "/dev/null", F_OK, AT_SYMLINK_NOFOLLOW));
#endif
@@ -309,8 +311,8 @@
ASSERT_EQ(-1, faccessat(AT_FDCWD, "/blah", F_OK, AT_SYMLINK_NOFOLLOW));
#if defined(__BIONIC__)
// Android doesn't support AT_SYMLINK_NOFOLLOW
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
#else
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
#endif
}
diff --git a/tests/sys_time_test.cpp b/tests/sys_time_test.cpp
index 07394d6..ff9271f 100644
--- a/tests/sys_time_test.cpp
+++ b/tests/sys_time_test.cpp
@@ -23,6 +23,8 @@
#include <android-base/file.h>
+#include "utils.h"
+
// http://b/11383777
TEST(sys_time, utimes_nullptr) {
TemporaryFile tf;
@@ -36,19 +38,19 @@
tv[0].tv_usec = -123;
ASSERT_EQ(-1, utimes(tf.path, tv));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
tv[0].tv_usec = 1234567;
ASSERT_EQ(-1, utimes(tf.path, tv));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
tv[0].tv_usec = 0;
tv[1].tv_usec = -123;
ASSERT_EQ(-1, utimes(tf.path, tv));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
tv[1].tv_usec = 1234567;
ASSERT_EQ(-1, utimes(tf.path, tv));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(sys_time, futimes_nullptr) {
@@ -63,19 +65,19 @@
tv[0].tv_usec = -123;
ASSERT_EQ(-1, futimes(tf.fd, tv));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
tv[0].tv_usec = 1234567;
ASSERT_EQ(-1, futimes(tf.fd, tv));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
tv[0].tv_usec = 0;
tv[1].tv_usec = -123;
ASSERT_EQ(-1, futimes(tf.fd, tv));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
tv[1].tv_usec = 1234567;
ASSERT_EQ(-1, futimes(tf.fd, tv));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(sys_time, futimesat_nullptr) {
@@ -90,19 +92,19 @@
tv[0].tv_usec = -123;
ASSERT_EQ(-1, futimesat(AT_FDCWD, tf.path, tv));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
tv[0].tv_usec = 1234567;
ASSERT_EQ(-1, futimesat(AT_FDCWD, tf.path, tv));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
tv[0].tv_usec = 0;
tv[1].tv_usec = -123;
ASSERT_EQ(-1, futimesat(AT_FDCWD, tf.path, tv));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
tv[1].tv_usec = 1234567;
ASSERT_EQ(-1, futimesat(AT_FDCWD, tf.path, tv));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(sys_time, lutimes_nullptr) {
@@ -117,19 +119,19 @@
tv[0].tv_usec = -123;
ASSERT_EQ(-1, lutimes(tf.path, tv));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
tv[0].tv_usec = 1234567;
ASSERT_EQ(-1, lutimes(tf.path, tv));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
tv[0].tv_usec = 0;
tv[1].tv_usec = -123;
ASSERT_EQ(-1, lutimes(tf.path, tv));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
tv[1].tv_usec = 1234567;
ASSERT_EQ(-1, lutimes(tf.path, tv));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
// Musl doesn't define __NR_gettimeofday on 32-bit architectures.
diff --git a/tests/sys_uio_test.cpp b/tests/sys_uio_test.cpp
index aac08e7..97ba5d4 100644
--- a/tests/sys_uio_test.cpp
+++ b/tests/sys_uio_test.cpp
@@ -24,6 +24,8 @@
#include <android-base/file.h>
+#include "utils.h"
+
TEST(sys_uio, readv_writev) {
TemporaryFile tf;
@@ -123,8 +125,9 @@
// Reading from non-allocated memory should return an error
remote = { nullptr, sizeof dst };
+ errno = 0;
ASSERT_EQ(-1, process_vm_readv(getpid(), &local, 1, &remote, 1, 0));
- ASSERT_EQ(EFAULT, errno);
+ ASSERT_ERRNO(EFAULT);
}
TEST(sys_uio, process_vm_writev) {
@@ -142,6 +145,7 @@
// Writing to non-allocated memory should return an error
remote = { nullptr, sizeof dst };
+ errno = 0;
ASSERT_EQ(-1, process_vm_writev(getpid(), &local, 1, &remote, 1, 0));
- ASSERT_EQ(EFAULT, errno);
+ ASSERT_ERRNO(EFAULT);
}
diff --git a/tests/sys_vfs_test.cpp b/tests/sys_vfs_test.cpp
index 242f8d4..2e116a2 100644
--- a/tests/sys_vfs_test.cpp
+++ b/tests/sys_vfs_test.cpp
@@ -24,6 +24,8 @@
#include <string>
+#include "utils.h"
+
template <typename StatFsT> void Check(StatFsT& sb) {
EXPECT_EQ(4096, static_cast<int>(sb.f_bsize));
EXPECT_EQ(0U, sb.f_bfree);
@@ -48,7 +50,7 @@
struct statfs sb;
errno = 0;
ASSERT_EQ(-1, statfs("/does-not-exist", &sb));
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
}
TEST(sys_vfs, statfs64_smoke) {
@@ -61,7 +63,7 @@
struct statfs64 sb;
errno = 0;
ASSERT_EQ(-1, statfs64("/does-not-exist", &sb));
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
}
TEST(sys_vfs, fstatfs) {
@@ -76,7 +78,7 @@
struct statfs sb;
errno = 0;
ASSERT_EQ(-1, fstatfs(-1, &sb));
- ASSERT_EQ(EBADF, errno);
+ ASSERT_ERRNO(EBADF);
}
TEST(sys_vfs, fstatfs64_smoke) {
@@ -91,5 +93,5 @@
struct statfs sb;
errno = 0;
ASSERT_EQ(-1, fstatfs(-1, &sb));
- ASSERT_EQ(EBADF, errno);
+ ASSERT_ERRNO(EBADF);
}
diff --git a/tests/sys_xattr_test.cpp b/tests/sys_xattr_test.cpp
index 45cf379..fa2aee4 100644
--- a/tests/sys_xattr_test.cpp
+++ b/tests/sys_xattr_test.cpp
@@ -21,6 +21,8 @@
#include <android-base/file.h>
#include <gtest/gtest.h>
+#include "utils.h"
+
TEST(sys_xattr, setxattr) {
TemporaryFile tf;
char buf[10];
@@ -52,17 +54,17 @@
char buf[10];
ASSERT_EQ(0, fsetxattr(tf.fd, "user.foo", "01234567890123456789", 21, 0));
ASSERT_EQ(-1, fgetxattr(tf.fd, "user.foo", buf, sizeof(buf)));
- ASSERT_EQ(ERANGE, errno);
+ ASSERT_ERRNO(ERANGE);
}
TEST(sys_xattr, fsetxattr_invalid_fd) {
char buf[10];
errno = 0;
ASSERT_EQ(-1, fsetxattr(-1, "user.foo", "0123", 5, 0));
- ASSERT_EQ(EBADF, errno);
+ ASSERT_ERRNO(EBADF);
errno = 0;
ASSERT_EQ(-1, fgetxattr(-1, "user.foo", buf, sizeof(buf)));
- ASSERT_EQ(EBADF, errno);
+ ASSERT_ERRNO(EBADF);
}
TEST(sys_xattr, fsetxattr_with_opath) {
@@ -78,7 +80,7 @@
ASSERT_STREQ("bar", buf);
#else
ASSERT_EQ(-1, res);
- ASSERT_EQ(EBADF, errno);
+ ASSERT_ERRNO(EBADF);
#endif
close(fd);
}
@@ -93,10 +95,10 @@
char buf[10];
ASSERT_EQ(0, res);
ASSERT_EQ(-1, fgetxattr(fd, "user.foo", buf, sizeof(buf)));
- ASSERT_EQ(ERANGE, errno);
+ ASSERT_ERRNO(ERANGE);
#else
ASSERT_EQ(-1, res);
- ASSERT_EQ(EBADF, errno);
+ ASSERT_ERRNO(EBADF);
#endif
close(fd);
}
@@ -123,7 +125,7 @@
ASSERT_TRUE(memmem(buf, res, "user.foo", 9) != nullptr);
#else
ASSERT_EQ(-1, res);
- ASSERT_EQ(EBADF, errno);
+ ASSERT_ERRNO(EBADF);
#endif
close(fd);
}
@@ -132,5 +134,5 @@
char buf[65536]; // 64kB is max possible xattr list size. See "man 7 xattr".
errno = 0;
ASSERT_EQ(-1, flistxattr(-1, buf, sizeof(buf)));
- ASSERT_EQ(EBADF, errno);
+ ASSERT_ERRNO(EBADF);
}
diff --git a/tests/termios_test.cpp b/tests/termios_test.cpp
index a8d5890..480f3af 100644
--- a/tests/termios_test.cpp
+++ b/tests/termios_test.cpp
@@ -34,6 +34,8 @@
#include <gtest/gtest.h>
+#include "utils.h"
+
// TODO:
// tcdrain
// tcflow
@@ -53,7 +55,7 @@
termios t = {};
errno = 0;
ASSERT_EQ(-1, cfsetispeed(&t, 1200));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(termios, cfgetospeed_cfsetospeed) {
@@ -66,7 +68,7 @@
termios t = {};
errno = 0;
ASSERT_EQ(-1, cfsetospeed(&t, 1200));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(termios, cfsetspeed) {
@@ -82,7 +84,7 @@
// glibc seems to allow 1200 as well as B1200 here, presumably for
// BSD compatibility (where Bxxx == xxx, unlike Linux).
ASSERT_EQ(-1, cfsetspeed(&t, 123));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(termios, cfmakeraw) {
@@ -105,11 +107,11 @@
errno = 0;
ASSERT_EQ(-1, tcgetwinsize(-1, &ws));
- ASSERT_EQ(EBADF, errno);
+ ASSERT_ERRNO(EBADF);
errno = 0;
ASSERT_EQ(-1, tcsetwinsize(-1, &ws));
- ASSERT_EQ(EBADF, errno);
+ ASSERT_ERRNO(EBADF);
#else
GTEST_SKIP() << "glibc too old";
#endif
diff --git a/tests/time_test.cpp b/tests/time_test.cpp
index ec59aa7..5e97c63 100644
--- a/tests/time_test.cpp
+++ b/tests/time_test.cpp
@@ -150,7 +150,7 @@
#if !defined(__LP64__)
// 32-bit bionic has a signed 32-bit time_t.
ASSERT_EQ(-1, mktime(&tm));
- ASSERT_EQ(EOVERFLOW, errno);
+ ASSERT_ERRNO(EOVERFLOW);
#else
// Everyone else should be using a signed 64-bit time_t.
ASSERT_GE(sizeof(time_t) * 8, 64U);
@@ -164,7 +164,7 @@
// mktime to interpret that time as local standard, hence offset
// is 8 hours, not 7.
ASSERT_EQ(static_cast<time_t>(4108348800U), mktime(&tm));
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
#endif
}
@@ -182,7 +182,7 @@
errno = 0;
ASSERT_NE(static_cast<time_t>(-1), mktime(&t));
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
// This will overflow for LP32.
t.tm_year = INT_MAX;
@@ -190,10 +190,10 @@
errno = 0;
#if !defined(__LP64__)
ASSERT_EQ(static_cast<time_t>(-1), mktime(&t));
- ASSERT_EQ(EOVERFLOW, errno);
+ ASSERT_ERRNO(EOVERFLOW);
#else
ASSERT_EQ(static_cast<time_t>(67768036166016000U), mktime(&t));
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
#endif
// This will overflow for LP32 or LP64.
@@ -204,7 +204,7 @@
errno = 0;
ASSERT_EQ(static_cast<time_t>(-1), mktime(&t));
- ASSERT_EQ(EOVERFLOW, errno);
+ ASSERT_ERRNO(EOVERFLOW);
}
TEST(time, mktime_invalid_tm_TZ_combination) {
@@ -222,7 +222,7 @@
EXPECT_EQ(static_cast<time_t>(-1), mktime(&t));
// mktime sets errno to EOVERFLOW if result is unrepresentable.
- EXPECT_EQ(EOVERFLOW, errno);
+ EXPECT_ERRNO(EOVERFLOW);
}
// Transitions in the tzdata file are generated up to the year 2100. Testing
@@ -233,14 +233,13 @@
#if !defined(__LP64__)
// 32-bit bionic has a signed 32-bit time_t.
ASSERT_EQ(-1, mktime(&tm));
- ASSERT_EQ(EOVERFLOW, errno);
+ ASSERT_ERRNO(EOVERFLOW);
#else
setenv("TZ", "Europe/London", 1);
tzset();
errno = 0;
-
ASSERT_EQ(static_cast<time_t>(5686156800U), mktime(&tm));
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
#endif
}
@@ -649,7 +648,7 @@
if (pid == 0) {
// Timers are not inherited by the child.
ASSERT_EQ(-1, timer_delete(timer_id));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
_exit(0);
}
@@ -804,7 +803,7 @@
// A SIGEV_SIGNAL timer is easy; the kernel does all that.
timer_t timer_id;
ASSERT_EQ(-1, timer_create(invalid_clock, nullptr, &timer_id));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
// A SIGEV_THREAD timer is more interesting because we have stuff to clean up.
sigevent se;
@@ -812,7 +811,7 @@
se.sigev_notify = SIGEV_THREAD;
se.sigev_notify_function = NoOpNotifyFunction;
ASSERT_EQ(-1, timer_create(invalid_clock, &se, &timer_id));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(time, timer_create_multiple) {
@@ -915,7 +914,7 @@
cur_time = time(NULL);
while ((kill(tdd.tid, 0) != -1 || errno != ESRCH) && (time(NULL) - cur_time) < 5);
ASSERT_EQ(-1, kill(tdd.tid, 0));
- ASSERT_EQ(ESRCH, errno);
+ ASSERT_ERRNO(ESRCH);
#endif
}
@@ -973,7 +972,7 @@
errno = 0;
timespec ts;
ASSERT_EQ(-1, clock_gettime(-1, &ts));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(time, clock_getres_CLOCK_REALTIME) {
@@ -1011,7 +1010,7 @@
errno = 0;
timespec ts = { -1, -1 };
ASSERT_EQ(-1, clock_getres(-1, &ts));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
ASSERT_EQ(-1, ts.tv_nsec);
ASSERT_EQ(-1, ts.tv_sec);
}
@@ -1064,14 +1063,14 @@
<< "commit/?id=e1b6b6ce55a0a25c8aa8af019095253b2133a41a\n"
<< "* https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/"
<< "commit/?id=c80ed088a519da53f27b798a69748eaabc66aadf\n";
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
}
TEST(time, clock_settime) {
errno = 0;
timespec ts;
ASSERT_EQ(-1, clock_settime(-1, &ts));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(time, clock_nanosleep_EINVAL) {
@@ -1107,7 +1106,7 @@
timespec ts = {.tv_sec = -1};
errno = 0;
ASSERT_EQ(-1, nanosleep(&ts, nullptr));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(time, bug_31938693) {
diff --git a/tests/uchar_test.cpp b/tests/uchar_test.cpp
index 512f098..fd3b332 100644
--- a/tests/uchar_test.cpp
+++ b/tests/uchar_test.cpp
@@ -24,6 +24,8 @@
#include <locale.h>
#include <stdint.h>
+#include "utils.h"
+
// Modern versions of UTF-8 (https://datatracker.ietf.org/doc/html/rfc3629 and
// newer) explicitly disallow code points beyond U+10FFFF, which exclude all 5-
// and 6-byte sequences. Earlier versions of UTF-8 allowed the wider range:
@@ -77,7 +79,7 @@
EXPECT_EQ(static_cast<size_t>(-2), mbrtoc32(nullptr, "\xc2", 1, &ps));
errno = 0;
EXPECT_EQ(static_cast<size_t>(-1), c32rtomb(out, 0x00a2, &ps));
- EXPECT_EQ(EILSEQ, errno);
+ EXPECT_ERRNO(EILSEQ);
// Similarly (but not in compliance with the standard afaict), musl seems to
// ignore the state entirely for the UTF-32 functions rather than reset it.
@@ -217,11 +219,11 @@
auto result = mbrtoc16(&out, "\xf8\xa1\xa2\xa3\xa4", 5, nullptr);
if (kLibcRejectsOverLongUtf8Sequences) {
EXPECT_EQ(static_cast<size_t>(-1), result);
- EXPECT_EQ(EILSEQ, errno);
+ EXPECT_ERRNO(EILSEQ);
EXPECT_EQ(u'\0', out);
} else {
EXPECT_EQ(5U, result);
- EXPECT_EQ(0, errno);
+ EXPECT_ERRNO(0);
EXPECT_EQ(u'\uf94a', out);
}
}
@@ -234,7 +236,7 @@
char16_t out = u'\0';
EXPECT_EQ(static_cast<size_t>(-1), mbrtoc16(&out, "\xf0\x80\xbf\xbf", 6, nullptr));
EXPECT_EQ(u'\0', out);
- EXPECT_EQ(EILSEQ, errno);
+ EXPECT_ERRNO(EILSEQ);
}
TEST(uchar, mbrtoc16_beyond_range) {
@@ -247,11 +249,11 @@
if (kLibcRejectsOverLongUtf8Sequences) {
EXPECT_EQ(static_cast<size_t>(-1), result);
EXPECT_EQ(u'\0', out);
- EXPECT_EQ(EILSEQ, errno);
+ EXPECT_ERRNO(EILSEQ);
} else {
EXPECT_EQ(4U, result);
EXPECT_EQ(u'\xdcc0', out);
- EXPECT_EQ(0, errno);
+ EXPECT_ERRNO(0);
}
}
@@ -290,7 +292,7 @@
ASSERT_EQ(static_cast<size_t>(-2), mbrtoc16(&out, "\xc2", 1, ps));
errno = 0;
ASSERT_EQ(static_cast<size_t>(-1), mbrtoc16(&out, "\x20" "cdef", 5, ps));
- ASSERT_EQ(EILSEQ, errno);
+ ASSERT_ERRNO(EILSEQ);
}
TEST(uchar, mbrtoc16_incomplete) {
@@ -347,7 +349,7 @@
// Invalid code point.
errno = 0;
EXPECT_EQ(static_cast<size_t>(-1), c32rtomb(bytes, 0xffffffff, nullptr));
- EXPECT_EQ(EILSEQ, errno);
+ EXPECT_ERRNO(EILSEQ);
}
TEST(uchar, mbrtoc32_valid_non_characters) {
@@ -370,11 +372,11 @@
auto result = mbrtoc32(&out, "\xf5\x80\x80\x80", 4, nullptr);
if (kLibcRejectsOverLongUtf8Sequences) {
EXPECT_EQ(static_cast<size_t>(-1), result);
- EXPECT_EQ(EILSEQ, errno);
+ EXPECT_ERRNO(EILSEQ);
EXPECT_EQ(U'\0', out);
} else {
EXPECT_EQ(4U, result);
- EXPECT_EQ(0, errno);
+ EXPECT_ERRNO(0);
EXPECT_EQ(U'\x140000', out);
}
}
@@ -428,7 +430,7 @@
"\xf8\xa1\xa2\xa3\xa4"
"f",
6, nullptr));
- EXPECT_EQ(EILSEQ, errno);
+ EXPECT_ERRNO(EILSEQ);
#endif
// Illegal over-long sequence.
errno = 0;
@@ -436,7 +438,7 @@
"\xf0\x82\x82\xac"
"ef",
6, nullptr));
- EXPECT_EQ(EILSEQ, errno);
+ EXPECT_ERRNO(EILSEQ);
}
void test_mbrtoc32_incomplete(mbstate_t* ps) {
@@ -466,7 +468,7 @@
ASSERT_EQ(static_cast<size_t>(-2), mbrtoc32(&out, "\xc2", 1, ps));
errno = 0;
ASSERT_EQ(static_cast<size_t>(-1), mbrtoc32(&out, "\x20" "cdef", 5, ps));
- ASSERT_EQ(EILSEQ, errno);
+ ASSERT_ERRNO(EILSEQ);
}
TEST(uchar, mbrtoc32_incomplete) {
diff --git a/tests/unistd_test.cpp b/tests/unistd_test.cpp
index ac39f96..74bd2f4 100644
--- a/tests/unistd_test.cpp
+++ b/tests/unistd_test.cpp
@@ -72,7 +72,7 @@
void* new_break = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(initial_break) + 1);
int ret = brk(new_break);
if (ret == -1) {
- ASSERT_EQ(errno, ENOMEM);
+ ASSERT_ERRNO(ENOMEM);
} else {
ASSERT_EQ(0, ret);
ASSERT_GE(get_brk(), new_break);
@@ -82,7 +82,7 @@
new_break = page_align(reinterpret_cast<uintptr_t>(initial_break) + sysconf(_SC_PAGE_SIZE));
ret = brk(new_break);
if (ret == -1) {
- ASSERT_EQ(errno, ENOMEM);
+ ASSERT_ERRNO(ENOMEM);
} else {
ASSERT_EQ(0, ret);
ASSERT_EQ(get_brk(), new_break);
@@ -91,7 +91,7 @@
TEST(UNISTD_TEST, brk_ENOMEM) {
ASSERT_EQ(-1, brk(reinterpret_cast<void*>(-1)));
- ASSERT_EQ(ENOMEM, errno);
+ ASSERT_ERRNO(ENOMEM);
}
#if defined(__GLIBC__)
@@ -124,18 +124,18 @@
// Can't increase by so much that we'd overflow.
ASSERT_EQ(reinterpret_cast<void*>(-1), sbrk(PTRDIFF_MAX));
- ASSERT_EQ(ENOMEM, errno);
+ ASSERT_ERRNO(ENOMEM);
// Set the current break to a point that will cause an overflow.
__bionic_brk = reinterpret_cast<void*>(static_cast<uintptr_t>(PTRDIFF_MAX));
ASSERT_EQ(reinterpret_cast<void*>(-1), sbrk(PTRDIFF_MIN));
- ASSERT_EQ(ENOMEM, errno);
+ ASSERT_ERRNO(ENOMEM);
__bionic_brk = reinterpret_cast<void*>(static_cast<uintptr_t>(PTRDIFF_MAX) - 1);
ASSERT_EQ(reinterpret_cast<void*>(-1), sbrk(PTRDIFF_MIN + 1));
- ASSERT_EQ(ENOMEM, errno);
+ ASSERT_ERRNO(ENOMEM);
#else
class ScopedBrk {
public:
@@ -154,7 +154,7 @@
ASSERT_EQ(reinterpret_cast<void*>(-1), sbrk(SBRK_MIN));
#if defined(__BIONIC__)
// GLIBC does not set errno in overflow case.
- ASSERT_EQ(ENOMEM, errno);
+ ASSERT_ERRNO(ENOMEM);
#endif
}
@@ -167,7 +167,7 @@
ASSERT_EQ(reinterpret_cast<void*>(-1), sbrk(SBRK_MAX));
#if defined(__BIONIC__)
// GLIBC does not set errno in overflow case.
- ASSERT_EQ(ENOMEM, errno);
+ ASSERT_ERRNO(ENOMEM);
#endif
}
#endif
@@ -217,7 +217,7 @@
TemporaryFile tf;
errno = 0;
ASSERT_EQ(-1, ftruncate(tf.fd, -123));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
static bool g_pause_test_flag = false;
@@ -253,7 +253,7 @@
// our syscall stubs correctly return a 64-bit -1.
char buf[1];
ASSERT_EQ(-1, read(-1, buf, sizeof(buf)));
- ASSERT_EQ(EBADF, errno);
+ ASSERT_ERRNO(EBADF);
}
TEST(UNISTD_TEST, syscall_long) {
@@ -288,27 +288,27 @@
TEST(UNISTD_TEST, unsetenv_EINVAL) {
EXPECT_EQ(-1, unsetenv(""));
- EXPECT_EQ(EINVAL, errno);
+ EXPECT_ERRNO(EINVAL);
EXPECT_EQ(-1, unsetenv("a=b"));
- EXPECT_EQ(EINVAL, errno);
+ EXPECT_ERRNO(EINVAL);
}
TEST(UNISTD_TEST, setenv_EINVAL) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wnonnull"
EXPECT_EQ(-1, setenv(nullptr, "value", 0));
- EXPECT_EQ(EINVAL, errno);
+ EXPECT_ERRNO(EINVAL);
EXPECT_EQ(-1, setenv(nullptr, "value", 1));
- EXPECT_EQ(EINVAL, errno);
+ EXPECT_ERRNO(EINVAL);
#pragma clang diagnostic pop
EXPECT_EQ(-1, setenv("", "value", 0));
- EXPECT_EQ(EINVAL, errno);
+ EXPECT_ERRNO(EINVAL);
EXPECT_EQ(-1, setenv("", "value", 1));
- EXPECT_EQ(EINVAL, errno);
+ EXPECT_ERRNO(EINVAL);
EXPECT_EQ(-1, setenv("a=b", "value", 0));
- EXPECT_EQ(EINVAL, errno);
+ EXPECT_ERRNO(EINVAL);
EXPECT_EQ(-1, setenv("a=b", "value", 1));
- EXPECT_EQ(EINVAL, errno);
+ EXPECT_ERRNO(EINVAL);
}
TEST(UNISTD_TEST, setenv) {
@@ -394,7 +394,7 @@
// Can't sync an invalid fd.
errno = 0;
EXPECT_EQ(-1, fn(-1));
- EXPECT_EQ(EBADF, errno);
+ EXPECT_ERRNO(EBADF);
// It doesn't matter whether you've opened a file for write or not.
TemporaryFile tf;
@@ -424,7 +424,7 @@
int fd = open("/proc/version", O_RDONLY);
ASSERT_NE(-1, fd);
EXPECT_EQ(-1, fn(fd));
- EXPECT_EQ(EINVAL, errno);
+ EXPECT_ERRNO(EINVAL);
close(fd);
}
@@ -737,7 +737,6 @@
ASSERT_EQ(0, gethostname(hostname, HOST_NAME_MAX));
// Can we get the hostname with a right-sized buffer?
- errno = 0;
ASSERT_EQ(0, gethostname(hostname, strlen(hostname) + 1));
// Does uname(2) agree?
@@ -749,7 +748,7 @@
// Do we correctly detect truncation?
errno = 0;
ASSERT_EQ(-1, gethostname(hostname, strlen(hostname)));
- ASSERT_EQ(ENAMETOOLONG, errno);
+ ASSERT_ERRNO(ENAMETOOLONG);
}
TEST(UNISTD_TEST, pathconf_fpathconf) {
@@ -1206,7 +1205,7 @@
// Equal, but invalid.
errno = 0;
ASSERT_EQ(-1, dup2(fd, fd));
- ASSERT_EQ(EBADF, errno);
+ ASSERT_ERRNO(EBADF);
}
TEST(UNISTD_TEST, dup3) {
@@ -1297,11 +1296,11 @@
// Check that the child cannot lock the file.
ASSERT_EQ(0, lseek64(tf.fd, 0, SEEK_SET));
ASSERT_EQ(-1, lockf64(tf.fd, F_TLOCK, file_size));
- ASSERT_EQ(EAGAIN, errno);
+ ASSERT_ERRNO(EAGAIN);
// Check also that it reports itself as locked.
ASSERT_EQ(0, lseek64(tf.fd, 0, SEEK_SET));
ASSERT_EQ(-1, lockf64(tf.fd, F_TEST, file_size));
- ASSERT_EQ(EACCES, errno);
+ ASSERT_ERRNO(EACCES);
_exit(0);
}
AssertChildExited(pid, 0);
@@ -1327,11 +1326,11 @@
// Check that the child cannot lock the first half.
ASSERT_EQ(0, lseek64(tf.fd, 0, SEEK_SET));
ASSERT_EQ(-1, lockf64(tf.fd, F_TEST, file_size/2));
- ASSERT_EQ(EACCES, errno);
+ ASSERT_ERRNO(EACCES);
// Check also that it reports itself as locked.
ASSERT_EQ(0, lseek64(tf.fd, 0, SEEK_SET));
ASSERT_EQ(-1, lockf64(tf.fd, F_TEST, file_size/2));
- ASSERT_EQ(EACCES, errno);
+ ASSERT_ERRNO(EACCES);
_exit(0);
}
AssertChildExited(pid, 0);
@@ -1353,7 +1352,7 @@
#if defined(__BIONIC__)
// bionic and glibc have different behaviors when len is too small
ASSERT_EQ(-1, getdomainname(buf, strlen(u.domainname)));
- EXPECT_EQ(EINVAL, errno);
+ EXPECT_ERRNO(EINVAL);
#endif
}
@@ -1378,7 +1377,7 @@
const char* name = "newdomainname";
ASSERT_EQ(-1, setdomainname(name, strlen(name)));
- ASSERT_EQ(EPERM, errno);
+ ASSERT_ERRNO(EPERM);
if (has_admin) {
ASSERT_EQ(0, capset(&header, &old_caps[0])) << "failed to restore admin privileges";
@@ -1389,7 +1388,7 @@
ExecTestHelper eth;
errno = 0;
ASSERT_EQ(-1, execve("/", eth.GetArgs(), eth.GetEnv()));
- ASSERT_EQ(EACCES, errno);
+ ASSERT_ERRNO(EACCES);
}
static void append_llvm_cov_env_var(std::string& env_str) {
@@ -1419,7 +1418,7 @@
TEST(UNISTD_TEST, execl_failure) {
errno = 0;
ASSERT_EQ(-1, execl("/", "/", nullptr));
- ASSERT_EQ(EACCES, errno);
+ ASSERT_ERRNO(EACCES);
}
TEST(UNISTD_TEST, execl) {
@@ -1432,7 +1431,7 @@
ExecTestHelper eth;
errno = 0;
ASSERT_EQ(-1, execle("/", "/", nullptr, eth.GetEnv()));
- ASSERT_EQ(EACCES, errno);
+ ASSERT_ERRNO(EACCES);
}
TEST(UNISTD_TEST, execle) {
@@ -1451,7 +1450,7 @@
ExecTestHelper eth;
errno = 0;
ASSERT_EQ(-1, execv("/", eth.GetArgs()));
- ASSERT_EQ(EACCES, errno);
+ ASSERT_ERRNO(EACCES);
}
TEST(UNISTD_TEST, execv) {
@@ -1464,7 +1463,7 @@
TEST(UNISTD_TEST, execlp_failure) {
errno = 0;
ASSERT_EQ(-1, execlp("/", "/", nullptr));
- ASSERT_EQ(EACCES, errno);
+ ASSERT_ERRNO(EACCES);
}
TEST(UNISTD_TEST, execlp) {
@@ -1478,7 +1477,7 @@
eth.SetArgs({nullptr});
errno = 0;
ASSERT_EQ(-1, execvp("/", eth.GetArgs()));
- ASSERT_EQ(EACCES, errno);
+ ASSERT_ERRNO(EACCES);
}
TEST(UNISTD_TEST, execvp) {
@@ -1493,7 +1492,7 @@
errno = 0;
ASSERT_EQ(-1, execvpe("this-does-not-exist", eth.GetArgs(), eth.GetEnv()));
// Running in CTS we might not even be able to search all directories in $PATH.
- ASSERT_TRUE(errno == ENOENT || errno == EACCES);
+ ASSERT_TRUE(errno == ENOENT || errno == EACCES) << strerror(errno);
}
TEST(UNISTD_TEST, execvpe) {
@@ -1528,7 +1527,7 @@
// It's not inherently executable.
errno = 0;
ASSERT_EQ(-1, execvpe(basename(tf.path), eth.GetArgs(), eth.GetEnv()));
- ASSERT_EQ(EACCES, errno);
+ ASSERT_ERRNO(EACCES);
// Make it executable (and keep it writable because we're going to rewrite it below).
ASSERT_EQ(0, chmod(tf.path, 0777));
@@ -1536,7 +1535,7 @@
// TemporaryFile will have a writable fd, so we can test ETXTBSY while we're here...
errno = 0;
ASSERT_EQ(-1, execvpe(basename(tf.path), eth.GetArgs(), eth.GetEnv()));
- ASSERT_EQ(ETXTBSY, errno);
+ ASSERT_ERRNO(ETXTBSY);
// 1. The simplest test: the kernel should handle this.
ASSERT_EQ(0, close(tf.fd));
@@ -1557,7 +1556,7 @@
errno = 0;
ASSERT_EQ(-1, execvp("/system/bin/does-not-exist", eth.GetArgs()));
- ASSERT_EQ(ENOENT, errno);
+ ASSERT_ERRNO(ENOENT);
}
TEST(UNISTD_TEST, exec_argv0_null) {
@@ -1584,7 +1583,7 @@
int fd = open("/", O_RDONLY);
ASSERT_NE(-1, fd);
ASSERT_EQ(-1, fexecve(fd, eth.GetArgs(), eth.GetEnv()));
- ASSERT_EQ(EACCES, errno);
+ ASSERT_ERRNO(EACCES);
close(fd);
}
@@ -1592,7 +1591,7 @@
ExecTestHelper eth;
errno = 0;
ASSERT_EQ(-1, fexecve(-1, eth.GetArgs(), eth.GetEnv()));
- ASSERT_EQ(EBADF, errno);
+ ASSERT_ERRNO(EBADF);
}
TEST(UNISTD_TEST, fexecve_args) {
@@ -1694,9 +1693,9 @@
if (close_range(fd, fd, 0) == 0) {
// we can't close it *again*
ASSERT_EQ(close(fd), -1);
- ASSERT_EQ(errno, EBADF);
+ ASSERT_ERRNO(EBADF);
} else {
- ASSERT_EQ(errno, ENOSYS);
+ ASSERT_ERRNO(ENOSYS);
// since close_range() failed, we can close it normally
ASSERT_EQ(close(fd), 0);
}
diff --git a/tests/utils.cpp b/tests/utils.cpp
index 948d0ec..e470724 100644
--- a/tests/utils.cpp
+++ b/tests/utils.cpp
@@ -70,3 +70,12 @@
return syscall(__NR_gettid);
}
#endif
+
+void PrintTo(const Errno& e, std::ostream* os) {
+ // TODO: strerrorname_np() might be more useful here, but we'd need to implement it first!
+ *os << strerror(e.errno_);
+}
+
+bool operator==(const Errno& lhs, const Errno& rhs) {
+ return lhs.errno_ == rhs.errno_;
+}
diff --git a/tests/utils.h b/tests/utils.h
index 2e00cc1..f6b7174 100644
--- a/tests/utils.h
+++ b/tests/utils.h
@@ -315,3 +315,13 @@
}
bool IsLowRamDevice();
+
+class Errno {
+ public:
+ Errno(int e) : errno_(e) {}
+ int errno_;
+};
+void PrintTo(const Errno& e, std::ostream* os);
+bool operator==(const Errno& lhs, const Errno& rhs);
+#define ASSERT_ERRNO(expected_errno) ASSERT_EQ(Errno(expected_errno), Errno(errno))
+#define EXPECT_ERRNO(expected_errno) EXPECT_EQ(Errno(expected_errno), Errno(errno))
diff --git a/tests/wchar_test.cpp b/tests/wchar_test.cpp
index 28c1046..c4cc0bd 100644
--- a/tests/wchar_test.cpp
+++ b/tests/wchar_test.cpp
@@ -122,7 +122,7 @@
EXPECT_EQ('\xa2', bytes[3]);
// Invalid code point.
EXPECT_EQ(static_cast<size_t>(-1), wcrtomb(bytes, 0xffffffff, nullptr));
- EXPECT_EQ(EILSEQ, errno);
+ EXPECT_ERRNO(EILSEQ);
}
TEST(wchar, wcrtomb_start_state) {
@@ -136,7 +136,7 @@
memset(&ps, 0, sizeof(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);
+ EXPECT_ERRNO(EILSEQ);
// If the first argument to wcrtomb is NULL or the second is L'\0' the shift
// state should be reset.
@@ -177,10 +177,10 @@
// An unrepresentable char just returns an error from wcstombs...
errno = 0;
EXPECT_EQ(static_cast<size_t>(-1), wcstombs(nullptr, bad_chars, 0));
- EXPECT_EQ(EILSEQ, errno);
+ EXPECT_ERRNO(EILSEQ);
errno = 0;
EXPECT_EQ(static_cast<size_t>(-1), wcstombs(nullptr, bad_chars, 256));
- EXPECT_EQ(EILSEQ, errno);
+ EXPECT_ERRNO(EILSEQ);
// And wcsrtombs doesn't tell us where it got stuck because we didn't ask it
// to actually convert anything...
@@ -188,12 +188,12 @@
src = bad_chars;
EXPECT_EQ(static_cast<size_t>(-1), wcsrtombs(nullptr, &src, 0, nullptr));
EXPECT_EQ(&bad_chars[0], src);
- EXPECT_EQ(EILSEQ, errno);
+ EXPECT_ERRNO(EILSEQ);
errno = 0;
src = bad_chars;
EXPECT_EQ(static_cast<size_t>(-1), wcsrtombs(nullptr, &src, 256, nullptr));
EXPECT_EQ(&bad_chars[0], src);
- EXPECT_EQ(EILSEQ, errno);
+ EXPECT_ERRNO(EILSEQ);
// Okay, now let's test actually converting something...
memset(bytes, 'x', sizeof(bytes));
@@ -211,7 +211,7 @@
errno = 0;
memset(bytes, 'x', sizeof(bytes));
EXPECT_EQ(static_cast<size_t>(-1), wcstombs(bytes, bad_chars, 256));
- EXPECT_EQ(EILSEQ, errno);
+ EXPECT_ERRNO(EILSEQ);
bytes[3] = 0;
EXPECT_STREQ("hix", bytes);
@@ -220,13 +220,13 @@
src = chars;
EXPECT_EQ(0U, wcsrtombs(bytes, &src, 0, nullptr));
EXPECT_EQ(&chars[0], src); // No input consumed.
- EXPECT_EQ(EILSEQ, errno);
+ EXPECT_ERRNO(EILSEQ);
memset(bytes, 'x', sizeof(bytes));
src = chars;
EXPECT_EQ(4U, wcsrtombs(bytes, &src, 4, nullptr));
EXPECT_EQ(&chars[4], src); // Some input consumed.
- EXPECT_EQ(EILSEQ, errno);
+ EXPECT_ERRNO(EILSEQ);
bytes[5] = 0;
EXPECT_STREQ("hellx", bytes);
@@ -234,21 +234,21 @@
src = chars;
EXPECT_EQ(5U, wcsrtombs(bytes, &src, 256, nullptr));
EXPECT_EQ(nullptr, src); // All input consumed!
- EXPECT_EQ(EILSEQ, errno);
+ EXPECT_ERRNO(EILSEQ);
EXPECT_STREQ("hello", bytes);
memset(bytes, 'x', sizeof(bytes));
src = chars;
EXPECT_EQ(5U, wcsrtombs(bytes, &src, 6, nullptr));
EXPECT_EQ(nullptr, src); // All input consumed.
- EXPECT_EQ(EILSEQ, errno);
+ EXPECT_ERRNO(EILSEQ);
EXPECT_STREQ("hello", bytes);
memset(bytes, 'x', sizeof(bytes));
src = bad_chars;
EXPECT_EQ(static_cast<size_t>(-1), wcsrtombs(bytes, &src, 256, nullptr));
EXPECT_EQ(&bad_chars[2], src);
- EXPECT_EQ(EILSEQ, errno);
+ EXPECT_ERRNO(EILSEQ);
bytes[3] = 0;
EXPECT_STREQ("hix", bytes);
@@ -258,7 +258,7 @@
memset(&ps, 0, sizeof(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);
+ EXPECT_ERRNO(EILSEQ);
}
TEST(wchar, limits) {
@@ -375,14 +375,14 @@
"\xf8\xa1\xa2\xa3\xa4"
"f",
6, nullptr));
- EXPECT_EQ(EILSEQ, errno);
+ EXPECT_ERRNO(EILSEQ);
#endif
// Illegal over-long sequence.
EXPECT_EQ(static_cast<size_t>(-1), mbrtowc(out,
"\xf0\x82\x82\xac"
"ef",
6, nullptr));
- EXPECT_EQ(EILSEQ, errno);
+ EXPECT_ERRNO(EILSEQ);
}
TEST(wchar, mbrtowc_valid_non_characters) {
@@ -406,10 +406,10 @@
auto result = mbrtowc(out, "\xf5\x80\x80\x80", 4, nullptr);
if (kLibcRejectsOverLongUtf8Sequences) {
ASSERT_EQ(static_cast<size_t>(-1), result);
- ASSERT_EQ(EILSEQ, errno);
+ ASSERT_ERRNO(EILSEQ);
} else {
ASSERT_EQ(4U, result);
- ASSERT_EQ(0, errno);
+ ASSERT_ERRNO(0);
}
}
@@ -439,7 +439,7 @@
// Invalid 2-byte
ASSERT_EQ(static_cast<size_t>(-2), mbrtowc(&out, "\xc2", 1, ps));
ASSERT_EQ(static_cast<size_t>(-1), mbrtowc(&out, "\x20" "cdef", 5, ps));
- ASSERT_EQ(EILSEQ, errno);
+ ASSERT_ERRNO(EILSEQ);
}
TEST(wchar, mbrtowc_incomplete) {
@@ -477,12 +477,12 @@
const char* invalid = INVALID;
ASSERT_EQ(static_cast<size_t>(-1), mbsrtowcs(out, &invalid, 4, ps));
- EXPECT_EQ(EILSEQ, errno);
+ EXPECT_ERRNO(EILSEQ);
ASSERT_EQ('\xc2', *invalid);
const char* incomplete = INCOMPLETE;
ASSERT_EQ(static_cast<size_t>(-1), mbsrtowcs(out, &incomplete, 2, ps));
- EXPECT_EQ(EILSEQ, errno);
+ EXPECT_ERRNO(EILSEQ);
ASSERT_EQ('\xc2', *incomplete);
// If dst is null, *src shouldn't be updated.
@@ -512,7 +512,7 @@
wchar_t out;
ASSERT_EQ(static_cast<size_t>(-2), mbrtowc(&out, "\xc2", 1, &ps));
ASSERT_EQ(static_cast<size_t>(-1), mbsrtowcs(&out, &invalid, 1, &ps));
- EXPECT_EQ(EILSEQ, errno);
+ EXPECT_ERRNO(EILSEQ);
ASSERT_EQ('\x20', *invalid);
}
@@ -642,12 +642,12 @@
src = incomplete;
errno = 0;
ASSERT_EQ(static_cast<size_t>(-1), mbsnrtowcs(dst, &src, SIZE_MAX, 3, nullptr));
- ASSERT_EQ(EILSEQ, errno);
+ ASSERT_ERRNO(EILSEQ);
src = incomplete;
errno = 0;
ASSERT_EQ(static_cast<size_t>(-1), mbsnrtowcs(nullptr, &src, SIZE_MAX, 3, nullptr));
- ASSERT_EQ(EILSEQ, errno);
+ ASSERT_ERRNO(EILSEQ);
}
TEST(wchar, wcsftime__wcsftime_l) {
@@ -798,12 +798,12 @@
// Invalid buffer.
errno = 0;
ASSERT_EQ(nullptr, open_wmemstream(nullptr, &size));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
// Invalid size.
errno = 0;
ASSERT_EQ(nullptr, open_wmemstream(&p, nullptr));
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
#pragma clang diagnostic pop
#else
GTEST_SKIP() << "This test is bionic-specific";
@@ -813,73 +813,73 @@
TEST(wchar, wcstol_EINVAL) {
errno = 0;
wcstol(L"123", nullptr, -1);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
wcstol(L"123", nullptr, 1);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
wcstol(L"123", nullptr, 37);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(wchar, wcstoll_EINVAL) {
errno = 0;
wcstoll(L"123", nullptr, -1);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
wcstoll(L"123", nullptr, 1);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
wcstoll(L"123", nullptr, 37);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(wchar, wcstoul_EINVAL) {
errno = 0;
wcstoul(L"123", nullptr, -1);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
wcstoul(L"123", nullptr, 1);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
wcstoul(L"123", nullptr, 37);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(wchar, wcstoull_EINVAL) {
errno = 0;
wcstoull(L"123", nullptr, -1);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
wcstoull(L"123", nullptr, 1);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
wcstoull(L"123", nullptr, 37);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(wchar, wcstoll_l_EINVAL) {
errno = 0;
wcstoll_l(L"123", nullptr, -1, SAFE_LC_GLOBAL_LOCALE);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
wcstoll_l(L"123", nullptr, 1, SAFE_LC_GLOBAL_LOCALE);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
wcstoll_l(L"123", nullptr, 37, SAFE_LC_GLOBAL_LOCALE);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(wchar, wcstoull_l_EINVAL) {
errno = 0;
wcstoull_l(L"123", nullptr, -1, SAFE_LC_GLOBAL_LOCALE);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
wcstoull_l(L"123", nullptr, 1, SAFE_LC_GLOBAL_LOCALE);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
errno = 0;
wcstoull_l(L"123", nullptr, 37, SAFE_LC_GLOBAL_LOCALE);
- ASSERT_EQ(EINVAL, errno);
+ ASSERT_ERRNO(EINVAL);
}
TEST(wchar, wmempcpy) {