commit 95646e66666113a5463085ef34da345b0fb7e5e9
author Elliott Hughes <enh@google.com> Thu Sep 21 14:11:19 2023 -0700
committer Elliott Hughes <enh@google.com> Thu Sep 21 14:15:59 2023 -0700
tree 42c7d3a270f006219970d4e27db7a1e979b00f8a
parent 631dfbb8ad2edd23e008c820f499152ac0d16caa

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

tests/signal_test.cpp

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(&not_SIGALRM);
   sigdelset(&not_SIGALRM, SIGALRM);
   ASSERT_EQ(-1, sigsuspend(&not_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(&not_SIGRTMIN);
   sigdelset64(&not_SIGRTMIN, SIGRTMIN);
   ASSERT_EQ(-1, sigsuspend64(&not_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);
 }