Magic-Mirror/llvm-capstone
1
0
Fork 0
mirror of https://github.com/capstone-engine/llvm-capstone.git synced 2025-02-28 22:37:18 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

Support allocators with explicit conversion constructors. Fixes bug #29000

Browse Source 
llvm-svn: 278904
This commit is contained in:
Marshall Clow 2016-08-17 05:58:40 +00:00
parent 14f383e9c4
commit 2a10c960fa
41 changed files with 1026 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
libcxx/include/map
View File

@ -873,7 +873,7 @@ public:
_LIBCPP_INLINE_VISIBILITY
explicit map(const key_compare& __comp, const allocator_type& __a)
: __tree_(__vc(__comp), __a) {}
: __tree_(__vc(__comp), typename __base::allocator_type(__a)) {}
template <class _InputIterator>
_LIBCPP_INLINE_VISIBILITY
@ -888,7 +888,7 @@ public:
_LIBCPP_INLINE_VISIBILITY
map(_InputIterator __f, _InputIterator __l,
const key_compare& __comp, const allocator_type& __a)
: __tree_(__vc(__comp), __a)
: __tree_(__vc(__comp), typename __base::allocator_type(__a))
{
insert(__f, __l);
}
@ -955,7 +955,7 @@ public:
_LIBCPP_INLINE_VISIBILITY
map(initializer_list<value_type> __il, const key_compare& __comp, const allocator_type& __a)
: __tree_(__vc(__comp), __a)
: __tree_(__vc(__comp), typename __base::allocator_type(__a))
{
insert(__il.begin(), __il.end());
}
@ -977,13 +977,13 @@ public:
_LIBCPP_INLINE_VISIBILITY
explicit map(const allocator_type& __a)
: __tree_(__a)
: __tree_(typename __base::allocator_type(__a))
{
}
_LIBCPP_INLINE_VISIBILITY
map(const map& __m, const allocator_type& __a)
: __tree_(__m.__tree_.value_comp(), __a)
: __tree_(__m.__tree_.value_comp(), typename __base::allocator_type(__a))
{
insert(__m.begin(), __m.end());
}
@ -1034,7 +1034,7 @@ public:
const mapped_type& at(const key_type& __k) const;
_LIBCPP_INLINE_VISIBILITY
allocator_type get_allocator() const _NOEXCEPT {return __tree_.__alloc();}
allocator_type get_allocator() const _NOEXCEPT {return allocator_type(__tree_.__alloc());}
_LIBCPP_INLINE_VISIBILITY
key_compare key_comp() const {return __tree_.value_comp().key_comp();}
_LIBCPP_INLINE_VISIBILITY
@ -1367,7 +1367,7 @@ map<_Key, _Tp, _Compare, _Allocator>::__find_equal_key(__node_base_pointer& __pa
template <class _Key, class _Tp, class _Compare, class _Allocator>
map<_Key, _Tp, _Compare, _Allocator>::map(map&& __m, const allocator_type& __a)
: __tree_(_VSTD::move(__m.__tree_), __a)
: __tree_(_VSTD::move(__m.__tree_), typename __base::allocator_type(__a))
{
if (__a != __m.get_allocator())
{
@ -1599,7 +1599,7 @@ public:
_LIBCPP_INLINE_VISIBILITY
explicit multimap(const key_compare& __comp, const allocator_type& __a)
: __tree_(__vc(__comp), __a) {}
: __tree_(__vc(__comp), typename __base::allocator_type(__a)) {}
template <class _InputIterator>
_LIBCPP_INLINE_VISIBILITY
@ -1614,7 +1614,7 @@ public:
_LIBCPP_INLINE_VISIBILITY
multimap(_InputIterator __f, _InputIterator __l,
const key_compare& __comp, const allocator_type& __a)
: __tree_(__vc(__comp), __a)
: __tree_(__vc(__comp), typename __base::allocator_type(__a))
{
insert(__f, __l);
}
@ -1682,7 +1682,7 @@ public:
_LIBCPP_INLINE_VISIBILITY
multimap(initializer_list<value_type> __il, const key_compare& __comp, const allocator_type& __a)
: __tree_(__vc(__comp), __a)
: __tree_(__vc(__comp), typename __base::allocator_type(__a))
{
insert(__il.begin(), __il.end());
}
@ -1704,13 +1704,13 @@ public:
_LIBCPP_INLINE_VISIBILITY
explicit multimap(const allocator_type& __a)
: __tree_(__a)
: __tree_(typename __base::allocator_type(__a))
{
}
_LIBCPP_INLINE_VISIBILITY
multimap(const multimap& __m, const allocator_type& __a)
: __tree_(__m.__tree_.value_comp(), __a)
: __tree_(__m.__tree_.value_comp(), typename __base::allocator_type(__a))
{
insert(__m.begin(), __m.end());
}
@ -1752,7 +1752,7 @@ public:
size_type max_size() const _NOEXCEPT {return __tree_.max_size();}
_LIBCPP_INLINE_VISIBILITY
allocator_type get_allocator() const _NOEXCEPT {return __tree_.__alloc();}
allocator_type get_allocator() const _NOEXCEPT {return allocator_type(__tree_.__alloc());}
_LIBCPP_INLINE_VISIBILITY
key_compare key_comp() const {return __tree_.value_comp().key_comp();}
_LIBCPP_INLINE_VISIBILITY
@ -1923,7 +1923,7 @@ private:
#ifndef _LIBCPP_CXX03_LANG
template <class _Key, class _Tp, class _Compare, class _Allocator>
multimap<_Key, _Tp, _Compare, _Allocator>::multimap(multimap&& __m, const allocator_type& __a)
: __tree_(_VSTD::move(__m.__tree_), __a)
: __tree_(_VSTD::move(__m.__tree_), typename __base::allocator_type(__a))
{
if (__a != __m.get_allocator())
{

24
libcxx/include/unordered_map
View File

@ -1185,7 +1185,7 @@ template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
size_type __n, const hasher& __hf, const key_equal& __eql,
const allocator_type& __a)
: __table_(__hf, __eql, __a)
: __table_(__hf, __eql, typename __table::allocator_type(__a))
{
#if _LIBCPP_DEBUG_LEVEL >= 2
__get_db()->__insert_c(this);
@ -1197,7 +1197,7 @@ template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
inline
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
const allocator_type& __a)
: __table_(__a)
: __table_(typename __table::allocator_type(__a))
{
#if _LIBCPP_DEBUG_LEVEL >= 2
__get_db()->__insert_c(this);
@ -1234,7 +1234,7 @@ template <class _InputIterator>
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
_InputIterator __first, _InputIterator __last, size_type __n,
const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
: __table_(__hf, __eql, __a)
: __table_(__hf, __eql, typename __table::allocator_type(__a))
{
#if _LIBCPP_DEBUG_LEVEL >= 2
__get_db()->__insert_c(this);
@ -1258,7 +1258,7 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
const unordered_map& __u, const allocator_type& __a)
: __table_(__u.__table_, __a)
: __table_(__u.__table_, typename __table::allocator_type(__a))
{
#if _LIBCPP_DEBUG_LEVEL >= 2
__get_db()->__insert_c(this);
@ -1285,7 +1285,7 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
unordered_map&& __u, const allocator_type& __a)
: __table_(_VSTD::move(__u.__table_), __a)
: __table_(_VSTD::move(__u.__table_), typename __table::allocator_type(__a))
{
#if _LIBCPP_DEBUG_LEVEL >= 2
__get_db()->__insert_c(this);
@ -1335,7 +1335,7 @@ template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
initializer_list<value_type> __il, size_type __n, const hasher& __hf,
const key_equal& __eql, const allocator_type& __a)
: __table_(__hf, __eql, __a)
: __table_(__hf, __eql, typename __table::allocator_type(__a))
{
#if _LIBCPP_DEBUG_LEVEL >= 2
__get_db()->__insert_c(this);
@ -1820,7 +1820,7 @@ template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
size_type __n, const hasher& __hf, const key_equal& __eql,
const allocator_type& __a)
: __table_(__hf, __eql, __a)
: __table_(__hf, __eql, typename __table::allocator_type(__a))
{
#if _LIBCPP_DEBUG_LEVEL >= 2
__get_db()->__insert_c(this);
@ -1858,7 +1858,7 @@ template <class _InputIterator>
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
_InputIterator __first, _InputIterator __last, size_type __n,
const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
: __table_(__hf, __eql, __a)
: __table_(__hf, __eql, typename __table::allocator_type(__a))
{
#if _LIBCPP_DEBUG_LEVEL >= 2
__get_db()->__insert_c(this);
@ -1871,7 +1871,7 @@ template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
inline
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
const allocator_type& __a)
: __table_(__a)
: __table_(typename __table::allocator_type(__a))
{
#if _LIBCPP_DEBUG_LEVEL >= 2
__get_db()->__insert_c(this);
@ -1893,7 +1893,7 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
const unordered_multimap& __u, const allocator_type& __a)
: __table_(__u.__table_, __a)
: __table_(__u.__table_, typename __table::allocator_type(__a))
{
#if _LIBCPP_DEBUG_LEVEL >= 2
__get_db()->__insert_c(this);
@ -1920,7 +1920,7 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
unordered_multimap&& __u, const allocator_type& __a)
: __table_(_VSTD::move(__u.__table_), __a)
: __table_(_VSTD::move(__u.__table_), typename __table::allocator_type(__a))
{
#if _LIBCPP_DEBUG_LEVEL >= 2
__get_db()->__insert_c(this);
@ -1972,7 +1972,7 @@ template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
initializer_list<value_type> __il, size_type __n, const hasher& __hf,
const key_equal& __eql, const allocator_type& __a)
: __table_(__hf, __eql, __a)
: __table_(__hf, __eql, typename __table::allocator_type(__a))
{
#if _LIBCPP_DEBUG_LEVEL >= 2
__get_db()->__insert_c(this);

8
libcxx/test/std/containers/associative/map/map.cons/alloc.pass.cpp
View File

@ -38,5 +38,13 @@ int main()
assert(m.begin() == m.end());
assert(m.get_allocator() == A());
}
{
typedef std::less<int> C;
typedef explicit_allocator<std::pair<const int, double> > A;
std::map<int, double, C, A> m(A{});
assert(m.empty());
assert(m.begin() == m.end());
assert(m.get_allocator() == A());
}
#endif
}

9
libcxx/test/std/containers/associative/map/map.cons/compare_alloc.pass.cpp
View File

@ -41,5 +41,14 @@ int main()
assert(m.key_comp() == C(4));
assert(m.get_allocator() == A());
}
{
typedef test_compare<std::less<int> > C;
typedef explicit_allocator<std::pair<const int, double> > A;
std::map<int, double, C, A> m(C(4), A{});
assert(m.empty());
assert(m.begin() == m.end());
assert(m.key_comp() == C(4));
assert(m.get_allocator() == A{});
}
#endif
}

34
libcxx/test/std/containers/associative/map/map.cons/copy_alloc.pass.cpp
View File

@ -83,6 +83,40 @@ int main()
assert(*next(m.begin()) == V(2, 1));
assert(*next(m.begin(), 2) == V(3, 1));
assert(mo.get_allocator() == A());
assert(mo.key_comp() == C(5));
assert(mo.size() == 3);
assert(distance(mo.begin(), mo.end()) == 3);
assert(*mo.begin() == V(1, 1));
assert(*next(mo.begin()) == V(2, 1));
assert(*next(mo.begin(), 2) == V(3, 1));
}
{
typedef std::pair<const int, double> V;
V ar[] =
{
V(1, 1),
V(1, 1.5),
V(1, 2),
V(2, 1),
V(2, 1.5),
V(2, 2),
V(3, 1),
V(3, 1.5),
V(3, 2),
};
typedef test_compare<std::less<int> > C;
typedef explicit_allocator<V> A;
std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A{});
std::map<int, double, C, A> m(mo, A{});
assert(m.get_allocator() == A());
assert(m.key_comp() == C(5));
assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == V(1, 1));
assert(*next(m.begin()) == V(2, 1));
assert(*next(m.begin(), 2) == V(3, 1));
assert(mo.get_allocator() == A());
assert(mo.key_comp() == C(5));
assert(mo.size() == 3);

14
libcxx/test/std/containers/associative/map/map.cons/default.pass.cpp
View File

@ -32,6 +32,20 @@ int main()
assert(m.begin() == m.end());
}
{
typedef explicit_allocator<std::pair<const int, double>> A;
{
std::map<int, double, std::less<int>, A> m;
assert(m.empty());
assert(m.begin() == m.end());
}
{
A a;
std::map<int, double, std::less<int>, A> m(a);
assert(m.empty());
assert(m.begin() == m.end());
}
}
{
std::map<int, double> m = {};
assert(m.empty());
assert(m.begin() == m.end());

26
libcxx/test/std/containers/associative/map/map.cons/initializer_list_compare_alloc.pass.cpp
View File

@ -69,7 +69,7 @@ int main()
assert(m.key_comp() == C(3));
assert(m.get_allocator() == A());
}
#if _LIBCPP_STD_VER > 11
#if TEST_STD_VER > 11
{
typedef std::pair<const int, double> V;
typedef min_allocator<V> A;
@ -95,6 +95,30 @@ int main()
assert(m.get_allocator() == a);
}
#endif
{
typedef std::pair<const int, double> V;
typedef explicit_allocator<V> A;
typedef test_compare<std::less<int> > C;
A a;
std::map<int, double, C, A> m({
{1, 1},
{1, 1.5},
{1, 2},
{2, 1},
{2, 1.5},
{2, 2},
{3, 1},
{3, 1.5},
{3, 2}
}, C(3), a);
assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == V(1, 1));
assert(*next(m.begin()) == V(2, 1));
assert(*next(m.begin(), 2) == V(3, 1));
assert(m.key_comp() == C(3));
assert(m.get_allocator() == a);
}
#endif
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
}

16
libcxx/test/std/containers/associative/map/map.cons/iter_iter_comp_alloc.pass.cpp
View File

@ -90,6 +90,7 @@ int main()
V(3, 1.5),
V(3, 2),
};
{
typedef std::pair<const int, double> V;
typedef min_allocator<V> A;
typedef test_compare<std::less<int> > C;
@ -103,6 +104,21 @@ int main()
assert(*next(m.begin(), 2) == V(3, 1));
assert(m.get_allocator() == a);
}
{
typedef std::pair<const int, double> V;
typedef explicit_allocator<V> A;
typedef test_compare<std::less<int> > C;
A a;
std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), a );
assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == V(1, 1));
assert(*next(m.begin()) == V(2, 1));
assert(*next(m.begin(), 2) == V(3, 1));
assert(m.get_allocator() == a);
}
}
#endif
#endif
}

39
libcxx/test/std/containers/associative/map/map.cons/move_alloc.pass.cpp
View File

@ -229,6 +229,45 @@ int main()
assert(m3.key_comp() == C(5));
assert(m1.empty());
}
{
typedef std::pair<MoveOnly, MoveOnly> V;
typedef std::pair<const MoveOnly, MoveOnly> VC;
typedef test_compare<std::less<MoveOnly> > C;
typedef explicit_allocator<VC> A;
typedef std::map<MoveOnly, MoveOnly, C, A> M;
typedef std::move_iterator<V*> I;
V a1[] =
{
V(1, 1),
V(1, 2),
V(1, 3),
V(2, 1),
V(2, 2),
V(2, 3),
V(3, 1),
V(3, 2),
V(3, 3)
};
M m1(I(a1), I(a1+sizeof(a1)/sizeof(a1[0])), C(5), A{});
V a2[] =
{
V(1, 1),
V(1, 2),
V(1, 3),
V(2, 1),
V(2, 2),
V(2, 3),
V(3, 1),
V(3, 2),
V(3, 3)
};
M m2(I(a2), I(a2+sizeof(a2)/sizeof(a2[0])), C(5), A{});
M m3(std::move(m1), A{});
assert(m3 == m2);
assert(m3.get_allocator() == A{});
assert(m3.key_comp() == C(5));
assert(m1.empty());
}
#endif
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}

8
libcxx/test/std/containers/associative/multimap/multimap.cons/alloc.pass.cpp
View File

@ -38,5 +38,13 @@ int main()
assert(m.begin() == m.end());
assert(m.get_allocator() == A());
}
{
typedef std::less<int> C;
typedef explicit_allocator<std::pair<const int, double> > A;
std::multimap<int, double, C, A> m(A{});
assert(m.empty());
assert(m.begin() == m.end());
assert(m.get_allocator() == A{});
}
#endif
}

9
libcxx/test/std/containers/associative/multimap/multimap.cons/compare_alloc.pass.cpp
View File

@ -41,5 +41,14 @@ int main()
assert(m.key_comp() == C(4));
assert(m.get_allocator() == A());
}
{
typedef test_compare<std::less<int> > C;
typedef explicit_allocator<std::pair<const int, double> > A;
std::multimap<int, double, C, A> m(C(4), A{});
assert(m.empty());
assert(m.begin() == m.end());
assert(m.key_comp() == C(4));
assert(m.get_allocator() == A{});
}
#endif
}

25
libcxx/test/std/containers/associative/multimap/multimap.cons/copy_alloc.pass.cpp
View File

@ -73,5 +73,30 @@ int main()
assert(mo.get_allocator() == A());
assert(mo.key_comp() == C(5));
}
{
typedef std::pair<const int, double> V;
V ar[] =
{
V(1, 1),
V(1, 1.5),
V(1, 2),
V(2, 1),
V(2, 1.5),
V(2, 2),
V(3, 1),
V(3, 1.5),
V(3, 2),
};
typedef test_compare<std::less<int> > C;
typedef explicit_allocator<V> A;
std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A{});
std::multimap<int, double, C, A> m(mo, A{});
assert(m == mo);
assert(m.get_allocator() == A{});
assert(m.key_comp() == C(5));
assert(mo.get_allocator() == A{});
assert(mo.key_comp() == C(5));
}
#endif
}

14
libcxx/test/std/containers/associative/multimap/multimap.cons/default.pass.cpp
View File

@ -32,6 +32,20 @@ int main()
assert(m.begin() == m.end());
}
{
typedef explicit_allocator<std::pair<const int, double>> A;
{
std::multimap<int, double, std::less<int>, A> m;
assert(m.empty());
assert(m.begin() == m.end());
}
{
A a;
std::multimap<int, double, std::less<int>, A> m(a);
assert(m.empty());
assert(m.begin() == m.end());
}
}
{
std::multimap<int, double> m = {};
assert(m.empty());
assert(m.begin() == m.end());

36
libcxx/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare_alloc.pass.cpp
View File

@ -92,7 +92,7 @@ int main()
assert(m.key_comp() == Cmp(4));
assert(m.get_allocator() == A());
}
#if _LIBCPP_STD_VER > 11
#if TEST_STD_VER > 11
{
typedef test_compare<std::less<int> > C;
typedef std::pair<const int, double> V;
@ -125,5 +125,39 @@ int main()
assert(m.get_allocator() == a);
}
#endif
{
typedef test_compare<std::less<int> > Cmp;
typedef explicit_allocator<std::pair<const int, double> > A;
typedef std::multimap<int, double, Cmp, A> C;
typedef C::value_type V;
C m(
{
{1, 1},
{1, 1.5},
{1, 2},
{2, 1},
{2, 1.5},
{2, 2},
{3, 1},
{3, 1.5},
{3, 2}
},
Cmp(4), A{}
);
assert(m.size() == 9);
assert(distance(m.begin(), m.end()) == 9);
C::const_iterator i = m.cbegin();
assert(*i == V(1, 1));
assert(*++i == V(1, 1.5));
assert(*++i == V(1, 2));
assert(*++i == V(2, 1));
assert(*++i == V(2, 1.5));
assert(*++i == V(2, 2));
assert(*++i == V(3, 1));
assert(*++i == V(3, 1.5));
assert(*++i == V(3, 2));
assert(m.key_comp() == Cmp(4));
assert(m.get_allocator() == A{});
}
#endif
}

31
libcxx/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp_alloc.pass.cpp
View File

@ -87,5 +87,36 @@ int main()
assert(*next(m.begin(), 7) == V(3, 1.5));
assert(*next(m.begin(), 8) == V(3, 2));
}
{
typedef std::pair<const int, double> V;
V ar[] =
{
V(1, 1),
V(1, 1.5),
V(1, 2),
V(2, 1),
V(2, 1.5),
V(2, 2),
V(3, 1),
V(3, 1.5),
V(3, 2),
};
typedef test_compare<std::less<int> > C;
typedef explicit_allocator<V> A;
std::multimap<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A{});
assert(m.get_allocator() == A{});
assert(m.key_comp() == C(5));
assert(m.size() == 9);
assert(distance(m.begin(), m.end()) == 9);
assert(*m.begin() == V(1, 1));
assert(*next(m.begin()) == V(1, 1.5));
assert(*next(m.begin(), 2) == V(1, 2));
assert(*next(m.begin(), 3) == V(2, 1));
assert(*next(m.begin(), 4) == V(2, 1.5));
assert(*next(m.begin(), 5) == V(2, 2));
assert(*next(m.begin(), 6) == V(3, 1));
assert(*next(m.begin(), 7) == V(3, 1.5));
assert(*next(m.begin(), 8) == V(3, 2));
}
#endif
}

39
libcxx/test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp
View File

@ -229,6 +229,45 @@ int main()
assert(m3.key_comp() == C(5));
assert(m1.empty());
}
{
typedef std::pair<MoveOnly, MoveOnly> V;
typedef std::pair<const MoveOnly, MoveOnly> VC;
typedef test_compare<std::less<MoveOnly> > C;
typedef explicit_allocator<VC> A;
typedef std::multimap<MoveOnly, MoveOnly, C, A> M;
typedef std::move_iterator<V*> I;
V a1[] =
{
V(1, 1),
V(1, 2),
V(1, 3),
V(2, 1),
V(2, 2),
V(2, 3),
V(3, 1),
V(3, 2),
V(3, 3)
};
M m1(I(a1), I(a1+sizeof(a1)/sizeof(a1[0])), C(5), A{});
V a2[] =
{
V(1, 1),
V(1, 2),
V(1, 3),
V(2, 1),
V(2, 2),
V(2, 3),
V(3, 1),
V(3, 2),
V(3, 3)
};
M m2(I(a2), I(a2+sizeof(a2)/sizeof(a2[0])), C(5), A{});
M m3(std::move(m1), A{});
assert(m3 == m2);
assert(m3.get_allocator() == A{});
assert(m3.key_comp() == C(5));
assert(m1.empty());
}
#endif
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}

14
libcxx/test/std/containers/associative/multiset/multiset.cons/default.pass.cpp
View File

@ -32,6 +32,20 @@ int main()
assert(m.begin() == m.end());
}
{
typedef explicit_allocator<int> A;
{
std::multiset<int, std::less<int>, A> m;
assert(m.empty());
assert(m.begin() == m.end());
}
{
A a;
std::multiset<int, std::less<int>, A> m(a);
assert(m.empty());
assert(m.begin() == m.end());
}
}
{
std::multiset<int> m = {};
assert(m.empty());
assert(m.begin() == m.end());

14
libcxx/test/std/containers/associative/set/set.cons/default.pass.cpp
View File

@ -32,6 +32,20 @@ int main()
assert(m.begin() == m.end());
}
{
typedef explicit_allocator<int> A;
{
std::set<int, std::less<int>, A> m;
assert(m.empty());
assert(m.begin() == m.end());
}
{
A a;
std::set<int, std::less<int>, A> m(a);
assert(m.empty());
assert(m.begin() == m.end());
}
}
{
std::set<int> m = {};
assert(m.empty());
assert(m.begin() == m.end());

2
libcxx/test/std/containers/sequences/deque/deque.cons/alloc.pass.cpp
View File

@ -34,5 +34,7 @@ int main()
#if TEST_STD_VER >= 11
test<int>(min_allocator<int>());
test<NotConstructible>(min_allocator<NotConstructible>{});
test<int>(explicit_allocator<int>());
test<NotConstructible>(explicit_allocator<NotConstructible>{});
#endif
}

8
libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.pass.cpp
View File

@ -37,5 +37,13 @@ int main()
assert(c.get_allocator() == A());
assert(c.empty());
}
{
typedef explicit_allocator<NotConstructible> A;
typedef A::value_type T;
typedef std::forward_list<T, A> C;
C c(A{});
assert(c.get_allocator() == A());
assert(c.empty());
}
#endif
}

10
libcxx/test/std/containers/sequences/list/list.cons/default.pass.cpp
View File

@ -54,5 +54,15 @@ int main()
assert(l.size() == 0);
assert(std::distance(l.begin(), l.end()) == 0);
}
{
std::list<int, explicit_allocator<int>> l;
assert(l.size() == 0);
assert(std::distance(l.begin(), l.end()) == 0);
}
{
std::list<int, explicit_allocator<int>> l((explicit_allocator<int>()));
assert(l.size() == 0);
assert(std::distance(l.begin(), l.end()) == 0);
}
#endif
}

4
libcxx/test/std/containers/sequences/vector.bool/construct_default.pass.cpp
View File

@ -66,5 +66,9 @@ int main()
test0<std::vector<bool, min_allocator<bool>> >();
test1<std::vector<bool, min_allocator<bool> > >(min_allocator<bool>());
}
{
test0<std::vector<bool, explicit_allocator<bool>> >();
test1<std::vector<bool, explicit_allocator<bool> > >(explicit_allocator<bool>());
}
#endif
}

12
libcxx/test/std/containers/sequences/vector/vector.cons/construct_default.pass.cpp
View File

@ -86,5 +86,17 @@ int main()
std::vector<int, min_allocator<int> > v;
assert(v.empty());
}
{
test0<std::vector<int, explicit_allocator<int>> >();
test0<std::vector<NotConstructible, explicit_allocator<NotConstructible>> >();
test1<std::vector<int, explicit_allocator<int> > >(explicit_allocator<int>{});
test1<std::vector<NotConstructible, explicit_allocator<NotConstructible> > >
(explicit_allocator<NotConstructible>{});
}
{
std::vector<int, explicit_allocator<int> > v;
assert(v.empty());
}
#endif
}

20
libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp
View File

@ -66,7 +66,25 @@ int main()
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
}
#if _LIBCPP_STD_VER > 11
{
typedef explicit_allocator<std::pair<const NotConstructible, NotConstructible>> A;
typedef std::unordered_map<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >,
A
> C;
C c(A{});
LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
assert(c.get_allocator() == A{});
assert(c.size() == 0);
assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
}
#if TEST_STD_VER > 11
{
typedef NotConstructible T;
typedef test_allocator<std::pair<const T, T>> A;

39
libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp
View File

@ -108,5 +108,44 @@ int main()
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
{
typedef explicit_allocator<std::pair<const int, std::string>> A;
typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >,
A
> C;
typedef std::pair<int, std::string> P;
P a[] =
{
P(1, "one"),
P(2, "two"),
P(3, "three"),
P(4, "four"),
P(1, "four"),
P(2, "four"),
};
C c0(a, a + sizeof(a)/sizeof(a[0]),
7,
test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9),
A{}
);
C c(c0, A{});
LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4);
assert(c.at(1) == "one");
assert(c.at(2) == "two");
assert(c.at(3) == "three");
assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A{});
assert(!c.empty());
assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#endif
}

33
libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp
View File

@ -66,6 +66,39 @@ int main()
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
}
{
typedef explicit_allocator<std::pair<const NotConstructible, NotConstructible>> A;
typedef std::unordered_map<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >,
A
> C;
{
C c;
LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
assert(c.get_allocator() == A());
assert(c.size() == 0);
assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
}
{
A a;
C c(a);
LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
assert(c.get_allocator() == a);
assert(c.size() == 0);
assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
}
}
{
std::unordered_map<int, int> c = {};
LIBCPP_ASSERT(c.bucket_count() == 0);

36
libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp
View File

@ -104,6 +104,42 @@ int main()
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
{
typedef explicit_allocator<std::pair<const int, std::string>> A;
typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >,
A
> C;
typedef std::pair<int, std::string> P;
C c({
P(1, "one"),
P(2, "two"),
P(3, "three"),
P(4, "four"),
P(1, "four"),
P(2, "four"),
},
7,
test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9),
A{}
);
LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4);
assert(c.at(1) == "one");
assert(c.at(2) == "two");
assert(c.at(3) == "three");
assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A{});
assert(!c.empty());
assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#endif
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
}

41
libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp
View File

@ -152,6 +152,47 @@ int main()
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c0.empty());
}
{
typedef std::pair<int, std::string> P;
typedef explicit_allocator<std::pair<const int, std::string>> A;
typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >,
A
> C;
P a[] =
{
P(1, "one"),
P(2, "two"),
P(3, "three"),
P(4, "four"),
P(1, "four"),
P(2, "four"),
};
C c0(a, a + sizeof(a)/sizeof(a[0]),
7,
test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9),
A{}
);
C c(std::move(c0), A{});
LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4);
assert(c.at(1) == "one");
assert(c.at(2) == "two");
assert(c.at(3) == "three");
assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A{});
assert(!c.empty());
assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c0.empty());
}
#endif

38
libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp
View File

@ -111,5 +111,43 @@ int main()
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
{
typedef explicit_allocator<std::pair<const int, std::string>> A;
typedef std::unordered_map<int, std::string,
test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >,
A
> C;
typedef std::pair<int, std::string> P;
P a[] =
{
P(1, "one"),
P(2, "two"),
P(3, "three"),
P(4, "four"),
P(1, "four"),
P(2, "four"),
};
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7,
test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9),
A{}
);
LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 4);
assert(c.at(1) == "one");
assert(c.at(2) == "two");
assert(c.at(3) == "three");
assert(c.at(4) == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A{});
assert(!c.empty());
assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#endif
}

22
libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp
View File

@ -74,5 +74,27 @@ int main()
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
}
{
typedef explicit_allocator<std::pair<const NotConstructible, NotConstructible> > A;
typedef std::unordered_map<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >,
A
> C;
C c(7,
test_hash<std::hash<NotConstructible> >(8),
test_compare<std::equal_to<NotConstructible> >(9),
A{}
);
LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
assert(c.get_allocator() == A{});
assert(c.size() == 0);
assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
}
#endif
}

18
libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp
View File

@ -66,6 +66,24 @@ int main()
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
}
{
typedef explicit_allocator<std::pair<const NotConstructible, NotConstructible>> A;
typedef std::unordered_multimap<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >,
A
> C;
C c(A{});
LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
assert(c.get_allocator() == A{});
assert(c.size() == 0);
assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
}
#if _LIBCPP_STD_VER > 11
{
typedef NotConstructible T;

53
libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp
View File

@ -136,5 +136,58 @@ int main()
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
{
typedef explicit_allocator<std::pair<const int, std::string>> A;
typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >,
A
> C;
typedef std::pair<int, std::string> P;
P a[] =
{
P(1, "one"),
P(2, "two"),
P(3, "three"),
P(4, "four"),
P(1, "four"),
P(2, "four"),
};
C c0(a, a + sizeof(a)/sizeof(a[0]),
7,
test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9),
A{}
);
C c(c0, A{});
LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6);
C::const_iterator i = c.cbegin();
assert(i->first == 1);
assert(i->second == "one");
++i;
assert(i->first == 1);
assert(i->second == "four");
++i;
assert(i->first == 2);
assert(i->second == "two");
++i;
assert(i->first == 2);
assert(i->second == "four");
++i;
assert(i->first == 3);
assert(i->second == "three");
++i;
assert(i->first == 4);
assert(i->second == "four");
assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A{});
assert(!c.empty());
assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#endif
}

33
libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp
View File

@ -66,6 +66,39 @@ int main()
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
}
{
typedef explicit_allocator<std::pair<const NotConstructible, NotConstructible>> A;
typedef std::unordered_multimap<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >,
A
> C;
{
C c;
LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
assert(c.get_allocator() == A());
assert(c.size() == 0);
assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
}
{
A a;
C c(a);
LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
assert(c.get_allocator() == a);
assert(c.size() == 0);
assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
}
}
{
std::unordered_multimap<int, int> c = {};
LIBCPP_ASSERT(c.bucket_count() == 0);

59
libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp
View File

@ -148,6 +148,65 @@ int main()
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
}
{
typedef explicit_allocator<std::pair<const int, std::string>> A;
typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >,
A
> C;
typedef std::pair<int, std::string> P;
C c({
P(1, "one"),
P(2, "two"),
P(3, "three"),
P(4, "four"),
P(1, "four"),
P(2, "four"),
},
7,
test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9),
A{}
);
LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
C::const_iterator i = eq.first;
assert(i->first == 1);
assert(i->second == "one");
++i;
assert(i->first == 1);
assert(i->second == "four");
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
i = eq.first;
assert(i->first == 2);
assert(i->second == "two");
++i;
assert(i->first == 2);
assert(i->second == "four");
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
assert(std::distance(eq.first, eq.second) == 1);
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A{});
}
#endif
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
}

64
libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp
View File

@ -223,6 +223,70 @@ int main()
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
assert(c0.empty());
}
{
typedef std::pair<int, std::string> P;
typedef explicit_allocator<std::pair<const int, std::string>> A;
typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >,
A
> C;
P a[] =
{
P(1, "one"),
P(2, "two"),
P(3, "three"),
P(4, "four"),
P(1, "four"),
P(2, "four"),
};
C c0(a, a + sizeof(a)/sizeof(a[0]),
7,
test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9),
A{}
);
C c(std::move(c0), A());
LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
C::const_iterator i = eq.first;
assert(i->first == 1);
assert(i->second == "one");
++i;
assert(i->first == 1);
assert(i->second == "four");
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
i = eq.first;
assert(i->first == 2);
assert(i->second == "two");
++i;
assert(i->first == 2);
assert(i->second == "four");
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
assert(std::distance(eq.first, eq.second) == 1);
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A{});
assert(c0.empty());
}
#endif

61
libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
View File

@ -155,5 +155,66 @@ int main()
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
}
{
typedef explicit_allocator<std::pair<const int, std::string>> A;
typedef std::unordered_multimap<int, std::string,
test_hash<std::hash<int> >,
test_compare<std::equal_to<int> >,
A
> C;
typedef std::pair<int, std::string> P;
P a[] =
{
P(1, "one"),
P(2, "two"),
P(3, "three"),
P(4, "four"),
P(1, "four"),
P(2, "four"),
};
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7,
test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9),
A{}
);
LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
Eq eq = c.equal_range(1);
assert(std::distance(eq.first, eq.second) == 2);
C::const_iterator i = eq.first;
assert(i->first == 1);
assert(i->second == "one");
++i;
assert(i->first == 1);
assert(i->second == "four");
eq = c.equal_range(2);
assert(std::distance(eq.first, eq.second) == 2);
i = eq.first;
assert(i->first == 2);
assert(i->second == "two");
++i;
assert(i->first == 2);
assert(i->second == "four");
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 1);
i = eq.first;
assert(i->first == 3);
assert(i->second == "three");
eq = c.equal_range(4);
assert(std::distance(eq.first, eq.second) == 1);
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A{});;
}
#endif
}

22
libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp
View File

@ -74,5 +74,27 @@ int main()
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
}
{
typedef explicit_allocator<std::pair<const NotConstructible, NotConstructible> > A;
typedef std::unordered_multimap<NotConstructible, NotConstructible,
test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >,
A
> C;
C c(7,
test_hash<std::hash<NotConstructible> >(8),
test_compare<std::equal_to<NotConstructible> >(9),
A{}
);
LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
assert(c.get_allocator() == A{});
assert(c.size() == 0);
assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
}
#endif
}

33
libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp
View File

@ -62,6 +62,39 @@ int main()
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
}
{
typedef explicit_allocator<NotConstructible> A;
typedef std::unordered_multiset<NotConstructible,
test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >,
A
> C;
{
C c;
LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
assert(c.get_allocator() == A());
assert(c.size() == 0);
assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
}
{
A a;
C c(a);
LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
assert(c.get_allocator() == a);
assert(c.size() == 0);
assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
}
}
{
std::unordered_multiset<int> c = {};
LIBCPP_ASSERT(c.bucket_count() == 0);

33
libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp
View File

@ -62,6 +62,39 @@ int main()
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
}
{
typedef explicit_allocator<NotConstructible> A;
typedef std::unordered_set<NotConstructible,
test_hash<std::hash<NotConstructible> >,
test_compare<std::equal_to<NotConstructible> >,
A
> C;
{
C c;
LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
assert(c.get_allocator() == A());
assert(c.size() == 0);
assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
}
{
A a;
C c(a);
LIBCPP_ASSERT(c.bucket_count() == 0);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
assert(c.get_allocator() == a);
assert(c.size() == 0);
assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
}
}
{
std::unordered_set<int> c = {};
LIBCPP_ASSERT(c.bucket_count() == 0);

1
libcxx/test/std/strings/basic.string/string.cons/alloc.pass.cpp
View File

@ -91,5 +91,6 @@ int main()
test<std::basic_string<char, std::char_traits<char>, test_allocator<char> > >();
#if TEST_STD_VER >= 11
test2<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
test2<std::basic_string<char, std::char_traits<char>, explicit_allocator<char> > >();
#endif
}

25
libcxx/test/support/min_allocator.h
View File

@ -340,6 +340,31 @@ public:
friend bool operator!=(min_allocator x, min_allocator y) {return !(x == y);}
};
template <class T>
class explicit_allocator
{
public:
typedef T value_type;
explicit_allocator() TEST_NOEXCEPT {}
template <class U>
explicit explicit_allocator(explicit_allocator<U>) TEST_NOEXCEPT {}
T* allocate(std::size_t n)
{
return static_cast<T*>(::operator new(n*sizeof(T)));
}
void deallocate(T* p, std::size_t)
{
return ::operator delete(static_cast<void*>(p));
}
friend bool operator==(explicit_allocator, explicit_allocator) {return true;}
friend bool operator!=(explicit_allocator x, explicit_allocator y) {return !(x == y);}
};
#endif // TEST_STD_VER >= 11
#endif // MIN_ALLOCATOR_H