Initial commit

module/jni/libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_assign.compile.fail.cpp

@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+// 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: c++03, c++11
+// <shared_mutex>
+
+// template <class Mutex> class shared_lock;
+
+// shared_lock& operator=(shared_lock const&) = delete;
+
+#include <shared_mutex>
+
+std::shared_timed_mutex m0;
+std::shared_timed_mutex m1;
+
+int main(int, char**)
+{
+    std::shared_lock<std::shared_timed_mutex> lk0(m0);
+    std::shared_lock<std::shared_timed_mutex> lk1(m1);
+    lk1 = lk0;
+
+  return 0;
+}

module/jni/libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_ctor.compile.fail.cpp

@@ -0,0 +1,26 @@
+//===----------------------------------------------------------------------===//
+//
+// 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: c++03, c++11
+// <shared_mutex>
+
+// template <class Mutex> class shared_lock;
+
+// shared_lock(shared_lock const&) = delete;
+
+#include <shared_mutex>
+
+std::shared_timed_mutex m;
+
+int main(int, char**)
+{
+    std::shared_lock<std::shared_timed_mutex> lk0(m);
+    std::shared_lock<std::shared_timed_mutex> lk = lk0;
+
+  return 0;
+}

module/jni/libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/default.pass.cpp

@@ -0,0 +1,33 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: c++03, c++11
+
+// dylib support for shared_mutex was added in macosx10.12
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
+
+// <shared_mutex>
+
+// template <class Mutex> class shared_lock;
+
+// shared_lock();
+
+#include <shared_mutex>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, char**)
+{
+    std::shared_lock<std::shared_timed_mutex> ul;
+    assert(!ul.owns_lock());
+    assert(ul.mutex() == nullptr);
+
+  return 0;
+}

module/jni/libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_assign.pass.cpp

@@ -0,0 +1,56 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: c++03, c++11
+
+// dylib support for shared_mutex was added in macosx10.12
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
+
+// <shared_mutex>
+
+// template <class Mutex> class shared_lock;
+
+// shared_lock& operator=(shared_lock&& u);
+
+#include <shared_mutex>
+#include <cassert>
+#include "nasty_containers.h"
+
+#include "test_macros.h"
+
+
+int main(int, char**)
+{
+    {
+    typedef std::shared_timed_mutex M;
+    M m0;
+    M m1;
+    std::shared_lock<M> lk0(m0);
+    std::shared_lock<M> lk1(m1);
+    lk1 = std::move(lk0);
+    assert(lk1.mutex() == std::addressof(m0));
+    assert(lk1.owns_lock() == true);
+    assert(lk0.mutex() == nullptr);
+    assert(lk0.owns_lock() == false);
+    }
+    {
+    typedef nasty_mutex M;
+    M m0;
+    M m1;
+    std::shared_lock<M> lk0(m0);
+    std::shared_lock<M> lk1(m1);
+    lk1 = std::move(lk0);
+    assert(lk1.mutex() == std::addressof(m0));
+    assert(lk1.owns_lock() == true);
+    assert(lk0.mutex() == nullptr);
+    assert(lk0.owns_lock() == false);
+    }
+
+  return 0;
+}

module/jni/libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_ctor.pass.cpp

@@ -0,0 +1,51 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: c++03, c++11
+
+// dylib support for shared_mutex was added in macosx10.12
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
+
+// <shared_mutex>
+
+// template <class Mutex> class shared_lock;
+
+// shared_lock(shared_lock&& u);
+
+#include <shared_mutex>
+#include <cassert>
+#include "nasty_containers.h"
+
+#include "test_macros.h"
+
+int main(int, char**)
+{
+    {
+    typedef std::shared_timed_mutex M;
+    M m;
+    std::shared_lock<M> lk0(m);
+    std::shared_lock<M> lk = std::move(lk0);
+    assert(lk.mutex() == std::addressof(m));
+    assert(lk.owns_lock() == true);
+    assert(lk0.mutex() == nullptr);
+    assert(lk0.owns_lock() == false);
+    }
+    {
+    typedef nasty_mutex M;
+    M m;
+    std::shared_lock<M> lk0(m);
+    std::shared_lock<M> lk = std::move(lk0);
+    assert(lk.mutex() == std::addressof(m));
+    assert(lk.owns_lock() == true);
+    assert(lk0.mutex() == nullptr);
+    assert(lk0.owns_lock() == false);
+    }
+
+  return 0;
+}

module/jni/libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex.pass.cpp

@@ -0,0 +1,107 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: c++03, c++11
+// ALLOW_RETRIES: 2
+
+// dylib support for shared_mutex was added in macosx10.12
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
+
+// <shared_mutex>
+
+// template <class Mutex> class shared_lock;
+
+// explicit shared_lock(mutex_type& m);
+
+// template<class _Mutex> shared_lock(shared_lock<_Mutex>)
+//     -> shared_lock<_Mutex>;  // C++17
+
+#include <shared_mutex>
+#include <thread>
+#include <vector>
+#include <cstdlib>
+#include <cassert>
+
+#include "make_test_thread.h"
+#include "test_macros.h"
+
+typedef std::chrono::system_clock Clock;
+typedef Clock::time_point time_point;
+typedef Clock::duration duration;
+typedef std::chrono::milliseconds ms;
+typedef std::chrono::nanoseconds ns;
+
+ms WaitTime = ms(250);
+
+// Thread sanitizer causes more overhead and will sometimes cause this test
+// to fail. To prevent this we give Thread sanitizer more time to complete the
+// test.
+#if !defined(TEST_HAS_SANITIZERS)
+ms Tolerance = ms(50);
+#else
+ms Tolerance = ms(50 * 5);
+#endif
+
+std::shared_timed_mutex m;
+
+void f()
+{
+    time_point t0 = Clock::now();
+    time_point t1;
+    {
+    std::shared_lock<std::shared_timed_mutex> ul(m);
+    t1 = Clock::now();
+    }
+    ns d = t1 - t0 - WaitTime;
+    assert(d < Tolerance);  // within tolerance
+}
+
+void g()
+{
+    time_point t0 = Clock::now();
+    time_point t1;
+    {
+    std::shared_lock<std::shared_timed_mutex> ul(m);
+    t1 = Clock::now();
+    }
+    ns d = t1 - t0;
+    assert(d < Tolerance);  // within tolerance
+}
+
+int main(int, char**)
+{
+    std::vector<std::thread> v;
+    {
+        m.lock();
+        for (int i = 0; i < 5; ++i)
+            v.push_back(support::make_test_thread(f));
+        std::this_thread::sleep_for(WaitTime);
+        m.unlock();
+        for (auto& t : v)
+            t.join();
+    }
+    {
+        m.lock_shared();
+        for (auto& t : v)
+            t = support::make_test_thread(g);
+        std::thread q = support::make_test_thread(f);
+        std::this_thread::sleep_for(WaitTime);
+        m.unlock_shared();
+        for (auto& t : v)
+            t.join();
+        q.join();
+    }
+
+#if TEST_STD_VER >= 17
+    std::shared_lock sl(m);
+    static_assert((std::is_same<decltype(sl), std::shared_lock<decltype(m)>>::value), "" );
+#endif
+
+  return 0;
+}

module/jni/libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_adopt_lock.pass.cpp

@@ -0,0 +1,48 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: c++03, c++11
+
+// dylib support for shared_mutex was added in macosx10.12
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
+
+// <shared_mutex>
+
+// template <class Mutex> class shared_lock;
+
+// shared_lock(mutex_type& m, adopt_lock_t);
+
+#include <shared_mutex>
+#include <cassert>
+#include <mutex>
+#include "nasty_containers.h"
+
+#include "test_macros.h"
+
+int main(int, char**)
+{
+    {
+    typedef std::shared_timed_mutex M;
+    M m;
+    m.lock();
+    std::unique_lock<M> lk(m, std::adopt_lock);
+    assert(lk.mutex() == std::addressof(m));
+    assert(lk.owns_lock() == true);
+    }
+    {
+    typedef nasty_mutex M;
+    M m;
+    m.lock();
+    std::unique_lock<M> lk(m, std::adopt_lock);
+    assert(lk.mutex() == std::addressof(m));
+    assert(lk.owns_lock() == true);
+    }
+
+  return 0;
+}

module/jni/libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_defer_lock.pass.cpp

@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: c++03, c++11
+
+// dylib support for shared_mutex was added in macosx10.12
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
+
+// <shared_mutex>
+
+// template <class Mutex> class shared_lock;
+
+// shared_lock(mutex_type& m, defer_lock_t);
+
+#include <shared_mutex>
+#include <cassert>
+#include <mutex>
+#include "nasty_containers.h"
+
+#include "test_macros.h"
+
+int main(int, char**)
+{
+    {
+    typedef std::shared_timed_mutex M;
+    M m;
+    std::unique_lock<M> lk(m, std::defer_lock);
+    assert(lk.mutex() == std::addressof(m));
+    assert(lk.owns_lock() == false);
+    }
+    {
+    typedef nasty_mutex M;
+    M m;
+    std::unique_lock<M> lk(m, std::defer_lock);
+    assert(lk.mutex() == std::addressof(m));
+    assert(lk.owns_lock() == false);
+    }
+
+  return 0;
+}

module/jni/libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_duration.pass.cpp

@@ -0,0 +1,100 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: c++03, c++11
+
+// dylib support for shared_mutex was added in macosx10.12
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
+
+// <shared_mutex>
+
+// class timed_mutex;
+
+// template <class Rep, class Period>
+//   shared_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
+
+#include <thread>
+
+#include <atomic>
+#include <cassert>
+#include <cstdlib>
+#include <shared_mutex>
+#include <vector>
+
+#include "make_test_thread.h"
+#include "test_macros.h"
+
+std::shared_timed_mutex m;
+
+typedef std::chrono::steady_clock Clock;
+typedef Clock::time_point time_point;
+typedef Clock::duration duration;
+typedef std::chrono::milliseconds ms;
+typedef std::chrono::nanoseconds ns;
+
+ms LongTime = ms(5000);
+ms ShortTime = ms(50);
+
+static const unsigned Threads = 5;
+
+std::atomic<unsigned> CountDown(Threads);
+
+void f1()
+{
+  // Preemptive scheduling means that one cannot make assumptions about when
+  // code executes and therefore we cannot assume anthing about when the mutex
+  // starts waiting relative to code in the main thread. We can however prove
+  // that a timeout occured and that implies that this code is waiting.
+  // See f2() below.
+  //
+  // Nevertheless, we should at least try to ensure that the mutex waits and
+  // therefore we use an atomic variable to signal to the main thread that this
+  // code is just a few instructions away from waiting.
+  --CountDown;
+  std::shared_lock<std::shared_timed_mutex> lk(m, LongTime);
+  assert(lk.owns_lock() == true);
+}
+
+void f2()
+{
+  time_point t0 = Clock::now();
+  std::shared_lock<std::shared_timed_mutex> lk(m, ShortTime);
+  time_point t1 = Clock::now();
+  assert(lk.owns_lock() == false);
+  assert(t1 - t0 >= ShortTime);
+}
+
+int main(int, char**)
+{
+  {
+    m.lock();
+    std::vector<std::thread> v;
+    for (unsigned i = 0; i < Threads; ++i)
+      v.push_back(support::make_test_thread(f1));
+    while (CountDown > 0)
+      std::this_thread::yield();
+    // Give one more chance for threads to block and wait for the mutex.
+    std::this_thread::yield();
+    std::this_thread::sleep_for(ShortTime);
+    m.unlock();
+    for (auto& t : v)
+      t.join();
+  }
+  {
+    m.lock();
+    std::vector<std::thread> v;
+    for (unsigned i = 0; i < Threads; ++i)
+      v.push_back(support::make_test_thread(f2));
+    for (auto& t : v)
+      t.join();
+    m.unlock();
+  }
+
+  return 0;
+}

module/jni/libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_time_point.pass.cpp

@@ -0,0 +1,92 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: c++03, c++11
+
+// dylib support for shared_mutex was added in macosx10.12
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
+
+// <shared_mutex>
+
+// class shared_timed_mutex;
+
+// template <class Clock, class Duration>
+//   shared_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
+
+#include <thread>
+
+#include <atomic>
+#include <cassert>
+#include <cstdlib>
+#include <shared_mutex>
+#include <vector>
+
+#include "make_test_thread.h"
+#include "test_macros.h"
+
+std::shared_timed_mutex m;
+
+typedef std::chrono::steady_clock Clock;
+typedef Clock::time_point time_point;
+typedef Clock::duration duration;
+typedef std::chrono::milliseconds ms;
+typedef std::chrono::nanoseconds ns;
+
+ms LongTime = ms(5000);
+ms ShortTime = ms(50);
+
+static constexpr unsigned Threads = 5;
+
+std::atomic<unsigned> CountDown(Threads);
+
+void f1()
+{
+  --CountDown;
+  time_point t0 = Clock::now();
+  std::shared_lock<std::shared_timed_mutex> lk(m, t0 + LongTime);
+  time_point t1 = Clock::now();
+  assert(lk.owns_lock() == true);
+  assert(t1 - t0 <= LongTime);
+}
+
+void f2()
+{
+  time_point t0 = Clock::now();
+  std::shared_lock<std::shared_timed_mutex> lk(m, t0 + ShortTime);
+  time_point t1 = Clock::now();
+  assert(lk.owns_lock() == false);
+  assert(t1 - t0 >= ShortTime);
+}
+
+int main(int, char**)
+{
+  {
+    m.lock();
+    std::vector<std::thread> v;
+    for (unsigned i = 0; i < Threads; ++i)
+      v.push_back(support::make_test_thread(f1));
+    while (CountDown > 0)
+      std::this_thread::yield();
+    std::this_thread::sleep_for(ShortTime);
+    m.unlock();
+    for (auto& t : v)
+      t.join();
+  }
+  {
+    m.lock();
+    std::vector<std::thread> v;
+    for (unsigned i = 0; i < Threads; ++i)
+      v.push_back(support::make_test_thread(f2));
+    for (auto& t : v)
+      t.join();
+    m.unlock();
+  }
+
+  return 0;
+}

module/jni/libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_try_to_lock.pass.cpp

@@ -0,0 +1,77 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: c++03, c++11
+// ALLOW_RETRIES: 2
+
+// dylib support for shared_mutex was added in macosx10.12
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
+
+// <shared_mutex>
+
+// template <class Mutex> class shared_lock;
+
+// shared_lock(mutex_type& m, try_to_lock_t);
+
+#include <shared_mutex>
+#include <thread>
+#include <vector>
+#include <cstdlib>
+#include <cassert>
+
+#include "make_test_thread.h"
+#include "test_macros.h"
+
+std::shared_timed_mutex m;
+
+typedef std::chrono::system_clock Clock;
+typedef Clock::time_point time_point;
+typedef Clock::duration duration;
+typedef std::chrono::milliseconds ms;
+typedef std::chrono::nanoseconds ns;
+
+void f()
+{
+    time_point t0 = Clock::now();
+    {
+        std::shared_lock<std::shared_timed_mutex> lk(m, std::try_to_lock);
+        assert(lk.owns_lock() == false);
+    }
+    {
+        std::shared_lock<std::shared_timed_mutex> lk(m, std::try_to_lock);
+        assert(lk.owns_lock() == false);
+    }
+    {
+        std::shared_lock<std::shared_timed_mutex> lk(m, std::try_to_lock);
+        assert(lk.owns_lock() == false);
+    }
+    while (true)
+    {
+        std::shared_lock<std::shared_timed_mutex> lk(m, std::try_to_lock);
+        if (lk.owns_lock())
+            break;
+    }
+    time_point t1 = Clock::now();
+    ns d = t1 - t0 - ms(250);
+    assert(d < ms(200));  // within 200ms
+}
+
+int main(int, char**)
+{
+    m.lock();
+    std::vector<std::thread> v;
+    for (int i = 0; i < 5; ++i)
+        v.push_back(support::make_test_thread(f));
+    std::this_thread::sleep_for(ms(250));
+    m.unlock();
+    for (auto& t : v)
+        t.join();
+
+  return 0;
+}

module/jni/libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/lock.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
+// UNSUPPORTED: c++03, c++11
+// ALLOW_RETRIES: 2
+
+// dylib support for shared_mutex was added in macosx10.12
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
+
+// <shared_mutex>
+
+// template <class Mutex> class shared_lock;
+
+// void lock();
+
+#include <shared_mutex>
+#include <thread>
+#include <vector>
+#include <cstdlib>
+#include <cassert>
+
+#include "make_test_thread.h"
+#include "test_macros.h"
+
+std::shared_timed_mutex m;
+
+typedef std::chrono::system_clock Clock;
+typedef Clock::time_point time_point;
+typedef Clock::duration duration;
+typedef std::chrono::milliseconds ms;
+typedef std::chrono::nanoseconds ns;
+
+ms WaitTime = ms(250);
+
+// Thread sanitizer causes more overhead and will sometimes cause this test
+// to fail. To prevent this we give Thread sanitizer more time to complete the
+// test.
+#if !defined(TEST_HAS_SANITIZERS)
+ms Tolerance = ms(25);
+#else
+ms Tolerance = ms(25 * 5);
+#endif
+
+
+void f()
+{
+    std::shared_lock<std::shared_timed_mutex> lk(m, std::defer_lock);
+    time_point t0 = Clock::now();
+    lk.lock();
+    time_point t1 = Clock::now();
+    assert(lk.owns_lock() == true);
+    ns d = t1 - t0 - WaitTime;
+    assert(d < Tolerance);  // within tolerance
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    try
+    {
+        lk.lock();
+        assert(false);
+    }
+    catch (std::system_error& e)
+    {
+        assert(e.code().value() == EDEADLK);
+    }
+#endif
+    lk.unlock();
+    lk.release();
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    try
+    {
+        lk.lock();
+        assert(false);
+    }
+    catch (std::system_error& e)
+    {
+        assert(e.code().value() == EPERM);
+    }
+#endif
+}
+
+int main(int, char**)
+{
+    m.lock();
+    std::vector<std::thread> v;
+    for (int i = 0; i < 5; ++i)
+        v.push_back(support::make_test_thread(f));
+    std::this_thread::sleep_for(WaitTime);
+    m.unlock();
+    for (auto& t : v)
+        t.join();
+
+  return 0;
+}

module/jni/libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock.pass.cpp

@@ -0,0 +1,75 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: c++03, c++11
+//
+// ALLOW_RETRIES: 2
+
+// <shared_mutex>
+
+// template <class Mutex> class shared_lock;
+
+// bool try_lock();
+
+#include <shared_mutex>
+#include <cassert>
+#include <mutex>
+
+#include "test_macros.h"
+
+bool try_lock_called = false;
+
+struct mutex
+{
+    bool try_lock_shared()
+    {
+        try_lock_called = !try_lock_called;
+        return try_lock_called;
+    }
+    void unlock_shared() {}
+};
+
+mutex m;
+
+int main(int, char**)
+{
+    std::shared_lock<mutex> lk(m, std::defer_lock);
+    assert(lk.try_lock() == true);
+    assert(try_lock_called == true);
+    assert(lk.owns_lock() == true);
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    try
+    {
+        TEST_IGNORE_NODISCARD lk.try_lock();
+        assert(false);
+    }
+    catch (std::system_error& e)
+    {
+        assert(e.code().value() == EDEADLK);
+    }
+#endif
+    lk.unlock();
+    assert(lk.try_lock() == false);
+    assert(try_lock_called == false);
+    assert(lk.owns_lock() == false);
+    lk.release();
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    try
+    {
+        TEST_IGNORE_NODISCARD lk.try_lock();
+        assert(false);
+    }
+    catch (std::system_error& e)
+    {
+        assert(e.code().value() == EPERM);
+    }
+#endif
+
+  return 0;
+}

module/jni/libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_for.pass.cpp

@@ -0,0 +1,79 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: c++03, c++11
+
+// <shared_mutex>
+
+// template <class Mutex> class shared_lock;
+
+// template <class Rep, class Period>
+//   bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
+
+#include <shared_mutex>
+#include <cassert>
+#include <chrono>
+#include <mutex>
+
+#include "test_macros.h"
+
+bool try_lock_for_called = false;
+
+typedef std::chrono::milliseconds ms;
+
+struct mutex
+{
+    template <class Rep, class Period>
+        bool try_lock_shared_for(const std::chrono::duration<Rep, Period>& rel_time)
+    {
+        assert(rel_time == ms(5));
+        try_lock_for_called = !try_lock_for_called;
+        return try_lock_for_called;
+    }
+    void unlock_shared() {}
+};
+
+mutex m;
+
+int main(int, char**)
+{
+    std::shared_lock<mutex> lk(m, std::defer_lock);
+    assert(lk.try_lock_for(ms(5)) == true);
+    assert(try_lock_for_called == true);
+    assert(lk.owns_lock() == true);
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    try
+    {
+        TEST_IGNORE_NODISCARD lk.try_lock_for(ms(5));
+        assert(false);
+    }
+    catch (std::system_error& e)
+    {
+        assert(e.code().value() == EDEADLK);
+    }
+#endif
+    lk.unlock();
+    assert(lk.try_lock_for(ms(5)) == false);
+    assert(try_lock_for_called == false);
+    assert(lk.owns_lock() == false);
+    lk.release();
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    try
+    {
+        TEST_IGNORE_NODISCARD lk.try_lock_for(ms(5));
+        assert(false);
+    }
+    catch (std::system_error& e)
+    {
+        assert(e.code().value() == EPERM);
+    }
+#endif
+
+  return 0;
+}

module/jni/libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_until.pass.cpp

@@ -0,0 +1,79 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: c++03, c++11
+
+// <shared_mutex>
+
+// template <class Mutex> class shared_lock;
+
+// template <class Clock, class Duration>
+//   bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
+
+#include <shared_mutex>
+#include <cassert>
+#include <chrono>
+#include <mutex>
+
+#include "test_macros.h"
+
+bool try_lock_until_called = false;
+
+struct mutex
+{
+    template <class Clock, class Duration>
+        bool try_lock_shared_until(const std::chrono::time_point<Clock, Duration>& abs_time)
+    {
+        typedef std::chrono::milliseconds ms;
+        assert(Clock::now() - abs_time < ms(5));
+        try_lock_until_called = !try_lock_until_called;
+        return try_lock_until_called;
+    }
+    void unlock_shared() {}
+};
+
+mutex m;
+
+int main(int, char**)
+{
+    typedef std::chrono::steady_clock Clock;
+    std::shared_lock<mutex> lk(m, std::defer_lock);
+    assert(lk.try_lock_until(Clock::now()) == true);
+    assert(try_lock_until_called == true);
+    assert(lk.owns_lock() == true);
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    try
+    {
+        TEST_IGNORE_NODISCARD lk.try_lock_until(Clock::now());
+        assert(false);
+    }
+    catch (std::system_error& e)
+    {
+        assert(e.code().value() == EDEADLK);
+    }
+#endif
+    lk.unlock();
+    assert(lk.try_lock_until(Clock::now()) == false);
+    assert(try_lock_until_called == false);
+    assert(lk.owns_lock() == false);
+    lk.release();
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    try
+    {
+        TEST_IGNORE_NODISCARD lk.try_lock_until(Clock::now());
+        assert(false);
+    }
+    catch (std::system_error& e)
+    {
+        assert(e.code().value() == EPERM);
+    }
+#endif
+
+  return 0;
+}

module/jni/libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/unlock.pass.cpp

@@ -0,0 +1,65 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: c++03, c++11
+
+// <shared_mutex>
+
+// template <class Mutex> class shared_lock;
+
+// void unlock();
+
+#include <shared_mutex>
+#include <cassert>
+#include <system_error>
+
+#include "test_macros.h"
+
+bool unlock_called = false;
+
+struct mutex
+{
+    void lock_shared() {}
+    void unlock_shared() {unlock_called = true;}
+};
+
+mutex m;
+
+int main(int, char**)
+{
+    std::shared_lock<mutex> lk(m);
+    lk.unlock();
+    assert(unlock_called == true);
+    assert(lk.owns_lock() == false);
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    try
+    {
+        lk.unlock();
+        assert(false);
+    }
+    catch (std::system_error& e)
+    {
+        assert(e.code().value() == EPERM);
+    }
+#endif
+    lk.release();
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    try
+    {
+        lk.unlock();
+        assert(false);
+    }
+    catch (std::system_error& e)
+    {
+        assert(e.code().value() == EPERM);
+    }
+#endif
+
+  return 0;
+}

module/jni/libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/member_swap.pass.cpp

@@ -0,0 +1,43 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: c++03, c++11
+
+// <shared_mutex>
+
+// template <class Mutex> class shared_lock;
+
+// void swap(shared_lock& u) noexcept;
+
+#include <shared_mutex>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct mutex
+{
+    void lock_shared() {}
+    void unlock_shared() {}
+};
+
+mutex m;
+
+int main(int, char**)
+{
+    std::shared_lock<mutex> lk1(m);
+    std::shared_lock<mutex> lk2;
+    lk1.swap(lk2);
+    assert(lk1.mutex() == nullptr);
+    assert(lk1.owns_lock() == false);
+    assert(lk2.mutex() == &m);
+    assert(lk2.owns_lock() == true);
+    static_assert(noexcept(lk1.swap(lk2)), "member swap must be noexcept");
+
+  return 0;
+}

module/jni/libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/nonmember_swap.pass.cpp

@@ -0,0 +1,44 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: c++03, c++11
+
+// <shared_mutex>
+
+// template <class Mutex> class shared_lock;
+
+// template <class Mutex>
+//   void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
+
+#include <shared_mutex>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct mutex
+{
+    void lock_shared() {}
+    void unlock_shared() {}
+};
+
+mutex m;
+
+int main(int, char**)
+{
+    std::shared_lock<mutex> lk1(m);
+    std::shared_lock<mutex> lk2;
+    swap(lk1, lk2);
+    assert(lk1.mutex() == nullptr);
+    assert(lk1.owns_lock() == false);
+    assert(lk2.mutex() == &m);
+    assert(lk2.owns_lock() == true);
+    static_assert(noexcept(swap(lk1, lk2)), "non-member swap must be noexcept");
+
+  return 0;
+}

module/jni/libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/release.pass.cpp

@@ -0,0 +1,51 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: c++03, c++11
+
+// <shared_mutex>
+
+// template <class Mutex> class shared_lock;
+
+// mutex_type* release() noexcept;
+
+#include <shared_mutex>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct mutex
+{
+    static int lock_count;
+    static int unlock_count;
+    void lock_shared() {++lock_count;}
+    void unlock_shared() {++unlock_count;}
+};
+
+int mutex::lock_count = 0;
+int mutex::unlock_count = 0;
+
+mutex m;
+
+int main(int, char**)
+{
+    std::shared_lock<mutex> lk(m);
+    assert(lk.mutex() == &m);
+    assert(lk.owns_lock() == true);
+    assert(mutex::lock_count == 1);
+    assert(mutex::unlock_count == 0);
+    assert(lk.release() == &m);
+    assert(lk.mutex() == nullptr);
+    assert(lk.owns_lock() == false);
+    assert(mutex::lock_count == 1);
+    assert(mutex::unlock_count == 0);
+    static_assert(noexcept(lk.release()), "release must be noexcept");
+
+  return 0;
+}

module/jni/libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/mutex.pass.cpp

@@ -0,0 +1,39 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: c++03, c++11
+
+// dylib support for shared_mutex was added in macosx10.12
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
+
+// <shared_mutex>
+
+// template <class Mutex> class shared_lock;
+
+// mutex_type *mutex() const noexcept;
+
+#include <shared_mutex>
+#include <cassert>
+
+#include "test_macros.h"
+
+std::shared_timed_mutex m;
+
+int main(int, char**)
+{
+    std::shared_lock<std::shared_timed_mutex> lk0;
+    assert(lk0.mutex() == nullptr);
+    std::shared_lock<std::shared_timed_mutex> lk1(m);
+    assert(lk1.mutex() == &m);
+    lk1.unlock();
+    assert(lk1.mutex() == &m);
+    static_assert(noexcept(lk0.mutex()), "mutex() must be noexcept");
+
+  return 0;
+}

module/jni/libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/op_bool.pass.cpp

@@ -0,0 +1,44 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: c++03, c++11
+
+// <shared_mutex>
+
+// template <class Mutex> class shared_lock;
+
+// explicit operator bool() const noexcept;
+
+#include <shared_mutex>
+#include <cassert>
+#include <type_traits>
+
+#include "test_macros.h"
+
+struct M {
+    void lock_shared() {}
+    void unlock_shared() {}
+};
+
+int main(int, char**)
+{
+    static_assert(std::is_constructible<bool, std::shared_lock<M>>::value, "");
+    static_assert(!std::is_convertible<std::shared_lock<M>, bool>::value, "");
+
+    M m;
+    std::shared_lock<M> lk0;
+    assert(static_cast<bool>(lk0) == false);
+    std::shared_lock<M> lk1(m);
+    assert(static_cast<bool>(lk1) == true);
+    lk1.unlock();
+    assert(static_cast<bool>(lk1) == false);
+    ASSERT_NOEXCEPT(static_cast<bool>(lk0));
+
+    return 0;
+}

module/jni/libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/owns_lock.pass.cpp

@@ -0,0 +1,39 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: c++03, c++11
+
+// dylib support for shared_mutex was added in macosx10.12
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
+
+// <shared_mutex>
+
+// template <class Mutex> class shared_lock;
+
+// bool owns_lock() const noexcept;
+
+#include <shared_mutex>
+#include <cassert>
+
+#include "test_macros.h"
+
+std::shared_timed_mutex m;
+
+int main(int, char**)
+{
+    std::shared_lock<std::shared_timed_mutex> lk0;
+    assert(lk0.owns_lock() == false);
+    std::shared_lock<std::shared_timed_mutex> lk1(m);
+    assert(lk1.owns_lock() == true);
+    lk1.unlock();
+    assert(lk1.owns_lock() == false);
+    static_assert(noexcept(lk0.owns_lock()), "owns_lock must be noexcept");
+
+  return 0;
+}

module/jni/libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/types.pass.cpp

@@ -0,0 +1,35 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: c++03, c++11
+
+
+// <shared_mutex>
+
+// template <class Mutex>
+// class shared_lock
+// {
+// public:
+//     typedef Mutex mutex_type;
+//     ...
+// };
+
+#include <shared_mutex>
+#include <mutex>
+#include <type_traits>
+
+#include "test_macros.h"
+
+int main(int, char**)
+{
+    static_assert((std::is_same<std::shared_lock<std::mutex>::mutex_type,
+                   std::mutex>::value), "");
+
+  return 0;
+}