diff options
Diffstat (limited to 'test/std/containers/unord/unord.map')
79 files changed, 8761 insertions, 0 deletions
diff --git a/test/std/containers/unord/unord.map/bucket.pass.cpp b/test/std/containers/unord/unord.map/bucket.pass.cpp new file mode 100644 index 0000000000000..6837294e35bcc --- /dev/null +++ b/test/std/containers/unord/unord.map/bucket.pass.cpp @@ -0,0 +1,77 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// size_type bucket(const key_type& __k) const; + +#ifdef _LIBCPP_DEBUG +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) +#endif + +#include <unordered_map> +#include <string> +#include <cassert> + +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<int, std::string> 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"), + }; + const C c(std::begin(a), std::end(a)); + size_t bc = c.bucket_count(); + assert(bc >= 5); + for (size_t i = 0; i < 13; ++i) + assert(c.bucket(i) == i % bc); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> 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"), + }; + const C c(std::begin(a), std::end(a)); + size_t bc = c.bucket_count(); + assert(bc >= 5); + for (size_t i = 0; i < 13; ++i) + assert(c.bucket(i) == i % bc); + } +#endif +#if _LIBCPP_DEBUG_LEVEL >= 1 + { + typedef std::unordered_map<int, std::string> C; + C c; + C::size_type i = c.bucket(3); + assert(false); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/bucket_count.pass.cpp b/test/std/containers/unord/unord.map/bucket_count.pass.cpp new file mode 100644 index 0000000000000..d3e80d86379a1 --- /dev/null +++ b/test/std/containers/unord/unord.map/bucket_count.pass.cpp @@ -0,0 +1,80 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// size_type bucket_count() const; + +#include <unordered_map> +#include <string> +#include <cassert> + +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<int, std::string> C; + typedef C::const_iterator I; + typedef std::pair<int, std::string> P; + const C c; + assert(c.bucket_count() == 0); + } + { + typedef std::unordered_map<int, std::string> C; + typedef C::const_iterator I; + typedef std::pair<int, std::string> P; + P a[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + const C c(std::begin(a), std::end(a)); + assert(c.bucket_count() >= 11); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> C; + typedef C::const_iterator I; + typedef std::pair<int, std::string> P; + const C c; + assert(c.bucket_count() == 0); + } + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> C; + typedef C::const_iterator I; + typedef std::pair<int, std::string> P; + P a[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + const C c(std::begin(a), std::end(a)); + assert(c.bucket_count() >= 11); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/bucket_size.pass.cpp b/test/std/containers/unord/unord.map/bucket_size.pass.cpp new file mode 100644 index 0000000000000..f3ab8fff4e436 --- /dev/null +++ b/test/std/containers/unord/unord.map/bucket_size.pass.cpp @@ -0,0 +1,81 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// size_type bucket_size(size_type n) const + +#ifdef _LIBCPP_DEBUG +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) +#endif + +#include <unordered_map> +#include <string> +#include <cassert> + +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<int, std::string> 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"), + }; + const C c(std::begin(a), std::end(a)); + assert(c.bucket_count() >= 5); + assert(c.bucket_size(0) == 0); + assert(c.bucket_size(1) == 1); + assert(c.bucket_size(2) == 1); + assert(c.bucket_size(3) == 1); + assert(c.bucket_size(4) == 1); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> 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"), + }; + const C c(std::begin(a), std::end(a)); + assert(c.bucket_count() >= 5); + assert(c.bucket_size(0) == 0); + assert(c.bucket_size(1) == 1); + assert(c.bucket_size(2) == 1); + assert(c.bucket_size(3) == 1); + assert(c.bucket_size(4) == 1); + } +#endif +#if _LIBCPP_DEBUG_LEVEL >= 1 + { + typedef std::unordered_map<int, std::string> C; + C c; + C::size_type i = c.bucket_size(3); + assert(false); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/compare.pass.cpp b/test/std/containers/unord/unord.map/compare.pass.cpp new file mode 100644 index 0000000000000..8979a3a34ad69 --- /dev/null +++ b/test/std/containers/unord/unord.map/compare.pass.cpp @@ -0,0 +1,42 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// http://llvm.org/bugs/show_bug.cgi?id=16538 +// http://llvm.org/bugs/show_bug.cgi?id=16549 + +#include <unordered_map> + +struct Key { + template <typename T> Key(const T&) {} + bool operator== (const Key&) const { return true; } +}; + +namespace std +{ + template <> + struct hash<Key> + { + size_t operator()(Key const &) const {return 0;} + }; +} + +int +main() +{ + std::unordered_map<Key, int>::iterator it = + std::unordered_map<Key, int>().find(Key(0)); + std::pair<std::unordered_map<Key, int>::iterator, bool> result = + std::unordered_map<Key, int>().insert(std::make_pair(Key(0), 0)); +} diff --git a/test/std/containers/unord/unord.map/count.pass.cpp b/test/std/containers/unord/unord.map/count.pass.cpp new file mode 100644 index 0000000000000..50abb53464ec8 --- /dev/null +++ b/test/std/containers/unord/unord.map/count.pass.cpp @@ -0,0 +1,65 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// size_type count(const key_type& k) const; + +#include <unordered_map> +#include <string> +#include <cassert> + +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<int, std::string> C; + typedef std::pair<int, std::string> P; + P a[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + const C c(std::begin(a), std::end(a)); + assert(c.count(30) == 1); + assert(c.count(5) == 0); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> C; + typedef std::pair<int, std::string> P; + P a[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + const C c(std::begin(a), std::end(a)); + assert(c.count(30) == 1); + assert(c.count(5) == 0); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/db_iterators_7.pass.cpp b/test/std/containers/unord/unord.map/db_iterators_7.pass.cpp new file mode 100644 index 0000000000000..b8db0a35ffc3e --- /dev/null +++ b/test/std/containers/unord/unord.map/db_iterators_7.pass.cpp @@ -0,0 +1,60 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// Increment iterator past end. + +#if _LIBCPP_DEBUG >= 1 + +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) + +#include <unordered_map> +#include <string> +#include <cassert> +#include <iterator> +#include <exception> +#include <cstdlib> + +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<int, std::string> C; + C c; + c.insert(std::make_pair(1, "one")); + C::iterator i = c.begin(); + ++i; + assert(i == c.end()); + ++i; + assert(false); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> C; + C c; + c.insert(std::make_pair(1, "one")); + C::iterator i = c.begin(); + ++i; + assert(i == c.end()); + ++i; + assert(false); + } +#endif +} + +#else + +int main() +{ +} + +#endif diff --git a/test/std/containers/unord/unord.map/db_iterators_8.pass.cpp b/test/std/containers/unord/unord.map/db_iterators_8.pass.cpp new file mode 100644 index 0000000000000..c923dd77862e6 --- /dev/null +++ b/test/std/containers/unord/unord.map/db_iterators_8.pass.cpp @@ -0,0 +1,56 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// Dereference non-dereferenceable iterator. + +#if _LIBCPP_DEBUG >= 1 + +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) + +#include <unordered_map> +#include <string> +#include <cassert> +#include <iterator> +#include <exception> +#include <cstdlib> + +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<int, std::string> C; + C c; + c.insert(std::make_pair(1, "one")); + C::iterator i = c.end(); + C::value_type j = *i; + assert(false); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> C; + C c; + c.insert(std::make_pair(1, "one")); + C::iterator i = c.end(); + C::value_type j = *i; + assert(false); + } +#endif +} + +#else + +int main() +{ +} + +#endif diff --git a/test/std/containers/unord/unord.map/db_local_iterators_7.pass.cpp b/test/std/containers/unord/unord.map/db_local_iterators_7.pass.cpp new file mode 100644 index 0000000000000..fa1886bfff189 --- /dev/null +++ b/test/std/containers/unord/unord.map/db_local_iterators_7.pass.cpp @@ -0,0 +1,57 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// Increment local_iterator past end. + +#if _LIBCPP_DEBUG >= 1 + +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) + +#include <unordered_map> +#include <string> +#include <cassert> +#include <iterator> +#include <exception> +#include <cstdlib> + +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<int, std::string> C; + C c(1); + C::local_iterator i = c.begin(0); + ++i; + ++i; + assert(false); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> C; + C c(1); + C::local_iterator i = c.begin(0); + ++i; + ++i; + assert(false); + } +#endif + +} + +#else + +int main() +{ +} + +#endif diff --git a/test/std/containers/unord/unord.map/db_local_iterators_8.pass.cpp b/test/std/containers/unord/unord.map/db_local_iterators_8.pass.cpp new file mode 100644 index 0000000000000..4b071cad7b473 --- /dev/null +++ b/test/std/containers/unord/unord.map/db_local_iterators_8.pass.cpp @@ -0,0 +1,54 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// Dereference non-dereferenceable iterator. + +#if _LIBCPP_DEBUG >= 1 + +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) + +#include <unordered_map> +#include <string> +#include <cassert> +#include <iterator> +#include <exception> +#include <cstdlib> + +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<int, std::string> C; + C c(1); + C::local_iterator i = c.end(0); + C::value_type j = *i; + assert(false); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> C; + C c(1); + C::local_iterator i = c.end(0); + C::value_type j = *i; + assert(false); + } +#endif +} + +#else + +int main() +{ +} + +#endif diff --git a/test/std/containers/unord/unord.map/eq.pass.cpp b/test/std/containers/unord/unord.map/eq.pass.cpp new file mode 100644 index 0000000000000..9258378eb09a3 --- /dev/null +++ b/test/std/containers/unord/unord.map/eq.pass.cpp @@ -0,0 +1,163 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash, class Pred, class Alloc> +// bool +// operator==(const unordered_map<Key, T, Hash, Pred, Alloc>& x, +// const unordered_map<Key, T, Hash, Pred, Alloc>& y); +// +// template <class Key, class T, class Hash, class Pred, class Alloc> +// bool +// operator!=(const unordered_map<Key, T, Hash, Pred, Alloc>& x, +// const unordered_map<Key, T, Hash, Pred, Alloc>& y); + +#include <unordered_map> +#include <string> +#include <cassert> + +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<int, std::string> C; + typedef std::pair<int, std::string> P; + P a[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + const C c1(std::begin(a), std::end(a)); + const C c2; + assert(!(c1 == c2)); + assert( (c1 != c2)); + } + { + typedef std::unordered_map<int, std::string> C; + typedef std::pair<int, std::string> P; + P a[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + const C c1(std::begin(a), std::end(a)); + const C c2 = c1; + assert( (c1 == c2)); + assert(!(c1 != c2)); + } + { + typedef std::unordered_map<int, std::string> C; + typedef std::pair<int, std::string> P; + P a[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + C c1(std::begin(a), std::end(a)); + C c2 = c1; + c2.rehash(30); + assert( (c1 == c2)); + assert(!(c1 != c2)); + c2.insert(P(90, "ninety")); + assert(!(c1 == c2)); + assert( (c1 != c2)); + c1.insert(P(90, "ninety")); + assert( (c1 == c2)); + assert(!(c1 != c2)); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> C; + typedef std::pair<int, std::string> P; + P a[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + const C c1(std::begin(a), std::end(a)); + const C c2; + assert(!(c1 == c2)); + assert( (c1 != c2)); + } + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> C; + typedef std::pair<int, std::string> P; + P a[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + const C c1(std::begin(a), std::end(a)); + const C c2 = c1; + assert( (c1 == c2)); + assert(!(c1 != c2)); + } + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> C; + typedef std::pair<int, std::string> P; + P a[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + C c1(std::begin(a), std::end(a)); + C c2 = c1; + c2.rehash(30); + assert( (c1 == c2)); + assert(!(c1 != c2)); + c2.insert(P(90, "ninety")); + assert(!(c1 == c2)); + assert( (c1 != c2)); + c1.insert(P(90, "ninety")); + assert( (c1 == c2)); + assert(!(c1 != c2)); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/equal_range_const.pass.cpp b/test/std/containers/unord/unord.map/equal_range_const.pass.cpp new file mode 100644 index 0000000000000..fe166c965b165 --- /dev/null +++ b/test/std/containers/unord/unord.map/equal_range_const.pass.cpp @@ -0,0 +1,75 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// pair<const_iterator, const_iterator> equal_range(const key_type& k) const; + +#include <unordered_map> +#include <string> +#include <cassert> + +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<int, std::string> C; + typedef C::const_iterator I; + typedef std::pair<int, std::string> P; + P a[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + const C c(std::begin(a), std::end(a)); + std::pair<I, I> r = c.equal_range(30); + assert(std::distance(r.first, r.second) == 1); + assert(r.first->first == 30); + assert(r.first->second == "thirty"); + r = c.equal_range(5); + assert(std::distance(r.first, r.second) == 0); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> C; + typedef C::const_iterator I; + typedef std::pair<int, std::string> P; + P a[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + const C c(std::begin(a), std::end(a)); + std::pair<I, I> r = c.equal_range(30); + assert(std::distance(r.first, r.second) == 1); + assert(r.first->first == 30); + assert(r.first->second == "thirty"); + r = c.equal_range(5); + assert(std::distance(r.first, r.second) == 0); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/equal_range_non_const.pass.cpp b/test/std/containers/unord/unord.map/equal_range_non_const.pass.cpp new file mode 100644 index 0000000000000..9e8d1a9644c52 --- /dev/null +++ b/test/std/containers/unord/unord.map/equal_range_non_const.pass.cpp @@ -0,0 +1,75 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// pair<iterator, iterator> equal_range(const key_type& k); + +#include <unordered_map> +#include <string> +#include <cassert> + +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<int, std::string> C; + typedef C::iterator I; + typedef std::pair<int, std::string> P; + P a[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + C c(std::begin(a), std::end(a)); + std::pair<I, I> r = c.equal_range(30); + assert(std::distance(r.first, r.second) == 1); + assert(r.first->first == 30); + assert(r.first->second == "thirty"); + r = c.equal_range(5); + assert(std::distance(r.first, r.second) == 0); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> C; + typedef C::iterator I; + typedef std::pair<int, std::string> P; + P a[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + C c(std::begin(a), std::end(a)); + std::pair<I, I> r = c.equal_range(30); + assert(std::distance(r.first, r.second) == 1); + assert(r.first->first == 30); + assert(r.first->second == "thirty"); + r = c.equal_range(5); + assert(std::distance(r.first, r.second) == 0); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/find_const.pass.cpp b/test/std/containers/unord/unord.map/find_const.pass.cpp new file mode 100644 index 0000000000000..120efa3061b1b --- /dev/null +++ b/test/std/containers/unord/unord.map/find_const.pass.cpp @@ -0,0 +1,71 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// const_iterator find(const key_type& k) const; + +#include <unordered_map> +#include <string> +#include <cassert> + +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<int, std::string> C; + typedef std::pair<int, std::string> P; + P a[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + const C c(std::begin(a), std::end(a)); + C::const_iterator i = c.find(30); + assert(i->first == 30); + assert(i->second == "thirty"); + i = c.find(5); + assert(i == c.cend()); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> C; + typedef std::pair<int, std::string> P; + P a[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + const C c(std::begin(a), std::end(a)); + C::const_iterator i = c.find(30); + assert(i->first == 30); + assert(i->second == "thirty"); + i = c.find(5); + assert(i == c.cend()); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/find_non_const.pass.cpp b/test/std/containers/unord/unord.map/find_non_const.pass.cpp new file mode 100644 index 0000000000000..7582a796dd7c5 --- /dev/null +++ b/test/std/containers/unord/unord.map/find_non_const.pass.cpp @@ -0,0 +1,71 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// iterator find(const key_type& k); + +#include <unordered_map> +#include <string> +#include <cassert> + +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<int, std::string> C; + typedef std::pair<int, std::string> P; + P a[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + C c(std::begin(a), std::end(a)); + C::iterator i = c.find(30); + assert(i->first == 30); + assert(i->second == "thirty"); + i = c.find(5); + assert(i == c.end()); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> C; + typedef std::pair<int, std::string> P; + P a[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + C c(std::begin(a), std::end(a)); + C::iterator i = c.find(30); + assert(i->first == 30); + assert(i->second == "thirty"); + i = c.find(5); + assert(i == c.end()); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/iterators.pass.cpp b/test/std/containers/unord/unord.map/iterators.pass.cpp new file mode 100644 index 0000000000000..47b1d73866840 --- /dev/null +++ b/test/std/containers/unord/unord.map/iterators.pass.cpp @@ -0,0 +1,128 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// iterator begin() {return __table_.begin();} +// iterator end() {return __table_.end();} +// const_iterator begin() const {return __table_.begin();} +// const_iterator end() const {return __table_.end();} +// const_iterator cbegin() const {return __table_.begin();} +// const_iterator cend() const {return __table_.end();} + +#include <unordered_map> +#include <string> +#include <cassert> + +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<int, std::string> 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(a, a + sizeof(a)/sizeof(a[0])); + assert(c.bucket_count() >= 5); + assert(c.size() == 4); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + C::iterator i; + } + { + typedef std::unordered_map<int, std::string> 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"), + }; + const C c(a, a + sizeof(a)/sizeof(a[0])); + assert(c.bucket_count() >= 5); + assert(c.size() == 4); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + C::const_iterator i; + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> 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(a, a + sizeof(a)/sizeof(a[0])); + assert(c.bucket_count() >= 5); + assert(c.size() == 4); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + C::iterator i; + } + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> 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"), + }; + const C c(a, a + sizeof(a)/sizeof(a[0])); + assert(c.bucket_count() >= 5); + assert(c.size() == 4); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + C::const_iterator i; + } +#endif +#if _LIBCPP_STD_VER > 11 + { // N3644 testing + typedef std::unordered_map<int,double> C; + C::iterator ii1{}, ii2{}; + C::iterator ii4 = ii1; + C::const_iterator cii{}; + assert ( ii1 == ii2 ); + assert ( ii1 == ii4 ); + + assert (!(ii1 != ii2 )); + + assert ( (ii1 == cii )); + assert ( (cii == ii1 )); + assert (!(ii1 != cii )); + assert (!(cii != ii1 )); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/load_factor.pass.cpp b/test/std/containers/unord/unord.map/load_factor.pass.cpp new file mode 100644 index 0000000000000..472e41abf6e0e --- /dev/null +++ b/test/std/containers/unord/unord.map/load_factor.pass.cpp @@ -0,0 +1,77 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// float load_factor() const + +#include <unordered_map> +#include <string> +#include <cassert> +#include <cfloat> + +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<int, std::string> C; + typedef std::pair<int, std::string> P; + P a[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + const C c(std::begin(a), std::end(a)); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + } + { + typedef std::unordered_map<int, std::string> C; + typedef std::pair<int, std::string> P; + const C c; + assert(c.load_factor() == 0); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> C; + typedef std::pair<int, std::string> P; + P a[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + const C c(std::begin(a), std::end(a)); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + } + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> C; + typedef std::pair<int, std::string> P; + const C c; + assert(c.load_factor() == 0); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/local_iterators.pass.cpp b/test/std/containers/unord/unord.map/local_iterators.pass.cpp new file mode 100644 index 0000000000000..770b1ace7a3e2 --- /dev/null +++ b/test/std/containers/unord/unord.map/local_iterators.pass.cpp @@ -0,0 +1,421 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// local_iterator begin (size_type n); +// local_iterator end (size_type n); +// const_local_iterator begin (size_type n) const; +// const_local_iterator end (size_type n) const; +// const_local_iterator cbegin(size_type n) const; +// const_local_iterator cend (size_type n) const; + +#include <unordered_map> +#include <string> +#include <cassert> + +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<int, std::string> C; + typedef std::pair<int, std::string> P; + typedef C::local_iterator I; + P a[] = + { + P(1, "one"), + P(2, "two"), + P(3, "three"), + P(4, "four"), + P(1, "four"), + P(2, "four"), + }; + C c(a, a + sizeof(a)/sizeof(a[0])); + assert(c.bucket_count() >= 5); + C::size_type b = c.bucket(0); + I i = c.begin(b); + I j = c.end(b); + assert(std::distance(i, j) == 0); + + b = c.bucket(1); + i = c.begin(b); + j = c.end(b); + assert(std::distance(i, j) == 1); + assert(i->first == 1); + assert(i->second == "one"); + + b = c.bucket(2); + i = c.begin(b); + j = c.end(b); + assert(std::distance(i, j) == 1); + assert(i->first == 2); + assert(i->second == "two"); + + b = c.bucket(3); + i = c.begin(b); + j = c.end(b); + assert(std::distance(i, j) == 1); + assert(i->first == 3); + assert(i->second == "three"); + + b = c.bucket(4); + i = c.begin(b); + j = c.end(b); + assert(std::distance(i, j) == 1); + assert(i->first == 4); + assert(i->second == "four"); + } + { + typedef std::unordered_map<int, std::string> C; + typedef std::pair<int, std::string> P; + typedef C::const_local_iterator I; + P a[] = + { + P(1, "one"), + P(2, "two"), + P(3, "three"), + P(4, "four"), + P(1, "four"), + P(2, "four"), + }; + const C c(a, a + sizeof(a)/sizeof(a[0])); + assert(c.bucket_count() >= 5); + C::size_type b = c.bucket(0); + I i = c.begin(b); + I j = c.end(b); + assert(std::distance(i, j) == 0); + + b = c.bucket(1); + i = c.begin(b); + j = c.end(b); + assert(std::distance(i, j) == 1); + assert(i->first == 1); + assert(i->second == "one"); + + b = c.bucket(2); + i = c.begin(b); + j = c.end(b); + assert(std::distance(i, j) == 1); + assert(i->first == 2); + assert(i->second == "two"); + + b = c.bucket(3); + i = c.begin(b); + j = c.end(b); + assert(std::distance(i, j) == 1); + assert(i->first == 3); + assert(i->second == "three"); + + b = c.bucket(4); + i = c.begin(b); + j = c.end(b); + assert(std::distance(i, j) == 1); + assert(i->first == 4); + assert(i->second == "four"); + } + { + typedef std::unordered_map<int, std::string> C; + typedef std::pair<int, std::string> P; + typedef C::const_local_iterator I; + P a[] = + { + P(1, "one"), + P(2, "two"), + P(3, "three"), + P(4, "four"), + P(1, "four"), + P(2, "four"), + }; + C c(a, a + sizeof(a)/sizeof(a[0])); + assert(c.bucket_count() >= 5); + C::size_type b = c.bucket(0); + I i = c.cbegin(b); + I j = c.cend(b); + assert(std::distance(i, j) == 0); + + b = c.bucket(1); + i = c.cbegin(b); + j = c.cend(b); + assert(std::distance(i, j) == 1); + assert(i->first == 1); + assert(i->second == "one"); + + b = c.bucket(2); + i = c.cbegin(b); + j = c.cend(b); + assert(std::distance(i, j) == 1); + assert(i->first == 2); + assert(i->second == "two"); + + b = c.bucket(3); + i = c.cbegin(b); + j = c.cend(b); + assert(std::distance(i, j) == 1); + assert(i->first == 3); + assert(i->second == "three"); + + b = c.bucket(4); + i = c.cbegin(b); + j = c.cend(b); + assert(std::distance(i, j) == 1); + assert(i->first == 4); + assert(i->second == "four"); + } + { + typedef std::unordered_map<int, std::string> C; + typedef std::pair<int, std::string> P; + typedef C::const_local_iterator I; + P a[] = + { + P(1, "one"), + P(2, "two"), + P(3, "three"), + P(4, "four"), + P(1, "four"), + P(2, "four"), + }; + const C c(a, a + sizeof(a)/sizeof(a[0])); + assert(c.bucket_count() >= 5); + C::size_type b = c.bucket(0); + I i = c.cbegin(b); + I j = c.cend(b); + assert(std::distance(i, j) == 0); + + b = c.bucket(1); + i = c.cbegin(b); + j = c.cend(b); + assert(std::distance(i, j) == 1); + assert(i->first == 1); + assert(i->second == "one"); + + b = c.bucket(2); + i = c.cbegin(b); + j = c.cend(b); + assert(std::distance(i, j) == 1); + assert(i->first == 2); + assert(i->second == "two"); + + b = c.bucket(3); + i = c.cbegin(b); + j = c.cend(b); + assert(std::distance(i, j) == 1); + assert(i->first == 3); + assert(i->second == "three"); + + b = c.bucket(4); + i = c.cbegin(b); + j = c.cend(b); + assert(std::distance(i, j) == 1); + assert(i->first == 4); + assert(i->second == "four"); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> C; + typedef std::pair<int, std::string> P; + typedef C::local_iterator I; + P a[] = + { + P(1, "one"), + P(2, "two"), + P(3, "three"), + P(4, "four"), + P(1, "four"), + P(2, "four"), + }; + C c(a, a + sizeof(a)/sizeof(a[0])); + assert(c.bucket_count() >= 5); + C::size_type b = c.bucket(0); + I i = c.begin(b); + I j = c.end(b); + assert(std::distance(i, j) == 0); + + b = c.bucket(1); + i = c.begin(b); + j = c.end(b); + assert(std::distance(i, j) == 1); + assert(i->first == 1); + assert(i->second == "one"); + + b = c.bucket(2); + i = c.begin(b); + j = c.end(b); + assert(std::distance(i, j) == 1); + assert(i->first == 2); + assert(i->second == "two"); + + b = c.bucket(3); + i = c.begin(b); + j = c.end(b); + assert(std::distance(i, j) == 1); + assert(i->first == 3); + assert(i->second == "three"); + + b = c.bucket(4); + i = c.begin(b); + j = c.end(b); + assert(std::distance(i, j) == 1); + assert(i->first == 4); + assert(i->second == "four"); + } + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> C; + typedef std::pair<int, std::string> P; + typedef C::const_local_iterator I; + P a[] = + { + P(1, "one"), + P(2, "two"), + P(3, "three"), + P(4, "four"), + P(1, "four"), + P(2, "four"), + }; + const C c(a, a + sizeof(a)/sizeof(a[0])); + assert(c.bucket_count() >= 5); + C::size_type b = c.bucket(0); + I i = c.begin(b); + I j = c.end(b); + assert(std::distance(i, j) == 0); + + b = c.bucket(1); + i = c.begin(b); + j = c.end(b); + assert(std::distance(i, j) == 1); + assert(i->first == 1); + assert(i->second == "one"); + + b = c.bucket(2); + i = c.begin(b); + j = c.end(b); + assert(std::distance(i, j) == 1); + assert(i->first == 2); + assert(i->second == "two"); + + b = c.bucket(3); + i = c.begin(b); + j = c.end(b); + assert(std::distance(i, j) == 1); + assert(i->first == 3); + assert(i->second == "three"); + + b = c.bucket(4); + i = c.begin(b); + j = c.end(b); + assert(std::distance(i, j) == 1); + assert(i->first == 4); + assert(i->second == "four"); + } + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> C; + typedef std::pair<int, std::string> P; + typedef C::const_local_iterator I; + P a[] = + { + P(1, "one"), + P(2, "two"), + P(3, "three"), + P(4, "four"), + P(1, "four"), + P(2, "four"), + }; + C c(a, a + sizeof(a)/sizeof(a[0])); + assert(c.bucket_count() >= 5); + C::size_type b = c.bucket(0); + I i = c.cbegin(b); + I j = c.cend(b); + assert(std::distance(i, j) == 0); + + b = c.bucket(1); + i = c.cbegin(b); + j = c.cend(b); + assert(std::distance(i, j) == 1); + assert(i->first == 1); + assert(i->second == "one"); + + b = c.bucket(2); + i = c.cbegin(b); + j = c.cend(b); + assert(std::distance(i, j) == 1); + assert(i->first == 2); + assert(i->second == "two"); + + b = c.bucket(3); + i = c.cbegin(b); + j = c.cend(b); + assert(std::distance(i, j) == 1); + assert(i->first == 3); + assert(i->second == "three"); + + b = c.bucket(4); + i = c.cbegin(b); + j = c.cend(b); + assert(std::distance(i, j) == 1); + assert(i->first == 4); + assert(i->second == "four"); + } + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> C; + typedef std::pair<int, std::string> P; + typedef C::const_local_iterator I; + P a[] = + { + P(1, "one"), + P(2, "two"), + P(3, "three"), + P(4, "four"), + P(1, "four"), + P(2, "four"), + }; + const C c(a, a + sizeof(a)/sizeof(a[0])); + assert(c.bucket_count() >= 5); + C::size_type b = c.bucket(0); + I i = c.cbegin(b); + I j = c.cend(b); + assert(std::distance(i, j) == 0); + + b = c.bucket(1); + i = c.cbegin(b); + j = c.cend(b); + assert(std::distance(i, j) == 1); + assert(i->first == 1); + assert(i->second == "one"); + + b = c.bucket(2); + i = c.cbegin(b); + j = c.cend(b); + assert(std::distance(i, j) == 1); + assert(i->first == 2); + assert(i->second == "two"); + + b = c.bucket(3); + i = c.cbegin(b); + j = c.cend(b); + assert(std::distance(i, j) == 1); + assert(i->first == 3); + assert(i->second == "three"); + + b = c.bucket(4); + i = c.cbegin(b); + j = c.cend(b); + assert(std::distance(i, j) == 1); + assert(i->first == 4); + assert(i->second == "four"); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/max_bucket_count.pass.cpp b/test/std/containers/unord/unord.map/max_bucket_count.pass.cpp new file mode 100644 index 0000000000000..b4ca8eb044725 --- /dev/null +++ b/test/std/containers/unord/unord.map/max_bucket_count.pass.cpp @@ -0,0 +1,43 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// size_type max_bucket_count() const; + +#include <unordered_map> +#include <string> +#include <cassert> + +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<int, std::string> C; + typedef C::const_iterator I; + typedef std::pair<int, std::string> P; + const C c; + assert(c.max_bucket_count() > 0); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> C; + typedef C::const_iterator I; + typedef std::pair<int, std::string> P; + const C c; + assert(c.max_bucket_count() > 0); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/max_load_factor.pass.cpp b/test/std/containers/unord/unord.map/max_load_factor.pass.cpp new file mode 100644 index 0000000000000..69fd70d2a1723 --- /dev/null +++ b/test/std/containers/unord/unord.map/max_load_factor.pass.cpp @@ -0,0 +1,71 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// float max_load_factor() const; +// void max_load_factor(float mlf); + +#ifdef _LIBCPP_DEBUG +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) +#endif + +#include <unordered_map> +#include <string> +#include <cassert> + +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<int, std::string> C; + typedef std::pair<int, std::string> P; + const C c; + assert(c.max_load_factor() == 1); + } + { + typedef std::unordered_map<int, std::string> C; + typedef std::pair<int, std::string> P; + C c; + assert(c.max_load_factor() == 1); + c.max_load_factor(2.5); + assert(c.max_load_factor() == 2.5); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> C; + typedef std::pair<int, std::string> P; + const C c; + assert(c.max_load_factor() == 1); + } + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> C; + typedef std::pair<int, std::string> P; + C c; + assert(c.max_load_factor() == 1); + c.max_load_factor(2.5); + assert(c.max_load_factor() == 2.5); + } +#endif +#if _LIBCPP_DEBUG_LEVEL >= 1 + { + typedef std::unordered_map<int, std::string> C; + C c; + c.max_load_factor(0); + assert(false); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/max_size.pass.cpp b/test/std/containers/unord/unord.map/max_size.pass.cpp new file mode 100644 index 0000000000000..7d5ae3a8e46d7 --- /dev/null +++ b/test/std/containers/unord/unord.map/max_size.pass.cpp @@ -0,0 +1,36 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// size_type max_size() const; + +#include <unordered_map> +#include <cassert> + +#include "min_allocator.h" + +int main() +{ + { + std::unordered_map<int, int> u; + assert(u.max_size() > 0); + } +#if __cplusplus >= 201103L + { + std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, int>>> u; + assert(u.max_size() > 0); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/rehash.pass.cpp b/test/std/containers/unord/unord.map/rehash.pass.cpp new file mode 100644 index 0000000000000..84ece23555112 --- /dev/null +++ b/test/std/containers/unord/unord.map/rehash.pass.cpp @@ -0,0 +1,91 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// void rehash(size_type n); + +#include <unordered_map> +#include <string> +#include <cassert> + +#include "min_allocator.h" + +template <class C> +void test(const C& c) +{ + assert(c.size() == 4); + assert(c.at(1) == "one"); + assert(c.at(2) == "two"); + assert(c.at(3) == "three"); + assert(c.at(4) == "four"); +} + +int main() +{ + { + typedef std::unordered_map<int, std::string> 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(a, a + sizeof(a)/sizeof(a[0])); + test(c); + assert(c.bucket_count() >= 5); + c.rehash(3); + assert(c.bucket_count() == 5); + test(c); + c.max_load_factor(2); + c.rehash(3); + assert(c.bucket_count() == 3); + test(c); + c.rehash(31); + assert(c.bucket_count() == 31); + test(c); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> 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(a, a + sizeof(a)/sizeof(a[0])); + test(c); + assert(c.bucket_count() >= 5); + c.rehash(3); + assert(c.bucket_count() == 5); + test(c); + c.max_load_factor(2); + c.rehash(3); + assert(c.bucket_count() == 3); + test(c); + c.rehash(31); + assert(c.bucket_count() == 31); + test(c); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/reserve.pass.cpp b/test/std/containers/unord/unord.map/reserve.pass.cpp new file mode 100644 index 0000000000000..48667cdc7f928 --- /dev/null +++ b/test/std/containers/unord/unord.map/reserve.pass.cpp @@ -0,0 +1,91 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// void reserve(size_type n); + +#include <unordered_map> +#include <string> +#include <cassert> + +#include "min_allocator.h" + +template <class C> +void test(const C& c) +{ + assert(c.size() == 4); + assert(c.at(1) == "one"); + assert(c.at(2) == "two"); + assert(c.at(3) == "three"); + assert(c.at(4) == "four"); +} + +int main() +{ + { + typedef std::unordered_map<int, std::string> 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(a, a + sizeof(a)/sizeof(a[0])); + test(c); + assert(c.bucket_count() >= 5); + c.reserve(3); + assert(c.bucket_count() == 5); + test(c); + c.max_load_factor(2); + c.reserve(3); + assert(c.bucket_count() >= 2); + test(c); + c.reserve(31); + assert(c.bucket_count() >= 16); + test(c); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> 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(a, a + sizeof(a)/sizeof(a[0])); + test(c); + assert(c.bucket_count() >= 5); + c.reserve(3); + assert(c.bucket_count() == 5); + test(c); + c.max_load_factor(2); + c.reserve(3); + assert(c.bucket_count() >= 2); + test(c); + c.reserve(31); + assert(c.bucket_count() >= 16); + test(c); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/swap_member.pass.cpp b/test/std/containers/unord/unord.map/swap_member.pass.cpp new file mode 100644 index 0000000000000..8ab1eb6211b88 --- /dev/null +++ b/test/std/containers/unord/unord.map/swap_member.pass.cpp @@ -0,0 +1,572 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// void swap(unordered_map& __u); + +#include <unordered_map> +#include <string> +#include <cassert> + +#include "../../test_compare.h" +#include "../../test_hash.h" +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ + { + typedef test_hash<std::hash<int> > Hash; + typedef test_compare<std::equal_to<int> > Compare; + typedef test_allocator<std::pair<const int, std::string> > Alloc; + typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; + typedef std::pair<int, std::string> P; + C c1(0, Hash(1), Compare(1), Alloc(1)); + C c2(0, Hash(2), Compare(2), Alloc(2)); + c2.max_load_factor(2); + c1.swap(c2); + + assert(c1.bucket_count() == 0); + assert(c1.size() == 0); + assert(c1.hash_function() == Hash(2)); + assert(c1.key_eq() == Compare(2)); + assert(c1.get_allocator() == Alloc(1)); + assert(std::distance(c1.begin(), c1.end()) == c1.size()); + assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); + assert(c1.max_load_factor() == 2); + + assert(c2.bucket_count() == 0); + assert(c2.size() == 0); + assert(c2.hash_function() == Hash(1)); + assert(c2.key_eq() == Compare(1)); + assert(c2.get_allocator() == Alloc(2)); + assert(std::distance(c2.begin(), c2.end()) == c2.size()); + assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); + assert(c2.max_load_factor() == 1); + } + { + typedef test_hash<std::hash<int> > Hash; + typedef test_compare<std::equal_to<int> > Compare; + typedef test_allocator<std::pair<const int, std::string> > Alloc; + typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; + typedef std::pair<int, std::string> P; + P a2[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + C c1(0, Hash(1), Compare(1), Alloc(1)); + C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); + c2.max_load_factor(2); + c1.swap(c2); + + assert(c1.bucket_count() >= 11); + assert(c1.size() == 8); + assert(c1.at(10) == "ten"); + assert(c1.at(20) == "twenty"); + assert(c1.at(30) == "thirty"); + assert(c1.at(40) == "forty"); + assert(c1.at(50) == "fifty"); + assert(c1.at(60) == "sixty"); + assert(c1.at(70) == "seventy"); + assert(c1.at(80) == "eighty"); + assert(c1.hash_function() == Hash(2)); + assert(c1.key_eq() == Compare(2)); + assert(c1.get_allocator() == Alloc(1)); + assert(std::distance(c1.begin(), c1.end()) == c1.size()); + assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); + assert(c1.max_load_factor() == 2); + + assert(c2.bucket_count() == 0); + assert(c2.size() == 0); + assert(c2.hash_function() == Hash(1)); + assert(c2.key_eq() == Compare(1)); + assert(c2.get_allocator() == Alloc(2)); + assert(std::distance(c2.begin(), c2.end()) == c2.size()); + assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); + assert(c2.max_load_factor() == 1); + } + { + typedef test_hash<std::hash<int> > Hash; + typedef test_compare<std::equal_to<int> > Compare; + typedef test_allocator<std::pair<const int, std::string> > Alloc; + typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; + typedef std::pair<int, std::string> P; + P a1[] = + { + P(1, "one"), + P(2, "two"), + P(3, "three"), + P(4, "four"), + P(1, "four"), + P(2, "four"), + }; + C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); + C c2(0, Hash(2), Compare(2), Alloc(2)); + c2.max_load_factor(2); + c1.swap(c2); + + assert(c1.bucket_count() == 0); + assert(c1.size() == 0); + assert(c1.hash_function() == Hash(2)); + assert(c1.key_eq() == Compare(2)); + assert(c1.get_allocator() == Alloc(1)); + assert(std::distance(c1.begin(), c1.end()) == c1.size()); + assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); + assert(c1.max_load_factor() == 2); + + assert(c2.bucket_count() >= 5); + assert(c2.size() == 4); + assert(c2.at(1) == "one"); + assert(c2.at(2) == "two"); + assert(c2.at(3) == "three"); + assert(c2.at(4) == "four"); + assert(c2.hash_function() == Hash(1)); + assert(c2.key_eq() == Compare(1)); + assert(c2.get_allocator() == Alloc(2)); + assert(std::distance(c2.begin(), c2.end()) == c2.size()); + assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); + assert(c2.max_load_factor() == 1); + } + { + typedef test_hash<std::hash<int> > Hash; + typedef test_compare<std::equal_to<int> > Compare; + typedef test_allocator<std::pair<const int, std::string> > Alloc; + typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; + typedef std::pair<int, std::string> P; + P a1[] = + { + P(1, "one"), + P(2, "two"), + P(3, "three"), + P(4, "four"), + P(1, "four"), + P(2, "four"), + }; + P a2[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); + C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); + c2.max_load_factor(2); + c1.swap(c2); + + assert(c1.bucket_count() >= 11); + assert(c1.size() == 8); + assert(c1.at(10) == "ten"); + assert(c1.at(20) == "twenty"); + assert(c1.at(30) == "thirty"); + assert(c1.at(40) == "forty"); + assert(c1.at(50) == "fifty"); + assert(c1.at(60) == "sixty"); + assert(c1.at(70) == "seventy"); + assert(c1.at(80) == "eighty"); + assert(c1.hash_function() == Hash(2)); + assert(c1.key_eq() == Compare(2)); + assert(c1.get_allocator() == Alloc(1)); + assert(std::distance(c1.begin(), c1.end()) == c1.size()); + assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); + assert(c1.max_load_factor() == 2); + + assert(c2.bucket_count() >= 5); + assert(c2.size() == 4); + assert(c2.at(1) == "one"); + assert(c2.at(2) == "two"); + assert(c2.at(3) == "three"); + assert(c2.at(4) == "four"); + assert(c2.hash_function() == Hash(1)); + assert(c2.key_eq() == Compare(1)); + assert(c2.get_allocator() == Alloc(2)); + assert(std::distance(c2.begin(), c2.end()) == c2.size()); + assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); + assert(c2.max_load_factor() == 1); + } + + { + typedef test_hash<std::hash<int> > Hash; + typedef test_compare<std::equal_to<int> > Compare; + typedef other_allocator<std::pair<const int, std::string> > Alloc; + typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; + typedef std::pair<int, std::string> P; + C c1(0, Hash(1), Compare(1), Alloc(1)); + C c2(0, Hash(2), Compare(2), Alloc(2)); + c2.max_load_factor(2); + c1.swap(c2); + + assert(c1.bucket_count() == 0); + assert(c1.size() == 0); + assert(c1.hash_function() == Hash(2)); + assert(c1.key_eq() == Compare(2)); + assert(c1.get_allocator() == Alloc(2)); + assert(std::distance(c1.begin(), c1.end()) == c1.size()); + assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); + assert(c1.max_load_factor() == 2); + + assert(c2.bucket_count() == 0); + assert(c2.size() == 0); + assert(c2.hash_function() == Hash(1)); + assert(c2.key_eq() == Compare(1)); + assert(c2.get_allocator() == Alloc(1)); + assert(std::distance(c2.begin(), c2.end()) == c2.size()); + assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); + assert(c2.max_load_factor() == 1); + } + { + typedef test_hash<std::hash<int> > Hash; + typedef test_compare<std::equal_to<int> > Compare; + typedef other_allocator<std::pair<const int, std::string> > Alloc; + typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; + typedef std::pair<int, std::string> P; + P a2[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + C c1(0, Hash(1), Compare(1), Alloc(1)); + C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); + c2.max_load_factor(2); + c1.swap(c2); + + assert(c1.bucket_count() >= 11); + assert(c1.size() == 8); + assert(c1.at(10) == "ten"); + assert(c1.at(20) == "twenty"); + assert(c1.at(30) == "thirty"); + assert(c1.at(40) == "forty"); + assert(c1.at(50) == "fifty"); + assert(c1.at(60) == "sixty"); + assert(c1.at(70) == "seventy"); + assert(c1.at(80) == "eighty"); + assert(c1.hash_function() == Hash(2)); + assert(c1.key_eq() == Compare(2)); + assert(c1.get_allocator() == Alloc(2)); + assert(std::distance(c1.begin(), c1.end()) == c1.size()); + assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); + assert(c1.max_load_factor() == 2); + + assert(c2.bucket_count() == 0); + assert(c2.size() == 0); + assert(c2.hash_function() == Hash(1)); + assert(c2.key_eq() == Compare(1)); + assert(c2.get_allocator() == Alloc(1)); + assert(std::distance(c2.begin(), c2.end()) == c2.size()); + assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); + assert(c2.max_load_factor() == 1); + } + { + typedef test_hash<std::hash<int> > Hash; + typedef test_compare<std::equal_to<int> > Compare; + typedef other_allocator<std::pair<const int, std::string> > Alloc; + typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; + typedef std::pair<int, std::string> P; + P a1[] = + { + P(1, "one"), + P(2, "two"), + P(3, "three"), + P(4, "four"), + P(1, "four"), + P(2, "four"), + }; + C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); + C c2(0, Hash(2), Compare(2), Alloc(2)); + c2.max_load_factor(2); + c1.swap(c2); + + assert(c1.bucket_count() == 0); + assert(c1.size() == 0); + assert(c1.hash_function() == Hash(2)); + assert(c1.key_eq() == Compare(2)); + assert(c1.get_allocator() == Alloc(2)); + assert(std::distance(c1.begin(), c1.end()) == c1.size()); + assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); + assert(c1.max_load_factor() == 2); + + assert(c2.bucket_count() >= 5); + assert(c2.size() == 4); + assert(c2.at(1) == "one"); + assert(c2.at(2) == "two"); + assert(c2.at(3) == "three"); + assert(c2.at(4) == "four"); + assert(c2.hash_function() == Hash(1)); + assert(c2.key_eq() == Compare(1)); + assert(c2.get_allocator() == Alloc(1)); + assert(std::distance(c2.begin(), c2.end()) == c2.size()); + assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); + assert(c2.max_load_factor() == 1); + } + { + typedef test_hash<std::hash<int> > Hash; + typedef test_compare<std::equal_to<int> > Compare; + typedef other_allocator<std::pair<const int, std::string> > Alloc; + typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; + typedef std::pair<int, std::string> P; + P a1[] = + { + P(1, "one"), + P(2, "two"), + P(3, "three"), + P(4, "four"), + P(1, "four"), + P(2, "four"), + }; + P a2[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); + C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); + c2.max_load_factor(2); + c1.swap(c2); + + assert(c1.bucket_count() >= 11); + assert(c1.size() == 8); + assert(c1.at(10) == "ten"); + assert(c1.at(20) == "twenty"); + assert(c1.at(30) == "thirty"); + assert(c1.at(40) == "forty"); + assert(c1.at(50) == "fifty"); + assert(c1.at(60) == "sixty"); + assert(c1.at(70) == "seventy"); + assert(c1.at(80) == "eighty"); + assert(c1.hash_function() == Hash(2)); + assert(c1.key_eq() == Compare(2)); + assert(c1.get_allocator() == Alloc(2)); + assert(std::distance(c1.begin(), c1.end()) == c1.size()); + assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); + assert(c1.max_load_factor() == 2); + + assert(c2.bucket_count() >= 5); + assert(c2.size() == 4); + assert(c2.at(1) == "one"); + assert(c2.at(2) == "two"); + assert(c2.at(3) == "three"); + assert(c2.at(4) == "four"); + assert(c2.hash_function() == Hash(1)); + assert(c2.key_eq() == Compare(1)); + assert(c2.get_allocator() == Alloc(1)); + assert(std::distance(c2.begin(), c2.end()) == c2.size()); + assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); + assert(c2.max_load_factor() == 1); + } +#if __cplusplus >= 201103L + { + typedef test_hash<std::hash<int> > Hash; + typedef test_compare<std::equal_to<int> > Compare; + typedef min_allocator<std::pair<const int, std::string> > Alloc; + typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; + typedef std::pair<int, std::string> P; + C c1(0, Hash(1), Compare(1), Alloc()); + C c2(0, Hash(2), Compare(2), Alloc()); + c2.max_load_factor(2); + c1.swap(c2); + + assert(c1.bucket_count() == 0); + assert(c1.size() == 0); + assert(c1.hash_function() == Hash(2)); + assert(c1.key_eq() == Compare(2)); + assert(c1.get_allocator() == Alloc()); + assert(std::distance(c1.begin(), c1.end()) == c1.size()); + assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); + assert(c1.max_load_factor() == 2); + + assert(c2.bucket_count() == 0); + assert(c2.size() == 0); + assert(c2.hash_function() == Hash(1)); + assert(c2.key_eq() == Compare(1)); + assert(c2.get_allocator() == Alloc()); + assert(std::distance(c2.begin(), c2.end()) == c2.size()); + assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); + assert(c2.max_load_factor() == 1); + } + { + typedef test_hash<std::hash<int> > Hash; + typedef test_compare<std::equal_to<int> > Compare; + typedef min_allocator<std::pair<const int, std::string> > Alloc; + typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; + typedef std::pair<int, std::string> P; + P a2[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + C c1(0, Hash(1), Compare(1), Alloc()); + C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc()); + c2.max_load_factor(2); + c1.swap(c2); + + assert(c1.bucket_count() >= 11); + assert(c1.size() == 8); + assert(c1.at(10) == "ten"); + assert(c1.at(20) == "twenty"); + assert(c1.at(30) == "thirty"); + assert(c1.at(40) == "forty"); + assert(c1.at(50) == "fifty"); + assert(c1.at(60) == "sixty"); + assert(c1.at(70) == "seventy"); + assert(c1.at(80) == "eighty"); + assert(c1.hash_function() == Hash(2)); + assert(c1.key_eq() == Compare(2)); + assert(c1.get_allocator() == Alloc()); + assert(std::distance(c1.begin(), c1.end()) == c1.size()); + assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); + assert(c1.max_load_factor() == 2); + + assert(c2.bucket_count() == 0); + assert(c2.size() == 0); + assert(c2.hash_function() == Hash(1)); + assert(c2.key_eq() == Compare(1)); + assert(c2.get_allocator() == Alloc()); + assert(std::distance(c2.begin(), c2.end()) == c2.size()); + assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); + assert(c2.max_load_factor() == 1); + } + { + typedef test_hash<std::hash<int> > Hash; + typedef test_compare<std::equal_to<int> > Compare; + typedef min_allocator<std::pair<const int, std::string> > Alloc; + typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; + typedef std::pair<int, std::string> P; + P a1[] = + { + P(1, "one"), + P(2, "two"), + P(3, "three"), + P(4, "four"), + P(1, "four"), + P(2, "four"), + }; + C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc()); + C c2(0, Hash(2), Compare(2), Alloc()); + c2.max_load_factor(2); + c1.swap(c2); + + assert(c1.bucket_count() == 0); + assert(c1.size() == 0); + assert(c1.hash_function() == Hash(2)); + assert(c1.key_eq() == Compare(2)); + assert(c1.get_allocator() == Alloc()); + assert(std::distance(c1.begin(), c1.end()) == c1.size()); + assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); + assert(c1.max_load_factor() == 2); + + assert(c2.bucket_count() >= 5); + assert(c2.size() == 4); + assert(c2.at(1) == "one"); + assert(c2.at(2) == "two"); + assert(c2.at(3) == "three"); + assert(c2.at(4) == "four"); + assert(c2.hash_function() == Hash(1)); + assert(c2.key_eq() == Compare(1)); + assert(c2.get_allocator() == Alloc()); + assert(std::distance(c2.begin(), c2.end()) == c2.size()); + assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); + assert(c2.max_load_factor() == 1); + } + { + typedef test_hash<std::hash<int> > Hash; + typedef test_compare<std::equal_to<int> > Compare; + typedef min_allocator<std::pair<const int, std::string> > Alloc; + typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; + typedef std::pair<int, std::string> P; + P a1[] = + { + P(1, "one"), + P(2, "two"), + P(3, "three"), + P(4, "four"), + P(1, "four"), + P(2, "four"), + }; + P a2[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc()); + C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc()); + c2.max_load_factor(2); + c1.swap(c2); + + assert(c1.bucket_count() >= 11); + assert(c1.size() == 8); + assert(c1.at(10) == "ten"); + assert(c1.at(20) == "twenty"); + assert(c1.at(30) == "thirty"); + assert(c1.at(40) == "forty"); + assert(c1.at(50) == "fifty"); + assert(c1.at(60) == "sixty"); + assert(c1.at(70) == "seventy"); + assert(c1.at(80) == "eighty"); + assert(c1.hash_function() == Hash(2)); + assert(c1.key_eq() == Compare(2)); + assert(c1.get_allocator() == Alloc()); + assert(std::distance(c1.begin(), c1.end()) == c1.size()); + assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); + assert(c1.max_load_factor() == 2); + + assert(c2.bucket_count() >= 5); + assert(c2.size() == 4); + assert(c2.at(1) == "one"); + assert(c2.at(2) == "two"); + assert(c2.at(3) == "three"); + assert(c2.at(4) == "four"); + assert(c2.hash_function() == Hash(1)); + assert(c2.key_eq() == Compare(1)); + assert(c2.get_allocator() == Alloc()); + assert(std::distance(c2.begin(), c2.end()) == c2.size()); + assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); + assert(c2.max_load_factor() == 1); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/types.pass.cpp b/test/std/containers/unord/unord.map/types.pass.cpp new file mode 100644 index 0000000000000..b53ff8e1540ae --- /dev/null +++ b/test/std/containers/unord/unord.map/types.pass.cpp @@ -0,0 +1,72 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map +// { +// public: +// // types +// typedef Key key_type; +// typedef T mapped_type; +// typedef Hash hasher; +// typedef Pred key_equal; +// typedef Alloc allocator_type; +// typedef pair<const key_type, mapped_type> value_type; +// typedef value_type& reference; +// typedef const value_type& const_reference; +// typedef typename allocator_traits<allocator_type>::pointer pointer; +// typedef typename allocator_traits<allocator_type>::const_pointer const_pointer; +// typedef typename allocator_traits<allocator_type>::size_type size_type; +// typedef typename allocator_traits<allocator_type>::difference_type difference_type; + +#include <unordered_map> +#include <type_traits> + +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<char, short> C; + static_assert((std::is_same<C::key_type, char>::value), ""); + static_assert((std::is_same<C::mapped_type, short>::value), ""); + static_assert((std::is_same<C::hasher, std::hash<C::key_type> >::value), ""); + static_assert((std::is_same<C::key_equal, std::equal_to<C::key_type> >::value), ""); + static_assert((std::is_same<C::allocator_type, std::allocator<C::value_type> >::value), ""); + static_assert((std::is_same<C::value_type, std::pair<const C::key_type, C::mapped_type> >::value), ""); + static_assert((std::is_same<C::reference, C::value_type&>::value), ""); + static_assert((std::is_same<C::const_reference, const C::value_type&>::value), ""); + static_assert((std::is_same<C::pointer, C::value_type*>::value), ""); + static_assert((std::is_same<C::const_pointer, const C::value_type*>::value), ""); + static_assert((std::is_same<C::size_type, std::size_t>::value), ""); + static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), ""); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<char, short, std::hash<char>, std::equal_to<char>, + min_allocator<std::pair<const char, short>>> C; + static_assert((std::is_same<C::key_type, char>::value), ""); + static_assert((std::is_same<C::mapped_type, short>::value), ""); + static_assert((std::is_same<C::hasher, std::hash<C::key_type> >::value), ""); + static_assert((std::is_same<C::key_equal, std::equal_to<C::key_type> >::value), ""); + static_assert((std::is_same<C::allocator_type, min_allocator<C::value_type> >::value), ""); + static_assert((std::is_same<C::value_type, std::pair<const C::key_type, C::mapped_type> >::value), ""); + static_assert((std::is_same<C::reference, C::value_type&>::value), ""); + static_assert((std::is_same<C::const_reference, const C::value_type&>::value), ""); + static_assert((std::is_same<C::pointer, min_pointer<C::value_type>>::value), ""); + static_assert((std::is_same<C::const_pointer, min_pointer<const C::value_type>>::value), ""); + // min_allocator doesn't have a size_type, so one gets synthesized + static_assert((std::is_same<C::size_type, std::make_unsigned<C::difference_type>::type>::value), ""); + static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), ""); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp new file mode 100644 index 0000000000000..0fc76db0fb2f2 --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp @@ -0,0 +1,111 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// explicit unordered_map(const allocator_type& __a); + +#include <unordered_map> +#include <cassert> + +#include "../../../NotConstructible.h" +#include "../../../test_compare.h" +#include "../../../test_hash.h" +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<NotConstructible, NotConstructible, + test_hash<std::hash<NotConstructible> >, + test_compare<std::equal_to<NotConstructible> >, + test_allocator<std::pair<const NotConstructible, + NotConstructible> > + > C; + C c(test_allocator<std::pair<const NotConstructible, NotConstructible> >(10)); + 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() == + (test_allocator<std::pair<const NotConstructible, NotConstructible> >(10))); + 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 __cplusplus >= 201103L + { + typedef std::unordered_map<NotConstructible, NotConstructible, + test_hash<std::hash<NotConstructible> >, + test_compare<std::equal_to<NotConstructible> >, + min_allocator<std::pair<const NotConstructible, + NotConstructible> > + > C; + C c(min_allocator<std::pair<const NotConstructible, NotConstructible> >{}); + 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() == + (min_allocator<std::pair<const NotConstructible, NotConstructible> >())); + 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; + typedef test_allocator<std::pair<const T, T>> A; + typedef test_hash<std::hash<T>> HF; + typedef test_compare<std::equal_to<T>> Comp; + typedef std::unordered_map<T, T, HF, Comp, A> C; + + A a(10); + C c(2, a); + assert(c.bucket_count() == 2); + assert(c.hash_function() == HF()); + assert(c.key_eq() == Comp()); + 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); + } + { + typedef NotConstructible T; + typedef test_allocator<std::pair<const T, T>> A; + typedef test_hash<std::hash<T>> HF; + typedef test_compare<std::equal_to<T>> Comp; + typedef std::unordered_map<T, T, HF, Comp, A> C; + + A a(10); + HF hf(12); + C c(2, hf, a); + assert(c.bucket_count() == 2); + assert(c.hash_function() == hf); + assert(!(c.hash_function() == HF())); + assert(c.key_eq() == Comp()); + 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 +#endif +} diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp new file mode 100644 index 0000000000000..fa0105604f154 --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp @@ -0,0 +1,185 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// unordered_map& operator=(const unordered_map& u); + +#include <unordered_map> +#include <string> +#include <cassert> +#include <cfloat> + +#include "../../../test_compare.h" +#include "../../../test_hash.h" +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ + { + typedef test_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(10) + ); + C c(a, a + 2, + 7, + test_hash<std::hash<int> >(2), + test_compare<std::equal_to<int> >(3), + A(4) + ); + c = c0; + 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(4)); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + } + { + typedef std::unordered_map<int, std::string> C; + typedef std::pair<const int, std::string> P; + const P a[] = + { + P(1, "one"), + P(2, "two"), + P(3, "three"), + P(4, "four"), + P(1, "four"), + P(2, "four"), + }; + C c(a, a + sizeof(a)/sizeof(a[0])); + C *p = &c; + c = *p; + assert(c.size() == 4); + assert(std::is_permutation(c.begin(), c.end(), a)); + } + { + typedef other_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(10) + ); + C c(a, a + 2, + 7, + test_hash<std::hash<int> >(2), + test_compare<std::equal_to<int> >(3), + A(4) + ); + c = c0; + assert(c.bucket_count() >= 5); + 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(10)); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + } +#if __cplusplus >= 201103L + { + typedef min_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(a, a + 2, + 7, + test_hash<std::hash<int> >(2), + test_compare<std::equal_to<int> >(3), + A() + ); + c = c0; + 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(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/assign_init.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/assign_init.pass.cpp new file mode 100644 index 0000000000000..3a854e1065431 --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.cnstr/assign_init.pass.cpp @@ -0,0 +1,97 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// unordered_map& operator=(initializer_list<value_type> il); + +#include <unordered_map> +#include <string> +#include <cassert> +#include <cfloat> + +#include "../../../test_compare.h" +#include "../../../test_hash.h" +#include "min_allocator.h" + +int main() +{ +#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS + { + typedef std::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(4, "four"), + P(1, "four"), + P(2, "four"), + }; + c = { + P(1, "one"), + P(2, "two"), + P(3, "three"), + P(4, "four"), + P(1, "four"), + P(2, "four"), + }; + assert(c.bucket_count() >= 5); + 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(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + } +#if __cplusplus >= 201103L + { + typedef min_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(4, "four"), + P(1, "four"), + P(2, "four"), + }; + c = { + P(1, "one"), + P(2, "two"), + P(3, "three"), + P(4, "four"), + P(1, "four"), + P(2, "four"), + }; + assert(c.bucket_count() >= 5); + 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(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(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 +} diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp new file mode 100644 index 0000000000000..dd57c58214fa1 --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp @@ -0,0 +1,229 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// unordered_map& operator=(unordered_map&& u); + +#include <unordered_map> +#include <string> +#include <cassert> +#include <cfloat> + +#include "../../../test_compare.h" +#include "../../../test_hash.h" +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + { + typedef test_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(10) + ); + C c(a, a + 2, + 7, + test_hash<std::hash<int> >(2), + test_compare<std::equal_to<int> >(3), + A(4) + ); + c = std::move(c0); + 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(4)); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + } + { + typedef test_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(10) + ); + C c(a, a + 2, + 7, + test_hash<std::hash<int> >(2), + test_compare<std::equal_to<int> >(3), + A(10) + ); + c = std::move(c0); + 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(10)); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + assert(c0.size() == 0); + } + { + typedef other_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(10) + ); + C c(a, a + 2, + 7, + test_hash<std::hash<int> >(2), + test_compare<std::equal_to<int> >(3), + A(4) + ); + c = std::move(c0); + 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(10)); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + assert(c0.size() == 0); + } +#if __cplusplus >= 201103L + { + typedef min_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(a, a + 2, + 7, + test_hash<std::hash<int> >(2), + test_compare<std::equal_to<int> >(3), + A() + ); + c = std::move(c0); + 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(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + assert(c0.size() == 0); + } +#endif +#if _LIBCPP_DEBUG >= 1 + { + std::unordered_map<int, int> s1 = {{1, 1}, {2, 2}, {3, 3}}; + std::unordered_map<int, int>::iterator i = s1.begin(); + std::pair<const int, int> k = *i; + std::unordered_map<int, int> s2; + s2 = std::move(s1); + assert(*i == k); + s2.erase(i); + assert(s2.size() == 2); + } +#endif +#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES +} diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp new file mode 100644 index 0000000000000..227343e6d5b77 --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp @@ -0,0 +1,151 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// unordered_map(const unordered_map& u); + +#include <unordered_map> +#include <string> +#include <cassert> +#include <cfloat> + +#include "../../../test_compare.h" +#include "../../../test_hash.h" +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<int, std::string, + test_hash<std::hash<int> >, + test_compare<std::equal_to<int> >, + test_allocator<std::pair<const int, std::string> > + > 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), + test_allocator<std::pair<const int, std::string> >(10) + ); + C c = c0; + 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() == + (test_allocator<std::pair<const int, std::string> >(10))); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + } +#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE + { + typedef std::unordered_map<int, std::string, + test_hash<std::hash<int> >, + test_compare<std::equal_to<int> >, + other_allocator<std::pair<const int, std::string> > + > 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), + other_allocator<std::pair<const int, std::string> >(10) + ); + C c = c0; + 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() == + (other_allocator<std::pair<const int, std::string> >(-2))); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + } +#endif // _LIBCPP_HAS_NO_ADVANCED_SFINAE +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, + test_hash<std::hash<int> >, + test_compare<std::equal_to<int> >, + min_allocator<std::pair<const int, std::string> > + > 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), + min_allocator<std::pair<const int, std::string> >() + ); + C c = c0; + 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() == + (min_allocator<std::pair<const int, std::string> >())); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp new file mode 100644 index 0000000000000..d1757d8a3c1b9 --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp @@ -0,0 +1,110 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// unordered_map(const unordered_map& u, const allocator_type& a); + +#include <unordered_map> +#include <string> +#include <cassert> +#include <cfloat> + +#include "../../../test_compare.h" +#include "../../../test_hash.h" +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<int, std::string, + test_hash<std::hash<int> >, + test_compare<std::equal_to<int> >, + test_allocator<std::pair<const int, std::string> > + > 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), + test_allocator<std::pair<const int, std::string> >(10) + ); + C c(c0, test_allocator<std::pair<const int, std::string> >(5)); + 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() == + (test_allocator<std::pair<const int, std::string> >(5))); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, + test_hash<std::hash<int> >, + test_compare<std::equal_to<int> >, + min_allocator<std::pair<const int, std::string> > + > 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), + min_allocator<std::pair<const int, std::string> >() + ); + C c(c0, min_allocator<std::pair<const int, std::string> >()); + 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() == + (min_allocator<std::pair<const int, std::string> >())); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp new file mode 100644 index 0000000000000..a0825db1ecd2d --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp @@ -0,0 +1,78 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// unordered_map(); + +#include <unordered_map> +#include <cassert> + +#include "../../../NotConstructible.h" +#include "../../../test_compare.h" +#include "../../../test_hash.h" +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<NotConstructible, NotConstructible, + test_hash<std::hash<NotConstructible> >, + test_compare<std::equal_to<NotConstructible> >, + test_allocator<std::pair<const NotConstructible, + NotConstructible> > + > C; + C c; + 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() == + (test_allocator<std::pair<const NotConstructible, NotConstructible> >())); + 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 __cplusplus >= 201103L + { + typedef std::unordered_map<NotConstructible, NotConstructible, + test_hash<std::hash<NotConstructible> >, + test_compare<std::equal_to<NotConstructible> >, + min_allocator<std::pair<const NotConstructible, + NotConstructible> > + > C; + C c; + 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() == + (min_allocator<std::pair<const NotConstructible, NotConstructible> >())); + 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 = {}; + assert(c.bucket_count() == 0); + 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 +} diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/default_noexcept.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/default_noexcept.pass.cpp new file mode 100644 index 0000000000000..30e0dc1705a31 --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.cnstr/default_noexcept.pass.cpp @@ -0,0 +1,70 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// unordered_map() +// noexcept( +// is_nothrow_default_constructible<allocator_type>::value && +// is_nothrow_default_constructible<key_compare>::value && +// is_nothrow_copy_constructible<key_compare>::value); + +// This tests a conforming extension + +#include <unordered_map> +#include <cassert> + +#include "MoveOnly.h" +#include "test_allocator.h" +#include "../../../test_hash.h" + +template <class T> +struct some_comp +{ + typedef T value_type; + some_comp(); + some_comp(const some_comp&); +}; + +template <class T> +struct some_hash +{ + typedef T value_type; + some_hash(); + some_hash(const some_hash&); +}; + +int main() +{ +#if __has_feature(cxx_noexcept) + { + typedef std::unordered_map<MoveOnly, MoveOnly> C; + static_assert(std::is_nothrow_default_constructible<C>::value, ""); + } + { + typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, + std::equal_to<MoveOnly>, test_allocator<std::pair<const MoveOnly, MoveOnly>>> C; + static_assert(std::is_nothrow_default_constructible<C>::value, ""); + } + { + typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, + std::equal_to<MoveOnly>, other_allocator<std::pair<const MoveOnly, MoveOnly>>> C; + static_assert(!std::is_nothrow_default_constructible<C>::value, ""); + } + { + typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>> C; + static_assert(!std::is_nothrow_default_constructible<C>::value, ""); + } + { + typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, + some_comp<MoveOnly>> C; + static_assert(!std::is_nothrow_default_constructible<C>::value, ""); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/dtor_noexcept.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/dtor_noexcept.pass.cpp new file mode 100644 index 0000000000000..7fb4200605cf3 --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.cnstr/dtor_noexcept.pass.cpp @@ -0,0 +1,67 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// ~unordered_map() // implied noexcept; + +#include <unordered_map> +#include <cassert> + +#include "MoveOnly.h" +#include "test_allocator.h" + +#if __has_feature(cxx_noexcept) + +template <class T> +struct some_comp +{ + typedef T value_type; + ~some_comp() noexcept(false); +}; + +template <class T> +struct some_hash +{ + typedef T value_type; + some_hash(); + some_hash(const some_hash&); + ~some_hash() noexcept(false); +}; + +#endif + +int main() +{ +#if __has_feature(cxx_noexcept) + { + typedef std::unordered_map<MoveOnly, MoveOnly> C; + static_assert(std::is_nothrow_destructible<C>::value, ""); + } + { + typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, + std::equal_to<MoveOnly>, test_allocator<std::pair<const MoveOnly, MoveOnly>>> C; + static_assert(std::is_nothrow_destructible<C>::value, ""); + } + { + typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, + std::equal_to<MoveOnly>, other_allocator<std::pair<const MoveOnly, MoveOnly>>> C; + static_assert(std::is_nothrow_destructible<C>::value, ""); + } + { + typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>> C; + static_assert(!std::is_nothrow_destructible<C>::value, ""); + } + { + typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, + some_comp<MoveOnly>> C; + static_assert(!std::is_nothrow_destructible<C>::value, ""); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/init.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/init.pass.cpp new file mode 100644 index 0000000000000..dbc48f816c8b6 --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.cnstr/init.pass.cpp @@ -0,0 +1,162 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// unordered_map(initializer_list<value_type> il); + +#include <unordered_map> +#include <string> +#include <cassert> +#include <cfloat> + +#include "../../../test_compare.h" +#include "../../../test_hash.h" +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ +#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS + { + typedef std::unordered_map<int, std::string, + test_hash<std::hash<int> >, + test_compare<std::equal_to<int> >, + test_allocator<std::pair<const int, std::string> > + > 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"), + }; + assert(c.bucket_count() >= 5); + 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> >()); + assert(c.key_eq() == test_compare<std::equal_to<int> >()); + assert(c.get_allocator() == + (test_allocator<std::pair<const int, std::string> >())); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, + test_hash<std::hash<int> >, + test_compare<std::equal_to<int> >, + min_allocator<std::pair<const int, std::string> > + > 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"), + }; + assert(c.bucket_count() >= 5); + 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> >()); + assert(c.key_eq() == test_compare<std::equal_to<int> >()); + assert(c.get_allocator() == + (min_allocator<std::pair<const int, std::string> >())); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + } +#if _LIBCPP_STD_VER > 11 + { + typedef std::pair<int, std::string> P; + typedef test_allocator<std::pair<const int, std::string>> A; + typedef test_hash<std::hash<int>> HF; + typedef test_compare<std::equal_to<int>> Comp; + typedef std::unordered_map<int, std::string, HF, Comp, A> C; + + A a(42); + C c ( { + P(1, "one"), + P(2, "two"), + P(3, "three"), + P(4, "four"), + P(1, "four"), + P(2, "four"), + }, 12, a); + assert(c.bucket_count() >= 12); + 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> >()); + assert(c.key_eq() == test_compare<std::equal_to<int> >()); + 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(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + } + { + typedef std::pair<int, std::string> P; + typedef test_allocator<std::pair<const int, std::string>> A; + typedef test_hash<std::hash<int>> HF; + typedef test_compare<std::equal_to<int>> Comp; + typedef std::unordered_map<int, std::string, HF, Comp, A> C; + + HF hf(42); + A a(43); + C c ( { + P(1, "one"), + P(2, "two"), + P(3, "three"), + P(4, "four"), + P(1, "four"), + P(2, "four"), + }, 12, hf, a); + assert(c.bucket_count() >= 12); + 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() == hf); + assert(!(c.hash_function() == test_hash<std::hash<int> >())); + assert(c.key_eq() == test_compare<std::equal_to<int> >()); + 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(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + } +#endif +#endif +#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS +} diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp new file mode 100644 index 0000000000000..ac09053b1ebc1 --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp @@ -0,0 +1,100 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// unordered_map(initializer_list<value_type> il, size_type n); + +#include <unordered_map> +#include <string> +#include <cassert> +#include <cfloat> + +#include "../../../test_compare.h" +#include "../../../test_hash.h" +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ +#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS + { + typedef std::unordered_map<int, std::string, + test_hash<std::hash<int> >, + test_compare<std::equal_to<int> >, + test_allocator<std::pair<const int, std::string> > + > 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 + ); + 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> >()); + assert(c.key_eq() == test_compare<std::equal_to<int> >()); + assert(c.get_allocator() == + (test_allocator<std::pair<const int, std::string> >())); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, + test_hash<std::hash<int> >, + test_compare<std::equal_to<int> >, + min_allocator<std::pair<const int, std::string> > + > 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 + ); + 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> >()); + assert(c.key_eq() == test_compare<std::equal_to<int> >()); + assert(c.get_allocator() == + (min_allocator<std::pair<const int, std::string> >())); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(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 +} diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp new file mode 100644 index 0000000000000..7a4130bde8fa1 --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp @@ -0,0 +1,102 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// unordered_map(initializer_list<value_type> il, size_type n, const hasher& hf); + +#include <unordered_map> +#include <string> +#include <cassert> +#include <cfloat> + +#include "../../../test_compare.h" +#include "../../../test_hash.h" +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ +#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS + { + typedef std::unordered_map<int, std::string, + test_hash<std::hash<int> >, + test_compare<std::equal_to<int> >, + test_allocator<std::pair<const int, std::string> > + > 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) + ); + 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> >()); + assert(c.get_allocator() == + (test_allocator<std::pair<const int, std::string> >())); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, + test_hash<std::hash<int> >, + test_compare<std::equal_to<int> >, + min_allocator<std::pair<const int, std::string> > + > 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) + ); + 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> >()); + assert(c.get_allocator() == + (min_allocator<std::pair<const int, std::string> >())); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(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 +} diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp new file mode 100644 index 0000000000000..036008c0b863c --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp @@ -0,0 +1,105 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// unordered_map(initializer_list<value_type> il, size_type n, +// const hasher& hf, const key_equal& eql); + +#include <unordered_map> +#include <string> +#include <cassert> +#include <cfloat> + +#include "../../../test_compare.h" +#include "../../../test_hash.h" +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ +#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS + { + typedef std::unordered_map<int, std::string, + test_hash<std::hash<int> >, + test_compare<std::equal_to<int> >, + test_allocator<std::pair<const int, std::string> > + > 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) + ); + 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() == + (test_allocator<std::pair<const int, std::string> >())); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, + test_hash<std::hash<int> >, + test_compare<std::equal_to<int> >, + min_allocator<std::pair<const int, std::string> > + > 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) + ); + 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() == + (min_allocator<std::pair<const int, std::string> >())); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(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 +} diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp new file mode 100644 index 0000000000000..7c83192b664cd --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp @@ -0,0 +1,107 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// unordered_map(initializer_list<value_type> il, size_type n, +// const hasher& hf, const key_equal& eql, const allocator_type& a); + +#include <unordered_map> +#include <string> +#include <cassert> +#include <cfloat> + +#include "../../../test_compare.h" +#include "../../../test_hash.h" +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ +#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS + { + typedef std::unordered_map<int, std::string, + test_hash<std::hash<int> >, + test_compare<std::equal_to<int> >, + test_allocator<std::pair<const int, std::string> > + > 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), + test_allocator<std::pair<const int, std::string> >(10) + ); + 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() == + (test_allocator<std::pair<const int, std::string> >(10))); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, + test_hash<std::hash<int> >, + test_compare<std::equal_to<int> >, + min_allocator<std::pair<const int, std::string> > + > 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), + min_allocator<std::pair<const int, std::string> >() + ); + 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() == + (min_allocator<std::pair<const int, std::string> >())); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(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 +} diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/move.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/move.pass.cpp new file mode 100644 index 0000000000000..18e6683011c85 --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.cnstr/move.pass.cpp @@ -0,0 +1,199 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// unordered_map(unordered_map&& u); + +#include <unordered_map> +#include <string> +#include <cassert> +#include <cfloat> + +#include "../../../test_compare.h" +#include "../../../test_hash.h" +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + { + typedef std::unordered_map<int, std::string, + test_hash<std::hash<int> >, + test_compare<std::equal_to<int> >, + test_allocator<std::pair<const int, std::string> > + > 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(7, + test_hash<std::hash<int> >(8), + test_compare<std::equal_to<int> >(9), + test_allocator<std::pair<const int, std::string> >(10) + ); + C c = std::move(c0); + assert(c.bucket_count() == 7); + assert(c.size() == 0); + 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() == + (test_allocator<std::pair<const int, std::string> >(10))); + assert(c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(c.load_factor() == 0); + assert(c.max_load_factor() == 1); + + assert(c0.empty()); + } + { + typedef std::unordered_map<int, std::string, + test_hash<std::hash<int> >, + test_compare<std::equal_to<int> >, + test_allocator<std::pair<const int, std::string> > + > 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), + test_allocator<std::pair<const int, std::string> >(10) + ); + C c = std::move(c0); + 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() == + (test_allocator<std::pair<const int, std::string> >(10))); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + + assert(c0.empty()); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, + test_hash<std::hash<int> >, + test_compare<std::equal_to<int> >, + min_allocator<std::pair<const int, std::string> > + > 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(7, + test_hash<std::hash<int> >(8), + test_compare<std::equal_to<int> >(9), + min_allocator<std::pair<const int, std::string> >() + ); + C c = std::move(c0); + assert(c.bucket_count() == 7); + assert(c.size() == 0); + 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() == + (min_allocator<std::pair<const int, std::string> >())); + assert(c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(c.load_factor() == 0); + assert(c.max_load_factor() == 1); + + assert(c0.empty()); + } + { + typedef std::unordered_map<int, std::string, + test_hash<std::hash<int> >, + test_compare<std::equal_to<int> >, + min_allocator<std::pair<const int, std::string> > + > 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), + min_allocator<std::pair<const int, std::string> >() + ); + C c = std::move(c0); + 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() == + (min_allocator<std::pair<const int, std::string> >())); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + + assert(c0.empty()); + } +#endif +#if _LIBCPP_DEBUG >= 1 + { + std::unordered_map<int, int> s1 = {{1, 1}, {2, 2}, {3, 3}}; + std::unordered_map<int, int>::iterator i = s1.begin(); + std::pair<const int, int> k = *i; + std::unordered_map<int, int> s2 = std::move(s1); + assert(*i == k); + s2.erase(i); + assert(s2.size() == 2); + } +#endif +#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES +} diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp new file mode 100644 index 0000000000000..091a72f0d1600 --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp @@ -0,0 +1,157 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// unordered_map(unordered_map&& u, const allocator_type& a); + +#include <unordered_map> +#include <string> +#include <cassert> +#include <cfloat> + +#include "../../../test_compare.h" +#include "../../../test_hash.h" +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + { + typedef std::pair<int, std::string> P; + typedef test_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(10) + ); + C c(std::move(c0), A(12)); + assert(c.bucket_count() >= 5); + 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(12)); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(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 test_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(10) + ); + C c(std::move(c0), A(10)); + 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(10)); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + + assert(c0.empty()); + } +#if __cplusplus >= 201103L + { + typedef std::pair<int, std::string> P; + typedef min_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()); + 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(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + + assert(c0.empty()); + } +#endif +#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES +} diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/move_assign_noexcept.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/move_assign_noexcept.pass.cpp new file mode 100644 index 0000000000000..fc3fc6f05f8a0 --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.cnstr/move_assign_noexcept.pass.cpp @@ -0,0 +1,69 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// unordered_map& operator=(unordered_map&& c) +// noexcept( +// allocator_type::propagate_on_container_move_assignment::value && +// is_nothrow_move_assignable<allocator_type>::value && +// is_nothrow_move_assignable<key_compare>::value); + +// This tests a conforming extension + +#include <unordered_map> +#include <cassert> + +#include "MoveOnly.h" +#include "test_allocator.h" + +template <class T> +struct some_comp +{ + typedef T value_type; + some_comp& operator=(const some_comp&); +}; + +template <class T> +struct some_hash +{ + typedef T value_type; + some_hash(); + some_hash(const some_hash&); + some_hash& operator=(const some_hash&); +}; + +int main() +{ +#if __has_feature(cxx_noexcept) + { + typedef std::unordered_map<MoveOnly, MoveOnly> C; + static_assert(std::is_nothrow_move_assignable<C>::value, ""); + } + { + typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, + std::equal_to<MoveOnly>, test_allocator<std::pair<const MoveOnly, MoveOnly>>> C; + static_assert(!std::is_nothrow_move_assignable<C>::value, ""); + } + { + typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, + std::equal_to<MoveOnly>, other_allocator<std::pair<const MoveOnly, MoveOnly>>> C; + static_assert(std::is_nothrow_move_assignable<C>::value, ""); + } + { + typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>> C; + static_assert(!std::is_nothrow_move_assignable<C>::value, ""); + } + { + typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, + some_comp<MoveOnly>> C; + static_assert(!std::is_nothrow_move_assignable<C>::value, ""); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/move_noexcept.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/move_noexcept.pass.cpp new file mode 100644 index 0000000000000..f292011cd7b60 --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.cnstr/move_noexcept.pass.cpp @@ -0,0 +1,66 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// unordered_map(unordered_map&&) +// noexcept(is_nothrow_move_constructible<allocator_type>::value && +// is_nothrow_move_constructible<key_compare>::value); + +// This tests a conforming extension + +#include <unordered_map> +#include <cassert> + +#include "MoveOnly.h" +#include "test_allocator.h" + +template <class T> +struct some_comp +{ + typedef T value_type; + some_comp(const some_comp&); +}; + +template <class T> +struct some_hash +{ + typedef T value_type; + some_hash(); + some_hash(const some_hash&); +}; + +int main() +{ +#if __has_feature(cxx_noexcept) + { + typedef std::unordered_map<MoveOnly, MoveOnly> C; + static_assert(std::is_nothrow_move_constructible<C>::value, ""); + } + { + typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, + std::equal_to<MoveOnly>, test_allocator<std::pair<const MoveOnly, MoveOnly>>> C; + static_assert(std::is_nothrow_move_constructible<C>::value, ""); + } + { + typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, + std::equal_to<MoveOnly>, other_allocator<std::pair<const MoveOnly, MoveOnly>>> C; + static_assert(std::is_nothrow_move_constructible<C>::value, ""); + } + { + typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>> C; + static_assert(!std::is_nothrow_move_constructible<C>::value, ""); + } + { + typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, + some_comp<MoveOnly>> C; + static_assert(!std::is_nothrow_move_constructible<C>::value, ""); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp new file mode 100644 index 0000000000000..c1784d63b2939 --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp @@ -0,0 +1,170 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// template <class InputIterator> +// unordered_map(InputIterator first, InputIterator last); + +#include <unordered_map> +#include <string> +#include <cassert> +#include <cfloat> + +#include "test_iterators.h" +#include "../../../NotConstructible.h" +#include "../../../test_compare.h" +#include "../../../test_hash.h" +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<int, std::string, + test_hash<std::hash<int> >, + test_compare<std::equal_to<int> >, + test_allocator<std::pair<const int, std::string> > + > 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]))); + assert(c.bucket_count() >= 5); + 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> >()); + assert(c.key_eq() == test_compare<std::equal_to<int> >()); + assert(c.get_allocator() == + (test_allocator<std::pair<const int, std::string> >())); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, + test_hash<std::hash<int> >, + test_compare<std::equal_to<int> >, + min_allocator<std::pair<const int, std::string> > + > 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]))); + assert(c.bucket_count() >= 5); + 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> >()); + assert(c.key_eq() == test_compare<std::equal_to<int> >()); + assert(c.get_allocator() == + (min_allocator<std::pair<const int, std::string> >())); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + } +#if _LIBCPP_STD_VER > 11 + { + typedef std::pair<int, std::string> P; + typedef test_allocator<std::pair<const int, std::string>> A; + typedef test_hash<std::hash<int>> HF; + typedef test_compare<std::equal_to<int>> Comp; + typedef std::unordered_map<int, std::string, HF, Comp, A> C; + + P arr[] = + { + P(1, "one"), + P(2, "two"), + P(3, "three"), + P(4, "four"), + P(1, "four"), + P(2, "four"), + }; + C c(input_iterator<P*>(arr), input_iterator<P*>(arr + sizeof(arr)/sizeof(arr[0])), 14); + assert(c.bucket_count() >= 14); + 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() == HF()); + assert(c.key_eq() == Comp()); + 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(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + } + { + typedef std::pair<int, std::string> P; + typedef test_allocator<std::pair<const int, std::string>> A; + typedef test_hash<std::hash<int>> HF; + typedef test_compare<std::equal_to<int>> Comp; + typedef std::unordered_map<int, std::string, HF, Comp, A> C; + + P arr[] = + { + P(1, "one"), + P(2, "two"), + P(3, "three"), + P(4, "four"), + P(1, "four"), + P(2, "four"), + }; + HF hf(42); + A a(43); + C c(input_iterator<P*>(arr), input_iterator<P*>(arr + sizeof(arr)/sizeof(arr[0])), 14, hf, a); + assert(c.bucket_count() >= 14); + 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() == hf); + assert(!(c.hash_function() == HF())); + assert(c.key_eq() == Comp()); + 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(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + } +#endif +#endif +} diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp new file mode 100644 index 0000000000000..f914b3060718f --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp @@ -0,0 +1,105 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// template <class InputIterator> +// unordered_map(InputIterator first, InputIterator last, size_type n); + +#include <unordered_map> +#include <string> +#include <cassert> +#include <cfloat> + +#include "test_iterators.h" +#include "../../../NotConstructible.h" +#include "../../../test_compare.h" +#include "../../../test_hash.h" +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<int, std::string, + test_hash<std::hash<int> >, + test_compare<std::equal_to<int> >, + test_allocator<std::pair<const int, std::string> > + > 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])), + 10 + ); + assert(c.bucket_count() == 11); + 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> >()); + assert(c.key_eq() == test_compare<std::equal_to<int> >()); + assert(c.get_allocator() == + (test_allocator<std::pair<const int, std::string> >())); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, + test_hash<std::hash<int> >, + test_compare<std::equal_to<int> >, + min_allocator<std::pair<const int, std::string> > + > 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])), + 10 + ); + assert(c.bucket_count() == 11); + 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> >()); + assert(c.key_eq() == test_compare<std::equal_to<int> >()); + assert(c.get_allocator() == + (min_allocator<std::pair<const int, std::string> >())); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp new file mode 100644 index 0000000000000..7a0dbceb17c15 --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp @@ -0,0 +1,108 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// template <class InputIterator> +// unordered_map(InputIterator first, InputIterator last, size_type n, +// const hasher& hf); + +#include <unordered_map> +#include <string> +#include <cassert> +#include <cfloat> + +#include "test_iterators.h" +#include "../../../NotConstructible.h" +#include "../../../test_compare.h" +#include "../../../test_hash.h" +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<int, std::string, + test_hash<std::hash<int> >, + test_compare<std::equal_to<int> >, + test_allocator<std::pair<const int, std::string> > + > 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) + ); + 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> >()); + assert(c.get_allocator() == + (test_allocator<std::pair<const int, std::string> >())); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, + test_hash<std::hash<int> >, + test_compare<std::equal_to<int> >, + min_allocator<std::pair<const int, std::string> > + > 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) + ); + 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> >()); + assert(c.get_allocator() == + (min_allocator<std::pair<const int, std::string> >())); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp new file mode 100644 index 0000000000000..61eef5bc40a4b --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp @@ -0,0 +1,110 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// template <class InputIterator> +// unordered_map(InputIterator first, InputIterator last, size_type n, +// const hasher& hf, const key_equal& eql); + +#include <unordered_map> +#include <string> +#include <cassert> +#include <cfloat> + +#include "test_iterators.h" +#include "../../../NotConstructible.h" +#include "../../../test_compare.h" +#include "../../../test_hash.h" +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<int, std::string, + test_hash<std::hash<int> >, + test_compare<std::equal_to<int> >, + test_allocator<std::pair<const int, std::string> > + > 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) + ); + 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() == + (test_allocator<std::pair<const int, std::string> >())); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, + test_hash<std::hash<int> >, + test_compare<std::equal_to<int> >, + min_allocator<std::pair<const int, std::string> > + > 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) + ); + 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() == + (min_allocator<std::pair<const int, std::string> >())); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp new file mode 100644 index 0000000000000..99493fad32c59 --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp @@ -0,0 +1,113 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// template <class InputIterator> +// unordered_map(InputIterator first, InputIterator last, size_type n, +// const hasher& hf, const key_equal& eql, +// const allocator_type& a); + +#include <unordered_map> +#include <string> +#include <cassert> +#include <cfloat> + +#include "test_iterators.h" +#include "../../../NotConstructible.h" +#include "../../../test_compare.h" +#include "../../../test_hash.h" +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<int, std::string, + test_hash<std::hash<int> >, + test_compare<std::equal_to<int> >, + test_allocator<std::pair<const int, std::string> > + > 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), + test_allocator<std::pair<const int, std::string> >(10) + ); + 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() == + (test_allocator<std::pair<const int, std::string> >(10))); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, + test_hash<std::hash<int> >, + test_compare<std::equal_to<int> >, + min_allocator<std::pair<const int, std::string> > + > 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), + min_allocator<std::pair<const int, std::string> >() + ); + 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() == + (min_allocator<std::pair<const int, std::string> >())); + assert(!c.empty()); + assert(std::distance(c.begin(), c.end()) == c.size()); + assert(std::distance(c.cbegin(), c.cend()) == c.size()); + assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); + assert(c.max_load_factor() == 1); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp new file mode 100644 index 0000000000000..0a3ae3a117f17 --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp @@ -0,0 +1,69 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// unordered_map(size_type n); + +#include <unordered_map> +#include <cassert> + +#include "../../../NotConstructible.h" +#include "../../../test_compare.h" +#include "../../../test_hash.h" +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<NotConstructible, NotConstructible, + test_hash<std::hash<NotConstructible> >, + test_compare<std::equal_to<NotConstructible> >, + test_allocator<std::pair<const NotConstructible, + NotConstructible> > + > C; + C c = 7; + assert(c.bucket_count() == 7); + assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); + assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); + assert(c.get_allocator() == + (test_allocator<std::pair<const NotConstructible, NotConstructible> >())); + 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 __cplusplus >= 201103L + { + typedef std::unordered_map<NotConstructible, NotConstructible, + test_hash<std::hash<NotConstructible> >, + test_compare<std::equal_to<NotConstructible> >, + min_allocator<std::pair<const NotConstructible, + NotConstructible> > + > C; + C c = 7; + assert(c.bucket_count() == 7); + assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); + assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); + assert(c.get_allocator() == + (min_allocator<std::pair<const NotConstructible, NotConstructible> >())); + 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 +} diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp new file mode 100644 index 0000000000000..708dc2362739b --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp @@ -0,0 +1,69 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// unordered_map(size_type n); + +#include <unordered_map> +#include <cassert> + +#include "../../../NotConstructible.h" +#include "../../../test_compare.h" +#include "../../../test_hash.h" +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<NotConstructible, NotConstructible, + test_hash<std::hash<NotConstructible> >, + test_compare<std::equal_to<NotConstructible> >, + test_allocator<std::pair<const NotConstructible, + NotConstructible> > + > C; + C c(7); + assert(c.bucket_count() == 7); + assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); + assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); + assert(c.get_allocator() == + (test_allocator<std::pair<const NotConstructible, NotConstructible> >())); + 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 __cplusplus >= 201103L + { + typedef std::unordered_map<NotConstructible, NotConstructible, + test_hash<std::hash<NotConstructible> >, + test_compare<std::equal_to<NotConstructible> >, + min_allocator<std::pair<const NotConstructible, + NotConstructible> > + > C; + C c(7); + assert(c.bucket_count() == 7); + assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); + assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); + assert(c.get_allocator() == + (min_allocator<std::pair<const NotConstructible, NotConstructible> >())); + 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 +} diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp new file mode 100644 index 0000000000000..6c975ec72030e --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp @@ -0,0 +1,73 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// unordered_map(size_type n, const hasher& hf); + +#include <unordered_map> +#include <cassert> + +#include "../../../NotConstructible.h" +#include "../../../test_compare.h" +#include "../../../test_hash.h" +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<NotConstructible, NotConstructible, + test_hash<std::hash<NotConstructible> >, + test_compare<std::equal_to<NotConstructible> >, + test_allocator<std::pair<const NotConstructible, + NotConstructible> > + > C; + C c(7, + test_hash<std::hash<NotConstructible> >(8) + ); + 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> >()); + assert(c.get_allocator() == + (test_allocator<std::pair<const NotConstructible, NotConstructible> >())); + 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 __cplusplus >= 201103L + { + typedef std::unordered_map<NotConstructible, NotConstructible, + test_hash<std::hash<NotConstructible> >, + test_compare<std::equal_to<NotConstructible> >, + min_allocator<std::pair<const NotConstructible, + NotConstructible> > + > C; + C c(7, + test_hash<std::hash<NotConstructible> >(8) + ); + 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> >()); + assert(c.get_allocator() == + (min_allocator<std::pair<const NotConstructible, NotConstructible> >())); + 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 +} diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp new file mode 100644 index 0000000000000..8b2bb317987ec --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp @@ -0,0 +1,75 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// unordered_map(size_type n, const hasher& hf, const key_equal& eql); + +#include <unordered_map> +#include <cassert> + +#include "../../../NotConstructible.h" +#include "../../../test_compare.h" +#include "../../../test_hash.h" +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<NotConstructible, NotConstructible, + test_hash<std::hash<NotConstructible> >, + test_compare<std::equal_to<NotConstructible> >, + test_allocator<std::pair<const NotConstructible, + NotConstructible> > + > C; + C c(7, + test_hash<std::hash<NotConstructible> >(8), + test_compare<std::equal_to<NotConstructible> >(9) + ); + 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() == + (test_allocator<std::pair<const NotConstructible, NotConstructible> >())); + 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 __cplusplus >= 201103L + { + typedef std::unordered_map<NotConstructible, NotConstructible, + test_hash<std::hash<NotConstructible> >, + test_compare<std::equal_to<NotConstructible> >, + min_allocator<std::pair<const NotConstructible, + NotConstructible> > + > C; + C c(7, + test_hash<std::hash<NotConstructible> >(8), + test_compare<std::equal_to<NotConstructible> >(9) + ); + 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() == + (min_allocator<std::pair<const NotConstructible, NotConstructible> >())); + 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 +} diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp new file mode 100644 index 0000000000000..bcf7b91503add --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp @@ -0,0 +1,77 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// unordered_map(size_type n, const hasher& hf, const key_equal& eql, const allocator_type& a); + +#include <unordered_map> +#include <cassert> + +#include "../../../NotConstructible.h" +#include "../../../test_compare.h" +#include "../../../test_hash.h" +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<NotConstructible, NotConstructible, + test_hash<std::hash<NotConstructible> >, + test_compare<std::equal_to<NotConstructible> >, + test_allocator<std::pair<const NotConstructible, + NotConstructible> > + > C; + C c(7, + test_hash<std::hash<NotConstructible> >(8), + test_compare<std::equal_to<NotConstructible> >(9), + test_allocator<std::pair<const NotConstructible, NotConstructible> >(10) + ); + 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() == + (test_allocator<std::pair<const NotConstructible, NotConstructible> >(10))); + 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 __cplusplus >= 201103L + { + typedef std::unordered_map<NotConstructible, NotConstructible, + test_hash<std::hash<NotConstructible> >, + test_compare<std::equal_to<NotConstructible> >, + min_allocator<std::pair<const NotConstructible, + NotConstructible> > + > C; + C c(7, + test_hash<std::hash<NotConstructible> >(8), + test_compare<std::equal_to<NotConstructible> >(9), + min_allocator<std::pair<const NotConstructible, NotConstructible> >() + ); + 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() == + (min_allocator<std::pair<const NotConstructible, NotConstructible> >())); + 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 +} diff --git a/test/std/containers/unord/unord.map/unord.map.elem/at.pass.cpp b/test/std/containers/unord/unord.map/unord.map.elem/at.pass.cpp new file mode 100644 index 0000000000000..5fd9f9d6114a8 --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.elem/at.pass.cpp @@ -0,0 +1,134 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// mapped_type& at(const key_type& k); +// const mapped_type& at(const key_type& k) const; + +#include <unordered_map> +#include <string> +#include <cassert> + +#include "MoveOnly.h" +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<int, std::string> 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(a, a + sizeof(a)/sizeof(a[0])); + assert(c.size() == 4); + c.at(1) = "ONE"; + assert(c.at(1) == "ONE"); + try + { + c.at(11) = "eleven"; + assert(false); + } + catch (std::out_of_range&) + { + } + assert(c.size() == 4); + } + { + typedef std::unordered_map<int, std::string> 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"), + }; + const C c(a, a + sizeof(a)/sizeof(a[0])); + assert(c.size() == 4); + assert(c.at(1) == "one"); + try + { + c.at(11); + assert(false); + } + catch (std::out_of_range&) + { + } + assert(c.size() == 4); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> 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(a, a + sizeof(a)/sizeof(a[0])); + assert(c.size() == 4); + c.at(1) = "ONE"; + assert(c.at(1) == "ONE"); + try + { + c.at(11) = "eleven"; + assert(false); + } + catch (std::out_of_range&) + { + } + assert(c.size() == 4); + } + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> 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"), + }; + const C c(a, a + sizeof(a)/sizeof(a[0])); + assert(c.size() == 4); + assert(c.at(1) == "one"); + try + { + c.at(11); + assert(false); + } + catch (std::out_of_range&) + { + } + assert(c.size() == 4); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/unord.map.elem/index.pass.cpp b/test/std/containers/unord/unord.map/unord.map.elem/index.pass.cpp new file mode 100644 index 0000000000000..c072248f866af --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.elem/index.pass.cpp @@ -0,0 +1,115 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// mapped_type& operator[](const key_type& k); + +#include <unordered_map> +#include <string> +#include <cassert> + +#include "MoveOnly.h" +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<int, std::string> 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(a, a + sizeof(a)/sizeof(a[0])); + assert(c.size() == 4); + c[1] = "ONE"; + assert(c.at(1) == "ONE"); + c[11] = "eleven"; + assert(c.size() == 5); + assert(c.at(11) == "eleven"); + } +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + { + typedef std::unordered_map<MoveOnly, std::string> 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(a, a + sizeof(a)/sizeof(a[0])); + assert(c.size() == 4); + c[1] = "ONE"; + assert(c.at(1) == "ONE"); + c[11] = "eleven"; + assert(c.size() == 5); + assert(c.at(11) == "eleven"); + } +#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> 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(a, a + sizeof(a)/sizeof(a[0])); + assert(c.size() == 4); + c[1] = "ONE"; + assert(c.at(1) == "ONE"); + c[11] = "eleven"; + assert(c.size() == 5); + assert(c.at(11) == "eleven"); + } +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + { + typedef std::unordered_map<MoveOnly, std::string, std::hash<MoveOnly>, std::equal_to<MoveOnly>, + min_allocator<std::pair<const MoveOnly, std::string>>> 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(a, a + sizeof(a)/sizeof(a[0])); + assert(c.size() == 4); + c[1] = "ONE"; + assert(c.at(1) == "ONE"); + c[11] = "eleven"; + assert(c.size() == 5); + assert(c.at(11) == "eleven"); + } +#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES +#endif +} diff --git a/test/std/containers/unord/unord.map/unord.map.elem/index_tuple.pass.cpp b/test/std/containers/unord/unord.map/unord.map.elem/index_tuple.pass.cpp new file mode 100644 index 0000000000000..c319b5c30b2c6 --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.elem/index_tuple.pass.cpp @@ -0,0 +1,41 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// mapped_type& operator[](const key_type& k); + +// http://llvm.org/bugs/show_bug.cgi?id=16542 + +#include <unordered_map> + +#ifndef _LIBCPP_HAS_NO_VARIADICS + +#include <tuple> + +using namespace std; + +struct my_hash +{ + size_t operator()(const tuple<int,int>&) const {return 0;} +}; + +#endif + +int main() +{ +#ifndef _LIBCPP_HAS_NO_VARIADICS + unordered_map<tuple<int,int>, size_t, my_hash> m; + m[make_tuple(2,3)]=7; +#endif +} diff --git a/test/std/containers/unord/unord.map/unord.map.swap/db_swap_1.pass.cpp b/test/std/containers/unord/unord.map/unord.map.swap/db_swap_1.pass.cpp new file mode 100644 index 0000000000000..6ab9c923da312 --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.swap/db_swap_1.pass.cpp @@ -0,0 +1,44 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class Value, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, Value>>> +// class unordered_map + +// void swap(unordered_map& x, unordered_map& y); + +#if _LIBCPP_DEBUG >= 1 +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) +#endif + +#include <unordered_map> +#include <cassert> + +int main() +{ +#if _LIBCPP_DEBUG >= 1 + { + typedef std::pair<int, int> P; + P a1[] = {P(1, 1), P(3, 3), P(7, 7), P(9, 9), P(10, 10)}; + P a2[] = {P(0, 0), P(2, 2), P(4, 4), P(5, 5), P(6, 6), P(8, 8), P(11, 11)}; + std::unordered_map<int, int> c1(a1, a1+sizeof(a1)/sizeof(a1[0])); + std::unordered_map<int, int> c2(a2, a2+sizeof(a2)/sizeof(a2[0])); + std::unordered_map<int, int>::iterator i1 = c1.begin(); + std::unordered_map<int, int>::iterator i2 = c2.begin(); + swap(c1, c2); + c1.erase(i2); + c2.erase(i1); + std::unordered_map<int, int>::iterator j = i1; + c1.erase(i1); + assert(false); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/unord.map.swap/swap_noexcept.pass.cpp b/test/std/containers/unord/unord.map/unord.map.swap/swap_noexcept.pass.cpp new file mode 100644 index 0000000000000..1056c231f0db3 --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.swap/swap_noexcept.pass.cpp @@ -0,0 +1,199 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// void swap(unordered_map& c) +// noexcept( +// (!allocator_type::propagate_on_container_swap::value || +// __is_nothrow_swappable<allocator_type>::value) && +// __is_nothrow_swappable<hasher>::value && +// __is_nothrow_swappable<key_equal>::value); +// +// In C++17, the standard says that swap shall have: +// noexcept(allocator_traits<Allocator>::is_always_equal::value && +// noexcept(swap(declval<Hash&>(), declval<Hash&>())) && +// noexcept(swap(declval<Pred&>(), declval<Pred&>()))); + +// This tests a conforming extension + +#include <unordered_map> +#include <cassert> + +#include "MoveOnly.h" +#include "test_allocator.h" + +template <class T> +struct some_comp +{ + typedef T value_type; + + some_comp() {} + some_comp(const some_comp&) {} +}; + +template <class T> +struct some_comp2 +{ + typedef T value_type; + + some_comp2() {} + some_comp2(const some_comp2&) {} + void deallocate(void*, unsigned) {} + typedef std::true_type propagate_on_container_swap; +}; + +#if TEST_STD_VER >= 14 +template <typename T> +void swap(some_comp2<T>&, some_comp2<T>&) noexcept {} +#endif + +template <class T> +struct some_hash +{ + typedef T value_type; + some_hash() {} + some_hash(const some_hash&); +}; + +template <class T> +struct some_hash2 +{ + typedef T value_type; + some_hash2() {} + some_hash2(const some_hash2&); +}; + +#if TEST_STD_VER >= 14 +template <typename T> +void swap(some_hash2<T>&, some_hash2<T>&) noexcept {} +#endif + +template <class T> +struct some_alloc +{ + typedef T value_type; + + some_alloc() {} + some_alloc(const some_alloc&); + void deallocate(void*, unsigned) {} + + typedef std::true_type propagate_on_container_swap; +}; + +template <class T> +struct some_alloc2 +{ + typedef T value_type; + + some_alloc2() {} + some_alloc2(const some_alloc2&); + void deallocate(void*, unsigned) {} + + typedef std::false_type propagate_on_container_swap; + typedef std::true_type is_always_equal; +}; + +template <class T> +struct some_alloc3 +{ + typedef T value_type; + + some_alloc3() {} + some_alloc3(const some_alloc3&); + void deallocate(void*, unsigned) {} + + typedef std::false_type propagate_on_container_swap; + typedef std::false_type is_always_equal; +}; + + +int main() +{ +#if __has_feature(cxx_noexcept) + typedef std::pair<const MoveOnly, MoveOnly> MapType; + { + typedef std::unordered_map<MoveOnly, MoveOnly> C; + C c1, c2; + static_assert(noexcept(swap(c1, c2)), ""); + } + { + typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, + std::equal_to<MoveOnly>, test_allocator<MapType>> C; + C c1, c2; + static_assert(noexcept(swap(c1, c2)), ""); + } + { + typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, + std::equal_to<MoveOnly>, other_allocator<MapType>> C; + C c1, c2; + static_assert(noexcept(swap(c1, c2)), ""); + } + { + typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>> C; + C c1, c2; + static_assert(!noexcept(swap(c1, c2)), ""); + } + { + typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, + some_comp<MoveOnly>> C; + C c1, c2; + static_assert(!noexcept(swap(c1, c2)), ""); + } + +#if TEST_STD_VER >= 14 + { // POCS allocator, throwable swap for hash, throwable swap for comp + typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp <MoveOnly>, some_alloc <MapType>> C; + C c1, c2; + static_assert(!noexcept(swap(c1, c2)), ""); + } + { // always equal allocator, throwable swap for hash, throwable swap for comp + typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp <MoveOnly>, some_alloc2<MapType>> C; + C c1, c2; + static_assert(!noexcept(swap(c1, c2)), ""); + } + { // POCS allocator, throwable swap for hash, nothrow swap for comp + typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp2<MoveOnly>, some_alloc <MapType>> C; + C c1, c2; + static_assert(!noexcept(swap(c1, c2)), ""); + } + { // always equal allocator, throwable swap for hash, nothrow swap for comp + typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>, some_comp2<MoveOnly>, some_alloc2<MapType>> C; + C c1, c2; + static_assert(!noexcept(swap(c1, c2)), ""); + } + { // POCS allocator, nothrow swap for hash, throwable swap for comp + typedef std::unordered_map<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp <MoveOnly>, some_alloc <MapType>> C; + C c1, c2; + static_assert(!noexcept(swap(c1, c2)), ""); + } + { // always equal allocator, nothrow swap for hash, throwable swap for comp + typedef std::unordered_map<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp <MoveOnly>, some_alloc2<MapType>> C; + C c1, c2; + static_assert(!noexcept(swap(c1, c2)), ""); + } + { // POCS allocator, nothrow swap for hash, nothrow swap for comp + typedef std::unordered_map<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc <MapType>> C; + C c1, c2; + static_assert( noexcept(swap(c1, c2)), ""); + } + { // always equal allocator, nothrow swap for hash, nothrow swap for comp + typedef std::unordered_map<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc2<MapType>> C; + C c1, c2; + static_assert( noexcept(swap(c1, c2)), ""); + } + + { // NOT always equal allocator, nothrow swap for hash, nothrow swap for comp + typedef std::unordered_map<MoveOnly, MoveOnly, some_hash2<MoveOnly>, some_comp2<MoveOnly>, some_alloc3<MapType>> C; + C c1, c2; + static_assert( noexcept(swap(c1, c2)), ""); + } +#endif +#endif +} diff --git a/test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp b/test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp new file mode 100644 index 0000000000000..7e04b8db117cc --- /dev/null +++ b/test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp @@ -0,0 +1,572 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// void swap(unordered_map& __u); + +#include <unordered_map> +#include <string> +#include <cassert> + +#include "../../../test_compare.h" +#include "../../../test_hash.h" +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ + { + typedef test_hash<std::hash<int> > Hash; + typedef test_compare<std::equal_to<int> > Compare; + typedef test_allocator<std::pair<const int, std::string> > Alloc; + typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; + typedef std::pair<int, std::string> P; + C c1(0, Hash(1), Compare(1), Alloc(1)); + C c2(0, Hash(2), Compare(2), Alloc(2)); + c2.max_load_factor(2); + swap(c1, c2); + + assert(c1.bucket_count() == 0); + assert(c1.size() == 0); + assert(c1.hash_function() == Hash(2)); + assert(c1.key_eq() == Compare(2)); + assert(c1.get_allocator() == Alloc(1)); + assert(std::distance(c1.begin(), c1.end()) == c1.size()); + assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); + assert(c1.max_load_factor() == 2); + + assert(c2.bucket_count() == 0); + assert(c2.size() == 0); + assert(c2.hash_function() == Hash(1)); + assert(c2.key_eq() == Compare(1)); + assert(c2.get_allocator() == Alloc(2)); + assert(std::distance(c2.begin(), c2.end()) == c2.size()); + assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); + assert(c2.max_load_factor() == 1); + } + { + typedef test_hash<std::hash<int> > Hash; + typedef test_compare<std::equal_to<int> > Compare; + typedef test_allocator<std::pair<const int, std::string> > Alloc; + typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; + typedef std::pair<int, std::string> P; + P a2[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + C c1(0, Hash(1), Compare(1), Alloc(1)); + C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); + c2.max_load_factor(2); + swap(c1, c2); + + assert(c1.bucket_count() >= 11); + assert(c1.size() == 8); + assert(c1.at(10) == "ten"); + assert(c1.at(20) == "twenty"); + assert(c1.at(30) == "thirty"); + assert(c1.at(40) == "forty"); + assert(c1.at(50) == "fifty"); + assert(c1.at(60) == "sixty"); + assert(c1.at(70) == "seventy"); + assert(c1.at(80) == "eighty"); + assert(c1.hash_function() == Hash(2)); + assert(c1.key_eq() == Compare(2)); + assert(c1.get_allocator() == Alloc(1)); + assert(std::distance(c1.begin(), c1.end()) == c1.size()); + assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); + assert(c1.max_load_factor() == 2); + + assert(c2.bucket_count() == 0); + assert(c2.size() == 0); + assert(c2.hash_function() == Hash(1)); + assert(c2.key_eq() == Compare(1)); + assert(c2.get_allocator() == Alloc(2)); + assert(std::distance(c2.begin(), c2.end()) == c2.size()); + assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); + assert(c2.max_load_factor() == 1); + } + { + typedef test_hash<std::hash<int> > Hash; + typedef test_compare<std::equal_to<int> > Compare; + typedef test_allocator<std::pair<const int, std::string> > Alloc; + typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; + typedef std::pair<int, std::string> P; + P a1[] = + { + P(1, "one"), + P(2, "two"), + P(3, "three"), + P(4, "four"), + P(1, "four"), + P(2, "four"), + }; + C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); + C c2(0, Hash(2), Compare(2), Alloc(2)); + c2.max_load_factor(2); + swap(c1, c2); + + assert(c1.bucket_count() == 0); + assert(c1.size() == 0); + assert(c1.hash_function() == Hash(2)); + assert(c1.key_eq() == Compare(2)); + assert(c1.get_allocator() == Alloc(1)); + assert(std::distance(c1.begin(), c1.end()) == c1.size()); + assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); + assert(c1.max_load_factor() == 2); + + assert(c2.bucket_count() >= 5); + assert(c2.size() == 4); + assert(c2.at(1) == "one"); + assert(c2.at(2) == "two"); + assert(c2.at(3) == "three"); + assert(c2.at(4) == "four"); + assert(c2.hash_function() == Hash(1)); + assert(c2.key_eq() == Compare(1)); + assert(c2.get_allocator() == Alloc(2)); + assert(std::distance(c2.begin(), c2.end()) == c2.size()); + assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); + assert(c2.max_load_factor() == 1); + } + { + typedef test_hash<std::hash<int> > Hash; + typedef test_compare<std::equal_to<int> > Compare; + typedef test_allocator<std::pair<const int, std::string> > Alloc; + typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; + typedef std::pair<int, std::string> P; + P a1[] = + { + P(1, "one"), + P(2, "two"), + P(3, "three"), + P(4, "four"), + P(1, "four"), + P(2, "four"), + }; + P a2[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); + C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); + c2.max_load_factor(2); + swap(c1, c2); + + assert(c1.bucket_count() >= 11); + assert(c1.size() == 8); + assert(c1.at(10) == "ten"); + assert(c1.at(20) == "twenty"); + assert(c1.at(30) == "thirty"); + assert(c1.at(40) == "forty"); + assert(c1.at(50) == "fifty"); + assert(c1.at(60) == "sixty"); + assert(c1.at(70) == "seventy"); + assert(c1.at(80) == "eighty"); + assert(c1.hash_function() == Hash(2)); + assert(c1.key_eq() == Compare(2)); + assert(c1.get_allocator() == Alloc(1)); + assert(std::distance(c1.begin(), c1.end()) == c1.size()); + assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); + assert(c1.max_load_factor() == 2); + + assert(c2.bucket_count() >= 5); + assert(c2.size() == 4); + assert(c2.at(1) == "one"); + assert(c2.at(2) == "two"); + assert(c2.at(3) == "three"); + assert(c2.at(4) == "four"); + assert(c2.hash_function() == Hash(1)); + assert(c2.key_eq() == Compare(1)); + assert(c2.get_allocator() == Alloc(2)); + assert(std::distance(c2.begin(), c2.end()) == c2.size()); + assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); + assert(c2.max_load_factor() == 1); + } + + { + typedef test_hash<std::hash<int> > Hash; + typedef test_compare<std::equal_to<int> > Compare; + typedef other_allocator<std::pair<const int, std::string> > Alloc; + typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; + typedef std::pair<int, std::string> P; + C c1(0, Hash(1), Compare(1), Alloc(1)); + C c2(0, Hash(2), Compare(2), Alloc(2)); + c2.max_load_factor(2); + swap(c1, c2); + + assert(c1.bucket_count() == 0); + assert(c1.size() == 0); + assert(c1.hash_function() == Hash(2)); + assert(c1.key_eq() == Compare(2)); + assert(c1.get_allocator() == Alloc(2)); + assert(std::distance(c1.begin(), c1.end()) == c1.size()); + assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); + assert(c1.max_load_factor() == 2); + + assert(c2.bucket_count() == 0); + assert(c2.size() == 0); + assert(c2.hash_function() == Hash(1)); + assert(c2.key_eq() == Compare(1)); + assert(c2.get_allocator() == Alloc(1)); + assert(std::distance(c2.begin(), c2.end()) == c2.size()); + assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); + assert(c2.max_load_factor() == 1); + } + { + typedef test_hash<std::hash<int> > Hash; + typedef test_compare<std::equal_to<int> > Compare; + typedef other_allocator<std::pair<const int, std::string> > Alloc; + typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; + typedef std::pair<int, std::string> P; + P a2[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + C c1(0, Hash(1), Compare(1), Alloc(1)); + C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); + c2.max_load_factor(2); + swap(c1, c2); + + assert(c1.bucket_count() >= 11); + assert(c1.size() == 8); + assert(c1.at(10) == "ten"); + assert(c1.at(20) == "twenty"); + assert(c1.at(30) == "thirty"); + assert(c1.at(40) == "forty"); + assert(c1.at(50) == "fifty"); + assert(c1.at(60) == "sixty"); + assert(c1.at(70) == "seventy"); + assert(c1.at(80) == "eighty"); + assert(c1.hash_function() == Hash(2)); + assert(c1.key_eq() == Compare(2)); + assert(c1.get_allocator() == Alloc(2)); + assert(std::distance(c1.begin(), c1.end()) == c1.size()); + assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); + assert(c1.max_load_factor() == 2); + + assert(c2.bucket_count() == 0); + assert(c2.size() == 0); + assert(c2.hash_function() == Hash(1)); + assert(c2.key_eq() == Compare(1)); + assert(c2.get_allocator() == Alloc(1)); + assert(std::distance(c2.begin(), c2.end()) == c2.size()); + assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); + assert(c2.max_load_factor() == 1); + } + { + typedef test_hash<std::hash<int> > Hash; + typedef test_compare<std::equal_to<int> > Compare; + typedef other_allocator<std::pair<const int, std::string> > Alloc; + typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; + typedef std::pair<int, std::string> P; + P a1[] = + { + P(1, "one"), + P(2, "two"), + P(3, "three"), + P(4, "four"), + P(1, "four"), + P(2, "four"), + }; + C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); + C c2(0, Hash(2), Compare(2), Alloc(2)); + c2.max_load_factor(2); + swap(c1, c2); + + assert(c1.bucket_count() == 0); + assert(c1.size() == 0); + assert(c1.hash_function() == Hash(2)); + assert(c1.key_eq() == Compare(2)); + assert(c1.get_allocator() == Alloc(2)); + assert(std::distance(c1.begin(), c1.end()) == c1.size()); + assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); + assert(c1.max_load_factor() == 2); + + assert(c2.bucket_count() >= 5); + assert(c2.size() == 4); + assert(c2.at(1) == "one"); + assert(c2.at(2) == "two"); + assert(c2.at(3) == "three"); + assert(c2.at(4) == "four"); + assert(c2.hash_function() == Hash(1)); + assert(c2.key_eq() == Compare(1)); + assert(c2.get_allocator() == Alloc(1)); + assert(std::distance(c2.begin(), c2.end()) == c2.size()); + assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); + assert(c2.max_load_factor() == 1); + } + { + typedef test_hash<std::hash<int> > Hash; + typedef test_compare<std::equal_to<int> > Compare; + typedef other_allocator<std::pair<const int, std::string> > Alloc; + typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; + typedef std::pair<int, std::string> P; + P a1[] = + { + P(1, "one"), + P(2, "two"), + P(3, "three"), + P(4, "four"), + P(1, "four"), + P(2, "four"), + }; + P a2[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); + C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); + c2.max_load_factor(2); + swap(c1, c2); + + assert(c1.bucket_count() >= 11); + assert(c1.size() == 8); + assert(c1.at(10) == "ten"); + assert(c1.at(20) == "twenty"); + assert(c1.at(30) == "thirty"); + assert(c1.at(40) == "forty"); + assert(c1.at(50) == "fifty"); + assert(c1.at(60) == "sixty"); + assert(c1.at(70) == "seventy"); + assert(c1.at(80) == "eighty"); + assert(c1.hash_function() == Hash(2)); + assert(c1.key_eq() == Compare(2)); + assert(c1.get_allocator() == Alloc(2)); + assert(std::distance(c1.begin(), c1.end()) == c1.size()); + assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); + assert(c1.max_load_factor() == 2); + + assert(c2.bucket_count() >= 5); + assert(c2.size() == 4); + assert(c2.at(1) == "one"); + assert(c2.at(2) == "two"); + assert(c2.at(3) == "three"); + assert(c2.at(4) == "four"); + assert(c2.hash_function() == Hash(1)); + assert(c2.key_eq() == Compare(1)); + assert(c2.get_allocator() == Alloc(1)); + assert(std::distance(c2.begin(), c2.end()) == c2.size()); + assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); + assert(c2.max_load_factor() == 1); + } +#if __cplusplus >= 201103L + { + typedef test_hash<std::hash<int> > Hash; + typedef test_compare<std::equal_to<int> > Compare; + typedef min_allocator<std::pair<const int, std::string> > Alloc; + typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; + typedef std::pair<int, std::string> P; + C c1(0, Hash(1), Compare(1), Alloc()); + C c2(0, Hash(2), Compare(2), Alloc()); + c2.max_load_factor(2); + swap(c1, c2); + + assert(c1.bucket_count() == 0); + assert(c1.size() == 0); + assert(c1.hash_function() == Hash(2)); + assert(c1.key_eq() == Compare(2)); + assert(c1.get_allocator() == Alloc()); + assert(std::distance(c1.begin(), c1.end()) == c1.size()); + assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); + assert(c1.max_load_factor() == 2); + + assert(c2.bucket_count() == 0); + assert(c2.size() == 0); + assert(c2.hash_function() == Hash(1)); + assert(c2.key_eq() == Compare(1)); + assert(c2.get_allocator() == Alloc()); + assert(std::distance(c2.begin(), c2.end()) == c2.size()); + assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); + assert(c2.max_load_factor() == 1); + } + { + typedef test_hash<std::hash<int> > Hash; + typedef test_compare<std::equal_to<int> > Compare; + typedef min_allocator<std::pair<const int, std::string> > Alloc; + typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; + typedef std::pair<int, std::string> P; + P a2[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + C c1(0, Hash(1), Compare(1), Alloc()); + C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc()); + c2.max_load_factor(2); + swap(c1, c2); + + assert(c1.bucket_count() >= 11); + assert(c1.size() == 8); + assert(c1.at(10) == "ten"); + assert(c1.at(20) == "twenty"); + assert(c1.at(30) == "thirty"); + assert(c1.at(40) == "forty"); + assert(c1.at(50) == "fifty"); + assert(c1.at(60) == "sixty"); + assert(c1.at(70) == "seventy"); + assert(c1.at(80) == "eighty"); + assert(c1.hash_function() == Hash(2)); + assert(c1.key_eq() == Compare(2)); + assert(c1.get_allocator() == Alloc()); + assert(std::distance(c1.begin(), c1.end()) == c1.size()); + assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); + assert(c1.max_load_factor() == 2); + + assert(c2.bucket_count() == 0); + assert(c2.size() == 0); + assert(c2.hash_function() == Hash(1)); + assert(c2.key_eq() == Compare(1)); + assert(c2.get_allocator() == Alloc()); + assert(std::distance(c2.begin(), c2.end()) == c2.size()); + assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); + assert(c2.max_load_factor() == 1); + } + { + typedef test_hash<std::hash<int> > Hash; + typedef test_compare<std::equal_to<int> > Compare; + typedef min_allocator<std::pair<const int, std::string> > Alloc; + typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; + typedef std::pair<int, std::string> P; + P a1[] = + { + P(1, "one"), + P(2, "two"), + P(3, "three"), + P(4, "four"), + P(1, "four"), + P(2, "four"), + }; + C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc()); + C c2(0, Hash(2), Compare(2), Alloc()); + c2.max_load_factor(2); + swap(c1, c2); + + assert(c1.bucket_count() == 0); + assert(c1.size() == 0); + assert(c1.hash_function() == Hash(2)); + assert(c1.key_eq() == Compare(2)); + assert(c1.get_allocator() == Alloc()); + assert(std::distance(c1.begin(), c1.end()) == c1.size()); + assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); + assert(c1.max_load_factor() == 2); + + assert(c2.bucket_count() >= 5); + assert(c2.size() == 4); + assert(c2.at(1) == "one"); + assert(c2.at(2) == "two"); + assert(c2.at(3) == "three"); + assert(c2.at(4) == "four"); + assert(c2.hash_function() == Hash(1)); + assert(c2.key_eq() == Compare(1)); + assert(c2.get_allocator() == Alloc()); + assert(std::distance(c2.begin(), c2.end()) == c2.size()); + assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); + assert(c2.max_load_factor() == 1); + } + { + typedef test_hash<std::hash<int> > Hash; + typedef test_compare<std::equal_to<int> > Compare; + typedef min_allocator<std::pair<const int, std::string> > Alloc; + typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; + typedef std::pair<int, std::string> P; + P a1[] = + { + P(1, "one"), + P(2, "two"), + P(3, "three"), + P(4, "four"), + P(1, "four"), + P(2, "four"), + }; + P a2[] = + { + P(10, "ten"), + P(20, "twenty"), + P(30, "thirty"), + P(40, "forty"), + P(50, "fifty"), + P(60, "sixty"), + P(70, "seventy"), + P(80, "eighty"), + }; + C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc()); + C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc()); + c2.max_load_factor(2); + swap(c1, c2); + + assert(c1.bucket_count() >= 11); + assert(c1.size() == 8); + assert(c1.at(10) == "ten"); + assert(c1.at(20) == "twenty"); + assert(c1.at(30) == "thirty"); + assert(c1.at(40) == "forty"); + assert(c1.at(50) == "fifty"); + assert(c1.at(60) == "sixty"); + assert(c1.at(70) == "seventy"); + assert(c1.at(80) == "eighty"); + assert(c1.hash_function() == Hash(2)); + assert(c1.key_eq() == Compare(2)); + assert(c1.get_allocator() == Alloc()); + assert(std::distance(c1.begin(), c1.end()) == c1.size()); + assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); + assert(c1.max_load_factor() == 2); + + assert(c2.bucket_count() >= 5); + assert(c2.size() == 4); + assert(c2.at(1) == "one"); + assert(c2.at(2) == "two"); + assert(c2.at(3) == "three"); + assert(c2.at(4) == "four"); + assert(c2.hash_function() == Hash(1)); + assert(c2.key_eq() == Compare(1)); + assert(c2.get_allocator() == Alloc()); + assert(std::distance(c2.begin(), c2.end()) == c2.size()); + assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); + assert(c2.max_load_factor() == 1); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/unorder.map.modifiers/clear.pass.cpp b/test/std/containers/unord/unord.map/unorder.map.modifiers/clear.pass.cpp new file mode 100644 index 0000000000000..9f320e9494798 --- /dev/null +++ b/test/std/containers/unord/unord.map/unorder.map.modifiers/clear.pass.cpp @@ -0,0 +1,61 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// void clear() + +#include <unordered_map> +#include <string> +#include <cassert> + +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<int, std::string> 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(a, a + sizeof(a)/sizeof(a[0])); + c.clear(); + assert(c.size() == 0); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> 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(a, a + sizeof(a)/sizeof(a[0])); + c.clear(); + assert(c.size() == 0); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/unorder.map.modifiers/emplace.pass.cpp b/test/std/containers/unord/unord.map/unorder.map.modifiers/emplace.pass.cpp new file mode 100644 index 0000000000000..5de74d2e6c92e --- /dev/null +++ b/test/std/containers/unord/unord.map/unorder.map.modifiers/emplace.pass.cpp @@ -0,0 +1,80 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// template <class... Args> +// pair<iterator, bool> emplace(Args&&... args); + +#include <unordered_map> +#include <cassert> + +#include "../../../Emplaceable.h" +#include "min_allocator.h" + +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 +} diff --git a/test/std/containers/unord/unord.map/unorder.map.modifiers/emplace_hint.pass.cpp b/test/std/containers/unord/unord.map/unorder.map.modifiers/emplace_hint.pass.cpp new file mode 100644 index 0000000000000..21a4689658ae3 --- /dev/null +++ b/test/std/containers/unord/unord.map/unorder.map.modifiers/emplace_hint.pass.cpp @@ -0,0 +1,93 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// template <class... Args> +// iterator emplace_hint(const_iterator p, Args&&... args); + +#if _LIBCPP_DEBUG >= 1 +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) +#endif + +#include <unordered_map> +#include <cassert> + +#include "../../../Emplaceable.h" +#include "min_allocator.h" + +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 +} diff --git a/test/std/containers/unord/unord.map/unorder.map.modifiers/erase_const_iter.pass.cpp b/test/std/containers/unord/unord.map/unorder.map.modifiers/erase_const_iter.pass.cpp new file mode 100644 index 0000000000000..dbb812974d46d --- /dev/null +++ b/test/std/containers/unord/unord.map/unorder.map.modifiers/erase_const_iter.pass.cpp @@ -0,0 +1,92 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// iterator erase(const_iterator p) + +#include <unordered_map> +#include <string> +#include <cassert> + +#include "min_allocator.h" + +struct TemplateConstructor +{ + template<typename T> + TemplateConstructor (const T&) {} +}; + +bool operator==(const TemplateConstructor&, const TemplateConstructor&) { return false; } +struct Hash { size_t operator() (const TemplateConstructor &) const { return 0; } }; + +int main() +{ + { + typedef std::unordered_map<int, std::string> 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(a, a + sizeof(a)/sizeof(a[0])); + C::const_iterator i = c.find(2); + C::iterator j = c.erase(i); + assert(c.size() == 3); + assert(c.at(1) == "one"); + assert(c.at(3) == "three"); + assert(c.at(4) == "four"); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> 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(a, a + sizeof(a)/sizeof(a[0])); + C::const_iterator i = c.find(2); + C::iterator j = c.erase(i); + assert(c.size() == 3); + assert(c.at(1) == "one"); + assert(c.at(3) == "three"); + assert(c.at(4) == "four"); + } +#endif +#if __cplusplus >= 201402L + { + // This is LWG #2059 + typedef TemplateConstructor T; + typedef std::unordered_map<T, int, Hash> C; + typedef C::iterator I; + + C m; + T a{0}; + I it = m.find(a); + if (it != m.end()) + m.erase(it); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/unorder.map.modifiers/erase_iter_db1.pass.cpp b/test/std/containers/unord/unord.map/unorder.map.modifiers/erase_iter_db1.pass.cpp new file mode 100644 index 0000000000000..60b093553f183 --- /dev/null +++ b/test/std/containers/unord/unord.map/unorder.map.modifiers/erase_iter_db1.pass.cpp @@ -0,0 +1,39 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// Call erase(const_iterator position) with end() + +#if _LIBCPP_DEBUG >= 1 + +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) + +#include <unordered_map> +#include <cassert> + +int main() +{ + { + typedef std::pair<int, int> P; + P a1[] = {P(1, 1), P(2, 2), P(3, 3)}; + std::unordered_map<int, int> l1(a1, a1+3); + std::unordered_map<int, int>::const_iterator i = l1.end(); + l1.erase(i); + assert(false); + } +} + +#else + +int main() +{ +} + +#endif diff --git a/test/std/containers/unord/unord.map/unorder.map.modifiers/erase_iter_db2.pass.cpp b/test/std/containers/unord/unord.map/unorder.map.modifiers/erase_iter_db2.pass.cpp new file mode 100644 index 0000000000000..05046f5dedc11 --- /dev/null +++ b/test/std/containers/unord/unord.map/unorder.map.modifiers/erase_iter_db2.pass.cpp @@ -0,0 +1,42 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// Call erase(const_iterator position) with iterator from another container + +#if _LIBCPP_DEBUG >= 1 + +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) + +#include <unordered_map> +#include <cassert> +#include <cstdlib> +#include <exception> + +int main() +{ + { + typedef std::pair<int, int> P; + P a1[] = {P(1, 1), P(2, 2), P(3, 3)}; + std::unordered_map<int, int> l1(a1, a1+3); + std::unordered_map<int, int> l2(a1, a1+3); + std::unordered_map<int, int>::const_iterator i = l2.begin(); + l1.erase(i); + assert(false); + } +} + +#else + +int main() +{ +} + +#endif diff --git a/test/std/containers/unord/unord.map/unorder.map.modifiers/erase_iter_iter_db1.pass.cpp b/test/std/containers/unord/unord.map/unorder.map.modifiers/erase_iter_iter_db1.pass.cpp new file mode 100644 index 0000000000000..81a8d3de15760 --- /dev/null +++ b/test/std/containers/unord/unord.map/unorder.map.modifiers/erase_iter_iter_db1.pass.cpp @@ -0,0 +1,41 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// Call erase(const_iterator first, const_iterator last); with first iterator from another container + +#if _LIBCPP_DEBUG >= 1 + +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) + +#include <unordered_map> +#include <cassert> +#include <exception> +#include <cstdlib> + +int main() +{ + { + typedef std::pair<int, int> P; + P a1[] = {P(1, 1), P(2, 2), P(3, 3)}; + std::unordered_map<int, int> l1(a1, a1+3); + std::unordered_map<int, int> l2(a1, a1+3); + std::unordered_map<int, int>::iterator i = l1.erase(l2.cbegin(), next(l1.cbegin())); + assert(false); + } +} + +#else + +int main() +{ +} + +#endif diff --git a/test/std/containers/unord/unord.map/unorder.map.modifiers/erase_iter_iter_db2.pass.cpp b/test/std/containers/unord/unord.map/unorder.map.modifiers/erase_iter_iter_db2.pass.cpp new file mode 100644 index 0000000000000..4b103a0ad75c9 --- /dev/null +++ b/test/std/containers/unord/unord.map/unorder.map.modifiers/erase_iter_iter_db2.pass.cpp @@ -0,0 +1,41 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// Call erase(const_iterator first, const_iterator last); with second iterator from another container + +#if _LIBCPP_DEBUG >= 1 + +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) + +#include <unordered_map> +#include <cassert> +#include <exception> +#include <cstdlib> + +int main() +{ + { + typedef std::pair<int, int> P; + P a1[] = {P(1, 1), P(2, 2), P(3, 3)}; + std::unordered_map<int, int> l1(a1, a1+3); + std::unordered_map<int, int> l2(a1, a1+3); + std::unordered_map<int, int>::iterator i = l1.erase(l1.cbegin(), next(l2.cbegin())); + assert(false); + } +} + +#else + +int main() +{ +} + +#endif diff --git a/test/std/containers/unord/unord.map/unorder.map.modifiers/erase_iter_iter_db3.pass.cpp b/test/std/containers/unord/unord.map/unorder.map.modifiers/erase_iter_iter_db3.pass.cpp new file mode 100644 index 0000000000000..6ef1e07add1e4 --- /dev/null +++ b/test/std/containers/unord/unord.map/unorder.map.modifiers/erase_iter_iter_db3.pass.cpp @@ -0,0 +1,41 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// Call erase(const_iterator first, const_iterator last); with both iterators from another container + +#if _LIBCPP_DEBUG >= 1 + +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) + +#include <unordered_map> +#include <cassert> +#include <exception> +#include <cstdlib> + +int main() +{ + { + typedef std::pair<int, int> P; + P a1[] = {P(1, 1), P(2, 2), P(3, 3)}; + std::unordered_map<int, int> l1(a1, a1+3); + std::unordered_map<int, int> l2(a1, a1+3); + std::unordered_map<int, int>::iterator i = l1.erase(l2.cbegin(), next(l2.cbegin())); + assert(false); + } +} + +#else + +int main() +{ +} + +#endif diff --git a/test/std/containers/unord/unord.map/unorder.map.modifiers/erase_iter_iter_db4.pass.cpp b/test/std/containers/unord/unord.map/unorder.map.modifiers/erase_iter_iter_db4.pass.cpp new file mode 100644 index 0000000000000..1185ddf8fd4a5 --- /dev/null +++ b/test/std/containers/unord/unord.map/unorder.map.modifiers/erase_iter_iter_db4.pass.cpp @@ -0,0 +1,40 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// Call erase(const_iterator first, const_iterator last); with a bad range + +#if _LIBCPP_DEBUG >= 1 + +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) + +#include <unordered_map> +#include <cassert> +#include <exception> +#include <cstdlib> + +int main() +{ + { + typedef std::pair<int, int> P; + P a1[] = {P(1, 1), P(2, 2), P(3, 3)}; + std::unordered_map<int, int> l1(a1, a1+3); + std::unordered_map<int, int>::iterator i = l1.erase(next(l1.cbegin()), l1.cbegin()); + assert(false); + } +} + +#else + +int main() +{ +} + +#endif diff --git a/test/std/containers/unord/unord.map/unorder.map.modifiers/erase_key.pass.cpp b/test/std/containers/unord/unord.map/unorder.map.modifiers/erase_key.pass.cpp new file mode 100644 index 0000000000000..0e8ef8b895a74 --- /dev/null +++ b/test/std/containers/unord/unord.map/unorder.map.modifiers/erase_key.pass.cpp @@ -0,0 +1,177 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// size_type erase(const key_type& k); + +#include <unordered_map> +#include <string> +#include <cassert> + +#include "min_allocator.h" + +#if __cplusplus >= 201103L +template <typename Unordered> +bool only_deletions ( const Unordered &whole, const Unordered &part ) { + typename Unordered::const_iterator w = whole.begin(); + typename Unordered::const_iterator p = part.begin(); + + while ( w != whole.end () && p != part.end()) { + if ( *w == *p ) + p++; + w++; + } + + return p == part.end(); +} +#endif + + +int main() +{ + { + typedef std::unordered_map<int, std::string> 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(a, a + sizeof(a)/sizeof(a[0])); + assert(c.erase(5) == 0); + 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.erase(2) == 1); + assert(c.size() == 3); + assert(c.at(1) == "one"); + assert(c.at(3) == "three"); + assert(c.at(4) == "four"); + + assert(c.erase(2) == 0); + assert(c.size() == 3); + assert(c.at(1) == "one"); + assert(c.at(3) == "three"); + assert(c.at(4) == "four"); + + assert(c.erase(4) == 1); + assert(c.size() == 2); + assert(c.at(1) == "one"); + assert(c.at(3) == "three"); + + assert(c.erase(4) == 0); + assert(c.size() == 2); + assert(c.at(1) == "one"); + assert(c.at(3) == "three"); + + assert(c.erase(1) == 1); + assert(c.size() == 1); + assert(c.at(3) == "three"); + + assert(c.erase(1) == 0); + assert(c.size() == 1); + assert(c.at(3) == "three"); + + assert(c.erase(3) == 1); + assert(c.size() == 0); + + assert(c.erase(3) == 0); + assert(c.size() == 0); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> 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(a, a + sizeof(a)/sizeof(a[0])); + assert(c.erase(5) == 0); + 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.erase(2) == 1); + assert(c.size() == 3); + assert(c.at(1) == "one"); + assert(c.at(3) == "three"); + assert(c.at(4) == "four"); + + assert(c.erase(2) == 0); + assert(c.size() == 3); + assert(c.at(1) == "one"); + assert(c.at(3) == "three"); + assert(c.at(4) == "four"); + + assert(c.erase(4) == 1); + assert(c.size() == 2); + assert(c.at(1) == "one"); + assert(c.at(3) == "three"); + + assert(c.erase(4) == 0); + assert(c.size() == 2); + assert(c.at(1) == "one"); + assert(c.at(3) == "three"); + + assert(c.erase(1) == 1); + assert(c.size() == 1); + assert(c.at(3) == "three"); + + assert(c.erase(1) == 0); + assert(c.size() == 1); + assert(c.at(3) == "three"); + + assert(c.erase(3) == 1); + assert(c.size() == 0); + + assert(c.erase(3) == 0); + assert(c.size() == 0); + } + { + typedef std::unordered_map<int, int> C; + C m, m2; + for ( int i = 0; i < 10; ++i ) { + m[i] = i; + m2[i] = i; + } + + C::iterator i = m2.begin(); + int ctr = 0; + while (i != m2.end()) { + if (ctr++ % 2 == 0) + m2.erase(i++); + else + ++i; + } + + assert (only_deletions (m, m2)); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/unorder.map.modifiers/erase_range.pass.cpp b/test/std/containers/unord/unord.map/unorder.map.modifiers/erase_range.pass.cpp new file mode 100644 index 0000000000000..f0664c3c3ffc1 --- /dev/null +++ b/test/std/containers/unord/unord.map/unorder.map.modifiers/erase_range.pass.cpp @@ -0,0 +1,99 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// iterator erase(const_iterator first, const_iterator last) + +#include <unordered_map> +#include <string> +#include <cassert> + +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<int, std::string> 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(a, a + sizeof(a)/sizeof(a[0])); + C::const_iterator i = c.find(2); + C::const_iterator j = next(i, 1); + C::iterator k = c.erase(i, i); + assert(k == i); + assert(c.size() == 4); + assert(c.at(1) == "one"); + assert(c.at(2) == "two"); + assert(c.at(3) == "three"); + assert(c.at(4) == "four"); + + k = c.erase(i, j); + assert(c.size() == 3); + assert(k == j); + assert(c.at(1) == "one"); + assert(c.at(3) == "three"); + assert(c.at(4) == "four"); + + k = c.erase(c.cbegin(), c.cend()); + assert(k == c.cend()); + assert(c.size() == 0); + assert(k == c.end()); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> 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(a, a + sizeof(a)/sizeof(a[0])); + C::const_iterator i = c.find(2); + C::const_iterator j = next(i, 1); + C::iterator k = c.erase(i, i); + assert(k == i); + assert(c.size() == 4); + assert(c.at(1) == "one"); + assert(c.at(2) == "two"); + assert(c.at(3) == "three"); + assert(c.at(4) == "four"); + + k = c.erase(i, j); + assert(c.size() == 3); + assert(k == j); + assert(c.at(1) == "one"); + assert(c.at(3) == "three"); + assert(c.at(4) == "four"); + + k = c.erase(c.cbegin(), c.cend()); + assert(k == c.cend()); + assert(c.size() == 0); + assert(k == c.end()); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/unorder.map.modifiers/insert_const_lvalue.pass.cpp b/test/std/containers/unord/unord.map/unorder.map.modifiers/insert_const_lvalue.pass.cpp new file mode 100644 index 0000000000000..a16f097b4c01f --- /dev/null +++ b/test/std/containers/unord/unord.map/unorder.map.modifiers/insert_const_lvalue.pass.cpp @@ -0,0 +1,86 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// pair<iterator, bool> insert(const value_type& x); + +#include <unordered_map> +#include <cassert> + +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<double, int> C; + typedef std::pair<C::iterator, bool> R; + typedef C::value_type P; + C c; + R r = c.insert(P(3.5, 3)); + assert(r.second); + assert(c.size() == 1); + assert(r.first->first == 3.5); + assert(r.first->second == 3); + + r = c.insert(P(3.5, 4)); + assert(!r.second); + assert(c.size() == 1); + assert(r.first->first == 3.5); + assert(r.first->second == 3); + + r = c.insert(P(4.5, 4)); + assert(r.second); + assert(c.size() == 2); + assert(r.first->first == 4.5); + assert(r.first->second == 4); + + r = c.insert(P(5.5, 4)); + assert(r.second); + assert(c.size() == 3); + assert(r.first->first == 5.5); + assert(r.first->second == 4); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<double, int, std::hash<double>, std::equal_to<double>, + min_allocator<std::pair<const double, int>>> C; + typedef std::pair<C::iterator, bool> R; + typedef C::value_type P; + C c; + R r = c.insert(P(3.5, 3)); + assert(r.second); + assert(c.size() == 1); + assert(r.first->first == 3.5); + assert(r.first->second == 3); + + r = c.insert(P(3.5, 4)); + assert(!r.second); + assert(c.size() == 1); + assert(r.first->first == 3.5); + assert(r.first->second == 3); + + r = c.insert(P(4.5, 4)); + assert(r.second); + assert(c.size() == 2); + assert(r.first->first == 4.5); + assert(r.first->second == 4); + + r = c.insert(P(5.5, 4)); + assert(r.second); + assert(c.size() == 3); + assert(r.first->first == 5.5); + assert(r.first->second == 4); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/unorder.map.modifiers/insert_hint_const_lvalue.pass.cpp b/test/std/containers/unord/unord.map/unorder.map.modifiers/insert_hint_const_lvalue.pass.cpp new file mode 100644 index 0000000000000..981b8fb18a0a2 --- /dev/null +++ b/test/std/containers/unord/unord.map/unorder.map.modifiers/insert_hint_const_lvalue.pass.cpp @@ -0,0 +1,97 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// iterator insert(const_iterator p, const value_type& x); + +#if _LIBCPP_DEBUG >= 1 +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) +#endif + +#include <unordered_map> +#include <cassert> + +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<double, int> C; + typedef C::iterator R; + typedef C::value_type P; + C c; + C::const_iterator e = c.end(); + R r = c.insert(e, P(3.5, 3)); + assert(c.size() == 1); + assert(r->first == 3.5); + assert(r->second == 3); + + r = c.insert(c.end(), P(3.5, 4)); + assert(c.size() == 1); + assert(r->first == 3.5); + assert(r->second == 3); + + r = c.insert(c.end(), P(4.5, 4)); + assert(c.size() == 2); + assert(r->first == 4.5); + assert(r->second == 4); + + r = c.insert(c.end(), P(5.5, 4)); + assert(c.size() == 3); + assert(r->first == 5.5); + assert(r->second == 4); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<double, int, std::hash<double>, std::equal_to<double>, + min_allocator<std::pair<const double, int>>> C; + typedef C::iterator R; + typedef C::value_type P; + C c; + C::const_iterator e = c.end(); + R r = c.insert(e, P(3.5, 3)); + assert(c.size() == 1); + assert(r->first == 3.5); + assert(r->second == 3); + + r = c.insert(c.end(), P(3.5, 4)); + assert(c.size() == 1); + assert(r->first == 3.5); + assert(r->second == 3); + + r = c.insert(c.end(), P(4.5, 4)); + assert(c.size() == 2); + assert(r->first == 4.5); + assert(r->second == 4); + + r = c.insert(c.end(), P(5.5, 4)); + assert(c.size() == 3); + assert(r->first == 5.5); + assert(r->second == 4); + } +#endif +#if _LIBCPP_DEBUG >= 1 + { + typedef std::unordered_map<double, int> C; + typedef C::iterator R; + typedef C::value_type P; + C c; + C c2; + C::const_iterator e = c2.end(); + P v(3.5, 3); + R r = c.insert(e, v); + assert(false); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/unorder.map.modifiers/insert_hint_rvalue.pass.cpp b/test/std/containers/unord/unord.map/unorder.map.modifiers/insert_hint_rvalue.pass.cpp new file mode 100644 index 0000000000000..1618c1019e1c1 --- /dev/null +++ b/test/std/containers/unord/unord.map/unorder.map.modifiers/insert_hint_rvalue.pass.cpp @@ -0,0 +1,156 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// template <class P, +// class = typename enable_if<is_convertible<P, value_type>::value>::type> +// iterator insert(const_iterator p, P&& x); + +#if _LIBCPP_DEBUG >= 1 +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) +#endif + +#include <unordered_map> +#include <cassert> + +#include "MoveOnly.h" +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<double, int> C; + typedef C::iterator R; + typedef std::pair<double, short> P; + C c; + C::const_iterator e = c.end(); + R r = c.insert(e, P(3.5, 3)); + assert(c.size() == 1); + assert(r->first == 3.5); + assert(r->second == 3); + + r = c.insert(c.end(), P(3.5, 4)); + assert(c.size() == 1); + assert(r->first == 3.5); + assert(r->second == 3); + + r = c.insert(c.end(), P(4.5, 4)); + assert(c.size() == 2); + assert(r->first == 4.5); + assert(r->second == 4); + + r = c.insert(c.end(), P(5.5, 4)); + assert(c.size() == 3); + assert(r->first == 5.5); + assert(r->second == 4); + } +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + { + typedef std::unordered_map<MoveOnly, MoveOnly> C; + typedef C::iterator R; + typedef std::pair<MoveOnly, MoveOnly> P; + C c; + C::const_iterator e = c.end(); + R r = c.insert(e, P(3, 3)); + assert(c.size() == 1); + assert(r->first == 3); + assert(r->second == 3); + + r = c.insert(c.end(), P(3, 4)); + assert(c.size() == 1); + assert(r->first == 3); + assert(r->second == 3); + + r = c.insert(c.end(), P(4, 4)); + assert(c.size() == 2); + assert(r->first == 4); + assert(r->second == 4); + + r = c.insert(c.end(), P(5, 4)); + assert(c.size() == 3); + assert(r->first == 5); + assert(r->second == 4); + } +#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES +#if __cplusplus >= 201103L + { + typedef std::unordered_map<double, int, std::hash<double>, std::equal_to<double>, + min_allocator<std::pair<const double, int>>> C; + typedef C::iterator R; + typedef std::pair<double, short> P; + C c; + C::const_iterator e = c.end(); + R r = c.insert(e, P(3.5, 3)); + assert(c.size() == 1); + assert(r->first == 3.5); + assert(r->second == 3); + + r = c.insert(c.end(), P(3.5, 4)); + assert(c.size() == 1); + assert(r->first == 3.5); + assert(r->second == 3); + + r = c.insert(c.end(), P(4.5, 4)); + assert(c.size() == 2); + assert(r->first == 4.5); + assert(r->second == 4); + + r = c.insert(c.end(), P(5.5, 4)); + assert(c.size() == 3); + assert(r->first == 5.5); + assert(r->second == 4); + } +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + { + typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, std::equal_to<MoveOnly>, + min_allocator<std::pair<const MoveOnly, MoveOnly>>> C; + typedef C::iterator R; + typedef std::pair<MoveOnly, MoveOnly> P; + C c; + C::const_iterator e = c.end(); + R r = c.insert(e, P(3, 3)); + assert(c.size() == 1); + assert(r->first == 3); + assert(r->second == 3); + + r = c.insert(c.end(), P(3, 4)); + assert(c.size() == 1); + assert(r->first == 3); + assert(r->second == 3); + + r = c.insert(c.end(), P(4, 4)); + assert(c.size() == 2); + assert(r->first == 4); + assert(r->second == 4); + + r = c.insert(c.end(), P(5, 4)); + assert(c.size() == 3); + assert(r->first == 5); + assert(r->second == 4); + } +#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES +#if _LIBCPP_DEBUG >= 1 + { + typedef std::unordered_map<double, int> C; + typedef C::iterator R; + typedef C::value_type P; + C c; + C c2; + C::const_iterator e = c2.end(); + R r = c.insert(e, P(3.5, 3)); + assert(false); + } +#endif +#endif +} diff --git a/test/std/containers/unord/unord.map/unorder.map.modifiers/insert_init.pass.cpp b/test/std/containers/unord/unord.map/unorder.map.modifiers/insert_init.pass.cpp new file mode 100644 index 0000000000000..81e8a468d83fb --- /dev/null +++ b/test/std/containers/unord/unord.map/unorder.map.modifiers/insert_init.pass.cpp @@ -0,0 +1,72 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// void insert(initializer_list<value_type> il); + +#include <unordered_map> +#include <string> +#include <cassert> + +#include "test_iterators.h" +#include "min_allocator.h" + +int main() +{ +#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS + { + typedef std::unordered_map<int, std::string> C; + typedef std::pair<int, std::string> P; + C c; + c.insert( + { + P(1, "one"), + P(2, "two"), + P(3, "three"), + P(4, "four"), + P(1, "four"), + P(2, "four"), + } + ); + assert(c.size() == 4); + assert(c.at(1) == "one"); + assert(c.at(2) == "two"); + assert(c.at(3) == "three"); + assert(c.at(4) == "four"); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> C; + typedef std::pair<int, std::string> P; + C c; + c.insert( + { + P(1, "one"), + P(2, "two"), + P(3, "three"), + P(4, "four"), + P(1, "four"), + P(2, "four"), + } + ); + assert(c.size() == 4); + assert(c.at(1) == "one"); + assert(c.at(2) == "two"); + assert(c.at(3) == "three"); + assert(c.at(4) == "four"); + } +#endif +#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS +} diff --git a/test/std/containers/unord/unord.map/unorder.map.modifiers/insert_or_assign.pass.cpp b/test/std/containers/unord/unord.map/unorder.map.modifiers/insert_or_assign.pass.cpp new file mode 100644 index 0000000000000..89929c856ec9b --- /dev/null +++ b/test/std/containers/unord/unord.map/unorder.map.modifiers/insert_or_assign.pass.cpp @@ -0,0 +1,198 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// UNSUPPORTED: c++03, c++11, c++14 + +// <unordered_map> + +// class unordered_map + +// template <class M> +// pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj); // C++17 +// template <class M> +// pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj); // C++17 +// template <class M> +// iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj); // C++17 +// template <class M> +// iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj); // C++17 + +#include <__config> +#include <unordered_map> +#include <cassert> +#include <tuple> + +#include <iostream> + +class Moveable +{ + Moveable(const Moveable&); + Moveable& operator=(const Moveable&); + + int int_; + double double_; +public: + Moveable() : int_(0), double_(0) {} + Moveable(int i, double d) : int_(i), double_(d) {} + Moveable(Moveable&& x) + : int_(x.int_), double_(x.double_) + {x.int_ = -1; x.double_ = -1;} + Moveable& operator=(Moveable&& x) + {int_ = x.int_; x.int_ = -1; + double_ = x.double_; x.double_ = -1; + return *this; + } + + bool operator==(const Moveable& x) const + {return int_ == x.int_ && double_ == x.double_;} + bool operator<(const Moveable& x) const + {return int_ < x.int_ || (int_ == x.int_ && double_ < x.double_);} + size_t hash () const { return std::hash<int>()(int_) + std::hash<double>()(double_); } + + int get() const {return int_;} + bool moved() const {return int_ == -1;} +}; + +namespace std { + template <> struct hash<Moveable> { + size_t operator () (const Moveable &m) const { return m.hash(); } + }; +} + +int main() +{ +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES +#ifndef _LIBCPP_HAS_NO_VARIADICS + + { // pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj); + typedef std::unordered_map<int, Moveable> M; + typedef std::pair<M::iterator, bool> R; + M m; + R r; + for (int i = 0; i < 20; i += 2) + m.emplace ( i, Moveable(i, (double) i)); + assert(m.size() == 10); + + for (int i=0; i < 20; i += 2) + { + Moveable mv(i+1, i+1); + r = m.insert_or_assign(i, std::move(mv)); + assert(m.size() == 10); + assert(!r.second); // was not inserted + assert(mv.moved()); // was moved from + assert(r.first->first == i); // key + assert(r.first->second.get() == i+1); // value + } + + Moveable mv1(5, 5.0); + r = m.insert_or_assign(-1, std::move(mv1)); + assert(m.size() == 11); + assert(r.second); // was inserted + assert(mv1.moved()); // was moved from + assert(r.first->first == -1); // key + assert(r.first->second.get() == 5); // value + + Moveable mv2(9, 9.0); + r = m.insert_or_assign(3, std::move(mv2)); + assert(m.size() == 12); + assert(r.second); // was inserted + assert(mv2.moved()); // was moved from + assert(r.first->first == 3); // key + assert(r.first->second.get() == 9); // value + + Moveable mv3(-1, 5.0); + r = m.insert_or_assign(117, std::move(mv3)); + assert(m.size() == 13); + assert(r.second); // was inserted + assert(mv3.moved()); // was moved from + assert(r.first->first == 117); // key + assert(r.first->second.get() == -1); // value + } + { // pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj); + typedef std::unordered_map<Moveable, Moveable> M; + typedef std::pair<M::iterator, bool> R; + M m; + R r; + for (int i = 0; i < 20; i += 2) + m.emplace ( Moveable(i, (double) i), Moveable(i+1, (double) i+1)); + assert(m.size() == 10); + + Moveable mvkey1(2, 2.0); + Moveable mv1(4, 4.0); + r = m.insert_or_assign(std::move(mvkey1), std::move(mv1)); + assert(m.size() == 10); + assert(!r.second); // was not inserted + assert(!mvkey1.moved()); // was not moved from + assert(mv1.moved()); // was moved from + assert(r.first->first == mvkey1); // key + assert(r.first->second.get() == 4); // value + + Moveable mvkey2(3, 3.0); + Moveable mv2(5, 5.0); + r = m.try_emplace(std::move(mvkey2), std::move(mv2)); + assert(m.size() == 11); + assert(r.second); // was inserted + assert(mv2.moved()); // was moved from + assert(mvkey2.moved()); // was moved from + assert(r.first->first.get() == 3); // key + assert(r.first->second.get() == 5); // value + } + { // iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj); + typedef std::unordered_map<int, Moveable> M; + M m; + M::iterator r; + for (int i = 0; i < 20; i += 2) + m.emplace ( i, Moveable(i, (double) i)); + assert(m.size() == 10); + M::const_iterator it = m.find(2); + + Moveable mv1(3, 3.0); + r = m.insert_or_assign(it, 2, std::move(mv1)); + assert(m.size() == 10); + assert(mv1.moved()); // was moved from + assert(r->first == 2); // key + assert(r->second.get() == 3); // value + + Moveable mv2(5, 5.0); + r = m.insert_or_assign(it, 3, std::move(mv2)); + assert(m.size() == 11); + assert(mv2.moved()); // was moved from + assert(r->first == 3); // key + assert(r->second.get() == 5); // value + } + { // iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj); + typedef std::unordered_map<Moveable, Moveable> M; + M m; + M::iterator r; + for (int i = 0; i < 20; i += 2) + m.emplace ( Moveable(i, (double) i), Moveable(i+1, (double) i+1)); + assert(m.size() == 10); + M::const_iterator it = std::next(m.cbegin()); + + Moveable mvkey1(2, 2.0); + Moveable mv1(4, 4.0); + r = m.insert_or_assign(it, std::move(mvkey1), std::move(mv1)); + assert(m.size() == 10); + assert(mv1.moved()); // was moved from + assert(!mvkey1.moved()); // was not moved from + assert(r->first == mvkey1); // key + assert(r->second.get() == 4); // value + + Moveable mvkey2(3, 3.0); + Moveable mv2(5, 5.0); + r = m.insert_or_assign(it, std::move(mvkey2), std::move(mv2)); + assert(m.size() == 11); + assert(mv2.moved()); // was moved from + assert(mvkey2.moved()); // was moved from + assert(r->first.get() == 3); // key + assert(r->second.get() == 5); // value + } + +#endif // _LIBCPP_HAS_NO_VARIADICS +#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES +}
\ No newline at end of file diff --git a/test/std/containers/unord/unord.map/unorder.map.modifiers/insert_range.pass.cpp b/test/std/containers/unord/unord.map/unorder.map.modifiers/insert_range.pass.cpp new file mode 100644 index 0000000000000..fc44e7828ffa1 --- /dev/null +++ b/test/std/containers/unord/unord.map/unorder.map.modifiers/insert_range.pass.cpp @@ -0,0 +1,71 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// template <class InputIterator> +// void insert(InputIterator first, InputIterator last); + +#include <unordered_map> +#include <string> +#include <cassert> + +#include "test_iterators.h" +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<int, std::string> 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; + c.insert(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0]))); + assert(c.size() == 4); + assert(c.at(1) == "one"); + assert(c.at(2) == "two"); + assert(c.at(3) == "three"); + assert(c.at(4) == "four"); + } +#if __cplusplus >= 201103L + { + typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, + min_allocator<std::pair<const int, std::string>>> 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; + c.insert(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0]))); + assert(c.size() == 4); + assert(c.at(1) == "one"); + assert(c.at(2) == "two"); + assert(c.at(3) == "three"); + assert(c.at(4) == "four"); + } +#endif +} diff --git a/test/std/containers/unord/unord.map/unorder.map.modifiers/insert_rvalue.pass.cpp b/test/std/containers/unord/unord.map/unorder.map.modifiers/insert_rvalue.pass.cpp new file mode 100644 index 0000000000000..f53dc6c7e97a8 --- /dev/null +++ b/test/std/containers/unord/unord.map/unorder.map.modifiers/insert_rvalue.pass.cpp @@ -0,0 +1,152 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, +// class Alloc = allocator<pair<const Key, T>>> +// class unordered_map + +// template <class P, +// class = typename enable_if<is_convertible<P, value_type>::value>::type> +// pair<iterator, bool> insert(P&& x); + +#include <unordered_map> +#include <cassert> + +#include "MoveOnly.h" +#include "min_allocator.h" + +int main() +{ + { + typedef std::unordered_map<double, int> C; + typedef std::pair<C::iterator, bool> R; + typedef std::pair<double, short> P; + C c; + R r = c.insert(P(3.5, 3)); + assert(r.second); + assert(c.size() == 1); + assert(r.first->first == 3.5); + assert(r.first->second == 3); + + r = c.insert(P(3.5, 4)); + assert(!r.second); + assert(c.size() == 1); + assert(r.first->first == 3.5); + assert(r.first->second == 3); + + r = c.insert(P(4.5, 4)); + assert(r.second); + assert(c.size() == 2); + assert(r.first->first == 4.5); + assert(r.first->second == 4); + + r = c.insert(P(5.5, 4)); + assert(r.second); + assert(c.size() == 3); + assert(r.first->first == 5.5); + assert(r.first->second == 4); + } +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + { + typedef std::unordered_map<MoveOnly, MoveOnly> C; + typedef std::pair<C::iterator, bool> R; + typedef std::pair<MoveOnly, MoveOnly> P; + C c; + R r = c.insert(P(3, 3)); + assert(r.second); + assert(c.size() == 1); + assert(r.first->first == 3); + assert(r.first->second == 3); + + r = c.insert(P(3, 4)); + assert(!r.second); + assert(c.size() == 1); + assert(r.first->first == 3); + assert(r.first->second == 3); + + r = c.insert(P(4, 4)); + assert(r.second); + assert(c.size() == 2); + assert(r.first->first == 4); + assert(r.first->second == 4); + + r = c.insert(P(5, 4)); + assert(r.second); + assert(c.size() == 3); + assert(r.first->first == 5); + assert(r.first->second == 4); + } +#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES +#if __cplusplus >= 201103L + { + typedef std::unordered_map<double, int, std::hash<double>, std::equal_to<double>, + min_allocator<std::pair<const double, int>>> C; + typedef std::pair<C::iterator, bool> R; + typedef std::pair<double, short> P; + C c; + R r = c.insert(P(3.5, 3)); + assert(r.second); + assert(c.size() == 1); + assert(r.first->first == 3.5); + assert(r.first->second == 3); + + r = c.insert(P(3.5, 4)); + assert(!r.second); + assert(c.size() == 1); + assert(r.first->first == 3.5); + assert(r.first->second == 3); + + r = c.insert(P(4.5, 4)); + assert(r.second); + assert(c.size() == 2); + assert(r.first->first == 4.5); + assert(r.first->second == 4); + + r = c.insert(P(5.5, 4)); + assert(r.second); + assert(c.size() == 3); + assert(r.first->first == 5.5); + assert(r.first->second == 4); + } +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + { + typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, std::equal_to<MoveOnly>, + min_allocator<std::pair<const MoveOnly, MoveOnly>>> C; + typedef std::pair<C::iterator, bool> R; + typedef std::pair<MoveOnly, MoveOnly> P; + C c; + R r = c.insert(P(3, 3)); + assert(r.second); + assert(c.size() == 1); + assert(r.first->first == 3); + assert(r.first->second == 3); + + r = c.insert(P(3, 4)); + assert(!r.second); + assert(c.size() == 1); + assert(r.first->first == 3); + assert(r.first->second == 3); + + r = c.insert(P(4, 4)); + assert(r.second); + assert(c.size() == 2); + assert(r.first->first == 4); + assert(r.first->second == 4); + + r = c.insert(P(5, 4)); + assert(r.second); + assert(c.size() == 3); + assert(r.first->first == 5); + assert(r.first->second == 4); + } +#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES +#endif +} diff --git a/test/std/containers/unord/unord.map/unorder.map.modifiers/try.emplace.pass.cpp b/test/std/containers/unord/unord.map/unorder.map.modifiers/try.emplace.pass.cpp new file mode 100644 index 0000000000000..e6964ce947b5d --- /dev/null +++ b/test/std/containers/unord/unord.map/unorder.map.modifiers/try.emplace.pass.cpp @@ -0,0 +1,195 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// UNSUPPORTED: c++03, c++11, c++14 + +// <unordered_map> + +// class unordered_map + +// template <class... Args> +// pair<iterator, bool> try_emplace(const key_type& k, Args&&... args); // C++17 +// template <class... Args> +// pair<iterator, bool> try_emplace(key_type&& k, Args&&... args); // C++17 +// template <class... Args> +// iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args); // C++17 +// template <class... Args> +// iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args); // C++17 + +#include <__config> +#include <unordered_map> +#include <cassert> +#include <tuple> + +class Moveable +{ + Moveable(const Moveable&); + Moveable& operator=(const Moveable&); + + int int_; + double double_; +public: + Moveable() : int_(0), double_(0) {} + Moveable(int i, double d) : int_(i), double_(d) {} + Moveable(Moveable&& x) + : int_(x.int_), double_(x.double_) + {x.int_ = -1; x.double_ = -1;} + Moveable& operator=(Moveable&& x) + {int_ = x.int_; x.int_ = -1; + double_ = x.double_; x.double_ = -1; + return *this; + } + + bool operator==(const Moveable& x) const + {return int_ == x.int_ && double_ == x.double_;} + bool operator<(const Moveable& x) const + {return int_ < x.int_ || (int_ == x.int_ && double_ < x.double_);} + size_t hash () const { return std::hash<int>()(int_) + std::hash<double>()(double_); } + + int get() const {return int_;} + bool moved() const {return int_ == -1;} +}; + +namespace std { + template <> struct hash<Moveable> { + size_t operator () (const Moveable &m) const { return m.hash(); } + }; +} + +int main() +{ +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES +#ifndef _LIBCPP_HAS_NO_VARIADICS + + { // pair<iterator, bool> try_emplace(const key_type& k, Args&&... args); + typedef std::unordered_map<int, Moveable> M; + typedef std::pair<M::iterator, bool> R; + M m; + R r; + for (int i = 0; i < 20; i += 2) + m.emplace (i, Moveable(i, (double) i)); + assert(m.size() == 10); + + Moveable mv1(3, 3.0); + for (int i=0; i < 20; i += 2) + { + r = m.try_emplace(i, std::move(mv1)); + assert(m.size() == 10); + assert(!r.second); // was not inserted + assert(!mv1.moved()); // was not moved from + assert(r.first->first == i); // key + } + + r = m.try_emplace(-1, std::move(mv1)); + assert(m.size() == 11); + assert(r.second); // was inserted + assert(mv1.moved()); // was moved from + assert(r.first->first == -1); // key + assert(r.first->second.get() == 3); // value + + Moveable mv2(5, 3.0); + r = m.try_emplace(5, std::move(mv2)); + assert(m.size() == 12); + assert(r.second); // was inserted + assert(mv2.moved()); // was moved from + assert(r.first->first == 5); // key + assert(r.first->second.get() == 5); // value + + Moveable mv3(-1, 3.0); + r = m.try_emplace(117, std::move(mv2)); + assert(m.size() == 13); + assert(r.second); // was inserted + assert(mv2.moved()); // was moved from + assert(r.first->first == 117); // key + assert(r.first->second.get() == -1); // value + } + + { // pair<iterator, bool> try_emplace(key_type&& k, Args&&... args); + typedef std::unordered_map<Moveable, Moveable> M; + typedef std::pair<M::iterator, bool> R; + M m; + R r; + for (int i = 0; i < 20; i += 2) + m.emplace ( Moveable(i, (double) i), Moveable(i+1, (double) i+1)); + assert(m.size() == 10); + + Moveable mvkey1(2, 2.0); + Moveable mv1(4, 4.0); + r = m.try_emplace(std::move(mvkey1), std::move(mv1)); + assert(m.size() == 10); + assert(!r.second); // was not inserted + assert(!mv1.moved()); // was not moved from + assert(!mvkey1.moved()); // was not moved from + assert(r.first->first == mvkey1); // key + + Moveable mvkey2(3, 3.0); + r = m.try_emplace(std::move(mvkey2), std::move(mv1)); + assert(m.size() == 11); + assert(r.second); // was inserted + assert(mv1.moved()); // was moved from + assert(mvkey2.moved()); // was moved from + assert(r.first->first.get() == 3); // key + assert(r.first->second.get() == 4); // value + } + + { // iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args); + typedef std::unordered_map<int, Moveable> M; + M m; + M::iterator r; + for (int i = 0; i < 20; i += 2) + m.try_emplace ( i, Moveable(i, (double) i)); + assert(m.size() == 10); + M::const_iterator it = m.find(2); + + Moveable mv1(3, 3.0); + for (int i=0; i < 20; i += 2) + { + r = m.try_emplace(it, i, std::move(mv1)); + assert(m.size() == 10); + assert(!mv1.moved()); // was not moved from + assert(r->first == i); // key + assert(r->second.get() == i); // value + } + + r = m.try_emplace(it, 3, std::move(mv1)); + assert(m.size() == 11); + assert(mv1.moved()); // was moved from + assert(r->first == 3); // key + assert(r->second.get() == 3); // value + } + + { // iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args); + typedef std::unordered_map<Moveable, Moveable> M; + M m; + M::iterator r; + for ( int i = 0; i < 20; i += 2 ) + m.emplace ( Moveable(i, (double) i), Moveable(i+1, (double) i+1)); + assert(m.size() == 10); + M::const_iterator it = std::next(m.cbegin()); + + Moveable mvkey1(2, 2.0); + Moveable mv1(4, 4.0); + r = m.try_emplace(it, std::move(mvkey1), std::move(mv1)); + assert(m.size() == 10); + assert(!mv1.moved()); // was not moved from + assert(!mvkey1.moved()); // was not moved from + assert(r->first == mvkey1); // key + + Moveable mvkey2(3, 3.0); + r = m.try_emplace(it, std::move(mvkey2), std::move(mv1)); + assert(m.size() == 11); + assert(mv1.moved()); // was moved from + assert(mvkey2.moved()); // was moved from + assert(r->first.get() == 3); // key + assert(r->second.get() == 4); // value + } + +#endif // _LIBCPP_HAS_NO_VARIADICS +#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES +} diff --git a/test/std/containers/unord/unord.map/version.pass.cpp b/test/std/containers/unord/unord.map/version.pass.cpp new file mode 100644 index 0000000000000..fc47a326c571e --- /dev/null +++ b/test/std/containers/unord/unord.map/version.pass.cpp @@ -0,0 +1,20 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <unordered_map> + +#include <unordered_map> + +#ifndef _LIBCPP_VERSION +#error _LIBCPP_VERSION not defined +#endif + +int main() +{ +} |