int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
typedef std::multiset<DefaultOnly> M;
typedef M::iterator R;
M m;
assert(DefaultOnly::count == 0);
R r = m.emplace_hint(m.cend());
assert(r == m.begin());
assert(m.size() == 1);
assert(*m.begin() == DefaultOnly());
assert(DefaultOnly::count == 1);
r = m.emplace_hint(m.cbegin());
assert(r == m.begin());
assert(m.size() == 2);
assert(*m.begin() == DefaultOnly());
assert(DefaultOnly::count == 2);
}
assert(DefaultOnly::count == 0);
{
typedef std::multiset<Emplaceable> M;
typedef M::iterator R;
M m;
R r = m.emplace_hint(m.cend());
assert(r == m.begin());
assert(m.size() == 1);
assert(*m.begin() == Emplaceable());
r = m.emplace_hint(m.cend(), 2, 3.5);
assert(r == next(m.begin()));
assert(m.size() == 2);
assert(*r == Emplaceable(2, 3.5));
r = m.emplace_hint(m.cbegin(), 2, 3.5);
assert(r == next(m.begin()));
assert(m.size() == 3);
assert(*r == Emplaceable(2, 3.5));
}
{
typedef std::multiset<int> M;
typedef M::iterator R;
M m;
R r = m.emplace_hint(m.cend(), M::value_type(2));
assert(r == m.begin());
assert(m.size() == 1);
assert(*r == 2);
}
#if __cplusplus >= 201103L
{
typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
typedef M::iterator R;
M m;
R r = m.emplace_hint(m.cend(), M::value_type(2));
assert(r == m.begin());
assert(m.size() == 1);
assert(*r == 2);
}
#endif
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
typedef std::unordered_map<int, Emplaceable> C;
typedef std::pair<C::iterator, bool> R;
C c;
R r = c.emplace(3);
assert(r.second);
assert(c.size() == 1);
assert(r.first->first == 3);
assert(r.first->second == Emplaceable());
r = c.emplace(std::pair<const int, Emplaceable>(4, Emplaceable(5, 6)));
assert(r.second);
assert(c.size() == 2);
assert(r.first->first == 4);
assert(r.first->second == Emplaceable(5, 6));
r = c.emplace(5, 6, 7);
assert(r.second);
assert(c.size() == 3);
assert(r.first->first == 5);
assert(r.first->second == Emplaceable(6, 7));
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}
int main(int, char**)
{
{
typedef std::set<DefaultOnly> M;
typedef M::iterator R;
M m;
assert(DefaultOnly::count == 0);
R r = m.emplace_hint(m.cend());
assert(r == m.begin());
assert(m.size() == 1);
assert(*m.begin() == DefaultOnly());
assert(DefaultOnly::count == 1);
r = m.emplace_hint(m.cbegin());
assert(r == m.begin());
assert(m.size() == 1);
assert(*m.begin() == DefaultOnly());
assert(DefaultOnly::count == 1);
}
assert(DefaultOnly::count == 0);
{
typedef std::set<Emplaceable> M;
typedef M::iterator R;
M m;
R r = m.emplace_hint(m.cend());
assert(r == m.begin());
assert(m.size() == 1);
assert(*m.begin() == Emplaceable());
r = m.emplace_hint(m.cend(), 2, 3.5);
assert(r == next(m.begin()));
assert(m.size() == 2);
assert(*r == Emplaceable(2, 3.5));
r = m.emplace_hint(m.cbegin(), 2, 3.5);
assert(r == next(m.begin()));
assert(m.size() == 2);
assert(*r == Emplaceable(2, 3.5));
}
{
typedef std::set<int> M;
typedef M::iterator R;
M m;
R r = m.emplace_hint(m.cend(), M::value_type(2));
assert(r == m.begin());
assert(m.size() == 1);
assert(*r == 2);
}
{
typedef std::set<int, std::less<int>, min_allocator<int>> M;
typedef M::iterator R;
M m;
R r = m.emplace_hint(m.cend(), M::value_type(2));
assert(r == m.begin());
assert(m.size() == 1);
assert(*r == 2);
}
return 0;
}
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
typedef std::set<DefaultOnly> M;
typedef std::pair<M::iterator, bool> R;
M m;
assert(DefaultOnly::count == 0);
R r = m.emplace();
assert(r.second);
assert(r.first == m.begin());
assert(m.size() == 1);
assert(*m.begin() == DefaultOnly());
assert(DefaultOnly::count == 1);
r = m.emplace();
assert(!r.second);
assert(r.first == m.begin());
assert(m.size() == 1);
assert(*m.begin() == DefaultOnly());
assert(DefaultOnly::count == 1);
}
assert(DefaultOnly::count == 0);
{
typedef std::set<Emplaceable> M;
typedef std::pair<M::iterator, bool> R;
M m;
R r = m.emplace();
assert(r.second);
assert(r.first == m.begin());
assert(m.size() == 1);
assert(*m.begin() == Emplaceable());
r = m.emplace(2, 3.5);
assert(r.second);
assert(r.first == next(m.begin()));
assert(m.size() == 2);
assert(*r.first == Emplaceable(2, 3.5));
r = m.emplace(2, 3.5);
assert(!r.second);
assert(r.first == next(m.begin()));
assert(m.size() == 2);
assert(*r.first == Emplaceable(2, 3.5));
}
{
typedef std::set<int> M;
typedef std::pair<M::iterator, bool> R;
M m;
R r = m.emplace(M::value_type(2));
assert(r.second);
assert(r.first == m.begin());
assert(m.size() == 1);
assert(*r.first == 2);
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}
void
test(C& c1)
{
typedef typename C::iterator I;
std::size_t c1_osize = c1.size();
c1.emplace_back(Emplaceable(1, 2.5));
assert(c1.size() == c1_osize + 1);
assert(distance(c1.begin(), c1.end()) == c1.size());
I i = c1.end();
assert(*--i == Emplaceable(1, 2.5));
}
void
test(C& c1)
{
typedef typename C::iterator I;
typedef typename C::reference Ref;
std::size_t c1_osize = c1.size();
Ref res_ref = c1.emplace_front(Emplaceable(1, 2.5));
assert(c1.size() == c1_osize + 1);
assert(distance(c1.begin(), c1.end())
== static_cast<std::ptrdiff_t>(c1.size()));
I i = c1.begin();
assert(*i == Emplaceable(1, 2.5));
assert(&res_ref == &(*i));
}
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
typedef std::unordered_map<int, Emplaceable> C;
typedef std::pair<C::iterator, bool> R;
C c;
R r = c.emplace(std::piecewise_construct, std::forward_as_tuple(3),
std::forward_as_tuple());
assert(r.second);
assert(c.size() == 1);
assert(r.first->first == 3);
assert(r.first->second == Emplaceable());
r = c.emplace(std::pair<const int, Emplaceable>(4, Emplaceable(5, 6)));
assert(r.second);
assert(c.size() == 2);
assert(r.first->first == 4);
assert(r.first->second == Emplaceable(5, 6));
r = c.emplace(std::piecewise_construct, std::forward_as_tuple(5),
std::forward_as_tuple(6, 7));
assert(r.second);
assert(c.size() == 3);
assert(r.first->first == 5);
assert(r.first->second == Emplaceable(6, 7));
}
#if __cplusplus >= 201103L
{
typedef std::unordered_map<int, Emplaceable, std::hash<int>, std::equal_to<int>,
min_allocator<std::pair<const int, Emplaceable>>> C;
typedef std::pair<C::iterator, bool> R;
C c;
R r = c.emplace(std::piecewise_construct, std::forward_as_tuple(3),
std::forward_as_tuple());
assert(r.second);
assert(c.size() == 1);
assert(r.first->first == 3);
assert(r.first->second == Emplaceable());
r = c.emplace(std::pair<const int, Emplaceable>(4, Emplaceable(5, 6)));
assert(r.second);
assert(c.size() == 2);
assert(r.first->first == 4);
assert(r.first->second == Emplaceable(5, 6));
r = c.emplace(std::piecewise_construct, std::forward_as_tuple(5),
std::forward_as_tuple(6, 7));
assert(r.second);
assert(c.size() == 3);
assert(r.first->first == 5);
assert(r.first->second == Emplaceable(6, 7));
}
#endif
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}
void
test(C& c1)
{
typedef typename C::iterator I;
std::size_t c1_osize = c1.size();
#if TEST_STD_VER > 14
typedef typename C::reference Ref;
Ref ref = c1.emplace_back(Emplaceable(1, 2.5));
#else
c1.emplace_back(Emplaceable(1, 2.5));
#endif
assert(c1.size() == c1_osize + 1);
assert(distance(c1.begin(), c1.end())
== static_cast<std::ptrdiff_t>(c1.size()));
I i = c1.end();
assert(*--i == Emplaceable(1, 2.5));
#if TEST_STD_VER > 14
assert(&(*i) == &ref);
#endif
}
int tc_libcxx_containers_unord_multimap_modifiers_emplace_hint(void)
{
{
typedef std::unordered_multimap<int, Emplaceable> C;
typedef C::iterator R;
C c;
C::const_iterator e = c.end();
R r = c.emplace_hint(e, std::piecewise_construct, std::forward_as_tuple(3),
std::forward_as_tuple());
TC_ASSERT_EXPR(c.size() == 1);
TC_ASSERT_EXPR(r->first == 3);
TC_ASSERT_EXPR(r->second == Emplaceable());
r = c.emplace_hint(c.end(), std::pair<const int, Emplaceable>(3, Emplaceable(5, 6)));
TC_ASSERT_EXPR(c.size() == 2);
TC_ASSERT_EXPR(r->first == 3);
TC_ASSERT_EXPR(r->second == Emplaceable(5, 6));
LIBCPP_ASSERT(r == next(c.begin()));
r = c.emplace_hint(r, std::piecewise_construct, std::forward_as_tuple(3),
std::forward_as_tuple(6, 7));
TC_ASSERT_EXPR(c.size() == 3);
TC_ASSERT_EXPR(r->first == 3);
TC_ASSERT_EXPR(r->second == Emplaceable(6, 7));
LIBCPP_ASSERT(r == next(c.begin()));
r = c.begin();
TC_ASSERT_EXPR(r->first == 3);
LIBCPP_ASSERT(r->second == Emplaceable());
r = next(r, 2);
TC_ASSERT_EXPR(r->first == 3);
LIBCPP_ASSERT(r->second == Emplaceable(5, 6));
}
TC_SUCCESS_RESULT();
return 0;
}
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
typedef Emplaceable T;
typedef std::forward_list<T> C;
C c;
c.emplace_front();
assert(c.front() == Emplaceable());
assert(distance(c.begin(), c.end()) == 1);
c.emplace_front(1, 2.5);
assert(c.front() == Emplaceable(1, 2.5));
assert(*next(c.begin()) == Emplaceable());
assert(distance(c.begin(), c.end()) == 2);
}
#if TEST_STD_VER >= 11
{
typedef Emplaceable T;
typedef std::forward_list<T, min_allocator<T>> C;
C c;
c.emplace_front();
assert(c.front() == Emplaceable());
assert(distance(c.begin(), c.end()) == 1);
c.emplace_front(1, 2.5);
assert(c.front() == Emplaceable(1, 2.5));
assert(*next(c.begin()) == Emplaceable());
assert(distance(c.begin(), c.end()) == 2);
}
#endif
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}
int main()
{
{
typedef Emplaceable T;
typedef std::forward_list<T> C;
C c;
T& r1 = c.emplace_front();
assert(c.front() == Emplaceable());
assert(&r1 == &c.front());
assert(distance(c.begin(), c.end()) == 1);
T& r2 = c.emplace_front(1, 2.5);
assert(c.front() == Emplaceable(1, 2.5));
assert(&r2 == &c.front());
assert(*next(c.begin()) == Emplaceable());
assert(distance(c.begin(), c.end()) == 2);
}
{
typedef Emplaceable T;
typedef std::forward_list<T, min_allocator<T>> C;
C c;
T& r1 = c.emplace_front();
assert(c.front() == Emplaceable());
assert(&r1 == &c.front());
assert(distance(c.begin(), c.end()) == 1);
T& r2 = c.emplace_front(1, 2.5);
assert(c.front() == Emplaceable(1, 2.5));
assert(&r2 == &c.front());
assert(*next(c.begin()) == Emplaceable());
assert(distance(c.begin(), c.end()) == 2);
}
}
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
typedef std::unordered_multimap<int, Emplaceable> C;
typedef C::iterator R;
C c;
C::const_iterator e = c.end();
R r = c.emplace_hint(e, 3);
assert(c.size() == 1);
assert(r->first == 3);
assert(r->second == Emplaceable());
r = c.emplace_hint(e, std::pair<const int, Emplaceable>(3, Emplaceable(5, 6)));
assert(c.size() == 2);
assert(r->first == 3);
assert(r->second == Emplaceable(5, 6));
assert(r == next(c.begin()));
r = c.emplace_hint(r, 3, 6, 7);
assert(c.size() == 3);
assert(r->first == 3);
assert(r->second == Emplaceable(6, 7));
assert(r == next(c.begin()));
r = c.begin();
assert(r->first == 3);
assert(r->second == Emplaceable());
r = next(r, 2);
assert(r->first == 3);
assert(r->second == Emplaceable(5, 6));
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}
int main()
{
typedef Emplaceable T;
std::queue<Emplaceable> q;
#if TEST_STD_VER > 14
T& r1 = q.emplace(1, 2.5);
assert(&r1 == &q.back());
T& r2 = q.emplace(2, 3.5);
assert(&r2 == &q.back());
T& r3 = q.emplace(3, 4.5);
assert(&r3 == &q.back());
assert(&r1 == &q.front());
#else
q.emplace(1, 2.5);
q.emplace(2, 3.5);
q.emplace(3, 4.5);
#endif
assert(q.size() == 3);
assert(q.front() == Emplaceable(1, 2.5));
assert(q.back() == Emplaceable(3, 4.5));
}
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
typedef std::unordered_set<Emplaceable> C;
typedef std::pair<C::iterator, bool> R;
C c;
R r = c.emplace();
assert(c.size() == 1);
assert(*r.first == Emplaceable());
assert(r.second);
r = c.emplace(Emplaceable(5, 6));
assert(c.size() == 2);
assert(*r.first == Emplaceable(5, 6));
assert(r.second);
r = c.emplace(5, 6);
assert(c.size() == 2);
assert(*r.first == Emplaceable(5, 6));
assert(!r.second);
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}
int main(int, char**)
{
{
typedef std::unordered_set<Emplaceable> C;
typedef std::pair<C::iterator, bool> R;
C c;
R r = c.emplace();
assert(c.size() == 1);
assert(*r.first == Emplaceable());
assert(r.second);
r = c.emplace(Emplaceable(5, 6));
assert(c.size() == 2);
assert(*r.first == Emplaceable(5, 6));
assert(r.second);
r = c.emplace(5, 6);
assert(c.size() == 2);
assert(*r.first == Emplaceable(5, 6));
assert(!r.second);
}
{
typedef std::unordered_set<Emplaceable, std::hash<Emplaceable>,
std::equal_to<Emplaceable>, min_allocator<Emplaceable>> C;
typedef std::pair<C::iterator, bool> R;
C c;
R r = c.emplace();
assert(c.size() == 1);
assert(*r.first == Emplaceable());
assert(r.second);
r = c.emplace(Emplaceable(5, 6));
assert(c.size() == 2);
assert(*r.first == Emplaceable(5, 6));
assert(r.second);
r = c.emplace(5, 6);
assert(c.size() == 2);
assert(*r.first == Emplaceable(5, 6));
assert(!r.second);
}
return 0;
}
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
typedef std::unordered_set<Emplaceable> C;
typedef C::iterator R;
C c;
C::const_iterator e = c.end();
R r = c.emplace_hint(e);
assert(c.size() == 1);
assert(*r == Emplaceable());
r = c.emplace_hint(e, Emplaceable(5, 6));
assert(c.size() == 2);
assert(*r == Emplaceable(5, 6));
r = c.emplace_hint(r, 5, 6);
assert(c.size() == 2);
assert(*r == Emplaceable(5, 6));
}
#if __cplusplus >= 201103L
{
typedef std::unordered_set<Emplaceable, std::hash<Emplaceable>,
std::equal_to<Emplaceable>, min_allocator<Emplaceable>> C;
typedef C::iterator R;
C c;
C::const_iterator e = c.end();
R r = c.emplace_hint(e);
assert(c.size() == 1);
assert(*r == Emplaceable());
r = c.emplace_hint(e, Emplaceable(5, 6));
assert(c.size() == 2);
assert(*r == Emplaceable(5, 6));
r = c.emplace_hint(r, 5, 6);
assert(c.size() == 2);
assert(*r == Emplaceable(5, 6));
}
#endif
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}
C
make(int size, int start = 0 )
{
const int b = 4096 / sizeof(int);
int init = 0;
if (start > 0)
{
init = (start+1) / b + ((start+1) % b != 0);
init *= b;
--init;
}
C c(init);
for (int i = 0; i < init-start; ++i)
c.pop_back();
for (int i = 0; i < size; ++i)
c.push_back(Emplaceable());
for (int i = 0; i < start; ++i)
c.pop_front();
return c;
}
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
typedef std::unordered_map<int, Emplaceable> C;
typedef C::iterator R;
C c;
C::const_iterator e = c.end();
R r = c.emplace_hint(e, std::piecewise_construct, std::forward_as_tuple(3),
std::forward_as_tuple());
assert(c.size() == 1);
assert(r->first == 3);
assert(r->second == Emplaceable());
r = c.emplace_hint(c.end(), std::pair<const int, Emplaceable>(4, Emplaceable(5, 6)));
assert(c.size() == 2);
assert(r->first == 4);
assert(r->second == Emplaceable(5, 6));
r = c.emplace_hint(c.end(), std::piecewise_construct, std::forward_as_tuple(5),
std::forward_as_tuple(6, 7));
assert(c.size() == 3);
assert(r->first == 5);
assert(r->second == Emplaceable(6, 7));
}
#if __cplusplus >= 201103L
{
typedef std::unordered_map<int, Emplaceable, std::hash<int>, std::equal_to<int>,
min_allocator<std::pair<const int, Emplaceable>>> C;
typedef C::iterator R;
C c;
C::const_iterator e = c.end();
R r = c.emplace_hint(e, std::piecewise_construct, std::forward_as_tuple(3),
std::forward_as_tuple());
assert(c.size() == 1);
assert(r->first == 3);
assert(r->second == Emplaceable());
r = c.emplace_hint(c.end(), std::pair<const int, Emplaceable>(4, Emplaceable(5, 6)));
assert(c.size() == 2);
assert(r->first == 4);
assert(r->second == Emplaceable(5, 6));
r = c.emplace_hint(c.end(), std::piecewise_construct, std::forward_as_tuple(5),
std::forward_as_tuple(6, 7));
assert(c.size() == 3);
assert(r->first == 5);
assert(r->second == Emplaceable(6, 7));
}
#endif
#if _LIBCPP_DEBUG >= 1
{
typedef std::unordered_map<int, Emplaceable> C;
typedef C::iterator R;
typedef C::value_type P;
C c;
C c2;
R r = c.emplace_hint(c2.end(), std::piecewise_construct,
std::forward_as_tuple(3),
std::forward_as_tuple());
assert(false);
}
#endif
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}
int main()
{
{
typedef std::multimap<int, DefaultOnly> M;
typedef M::iterator R;
M m;
assert(DefaultOnly::count == 0);
R r = m.emplace_hint(m.cend());
assert(r == m.begin());
assert(m.size() == 1);
assert(m.begin()->first == 0);
assert(m.begin()->second == DefaultOnly());
assert(DefaultOnly::count == 1);
r = m.emplace_hint(m.cend(), std::piecewise_construct,
std::forward_as_tuple(1),
std::forward_as_tuple());
assert(r == next(m.begin()));
assert(m.size() == 2);
assert(next(m.begin())->first == 1);
assert(next(m.begin())->second == DefaultOnly());
assert(DefaultOnly::count == 2);
r = m.emplace_hint(m.cend(), std::piecewise_construct,
std::forward_as_tuple(1),
std::forward_as_tuple());
assert(r == next(m.begin(), 2));
assert(m.size() == 3);
assert(next(m.begin(), 2)->first == 1);
assert(next(m.begin(), 2)->second == DefaultOnly());
assert(DefaultOnly::count == 3);
}
assert(DefaultOnly::count == 0);
{
typedef std::multimap<int, Emplaceable> M;
typedef M::iterator R;
M m;
R r = m.emplace_hint(m.cend(), std::piecewise_construct,
std::forward_as_tuple(2),
std::forward_as_tuple());
assert(r == m.begin());
assert(m.size() == 1);
assert(m.begin()->first == 2);
assert(m.begin()->second == Emplaceable());
r = m.emplace_hint(m.cbegin(), std::piecewise_construct,
std::forward_as_tuple(1),
std::forward_as_tuple(2, 3.5));
assert(r == m.begin());
assert(m.size() == 2);
assert(m.begin()->first == 1);
assert(m.begin()->second == Emplaceable(2, 3.5));
r = m.emplace_hint(m.cbegin(), std::piecewise_construct,
std::forward_as_tuple(1),
std::forward_as_tuple(3, 3.5));
assert(r == m.begin());
assert(m.size() == 3);
assert(r->first == 1);
assert(r->second == Emplaceable(3, 3.5));
}
{
typedef std::multimap<int, double> M;
typedef M::iterator R;
M m;
R r = m.emplace_hint(m.cend(), M::value_type(2, 3.5));
assert(r == m.begin());
assert(m.size() == 1);
assert(m.begin()->first == 2);
assert(m.begin()->second == 3.5);
}
{
typedef std::multimap<int, DefaultOnly, std::less<int>, min_allocator<std::pair<const int, DefaultOnly>>> M;
typedef M::iterator R;
M m;
assert(DefaultOnly::count == 0);
R r = m.emplace_hint(m.cend());
assert(r == m.begin());
assert(m.size() == 1);
assert(m.begin()->first == 0);
assert(m.begin()->second == DefaultOnly());
assert(DefaultOnly::count == 1);
r = m.emplace_hint(m.cend(), std::piecewise_construct,
std::forward_as_tuple(1),
std::forward_as_tuple());
assert(r == next(m.begin()));
assert(m.size() == 2);
assert(next(m.begin())->first == 1);
assert(next(m.begin())->second == DefaultOnly());
assert(DefaultOnly::count == 2);
r = m.emplace_hint(m.cend(), std::piecewise_construct,
std::forward_as_tuple(1),
std::forward_as_tuple());
assert(r == next(m.begin(), 2));
assert(m.size() == 3);
assert(next(m.begin(), 2)->first == 1);
assert(next(m.begin(), 2)->second == DefaultOnly());
assert(DefaultOnly::count == 3);
}
assert(DefaultOnly::count == 0);
{
typedef std::multimap<int, Emplaceable, std::less<int>, min_allocator<std::pair<const int, Emplaceable>>> M;
typedef M::iterator R;
M m;
R r = m.emplace_hint(m.cend(), std::piecewise_construct,
std::forward_as_tuple(2),
std::forward_as_tuple());
assert(r == m.begin());
assert(m.size() == 1);
assert(m.begin()->first == 2);
assert(m.begin()->second == Emplaceable());
r = m.emplace_hint(m.cbegin(), std::piecewise_construct,
std::forward_as_tuple(1),
std::forward_as_tuple(2, 3.5));
assert(r == m.begin());
assert(m.size() == 2);
assert(m.begin()->first == 1);
assert(m.begin()->second == Emplaceable(2, 3.5));
r = m.emplace_hint(m.cbegin(), std::piecewise_construct,
std::forward_as_tuple(1),
std::forward_as_tuple(3, 3.5));
assert(r == m.begin());
assert(m.size() == 3);
assert(r->first == 1);
assert(r->second == Emplaceable(3, 3.5));
}
{
typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
typedef M::iterator R;
M m;
R r = m.emplace_hint(m.cend(), M::value_type(2, 3.5));
assert(r == m.begin());
assert(m.size() == 1);
assert(m.begin()->first == 2);
assert(m.begin()->second == 3.5);
}
}
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
typedef std::multimap<int, DefaultOnly> M;
typedef M::iterator R;
M m;
assert(DefaultOnly::count == 0);
R r = m.emplace();
assert(r == m.begin());
assert(m.size() == 1);
assert(m.begin()->first == 0);
assert(m.begin()->second == DefaultOnly());
assert(DefaultOnly::count == 1);
r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1),
std::forward_as_tuple());
assert(r == next(m.begin()));
assert(m.size() == 2);
assert(next(m.begin())->first == 1);
assert(next(m.begin())->second == DefaultOnly());
assert(DefaultOnly::count == 2);
r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1),
std::forward_as_tuple());
assert(r == next(m.begin(), 2));
assert(m.size() == 3);
assert(next(m.begin(), 2)->first == 1);
assert(next(m.begin(), 2)->second == DefaultOnly());
assert(DefaultOnly::count == 3);
}
assert(DefaultOnly::count == 0);
{
typedef std::multimap<int, Emplaceable> M;
typedef M::iterator R;
M m;
R r = m.emplace(std::piecewise_construct, std::forward_as_tuple(2),
std::forward_as_tuple());
assert(r == m.begin());
assert(m.size() == 1);
assert(m.begin()->first == 2);
assert(m.begin()->second == Emplaceable());
r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1),
std::forward_as_tuple(2, 3.5));
assert(r == m.begin());
assert(m.size() == 2);
assert(m.begin()->first == 1);
assert(m.begin()->second == Emplaceable(2, 3.5));
r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1),
std::forward_as_tuple(3, 3.5));
assert(r == next(m.begin()));
assert(m.size() == 3);
assert(r->first == 1);
assert(r->second == Emplaceable(3, 3.5));
}
{
typedef std::multimap<int, double> M;
typedef M::iterator R;
M m;
R r = m.emplace(M::value_type(2, 3.5));
assert(r == m.begin());
assert(m.size() == 1);
assert(m.begin()->first == 2);
assert(m.begin()->second == 3.5);
}
#if __cplusplus >= 201103L || defined(_LIBCPP_MSVC)
{
typedef std::multimap<int, DefaultOnly, std::less<int>, min_allocator<std::pair<const int, DefaultOnly>>> M;
typedef M::iterator R;
M m;
assert(DefaultOnly::count == 0);
R r = m.emplace();
assert(r == m.begin());
assert(m.size() == 1);
assert(m.begin()->first == 0);
assert(m.begin()->second == DefaultOnly());
assert(DefaultOnly::count == 1);
r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1),
std::forward_as_tuple());
assert(r == next(m.begin()));
assert(m.size() == 2);
assert(next(m.begin())->first == 1);
assert(next(m.begin())->second == DefaultOnly());
assert(DefaultOnly::count == 2);
r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1),
std::forward_as_tuple());
assert(r == next(m.begin(), 2));
assert(m.size() == 3);
assert(next(m.begin(), 2)->first == 1);
assert(next(m.begin(), 2)->second == DefaultOnly());
assert(DefaultOnly::count == 3);
}
assert(DefaultOnly::count == 0);
{
typedef std::multimap<int, Emplaceable, std::less<int>, min_allocator<std::pair<const int, Emplaceable>>> M;
typedef M::iterator R;
M m;
R r = m.emplace(std::piecewise_construct, std::forward_as_tuple(2),
std::forward_as_tuple());
assert(r == m.begin());
assert(m.size() == 1);
assert(m.begin()->first == 2);
assert(m.begin()->second == Emplaceable());
r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1),
std::forward_as_tuple(2, 3.5));
assert(r == m.begin());
assert(m.size() == 2);
assert(m.begin()->first == 1);
assert(m.begin()->second == Emplaceable(2, 3.5));
r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1),
std::forward_as_tuple(3, 3.5));
assert(r == next(m.begin()));
assert(m.size() == 3);
assert(r->first == 1);
assert(r->second == Emplaceable(3, 3.5));
}
{
typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
typedef M::iterator R;
M m;
R r = m.emplace(M::value_type(2, 3.5));
assert(r == m.begin());
assert(m.size() == 1);
assert(m.begin()->first == 2);
assert(m.begin()->second == 3.5);
}
#endif
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
typedef Emplaceable T;
typedef std::forward_list<T> C;
typedef C::iterator I;
C c;
I i = c.emplace_after(c.cbefore_begin());
assert(i == c.begin());
assert(c.front() == Emplaceable());
assert(distance(c.begin(), c.end()) == 1);
i = c.emplace_after(c.cbegin(), 1, 2.5);
assert(i == next(c.begin()));
assert(c.front() == Emplaceable());
assert(*next(c.begin()) == Emplaceable(1, 2.5));
assert(distance(c.begin(), c.end()) == 2);
i = c.emplace_after(next(c.cbegin()), 2, 3.5);
assert(i == next(c.begin(), 2));
assert(c.front() == Emplaceable());
assert(*next(c.begin()) == Emplaceable(1, 2.5));
assert(*next(c.begin(), 2) == Emplaceable(2, 3.5));
assert(distance(c.begin(), c.end()) == 3);
i = c.emplace_after(c.cbegin(), 3, 4.5);
assert(i == next(c.begin()));
assert(c.front() == Emplaceable());
assert(*next(c.begin(), 1) == Emplaceable(3, 4.5));
assert(*next(c.begin(), 2) == Emplaceable(1, 2.5));
assert(*next(c.begin(), 3) == Emplaceable(2, 3.5));
assert(distance(c.begin(), c.end()) == 4);
}
#if __cplusplus >= 201103L
{
typedef Emplaceable T;
typedef std::forward_list<T, min_allocator<T>> C;
typedef C::iterator I;
C c;
I i = c.emplace_after(c.cbefore_begin());
assert(i == c.begin());
assert(c.front() == Emplaceable());
assert(distance(c.begin(), c.end()) == 1);
i = c.emplace_after(c.cbegin(), 1, 2.5);
assert(i == next(c.begin()));
assert(c.front() == Emplaceable());
assert(*next(c.begin()) == Emplaceable(1, 2.5));
assert(distance(c.begin(), c.end()) == 2);
i = c.emplace_after(next(c.cbegin()), 2, 3.5);
assert(i == next(c.begin(), 2));
assert(c.front() == Emplaceable());
assert(*next(c.begin()) == Emplaceable(1, 2.5));
assert(*next(c.begin(), 2) == Emplaceable(2, 3.5));
assert(distance(c.begin(), c.end()) == 3);
i = c.emplace_after(c.cbegin(), 3, 4.5);
assert(i == next(c.begin()));
assert(c.front() == Emplaceable());
assert(*next(c.begin(), 1) == Emplaceable(3, 4.5));
assert(*next(c.begin(), 2) == Emplaceable(1, 2.5));
assert(*next(c.begin(), 3) == Emplaceable(2, 3.5));
assert(distance(c.begin(), c.end()) == 4);
}
#endif
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}
void main()
{
#ifndef _LIBCPP_HAS_NO_VARIADICS
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
typedef unordered_map<int, Emplaceable> C;
typedef C::iterator R;
C c;
C::const_iterator e = c.end();
R r = c.emplace_hint(e, std::piecewise_construct, std::forward_as_tuple(3),
std::forward_as_tuple());
assert(c.size() == 1);
assert(r->first == 3);
assert(r->second == Emplaceable());
r = c.emplace_hint(c.end(), std::pair<const int, Emplaceable>(4, Emplaceable(5, 6)));
assert(c.size() == 2);
assert(r->first == 4);
assert(r->second == Emplaceable(5, 6));
r = c.emplace_hint(c.end(), std::piecewise_construct, std::forward_as_tuple(5),
std::forward_as_tuple(6, 7));
assert(c.size() == 3);
assert(r->first == 5);
assert(r->second == Emplaceable(6, 7));
}
//#if __cplusplus >= 201103L
#ifdef LIBCPP_TEST_MIN_ALLOCATOR
{
typedef unordered_map<int, Emplaceable, std::hash<int>, std::equal_to<int>,
min_allocator<std::pair<const int, Emplaceable>>> C;
typedef C::iterator R;
C c;
C::const_iterator e = c.end();
R r = c.emplace_hint(e, std::piecewise_construct, std::forward_as_tuple(3),
std::forward_as_tuple());
assert(c.size() == 1);
assert(r->first == 3);
assert(r->second == Emplaceable());
r = c.emplace_hint(c.end(), std::pair<const int, Emplaceable>(4, Emplaceable(5, 6)));
assert(c.size() == 2);
assert(r->first == 4);
assert(r->second == Emplaceable(5, 6));
r = c.emplace_hint(c.end(), std::piecewise_construct, std::forward_as_tuple(5),
std::forward_as_tuple(6, 7));
assert(c.size() == 3);
assert(r->first == 5);
assert(r->second == Emplaceable(6, 7));
}
#endif
#if _LIBCPP_DEBUG >= 1
#ifdef LIBCPP_HAS_BAD_NEWS_FOR_MOMO
{
typedef unordered_map<int, Emplaceable> C;
typedef C::iterator R;
typedef C::value_type P;
C c;
C c2;
LIBCPP_CATCH(c.emplace_hint(c2.end(), std::piecewise_construct,
std::forward_as_tuple(3),
std::forward_as_tuple()));
//assert(false);
}
#endif
#endif
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif // _LIBCPP_HAS_NO_VARIADICS
}
int main(int, char**)
{
{
typedef std::set<DefaultOnly> M;
typedef std::pair<M::iterator, bool> R;
M m;
assert(DefaultOnly::count == 0);
R r = m.emplace();
assert(r.second);
assert(r.first == m.begin());
assert(m.size() == 1);
assert(*m.begin() == DefaultOnly());
assert(DefaultOnly::count == 1);
r = m.emplace();
assert(!r.second);
assert(r.first == m.begin());
assert(m.size() == 1);
assert(*m.begin() == DefaultOnly());
assert(DefaultOnly::count == 1);
}
assert(DefaultOnly::count == 0);
{
typedef std::set<Emplaceable> M;
typedef std::pair<M::iterator, bool> R;
M m;
R r = m.emplace();
assert(r.second);
assert(r.first == m.begin());
assert(m.size() == 1);
assert(*m.begin() == Emplaceable());
r = m.emplace(2, 3.5);
assert(r.second);
assert(r.first == next(m.begin()));
assert(m.size() == 2);
assert(*r.first == Emplaceable(2, 3.5));
r = m.emplace(2, 3.5);
assert(!r.second);
assert(r.first == next(m.begin()));
assert(m.size() == 2);
assert(*r.first == Emplaceable(2, 3.5));
}
{
typedef std::set<int> M;
typedef std::pair<M::iterator, bool> R;
M m;
R r = m.emplace(M::value_type(2));
assert(r.second);
assert(r.first == m.begin());
assert(m.size() == 1);
assert(*r.first == 2);
}
{
typedef std::set<int, std::less<int>, min_allocator<int>> M;
typedef std::pair<M::iterator, bool> R;
M m;
R r = m.emplace(M::value_type(2));
assert(r.second);
assert(r.first == m.begin());
assert(m.size() == 1);
assert(*r.first == 2);
}
return 0;
}
