From b97d804d4b52130e5150e572bf9947402de3fee2 Mon Sep 17 00:00:00 2001
From: Peter Griess <pgriess@fb.com>
Date: Thu, 26 Sep 2013 09:53:39 -0500
Subject: [PATCH] Disable timed sychronization tests on Apple platforms.

Summary:
- Apple doesn't provide timed sychronization primitives. We already
handle this in Sychronization.h, but our unit tests were being run for
all platforms.

Test Plan:
- fbconfig -r folly && fbmake runtests
- ./configure && make check on Ubuntu/FC/Mac

Reviewed By: andrei.alexandrescu@fb.com

FB internal diff: D998581
---
 folly/test/SynchronizedTest.cpp | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/folly/test/SynchronizedTest.cpp b/folly/test/SynchronizedTest.cpp
index 197f8736..37296adb 100644
--- a/folly/test/SynchronizedTest.cpp
+++ b/folly/test/SynchronizedTest.cpp
@@ -27,66 +27,91 @@
 TEST(Synchronized, Basic) {
   testBasic<std::mutex>();
   testBasic<std::recursive_mutex>();
+#ifndef __APPLE__
   testBasic<std::timed_mutex>();
   testBasic<std::recursive_timed_mutex>();
+#endif
 
+#ifdef RW_SPINLOCK_USE_X86_INTRINSIC_
   testBasic<folly::RWTicketSpinLock32>();
+#endif
 
   testBasic<boost::mutex>();
   testBasic<boost::recursive_mutex>();
   testBasic<boost::shared_mutex>();
+#ifndef __APPLE__
   testBasic<boost::timed_mutex>();
   testBasic<boost::recursive_timed_mutex>();
+#endif
 }
 
 TEST(Synchronized, Concurrency) {
   testConcurrency<std::mutex>();
   testConcurrency<std::recursive_mutex>();
+#ifndef __APPLE__
   testConcurrency<std::timed_mutex>();
   testConcurrency<std::recursive_timed_mutex>();
+#endif
 
+#ifdef RW_SPINLOCK_USE_X86_INTRINSIC_
   testConcurrency<folly::RWTicketSpinLock32>();
+#endif
 
   testConcurrency<boost::mutex>();
   testConcurrency<boost::recursive_mutex>();
   testConcurrency<boost::shared_mutex>();
+#ifndef __APPLE__
   testConcurrency<boost::timed_mutex>();
   testConcurrency<boost::recursive_timed_mutex>();
+#endif
 }
 
 
 TEST(Synchronized, DualLocking) {
   testDualLocking<std::mutex>();
   testDualLocking<std::recursive_mutex>();
+#ifndef __APPLE__
   testDualLocking<std::timed_mutex>();
   testDualLocking<std::recursive_timed_mutex>();
+#endif
 
+#ifdef RW_SPINLOCK_USE_X86_INTRINSIC_
   testDualLocking<folly::RWTicketSpinLock32>();
+#endif
 
   testDualLocking<boost::mutex>();
   testDualLocking<boost::recursive_mutex>();
   testDualLocking<boost::shared_mutex>();
+#ifndef __APPLE__
   testDualLocking<boost::timed_mutex>();
   testDualLocking<boost::recursive_timed_mutex>();
+#endif
 }
 
 
 TEST(Synchronized, DualLockingWithConst) {
   testDualLockingWithConst<std::mutex>();
   testDualLockingWithConst<std::recursive_mutex>();
+#ifndef __APPLE__
   testDualLockingWithConst<std::timed_mutex>();
   testDualLockingWithConst<std::recursive_timed_mutex>();
+#endif
 
+#ifdef RW_SPINLOCK_USE_X86_INTRINSIC_
   testDualLockingWithConst<folly::RWTicketSpinLock32>();
+#endif
 
   testDualLockingWithConst<boost::mutex>();
   testDualLockingWithConst<boost::recursive_mutex>();
   testDualLockingWithConst<boost::shared_mutex>();
+#ifndef __APPLE__
   testDualLockingWithConst<boost::timed_mutex>();
   testDualLockingWithConst<boost::recursive_timed_mutex>();
+#endif
 }
 
 
+#ifndef __APPLE__
 TEST(Synchronized, TimedSynchronized) {
   testTimedSynchronized<std::timed_mutex>();
   testTimedSynchronized<std::recursive_timed_mutex>();
@@ -95,12 +120,15 @@ TEST(Synchronized, TimedSynchronized) {
   testTimedSynchronized<boost::recursive_timed_mutex>();
   testTimedSynchronized<boost::shared_mutex>();
 }
+#endif
 
 TEST(Synchronized, ConstCopy) {
+#ifndef __APPLE__
   testConstCopy<std::timed_mutex>();
   testConstCopy<std::recursive_timed_mutex>();
 
   testConstCopy<boost::timed_mutex>();
   testConstCopy<boost::recursive_timed_mutex>();
+#endif
   testConstCopy<boost::shared_mutex>();
 }
-- 
2.34.1