[libc][NFC] Use specific EXPECT/ASSERT macros to test errno #79573
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
|
@llvm/pr-subscribers-libc Author: Guillaume Chatelet (gchatelet) ChangesPatch is 80.58 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/79573.diff 57 Files Affected:
diff --git a/libc/test/IntegrationTest/test.h b/libc/test/IntegrationTest/test.h
index 1e5ad1cfef0d7b5..f1c2e8f9ec72e3c 100644
--- a/libc/test/IntegrationTest/test.h
+++ b/libc/test/IntegrationTest/test.h
@@ -45,10 +45,17 @@
LIBC_NAMESPACE::quick_exit(127); \
}
+////////////////////////////////////////////////////////////////////////////////
+// Boolean checks are handled as comparison to the true / false values.
+
#define EXPECT_TRUE(val) __CHECK_TRUE(__FILE__, __LINE__, val, false)
#define ASSERT_TRUE(val) __CHECK_TRUE(__FILE__, __LINE__, val, true)
#define EXPECT_FALSE(val) __CHECK_FALSE(__FILE__, __LINE__, val, false)
#define ASSERT_FALSE(val) __CHECK_FALSE(__FILE__, __LINE__, val, true)
+
+////////////////////////////////////////////////////////////////////////////////
+// Binary equality / inequality.
+
#define EXPECT_EQ(val1, val2) \
__CHECK_EQ(__FILE__, __LINE__, (val1), (val2), false)
#define ASSERT_EQ(val1, val2) \
@@ -58,6 +65,15 @@
#define ASSERT_NE(val1, val2) \
__CHECK_NE(__FILE__, __LINE__, (val1), (val2), true)
+////////////////////////////////////////////////////////////////////////////////
+// Errno checks.
+
+#define EXPECT_ERRNO_EQ(VAL) EXPECT_EQ(VAL, static_cast<int>(libc_errno))
+#define ASSERT_ERRNO_EQ(VAL) ASSERT_EQ(VAL, static_cast<int>(libc_errno))
+
+#define EXPECT_ERRNO() EXPECT_NE(static_cast<int>(libc_errno), 0)
+#define ASSERT_ERRNO() ASSERT_NE(static_cast<int>(libc_errno), 0)
+
// Integration tests are compiled with -ffreestanding which stops treating
// the main function as a non-overloadable special function. Hence, we use a
// convenience macro which declares it 'extern "C"'.
diff --git a/libc/test/UnitTest/LibcTest.h b/libc/test/UnitTest/LibcTest.h
index 68fd5f28f3e0bd7..cfea23a679755ea 100644
--- a/libc/test/UnitTest/LibcTest.h
+++ b/libc/test/UnitTest/LibcTest.h
@@ -443,6 +443,15 @@ CString libc_make_test_file_path_func(const char *file_name);
#define EXPECT_STRNE(LHS, RHS) LIBC_TEST_STR_(testStrNe, LHS, RHS, )
#define ASSERT_STRNE(LHS, RHS) LIBC_TEST_STR_(testStrNe, LHS, RHS, return)
+////////////////////////////////////////////////////////////////////////////////
+// Errno checks.
+
+#define EXPECT_ERRNO_EQ(VAL) EXPECT_EQ(VAL, static_cast<int>(libc_errno))
+#define ASSERT_ERRNO_EQ(VAL) ASSERT_EQ(VAL, static_cast<int>(libc_errno))
+
+#define EXPECT_ERRNO() EXPECT_NE(static_cast<int>(libc_errno), 0)
+#define ASSERT_ERRNO() ASSERT_NE(static_cast<int>(libc_errno), 0)
+
////////////////////////////////////////////////////////////////////////////////
// Subprocess checks.
diff --git a/libc/test/integration/src/pthread/pthread_create_test.cpp b/libc/test/integration/src/pthread/pthread_create_test.cpp
index 6a9b44cc1422cc5..bce380fbec2fc81 100644
--- a/libc/test/integration/src/pthread/pthread_create_test.cpp
+++ b/libc/test/integration/src/pthread/pthread_create_test.cpp
@@ -47,7 +47,7 @@ static void *successThread(void *Arg) {
pthread_t th = LIBC_NAMESPACE::pthread_self();
auto *thread = reinterpret_cast<LIBC_NAMESPACE::Thread *>(&th);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
ASSERT_TRUE(thread);
ASSERT_TRUE(thread->attrib);
@@ -62,22 +62,22 @@ static void *successThread(void *Arg) {
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_getstack(expec_attrs, &expec_stack,
&expec_stacksize),
0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
ASSERT_EQ(
LIBC_NAMESPACE::pthread_attr_getstacksize(expec_attrs, &expec_stacksize2),
0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
ASSERT_EQ(
LIBC_NAMESPACE::pthread_attr_getguardsize(expec_attrs, &expec_guardsize),
0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
ASSERT_EQ(
LIBC_NAMESPACE::pthread_attr_getdetachstate(expec_attrs, &expec_detached),
0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
ASSERT_EQ(expec_stacksize, expec_stacksize2);
@@ -125,7 +125,7 @@ static void *successThread(void *Arg) {
// permissions. Maybe we can read from /proc/{self}/map?
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_destroy(expec_attrs), 0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
// Arg is malloced, so free.
delete th_arg;
@@ -140,13 +140,13 @@ static void run_success_config(int detachstate, size_t guardsize,
pthread_attr_t *attr = &(th_arg->attrs);
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_init(attr), 0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_setdetachstate(attr, detachstate), 0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_setguardsize(attr, guardsize), 0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
void *Stack = nullptr;
if (customstack) {
@@ -154,20 +154,20 @@ static void run_success_config(int detachstate, size_t guardsize,
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(Stack, MAP_FAILED);
ASSERT_NE(Stack, static_cast<void *>(nullptr));
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_setstack(attr, Stack, stacksize), 0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
} else {
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_setstacksize(attr, stacksize), 0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
}
void *expec_ret = nullptr;
if (detachstate == PTHREAD_CREATE_JOINABLE) {
ASSERT_EQ(LIBC_NAMESPACE::getrandom(&expec_ret, sizeof(expec_ret), 0),
static_cast<ssize_t>(sizeof(expec_ret)));
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
}
th_arg->ret = expec_ret;
@@ -178,17 +178,17 @@ static void run_success_config(int detachstate, size_t guardsize,
ASSERT_EQ(LIBC_NAMESPACE::pthread_create(&tid, attr, successThread,
reinterpret_cast<void *>(th_arg)),
0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
if (detachstate == PTHREAD_CREATE_JOINABLE) {
void *th_ret;
ASSERT_EQ(LIBC_NAMESPACE::pthread_join(tid, &th_ret), 0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
ASSERT_EQ(th_ret, expec_ret);
if (customstack) {
ASSERT_EQ(LIBC_NAMESPACE::munmap(Stack, stacksize), 0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
}
} else {
ASSERT_FALSE(customstack);
@@ -260,23 +260,23 @@ static void create_and_check_failure_thread(pthread_attr_t *attr) {
// was just really larger we failed mmap.
ASSERT_TRUE(result == EINVAL || result == EAGAIN);
// pthread_create should NOT set errno on error
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_destroy(attr), 0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
}
static void run_failure_config(size_t guardsize, size_t stacksize) {
pthread_attr_t attr;
guardsize &= -EXEC_PAGESIZE;
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_init(&attr), 0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_setguardsize(&attr, guardsize), 0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_setstacksize(&attr, stacksize), 0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
create_and_check_failure_thread(&attr);
}
@@ -301,32 +301,32 @@ static void run_failure_tests() {
// Stacksize too small.
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_init(&attr), 0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
attr.__stacksize = PTHREAD_STACK_MIN - 16;
create_and_check_failure_thread(&attr);
// Stack misaligned.
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_init(&attr), 0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
attr.__stack = reinterpret_cast<void *>(1);
create_and_check_failure_thread(&attr);
// Stack + stacksize misaligned.
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_init(&attr), 0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
attr.__stacksize = PTHREAD_STACK_MIN + 1;
attr.__stack = reinterpret_cast<void *>(16);
create_and_check_failure_thread(&attr);
// Guardsize misaligned.
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_init(&attr), 0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
attr.__guardsize = EXEC_PAGESIZE / 2;
create_and_check_failure_thread(&attr);
// Detachstate is unknown.
ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_init(&attr), 0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
attr.__detachstate = -1;
create_and_check_failure_thread(&attr);
}
diff --git a/libc/test/integration/src/pthread/pthread_join_test.cpp b/libc/test/integration/src/pthread/pthread_join_test.cpp
index f4126357a0579dc..b441917a4cac29f 100644
--- a/libc/test/integration/src/pthread/pthread_join_test.cpp
+++ b/libc/test/integration/src/pthread/pthread_join_test.cpp
@@ -19,9 +19,9 @@ static void nullJoinTest() {
pthread_t Tid;
ASSERT_EQ(LIBC_NAMESPACE::pthread_create(&Tid, nullptr, simpleFunc, nullptr),
0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
ASSERT_EQ(LIBC_NAMESPACE::pthread_join(Tid, nullptr), 0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
}
TEST_MAIN() {
diff --git a/libc/test/integration/src/unistd/getcwd_test.cpp b/libc/test/integration/src/unistd/getcwd_test.cpp
index 3d8f5821a69efcb..87687d09b9e7aff 100644
--- a/libc/test/integration/src/unistd/getcwd_test.cpp
+++ b/libc/test/integration/src/unistd/getcwd_test.cpp
@@ -30,7 +30,7 @@ TEST_MAIN(int argc, char **argv, char **envp) {
// Bad size
cwd = LIBC_NAMESPACE::getcwd(buffer, 0);
ASSERT_TRUE(cwd == nullptr);
- ASSERT_EQ(libc_errno, EINVAL);
+ ASSERT_ERRNO_EQ(EINVAL);
libc_errno = 0;
// Insufficient size
diff --git a/libc/test/src/dirent/dirent_test.cpp b/libc/test/src/dirent/dirent_test.cpp
index ff1a30a2639fe25..63778ddc01483d9 100644
--- a/libc/test/src/dirent/dirent_test.cpp
+++ b/libc/test/src/dirent/dirent_test.cpp
@@ -44,7 +44,7 @@ TEST(LlvmLibcDirentTest, SimpleOpenAndRead) {
}
// Verify that we don't break out of the above loop in error.
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
ASSERT_TRUE(file1 != nullptr);
ASSERT_TRUE(file2 != nullptr);
@@ -58,7 +58,7 @@ TEST(LlvmLibcDirentTest, OpenNonExistentDir) {
libc_errno = 0;
::DIR *dir = LIBC_NAMESPACE::opendir("___xyz123__.non_existent__");
ASSERT_TRUE(dir == nullptr);
- ASSERT_EQ(libc_errno, ENOENT);
+ ASSERT_ERRNO_EQ(ENOENT);
libc_errno = 0;
}
@@ -66,6 +66,6 @@ TEST(LlvmLibcDirentTest, OpenFile) {
libc_errno = 0;
::DIR *dir = LIBC_NAMESPACE::opendir("testdata/file1.txt");
ASSERT_TRUE(dir == nullptr);
- ASSERT_EQ(libc_errno, ENOTDIR);
+ ASSERT_ERRNO_EQ(ENOTDIR);
libc_errno = 0;
}
diff --git a/libc/test/src/fcntl/creat_test.cpp b/libc/test/src/fcntl/creat_test.cpp
index ef30d8862c45f26..9f5a1394dbfcd14 100644
--- a/libc/test/src/fcntl/creat_test.cpp
+++ b/libc/test/src/fcntl/creat_test.cpp
@@ -19,12 +19,12 @@ TEST(LlvmLibcCreatTest, CreatAndOpen) {
using LIBC_NAMESPACE::testing::ErrnoSetterMatcher::Succeeds;
constexpr const char *TEST_FILE = "testdata/creat.test";
int fd = LIBC_NAMESPACE::creat(TEST_FILE, S_IRWXU);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
ASSERT_GT(fd, 0);
ASSERT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));
fd = LIBC_NAMESPACE::open(TEST_FILE, O_RDONLY);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
ASSERT_GT(fd, 0);
ASSERT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));
diff --git a/libc/test/src/fcntl/openat_test.cpp b/libc/test/src/fcntl/openat_test.cpp
index b95f3f212720116..a6302973b8e2f35 100644
--- a/libc/test/src/fcntl/openat_test.cpp
+++ b/libc/test/src/fcntl/openat_test.cpp
@@ -21,13 +21,13 @@ TEST(LlvmLibcUniStd, OpenAndReadTest) {
constexpr const char *TEST_DIR = "testdata";
constexpr const char *TEST_FILE = "openat.test";
int dir_fd = LIBC_NAMESPACE::open(TEST_DIR, O_DIRECTORY);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
ASSERT_GT(dir_fd, 0);
constexpr const char TEST_MSG[] = "openat test";
constexpr int TEST_MSG_SIZE = sizeof(TEST_MSG) - 1;
int read_fd = LIBC_NAMESPACE::openat(dir_fd, TEST_FILE, O_RDONLY);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
ASSERT_GT(read_fd, 0);
char read_buf[TEST_MSG_SIZE];
ASSERT_THAT(LIBC_NAMESPACE::read(read_fd, read_buf, TEST_MSG_SIZE),
diff --git a/libc/test/src/sched/get_priority_test.cpp b/libc/test/src/sched/get_priority_test.cpp
index 3a79a67802cf3e9..6d62391ee2cb1b5 100644
--- a/libc/test/src/sched/get_priority_test.cpp
+++ b/libc/test/src/sched/get_priority_test.cpp
@@ -20,40 +20,40 @@ TEST(LlvmLibcSchedGetPriorityTest, HandleBadPolicyTest) {
int policy = -1;
int max_priority = LIBC_NAMESPACE::sched_get_priority_max(policy);
ASSERT_EQ(max_priority, -1);
- ASSERT_EQ(libc_errno, EINVAL);
+ ASSERT_ERRNO_EQ(EINVAL);
int min_priority = LIBC_NAMESPACE::sched_get_priority_min(policy);
ASSERT_EQ(min_priority, -1);
- ASSERT_EQ(libc_errno, EINVAL);
+ ASSERT_ERRNO_EQ(EINVAL);
}
{
int policy = 30;
int max_priority = LIBC_NAMESPACE::sched_get_priority_max(policy);
ASSERT_EQ(max_priority, -1);
- ASSERT_EQ(libc_errno, EINVAL);
+ ASSERT_ERRNO_EQ(EINVAL);
int min_priority = LIBC_NAMESPACE::sched_get_priority_min(policy);
ASSERT_EQ(min_priority, -1);
- ASSERT_EQ(libc_errno, EINVAL);
+ ASSERT_ERRNO_EQ(EINVAL);
}
{
int policy = 80;
int max_priority = LIBC_NAMESPACE::sched_get_priority_max(policy);
ASSERT_EQ(max_priority, -1);
- ASSERT_EQ(libc_errno, EINVAL);
+ ASSERT_ERRNO_EQ(EINVAL);
int min_priority = LIBC_NAMESPACE::sched_get_priority_min(policy);
ASSERT_EQ(min_priority, -1);
- ASSERT_EQ(libc_errno, EINVAL);
+ ASSERT_ERRNO_EQ(EINVAL);
}
{
int policy = 110;
int max_priority = LIBC_NAMESPACE::sched_get_priority_max(policy);
ASSERT_EQ(max_priority, -1);
- ASSERT_EQ(libc_errno, EINVAL);
+ ASSERT_ERRNO_EQ(EINVAL);
int min_priority = LIBC_NAMESPACE::sched_get_priority_min(policy);
ASSERT_EQ(min_priority, -1);
- ASSERT_EQ(libc_errno, EINVAL);
+ ASSERT_ERRNO_EQ(EINVAL);
}
}
@@ -68,10 +68,10 @@ TEST(LlvmLibcSchedGetPriorityTest, SmokeTest) {
int policy = SCHED_OTHER;
int max_priority = LIBC_NAMESPACE::sched_get_priority_max(policy);
ASSERT_GE(max_priority, 0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
int min_priority = LIBC_NAMESPACE::sched_get_priority_min(policy);
ASSERT_GE(min_priority, 0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
ASSERT_LE(max_priority, 99);
ASSERT_GE(min_priority, 0);
@@ -82,10 +82,10 @@ TEST(LlvmLibcSchedGetPriorityTest, SmokeTest) {
int policy = SCHED_FIFO;
int max_priority = LIBC_NAMESPACE::sched_get_priority_max(policy);
ASSERT_GE(max_priority, 0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
int min_priority = LIBC_NAMESPACE::sched_get_priority_min(policy);
ASSERT_GE(min_priority, 0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
ASSERT_LE(max_priority, 99);
ASSERT_GE(min_priority, 0);
@@ -96,10 +96,10 @@ TEST(LlvmLibcSchedGetPriorityTest, SmokeTest) {
int policy = SCHED_RR;
int max_priority = LIBC_NAMESPACE::sched_get_priority_max(policy);
ASSERT_GE(max_priority, 0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
int min_priority = LIBC_NAMESPACE::sched_get_priority_min(policy);
ASSERT_GE(min_priority, 0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
ASSERT_LE(max_priority, 99);
ASSERT_GE(min_priority, 0);
diff --git a/libc/test/src/sched/param_and_scheduler_test.cpp b/libc/test/src/sched/param_and_scheduler_test.cpp
index 8c6485f07897125..196db53eb33be3b 100644
--- a/libc/test/src/sched/param_and_scheduler_test.cpp
+++ b/libc/test/src/sched/param_and_scheduler_test.cpp
@@ -41,35 +41,35 @@ class SchedTest : public LIBC_NAMESPACE::testing::Test {
int init_policy = LIBC_NAMESPACE::sched_getscheduler(0);
ASSERT_GE(init_policy, 0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
int max_priority = LIBC_NAMESPACE::sched_get_priority_max(policy);
ASSERT_GE(max_priority, 0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
int min_priority = LIBC_NAMESPACE::sched_get_priority_min(policy);
ASSERT_GE(min_priority, 0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
struct sched_param param = {min_priority};
// Negative pid
ASSERT_EQ(LIBC_NAMESPACE::sched_setscheduler(-1, policy, ¶m), -1);
- ASSERT_EQ(libc_errno, EINVAL);
+ ASSERT_ERRNO_EQ(EINVAL);
libc_errno = 0;
ASSERT_EQ(LIBC_NAMESPACE::sched_getscheduler(-1), -1);
- ASSERT_EQ(libc_errno, EINVAL);
+ ASSERT_ERRNO_EQ(EINVAL);
libc_errno = 0;
// Invalid Policy
ASSERT_EQ(LIBC_NAMESPACE::sched_setscheduler(0, policy | 128, ¶m), -1);
- ASSERT_EQ(libc_errno, EINVAL);
+ ASSERT_ERRNO_EQ(EINVAL);
libc_errno = 0;
// Out of bounds priority
param.sched_priority = min_priority - 1;
ASSERT_EQ(LIBC_NAMESPACE::sched_setscheduler(0, policy, ¶m), -1);
- ASSERT_EQ(libc_errno, EINVAL);
+ ASSERT_ERRNO_EQ(EINVAL);
libc_errno = 0;
param.sched_priority = max_priority + 1;
@@ -90,33 +90,33 @@ class SchedTest : public LIBC_NAMESPACE::testing::Test {
ASSERT_EQ(LIBC_NAMESPACE::sched_getscheduler(0),
can_set ? policy : init_policy);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
// Out of bounds priority
param.sched_priority = -1;
ASSERT_EQ(LIBC_NAMESPACE::sched_setparam(0, ¶m), -1);
- ASSERT_EQ(libc_errno, EINVAL);
+ ASSERT_ERRNO_EQ(EINVAL);
libc_errno = 0;
param.sched_priority = max_priority + 1;
ASSERT_EQ(LIBC_NAMESPACE::sched_setparam(0, ¶m), -1);
- ASSERT_EQ(libc_errno, EINVAL);
+ ASSERT_ERRNO_EQ(EINVAL);
libc_errno = 0;
for (int priority = min_priority; priority <= max_priority; ++priority) {
ASSERT_EQ(LIBC_NAMESPACE::sched_getparam(0, ¶m), 0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
int init_priority = param.sched_priority;
param.sched_priority = priority;
// Negative pid
ASSERT_EQ(LIBC_NAMESPACE::sched_setparam(-1, ¶m), -1);
- ASSERT_EQ(libc_errno, EINVAL);
+ ASSERT_ERRNO_EQ(EINVAL);
libc_errno = 0;
ASSERT_EQ(LIBC_NAMESPACE::sched_getparam(-1, ¶m), -1);
- ASSERT_EQ(libc_errno, EINVAL);
+ ASSERT_ERRNO_EQ(EINVAL);
libc_errno = 0;
// Success / missing permissions
@@ -126,14 +126,14 @@ class SchedTest : public LIBC_NAMESPACE::testing::Test {
libc_errno = 0;
ASSERT_EQ(LIBC_NAMESPACE::sched_getparam(0, ¶m), 0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
ASSERT_EQ(param.sched_priority, can_set ? priority : init_priority);
}
// Null test
ASSERT_EQ(LIBC_NAMESPACE::sched_setscheduler(0, policy, nullptr), -1);
- ASSERT_EQ(libc_errno, EINVAL);
+ ASSERT_ERRNO_EQ(EINVAL);
libc_errno = 0;
}
};
@@ -155,10 +155,10 @@ TEST(LlvmLibcSchedParamAndSchedulerTest, NullParamTest) {
libc_errno = 0;
ASSERT_EQ(LIBC_NAMESPACE::sched_setparam(0, nullptr), -1);
- ASSERT_EQ(libc_errno, EINVAL);
+ ASSERT_ERRNO_EQ(EINVAL);
libc_errno = 0;
ASSERT_EQ(LIBC_NAMESPACE::sched_getparam(0, nullptr), -1);
- ASSERT_EQ(libc_errno, EINVAL);
+ ASSERT_ERRNO_EQ(EINVAL);
libc_errno = 0;
}
diff --git a/libc/test/src/sched/sched_rr_get_interval_test.cpp b/libc/test/src/sched/sched_rr_get_interval_test.cpp
index 100100079504165..85a9dbd29bfb6fa 100644
--- a/libc/test/src/sched/sched_rr_get_interval_test.cpp
+++ b/libc/test/src/sched/sched_rr_get_interval_test.cpp
@@ -21,11 +21,11 @@ TEST(LlvmLibcSchedRRGetIntervalTest, SmokeTest) {
auto SetSched = [&](int policy) {
int min_priority = LIBC_NAMESPACE::sched_get_priority_min(policy);
ASSERT_GE(min_priority, 0);
- ASSERT_EQ(libc_errno, 0);
+ ASSERT_ERRNO_EQ(0);
struct sched_param param...
[truncated]
|
lntue
reviewed
Jan 26, 2024
libc/test/IntegrationTest/test.h
Outdated
| #define EXPECT_ERRNO_EQ(VAL) EXPECT_EQ(VAL, static_cast<int>(libc_errno)) | ||
| #define ASSERT_ERRNO_EQ(VAL) ASSERT_EQ(VAL, static_cast<int>(libc_errno)) | ||
|
|
||
| #define EXPECT_ERRNO() EXPECT_NE(static_cast<int>(libc_errno), 0) |
There was a problem hiding this comment.
Shall we consistently choose one between ASSERT_ERRNO_EQ(0) and ASSERT_ERRNO()? I see that both are used below. Maybe just pick the former one, and drop ASSERT_ERRNO() form, since the former one is essential for other value.
There was a problem hiding this comment.
ASSERT_ERRNO asserts that the error is not 0 (i.e., there is an error).
To be honest I was not super happy with the naming. Maybe we should have ASSERT_ERRNO_EQ and ASSERT_ERRNO_NE, it would be clearer I think.
Also maybe we don't need the EXPECT and ASSERT versions? How about reducing all of these to just ASSERT_ERRNO_EQ and ASSERT_ERRNO_NE?
There was a problem hiding this comment.
Or maybe ASSERT_ERRNO_EQ and ASSERT_ERRNO_FAILURE?
There was a problem hiding this comment.
I pushed a a new version, let me know what you think.
There was a problem hiding this comment.
I've added another variant with ASSERT_ERRNO_EQ, ASSERT_ERRNO_FAILURE and ASSERT_ERRNO_SUCCESS.
|
Thanks for cleaning this up! Just a little nit on the style consistency. |
lntue
approved these changes
Jan 26, 2024
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
No description provided.