[libc][NFC] Add a death test API adaptation macro

[michaelrj]

Summary

Fuchsia's zxtest has a slightly different death test definition, and
this macro makes our death test API work on Fuchsia.

[sivachandra]

You need update all tests with EXPECT|ASSERT_DEATH.

[michaelrj]

update all of the EXPECT_DEATH calls

libc/test/src/assert/assert_test.cpp

TEST(LlvmLibcAssert, Enabled) {
   // -1 matches against any signal, which is necessary for now until
   // __llvm_libc::abort() unblocks SIGABRT. Close standard error for the
   // child process so we don't print the assertion failure message.
   EXPECT_DEATH(
       [] {
         close(2);
         assert(0);
       },
-      -1);
+      WITH_SIGNAL(-1));
 }
 
 #define NDEBUG
 #include "src/assert/assert.h"
 
 TEST(LlvmLibcAssert, Disabled) {
   EXPECT_EXITS([] { assert(0); }, 0);
 }

libc/test/src/fenv/enabled_exceptions_test.cpp

ASSERT_DEATH(
           ASSERT_EQ(__llvm_libc::feraiseexcept(others), 0);
           ASSERT_EQ(__llvm_libc::fetestexcept(others), others);
 
           // We don't check the return value when raising |e| as
           // feraiseexcept will not return when it raises an enabled
           // exception.
           __llvm_libc::feraiseexcept(e);
         },
-        SIGFPE);
+        WITH_SIGNAL(SIGFPE));
   }
 }

libc/test/src/signal/raise_test.cpp

 
 TEST(LlvmLibcSignalTest, Raise) {
   // SIGCONT is ingored unless stopped, so we can use it to check the return
   // value of raise without needing to block.
   EXPECT_EQ(__llvm_libc::raise(SIGCONT), 0);
 
   // SIGKILL is chosen because other fatal signals could be caught by sanitizers
   // for example and incorrectly report test failure.
-  EXPECT_DEATH([] { __llvm_libc::raise(SIGKILL); }, SIGKILL);
+  EXPECT_DEATH([] { __llvm_libc::raise(SIGKILL); }, WITH_SIGNAL(SIGKILL));
 }

libc/test/src/signal/sigaction_test.cpp

TEST(LlvmLibcSigaction, CustomAction) {
 
   __llvm_libc::raise(SIGUSR1);
   EXPECT_EQ(sigusr1Count, 1);
   EXPECT_TRUE(correctSignal);
 
   action.sa_handler = SIG_DFL;
   EXPECT_THAT(__llvm_libc::sigaction(SIGUSR1, &action, nullptr), Succeeds());
 
-  EXPECT_DEATH([] { __llvm_libc::raise(SIGUSR1); }, SIGUSR1);
+  EXPECT_DEATH([] { __llvm_libc::raise(SIGUSR1); }, WITH_SIGNAL(SIGUSR1));
 }
 
 TEST(LlvmLibcSigaction, Ignore) {
   struct __sigaction action;
   EXPECT_THAT(__llvm_libc::sigaction(SIGUSR1, nullptr, &action), Succeeds());
   action.sa_handler = SIG_IGN;
   EXPECT_THAT(__llvm_libc::sigaction(SIGUSR1, &action, nullptr), Succeeds());
 
   EXPECT_EXITS([] { __llvm_libc::raise(SIGUSR1); }, 0);
 }

libc/test/src/signal/sigdelset_test.cpp

 }
 
 TEST(LlvmLibcSigdelset, UnblockOne) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   sigset_t set;
   EXPECT_THAT(__llvm_libc::sigfillset(&set), Succeeds());
   EXPECT_THAT(__llvm_libc::sigdelset(&set, SIGUSR1), Succeeds());
   EXPECT_THAT(__llvm_libc::sigprocmask(SIG_SETMASK, &set, nullptr), Succeeds());
-  EXPECT_DEATH([] { __llvm_libc::raise(SIGUSR1); }, SIGUSR1);
+  EXPECT_DEATH([] { __llvm_libc::raise(SIGUSR1); }, WITH_SIGNAL(SIGUSR1));
 }

libc/test/src/signal/sigprocmask_test.cpp

 }
 
 // This tests that when nothing is blocked, a process gets killed and alse tests
 // that when signals are blocked they are not delivered to the process.
 TEST_F(LlvmLibcSignalTest, BlockUnblock) {
   sigset_t sigset;
   EXPECT_EQ(__llvm_libc::sigemptyset(&sigset), 0);
   EXPECT_EQ(__llvm_libc::sigprocmask(SIG_SETMASK, &sigset, nullptr), 0);
-  EXPECT_DEATH([] { __llvm_libc::raise(SIGUSR1); }, SIGUSR1);
+  EXPECT_DEATH([] { __llvm_libc::raise(SIGUSR1); }, WITH_SIGNAL(SIGUSR1));
   EXPECT_EQ(__llvm_libc::sigaddset(&sigset, SIGUSR1), 0);
   EXPECT_EQ(__llvm_libc::sigprocmask(SIG_SETMASK, &sigset, nullptr), 0);
   EXPECT_EXITS([] { __llvm_libc::raise(SIGUSR1); }, 0);
 }

libc/test/src/stdlib/abort_test.cpp

 //===-- Unittests for abort -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "include/signal.h"
 #include "include/stdlib.h"
 #include "src/stdlib/abort.h"
 #include "utils/UnitTest/Test.h"
 
 TEST(LlvmLibcStdlib, abort) {
   // -1 matches against any signal, which is necessary for now until
   // __llvm_libc::abort() unblocks SIGABRT.
-  EXPECT_DEATH([] { __llvm_libc::abort(); }, -1);
+  EXPECT_DEATH([] { __llvm_libc::abort(); }, WITH_SIGNAL(-1));
 }

libc/utils/UnitTest/FuchsiaTest.h

 //===-- Header for setting up the Fuchsia tests -----------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_UTILS_UNITTEST_FUCHSIATEST_H
 #define LLVM_LIBC_UTILS_UNITTEST_FUCHSIATEST_H
 
 #include <zxtest/zxtest.h>
 
+#define WITH_SIGNAL(X) #X
+
 #endif // LLVM_LIBC_UTILS_UNITTEST_FUCHSIATEST_H

libc/utils/UnitTest/LibcTest.h

#define ASSERT_THAT(MATCH, MATCHER)                                            \
   do {                                                                         \
     auto UNIQUE_VAR(__matcher) = (MATCHER);                                    \
     if (!this->testMatch(UNIQUE_VAR(__matcher).match((MATCH)),                 \
                          UNIQUE_VAR(__matcher), #MATCH, #MATCHER, __FILE__,    \
                          __LINE__))                                            \
       return;                                                                  \
   } while (0)
 
+#define WITH_SIGNAL(X) X
+
 #endif // LLVM_LIBC_UTILS_UNITTEST_LIBCTEST_H