[libc][NFC] Convert threads unittests in to integration tests.

[sivachandra]

Summary

This is mostly a mechanical change. In a future pass, all tests from
pthread which create threads will also be converted to integration tests.

Some of thread related features are tightly coupled with the loader. So,
they can only be tested with the in-house loader. Hence, going forward, all
tests which create threads will have to be integration tests.

[sivachandra]

Remove a now empty directory.

libc/test/integration/CMakeLists.txt

 add_custom_target(libc-integration-tests)
 
+function(add_libc_integration_test_suite name)
+  add_custom_target(${name})
+  add_dependencies(libc-integration-tests ${name})
+endfunction()
+
 add_library(
   libc_integration_test_dummy
   STATIC
   dummy.cpp
 )
 set_target_properties(libc_integration_test_dummy
     PROPERTIES
       ARCHIVE_OUTPUT_NAME dummy
       ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 
 add_subdirectory(loader)
 add_subdirectory(scudo)
 add_subdirectory(src)

libc/test/integration/src/CMakeLists.txt

 add_subdirectory(stdlib)
+add_subdirectory(threads)

libc/test/integration/src/threads/CMakeLists.txt

-add_libc_testsuite(libc_threads_unittests)
+add_libc_integration_test_suite(libc-threads-integration-tests)
 
-add_libc_unittest(
-  call_once_test
+add_integration_test(
+  mtx_test
   SUITE
-    libc_threads_unittests
+    libc-threads-integration-tests
   SRCS
-    call_once_test.cpp
+    mtx_test.cpp
+  LOADER
+    libc.loader.linux.crt1
   DEPENDS
     libc.include.threads
-    libc.src.threads.call_once
+    libc.src.errno.errno
     libc.src.threads.mtx_destroy
     libc.src.threads.mtx_init
     libc.src.threads.mtx_lock
     libc.src.threads.mtx_unlock
     libc.src.threads.thrd_create
     libc.src.threads.thrd_join
-    libc.src.__support.CPP.atomic
 )
 
-add_libc_unittest(
+add_integration_test(
   thrd_test
   SUITE
-    libc_threads_unittests
+    libc-threads-integration-tests
   SRCS
     thrd_test.cpp
+  LOADER
+    libc.loader.linux.crt1
   DEPENDS
     libc.include.threads
     libc.src.errno.errno
     libc.src.threads.thrd_create
     libc.src.threads.thrd_join
 )
 
-add_libc_unittest(
-  mtx_test
+add_integration_test(
+  call_once_test
   SUITE
-    libc_threads_unittests
+    libc-threads-integration-tests
   SRCS
-    mtx_test.cpp
+    call_once_test.cpp
+  LOADER
+    libc.loader.linux.crt1
   DEPENDS
     libc.include.threads
-    libc.src.errno.errno
+    libc.src.threads.call_once
     libc.src.threads.mtx_destroy
     libc.src.threads.mtx_init
     libc.src.threads.mtx_lock
     libc.src.threads.mtx_unlock
     libc.src.threads.thrd_create
     libc.src.threads.thrd_join
+    libc.src.__support.CPP.atomic
 )
 
-add_libc_unittest(
+add_integration_test(
   cnd_test
   SUITE
-    libc_threads_unittests
+    libc-threads-integration-tests
   SRCS
     cnd_test.cpp
+  LOADER
+    libc.loader.linux.crt1
   DEPENDS
     libc.include.threads
     libc.src.threads.cnd_init
     libc.src.threads.cnd_broadcast
     libc.src.threads.cnd_signal
     libc.src.threads.cnd_destroy
     libc.src.threads.cnd_wait
     libc.src.threads.mtx_destroy
     libc.src.threads.mtx_init
     libc.src.threads.mtx_lock
     libc.src.threads.mtx_unlock
     libc.src.threads.thrd_create
     libc.src.threads.thrd_join
     libc.src.threads.linux.threads_utils
 )

libc/test/integration/src/threads/call_once_test.cpp

-//===-- Unittests for call_once -------------------------------------------===//
+//===-- Tests for call_once -----------------------------------------------===//
 //
 // 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/threads.h"
 #include "src/__support/CPP/atomic.h"
 #include "src/threads/call_once.h"
 #include "src/threads/mtx_destroy.h"
 #include "src/threads/mtx_init.h"
 #include "src/threads/mtx_lock.h"
 #include "src/threads/mtx_unlock.h"
 #include "src/threads/thrd_create.h"
 #include "src/threads/thrd_join.h"
-#include "utils/UnitTest/Test.h"
+
+#include "utils/IntegrationTest/test.h"
+
+#include <threads.h>
 
 static constexpr unsigned int NUM_THREADS = 5;
 static __llvm_libc::cpp::Atomic<unsigned int> thread_count;
 
 static unsigned int call_count;
 static void call_once_func() { ++call_count; }
 
 static int func(void *) {
   static once_flag flag = ONCE_FLAG_INIT;
   __llvm_libc::call_once(&flag, call_once_func);
 
   thread_count.fetch_add(1);
 
   return 0;
 }
 
-TEST(LlvmLibcCallOnceTest, CallFrom5Threads) {
+void call_from_5_threads() {
   // Ensure the call count and thread count are 0 to begin with.
   call_count = 0;
   thread_count = 0;
 
   thrd_t threads[NUM_THREADS];
   for (unsigned int i = 0; i < NUM_THREADS; ++i) {
     ASSERT_EQ(__llvm_libc::thrd_create(threads + i, func, nullptr),
               static_cast<int>(thrd_success));
static int once_func_caller(void *) {
   __llvm_libc::call_once(&flag, blocking_once_func);
   done_count.fetch_add(1);
   return 0;
 }
 
 // Test the synchronization aspect of the call_once function.
 // This is not a fool proof test, but something which might be
 // useful when we add a flakiness detection scheme to UnitTest.
-TEST(LlvmLibcCallOnceTest, TestSynchronization) {
+void test_synchronization() {
   start_count = 0;
   done_count = 0;
 
   ASSERT_EQ(__llvm_libc::mtx_init(&once_func_blocker, mtx_plain),
             static_cast<int>(thrd_success));
   // Lock the blocking mutex so that the once func blocks.
   ASSERT_EQ(__llvm_libc::mtx_lock(&once_func_blocker),
             static_cast<int>(thrd_success));
void test_synchronization() {
   ASSERT_EQ(__llvm_libc::thrd_join(&t2, &retval),
             static_cast<int>(thrd_success));
   ASSERT_EQ(retval, 0);
 
   ASSERT_EQ(done_count.val, 2U);
 
   __llvm_libc::mtx_destroy(&once_func_blocker);
 }
+
+int main() {
+  call_from_5_threads();
+  test_synchronization();
+  return 0;
+}

libc/test/integration/src/threads/cnd_test.cpp

-//===-- Unittests for condition variable broadcast fucntionality ----------===//
+//===-- Tests for standard condition variables ----------------------------===//
 //
 // 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/threads.h"
 #include "src/__support/CPP/atomic.h"
 #include "src/threads/cnd_broadcast.h"
 #include "src/threads/cnd_destroy.h"
 #include "src/threads/cnd_init.h"
 #include "src/threads/cnd_signal.h"
 #include "src/threads/cnd_wait.h"
 #include "src/threads/mtx_destroy.h"
 #include "src/threads/mtx_init.h"
 #include "src/threads/mtx_lock.h"
 #include "src/threads/mtx_unlock.h"
 #include "src/threads/thrd_create.h"
 #include "src/threads/thrd_join.h"
-#include "utils/UnitTest/Test.h"
+
+#include "utils/IntegrationTest/test.h"
+
+#include <threads.h>
 
 namespace wait_notify_broadcast_test {
 
 // The test in this namespace tests all condition variable operations. The
 // main thread spawns THRD_COUNT threads, each of which wait on a condition
 // variable |broadcast_cnd|. After spawing the threads, it waits on another
 // condition variable |threads_ready_cnd| which will be signalled by the last
 // thread before it starts waiting on |broadcast_cnd|. On signalled by the
int broadcast_thread_func(void *) {
   }
 
   __llvm_libc::cnd_wait(&broadcast_cnd, &broadcast_mtx);
   __llvm_libc::mtx_unlock(&broadcast_mtx);
   broadcast_count.fetch_sub(1);
   return 0;
 }
 
-TEST(LlvmLibcCndVarTest, WaitNotifyBroadcastTest) {
+void wait_notify_broadcast_test() {
   __llvm_libc::cnd_init(&broadcast_cnd);
   __llvm_libc::cnd_init(&threads_ready_cnd);
   __llvm_libc::mtx_init(&broadcast_mtx, mtx_plain);
   __llvm_libc::mtx_init(&threads_ready_mtx, mtx_plain);
 
   __llvm_libc::mtx_lock(&threads_ready_mtx);
   thrd_t threads[THRD_COUNT];
   for (unsigned int i = 0; i < THRD_COUNT; ++i)
int waiter_thread_func(void *unused) {
   __llvm_libc::mtx_unlock(&main_thread_mtx);
 
   __llvm_libc::cnd_wait(&waiter_cnd, &waiter_mtx);
   __llvm_libc::mtx_unlock(&waiter_mtx);
 
   return 0x600D;
 }
 
-TEST(LlvmLibcCndVarTest, SingleWaiterTest) {
+void single_waiter_test() {
   ASSERT_EQ(__llvm_libc::mtx_init(&waiter_mtx, mtx_plain), int(thrd_success));
   ASSERT_EQ(__llvm_libc::mtx_init(&main_thread_mtx, mtx_plain),
             int(thrd_success));
   ASSERT_EQ(__llvm_libc::cnd_init(&waiter_cnd), int(thrd_success));
   ASSERT_EQ(__llvm_libc::cnd_init(&main_thread_cnd), int(thrd_success));
 
   ASSERT_EQ(__llvm_libc::mtx_lock(&main_thread_mtx), int(thrd_success));
 
void single_waiter_test() {
 
   __llvm_libc::mtx_destroy(&waiter_mtx);
   __llvm_libc::mtx_destroy(&main_thread_mtx);
   __llvm_libc::cnd_destroy(&waiter_cnd);
   __llvm_libc::cnd_destroy(&main_thread_cnd);
 }
 
 } // namespace single_waiter_test
+
+int main() {
+  wait_notify_broadcast_test::wait_notify_broadcast_test();
+  single_waiter_test::single_waiter_test();
+  return 0;
+}

libc/test/integration/src/threads/mtx_test.cpp

-//===-- Unittests for mtx_t -----------------------------------------------===//
+//===-- Tests for mtx_t operations ----------------------------------------===//
 //
 // 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/threads.h"
 #include "src/threads/mtx_destroy.h"
 #include "src/threads/mtx_init.h"
 #include "src/threads/mtx_lock.h"
 #include "src/threads/mtx_unlock.h"
 #include "src/threads/thrd_create.h"
 #include "src/threads/thrd_join.h"
-#include "utils/UnitTest/Test.h"
+
+#include "utils/IntegrationTest/test.h"
+
+#include <threads.h>
 
 constexpr int START = 0;
 constexpr int MAX = 10000;
 
 mtx_t mutex;
 static int shared_int = START;
 
 int counter(void *arg) {
   int last_count = START;
   while (true) {
     __llvm_libc::mtx_lock(&mutex);
     if (shared_int == last_count + 1) {
       shared_int++;
       last_count = shared_int;
     }
     __llvm_libc::mtx_unlock(&mutex);
     if (last_count >= MAX)
       break;
   }
   return 0;
 }
 
-TEST(LlvmLibcMutexTest, RelayCounter) {
+void relay_counter() {
   ASSERT_EQ(__llvm_libc::mtx_init(&mutex, mtx_plain),
             static_cast<int>(thrd_success));
 
   // The idea of this test is that two competing threads will update
   // a counter only if the other thread has updated it.
   thrd_t thread;
   __llvm_libc::thrd_create(&thread, counter, nullptr);
 
int stepper(void *arg) {
   __llvm_libc::mtx_unlock(&start_lock);
 
   __llvm_libc::mtx_lock(&step_lock);
   step = true;
   __llvm_libc::mtx_unlock(&step_lock);
   return 0;
 }
 
-TEST(LlvmLibcMutexTest, WaitAndStep) {
+void wait_and_step() {
   ASSERT_EQ(__llvm_libc::mtx_init(&start_lock, mtx_plain),
             static_cast<int>(thrd_success));
   ASSERT_EQ(__llvm_libc::mtx_init(&step_lock, mtx_plain),
             static_cast<int>(thrd_success));
 
   // In this test, we start a new thread but block it before it can make a
   // step. Once we ensure that the thread is blocked, we unblock it.
   // After unblocking, we then verify that the thread was indeed unblocked.
int waiter_func(void *) {
 
   __llvm_libc::mtx_lock(&counter_lock);
   --wait_count;
   __llvm_libc::mtx_unlock(&counter_lock);
 
   return 0;
 }
 
-TEST(LlvmLibcMutexTest, MultipleWaiters) {
+void multiple_waiters() {
   __llvm_libc::mtx_init(&multiple_waiter_lock, mtx_plain);
   __llvm_libc::mtx_init(&counter_lock, mtx_plain);
 
   __llvm_libc::mtx_lock(&multiple_waiter_lock);
   thrd_t waiters[THREAD_COUNT];
   for (int i = 0; i < THREAD_COUNT; ++i) {
     __llvm_libc::thrd_create(waiters + i, waiter_func, nullptr);
   }
for (int i = 0; i < THREAD_COUNT; ++i) {
     __llvm_libc::thrd_join(waiters + i, &retval);
   }
 
   ASSERT_EQ(wait_count, 0);
 
   __llvm_libc::mtx_destroy(&multiple_waiter_lock);
   __llvm_libc::mtx_destroy(&counter_lock);
 }
+
+int main() {
+  relay_counter();
+  wait_and_step();
+  multiple_waiters();
+  return 0;
+}

libc/test/integration/src/threads/thrd_test.cpp

-//===-- Unittests for thrd_t ----------------------------------------------===//
+//===-- Tests for thrd_t creation and joining -----------------------------===//
 //
 // 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/threads.h"
 #include "src/threads/thrd_create.h"
 #include "src/threads/thrd_join.h"
-#include "utils/UnitTest/Test.h"
+
+#include "utils/IntegrationTest/test.h"
+
+#include <threads.h>
 
 static constexpr int thread_count = 1000;
 static int counter = 0;
 static int thread_func(void *) {
   ++counter;
   return 0;
 }
 
-TEST(LlvmLibcThreadTest, CreateAndJoin) {
+void create_and_join() {
   for (counter = 0; counter <= thread_count;) {
     thrd_t thread;
     int old_counter_val = counter;
     ASSERT_EQ(__llvm_libc::thrd_create(&thread, thread_func, nullptr),
               (int)thrd_success);
     int retval = thread_count + 1; // Start with a retval we dont expect.
     ASSERT_EQ(__llvm_libc::thrd_join(&thread, &retval), (int)thrd_success);
     ASSERT_EQ(retval, 0);
     ASSERT_EQ(counter, old_counter_val + 1);
   }
 }
 
 static int return_arg(void *arg) { return *reinterpret_cast<int *>(arg); }
 
-TEST(LlvmLibcThreadTest, SpawnAndJoin) {
+void spawn_and_join() {
   thrd_t thread_list[thread_count];
   int args[thread_count];
 
   for (int i = 0; i < thread_count; ++i) {
     args[i] = i;
     ASSERT_EQ(__llvm_libc::thrd_create(thread_list + i, return_arg, args + i),
               (int)thrd_success);
   }
 
   for (int i = 0; i < thread_count; ++i) {
     int retval = thread_count + 1; // Start with a retval we dont expect.
     ASSERT_EQ(__llvm_libc::thrd_join(&thread_list[i], &retval),
               (int)thrd_success);
     ASSERT_EQ(retval, i);
   }
 }
+
+int main() {
+  create_and_join();
+  spawn_and_join();
+}

libc/test/src/CMakeLists.txt

if(NOT LLVM_LIBC_FULL_BUILD)
   return()
 endif()
 
 # The signal API is currently disabled as signal.h is incorrect.
 # since assert uses the signal API, we disable assert also.
 # add_subdirectory(assert)
 # add_subdirectory(signal)
 add_subdirectory(stdio)
-add_subdirectory(threads)
 add_subdirectory(time)
 
 if(${LIBC_TARGET_OS} STREQUAL "linux")
   add_subdirectory(pthread)
 endif()
 
 set(public_test ${CMAKE_CURRENT_BINARY_DIR}/public_api_test.cpp)
 

libc/utils/IntegrationTest/test.h

 //===-- Simple checkers for integrations 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_INTEGRATION_TEST_TEST_H
 #define LLVM_LIBC_UTILS_INTEGRATION_TEST_TEST_H
 
 #include "src/__support/OSUtil/io.h"
 #include "src/__support/OSUtil/quick_exit.h"
 
 #define __AS_STRING(val) #val
-#define __CHECK(file, line, val, should_exit)                                  \
+#define __CHECK_TRUE(file, line, val, should_exit)                             \
   if (!(val)) {                                                                \
     __llvm_libc::write_to_stderr(file ":" __AS_STRING(                         \
         line) ": Expected '" #val "' to be true, but is false\n");             \
     if (should_exit)                                                           \
       __llvm_libc::quick_exit(127);                                            \
   }
 
-#define __CHECK_NE(file, line, val, should_exit)                               \
-  if ((val)) {                                                                 \
+#define __CHECK_FALSE(file, line, val, should_exit)                            \
+  if (val) {                                                                   \
     __llvm_libc::write_to_stderr(file ":" __AS_STRING(                         \
         line) ": Expected '" #val "' to be false, but is true\n");             \
     if (should_exit)                                                           \
       __llvm_libc::quick_exit(127);                                            \
   }
 
-#define EXPECT_TRUE(val) __CHECK(__FILE__, __LINE__, val, false)
-#define ASSERT_TRUE(val) __CHECK(__FILE__, __LINE__, val, true)
-#define EXPECT_FALSE(val) __CHECK_NE(__FILE__, __LINE__, val, false)
-#define ASSERT_FALSE(val) __CHECK_NE(__FILE__, __LINE__, val, true)
+#define __CHECK_EQ(file, line, val1, val2, should_exit)                        \
+  if ((val1) != (val2)) {                                                      \
+    __llvm_libc::write_to_stderr(file ":" __AS_STRING(                         \
+        line) ": Expected '" #val1 "' to be equal to '" #val2 "'\n");          \
+    if (should_exit)                                                           \
+      __llvm_libc::quick_exit(127);                                            \
+  }
+
+#define __CHECK_NE(file, line, val1, val2, should_exit)                        \
+  if ((val1) == (val2)) {                                                      \
+    __llvm_libc::write_to_stderr(file ":" __AS_STRING(                         \
+        line) ": Expected '" #val1 "' to not be equal to '" #val2 "'\n");      \
+    if (should_exit)                                                           \
+      __llvm_libc::quick_exit(127);                                            \
+  }
+
+#define EXPECT_TRUE(val) __CHECK_TRUE(__FILE__, __LINE__, val, false)
+#define ASSERT_TRUE(val) __CHECK_TRUE(__FILE__, __LINE__, val, true)
+#define EXPECT_FALSE(val) __CHECK_FALSE(__FILE__, __LINE__, val, false)
+#define ASSERT_FALSE(val) __CHECK_FALSE(__FILE__, __LINE__, val, true)
+#define EXPECT_EQ(val1, val2)                                                  \
+  __CHECK_EQ(__FILE__, __LINE__, (val1), (val2), false)
+#define ASSERT_EQ(val1, val2)                                                  \
+  __CHECK_EQ(__FILE__, __LINE__, (val1), (val2), true)
+#define EXPECT_NE(val1, val2)                                                  \
+  __CHECK_NE(__FILE__, __LINE__, (val1), (val2), false)
+#define ASSERT_NE(val1, val2)                                                  \
+  __CHECK_NE(__FILE__, __LINE__, (val1), (val2), true)
 
 #endif // LLVM_LIBC_UTILS_INTEGRATION_TEST_TEST_H