Test asyncMainDrainQueue hooking

This patch tests that the hook actually works. Not going to lie, the
test is pretty disgusting. The function we're testing is a noreturn
function, which introduces some interesting challenges when we need to
return to finish the test.

I need to somehow exit the function without killing the process, but
also without returning. If I just use a loop properly, the test will
hang for the age of the universe. If I don't and return from the hook,
the test will abort or crash. I tried removing the abort after the hook
in the hook override macro to see if we could sneak past the compiler,
and no, that explodes on the return pointer.

So, here's the workaround. C++11 threads don't seem to have a way to
kill themselves, but you can use `pthread_exit` or `pthread_kill` to
either kill yourself or kill another thread. So the override function
sets the `Ran` to true, and then exits (which is noreturn, so we haven't
broken that contract), killing itself and allowing us to join without
returning from the inferior. The main thread immediately waits for the
original thread to die. Since it blocks, we avoid the possible race on
setting the state of `Ran` in the override hook and where it gets
checked in the test. If that becomes an issue, we could probably just
wrap the `Ran` bool in an atomic and call it a day.

Anyway, it's well past my bedtime and I'm playing with threads. This can
only end in a creative disaster. :D

Author: etcwilde

unittests/runtime/CompatibilityOverrideConcurrency.cpp

@@ -18,6 +18,12 @@
 #include "swift/Runtime/Concurrency.h"
 #include "gtest/gtest.h"
 
+#if __has_include("pthread.h")
+
+#define RUN_ASYNC_MAIN_DRAIN_QUEUE_TEST 1
+#include <pthread.h>
+#endif // HAVE_PTHREAD_H
+
 #include <stdio.h>
 
 using namespace swift;
@@ -91,6 +97,16 @@ static void swift_task_enqueueMainExecutor_override(
   Ran = true;
 }
 
+#ifdef RUN_ASYNC_MAIN_DRAIN_QUEUE_TEST
+[[noreturn]] SWIFT_CC(swift)
+static void swift_task_asyncMainDrainQueue_override_fn(
+    swift_task_asyncMainDrainQueue_original original,
+    swift_task_asyncMainDrainQueue_override compatOverride) {
+  Ran = true;
+  pthread_exit(nullptr); // noreturn function
+}
+#endif
+
 class CompatibilityOverrideConcurrencyTest : public ::testing::Test {
 protected:
   virtual void SetUp() {
@@ -109,6 +125,10 @@ class CompatibilityOverrideConcurrencyTest : public ::testing::Test {
         swift_task_enqueueGlobalWithDelay_override;
     swift_task_enqueueMainExecutor_hook =
         swift_task_enqueueMainExecutor_override;
+#ifdef RUN_ASYNC_MAIN_DRAIN_QUEUE_TEST
+    swift_task_asyncMainDrainQueue_hook =
+        swift_task_asyncMainDrainQueue_override_fn;
+#endif
   }
 
   virtual void TearDown() {
@@ -264,4 +284,27 @@ TEST_F(CompatibilityOverrideConcurrencyTest, test_swift_task_escalate) {
   swift_task_escalate(nullptr, {});
 }
 
+#if RUN_ASYNC_MAIN_DRAIN_QUEUE_TEST
+TEST_F(CompatibilityOverrideConcurrencyTest, test_swift_task_asyncMainDrainQueue) {
+
+  auto runner = [](void *) -> void * {
+    swift_task_asyncMainDrainQueue();
+    return nullptr;
+  };
+
+  int ret = 0;
+  pthread_t thread;
+  pthread_attr_t attrs;
+  ret = pthread_attr_init(&attrs);
+  ASSERT_EQ(ret, 0);
+  ret = pthread_create(&thread, &attrs, runner, nullptr);
+  ASSERT_EQ(ret, 0);
+  void * result = nullptr;
+  ret = pthread_join(thread, &result);
+  ASSERT_EQ(ret, 0);
+  pthread_attr_destroy(&attrs);
+  ASSERT_EQ(ret, 0);
+}
+#endif
+
 #endif