Enable a missing test in the CMake build

Summary: This also silences a few warnings in the stl vector tests.

Reviewed By: yfeldblum

Differential Revision: D5350383

fbshipit-source-id: 84df2a7dbfbb23ebb3f15a09f0cb58080b3e06d6

CMakeLists.txt

@@ -347,6 +347,7 @@ if (BUILD_TESTS)
 
     DIRECTORY futures/test/
       TEST barrier_test SOURCES BarrierTest.cpp
+      TEST callback_lifetime_test SOURCES CallbackLifetimeTest.cpp
       TEST collect_test SOURCES CollectTest.cpp
       TEST context_test SOURCES ContextTest.cpp
       TEST core_test SOURCES CoreTest.cpp

folly/test/stl_tests/StlVectorTest.cpp

@@ -185,10 +185,16 @@ THOUGHTS:
 #include <boost/preprocessor.hpp>
 
 #include <folly/Conv.h>
+#include <folly/Portability.h>
 #include <folly/ScopeGuard.h>
 #include <folly/portability/GFlags.h>
 #include <folly/portability/GTest.h>
 
+// We use some pre-processor magic to auto-generate setup and destruct code,
+// but it also means we have some parameters that may not be used.
+FOLLY_PUSH_WARNING
+FOLLY_GCC_DISABLE_WARNING("-Wunused-parameter")
+
 using namespace std;
 using namespace folly;
 
@@ -333,23 +339,23 @@ template <> struct D4<true> {
 };
 
 template <Flags f>
-struct Delete : D0<(f & DC_DELETE) != 0>
-              , D1<(f & CC_DELETE) != 0>
-              , D2<(f & MC_DELETE) != 0>
-              , D3<(f & CA_DELETE) != 0>
-              , D4<(f & MA_DELETE) != 0> {
+struct Delete : D0<(f & DC_DELETE) != 0>,
+              D1<(f & CC_DELETE) != 0>,
+              D2<(f & MC_DELETE) != 0>,
+              D3<(f & CA_DELETE) != 0>,
+              D4<(f & MA_DELETE) != 0> {
   Delete() = default;
   Delete(const Delete&) = default;
   Delete(Delete&&) = default;
   Delete& operator=(const Delete&) = default;
   Delete& operator=(Delete&&) = default;
 
-  explicit Delete(std::nullptr_t)
-      : D0<(f & DC_DELETE) != 0>(nullptr)
-      , D1<(f & CC_DELETE) != 0>(nullptr)
-      , D2<(f & MC_DELETE) != 0>(nullptr)
-      , D3<(f & CA_DELETE) != 0>(nullptr)
-      , D4<(f & MA_DELETE) != 0>(nullptr)
+  explicit Delete(std::nullptr_t) :
+      D0<(f & DC_DELETE) != 0>(nullptr),
+      D1<(f & CC_DELETE) != 0>(nullptr),
+      D2<(f & MC_DELETE) != 0>(nullptr),
+      D3<(f & CA_DELETE) != 0>(nullptr),
+      D4<(f & MA_DELETE) != 0>(nullptr)
       {}
 };
 
@@ -365,7 +371,9 @@ struct Ticker {
   static int CountTicks;
   static int TicksLeft;
   static void Tick(const std::string& s) {
-    if (TicksLeft == 0) throw TickException(s);
+    if (TicksLeft == 0) {
+      throw TickException(s);
+    }
     CountTicks++;
     TicksLeft--;
   }
@@ -377,23 +385,35 @@ int Ticker::TicksLeft = -1;
 template <Flags f>
 struct DataTicker : Ticker {
   DataTicker() noexcept(f & DC_NOEXCEPT) {
-    if (!(f & DC_NOEXCEPT)) Tick("Data()");
+    if (!(f & DC_NOEXCEPT)) {
+      Tick("Data()");
+    }
   }
   DataTicker(const DataTicker&) noexcept((f & CC_NOEXCEPT) != 0) {
-    if (!(f & CC_NOEXCEPT)) Tick("Data(const Data&)");
+    if (!(f & CC_NOEXCEPT)) {
+      Tick("Data(const Data&)");
+    }
   }
   DataTicker(DataTicker&&) noexcept((f & MC_NOEXCEPT) != 0) {
-    if (!(f & MC_NOEXCEPT)) Tick("Data(Data&&)");
+    if (!(f & MC_NOEXCEPT)) {
+      Tick("Data(Data&&)");
+    }
   }
   explicit DataTicker(std::nullptr_t) noexcept((f & OC_NOEXCEPT) != 0) {
-    if (!(f & OC_NOEXCEPT)) Tick("Data(int)");
+    if (!(f & OC_NOEXCEPT)) {
+      Tick("Data(int)");
+    }
   }
   ~DataTicker() noexcept {}
   void operator=(const DataTicker&) noexcept((f & CA_NOEXCEPT) != 0) {
-    if (!(f & CA_NOEXCEPT)) Tick("op=(const Data&)");
+    if (!(f & CA_NOEXCEPT)) {
+      Tick("op=(const Data&)");
+    }
   }
   void operator=(DataTicker&&) noexcept((f & MA_NOEXCEPT) != 0) {
-    if (!(f & MA_NOEXCEPT)) Tick("op=(Data&&)");
+    if (!(f & MA_NOEXCEPT)) {
+      Tick("op=(Data&&)");
+    }
   }
 };
 
@@ -401,16 +421,44 @@ struct DataTicker : Ticker {
 // Operation counter
 
 struct Counter {
-  static int CountDC, CountCC, CountMC, CountOC, CountCA, CountMA;
-  static int CountDestroy, CountTotalOps, CountLoggedConstruction;
-
-  Counter()                         noexcept { CountTotalOps++; CountDC++; }
-  Counter(const Counter&)           noexcept { CountTotalOps++; CountCC++; }
-  Counter(Counter&&)                noexcept { CountTotalOps++; CountMC++; }
-  explicit Counter(std::nullptr_t)  noexcept { CountTotalOps++; CountOC++; }
-  void operator=(const Counter&)    noexcept { CountTotalOps++; CountCA++; }
-  void operator=(Counter&&)         noexcept { CountTotalOps++; CountMA++; }
-  ~Counter()                      noexcept { CountTotalOps++; CountDestroy++; }
+  static int CountDC;
+  static int CountCC;
+  static int CountMC;
+  static int CountOC;
+  static int CountCA;
+  static int CountMA;
+  static int CountDestroy;
+  static int CountTotalOps;
+  static int CountLoggedConstruction;
+
+  Counter() noexcept {
+    CountTotalOps++;
+    CountDC++;
+  }
+  Counter(const Counter&) noexcept {
+    CountTotalOps++;
+    CountCC++;
+  }
+  Counter(Counter&&) noexcept {
+    CountTotalOps++;
+    CountMC++;
+  }
+  explicit Counter(std::nullptr_t) noexcept {
+    CountTotalOps++;
+    CountOC++;
+  }
+  void operator=(const Counter&) noexcept {
+    CountTotalOps++;
+    CountCA++;
+  }
+  void operator=(Counter&&) noexcept {
+    CountTotalOps++;
+    CountMA++;
+  }
+  ~Counter() noexcept {
+    CountTotalOps++;
+    CountDestroy++;
+  }
 };
 
 int Counter::CountDC = 0;
@@ -444,33 +492,43 @@ struct DataTracker : Tracker {
   DataTracker() noexcept : Tracker(this, UID++) {
     UIDCount[uid]++;
     UIDTotal++;
-    if (!isRelocatable) Locations[self] = uid;
+    if (!isRelocatable) {
+      Locations[self] = uid;
+    }
     print("Data()");
   }
   DataTracker(const DataTracker& o) noexcept : Tracker(this, o.uid) {
     UIDCount[uid]++;
     UIDTotal++;
-    if (!isRelocatable) Locations[self] = uid;
+    if (!isRelocatable) {
+      Locations[self] = uid;
+    }
     print("Data(const Data&)");
   }
   DataTracker(DataTracker&& o) noexcept : Tracker(this, o.uid) {
     UIDCount[uid]++;
     UIDTotal++;
-    if (!isRelocatable) Locations[self] = uid;
+    if (!isRelocatable) {
+      Locations[self] = uid;
+    }
     print("Data(Data&&)");
   }
 
   explicit DataTracker(int uid) noexcept : Tracker(this, uid) {
     UIDCount[uid]++;
     UIDTotal++;
-    if (!isRelocatable) Locations[self] = uid;
+    if (!isRelocatable) {
+      Locations[self] = uid;
+    }
     print("Data(int)");
   }
 
   ~DataTracker() noexcept {
     UIDCount[uid]--;
     UIDTotal--;
-    if (!isRelocatable) Locations.erase(self);
+    if (!isRelocatable) {
+      Locations.erase(self);
+    }
     print("~Data()");
     uid = 0xdeadbeef;
     self = (DataTracker*)0xfeebdaed;
@@ -480,7 +538,9 @@ struct DataTracker : Tracker {
     UIDCount[uid]--;
     uid = o.uid;
     UIDCount[uid]++;
-    if (!isRelocatable) Locations[self] = uid;
+    if (!isRelocatable) {
+      Locations[self] = uid;
+    }
     print("op=(const Data&)");
     return *this;
   }
@@ -488,7 +548,9 @@ struct DataTracker : Tracker {
     UIDCount[uid]--;
     uid = o.uid;
     UIDCount[uid]++;
-    if (!isRelocatable) Locations[self] = uid;
+    if (!isRelocatable) {
+      Locations[self] = uid;
+    }
     print("op=(Data&&)");
     return *this;
   }
@@ -496,7 +558,9 @@ struct DataTracker : Tracker {
   void print(const std::string& fun) {
     if (Print) {
       std::cerr << std::setw(20) << fun << ": uid = " << std::setw(3) << uid;
-      if (!isRelocatable) std::cerr << ", self = " << self;
+      if (!isRelocatable) {
+        std::cerr << ", self = " << self;
+      }
       std::cerr << std::endl;
     }
   }
@@ -521,10 +585,11 @@ struct Data : DataTracker<(f & IS_RELOCATABLE) != 0>,
   Data() = default;
   Data(const Data&) = default;
   Data(Data&&) = default;
-  /* implicit */ Data(int i)
-    : DataTracker<(f & IS_RELOCATABLE) != 0>(i), Counter()
-    , DataTicker<f>(nullptr)
-    , Delete<f>(nullptr)
+  /* implicit */ Data(int i) :
+    DataTracker<(f & IS_RELOCATABLE) != 0>(i),
+    Counter(),
+    DataTicker<f>(nullptr),
+    Delete<f>(nullptr)
   {}
   ~Data() = default;
   Data& operator=(const Data&) = default;
@@ -619,9 +684,13 @@ struct Alloc : AllocTracker, Ticker {
     }
     if (Allocated[p] != n) {
       cerr << "deallocate(" << p << ", " << n << ") invalid: ";
-      if (Allocated[p] == 0) cerr << "never allocated";
-      else if (Allocated[p] == -1) cerr << "already deallocated";
-      else cerr << "wrong number (want " << Allocated[p] << ")";
+      if (Allocated[p] == 0) {
+        cerr << "never allocated";
+      } else if (Allocated[p] == size_t(-1)) {
+        cerr << "already deallocated";
+      } else {
+        cerr << "wrong number (want " << Allocated[p] << ")";
+      }
       cerr << endl;
       FAIL() << "deallocate failed";
     }
@@ -829,15 +898,21 @@ uint64_t ReadTSC() {
   template <class Vector> void test_ ## name ## 2 (std::false_type) {}   \
   template <class Vector> void test_ ## name ## 2 (std::true_type) {     \
     BOOST_PP_SEQ_FOR_EACH(GEN_LOOPER, _, argseq)                         \
-    { SETUP {                                                            \
-    BOOST_PP_SEQ_FOR_EACH(GEN_VMAKER, _, argseq)                         \
     {                                                                    \
-    test_ ## name <Vector, typename Vector::value_type,                  \
-      typename Vector::allocator_type> ( __VA_ARGS__ );                  \
-    if (::testing::Test::HasFatalFailure()) return;                      \
+      SETUP                                                              \
+      {                                                                  \
+        BOOST_PP_SEQ_FOR_EACH(GEN_VMAKER, _, argseq)                     \
+        {                                                                \
+          test_ ## name <Vector, typename Vector::value_type,            \
+            typename Vector::allocator_type> ( __VA_ARGS__ );            \
+          if (::testing::Test::HasFatalFailure()) {                      \
+            return;                                                      \
+          }                                                              \
+        }                                                                \
+        BOOST_PP_SEQ_FOR_EACH(GEN_UMAKER, _, BOOST_PP_SEQ_REVERSE(argseq)) \
+      }                                                                  \
+      TEARDOWN                                                           \
     }                                                                    \
-    BOOST_PP_SEQ_FOR_EACH(GEN_UMAKER, _, BOOST_PP_SEQ_REVERSE(argseq))   \
-    } TEARDOWN }                                                         \
     BOOST_PP_SEQ_FOR_EACH(GEN_CLOSER, _, BOOST_PP_SEQ_REVERSE(argseq))   \
   }                                                                      \
   template <class Vector> void test_ ## name ## 3 () {                   \
@@ -867,7 +942,9 @@ uint64_t ReadTSC() {
     BOOST_PP_SEQ_FOR_EACH(GEN_TYPE_TEST, name, INTERFACE_TYPES)          \
     bool one = false;                                                    \
     BOOST_PP_SEQ_FOR_EACH(GEN_RUNNABLE_TEST, name, types)                \
-    if (!one) FAIL() << "No tests qualified to run";                     \
+    if (!one) {                                                          \
+       FAIL() << "No tests qualified to run";                            \
+    }                                                                    \
   }
 
 #define DECL(name, ...)                                                       \
@@ -935,9 +1012,15 @@ typedef VECTOR_<DDSMA, Alloc<DDSMA>> _TSpecialMA;
 template <typename T>
 struct PrettyType {
   string operator()() {
-    if (is_same<T, int>::value) return "int";
-    if (is_same<T, char>::value) return "char";
-    if (is_same<T, uint64_t>::value) return "uint64_t";
+    if (is_same<T, int>::value) {
+      return "int";
+    }
+    if (is_same<T, char>::value) {
+      return "char";
+    }
+    if (is_same<T, uint64_t>::value) {
+      return "uint64_t";
+    }
     return typeid(T).name();
   }
 };
@@ -954,11 +1037,21 @@ struct PrettyType<Data<f, pad>> {
         (f & CA_DELETE) ||
         (f & MA_DELETE)) {
       tpe << "[^";
-      if (f & DC_DELETE) tpe << " DC,";
-      if (f & CC_DELETE) tpe << " CC,";
-      if (f & MC_DELETE) tpe << " MC,";
-      if (f & CA_DELETE) tpe << " CA,";
-      if (f & MA_DELETE) tpe << " MA,";
+      if (f & DC_DELETE) {
+        tpe << " DC,";
+      }
+      if (f & CC_DELETE) {
+        tpe << " CC,";
+      }
+      if (f & MC_DELETE) {
+        tpe << " MC,";
+      }
+      if (f & CA_DELETE) {
+        tpe << " CA,";
+      }
+      if (f & MA_DELETE) {
+        tpe << " MA,";
+      }
       tpe << "]";
     }
 
@@ -968,11 +1061,21 @@ struct PrettyType<Data<f, pad>> {
         (f & CA_NOEXCEPT) ||
         (f & MA_NOEXCEPT)) {
       tpe << "[safe";
-      if (f & DC_NOEXCEPT) tpe << " DC,";
-      if (f & CC_NOEXCEPT) tpe << " CC,";
-      if (f & MC_NOEXCEPT) tpe << " MC,";
-      if (f & CA_NOEXCEPT) tpe << " CA,";
-      if (f & MA_NOEXCEPT) tpe << " MA,";
+      if (f & DC_NOEXCEPT) {
+        tpe << " DC,";
+      }
+      if (f & CC_NOEXCEPT) {
+        tpe << " CC,";
+      }
+      if (f & MC_NOEXCEPT) {
+        tpe << " MC,";
+      }
+      if (f & CA_NOEXCEPT) {
+        tpe << " CA,";
+      }
+      if (f & MA_NOEXCEPT) {
+        tpe << " MA,";
+      }
       tpe << "]";
     }
 
@@ -1026,7 +1129,9 @@ struct PrettyType<Alloc<T>> {
 #define VMAKER_z std::nullptr_t z = nullptr;
 #define UMAKER_z                                                      \
   verify<Vector>(0);                                                  \
-  if (::testing::Test::HasFatalFailure()) return;
+  if (::testing::Test::HasFatalFailure()) {                           \
+    return;                                                           \
+  }
 #define CLOSER_z
 
 //------
@@ -1088,7 +1193,7 @@ void populate(Vector& v, const pair<int, int>& ss) {
     v.emplace_back(populateIndex++);
   }
   if (ss.second >= 0) {
-    while (v.capacity() - v.size() != ss.second) {
+    while (v.capacity() - v.size() != size_t(ss.second)) {
       v.emplace_back(populateIndex++);
     }
   }
@@ -1187,26 +1292,26 @@ iterSpotter(Vector& v, int i) {
 
   switch(i) {
   case 1:
-    if (v.empty()) ; // fall through
-    else {
+    if (!v.empty()) {
       it = v.begin();
       ++it;
       msg = "a[1]";
       break;
     }
+    FOLLY_FALLTHROUGH;
   case 0:
     it = v.begin();
     msg = "a.begin";
     break;
 
   case 2:
-    if (v.empty()) ; // fall through
-    else {
+    if (!v.empty()) {
       it = v.end();
       --it;
       msg = "a[-1]";
       break;
     }
+    FOLLY_FALLTHROUGH;
   case 3:
     it = v.end();
     msg = "a.end";
@@ -1285,8 +1390,8 @@ template <class Vector>
 void verifyVector(const Vector& v) {
   ASSERT_TRUE(v.begin() <= v.end()) << "end is before begin";
   ASSERT_TRUE(v.empty() == (v.begin() == v.end())) << "empty != (begin == end)";
-  ASSERT_TRUE(v.size() == distance(v.begin(), v.end()))
-    << "size != end - begin";
+  ASSERT_TRUE(v.size() == size_t(distance(v.begin(), v.end())))
+      << "size != end - begin";
   ASSERT_TRUE(v.size() <= v.capacity()) << "size > capacity";
   ASSERT_TRUE(v.capacity() <= v.max_size()) << "capacity > max_size";
   ASSERT_TRUE(v.data() || true); // message won't print - it will just crash
@@ -1298,8 +1403,11 @@ void verifyAllocator(int ele, int cap) {
   ASSERT_EQ(ele, AllocTracker::Constructed - AllocTracker::Destroyed);
 
   int tot = 0;
-  for (auto kv : AllocTracker::Allocated)
-    if (kv.second != -1) tot += kv.second;
+  for (auto kv : AllocTracker::Allocated) {
+    if (kv.second != size_t(-1)) {
+      tot += kv.second;
+    }
+  }
   ASSERT_EQ(cap, tot) << "the allocator counts " << tot << " space, "
     "but the vector(s) have (combined) capacity " << cap;
 }
@@ -1437,14 +1545,20 @@ Transformer<It, input_iterator_tag> makeInputIterator(const It& it) {
 
 // mutate a value (in contract only)
 void mutate(int& i) {
-  if (false) i = 0;
+  if ((false)) {
+    i = 0;
+  }
 }
 void mutate(uint64_t& i) {
-  if (false) i = 0;
+  if ((false)) {
+    i = 0;
+  }
 }
 template <Flags f, size_t pad>
 void mutate(Data<f, pad>& ds) {
-  if (false) ds.uid = 0;
+  if ((false)) {
+    ds.uid = 0;
+  }
 }
 
 //=============================================================================
@@ -1637,8 +1751,8 @@ STL_TEST("23.2.1 Table 96.15-18", iterators, is_destructible, a) {
     ASSERT_TRUE(Citb != Cite) << "cbegin == cend when non-empty";
   }
 
-  auto  dist = std::distance( itb,  ite);
-  auto Cdist = std::distance(Citb, Cite);
+  auto dist = size_t(std::distance(itb, ite));
+  auto Cdist = size_t(std::distance(Citb, Cite));
   ASSERT_TRUE( dist == ca.size()) << "distance(begin, end) != size";
   ASSERT_TRUE(Cdist == ca.size()) << "distance(cbegin, cend) != size";
 }
@@ -1804,8 +1918,8 @@ STL_TEST("23.2.1 Table 97.3-5", reversibleIterators, is_destructible, a) {
     ASSERT_TRUE(Critb != Crite) << "crbegin == crend when non-empty";
   }
 
-  auto  dist = std::distance( ritb,  rite);
-  auto Cdist = std::distance(Critb, Crite);
+  auto dist = size_t(std::distance(ritb, rite));
+  auto Cdist = size_t(std::distance(Critb, Crite));
   ASSERT_TRUE( dist == ca.size()) << "distance(rbegin, rend) != size";
   ASSERT_TRUE(Cdist == ca.size()) << "distance(crbegin, crend) != size";
 }
@@ -2100,7 +2214,7 @@ void insertNTCheck(const Vector& a, DataState<Vector>& dsa,
   for (; i < idx + n; ++i) {
     ASSERT_EQ(val, convertToInt(a.data()[i])) << i;
   }
-  for (; i < a.size(); ++i) {
+  for (; size_t(i) < a.size(); ++i) {
     ASSERT_EQ(dsa[i-n], convertToInt(a.data()[i])) << i;
   }
 }
@@ -2183,7 +2297,7 @@ void insertItCheck(const Vector& a, DataState<Vector>& dsa,
   for (; i < idx + (e - b); ++i) {
     ASSERT_EQ(*(b + i - idx), convertToInt(a.data()[i]));
   }
-  for (; i < a.size(); ++i) {
+  for (; size_t(i) < a.size(); ++i) {
     ASSERT_EQ(dsa[i - (e - b)], convertToInt(a.data()[i]));
   }
 }
@@ -2270,7 +2384,7 @@ STL_TEST("23.2.3 Table 100.10", iteratorInsertIL,
 template <class Vector>
 void eraseCheck(Vector& a, DataState<Vector>& dsa, int idx, int n) {
   ASSERT_EQ(dsa.size() - n, a.size());
-  size_t i = 0;
+  int i = 0;
   auto it = a.begin();
   for (; it != a.end(); ++it, ++i) {
     if (i == idx) i += n;
@@ -2511,7 +2625,7 @@ STL_TEST("23.2.3 Table 100.10", popBack, is_destructible, a) {
 
 STL_TEST("23.2.3 Table 100.11", operatorBrace, is_destructible, a) {
   const auto& ca = a;
-  for (int i = 0; i < ca.size(); ++i)
+  for (size_t i = 0; i < ca.size(); ++i)
     ASSERT_TRUE(addressof(ca[i]) == ca.data()+i);
 
   ASSERT_EQ(0, Counter::CountTotalOps);
@@ -2523,7 +2637,7 @@ STL_TEST("23.2.3 Table 100.11", operatorBrace, is_destructible, a) {
 
 STL_TEST("23.2.3 Table 100.12", at, is_destructible, a) {
   const auto& ca = a;
-  for (int i = 0; i < ca.size(); ++i)
+  for (size_t i = 0; i < ca.size(); ++i)
     ASSERT_TRUE(addressof(ca.at(i)) == ca.data()+i);
 
   ASSERT_EQ(0, Counter::CountTotalOps);
@@ -2579,11 +2693,11 @@ STL_TEST("23.3.6.3", reserve, is_move_constructible, a, n) {
   a.reserve(n);
 
   ASSERT_TRUE(am == a.get_allocator());
-  if (n <= ocap) {
+  if (size_t(n) <= ocap) {
     ASSERT_EQ(0, Counter::CountTotalOps);
     ASSERT_TRUE(adata == a.data());
   } else {
-    ASSERT_TRUE(a.capacity() >= n);
+    ASSERT_TRUE(a.capacity() >= size_t(n));
     ASSERT_LE(Counter::CountTotalOps, 2*a.size()); // move and delete
   }
 }
@@ -2729,3 +2843,5 @@ int main(int argc, char** argv) {
 
   return RUN_ALL_TESTS();
 }
+
+FOLLY_POP_WARNING