[Unittests] Add more threading library tests.

Added explicit tests for `swift::once` and also for the ulock implementation
used on Linux.

rdar://90776105

Author: al45tair

unittests/Threading/CMakeLists.txt

@@ -1,5 +1,7 @@
 add_swift_unittest(SwiftThreadingTests
   Mutex.cpp
+  Once.cpp
+  LinuxUlock.cpp
   )
 
 target_link_libraries(SwiftThreadingTests

unittests/Threading/LinuxUlock.cpp

@@ -0,0 +1,58 @@
+//===--- LinuxULock.cpp - Tests the Linux ulock implementation ------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#if SWIFT_THREADING_LINUX
+
+#include "swift/Threading/Impl/Linux/ulock.h"
+#include "gtest/gtest.h"
+
+#include "LockingHelpers.h"
+
+using namespace swift;
+using namespace swift::threading_impl;
+
+// -----------------------------------------------------------------------------
+
+// Use the existing locking tests to check threaded operation
+class UlockMutex {
+private:
+  linux::ulock_t lock_;
+
+public:
+  UlockMutex() : lock_(0) {}
+
+  void lock() { linux::ulock_lock(&lock); }
+  void unlock() { linux::ulock_unlock(&lock); }
+  bool try_lock() { return linux::ulock_trylock(&lock); }
+};
+
+TEST(LinuxUlockTest, SingleThreaded) {
+  UlockMutex mutex;
+  basicLockable(mutex);
+}
+
+TEST(LinuxUlockTest, SingleThreadedTryLock) {
+  UlockMutex mutex;
+  tryLockable(mutex);
+}
+
+TEST(LinuxULockTest, BasicLockableThreaded) {
+  UlockMutex mutex;
+  basicLockableThreaded(mutex);
+}
+
+TEST(LinuxULockTest, LockableThreaded) {
+  UlockMutex mutex;
+  lockableThreaded(mutex);
+}
+
+#endif // SWIFT_THREADING_LINUX

unittests/Threading/LockingHelpers.h

@@ -0,0 +1,151 @@
+//===--- LockingHelpers.h - Utilities to help test locks ------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LOCKING_HELPERS_H
+#define LOCKING_HELPERS_H
+
+#include "ThreadingHelpers.h"
+
+// Test that a Mutex object can be locked and unlocked from a single thread
+template <typename M> void basicLockable(M &mutex) {
+  // We can lock, unlock, lock and unlock an unlocked lock
+  mutex.lock();
+  mutex.unlock();
+  mutex.lock();
+  mutex.unlock();
+}
+
+// Test that a Mutex object's try_lock() method works.
+template <typename M> void tryLockable(M &mutex) {
+  bool ret;
+
+  // We can lock an unlocked lock
+  ret = mutex.try_lock();
+  ASSERT_TRUE(ret);
+
+  // We cannot lock a locked lock
+  ret = mutex.try_lock();
+  ASSERT_FALSE(ret);
+
+  mutex.unlock();
+}
+
+// Test that a Mutex object can be locked and unlocked
+template <typename M> void basicLockableThreaded(M &mutex) {
+  int count1 = 0;
+  int count2 = 0;
+
+  threadedExecute(10, [&](int) {
+    for (int j = 0; j < 50; ++j) {
+      mutex.lock();
+      auto count = count2;
+      count1++;
+      count2 = count + 1;
+      mutex.unlock();
+    }
+  });
+
+  ASSERT_EQ(count1, 500);
+  ASSERT_EQ(count2, 500);
+}
+
+// More extensive tests
+template <typename M> void lockableThreaded(M &mutex) {
+  mutex.lock();
+  threadedExecute(5, [&](int) { ASSERT_FALSE(mutex.try_lock()); });
+  mutex.unlock();
+  threadedExecute(1, [&](int) {
+    ASSERT_TRUE(mutex.try_lock());
+    mutex.unlock();
+  });
+
+  int count1 = 0;
+  int count2 = 0;
+  threadedExecute(10, [&](int) {
+    for (int j = 0; j < 50; ++j) {
+      if (mutex.try_lock()) {
+        auto count = count2;
+        count1++;
+        count2 = count + 1;
+        mutex.unlock();
+      } else {
+        j--;
+      }
+    }
+  });
+
+  ASSERT_EQ(count1, 500);
+  ASSERT_EQ(count2, 500);
+}
+
+// Test a scoped lock implementation
+template <typename SL, typename M> void scopedLockThreaded(M &mutex) {
+  int count1 = 0;
+  int count2 = 0;
+
+  threadedExecute(10, [&](int) {
+    for (int j = 0; j < 50; ++j) {
+      SL guard(mutex);
+      auto count = count2;
+      count1++;
+      count2 = count + 1;
+    }
+  });
+
+  ASSERT_EQ(count1, 500);
+  ASSERT_EQ(count2, 500);
+}
+
+// Test a scoped unlock nested in a scoped lock
+template <typename SL, typename SU, typename M>
+void scopedUnlockUnderScopedLockThreaded(M &mutex) {
+  int count1 = 0;
+  int count2 = 0;
+  int badCount = 0;
+
+  threadedExecute(10, [&](int) {
+    for (int j = 0; j < 50; ++j) {
+      SL guard(mutex);
+      {
+        SU unguard(mutex);
+        badCount++;
+      }
+      auto count = count2;
+      count1++;
+      count2 = count + 1;
+    }
+  });
+
+  ASSERT_EQ(count1, 500);
+  ASSERT_EQ(count2, 500);
+}
+
+// Test a critical section
+template <typename M> void criticalSectionThreaded(M &mutex) {
+  int count1 = 0;
+  int count2 = 0;
+
+  threadedExecute(10, [&](int) {
+    for (int j = 0; j < 50; ++j) {
+      mutex.withLock([&] {
+        auto count = count2;
+        count1++;
+        count2 = count + 1;
+      });
+    }
+  });
+
+  ASSERT_EQ(count1, 500);
+  ASSERT_EQ(count2, 500);
+}
+
+#endif