folly/test/SynchronizedTest.cpp

   1 /*
   2  * Copyright 2012 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   testBasic<std::timed_mutex>();
  31   testBasic<std::recursive_timed_mutex>();
  32
  33   testBasic<folly::RWTicketSpinLock32>();
  34
  35   testBasic<boost::mutex>();
  36   testBasic<boost::recursive_mutex>();
  37   testBasic<boost::shared_mutex>();
  38   testBasic<boost::timed_mutex>();
  39   testBasic<boost::recursive_timed_mutex>();
  40 }
  41
  42 TEST(Synchronized, Concurrency) {
  43   testConcurrency<std::mutex>();
  44   testConcurrency<std::recursive_mutex>();
  45   testConcurrency<std::timed_mutex>();
  46   testConcurrency<std::recursive_timed_mutex>();
  47
  48   testConcurrency<folly::RWTicketSpinLock32>();
  49
  50   testConcurrency<boost::mutex>();
  51   testConcurrency<boost::recursive_mutex>();
  52   testConcurrency<boost::shared_mutex>();
  53   testConcurrency<boost::timed_mutex>();
  54   testConcurrency<boost::recursive_timed_mutex>();
  55 }
  56
  57
  58 TEST(Synchronized, DualLocking) {
  59   testDualLocking<std::mutex>();
  60   testDualLocking<std::recursive_mutex>();
  61   testDualLocking<std::timed_mutex>();
  62   testDualLocking<std::recursive_timed_mutex>();
  63
  64   testDualLocking<folly::RWTicketSpinLock32>();
  65
  66   testDualLocking<boost::mutex>();
  67   testDualLocking<boost::recursive_mutex>();
  68   testDualLocking<boost::shared_mutex>();
  69   testDualLocking<boost::timed_mutex>();
  70   testDualLocking<boost::recursive_timed_mutex>();
  71 }
  72
  73
  74 TEST(Synchronized, DualLockingWithConst) {
  75   testDualLockingWithConst<std::mutex>();
  76   testDualLockingWithConst<std::recursive_mutex>();
  77   testDualLockingWithConst<std::timed_mutex>();
  78   testDualLockingWithConst<std::recursive_timed_mutex>();
  79
  80   testDualLockingWithConst<folly::RWTicketSpinLock32>();
  81
  82   testDualLockingWithConst<boost::mutex>();
  83   testDualLockingWithConst<boost::recursive_mutex>();
  84   testDualLockingWithConst<boost::shared_mutex>();
  85   testDualLockingWithConst<boost::timed_mutex>();
  86   testDualLockingWithConst<boost::recursive_timed_mutex>();
  87 }
  88
  89
  90 TEST(Synchronized, TimedSynchronized) {
  91   testTimedSynchronized<std::timed_mutex>();
  92   testTimedSynchronized<std::recursive_timed_mutex>();
  93
  94   testTimedSynchronized<boost::timed_mutex>();
  95   testTimedSynchronized<boost::recursive_timed_mutex>();
  96   testTimedSynchronized<boost::shared_mutex>();
  97 }
  98
  99 TEST(Synchronized, ConstCopy) {
 100   testConstCopy<std::timed_mutex>();
 101   testConstCopy<std::recursive_timed_mutex>();
 102
 103   testConstCopy<boost::timed_mutex>();
 104   testConstCopy<boost::recursive_timed_mutex>();
 105   testConstCopy<boost::shared_mutex>();
 106 }