semaphore_test.cc: add TimedWaitSpuriousWakeupLinux

app/tests/semaphore_test.cc

@@ -21,6 +21,18 @@
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
+// Set SEMAPHORE_LINUX to reflect whether the platform is "Linux", using the
+// same logic that semaphore.h uses.
+#if FIREBASE_PLATFORM_OSX || FIREBASE_PLATFORM_IOS || \
+    FIREBASE_PLATFORM_TVOS || FIREBASE_PLATFORM_WINDOWS
+#define SEMAPHORE_LINUX 0
+#else
+#define SEMAPHORE_LINUX 1
+#include <pthread.h>
+
+#include <csignal>
+#endif
+
 namespace {
 
 // Basic test of TryWait, to make sure that its successes and failures
@@ -76,6 +88,43 @@ TEST(SemaphoreTest, TimedWait) {
       0.20 * firebase::internal::kMillisecondsPerSecond);
 }
 
+#if SEMAPHORE_LINUX
+// Tests that Timed Wait handles spurious wakeup (Linux/Android specific).
+TEST(SemaphoreTest, TimedWaitSpuriousWakeupLinux) {
+  // Register a dummy signal handler for SIGUSR1; otherwise, sending SIGUSR1
+  // later on will crash the application.
+  signal(SIGUSR1, [](int signum) -> void {});
+
+  // Start a thread that will send SIGUSR1 to this thread in a few moments.
+  pthread_t main_thread = pthread_self();
+  firebase::Thread signal_sending_thread = firebase::Thread(
+      [](void* arg) {
+        firebase::internal::Sleep(500);
+        pthread_kill(*static_cast<pthread_t*>(arg), SIGUSR1);
+      },
+      &main_thread);
+
+  // Call Semaphore::TimedWait() and keep track of how long it blocks for.
+  firebase::Semaphore sem(0);
+  int64_t start_ms = firebase::internal::GetTimestamp();
+  EXPECT_FALSE(sem.TimedWait(2 * firebase::internal::kMillisecondsPerSecond));
+  int64_t finish_ms = firebase::internal::GetTimestamp();
+
+  // Wait for the "signal sending" thread to terminate, since it references
+  // memory on the stack and we can't have it running after this method returns.
+  signal_sending_thread.Join();
+
+  // Unregister the signal handler for SIGUSR1, since it's no longer needed.
+  signal(SIGUSR1, NULL);
+
+  // Make sure that Semaphore::TimedWait() blocked for the entire timeout, and,
+  // specifically, did NOT return early as a result of the SIGUSR1 interruption.
+  ASSERT_LT(labs((finish_ms - start_ms) -
+                 (2 * firebase::internal::kMillisecondsPerSecond)),
+            0.20 * firebase::internal::kMillisecondsPerSecond);
+}
+#endif  // #if SEMAPHORE_LINUX
+
 TEST(SemaphoreTest, DISABLED_MultithreadedStressTest) {
   for (int i = 0; i < 10000; ++i) {
     firebase::Semaphore sem(0);