[scudo][standalone] Enable death tests on Fuchsia

[cryptoad]

Summary

zxtest doesn't have EXPECT_DEATH and the Scudo unit-tests were
defining it as a no-op.

This enables death tests on Fuchsia by using ASSERT_DEATH instead.
I used a lambda to wrap the expressions as this appears to not be
working the same way as EXPECT_DEATH.

Additionnally, a death test using alarm was failing with the change,
as it's currently not implemented in Fuchsia, so move that test within
a !SCUDO_FUCHSIA block.

[mcgrathr]

compiler-rt/lib/scudo/standalone/tests/scudo_unit_test.h

21

The second argument to zxtest's ASSERT_DEATH is not comparable to the gtest EXPECT_DEATH argument.
In zxtest, it's just a message and printf args like in other ASSERT_* macros.
In gtest, it's a matcher for the error output of the crashing process.
In zxtest, the the test is run in a separate thread and not a separate process, so you need to make sure your death tests' assumptions don't include that fouling the process-wide state is OK. There is no facility for matching any particular kind of crash, it just checks that the thread got a fatal exception of some kind.

[cryptoad]

compiler-rt/lib/scudo/standalone/tests/scudo_unit_test.h

21

Thank you for pointing this out, I didn't realize it.
Currently most of the matchers are "", with a few being actual regexps, which could lead to confusion when they are dumped out. I could replace Y with "" since I don't think we need additional output information for those.
Regarding the state, for now everything is passing, but I'll go and check them one by one to make sure they don't mess with a process-wide state.

[cryptoad]

Went through the death tests to ensure they were not messing with the
global state.

Ran run fuchsia-pkg://fuchsia.com/libc-unittests-pkg#meta/libc-unittests-pkg.cmx
multiple times on Fuchsia with the patch applied, it all passes.

[mcgrathr]

lgtm.
btw, I think fx test --count will do that for you.

compiler-rt/lib/scudo/standalone/tests/scudo_unit_test.h

 //===-- scudo_unit_test.h ---------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "platform.h"
 
 #if SCUDO_FUCHSIA
 #include <zxtest/zxtest.h>
 #else
 #include "gtest/gtest.h"
 #endif
 
 // If EXPECT_DEATH isn't defined, make it a no-op.
 #ifndef EXPECT_DEATH
+// If ASSERT_DEATH is defined, make EXPECT_DEATH a wrapper to it.
+#ifdef ASSERT_DEATH
+#define EXPECT_DEATH(X, Y) ASSERT_DEATH(([&] { X; }), "")
+#else
 #define EXPECT_DEATH(X, Y)                                                     \
   do {                                                                         \
   } while (0)
-#endif
+#endif // ASSERT_DEATH
+#endif // EXPECT_DEATH
 
 // If EXPECT_STREQ isn't defined, define our own simple one.
 #ifndef EXPECT_STREQ
 #define EXPECT_STREQ(X, Y) EXPECT_EQ(strcmp(X, Y), 0)
 #endif
 
 extern bool UseQuarantine;

compiler-rt/lib/scudo/standalone/tests/wrappers_c_test.cpp

TEST(ScudoWrappersCTest, MallocIterateBoundary) {
 
   while (P) {
     void *NextP = *reinterpret_cast<void **>(P);
     free(P);
     P = NextP;
   }
 }
 
-// We expect heap operations within a disable/enable scope to deadlock.
+// Fuchsia doesn't have alarm, fork or malloc_info.
+#if !SCUDO_FUCHSIA
 TEST(ScudoWrappersCTest, MallocDisableDeadlock) {
+  // We expect heap operations within a disable/enable scope to deadlock.
   EXPECT_DEATH(
       {
         void *P = malloc(Size);
         EXPECT_NE(P, nullptr);
         free(P);
         malloc_disable();
         alarm(1);
         P = malloc(Size);
         malloc_enable();
       },
       "");
 }
 
-// Fuchsia doesn't have fork or malloc_info.
-#if !SCUDO_FUCHSIA
-
 TEST(ScudoWrappersCTest, MallocInfo) {
   // Use volatile so that the allocations don't get optimized away.
   void *volatile P1 = malloc(1234);
   void *volatile P2 = malloc(4321);
 
   char Buffer[16384];
   FILE *F = fmemopen(Buffer, sizeof(Buffer), "w+");
   EXPECT_NE(F, nullptr);