/*
- * Copyright 2014 Facebook, Inc.
+ * Copyright 2017 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*/
-// only compile if GCC is at least 4.7
-#if __GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 7
-
#if 0
#define USING_STD_VECTOR
#endif
#include <cstddef>
#include <iomanip>
-#include <folly/ScopeGuard.h>
-#include <folly/Conv.h>
-#include <boost/preprocessor.hpp>
#include <boost/iterator/iterator_adaptor.hpp>
-#include <gflags/gflags.h>
-#include <gtest/gtest.h>
+#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;
};
template <Flags f>
-struct Delete : D0<f & DC_DELETE>
- , D1<f & CC_DELETE>
- , D2<f & MC_DELETE>
- , D3<f & CA_DELETE>
- , D4<f & MA_DELETE> {
+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>(nullptr)
- , D1<f & CC_DELETE>(nullptr)
- , D2<f & MC_DELETE>(nullptr)
- , D3<f & CA_DELETE>(nullptr)
- , D4<f & MA_DELETE>(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)
{}
};
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--;
}
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) {
- if (!(f & CC_NOEXCEPT)) Tick("Data(const Data&)");
+ DataTicker(const DataTicker&) noexcept((f & CC_NOEXCEPT) != 0) {
+ if (!(f & CC_NOEXCEPT)) {
+ Tick("Data(const Data&)");
+ }
}
- DataTicker(DataTicker&&) noexcept(f & MC_NOEXCEPT) {
- if (!(f & MC_NOEXCEPT)) Tick("Data(Data&&)");
+ DataTicker(DataTicker&&) noexcept((f & MC_NOEXCEPT) != 0) {
+ if (!(f & MC_NOEXCEPT)) {
+ Tick("Data(Data&&)");
+ }
}
- explicit DataTicker(std::nullptr_t) noexcept(f & OC_NOEXCEPT) {
- if (!(f & OC_NOEXCEPT)) Tick("Data(int)");
+ explicit DataTicker(std::nullptr_t) noexcept((f & OC_NOEXCEPT) != 0) {
+ if (!(f & OC_NOEXCEPT)) {
+ Tick("Data(int)");
+ }
}
~DataTicker() noexcept {}
- void operator=(const DataTicker&) noexcept(f & CA_NOEXCEPT) {
- if (!(f & CA_NOEXCEPT)) Tick("op=(const Data&)");
+ void operator=(const DataTicker&) noexcept((f & CA_NOEXCEPT) != 0) {
+ if (!(f & CA_NOEXCEPT)) {
+ Tick("op=(const Data&)");
+ }
}
- void operator=(DataTicker&&) noexcept(f & MA_NOEXCEPT) {
- if (!(f & MA_NOEXCEPT)) Tick("op=(Data&&)");
+ void operator=(DataTicker&&) noexcept((f & MA_NOEXCEPT) != 0) {
+ if (!(f & MA_NOEXCEPT)) {
+ Tick("op=(Data&&)");
+ }
}
};
// 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;
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;
UIDCount[uid]--;
uid = o.uid;
UIDCount[uid]++;
- if (!isRelocatable) Locations[self] = uid;
+ if (!isRelocatable) {
+ Locations[self] = uid;
+ }
print("op=(const Data&)");
return *this;
}
UIDCount[uid]--;
uid = o.uid;
UIDCount[uid]++;
- if (!isRelocatable) Locations[self] = uid;
+ if (!isRelocatable) {
+ Locations[self] = uid;
+ }
print("op=(Data&&)");
return *this;
}
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;
}
}
// Data
template <Flags f = 0, size_t pad = 0>
-struct Data : DataTracker<f & IS_RELOCATABLE>,
+struct Data : DataTracker<(f & IS_RELOCATABLE) != 0>,
Counter, DataTicker<f>, Delete<f> {
static const Flags flags = f;
char spacehog[pad ? pad : 1];
Data() = default;
Data(const Data&) = default;
Data(Data&&) = default;
- /* implicit */ Data(int i)
- : DataTracker<f & IS_RELOCATABLE>(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;
template <Flags f, size_t pad>
struct IsRelocatable<Data<f, pad>>
: std::integral_constant<bool,
- f & IS_RELOCATABLE
+ (f & IS_RELOCATABLE) != 0
> {};
};
struct isPropCopy : true_type {};
template <Flags f, size_t pad>
struct isPropCopy<Data<f, pad>> :
- std::integral_constant<bool, f & PROP_COPY> {};
+ std::integral_constant<bool, (f & PROP_COPY) != 0> {};
template <typename T>
struct isPropMove : true_type {};
template <Flags f, size_t pad>
struct isPropMove<Data<f, pad>> :
- std::integral_constant<bool, f & PROP_MOVE> {};
+ std::integral_constant<bool, (f & PROP_MOVE) != 0> {};
template <typename T>
struct isPropSwap : true_type {};
template <Flags f, size_t pad>
struct isPropSwap<Data<f, pad>> :
- std::integral_constant<bool, f & PROP_SWAP> {};
+ std::integral_constant<bool, (f & PROP_SWAP) != 0> {};
struct AllocTracker {
struct Alloc : AllocTracker, Ticker {
typedef typename std::allocator<T>::pointer pointer;
typedef typename std::allocator<T>::const_pointer const_pointer;
+ typedef typename std::allocator<T>::difference_type difference_type;
typedef typename std::allocator<T>::size_type size_type;
typedef typename std::allocator<T>::value_type value_type;
std::allocator<T> a;
int id;
- explicit Alloc(int i = 8) : a(a), id(i) {}
+ explicit Alloc(int i = 8) : a(), id(i) {}
Alloc(const Alloc& o) : a(o.a), id(o.id) {}
Alloc(Alloc&& o) : a(move(o.a)), id(o.id) {}
Alloc& operator=(const Alloc&) = default;
}
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";
}
// Timing
uint64_t ReadTSC() {
+#ifdef _MSC_VER
+ return __rdtsc();
+#else
unsigned reslo, reshi;
__asm__ __volatile__ (
::: "%eax", "%ebx", "%ecx", "%edx");
return ((uint64_t)reshi << 32) | reslo;
+#endif
}
//-----------------------------------------------------------------------------
e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, \
e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, \
e55, e56, e57, e58, e59, e60, e61, e62, e63, size, ...) size
-#define IBOOST_PP_VARIADIC_TO_SEQ(args...) \
- BOOST_PP_TUPLE_TO_SEQ(IBOOST_PP_VARIADIC_SIZE(args), (args))
+#define IBOOST_PP_VARIADIC_TO_SEQ(...) \
+ BOOST_PP_TUPLE_TO_SEQ(IBOOST_PP_VARIADIC_SIZE(__VA_ARGS__), (__VA_ARGS__))
//-----------------------------------------------------------------------------
// STL_TEST
#define TYPIFY(r, d, name) BOOST_PP_CAT(TYPIFY_, name)
#define ARGIFY(r, d, name) TYPIFY(r, d, name) name
-#define MAKE_TEST(ref, name, types, restriction, argseq, rawargs...) \
+#define MAKE_TEST(ref, name, types, restriction, argseq, ...) \
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> ( rawargs ); \
- 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 () { \
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, args...) \
+#define DECL(name, ...) \
template <class Vector, typename T, typename Allocator> \
void test_ ## name (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM( \
- ARGIFY, _, IBOOST_PP_VARIADIC_TO_SEQ(args))))
+ ARGIFY, _, IBOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))))
-#define STL_TEST_I(ref, name, restriction, args...) \
- DECL(name, args); \
+#define STL_TEST_I(ref, name, restriction, ...) \
+ DECL(name, __VA_ARGS__); \
MAKE_TEST(ref, name, TEST_TYPES, restriction, \
- IBOOST_PP_VARIADIC_TO_SEQ(args), args) \
- DECL(name, args)
+ IBOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__), __VA_ARGS__) \
+ DECL(name, __VA_ARGS__)
-#define STL_TEST(ref, name, restriction, args...) \
- STL_TEST_I(ref, name, restriction, z, ## args, ticks)
+#define STL_TEST(ref, name, restriction, ...) \
+ STL_TEST_I(ref, name, restriction, z, ## __VA_ARGS__, ticks)
//-----------------------------------------------------------------------------
// Test Types
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();
}
};
(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 << "]";
}
(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 << "]";
}
#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
//------
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++);
}
}
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";
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
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;
}
// 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;
+ }
}
//=============================================================================
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";
}
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";
}
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;
}
}
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]));
}
}
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;
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);
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);
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
}
}
return RUN_ALL_TESTS();
}
-#else // GCC 4.7 guard
-
-// do nothing
-TEST(placeholder, gccversion) {}
-
-int main(int argc, char** argv) {
- testing::InitGoogleTest(&argc, argv);
- gflags::ParseCommandLineFlags(&argc, &argv, true);
-
- return RUN_ALL_TESTS();
-}
-
-#endif // GCC 4.7 guard
+FOLLY_POP_WARNING
projects / folly.git / blobdiff