[libc][NFC] Use specific EXPECT/ASSERT macros to test errno

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,13 @@
 #define ASSERT_NE(val1, val2)                                                  \
   __CHECK_NE(__FILE__, __LINE__, (val1), (val2), true)
 
+////////////////////////////////////////////////////////////////////////////////
+// Errno checks.
+
+#define ASSERT_ERRNO_EQ(VAL) ASSERT_EQ(VAL, static_cast<int>(libc_errno))
+#define ASSERT_ERRNO_SUCCESS() ASSERT_EQ(0, static_cast<int>(libc_errno))
+#define ASSERT_ERRNO_FAILURE() ASSERT_NE(0, static_cast<int>(libc_errno))
+
 // 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"'.

libc/test/UnitTest/LibcTest.h

@@ -443,6 +443,13 @@ 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 ASSERT_ERRNO_EQ(VAL) ASSERT_EQ(VAL, static_cast<int>(libc_errno))
+#define ASSERT_ERRNO_SUCCESS() ASSERT_EQ(0, static_cast<int>(libc_errno))
+#define ASSERT_ERRNO_FAILURE() ASSERT_NE(0, static_cast<int>(libc_errno))
+
 ////////////////////////////////////////////////////////////////////////////////
 // Subprocess checks.
 

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_SUCCESS();
   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_SUCCESS();
 
   ASSERT_EQ(
       LIBC_NAMESPACE::pthread_attr_getstacksize(expec_attrs, &expec_stacksize2),
       0);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_ERRNO_SUCCESS();
 
   ASSERT_EQ(
       LIBC_NAMESPACE::pthread_attr_getguardsize(expec_attrs, &expec_guardsize),
       0);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_ERRNO_SUCCESS();
 
   ASSERT_EQ(
       LIBC_NAMESPACE::pthread_attr_getdetachstate(expec_attrs, &expec_detached),
       0);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_ERRNO_SUCCESS();
 
   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_SUCCESS();
 
   // Arg is malloced, so free.
   delete th_arg;
@@ -140,34 +140,34 @@ 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_SUCCESS();
 
   ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_setdetachstate(attr, detachstate), 0);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_ERRNO_SUCCESS();
 
   ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_setguardsize(attr, guardsize), 0);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_ERRNO_SUCCESS();
 
   void *Stack = nullptr;
   if (customstack) {
     Stack = LIBC_NAMESPACE::mmap(nullptr, stacksize, PROT_READ | PROT_WRITE,
                                  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_SUCCESS();
 
     ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_setstack(attr, Stack, stacksize), 0);
-    ASSERT_EQ(libc_errno, 0);
+    ASSERT_ERRNO_SUCCESS();
   } else {
     ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_setstacksize(attr, stacksize), 0);
-    ASSERT_EQ(libc_errno, 0);
+    ASSERT_ERRNO_SUCCESS();
   }
 
   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_SUCCESS();
   }
 
   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_SUCCESS();
 
   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_SUCCESS();
     ASSERT_EQ(th_ret, expec_ret);
 
     if (customstack) {
       ASSERT_EQ(LIBC_NAMESPACE::munmap(Stack, stacksize), 0);
-      ASSERT_EQ(libc_errno, 0);
+      ASSERT_ERRNO_SUCCESS();
     }
   } 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_SUCCESS();
 
   ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_destroy(attr), 0);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_ERRNO_SUCCESS();
 }
 
 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_SUCCESS();
 
   ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_setguardsize(&attr, guardsize), 0);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_ERRNO_SUCCESS();
 
   ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_setstacksize(&attr, stacksize), 0);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_ERRNO_SUCCESS();
 
   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_SUCCESS();
   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_SUCCESS();
   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_SUCCESS();
   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_SUCCESS();
   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_SUCCESS();
   attr.__detachstate = -1;
   create_and_check_failure_thread(&attr);
 }

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_SUCCESS();
   ASSERT_EQ(LIBC_NAMESPACE::pthread_join(Tid, nullptr), 0);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_ERRNO_SUCCESS();
 }
 
 TEST_MAIN() {

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

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_SUCCESS();
 
   ASSERT_TRUE(file1 != nullptr);
   ASSERT_TRUE(file2 != nullptr);
@@ -58,14 +58,14 @@ 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;
 }
 
 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;
 }

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_SUCCESS();
   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_SUCCESS();
   ASSERT_GT(fd, 0);
   ASSERT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));
 

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_SUCCESS();
   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_SUCCESS();
   ASSERT_GT(read_fd, 0);
   char read_buf[TEST_MSG_SIZE];
   ASSERT_THAT(LIBC_NAMESPACE::read(read_fd, read_buf, TEST_MSG_SIZE),

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_SUCCESS();
     int min_priority = LIBC_NAMESPACE::sched_get_priority_min(policy);
     ASSERT_GE(min_priority, 0);
-    ASSERT_EQ(libc_errno, 0);
+    ASSERT_ERRNO_SUCCESS();
 
     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_SUCCESS();
     int min_priority = LIBC_NAMESPACE::sched_get_priority_min(policy);
     ASSERT_GE(min_priority, 0);
-    ASSERT_EQ(libc_errno, 0);
+    ASSERT_ERRNO_SUCCESS();
 
     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_SUCCESS();
     int min_priority = LIBC_NAMESPACE::sched_get_priority_min(policy);
     ASSERT_GE(min_priority, 0);
-    ASSERT_EQ(libc_errno, 0);
+    ASSERT_ERRNO_SUCCESS();
 
     ASSERT_LE(max_priority, 99);
     ASSERT_GE(min_priority, 0);