/*
- * Copyright 2017 Facebook, Inc.
+ * Copyright 2012-present Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
// but it also means we have some parameters that may not be used.
FOLLY_PUSH_WARNING
FOLLY_GCC_DISABLE_WARNING("-Wunused-parameter")
+FOLLY_GCC_DISABLE_WARNING("-Wunused-variable")
using namespace std;
using namespace folly;
Data& operator=(const Data&) = default;
Data& operator=(Data&&) = default;
-private:
+ private:
int operator&() const;
};
: std::integral_constant<bool,
(f & IS_RELOCATABLE) != 0
> {};
-};
+} // namespace folly
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int id;
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(Alloc&& o) noexcept : a(move(o.a)), id(o.id) {}
Alloc& operator=(const Alloc&) = default;
- Alloc& operator=(Alloc&&) = default;
+ Alloc& operator=(Alloc&&) noexcept = default;
bool operator==(const Alloc& o) const { return a == o.a && id == o.id; }
bool operator!=(const Alloc& o) const { return !(*this == o); }
return true; \
auto f = test_ ## name <Vector, \
typename Vector::value_type, typename Vector::allocator_type>; \
+ (void)f; \
return true; \
} \
template <class Vector> bool test_I_ ## name ## 3 () { \
{ 1, -1},
{ 2, -1},
{ 10, -1}, { 10, 1}, { 10, 0},
+#if !FOLLY_SANITIZE_ADDRESS
{100, -1}, {100, 1},
+#endif
//{ 10, -1}, { 10, 0}, { 10, 1}, { 10, 2}, { 10, 10},
//{ 100, -1}, { 100, 0}, { 100, 1}, { 100, 2}, { 100, 10}, { 100, 100},
// Master verifier
template <class Vector>
void verify(int extras) {
- if (!is_arithmetic<typename Vector::value_type>::value)
+ if (!is_arithmetic<typename Vector::value_type>::value) {
ASSERT_EQ(0 + extras, getTotal()) << "there exist Data but no vectors";
+ }
isSane();
- if (::testing::Test::HasFatalFailure()) return;
- if (customAllocator<Vector>::value) verifyAllocator(0, 0);
+ if (::testing::Test::HasFatalFailure()) {
+ return;
+ }
+ if (customAllocator<Vector>::value) {
+ verifyAllocator(0, 0);
+ }
}
template <class Vector>
void verify(int extras, const Vector& v) {
verifyVector(v);
- if (!is_arithmetic<typename Vector::value_type>::value)
+ if (!is_arithmetic<typename Vector::value_type>::value) {
ASSERT_EQ(v.size() + extras, getTotal())
<< "not all Data are in the vector";
+ }
isSane();
- if (::testing::Test::HasFatalFailure()) return;
- if (customAllocator<Vector>::value) verifyAllocator(v.size(), v.capacity());
+ if (::testing::Test::HasFatalFailure()) {
+ return;
+ }
+ if (customAllocator<Vector>::value) {
+ verifyAllocator(v.size(), v.capacity());
+ }
}
template <class Vector>
void verify(int extras, const Vector& v1, const Vector& v2) {
size += v2.size();
cap += v2.capacity();
}
- if (!is_arithmetic<typename Vector::value_type>::value)
+ if (!is_arithmetic<typename Vector::value_type>::value) {
ASSERT_EQ(size + extras, getTotal()) << "not all Data are in the vector(s)";
+ }
isSane();
- if (::testing::Test::HasFatalFailure()) return;
- if (customAllocator<Vector>::value) verifyAllocator(size, cap);
+ if (::testing::Test::HasFatalFailure()) {
+ return;
+ }
+ if (customAllocator<Vector>::value) {
+ verifyAllocator(size, cap);
+ }
}
//=============================================================================
typedef typename Vector::size_type size_type;
size_type size_;
int* data_;
-public:
+
+ public:
/* implicit */ DataState(const Vector& v) {
size_ = v.size();
if (size_ != 0) {
}
bool operator==(const DataState& o) const {
- if (size_ != o.size_) return false;
+ if (size_ != o.size_) {
+ return false;
+ }
for (size_type i = 0; i < size_; ++i) {
- if (data_[i] != o.data_[i]) return false;
+ if (data_[i] != o.data_[i]) {
+ return false;
+ }
}
return true;
}
friend class boost::iterator_core_access;
shared_ptr<set<It>> dereferenced;
-public:
+ public:
explicit Transformer(const It& it)
: Transformer::iterator_adaptor_(it)
, dereferenced(new set<It>()) {}
) << "only a shallow copy was made";
if (false) {
- Vector(ca);
- Vector u = ca;
+ Vector(ca2);
+ Vector u2 = ca2;
}
}
ASSERT_TRUE(dsa == u);
if (false) {
- Vector u = move(a);
+ Vector u2 = move(a);
}
}
ASSERT_TRUE(u.get_allocator() == m);
if (false) {
- Vector(m);
+ Vector t(m);
}
}
STL_TEST("23.2.1-7", ilAllocConstruction, is_arithmetic, m) {
// gcc fail
- if (Ticker::TicksLeft >= 0) return;
+ if (Ticker::TicksLeft >= 0) {
+ return;
+ }
const auto& cm = m;
ASSERT_TRUE(Allocator() == u.get_allocator());
ASSERT_EQ(n, u.size()) << "Vector(n, t).size() != n" << endl;
- for (const auto& val : u) ASSERT_EQ(convertToInt(t), convertToInt(val))
- << "not all elements of Vector(n, t) are equal to t";
+ for (const auto& val : u) {
+ ASSERT_EQ(convertToInt(t), convertToInt(val))
+ << "not all elements of Vector(n, t) are equal to t";
+ }
}
STL_TEST("23.2.3 Table 100.2", forwardIteratorConstruction,
ASSERT_LE(Counter::CountTotalOps, j-i);
ASSERT_EQ(j - i, u.size()) << "u(i,j).size() != j-i";
- for (auto it = u.begin(); it != u.end(); ++it, ++i)
+ for (auto it = u.begin(); it != u.end(); ++it, ++i) {
ASSERT_EQ(*i, convertToInt(*it)) << "u(i,j) constructed incorrectly";
}
+}
STL_TEST("23.2.3 Table 100.2", inputIteratorConstruction,
is_move_constructible, i, j) {
ASSERT_TRUE(Allocator() == u.get_allocator());
ASSERT_EQ(j - i, u.size()) << "u(i,j).size() != j-i";
- for (auto it = u.begin(); it != u.end(); ++it, ++i)
+ for (auto it = u.begin(); it != u.end(); ++it, ++i) {
ASSERT_EQ(*i, convertToInt(*it)) << "u(i,j) constructed incorrectly";
}
+}
STL_TEST("23.2.3 Table 100.3", ilConstruction, is_arithmetic) {
// whitebox: ensure that Vector(il) is implemented in terms of
// Vector(il.begin(), il.end())
// gcc fail
- if (Ticker::TicksLeft >= 0) return;
+ if (Ticker::TicksLeft >= 0) {
+ return;
+ }
Vector u = { 1, 4, 7 };
ASSERT_EQ(3, u.size()) << "u(il).size() fail";
int i = 1;
auto it = u.begin();
- for (; it != u.end(); ++it, i += 3)
+ for (; it != u.end(); ++it, i += 3) {
ASSERT_EQ(i, convertToInt(*it)) << "u(il) constructed incorrectly";
}
+}
STL_TEST("23.2.3 Table 100.4", ilAssignment,
is_arithmetic, a) {
// assign(il.begin(), il.end())
// gcc fail
- if (Ticker::TicksLeft >= 0) return;
+ if (Ticker::TicksLeft >= 0) {
+ return;
+ }
auto am = a.get_allocator();
ASSERT_EQ(3, a.size()) << "u(il).size() fail";
int i = 1;
auto it = a.begin();
- for (; it != a.end(); ++it, i += 3)
+ for (; it != a.end(); ++it, i += 3) {
ASSERT_EQ(i, convertToInt(*it)) << "u(il) constructed incorrectly";
}
+}
//----------------------------
// insert-and-erase subsection
STL_TEST("23.2.3 Table 100.7", iteratorInsertionRV,
is_move_constructibleAndAssignable, a, p, t) {
// rvalue-references cannot have their address checked for aliased inserts
- if (a.data() <= addressof(t) && addressof(t) < a.data() + a.size()) return;
+ if (a.data() <= addressof(t) && addressof(t) < a.data() + a.size()) {
+ return;
+ }
DataState<Vector> dsa(a);
int idx = distance(a.begin(), p);
STL_TEST("23.2.3 Table 100.10", iteratorInsertIL,
is_arithmetic, a, p) {
// gcc fail
- if (Ticker::TicksLeft >= 0) return;
+ if (Ticker::TicksLeft >= 0) {
+ return;
+ }
// whitebox: ensure that insert(p, il) is implemented in terms of
// insert(p, il.begin(), il.end())
int i = 0;
auto it = a.begin();
for (; it != a.end(); ++it, ++i) {
- if (i == idx) i += n;
+ if (i == idx) {
+ i += n;
+ }
ASSERT_EQ(dsa[i], convertToInt(*it));
}
}
STL_TEST("23.2.3 Table 100.11", iteratorErase, is_move_assignable, a, p) {
- if (p == a.end()) return;
+ if (p == a.end()) {
+ return;
+ }
DataState<Vector> dsa(a);
int idx = distance(a.begin(), p);
STL_TEST("23.2.3 Table 100.12", iteratorEraseRange,
is_move_assignable, a, p, q) {
- if (p == a.end()) return;
+ if (p == a.end()) {
+ return;
+ }
DataState<Vector> dsa(a);
int idx = distance(a.begin(), p);
ASSERT_TRUE(am == a.get_allocator());
ASSERT_EQ(distance(i, j), a.size());
- for (auto it = a.begin(); it != a.end(); ++it, ++i)
+ for (auto it = a.begin(); it != a.end(); ++it, ++i) {
ASSERT_EQ(*i, convertToInt(*it));
}
+}
STL_TEST("23.2.3 Table 100.14", assignInputRange,
is_move_constructibleAndAssignable, a, i, j) {
ASSERT_TRUE(am == a.get_allocator());
ASSERT_EQ(distance(i, j), a.size());
- for (auto it = a.begin(); it != a.end(); ++it, ++i)
+ for (auto it = a.begin(); it != a.end(); ++it, ++i) {
ASSERT_EQ(*i, convertToInt(*it));
}
+}
STL_TEST("23.2.3 Table 100.15", assignIL,
is_arithmetic, a) {
// assign(il.begin(), il.end())
// gcc fail
- if (Ticker::TicksLeft >= 0) return;
+ if (Ticker::TicksLeft >= 0) {
+ return;
+ }
auto am = a.get_allocator();
int* i = ila;
ASSERT_EQ(3, a.size());
- for (auto it = a.begin(); it != a.end(); ++it, ++i)
+ for (auto it = a.begin(); it != a.end(); ++it, ++i) {
ASSERT_EQ(*i, convertToInt(*it));
}
+}
STL_TEST("23.2.3 Table 100.16", assignN,
is_copy_constructibleAndAssignable, a, n, t) {
ASSERT_TRUE(am == a.get_allocator());
ASSERT_EQ(n, a.size());
- for (auto it = a.begin(); it != a.end(); ++it)
+ for (auto it = a.begin(); it != a.end(); ++it) {
ASSERT_EQ(tval, convertToInt(*it));
}
+}
STL_TEST("23.2.3 Table 101.1", front, is_destructible, a) {
- if (a.empty()) return;
+ if (a.empty()) {
+ return;
+ }
ASSERT_TRUE(addressof(a.front()) == a.data());
}
STL_TEST("23.2.3 Table 101.2", back, is_destructible, a) {
- if (a.empty()) return;
+ if (a.empty()) {
+ return;
+ }
ASSERT_TRUE(addressof(a.back()) == a.data() + a.size() - 1);
}
ASSERT_TRUE(am == a.get_allocator());
- if (excess > 0) ASSERT_TRUE(a.data() == adata) << "unnecessary relocation";
+ if (excess > 0) {
+ ASSERT_TRUE(a.data() == adata) << "unnecessary relocation";
+ }
ASSERT_EQ(dsa.size() + 1, a.size());
size_t i = 0;
auto it = a.begin();
- for (; i < dsa.size(); ++i, ++it)
+ for (; i < dsa.size(); ++i, ++it) {
ASSERT_EQ(dsa[i], convertToInt(*it));
+ }
ASSERT_EQ(44, convertToInt(a.back()));
}
}
ASSERT_TRUE(am == a.get_allocator());
- if (excess > 0) ASSERT_TRUE(a.data() == adata) << "unnecessary relocation";
+ if (excess > 0) {
+ ASSERT_TRUE(a.data() == adata) << "unnecessary relocation";
+ }
ASSERT_EQ(dsa.size() + 1, a.size());
size_t i = 0;
auto it = a.begin();
- for (; i < dsa.size(); ++i, ++it)
+ for (; i < dsa.size(); ++i, ++it) {
ASSERT_EQ(dsa[i], convertToInt(*it));
+ }
ASSERT_EQ(tval, convertToInt(a.back()));
}
}
ASSERT_TRUE(am == a.get_allocator());
- if (excess > 0) ASSERT_TRUE(a.data() == adata) << "unnecessary relocation";
+ if (excess > 0) {
+ ASSERT_TRUE(a.data() == adata) << "unnecessary relocation";
+ }
ASSERT_EQ(dsa.size() + 1, a.size());
size_t i = 0;
auto it = a.begin();
- for (; i < dsa.size(); ++i, ++it)
+ for (; i < dsa.size(); ++i, ++it) {
ASSERT_EQ(dsa[i], convertToInt(*it));
+ }
ASSERT_EQ(tval, convertToInt(a.back()));
}
STL_TEST("23.2.3 Table 100.10", popBack, is_destructible, a) {
- if (a.empty()) return;
+ if (a.empty()) {
+ return;
+ }
DataState<Vector> dsa(a);
auto am = a.get_allocator();
ASSERT_EQ(dsa.size() - 1, a.size());
size_t i = 0;
auto it = a.begin();
- for (; it != a.end(); ++it, ++i)
+ for (; it != a.end(); ++it, ++i) {
ASSERT_EQ(dsa[i], convertToInt(*it));
}
+}
STL_TEST("23.2.3 Table 100.11", operatorBrace, is_destructible, a) {
const auto& ca = a;
- for (size_t 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 (size_t 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);
STL_TEST("23.3.6.3", lengthError, is_move_constructible) {
auto mx = Vector().max_size();
auto big = mx+1;
- if (mx >= big) return; // max_size is the biggest size_type; overflowed
+ if (mx >= big) {
+ return; // max_size is the biggest size_type; overflowed
+ }
Vector u;
try {
ASSERT_EQ(0, a.capacity());
auto alloc = a.get_allocator();
- for (size_t i = 0; i < sz; ++i)
+ for (size_t i = 0; i < sz; ++i) {
std::allocator_traits<decltype(alloc)>::destroy(alloc, guts + i);
- if (guts != nullptr)
- std::allocator_traits<decltype(alloc)>::deallocate(alloc, guts, cap);
+ }
+ if (guts != nullptr) {
+ if (std::is_same<
+ decltype(alloc),
+ std::allocator<typename decltype(alloc)::value_type>>::value) {
+ free(guts);
+ } else {
+ std::allocator_traits<decltype(alloc)>::deallocate(alloc, guts, cap);
+ }
+ }
}
STL_TEST("attach", attach, is_destructible, a) {
projects / folly.git / blobdiff