folly/test/SynchronizedTest.cpp

   1 /*
   2  * Copyright 2014 Facebook, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 // @author: Andrei Alexandrescu (aalexandre)
  18
  19 // Test bed for folly/Synchronized.h
  20
  21 #include "folly/Synchronized.h"
  22 #include "folly/RWSpinLock.h"
  23 #include "folly/test/SynchronizedTestLib.h"
  24 #include <gtest/gtest.h>
  25
  26
  27 TEST(Synchronized, Basic) {
  28   testBasic<std::mutex>();
  29   testBasic<std::recursive_mutex>();
  30 #ifndef __APPLE__
  31   testBasic<std::timed_mutex>();
  32   testBasic<std::recursive_timed_mutex>();
  33 #endif
  34
  35 #ifdef RW_SPINLOCK_USE_X86_INTRINSIC_
  36   testBasic<folly::RWTicketSpinLock32>();
  37 #endif
  38
  39   testBasic<boost::mutex>();
  40   testBasic<boost::recursive_mutex>();
  41   testBasic<boost::shared_mutex>();
  42 #ifndef __APPLE__
  43   testBasic<boost::timed_mutex>();
  44   testBasic<boost::recursive_timed_mutex>();
  45 #endif
  46 }
  47
  48 TEST(Synchronized, Concurrency) {
  49   testConcurrency<std::mutex>();
  50   testConcurrency<std::recursive_mutex>();
  51 #ifndef __APPLE__
  52   testConcurrency<std::timed_mutex>();
  53   testConcurrency<std::recursive_timed_mutex>();
  54 #endif
  55
  56 #ifdef RW_SPINLOCK_USE_X86_INTRINSIC_
  57   testConcurrency<folly::RWTicketSpinLock32>();
  58 #endif
  59
  60   testConcurrency<boost::mutex>();
  61   testConcurrency<boost::recursive_mutex>();
  62   testConcurrency<boost::shared_mutex>();
  63 #ifndef __APPLE__
  64   testConcurrency<boost::timed_mutex>();
  65   testConcurrency<boost::recursive_timed_mutex>();
  66 #endif
  67 }
  68
  69
  70 TEST(Synchronized, DualLocking) {
  71   testDualLocking<std::mutex>();
  72   testDualLocking<std::recursive_mutex>();
  73 #ifndef __APPLE__
  74   testDualLocking<std::timed_mutex>();
  75   testDualLocking<std::recursive_timed_mutex>();
  76 #endif
  77
  78 #ifdef RW_SPINLOCK_USE_X86_INTRINSIC_
  79   testDualLocking<folly::RWTicketSpinLock32>();
  80 #endif
  81
  82   testDualLocking<boost::mutex>();
  83   testDualLocking<boost::recursive_mutex>();
  84   testDualLocking<boost::shared_mutex>();
  85 #ifndef __APPLE__
  86   testDualLocking<boost::timed_mutex>();
  87   testDualLocking<boost::recursive_timed_mutex>();
  88 #endif
  89 }
  90
  91
  92 TEST(Synchronized, DualLockingWithConst) {
  93   testDualLockingWithConst<std::mutex>();
  94   testDualLockingWithConst<std::recursive_mutex>();
  95 #ifndef __APPLE__
  96   testDualLockingWithConst<std::timed_mutex>();
  97   testDualLockingWithConst<std::recursive_timed_mutex>();
  98 #endif
  99
 100 #ifdef RW_SPINLOCK_USE_X86_INTRINSIC_
 101   testDualLockingWithConst<folly::RWTicketSpinLock32>();
 102 #endif
 103
 104   testDualLockingWithConst<boost::mutex>();
 105   testDualLockingWithConst<boost::recursive_mutex>();
 106   testDualLockingWithConst<boost::shared_mutex>();
 107 #ifndef __APPLE__
 108   testDualLockingWithConst<boost::timed_mutex>();
 109   testDualLockingWithConst<boost::recursive_timed_mutex>();
 110 #endif
 111 }
 112
 113
 114 #ifndef __APPLE__
 115 TEST(Synchronized, TimedSynchronized) {
 116   testTimedSynchronized<std::timed_mutex>();
 117   testTimedSynchronized<std::recursive_timed_mutex>();
 118
 119   testTimedSynchronized<boost::timed_mutex>();
 120   testTimedSynchronized<boost::recursive_timed_mutex>();
 121   testTimedSynchronized<boost::shared_mutex>();
 122
 123   testTimedSynchronizedWithConst<boost::shared_mutex>();
 124 }
 125 #endif
 126
 127 TEST(Synchronized, ConstCopy) {
 128 #ifndef __APPLE__
 129   testConstCopy<std::timed_mutex>();
 130   testConstCopy<std::recursive_timed_mutex>();
 131
 132   testConstCopy<boost::timed_mutex>();
 133   testConstCopy<boost::recursive_timed_mutex>();
 134 #endif
 135   testConstCopy<boost::shared_mutex>();
 136 }