Initial commit

module/jni/libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/detach.pass.cpp

@@ -0,0 +1,98 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: no-threads
+
+// <thread>
+
+// class thread
+
+// void detach();
+
+#include <thread>
+#include <atomic>
+#include <system_error>
+#include <cassert>
+
+#include "make_test_thread.h"
+#include "test_macros.h"
+
+std::atomic_bool done(false);
+
+class G
+{
+    int alive_;
+    bool done_;
+public:
+    static int n_alive;
+    static bool op_run;
+
+    G() : alive_(1), done_(false)
+    {
+        ++n_alive;
+    }
+
+    G(const G& g) : alive_(g.alive_), done_(false)
+    {
+        ++n_alive;
+    }
+    ~G()
+    {
+        alive_ = 0;
+        --n_alive;
+        if (done_) done = true;
+    }
+
+    void operator()()
+    {
+        assert(alive_ == 1);
+        assert(n_alive >= 1);
+        op_run = true;
+        done_ = true;
+    }
+};
+
+int G::n_alive = 0;
+bool G::op_run = false;
+
+void foo() { done = true; }
+
+int main(int, char**)
+{
+    {
+        G g;
+        std::thread t0 = support::make_test_thread(g);
+        assert(t0.joinable());
+        t0.detach();
+        assert(!t0.joinable());
+        while (!done) {}
+        assert(G::op_run);
+        assert(G::n_alive == 1);
+    }
+    assert(G::n_alive == 0);
+    done = false;
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    {
+        std::thread t0 = support::make_test_thread(foo);
+        assert(t0.joinable());
+        t0.detach();
+        assert(!t0.joinable());
+        try {
+            t0.detach();
+        } catch (std::system_error const&) {
+        }
+        // Wait to make sure that the detached thread has started up.
+        // Without this, we could exit main and start destructing global
+        // resources that are needed when the thread starts up, while the
+        // detached thread would start up only later.
+        while (!done) {}
+    }
+#endif
+
+  return 0;
+}

module/jni/libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/get_id.pass.cpp

@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: no-threads
+
+// <thread>
+
+// class thread
+
+// id get_id() const;
+
+#include <thread>
+#include <new>
+#include <cstdlib>
+#include <cassert>
+
+#include "make_test_thread.h"
+#include "test_macros.h"
+
+class G
+{
+    int alive_;
+public:
+    static int n_alive;
+    static bool op_run;
+
+    G() : alive_(1) {++n_alive;}
+    G(const G& g) : alive_(g.alive_) {++n_alive;}
+    ~G() {alive_ = 0; --n_alive;}
+
+    void operator()()
+    {
+        assert(alive_ == 1);
+        assert(n_alive >= 1);
+        op_run = true;
+    }
+};
+
+int G::n_alive = 0;
+bool G::op_run = false;
+
+int main(int, char**)
+{
+    {
+        G g;
+        std::thread t0 = support::make_test_thread(g);
+        std::thread::id id0 = t0.get_id();
+        std::thread t1;
+        std::thread::id id1 = t1.get_id();
+        assert(t0.get_id() == id0);
+        assert(id0 != id1);
+        assert(t1.get_id() == std::thread::id());
+        t0.join();
+    }
+
+  return 0;
+}

module/jni/libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/join.pass.cpp

@@ -0,0 +1,87 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: no-threads
+
+// <thread>
+
+// class thread
+
+// void join();
+
+#include <thread>
+#include <new>
+#include <cstdlib>
+#include <cassert>
+#include <system_error>
+#include <atomic>
+
+#include "make_test_thread.h"
+#include "test_macros.h"
+
+std::atomic_bool done(false);
+
+class G
+{
+    int alive_;
+public:
+    static int n_alive;
+    static bool op_run;
+
+    G() : alive_(1) {++n_alive;}
+    G(const G& g) : alive_(g.alive_) {++n_alive;}
+    ~G() {alive_ = 0; --n_alive;}
+
+    void operator()()
+    {
+        assert(alive_ == 1);
+        assert(n_alive >= 1);
+        op_run = true;
+    }
+};
+
+int G::n_alive = 0;
+bool G::op_run = false;
+
+void foo() { done = true; }
+
+int main(int, char**)
+{
+    {
+        G g;
+        std::thread t0 = support::make_test_thread(g);
+        assert(t0.joinable());
+        t0.join();
+        assert(!t0.joinable());
+#ifndef TEST_HAS_NO_EXCEPTIONS
+        try {
+            t0.join();
+            assert(false);
+        } catch (std::system_error const&) {
+        }
+#endif
+    }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    {
+        std::thread t0 = support::make_test_thread(foo);
+        t0.detach();
+        try {
+            t0.join();
+            assert(false);
+        } catch (std::system_error const&) {
+        }
+        // Wait to make sure that the detached thread has started up.
+        // Without this, we could exit main and start destructing global
+        // resources that are needed when the thread starts up, while the
+        // detached thread would start up only later.
+        while (!done) {}
+    }
+#endif
+
+  return 0;
+}

module/jni/libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/joinable.pass.cpp

@@ -0,0 +1,58 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: no-threads
+
+// <thread>
+
+// class thread
+
+// bool joinable() const;
+
+#include <thread>
+#include <new>
+#include <cstdlib>
+#include <cassert>
+
+#include "make_test_thread.h"
+#include "test_macros.h"
+
+class G
+{
+    int alive_;
+public:
+    static int n_alive;
+    static bool op_run;
+
+    G() : alive_(1) {++n_alive;}
+    G(const G& g) : alive_(g.alive_) {++n_alive;}
+    ~G() {alive_ = 0; --n_alive;}
+
+    void operator()()
+    {
+        assert(alive_ == 1);
+        assert(n_alive >= 1);
+        op_run = true;
+    }
+};
+
+int G::n_alive = 0;
+bool G::op_run = false;
+
+int main(int, char**)
+{
+    {
+        G g;
+        std::thread t0 = support::make_test_thread(g);
+        assert(t0.joinable());
+        t0.join();
+        assert(!t0.joinable());
+    }
+
+  return 0;
+}

module/jni/libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/swap.pass.cpp

@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: no-threads
+
+// <thread>
+
+// class thread
+
+// void swap(thread& t);
+
+#include <thread>
+#include <new>
+#include <cstdlib>
+#include <cassert>
+
+#include "make_test_thread.h"
+#include "test_macros.h"
+
+class G
+{
+    int alive_;
+public:
+    static int n_alive;
+    static bool op_run;
+
+    G() : alive_(1) {++n_alive;}
+    G(const G& g) : alive_(g.alive_) {++n_alive;}
+    ~G() {alive_ = 0; --n_alive;}
+
+    void operator()()
+    {
+        assert(alive_ == 1);
+        assert(n_alive >= 1);
+        op_run = true;
+    }
+};
+
+int G::n_alive = 0;
+bool G::op_run = false;
+
+int main(int, char**)
+{
+    {
+        G g;
+        std::thread t0 = support::make_test_thread(g);
+        std::thread::id id0 = t0.get_id();
+        std::thread t1;
+        std::thread::id id1 = t1.get_id();
+        t0.swap(t1);
+        assert(t0.get_id() == id1);
+        assert(t1.get_id() == id0);
+        t1.join();
+    }
+
+  return 0;
+}