[gcc/devel/ranger] libstdc++ Add missing tests for std::shared_timed_mutex

[Aldy Hernandez <aldyh@gcc.gnu.org>]

https://gcc.gnu.org/g:e3ef371982a1a5deac31adbe0eb305d3ee70e094

commit e3ef371982a1a5deac31adbe0eb305d3ee70e094
Author: Jonathan Wakely <jwakely@redhat.com>
Date:   Wed Mar 25 22:16:22 2020 +0000

    libstdc++ Add missing tests for std::shared_timed_mutex
    
    These tests were supposed to be committed as part of r278904 (aka
    b789efeae8c0620b83f25e4a0757c4871e02ab5f) but I didn't 'git add' them.
    
            * testsuite/30_threads/shared_timed_mutex/try_lock_until/1.cc: New
            test.
            * testsuite/30_threads/shared_timed_mutex/try_lock_until/2.cc: New
            test.

Diff:
---
 libstdc++-v3/ChangeLog                             |  5 ++
 .../shared_timed_mutex/try_lock_until/1.cc         | 87 ++++++++++++++++++++++
 .../shared_timed_mutex/try_lock_until/2.cc         | 74 ++++++++++++++++++
 3 files changed, 166 insertions(+)

diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog
index 95ac7c935c4..11f7f02eb0b 100644
--- a/libstdc++-v3/ChangeLog
+++ b/libstdc++-v3/ChangeLog
@@ -1,5 +1,10 @@
 2020-03-25  Jonathan Wakely  <jwakely@redhat.com>
 
+	* testsuite/30_threads/shared_timed_mutex/try_lock_until/1.cc: New
+	test.
+	* testsuite/30_threads/shared_timed_mutex/try_lock_until/2.cc: New
+	test.
+
 	* include/bits/fs_fwd.h (filesystem::__file_clock): Move to ...
 	* include/std/chrono (filesystem::__file_clock): Here.
 	(filesystem::__file_clock::from_sys, filesystem::__file_clock::to_sys):
diff --git a/libstdc++-v3/testsuite/30_threads/shared_timed_mutex/try_lock_until/1.cc b/libstdc++-v3/testsuite/30_threads/shared_timed_mutex/try_lock_until/1.cc
new file mode 100644
index 00000000000..f0c98ed571f
--- /dev/null
+++ b/libstdc++-v3/testsuite/30_threads/shared_timed_mutex/try_lock_until/1.cc
@@ -0,0 +1,87 @@
+// { dg-do run }
+// { dg-options "-pthread"  }
+// { dg-require-effective-target c++14 }
+// { dg-require-effective-target pthread }
+// { dg-require-gthreads "" }
+
+// Copyright (C) 2019-2020 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+#include <shared_mutex>
+#include <thread>
+#include <system_error>
+#include <testsuite_hooks.h>
+#include <slow_clock.h>
+
+template <typename clock_type>
+void test()
+{
+  typedef std::shared_timed_mutex mutex_type;
+
+  try
+    {
+      mutex_type m;
+      m.lock();
+      bool b;
+
+      std::thread t([&] {
+	try
+	  {
+	    using namespace std::chrono;
+	    const auto timeout = 100ms;
+
+	    {
+	      const auto start = clock_type::now();
+	      const auto b = m.try_lock_until(start + timeout);
+	      const auto t = clock_type::now() - start;
+	      VERIFY( !b );
+	      VERIFY( t >= timeout );
+	    }
+
+	    {
+	      const auto start = clock_type::now();
+	      const auto b = m.try_lock_shared_until(start + timeout);
+	      const auto t = clock_type::now() - start;
+	      VERIFY( !b );
+	      VERIFY( t >= timeout );
+	    }
+	  }
+	catch (const std::system_error& e)
+	  {
+	    VERIFY( false );
+	  }
+	});
+      t.join();
+      m.unlock();
+    }
+  catch (const std::system_error& e)
+    {
+      VERIFY( false );
+    }
+  catch (...)
+    {
+      VERIFY( false );
+    }
+}
+
+int main()
+{
+  test<std::chrono::system_clock>();
+  test<std::chrono::steady_clock>();
+  test<__gnu_test::slow_clock>();
+}
diff --git a/libstdc++-v3/testsuite/30_threads/shared_timed_mutex/try_lock_until/2.cc b/libstdc++-v3/testsuite/30_threads/shared_timed_mutex/try_lock_until/2.cc
new file mode 100644
index 00000000000..d07e81a4d73
--- /dev/null
+++ b/libstdc++-v3/testsuite/30_threads/shared_timed_mutex/try_lock_until/2.cc
@@ -0,0 +1,74 @@
+// { dg-do run }
+// { dg-options "-pthread"  }
+// { dg-require-effective-target c++14 }
+// { dg-require-effective-target pthread }
+// { dg-require-gthreads "" }
+
+// Copyright (C) 2019-2020 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+#include <shared_mutex>
+#include <system_error>
+#include <testsuite_hooks.h>
+#include <slow_clock.h>
+
+template <typename clock_type>
+void test()
+{
+  typedef std::shared_timed_mutex mutex_type;
+
+  try
+    {
+      using namespace std::chrono;
+      mutex_type m;
+
+      // Confirm that try_lock_until acts like try_lock if the timeout has
+      // already passed.
+
+      // First test unique lock with a timeout that is definitely in the past.
+      VERIFY( m.try_lock_until( clock_type::now() - 1s ) );
+      m.unlock();
+
+      // Then attempt to test unique lock with a timeout that might exactly
+      // match the current time.
+      VERIFY( m.try_lock_until( clock_type::now() ) );
+      m.unlock();
+
+      // Now do the same but with the shared lock
+      VERIFY( m.try_lock_shared_until( clock_type::now() - 1s ) );
+      m.unlock();
+
+      VERIFY( m.try_lock_shared_until( clock_type::now() ) );
+      m.unlock();
+    }
+  catch (const std::system_error& e)
+    {
+      VERIFY( false );
+    }
+  catch (...)
+    {
+      VERIFY( false );
+    }
+}
+
+int main()
+{
+  test<std::chrono::system_clock>();
+  test<std::chrono::steady_clock>();
+  test<__gnu_test::slow_clock>();
+}