Add tests to show that std::recursive_timed_mutex::try_lock_until and
std::recursive_timed_mutex::try_lock_for don't suffer from
libstdc++/PR116586.
libstdc++-v3/ChangeLog:
* testsuite/30_threads/recursive_timed_mutex/try_lock_until/116586.cc:
New test.
Signed-off-by: Mike Crowe <m...@mcrowe.com>
---
.../try_lock_until/116586.cc | 70 +++++++++++++++++++
1 file changed, 70 insertions(+)
create mode 100644
libstdc++-v3/testsuite/30_threads/recursive_timed_mutex/try_lock_until/116586.cc
diff --git
a/libstdc++-v3/testsuite/30_threads/recursive_timed_mutex/try_lock_until/116586.cc
b/libstdc++-v3/testsuite/30_threads/recursive_timed_mutex/try_lock_until/116586.cc
new file mode 100644
index 00000000000..af7a4bef5f6
--- /dev/null
+++
b/libstdc++-v3/testsuite/30_threads/recursive_timed_mutex/try_lock_until/116586.cc
@@ -0,0 +1,70 @@
+// { dg-do run { target c++11 } }
+
+#include <chrono>
+#include <mutex>
+#include <testsuite_hooks.h>
+
+namespace chrono = std::chrono;
+
+// thread.timedmutex.requirements.general:
+// If abs_time has already passed, the function attempts to obtain
+// ownership without blocking (as if by calling try_lock()).
+
+template <typename Clock>
+void
+test_absolute(chrono::nanoseconds offset)
+{
+ std::recursive_timed_mutex mtx;
+ chrono::time_point<Clock> tp(offset);
+ VERIFY(mtx.try_lock_until(tp));
+
+ {
+ // To test failing to lock a recursive mutex we need to try to lock on a
+ // different thread.
+ auto t = std::async(std::launch::async, [&mtx, tp]() {
+ VERIFY(!mtx.try_lock_until(tp));
+ });
+ }
+}
+
+// The type of clock used for the actual wait depends on whether
+// _GLIBCXX_USE_PTHREAD_MUTEX_CLOCKLOCK is defined. We might as well just test
+// both steady_clock and system_clock.
+template <typename Clock>
+void
+test_relative(chrono::nanoseconds offset)
+{
+ std::recursive_timed_mutex mtx;
+ const auto d = -Clock::now().time_since_epoch() + offset;
+ VERIFY(mtx.try_lock_for(d));
+
+ {
+ // To test failing to lock a recursive mutex we need to try to lock on a
+ // different thread.
+ auto t = std::async(std::launch::async, [&mtx, d]() {
+ VERIFY(!mtx.try_lock_for(d));
+ });
+ }
+}
+
+int main()
+{
+ // Try once with an offset that ought to result in tv_sec == 0, tv_nsec < 0
+ // and one with an offset that ought to result in tv_sec < 0, tv_nsec == 0
+ // for the absolute calls at least. It's not really possible to arrange for
+ // the relative calls to have tv_nsec == 0 due to time advancing.
+ for (const chrono::nanoseconds offset : {
+ // tv_sec == 0, tv_nsec == 0
+ chrono::nanoseconds{0},
+ // tv_sec == 0, tv_nsec < 0
+ chrono::duration_cast<chrono::nanoseconds>(chrono::milliseconds{-10}),
+ // tv_sec < 0
+ chrono::duration_cast<chrono::nanoseconds>(chrono::seconds{-10})
+ }) {
+ test_absolute<chrono::system_clock>(offset);
+ test_relative<chrono::system_clock>(offset);
+
+ test_absolute<chrono::steady_clock>(offset);
+ test_relative<chrono::steady_clock>(offset);
+ }
+}
--
2.39.5
